text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# У меня зазвонил телефон. Кто говорит?.. Поможет «слон»
Автоматическое определение клиента и его региона по входящему телефонному звонку стало неотъемлемой частью любой развитой HelpDesk или CRM-системы. Только **надо уметь делать это быстро** — тогда появляется масса возможностей.
Например, можно менеджеру сразу показать из какого города идет звонок, подтянуть актуальный прайс и условия доставки, вывести карточку звонящего клиента, последние сделки с ним, конкретное контактное лицо,… — да много чего полезного, как это умеет наш [СБИС CRM](https://sbis.ru/crm)!
[](https://sbis.ru/crm)
А как этот функционал реализовать самостоятельно? Оказывается, не так уж сложно. Собрать и опробовать работающую модель можно, буквально, «на коленке» — нужна только связка из Node.js и PostgreSQL.
Определяем регион по номеру
---------------------------
Давайте предположим, что АТС присылает нам уже нормализованный и отформатированный до 10 цифр (будем рассматривать только звонки внутри России) входящий телефонный номер. Как наиболее эффективно понять, откуда пришел звонок?
#### Собираем телефонные коды
Сначала нам понадобится база [телефонных кодов России](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BB%D0%B5%D1%84%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BB%D0%B0%D0%BD_%D0%BD%D1%83%D0%BC%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8_%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D0%B8) в привязке к регионам. Для этого можно воспользоваться официальным источником — актуальной [выпиской из плана нумерации](https://rossvyaz.gov.ru/deyatelnost/resurs-numeracii/vypiska-iz-reestra-sistemy-i-plana-numeracii) на сайте Федерального агентства связи.
Но найти — мало, надо эти данные скачать и извлечь. В этом нам поможет небольшой скрипт для Node.js, использующий библиотеку [request](https://github.com/request/request):
```
const async = require('async')
, request = require('request');
const fs = require('fs');
let queue = [
'ABC-3xx'
, 'ABC-4xx'
, 'ABC-8xx'
, 'DEF-9xx'
]
.map(key => (
{
base : 'https://rossvyaz.gov.ru'
, path : `/data/${key}.csv`
}
));
let ranges = [];
async.doWhilst(
cb => {
// берем из очереди и загружаем очередную страницу
let task = queue.shift();
request(
{
url : task.base + task.path
, pool : false
}
, (err, res, body) => {
// примитивный разбор CSV
body.split('\n').forEach(line => {
let tds = line.split(';');
let place = tds[5].split('|');
ranges.push([
tds[0]
, tds[1]
, tds[2]
, tds[4]
, place[place.length - 1]
, place[place.length - 2] && place[place.length - 2].startsWith('р-н') ? place[place.length - 2] : ''
, place.length > 1
? place[0].startsWith('р-н')
? ''
: place[0]
: ''
]);
});
return cb(err);
}
);
}
// итерируем, пока очередь заданий непуста
, cb => {
return cb(null, queue.length);
}
// когда все распарсили - подчищаем данные и формируем файл для загрузки в БД
, err => {
// чистим коды и диапазоны
ranges.forEach(row => {
// убираем пересечение цифр кода и диапазона
let ln = row[0].length + row[1].length - 10;
if (ln > 0) {
let sfx = row[0].slice(-ln);
if (row[1].startsWith(sfx) && row[2].startsWith(sfx)) {
row[1] = row[1].slice(ln);
row[2] = row[2].slice(ln);
}
}
// пересобираем общий префикс
let pfx;
for (let i = 1; i < row[1].length; i++) {
if (row[2].startsWith(row[1].slice(0, i))) {
pfx = row[1].slice(0, i);
}
else {
break;
}
}
if (pfx) {
row[0] = row[0] + pfx;
row[1] = row[1].slice(pfx.length);
row[2] = row[2].slice(pfx.length);
}
});
let sql = `
SET client_encoding = 'UTF-8';
CREATE TABLE phonecodes(
code
varchar
, numb
varchar
, nume
varchar
, oper
varchar
, region
varchar
, district
varchar
, city
varchar
);
COPY phonecodes FROM STDIN;
`;
// собираем COPY-формат
let copy = ranges.map(row => row.join('\t')).join('\n') + '\n\\.\n';
fs.writeFileSync('phonecodes.sql', sql + copy);
}
);
```
Теперь загрузим его в нашу тестовую базу, и можно работать:
```
psql -f phonecodes.sql -U postgres tst
```
Если все сработало как надо, в нашу таблицу будет загружено почти 378 тысяч диапазонов:
```
SET
CREATE TABLE
COPY 377937
```
> Замечу, что в нашем примере и код, и граничные номера диапазона представлены строками. Да, их можно превратить в `integer/bigint`, но мы пока не будем этим заниматься. Тем более, что входящий номер телефона не всегда состоит только из цифр — например, некоторые таксофоны могут сообщать свой номер с «цифрой A».
#### «Ищут пожарные, ищет милиция...»
Сначала попробуем наивный запрос:
```
WITH src AS (
SELECT '4852262000' num -- входящий номер
)
SELECT
*
FROM
src
, phonecodes
WHERE
num LIKE (code || '%') AND -- проверяем совпадение кода
num BETWEEN (code || numb) AND (code || nume) -- проверяем вхождение в диапазон
LIMIT 1;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/63da4c0b700ce00b82690184436c2e63:0:2020-08-17)
Вычитали почти 70 тысяч строк (и это еще повезло, что не все 380!), почти 10MB данных перелопатили… не слишком эффективно, но результат достигнут:
```
num | code | numb | nume | oper | region | district | city
-----------------------------------------------------------------------------------
4852262000 | 485226 | 0000 | 9999 | МТС | Ярославская обл. | | Ярославль
```
Но давайте как-то избавимся от `Seq Scan`! Для этого нам всего-то нужен индекс, который поможет искать по `LIKE`, так ведь?..
Увы, нет. Если нам надо искать `**column LIKE (val || '%')**`, то нам помогут префиксные индексы с [varchar\_pattern\_ops](https://postgrespro.ru/docs/postgresql/12/indexes-opclass), но у нас-то все наоборот — `**val LIKE (column || '%')**`. И мы получаем ситуацию близкую к той, что я описывал в статье [«Классифицируем ошибки из PostgreSQL-логов»](https://habr.com/ru/post/505810/).
#### Используем знания о прикладной области
Близкую, но, к счастью, все-таки существенно проще — данные у нас фиксированы и их относительно немного. Причем по кодам записи распределены достаточно разреженно:
```
SELECT -- сколько кодов с таким кол-вом диапазонов
ranges
, count(*)
FROM
(
SELECT -- сколько диапазонов по каждому коду
code
, count(*) ranges
FROM
phonecodes
GROUP BY
1
) T
GROUP BY
1
ORDER BY
1 DESC;
```
Только лишь около сотни кодов имеют по 10 диапазонов, а почти четверть — вообще ровно один:
```
ranges | count
--------------
10 | 121
9 | 577
8 | 1705
7 | 3556
6 | 6667
5 | 10496
4 | 12491
3 | 20283
2 | 22627
1 | 84453
```
Поэтому давайте проиндексируем пока только код. А раз все диапазоны одного кода нам понадобятся все вместе — упорядочим нашу таблицу с помощью `CLUSTER`, чтобы записи лежали физически рядом:
```
CREATE INDEX ON phonecodes(code);
CLUSTER phonecodes USING phonecodes_code_idx;
```
А теперь вспомним, что телефонный номер у нас состоит ровно (всего!) из 10 цифр, среди которых нам надо вычленить префиксный код. То есть наша задача спокойно решается простым перебором не более чем 10 вариантов:
```
WITH RECURSIVE src AS (
SELECT '4852262000' num
)
, T AS (
SELECT
num pfx -- в качестве исходного "префикса" задаем весь номер
, NULL::phonecodes pc
FROM
src
UNION ALL
SELECT
substr(pfx, 1, length(pfx) - 1) -- "отщипываем" последнюю цифру
, (
SELECT
X
FROM
phonecodes X
WHERE
code = T.pfx AND -- проверяем полное совпадение префикса
(TABLE src) BETWEEN (code || numb) AND (code || nume) -- проверяем вхождение в диапазон
LIMIT 1
) pc
FROM
T
WHERE
pc IS NOT DISTINCT FROM NULL AND -- ищем, пока ничего не нашли
length(pfx) > 2 -- ... и префикс еще может оказаться кодом
)
SELECT
(pc).* -- "разворачиваем" найденную запись диапазона в поля
FROM
T
WHERE
pc IS DISTINCT FROM NULL;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/0e627fc84ee276880765ec01ee8eb734:0:2020-08-17)
Нам потребовалось всего 5 обращений к индексу, чтобы найти искомый код. Выигрыш кажется микроскопическим в абсолютных цифрах, но мы получили **снижение нагрузки в 150 раз** относительно наивного варианта! Если вашей системе приходится обрабатывать десятки и сотни тысяч таких запросов в час — экономия становится весьма солидной!
> А можно делать еще меньше итераций по индексу — если все коды заранее привести к классическому виду «от 3 до 5 цифр». Правда, тогда возрастет количество диапазонов в каждом коде, и их фильтрация может добавить проблем.
#### int8range + GiST
Как правильно заметил в комментариях [miksir](https://habr.com/ru/users/miksir/), раз у нас все пары «код + диапазон» и входящий номер имеют строго одинаковую размерность в 10 цифр, то задачу можно свести к интервальному поиску среди числовых значений.
Для этого создадим индекс, который будет рассматривать наши записи как [`диапазонный тип int8range`](https://postgrespro.ru/docs/postgresql/12/rangetypes):
```
CREATE INDEX ON phonecodes USING gist(
int8range(
(code || numb)::bigint -- левая граница отрезка
, (code || nume)::bigint -- правая граница отрезка
, '[]' -- включая крайние точки
)
);
```
После этого мы сможем использовать его в запросе:
```
WITH src AS (
SELECT '4852262000'::bigint num
)
SELECT
*
FROM
phonecodes
WHERE
int8range((code || numb)::bigint, (code || nume)::bigint, '[]') @> ( -- вхождение интервала
SELECT
int8range(num, num, '[]') -- "интервал" из единственной точки
FROM
src
)
LIMIT 1;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/0a8a5d28f91e65bb1f2035f5203ce811:0:2020-08-18)
#### Непересекающиеся интервалы + btree
Сначала убедимся, что наши диапазоны номеров действительно не пересекаются:
```
SELECT
*
FROM
phonecodes X
, phonecodes Y
WHERE
int8range((X.code || X.numb)::bigint, (X.code || X.nume)::bigint, '[]') &&
int8range((Y.code || Y.numb)::bigint, (Y.code || Y.nume)::bigint, '[]') AND
X.ctid <> Y.ctid;
```
Если получили «ничего» — все хорошо, и можно применить следующую оптимизацию: *номер может входить только в тот из диапазонов, к концу (или началу) которого находится ближе всего*.
Для поиска ближайшего «начала» нам достаточно обычного btree-индекса:
```
CREATE INDEX ON phonecodes((code || numb));
```
```
WITH src AS (
SELECT '4852262000' num
)
SELECT
*
FROM
src
, LATERAL (
SELECT
*
FROM
( -- находим тот единственный ближайший диапазон
SELECT
*
FROM
phonecodes
WHERE
(code || numb) <= src.num
ORDER BY
(code || numb) DESC
LIMIT 1
) T
WHERE
src.num BETWEEN (code || numb) AND (code || nume) -- перепроверяем попадание
) T;
```
Несмотря на кажущуюся простоту, этот вариант дает производительность хуже предыдущего:
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/bd2adb49754dedf2bf8aa95659d80316:0:2020-08-18)
Определяем клиента по номеру
----------------------------
Теперь давайте представим, что у нас уже есть таблица с клиентами, где записан «подчищенный» номер телефона — убраны все скобки, дефисы, и т.п.
Но вот неприятность, далеко **не все и них имеют код города** — то ли менеджеры ленятся забивать, то ли АТС так настроена, что присылает не полные, а «внутригородские» номера… Как тогда найти клиента — ведь поиск по полному соответствию уже не сработает?
#### АТС дает полный номер
В этом случае воспользуемся **тем же «переборным» алгоритмом**. Только «отщипывать» цифры будем не с конца номера, а с начала.
Если номер в карточке клиента был указан полностью, мы на первой же итерации на него наткнемся. Если не полностью — когда «отрежем» какой-то из подходящих кодов.
Безусловно, нам потребуется какая-то перекрестная проверка по другим реквизитам (адрес, ИНН, ...), чтобы не получилось ситуации, что из входящего номера мы «отрезали» код Москвы, а по оставшемуся 7-значному номеру нашли клиента из Санкт-Петербурга.
#### АТС дает «городской» номер
```
пришло от АТС : 262000
указано в карточке : 4852262000
```
Тут ситуация интереснее. «Приращивать» каждый возможный код к короткому номеру и пробовать искать мы не можем — их слишком много. Взглянем на ситуацию с другой стороны — буквально:
```
reverse(262000) -> 000262
reverse(4852262000) -> 0002622584
```
Оказывается, если развернуть строки с номерами, то задача превращается в **обычный префиксный поиск**, который легко решается с помощью индекса с [varchar\_pattern\_ops](https://postgrespro.ru/docs/postgresql/12/indexes-opclass) и `LIKE`!
```
CREATE INDEX ON client(reverse(phone) varchar_pattern_ops);
```
```
SELECT
*
FROM
client
WHERE
reverse(phone) LIKE (reverse($1) || '%');
```
А дальше, опять-таки перепроверяем дополнительную информацию — из какого региона АТС нам прислала номер, к какому региону относится клиент. | https://habr.com/ru/post/514970/ | null | ru | null |
# JavaScript 2016, а можно попроще?
Последние полгода много пишут о неоправданной сложности клиентского JavaScript. Недавняя статья [How it feels to learn JavaScript in 2016](https://hackernoon.com/how-it-feels-to-learn-javascript-in-2016-d3a717dd577f#.l8ak5j3gz) и ее [перевод на хабре](https://habrahabr.ru/post/312022/) вызвали много внимания, критика во многом справедливая, но...
Усложнять просто, упрощать сложно. (Один из законов Мерфи)
В этой статье я дам практические советы, как можно просто сделать фронт-энд приложение, используя при этом современные технологии. Вначале практические детали реализации, а в конце статьи будет анализ выбранного стека.
Как пример используется приложение для работы с коллекцией фильмов. Фильмы отображаются в списке с постраничной выборкой, поиском, сортировкой, редактированием и удалением.
Использованный стек: create-react-app как сборщик для клиента, React, bootstrap, API с json-server или json-заглушки.
[](https://yegor-sytnyk.github.io/movies-list/)
Работающее демо здесь: [Movies List](https://yegor-sytnyk.github.io/movies-list/).
В уже упомянутой статье, ведется диалог между опытным фронт-энд разработчиком и бэк-энд разработчиком, который немного знает фронт-энд и хочет написать простое клиентское приложение используя современные технологии. Фронт-энд "гуру" вываливает все многообразие технологий которое можно использовать, и так озадачивает своего коллегу, что тот отказывается от своей идеи вообще или решает писать все по-старому с JQuery.
Я попытаюсь дать более практические советы о том как это сделать, более того покажу код готового приложения, чтобы можно было использовать его как пример.
GitHub репозиторий [здесь](https://github.com/yegor-sytnyk/movies-list).
Клиентская сборка с React Scripts
---------------------------------
Первая проблема в современной фронт-энд разработке — это необходимость клиентских сборок. Мы будем использовать готовую build систему, где все сразу работает "из коробки".
[Create-react-app](https://github.com/facebookincubator/create-react-app) или React Scripts — это молодой проект (первый комит в июне 2016) созданный Дэном Абрамовым, создателем Redux, который сейчас работает в facebook.
Чтобы начать
```
# установить create-react-app глобально
npm i -g create-react-app
# создать новое приложение в папке my-app
create-react-app my-app
```
React-scripts билдит клиентское приложение, без необходимости дополнительной настройки. Поддерживаются 2 режима development и production.
В режиме development используются клиентские сборки в памяти (с WebPack dev-server) сразу работает hot-reload (вы меняете код, страница перегружается), код проверяется линтером (например, если у вас есть неиспользуемая переменная, будет соответствующее предупреждение) и другое.
Для запуска в development режиме, просто:
```
#cd my-app
npm start
```
Если нужно сделать production сборку:
```
npm run build
```
Это создаст сборку приложения в папке "/build", где будет минимизированная и готовая к развертке версия.
Для импорта стилей и путей к картинкам, используется метод WebPack, просто делайте import для нужных ресурсов.
```
//импорт bootstrap стили из папки npm пакета
import '../node_modules/bootstrap/dist/css/bootstrap.css';
//импорт картинки из локальной папки приложения, в somePicture путь к картинке
import somePicture from '../media/picture.png';
```
Более подробно о работе с react-scripts читайте на [GitHub страничке](https://github.com/facebookincubator/create-react-app) проекта.
React
-----
В качестве JS фреймворка мы выбираем React. Есть другие хорошие опции (VueJS, Angular2), но в отличии от них, React имеет наиболее стабильную экосистему. Это означает стабильность API (не сильно меняется от версии к версии), поддержку в IDE, устоявшийся набор дополнительных библиотек (Redux, react-router), набор готовых компонентов (react-bootstrap, material-ui).
При этом, сам синтаксис React JSX не прост для начинающего и это, наверное, самое сложное с чем придется столкнуться в выбранном стеке.
Само приложение movies-list умышлено написано просто, чтобы было легче понятно для начинающих (например, в реальном приложении можно было бы сделать более детальное разбиение на компоненты).
Существует огромное количество всевозможных учебников по React, для выбранного стека вам нужно чтобы в учебнике использовался ES6 синтаксис (компоненты объявляются через class), и вам не нужно изучать Redux или React Router. С ними вы можете разобраться позже, если будет необходимость.
Примером такого учебника может быть [React Fundamentals on Eggheads](https://egghead.io/courses/react-fundamentals), стоит так же почитать [официальную документацию](https://facebook.github.io/react/docs/getting-started.html).
Дополнительные модули
---------------------
Модули используются как npm пакеты. В качестве CSS фреймовка используется "bootstrap". Для интеграции с React используются компоненты "reeact-bootstrap" (хорошо описаны на сайте проекта).
Пакет "toastr" используется для всплывающих сообщений об ошибке или уведомлении об успешной операции (например: фильм был сохранен). Этот пакет требует включение "jquery" и для реального проекта может иметь смысл найти аналог на React, чтобы не включать JQuery и уменьшить размер упакованного приложения.
Для выбора нескольких значений для жанра фильмов используется "react-select" — продвинутая версия компонента для выпадающего списка.
При использовании ES6 классов нужно делать связывание (bind) для функций. Пакет "react-autobind" упрощает эту задачу, потенциально может повлиять на производительность (вы привязываете все методы, а не только те, где это нужно), но облегчает разработку. Подробнее о bind в React [здесь](http://blog.andrewray.me/react-es6-autobinding-and-createclass/).
```
//вместо:
constructor() {
super()
this.update = this.update.bind(this);
//... все другие методы
}
//c autobind
import autoBind from 'react-autobind';
...
constructor() {
super()
autoBind(this);
}
```
Для более удобной манипуляции css классами используется пакет "classnames".
```
import classnames from 'classnames';
let oneClass = classnames('foo', 'bar'); //значение "foo bar"
let isActive = true;
let anotherClass = classnames({
'foo': true,
'bar': false,
'active': isActive
}) // значение "foo active"
```
API
---
Если у вас нет возможности или желания использовать серверную часть для клиентского приложения, то есть несколько альтернативных возможностей:
**JSON-заглушки** — начальные данные приложения хранятся в JSON файле, который импортируется как внешний ресурс.
```
import jsonData from '../myJsonFile.json';
```
В дальнейшем все операции происходят уже с загруженными данными. Вы реализуете операции поиска, редактирования, удаления самостоятельно, работая с начальными данными из JSON.
В movie-list этот подход используется по умолчанию, логика в файле 'movieServiceStubs'.
**Использование json-server** — пакет [json-server](https://github.com/typicode/json-server) при запуске дает доступ к набору API на основе структуры JSON файла.
Например, если у вас есть db.json в котором есть массив movies, то автоматически будут доступны следующие API:
```
GET /movies
GET /movies/1
POST /movies
PUT /movies/1
PATCH /movies/1
DELETE /movies/1
```
При этом, API меняют исходный db.json файл, для GET запросов поддерживается поиск, постраничная выборка, сортировка.
Кроме этого json-server поддерживает много дополнительных опций — кастомные маршруты, авто-генерация тестовых данных, поддержка связей между разными элементами.
В movie-list есть возможность работы с json-server, нужно использовать movieService вместо movieServiceStub, кроме этого:
```
#установить json-server глобально
npm i -g json-server
##запустить json-server через npm-scripts
npm run server
```
Для AJAX запросов в React Scripts предлагается использовать fetch API. Это новый браузерный стандарт, которые более удобен, чем XMLHttpRequest. Для поддержки старых браузеров в React Scripts используется полифил.
В отличии от JQuery, axios и других клиентских библиотек, Fetch это стандарт, который можно использовать уже сейчас и который будет всерьез и надолго.
Языковые функции
----------------
Чтобы не усложнять код дополнительными библиотеками, в movie-list я использую только ES6 фичи (без lodash)
Помимо стрелочных функций ((x) => ...) стоит обратить внимание на такие, как:
» [Шаблонные строки](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Template_literals)
» [Итерация по колекции for… of ...](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Statements/for...of)
» [Клонирование объекта c Object.assign](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
»[Методы массивов map, filter, reduce](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
Благодаря новым функциям ES6, в Lodash и подобных библиотеках уже нет такой острой необходимости, хотя их использование все равно может быть полезно.
В проекте не используются ES2016+ фичи, они поддерживаются *React Scripts*, но API менее надежны и хуже поддерживаются (документация, примеры, поддержка в IDE и др.). Если вам все-таки интересно, можете попробовать использование async/await вместо Promise и static свойства в React компонентах.
Публикация
----------
Есть много сайтов на которых вы можете выложить статические ресурсы (HTML/CSS/JS). React Scripts предлагает использовать для этого GitHub pages, в документации описано как это сделать и после 5-минутной настройки вы можете опубликовать демо-версию своего приложения. При этом, необходимо использовать json-заглушки, а это значит приложение потеряет свое состояние после полной перегрузки страницы, что для демо даже лучше.
Анализ выбранного стека
=======================
В уже упомянутой статье указываются несколько проблем современного фронт-энда:
Необходимость клиентских билдов
-------------------------------
Во-первых, зачем они вообще нужны? Почему нельзя как раньше просто включать скрипт в HTML странички и просто начинать писать код.
В основном, из-за того, что некоторые браузеры очень медленно имплементируют новые стандарты (не будем показывать пальцем, но в основном это касается IE). Пока эти браузеры не уйдут в историю (а это как минимум пару лет), будет существовать необходимость в клиентских сборках, хотя бы для того, чтобы использовать новые функции языка ES6. Помимо этого, если у вас большое приложение, то вам стоит минифицировать ваш код, и если он разбит на много файлов объединять их в одну сборку с учетом связей (если модуль A использует модуль Б, то модуль Б должен быть включен перед модулем A).
Самостоятельно настраивать клиентский билд сложно. Нужно подключить webpack, babel, с десяток webpack loaders, поддерживать dev/prod сборки. На это может уйти куча времени и нервных переживаний, даже при использовании boilerplate вам будет не просто его выбрать, а потом поддерживать. К счастью, появились сборщики (пока не много) для клиентского приложения, в которых все это скрыто внутри отдельного пакета и все что вам нужно это подключить этот сборщик и писать свое приложение с учетом определенных особенностей.
Уже существуют аналоги React Scripts, для VueJS это [vbuild](https://github.com/egoist/vbuild), для Angular2 альтернативы я пока не видел, но есть билд система для Ionic2 который построен на Angular2. Эти проекты пока еще не так обкатаны, но появление подобных инструментов лишь вопрос времени.
Некоторые сомневаются, что это подходит для серьезных приложений. Это вполне возможно, но при использовании готовой системы клиентской сборки вы должны соблюдать некоторые соглашения, например, точка входа в одна и находится в src/index.js, не используются CSS препроцессоры, код проверяется определенным набором правил линтера. При этом, само приложение может быть как простым "hello world" так и сложным клиентом на много страниц. К примеру, в проекте [Contoso Express](https://github.com/yegor-sytnyk/contoso-express) react scripts используются для гораздо более сложного приложения.
В конце концов, если через несколько месяцев вам понадобится что-то чего нельзя добиться готовым сборщиком, вы можете сделать свое кастомное решение, но вам не придется заниматься этим в самом начале.
Проблема быстрого устаревания технологий
----------------------------------------
Вы учите новую технологию, тратите много времени, а она устаревает через полгода или в новой версии API кардинально меняются и приходиться разбираться заново.
Это справедливо для многих технологий, цена прогресса, но не для всех. Если не хочется столкнуться с подобной ситуацией, нужно просто правильно выбирать стек. В нашем стеке большинство технологий давно существуют, работают надежно и не будут сильно меняться в дальнейшем.
Нельзя с полной уверенностью говорить про React (хотя после перехода на ES6 синтаксис, для компонентов никаких значительных изменений в базовом синтаксисе не было). Но что касается ES6, Fetch, Promises — это то, что уже является стандартом JS и будет актуально многие годы, и уже поддерживается в большинстве браузеров.
Проблема слишком большого выбора
--------------------------------
Умение правильно подбирать инструменты важно не только в программировании. Проблема в JS, что нет основного (mainstream) подхода, для большинства случаев, как например в .NET. И выбор сильно усложняется. В этом плане экосистема React достаточно устоялась, например, если вначале для React существовало множество Flux имплементаций, то сейчас большинство приложений использует Redux, есть только одна популярная версия для клиентской маршрутизации React Router, и т.д.
При этом важно не использовать лишние инструменты, используя прогрессивный процесс разработки. Начать с необходимого минимума, добавляя новые компоненты только при реальной необходимости. Например, в уже не раз упомянутой статье, для простого одностраничного приложения, предлагались некоторые технологии, в которых совсем не было смысла:
* *ES2016+* — приятное дополнение, но особой необходимости нет.
* *TypeScript/Flow* — дает преимущества строгой типизации, но требует дополнительных усилий при настройке и использовании, для начинающих будет лишь дополнительной морокой (в React Scripts можно подключать Flow).
* *Functional programming* — для простого приложения, необходимости в этом нет вообще, а для сложного приложения без этого вполне можно обойтись.
* *Lodash/Rumda* — с использованием ES6 многие полезные функции стали доступны на уровне языка, можно начать без них.
* *Flux(Redux)* — для сложного приложения необходим способ совместного использования состояния (данных) приложения для различных компонентов, для простого приложения отказ от них облегчит начальную разработку.
* *Тестирование UI* — для простого приложения без них можно обойтись (в React Scripts есть поддержка Jest для тестирования React компонентов).
Спасибо, тем кто дочитал до конца.
Happy coding! Stay tuned. | https://habr.com/ru/post/313234/ | null | ru | null |
# Проект Lazybones — «Лентяй», который работает за вас
Я не люблю Maven.
О моей пассионарной ненависти к этой штуке можно написать не одну статью, но сегодня я хочу поговорить об одной очень хорошей фиче Мавена — об архетипах. Что это такое можно прочитать [в официальной документации](https://maven.apache.org/guides/introduction/introduction-to-archetypes.html), в каждом из туторилов по Мавену на Хабре([1](http://habrahabr.ru/post/77382/), [2](http://habrahabr.ru/post/77333/), [3](http://habrahabr.ru/post/78252/)), да и вообще, вы наверняка знаете и сами.
Так вот, архетипы — это круто, и было бы здорово, если бы 1) во многих проектах со стандартной структурой они были. 2) можно было бы их прикрутить к тем, у которых их нет.
Примерно так думал [Питер Ледбрук](http://twitter.com/pledbrook), когда смотрел на полное отсутствие архетапов в [Ratpack](http://habrahabr.ru/post/190452/). Тогда и родился [проект Lazybones](https://github.com/pledbrook/lazybones) — инструмент генерации проектов.
В этой статье я расскажу вам как 1) Пользоваться Lazybones для генерации проектов, для которых уже созданы шаблоны. 2) Создавать новые шаблоны для любых проектов.
##### Использование существующих шаблонов Lazybones
Tут все будет предельно коротко:
1. Устанавливаем Lazybones с помощью [GVM](http://gvmtool.net/) или скачиваем дистрибутив с [Bintray](https://bintray.com/pkg/show/general/pledbrook/lazybones-templates/lazybones)
2. Смотрим какие шаблоны существуют с помощью команды `lazybones list` (или изучаем [репозиторий](https://bintray.com/pledbrook/lazybones-templates))
3. Изучаем информацию о выбраном шаблоне с помощью команды `lazybones info <имя шаблона>` (или читаем readme в packag-e шаблона на Бинтрее)
4. Создаем проект командой `lazybones create <имя шаблона> <версия шаблона> <имя директории в которой создавать>`
Всё, спасибо за внимание, все свободны. Хотя нет, сейчас будем делать как раз интересное.
##### Создание своего шаблона проекта
Поскольку вы все, скорее всего, знакомы с мавеновским архетипом #361 ([maven-archetype-quickstart](https://maven.apache.org/archetype/maven-archetype-bundles/maven-archetype-quickstart/)), мы сделаем что-то похожее (воссоздав все фичи, мы опустим некоторые повторы).
Мало того, что вы сможете сравнить количество скаченного интернета для создания обоих проектов, вы еще и сможете сравнить сложность создания самого шаблона, ибо процесс создания архетайпа Мавена прекрасно описан [вот тут](http://habrahabr.ru/post/111408/).
###### Итак, поехали.
Чего мы хотим добиться:
* Создать базовый pom.xml с выбраными через интерактивную командную строку `groupId`, `artifactId` и версией
* Создать директории src/main/java, src/main/resources (тоже самое для тестов, но мы не будем, для простоты примера)
* Создать класс для примера, прописать в нем выбранный через интерактивную командную строку `package` и положить его в походящую под `package` директорию (тоже самое для теста, но мы не будем, для простоты примера)
* В классе сгенерить `main`, который будет при запуске фазы теста печатать сообщение, выбранное через интерактивную командную строку
* Собрать шаблон
* Создать проект по нашему шаблону
* Запустить `mvn test`
* Профит
1. Для сборки шаблона нам понадобится скрипт Gradle и директория с шаблонами. Поскольку нам лень, мы запустим lazybones:
`>lazybones create lazybones-project lzb-templates`
В результате у нас есть следующее:
```
│ build.gradle //скрипт сборки шалбонов
│ gradlew //файл запуска скрипта для никсов
│ gradlew.bat //файл запуска скрипта для винды
│ README.md //файл описывающий этот проект
│
├───gradle //вспомогательная директория для скрипта
│
└───templates //пустая директория для наших шаблонов
```
2. Заходим в директорию `templates`, создаем в ней под-директорию нашего шаблона, и начинаем ваять. Создаем файл версии. Он называется `VERSION` и содержит только версию, например 0.1
```
>mkdir maven-simple
>cd maven simple
>echo 0.1 > VERSION
```
3. Кроме того, нужно создать `readme.md`, который будет показан после создания проекта.
4. Создаем директории `src/main/java`, `src/main/resources`. В `java` и `resources` из них кладем по пустому файлу `.retain`
```
├───maven-simple
│ │ README.md
│ │ VERSION
│ │
│ └───src
│ └───main
│ ├───java
│ │ .retain
│ │
│ └───resources
│ .retain
```
5. Теперь займемся шаблонами. Начнем с pom.xml:
```
4.0.0
${groupId}
${artifactId}
${version}
org.codehaus.mojo
exec-maven-plugin
1.2.1
test
java
${pkg}.App
${message}
```
> ААААА!!!!!!!
Так, взяли себя в руки, смотрим. Обратите внимание на всякие `${...}`. Это то, что мы будем менять на значения, которые нам задаст пользователь во время запуска `create`. По сути, это просто маркеры [Groovy Templates](http://groovy.codehaus.org/Groovy+Templates). Если вы знакомы с Velocity, Freemarker или любым другим обработчиком шаблонов, вам всё будет знакомо. Но об этом позже.
Адовый ад в — это всего лишь запуск `main`-а класса `App`. Обратите внимание, что нам пока нам неизвестны `package` этого класса и параметр, который мы передаем в `main`.
6. Теперь смотрим на файл `App.java`:
```
package ${pkg};
public class App {
public static void main(String[] args) {
System.out.println(args[0]);
}
}
```
Тут у нас всего одна переменная — опять-же, `package`. Заодно мы видим, что main печатает аргумент. Значит, что во время запуска мавена, в фазе теста, мы ожидаем увидеть сообщение, которое пользователь выберет, опять-же, во время `create`.
Итак, теперь мы имеем все директории и шаблоны:
```
│ App.java
│ lazybones.groovy
│ pom.xml
│ README.md
│ VERSION
│
└───src
└───main
├───java
│ .retain
│
└───resources
.retain
```
7. А вот теперь начинается самое интересное. Нам осталось написать пост-процессор, который будет бежать после распаковывания директорий. Задачи: 1) Узнать всё, что нужно у пользователя, 2) перенести java файл в директорию, соответствующую package, 3) обработать шаблоны.
Поможет нам в этом, конечно, элегантный Груви скрипт:
```
import static org.apache.commons.io.FileUtils.moveFileToDirectory
Map props = [:]
//метод ask принимает 2 параметра - сообщение, и значение по умолчанию.
//он показывает сообщение и ждет ввода. Ввод (или значение по умолчанию, если ввод пустой) возвращается.
props.groupId = ask('Выберите groupId [org.example]: ', 'org.example')
props.artifactId = ask('Выберите artifactId [maven-simple]: ', 'maven-simple')
props.version = ask('Выберите версию [1.0-SNAPSHOT]: ', '1.0-SNAPSHOT')
props.pkg = ask("Выберите package для класса [$props.groupId]:", props.groupId)
props.message = ask('Чего печатать в тесте? ', 'Привет, лентяй!')
//метод processTemplates обрабатывает шаблоны, заменяя меаркеры значениями из мапы.
processTemplates 'pom.xml', props
//заменяем точки на слэши
String packageDir = props.pkg.replaceAll(/\./, '/')
//переносим исходник в нужную директорию
moveFileToDirectory(new File(targetDir, 'App.java'), new File(targetDir, "src/main/java/$packageDir"), true)
//обрабатываем шаблон
processTemplates 'src/main/java/\*\*/App.java', props
```
Надеюсь, комментарии достаточно понятно объясняют, что происходит. Единственное, наверное, что нужно добавить, это то, что методы `ask()` и `processTemplates()` и поле `targetDir` попадают в скрипт из класса `uk.co.cacoethes.lazybones.LazybonesScript`, который является [кастомным супер-классом этого скрипта](http://mrhaki.blogspot.co.il/2011/11/groovy-goodness-create-our-own-script.html).
8. Пора собирать. У Lazybones есть свой плагин для Грейдла, который уже сконфигурирован в скрипте сборки, который мы сгенерировали в пункте 1. Этот плагин определяет [task rules](http://www.gradle.org/docs/current/userguide/userguide_single.html#N10F81) для сборки, установки в локальном кэше и деплоймента шаблонов на Бинтрей. Поскольку шаблон у нас не серъезный, на Бинтрей мы его класть не будем, а вот установить в кэш, чтобы попробовать запустить — обязательно. Запускаем сборку:
`>gradlew installTemplateMavenSimple`
`:packageTemplateMavenSimple`
`:installTemplateMavenSimple`
`BUILD SUCCESSFUL`
9. Тестируем! Создаем новую директорию и в ней создаем проект из шаблона (как мы уже видели):
`>lazybones create maven-simple 0.1 maven-simple`
`Creating project from template maven-simple 0.1 in 'maven-simple'`
`Выберите groupId [org.example]: com.demo`
`Выберите artifactId [maven-simple]:`
`Выберите версию [1.0-SNAPSHOT]: 0.1`
`Выберите package для класса [org.example]:org.simple`
`Чего печатать в тесте? Привет, Хабр!`
`Шаблон а-ля архетайп`
`---------------------------------`
`Ты создал Мавеновский проект. Может хватит? Грейлд ждет тебя.`
`Project created in maven-simple!`
Сообщение в конце, приходит, конечно из `readme.md`. Обратите внимание, я не указал `artifactId`, ожидаю `maven-simple` по умолчанию.
Заходим в директорию maven-simple, и любуемся:
```
│ pom.xml
│ README.md
│
└───src
└───main
├───java
│ └───org
│ └───simple
│ App.java
│
└───resources
```
Открываем pom.xml:
```
4.0.0
com.demo
maven-simple
0.1
org.codehaus.mojo
exec-maven-plugin
1.2.1
test
java
org.simple.App
Привет, Хабр!
```
Всё как надо. Открываем App.java:
```
package org.simple;
public class App {
public static void main(String[] args) {
System.out.println(args[0]);
}
}
```
Тоже порядок. Запускаем Мавен:
```
>mvn test
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building maven-simple 0.1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ maven-simple ---
[INFO] Copying 0 resource
[INFO]
[INFO] --- maven-compiler-plugin:2.5.1:compile (default-compile) @ maven-simple ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ maven-simple ---
[INFO]
[INFO] --- maven-compiler-plugin:2.5.1:testCompile (default-testCompile) @ maven-simple ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ maven-simple ---
[INFO] No tests to run.
[INFO]
[INFO] >>> exec-maven-plugin:1.2.1:java (default) @ maven-simple >>>
[INFO]
[INFO] <<< exec-maven-plugin:1.2.1:java (default) @ maven-simple <<<
[INFO]
[INFO] --- exec-maven-plugin:1.2.1:java (default) @ maven-simple ---
Привет, Хабр!
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.768s
[INFO] Finished at: Fri Apr 04 02:54:57 IDT 2014
[INFO] Final Memory: 7M/304M
[INFO] ------------------------------------------------------------------------
```
Вот и всё. Я надеюсь, вы прониклись простотой и изяществом как создания проектов из шаблонов так и созданием самих шаблонов в Lazybones. Мне кажется, за эти простоту и изящество во многом надо благодaрить Груви.
**Бесстыдный пиар, можно не читать**Если вам понравилось и вы со мной согласны на счет изящества и простоты, и если вы хотите и сами подучить немножко Груви, то приходите ко мне на тренинг [15-го апреля в Казани](http://jugru.timepad.ru/event/114085/), или [17-го апреля в Москве](http://jugru.timepad.ru/event/109275/). Обещаю научить Грувийным плюшкам. | https://habr.com/ru/post/218205/ | null | ru | null |
# Даже в Java 9 ArrayList всё ещё можно (и нужно) улучшать
Думаю, большинство джавистов согласится, что `java.util.ArrayList` — наиболее используемая коллекция в мире Java. Она появилась в версии 1.2 и быстро стала "коллекцией по умолчанию", ведь в большинстве случаев её возможностей вполне достаточно для повседневной работы. В этот класс вносилось множество изменений (см., например, [историю изменений в репозитории JDK 8](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/log/73d5bcd0585d/src/share/classes/java/util/ArrayList.java)), чтобы сделать его как можно более производительным. В этой заметке я покажу, что даже такой прокачанный компонент, как `ArrayList` всё ещё хранит в себе возможности для улучшения.
Положим, нам необходимо преобразовать в массив часть списка. Для этого опишем метод:
```
public T[] toSubArray(ArrayList list, int from, int to) {
return list
.subList(from, to)
.toArray(new T[0]);
}
```
Оценим его производительность в сравнении с преобразованием в массив исходного списка:
```
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Fork(jvmArgsAppend = {"-XX:+UseParallelGC", "-Xms1g", "-Xmx1g"})
public class SubListToArrayBenchmark {
/**
* baseline
*/
@Benchmark
public Integer[] list(Data data) {
return data.list.toArray(new Integer[0]);
}
@Benchmark
public Integer[] subList(Data data) {
return data.list.subList(0, data.size).toArray(new Integer[0]);
}
@State(Scope.Thread)
public static class Data {
ArrayList list;
@Param({"0", "10", "100", "1000"})
int size;
@Setup
public void setup() {
list = IntStream
.range(0, size)
.boxed()
.collect(toCollection(ArrayList::new));
}
}
}
```
Выполнив замеры обнаружим, что производительность метода `subList()` значительно уступает производительности baseline-а:
| Benchmark | size | Score | Error | Unit |
| --- | --- | --- | --- | --- |
| list | 0 | **7,2** | 0,1 | ns/op |
| subList | 0 | **12,8** | 0,2 | ns/op |
| list | 10 | **34,6** | 3,9 | ns/op |
| subList | 10 | **44,7** | 1,0 | ns/op |
| list | 100 | **141,9** | 2,2 | ns/op |
| subList | 100 | **252,1** | 4,9 | ns/op |
| list | 1000 | **1201,6** | 21,0 | ns/op |
| subList | 1000 | **2310,4** | 53,0 | ns/op |
Учитывая то обстоятельство, что в обоих случаях перемещается равный объём данных, значительная разница выглядит удивительной.
Разгадка лежит врутри класса `ArrayList`:
```
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable
{
//...
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
public T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
//...
}
```
Оба метода напрямую обращаются к массиву, используя `Arrays.copyOf()` и `System.arraycopy()` для перемещения данных. Заглянем внутрь:
```
public class Arrays {
//...
@HotSpotIntrinsicCandidate // since Java 9
public static T[] copyOf(U[] original, int newLength, Class extends T[] newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
//...
}
```
```
public final class System {
//...
@HotSpotIntrinsicCandidate // since Java 9
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
//...
}
```
Указанные методы помечены как `@HotSpotIntrinsicCandidate`, что позволяет ВМ ~~создавать для них высокопроизводительный машинный код~~ подменять их реализацию высокопроизводительным машинным кодом для достижения наилучшего быстродействия.
Теперь обратимся к методу `subList()`:
```
public List subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList<>(this, fromIndex, toIndex);
}
```
Как видим, `ArrayList` располагает собственной реализацией данного метода, и (что гораздо важнее) собственной реализацией представления части списка:
```
private static class SubList extends AbstractList implements RandomAccess {
private final ArrayList root;
private final SubList parent;
private final int offset;
private int size;
//...
}
```
Теперь главное: хотя `SubList` и помечен как `RandomAccess` и через поле `root` имеет прямой доступ к массиву, **он не располагает собственной реализацией** методов `toArray()` и `toArray(T[])`. А раз так, то **используются унаследованные методы** класса `AbstractCollection`:
```
public Object[] toArray() {
// Estimate size of array; be prepared to see more or fewer elements
Object[] r = new Object[size()];
Iterator it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) // fewer elements than expected
return Arrays.copyOf(r, i);
r[i] = it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
}
public T[] toArray(T[] a) {
// Estimate size of array; be prepared to see more or fewer elements
int size = size();
T[] r = a.length >= size ? a :
(T[])java.lang.reflect.Array
.newInstance(a.getClass().getComponentType(), size);
Iterator it = iterator();
for (int i = 0; i < r.length; i++) {
if (! it.hasNext()) { // fewer elements than expected
if (a == r) {
r[i] = null; // null-terminate
} else if (a.length < i) {
return Arrays.copyOf(r, i);
} else {
System.arraycopy(r, 0, a, 0, i);
if (a.length > i) {
a[i] = null;
}
}
return a;
}
r[i] = (T)it.next();
}
// more elements than expected
return it.hasNext() ? finishToArray(r, it) : r;
}
```
Здесь массив заполняется в цикле с помощью итератора, а это работает медленнее, чем перенос данных с помощью `Arrays.copyOf()` и `System.arraycopy()`. Отсюда следует, что для улучшения производительности нам нужно переопределить `toArray()` и `toArray(T[])` и использовать тот же подход, что и `ArrayList`. Дополним:
```
private static class SubList extends AbstractList implements RandomAccess {
private final ArrayList root;
private final SubList parent;
private final int offset;
private int size;
//...
@Override
public Object[] toArray() {
return Arrays.copyOfRange(root.elementData, offset, offset + size);
}
@Override
public T[] toArray(T[] a) {
if (a.length < size)
return (T[]) Arrays.copyOfRange(root.elementData, offset, offset + size, a.getClass());
System.arraycopy(root.elementData, offset, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
//...
}
```
Всё ли мы сделали правильно? Нет! Переопределённые нами методы не учитывают вероятность того, что исходный список может быть изменён уже после вызова метода `subList()`. Мы обязаны учесть такую возможность. Поэтому добавим проверку в начало каждого из переопределённых методов:
```
@Override
public Object[] toArray() {
checkForComodification(); // <--
return Arrays.copyOfRange(root.elementData, offset, offset + size);
}
@Override
public T[] toArray(T[] a) {
checkForComodification(); // <--
if (a.length < size)
return (T[]) Arrays.copyOfRange(root.elementData, offset, offset + size, a.getClass());
System.arraycopy(root.elementData, offset, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
```
Прогнав бенчмарк с изменённым `ArrayList`-ом обнаруживаем, что теперь производительность метода `subList()` лишь незначительно уступает производительности baseline-а. Небольшое отставание обусловлено созданием подсписка и вызовом `checkForComodification()` в начале метода `toArray(T[])`.
| Benchmark | size | Score | Error | Unit |
| --- | --- | --- | --- | --- |
| list | 0 | **7,2** | 0,1 | ns/op |
| subList | 0 | **7,5** | 0,2 | ns/op |
| list | 10 | **24,5** | 0,5 | ns/op |
| subList | 10 | **25,4** | 0,6 | ns/op |
| list | 100 | **142,8** | 4,5 | ns/op |
| subList | 100 | **141,6** | 2,5 | ns/op |
| list | 1000 | **1243,6** | 28,5 | ns/op |
| subList | 1000 | **1247,8** | 23,7 | ns/op |
**В сухом остатке:**
[Тикет и ссылка на патч](https://bugs.openjdk.java.net/browse/JDK-8196207) (закроют, скорее всего, в Java 11)
**Что почитать:**
[Длинная, сложная и чрезвычайно полезная статья о чёрном колдовстве в омуте ВМ](https://shipilev.net/blog/2016/arrays-wisdom-ancients/)
**Исходная переписка по теме заметки:** [находится тут](http://mail.openjdk.java.net/pipermail/core-libs-dev/2018-January/051102.html)
#### Выводы
* даже до боли знакомые классы могут скрывать недоработки
* абстрактные коллекции написаны для покрытия как можно большего числа случаев и предлагают обобщённые алгоритмы, поэтому при создании конкретной реализации нередко есть возможность написать более производительный код, заточенный под особенности вашей структуры данных
* для внесения изменений необязательно быть сотрудником "Оракла"; если у вас есть патч, устраняющий доказанную ошибку или привносящий ощутимое улучшение, — он будет принят к рассмотрению
* чаще заглядывайте в код платформы: джавист никогда не может знать о JDK слишком много
**P. S.** Тикет закрыли, изменения влиты. | https://habr.com/ru/post/348018/ | null | ru | null |
# PHPStorm + XDebug + Docker
Таких статей уже тысяча, зачем?Мне не подошла полностью ни одна. Я потратил около двух часов на весь процесс и за это время нашёл около десятка статей, в которых либо данные были неполные, либо просто устаревшие
Я ожидаю, что у вас уже есть проект с настроенным докером.
Шагов, на самом деле, немного, все очень простые.
1. Настраиваем интеграцию PHPStorm с DockerИдём в `Settings > Build, Execution, Deployment > Docker` и создаём максимально простую интеграцию через локальное приложение `Docker`:
2. Настраиваем выполнение скриптов через удалённый (в контейнере) интерпретаторИдём в `Settings > PHP > CLI Interpreter > 3 точки справа от него` и добавляем такую конфигурацию:
У меня не проходит валидация установленного пхп, потому что версия 5.6, но это ни на что не влияет`Name` может быть любым
`Server` выбираем тот, который создали шагом ранее
`Configuration files`: путь до `docker-compose.yml`
`Service`: контейнер с `PHP`
Остальное на ваш вкус, но в графе `Lifecycle` лучше оставить `connect to existing container`
Теперь, в графе `CLI Interpreter` вы увидите выбранным только что созданный конфиг:
3. Даём PHPStorm знать о том, как мы обращаемся к серверуИдём в `Settings > PHP > Servers`и добавляем новую конфигурацию сервера:
Порт берём из своего конфига `nginx`. В моём случае он поднят в отдельном контейнере и смотрит наружу через 8001
Тут важно запомнить `Name`, это пригодится чуть позже
4. Чуть-чуть донастроим интеграцию PHPStorm с XDebugИдём в `Settings > PHP > Debug > XDebug` и добавляем порт 9001:
5. Настроим конфигурацию запуска дебаггераИдём в `Run > Edit configurations` и создаём новую конфигурацию на основе `PHP Remote Debug`:
Здесь `Server` это как раз `Name` из пункта #3
В этом окне `Name` может быть любым, надо его запомнить, он, опять же, пригодятся чуть позже
`IDE key` может быть любым, **НО!** Если у вас XDebug 3, то обязательно запоминаем значение
6. Донастраиваем docker-compose.ymlВ контейнере с `PHP` для правильной интеграции с `XDebug` мы должны иметь доступ к локальной машине, то есть хосту:
```
old.???.php:
container_name: old.???.php
build: ./docker/php
volumes:
- ./:/app
restart: unless-stopped
extra_hosts:
- "host.docker.internal:host-gateway"
```
Здесь важна только директива `extra_hosts`, она обязательна
7. Донастраиваем Dockerfile контейнера с PHPДобавляем кусок конфига куда-нибудь в конец перед `WORKDIR /app`:
XDebug 2
```
# xdebug
COPY --from=mlocati/php-extension-installer /usr/bin/install-php-extensions /usr/bin/
RUN install-php-extensions xdebug
ENV PHP_IDE_CONFIG 'serverName=old.???’
RUN echo "xdebug.remote_enable=1" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.remote_host=docker.for.mac.localhost" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.remote_port=9001" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.remote_log=/var/log/xdebug.log" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.remote_autostart=1" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
```
XDebug 3
```
# xdebug
COPY --from=mlocati/php-extension-installer /usr/bin/install-php-extensions /usr/bin/
RUN install-php-extensions xdebug
ENV PHP_IDE_CONFIG 'serverName=old.???'
RUN echo "xdebug.mode=debug" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.start_with_request = yes" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.client_host=docker.for.mac.localhost" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.client_port=9001" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.log=/var/log/xdebug.log" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
RUN echo "xdebug.idekey = PHPSTORM" >> /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
```
В последней строке указываем `IDE key` из шага #5
Этот кусок ставит `XDebug` через через `pecl` и закидывает нужные параметры `XDebug` в конфиг
Из самого важного здесь:
1. `ENV PHP_IDE_CONFIG` - в `serverName` надо прописать `Name` из пункта #5
2. `xdebug.*_port` - порт из пункта #4
3. `xdebug.*_host` - в моём случае указан хост для мака, если у вас линукс или винда, то поищите альтернативы, они точно есть
8. Ставим брейкпоинты, заходим на сайт и радуемся жизниБольше тут сказать нечего :)
Буду рад, если это кому-то поможет!
UPD @ 25.01.2023: добавил конфиг для XDebug 3 | https://habr.com/ru/post/712670/ | null | ru | null |
# Док в Леопарде с черным треугольником
Я уверен, что есть небольшое количество людей, которым нравится трехмерный док в Леопарде, но которые не могут вынести светящуюся точку, обозначающую запущенное приложение. Так же я уверен, что небольшое количество пользователей будут рады увидеть возвращение черного треугольного индикатора в док.
Это возможно и, по факту, очень легко. Готовы немного погрузиться в Mac OS X?
Для начала вам нужны треугольники. Скачайте [indicators.zip](http://www.silvermac.com/wp-content/uploads/2007/10/indicators.zip "indicators.zip") и распакуйте его на рабочий стол. Файлы, которые понадобятся:
* indicator\_large.png (42 x 14 pixel)
* indicator\_medium.png (32 x 11 pixel)
* indicator\_small.png (14 x 8 pixel)
Почему три? Как вы потом заметите, в отличие от предыдущих версий OS X, размер индикатора в Леопарде меняется с размером дока. Вы можете попробовать использовать средний размер для всех трех, если не хотите, чтобы их размер менялся. Решайте сами. Или вы можете сделать свои собственные индикаторы. Просто проверьте, чтобы размеры изображений и названия файлов остались прежними, а фон сделайте прозрачным.
*Отказ от ответственности: Начинаю с этого момента все риски за вами. Вход в качестве root дает полный контроль над любым файлом на вашем Маке. Если вы не знаете, что делаете, то можете причинить серьезные повреждения вашим файлам и спровоцировать системный [fubar](http://en.wikipedia.org/wiki/FUBAR "FUBAR definition").
SilverMac не несет никакой ответственности за повреждения, которые вы или кто-то другой, работающий за вашим компьютером, можете вызвать следуя этим инструкциям.
Согласны продолжать на ваш страх и риск? Если так, то читайте дальше.*
Закройте все приложения и выйдите из системы. Затем войдите в качестве Администратора (root).
Перейдите в папку `/Users/<ваше_имя_пользователя>/Desktop`. Возьмите файлы индикаторов и перенесите их на рабочий стол root пользователя. В Finder выберите ваш жесткий диск (обычно Macintosh HD) и перейдите в папку `/System/Library/CoreServices`:
Нажмите правой кнопкой мыши на Dock и выберите «Показать содержание пакета» (Show package contents). (Если у вас нету этого пункта меню, то вам необходимо установить [Developer Tools](http://www.silvermac.com/2006/installing-developer-tools/)). Выбирите `Contents/Resources/`.
Здесь вы найдете оригинальные файлы индикаторов. На всякий случай дайте им какое-нибудь другое название. Например `original_indicator_small.png`.
Теперь скопируйте три ваших файла индикаторов в эту папку. Перезагрузите док (*Ctrl+Option+Правая кнопка мыши -> Relaunch*). Если у вас есть работающие приложения, то возможно потребуется закрыть и открыть их снова, чтобы обновить индикатор. Наслаждайтесь!
Я не программист и не написал а своей жизни ни одного скрипта, но я уверен, что это легко сделать. Так что если у кто-то, у кого достаточно способностей, знает как это сделать — то почему бы и нет. | https://habr.com/ru/post/45811/ | null | ru | null |
# Мой конспект с Joker 2020
Вот и прошла конференция Joker 2020 для Java senior-ов. Для меня эта конференция стала особенной сразу по нескольким причинам — это первая "серьёзная" техническая конференция на которую я попал (в качестве зрителя), это моя первая онлайн-конференция, и это первая конференция, билет на которую я купил сам, а не за счёт работодателя.
*Изображение [отсюда](https://jokerconf.com/en/)*
Потраченные деньги, плюс возможность пересматривать любую трансляцию мотивировали меня просмотреть как можно больше материала, в результате даже через неделю после завершения конференции, я всё ещё продолжал сидеть и конспектировать выступление за выступлением. *Совершенно нормальное поведение, хватит всем на меня так пялиться. Нет, я не пойду с добрым дядей доктором на обследование, спасибо.*
Сразу предупреждаю, что даже так я не сумел просмотреть все трансляции, но если кому-то интересно, что же из этого получилось — добро пожаловать под кат.
Spring: Your next Java microframework
-------------------------------------
Презентация от [Алексея Нестерова](https://twitter.com/alek_sys), в которой он доказывает, что Spring Boot может выглядеть как микрофреймворк, вести себя как микрофреймворк и даже крякать как микрофреймвок, а если так — то что же нам ещё нужно?
От микрофрейморках люди, как правило, ожидают несколько качеств: простоты разработки, "понятности" работы (simple vs easy), скорости работы, и готовности к работе в "облаке" (cloud-readiness, cloud-native). Как ни странно, Спринг может соответствовать всем этим критериям, и Алексей готов это доказать.
### Лёгкость разработки
У Spring есть [Boot Devtools](https://docs.spring.io/spring-boot/docs/2.4.x-SNAPSHOT/reference/html/using-spring-boot.html#using-boot-devtools), позволяющий, помимо всего прочего:
* получить LiveReload в браузере
* отключить кэширование шаблонов
* перезагружать сервис при обновлении файлов в classpath как локально, так и удалённо (но только не делайте так на продакшене, пожалуйста)
### Скорость запуска
Спринг может быть быстр для запуска, но надо понимать что вообще делает ваш код. Если вы грузите сторонние сервисы, или лезете в БД при запуске — нечего пенять на Спринг! Помимо этого оптимизировать старт могут следующие советы:
* распакуйте executable JAR и укажите Main класс
* используйте spring-context-indexer
* используйте функциональные бины
* уберите Actuator
* используйте реактивный стек
Боттлнеком всегда может стать ваш CPU, может быть проблема ещё в JVM — попробуйте разные, например J9, попробуйте CDS, или скомпилируйте в нативный файл с GraalVM.
Если совсем ничего не остаётся *(или если вам платят только за оптимизацию времени старта)* — переделайте все бины на ленивые, и используйте ленивую загрузку для репозиториев. *И пусть кто-то другой разбирается с проблемой тормозящего первого запроса.*
Примечания в *курсиве* — от меня, это не слова докладчика.
### Простота (понятность) в разработке
Тут докладчик потратил время на объяснение о том, чем в его представлении "easy" отличается от "simple". Очень надеюсь, что я понял правильно, что "easy" — это та "магия" Спринга, при которой ты просто вешаешь пачку аннотаций по коду и всё начинает работать "само собой" — на механизмах, зашитых в сам Спринг. В противовес этому есть "simple" — когда вы явно прописываете что идёт за чем, имеете полный контроль над кодом, но добавление новых компонент будет сопровождаться дополнительной работой с вашей стороны. Здесь не будет идеального решения, каждому разработчику/команде надо решать для себя, что им конкретно сейчас важнее.
Для обеспечения "понятности" разработки, в новых версиях Спринга появились такие альтернативы уже существующим механизмам:
* **Functional beans** вместо Component Scanning
* **Functional routing** вместо Route mapping
* Использование `@Query` или миграция с JPA вместо использования Generated Queries
* Manual import вместо Autoconfigurations
Оказывается, пока я учился мигрировать конфигурацию сервисов с XML на аннотации спринга, умные люди сделали ещё и [Functional beans](https://cloud.spring.io/spring-cloud-function/multi/multi__functional_bean_definitions.html) с [Functional routing](https://spring.io/blog/2016/09/22/new-in-spring-5-functional-web-framework) на лямбдах. Все три метода поддерживаются и могут работать дополняя друг друга, но новая функциональная конфигурация должна быть чуть-чуть быстрее, потому что не использует рефлексию.
С помощью новых механизмов, весь (микро-)сервис можно описать исключительно из Main-а, не используя никаких других методов конфигурации.
Все четыре тезиса были подкреплены демонстрацией примеров, в этом случае — на использование `applicationContext.registerBean(...)` и `RouterFunction`, `route().GET("/foo", request -> { ... })`.
### Cloud-ready
Напоследок, cloud-ready, но тут даже и обсуждать нечего — это движение по сути, со спринга и началось, Spring Cloud содержит готовые механизмы для Circuit Breakers, конфигурации, Service registry, балансировка нагрузки, API gateways, даже Serverless с Spring Cloud Function.
Сприг поддерживает такие платформы как Kubernetes, Cloud Foundry, AWS, Alibaba и другие.
Докладчик так же посоветовал посмотреть на Java Memory Calculator проект для тех, кто редактирует Dockerfile руками.
Из диалога с экспертами и ответов на вопросы стало понятно, что Spring DevTools перезагружают весь сервис — если у вас какие-то свои сессии на Spring Security — они будут пропадать. Функциональные бины работают так же, как и обычные. Пост процессоры бинов могут быть зарегистрированы точно так же.
How we did SQL in Hazelcast
---------------------------
Презентация от [Владимира Озерова](https://twitter.com/devozerov), в которой он показал основные принципы проектирования своего распределенного SQL хранилища, основываясь на опыте своей компании.
Изначально у них было предикатное API для хранения in-memory индексов, но этого было не достаточно, так как не давало нужной гибкости. В первых версиях они перешли на простые запросы вида `select ... from ... where` с использованием индексов. Оптимизация SQL запросов — это очень сложные задачи, к счастью в мире есть несколько решений, и одно из которых они решили использовать — это [Apache Calcite](https://calcite.apache.org/).
Процесс оптимизации запроса "по верхам" состоит из трёх шагов: анализ синтаксиса, анализ семантики, и оптимизация. По теме оптимизации есть множество исследовательских работ, например, “Access Path Selection in a Relational Database Management System”, “The Cascades Framework for Query Optimization”.
*Ремарка от меня*. До сих пор мне приходилось работать с SQL, например, с такими задачами как поддержка вызовов хранимых процедур на легаси системах, или использование больших и сложных SQL запросов, предоставленных нам от DBA. Так что название презентации меня очень заинтересовало, и я с интересом был готов послушать что-то новое. Однако, в этот момент даже до меня дошло, что что-то здесь не так, и тема как-то не похожа на ту, что я ожидал услышать, так что я решил "откланяться" и пойти слушать другой доклад. Тем не менее тема должна быть интересна, и кто хочет — может досмотреть её самостоятельно.
Spring Boot “fat” JAR: Thin parts of a thick artifact
-----------------------------------------------------
Здесь докладчик по имени [Владимир Плизга](https://twitter.com/toparvion), вместе с экспертами [Андреем Беляевым](https://twitter.com/belyaev_andrey) и [Андреем Когуном](https://twitter.com/andrei_kogun) разобрал устройство "fat" JAR-а.
Вообще, технология "fat" JAR — не нова, и [первые образцы технологии](https://en.wikipedia.org/wiki/Matryoshka_doll) были представлены ещё в 1890 году Василием Звёздочкиным. В спринге же существует с первой версии.
При запуске такого архива происходит следующая цепочка вызовов:
Внешний архив размечается так:
А вот так классы грузятся из архива:
*Все слайды — из презентации Владимира, он поделился ими по следующей [ссылке](https://toparvion.pro/talk/2020/joker/)*
Несколько замечаний докладчика: внутренние архивы **не** сжаты;
Spring вешает собственный наследник URLClassLoader-а на главный поток;
По сути чтение классов работает как чтение из внешнего архива с правильным отступом с использованием `RandomAccessFile`.
Если что-то пошло не так, то загрузку "fat" JAR-а можно отдебажить следующей последовательностью действий:
1. Скачать нужную версию Spring Boot-а
2. Поставить брейкпойнт на `org.springframework.boot.loader.JarLauncher#main`
3. Запустить джарку с параметром `-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005`
4. Подключиться дебагером из проекта
Тут завязалась дискуссия с экспертами, из которой прояснили ещё несколько моментов:
* Загрузка может поломаться: например — может появиться Class/MethodNotFoundException если порядок JAR-ок в "fat" JAR-е различается
* Запуск проекта из Идеи отличается от запуска самой джарки
**Мораль — тестируйте fat JAR ещё на этапе разработки, что бы избежать проблем на продакшене**
Использование "fat" JAR-а может потенциально поломать такие утилиты как `jshell`, `jdeps`, `jmint`, а так же пакет `java.util.logging` со всеми наследниками. Что бы это починить, постарайтесь не использовать ClassLoader.getSystemClassLoader(), или просто распаковывайте "fat" JAR перед использованием. Однако, даже со всеми этими недостатками fat "JAR" может помочь в миграции с application server'а на Спринг бут.
**Поддержка докера** с версии Spring Boot 2.3 (опционально — и с 2.4 — по умолчанию) в fat JAR добавился новый режим `-Djarmode=layertools`, позволяющий собирать артефакт [по слоям](https://spring.io/blog/2020/08/14/creating-efficient-docker-images-with-spring-boot-2-3), и это работает как с Maven, так и с Gradle плагинами. Посмотреть слои можно командой
```
java -Djarmode=layertools -jar fat.jar list
```
По умолчанию идут в таком порядке: зависимости, загрузчик спринг бута, snapshot зависимости, сгенерированный код, код приложения. Что именно попадёт в какой слой — можно [менять и настраивать](https://docs.spring.io/spring-boot/docs/current/gradle-plugin/reference/htmlsingle/#packaging-layered-jars). Далее, распакованный по слоям артефакт можно упаковать в докер вручную, с помощью докерфайла как-то так:
```
FROM .../openjdk-alpine:11 as builder
WORKDIR application
COPY fat.jar fat.jar
RUN java -Djarmode=layertools -jar fat.jar extract
...
FROM ...openjdk-alpine:11
WORKDIR application
COPY --from=builder application/dependencies/ ./
COPY --from=builder application/spring-boot-loader/ ./
...
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]
```
Использование спрнгового JarLauncher'а даже на распакованном артефакте позволяет нам сохранить "магию" Спринга, и, например, читать версию артефакта из манифеста.
Из презентации я так же узнал об утилите "dive", которую докладчик использовал для просмотра слоёв в контейнере.
Разобравшись с ручной упаковкой докерфайла у экспертов возник закономерный вопрос: "А где тут кнопка <сделать хорошо>"?
Оказывается, есть и такое — разные инструменты, вроде [Buildpacs](https://docs.spring.io/spring-boot/docs/current/gradle-plugin/reference/htmlsingle/#build-image), или [Google Jib](https://cloud.google.com/java/getting-started/jib).
Разница между ними такая — если нужен полный контроль, то используйте Layertools, если нужна "магия" и размеры полученного артефакта не заботят — то Buildpacs, если нет возможности использовать докер, или невозможно обновить Спринг Бут до версии 2.3 — берите Jib.
Общие рекомендации с презентации:
* Проверяйте что идёт в class-path в IDE
* Обновляйте Spring Boot до последней версии
* Распаковывайте fat JAR в целевом окружении
* Запускайте проект через JarLauncher, не Main-Class манифеста
* Подумайте об удобстве использования с Buildpacs
Дополнительные ссылки:
* <https://youtu.be/WL7U-yGfUXA>
* <https://reflectoring.io/spring-boot-docker/>
* <https://www.profit4cloud.nl/blog/building-containers-with-spring-boot-2-3/>
Hidden pearls for high-performance-persistence in Java
------------------------------------------------------
Презентация от [Свена Рупперта](https://twitter.com/SvenRuppert). Свен по максимуму воспользовался форматом онлайн презентации, и записал свою речь во время неторопливой прогулки по осеннему лесу с чашкой кофе. Несмотря на умиротворяющую атмосферу, сама презентация прошла в очень бодром темпе, а Свен успел перечислить и рассказать особенности множества интересных библиотек из мира Джавы.
[**JOOQ**](https://www.jooq.org/): кодогенератор для вызовов БД. *Вот только я подумал, что у меня наконец-то появилась идея своего проекта, которой ещё ни у кого не было...*
Позволяет генерировать DSL в зависимости от БД, со всеми таблицами и колонками, и использовать дальше в своих проектах. В бесплатной версии не поддерживает Oracle, SQL Server и MS Access.
[**Speedment**](https://speedment.github.io/speedment-doc/overview.html). *Хотел дать ссылку на их сайт, но там ошибка 500 — по злой иронии не может подключиться к БД и так лежит уже неделю*
Позволяет генерировать DSL под БД, но на потоках Java 8. Все фильтры и выборки задаются в лямбдах, выглядит интересно. Сюда же можно отнести и [JPA Streamer](https://jpastreamer.org/) — библиотеку, которая добавляет Java 8 streams поверх Hibernate.
[**Chronicle Bytes**](https://github.com/OpenHFT/Chronicle-Bytes): даёт два класса Bytes — для создания массивов байтов и MappedBytes — для привязки буфера к файлу. Написал в стиле С/С++ — записывать можешь что угодно в каком порядке, доставать обратно — тоже. Описания полей/классов не сохраняются, если при чтении перепутаешь порядок или попытаешься прочитать лишнее — сам виноват.
[**Chronicle Map**](https://github.com/OpenHFT/Chronicle-Map) — быстрое key-value хранилище разработанное для высоко нагруженных многопоточных приложений, не ограничено размерами RAM-а, и может сохранять данные на диск.
[**XODUS**](https://github.com/JetBrains/xodus) транзакционная schema-less встроенная БД, разработанная в JetBrains. Все изменения пишутся в иммутабельный лог.
[**MapDB**](http://www.mapdb.org/) совмещает движок БД и коллекции Java. Позволяет использовать словари, списки, для хранения данных либо вне сборщика мусора, либо на диске.
```
DB db = DBMaker.fileDB("/some/file").encryptionEnable("password").make();
ConcurrentNavigatableMap map = db.treeMap(...);
```
Можно использовать для получения многоуровневого кеша с истечением срока хранения, для хранения не влезающих в RAM данных диске, для последовательных бекапов, для фильтрации и обработки данных. Всё это достигается за счёт того, что типы хранилищ можно совмещать: например завести словарь вне GC, пишущий часть данных на диск.
[**Microstream**](https://microstream.one/) — проект, реализовавший собственную сериализацию для объектов, и хорошо умеющий работать с графами. В бесплатной версии не работает с Oracle БД, и не даёт параллельное чтение/запись. Стартовый класс — EmbeddedStorageManager, в нём можно задать корень графа, сохранить на диск. Позволяет хранить модели как есть, или в виде коллекций. Позволяет работать только с частями графов, но даже зацикленные графы для них не проблема. Могут быть проблемы с наследованиями.
Помимо этого Mictorstream устраивают [хакатон](https://hackathon.microstream.one/) с призовым фондом в 20к$, на котором Свен будет одним из членов жюри. До февраля есть возможность придумать какое-то интересное использование для этой библиотеки, выложить под лицензией Apache 2 и попробовать получить 5к$ на первом месте (всем участникам гарантируют майку).
Spring Patterns for adults
--------------------------
Последний крупный доклад, о котором я хотел бы здесь написать — это работа [Евгения Борисова](https://twitter.com/jekaborisov), которую он презентовал с приглашенными экспертами [Андреем](https://twitter.com/andrei_kogun) и [Кириллом](https://twitter.com/tolkv). Говорили много и интересно — по докладу видно, что Евгений отлично разбирается в теме и очень живо делится своими знаниями, я попробую передать лишь основное.
При запуске `@ComponentScan`, Спринг начинает сканировать все компоненты, включая унаследованные `@Service/@Repository/@Controller/@RestController` и даже `@Configuration` — это тоже компонента. Работает это потому, что Спринг не ищет конкретные аннотации, а проверяет каждую найденную и перебирает всех её предков. Таким образом можно писать собственные аннотации (как `@MyCompanyController`), наследующие, или аннотированные аннотациями Спринга, и они будут работать точно так же с остальными контроллерами.
Довольно распространённая ошибка — кто-то пишет `@Lazy` компонент (`@Lazy Component`, `@Lazy @Service`, ...) и не понимает, почему этот компонент стартует вместе со всеми, даже когда им никто не пользуется. Проблема в том, что любой `@Autowire` для компоненты — автоматически означает, что компонента нужна, и заставляет Спринг её создать. Решение простое — с версии 4.3 можно сделать `@Autowire @Lazy` — и вместо компоненты будет прокси-объект, который создаст реальную компоненту лишь тогда, когда кто-то начнёт ею пользоваться.
При тестировании приложений всегда есть проблема контекста, который надо разворачивать для тестирования. Разворачивать всё и всегда — долго, разворачивать только часть контекста в зависимости от теста — всегда есть риск, что что-то где-то будет падать из-за какой-то части проекта, в результате всё будет скатываться в первую ситуацию — когда для каждого теста разворачивается весь контекст. Для решения этой проблемы на тестах можно использовать `@ComponentScan(lazyInit = true)` (либо `spring.main.lazy-initialization=true` в файле настроек).
Была интересная дискуссия о том, так ли полезна инъекция параметров конструктора, которая, в отличие от инъекция по полям не должна — в теории — позволить растянуться коду в классе и должна помочь избежать создания "божественных объектов", которые делают слишком много всего сразу. На практике же программист просто лепит [@RequiredArgsConstructor](https://projectlombok.org/features/constructor) и классы продолжают расползаться.
Была ещё более интересная дискуссия о том, как использовать квалификаторы. К сожалению, текстом и в виде конспекта её не пересказать, я могу лишь показать картинку "Айтишники на троих разбирают запутанный случай Spring Boot'а".
Далее, по паттернам. Для использования паттерна Chain of Responsibility в спринге можно инжектить списки. `@Autowired List handlers;`заинжектит все компоненты, имплементирующие интерфейс `Hangler` — таким образом не надо будет их биндить по одному. Порядок будет произвольный, если нужен порядок, или какой-то особый список — то надо будет использовать BeanPostProcessor и собирать список самостоятельно из ApplicationContext.
Можно использовать Intrpspector.decapitalize() для получения имени бинов из имени класса.
Интересный пример того, как можно взять какой-либо старый фреймворк (например, из либы, которую нам нельзя менять) и заставить работать все старые легаси-компоненты в спринге. Делается это так с использованием [ImportBeanDefinitionRegistrar](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/ImportBeanDefinitionRegistrar.html)
```
class LegacyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
// ...
registerBeanDefinition() {
Reflections scanner = new Reflections("com.legacy.package");
Set> classes = scanner.getTypesAnnotatedWith(LegacySingleton.class);
for(Class aClass : classes) {
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setBeanClass(aClass);
// bd.addQualifier(new AutowireCandidateQualifier(Legacy.class)); // можно добавлять свои квалифаеры
beanDefinition.setScope(beanDefinition.SCOPE\_SINGLETON); // например
registry.registerBeanDefinition(Introspector.decapitalize(aClass.getSimpleName()), bd);
}
}
}
```
Начать использовать этот регистрар можно в классе с аннотацией `@Configuration @Import(LegacyBeanDefinitionRegistrar.class)`.
Далее, разобрали несколько вариантов того, как работать с паттерном Strategy & Command. Например, если мы хотим, что бы от клиента приходил запрос о том, как именно обрабатывать его запрос. Тут возникает соблазн начать использовать switch, но это опасный путь — сперва у тебя 5 кейсов, потом 6, там и 7-ой добавить вроде не страшно, потом вдруг 10 — но рефакторить уже сложно и какая разница, почему бы не добавить 11? После чего всё превращается в "ну да, у нас 234 кейсов, но рефакторить сложно, так что какая разница, что 235 добавим?". Чтоб избежать этой порочной практики, лучше сразу начинать писать как профессионалы.
Спринг позволяет сделать код, который вызывает нужный обработчик в зависимости от какой-нибудь строки несколькими методами.
```
@Autowired private Map map; // key = bean id, Handler - @Bean
```
Тут ключ — это айди бина, имя класса — может быть полезно, но не всегда применимо. Обойти это можно добавив какой-нибудь myType() метод в общий интерфейс, и собирая словарь в конструкторе, как в следующем примере.
```
interface HandlerInterface { String myType(); void doWork(); }
/// --
public class Controller {
private Map map;
public Controller()(List somethings) {
map = somethings.stream.collect(toMap(SomethingInterface::myType), Function.identity());
}
// ...
}
```
Ну и последний вариант — создать словарь как `@Bean`, использовать тот же метод группировки, что и в предыдущем.
Далее был интересный вариант того, как сделать так, что бы бины регистрировались на лету. Было показано несколько деталей, мне самым интересным показалось вот что: `@Autowired` можно вешать на любой метод, не обязательно сеттеры. Таким образом можно писать компоненты, которые при создании будут идти и регистрироваться у контроллера (например, из прошлого примера), добавив всего лишь один метод в общий интерфейс:
```
@Autowired default void regMe(Controller c) {
c.register(this.getType, this);
}
```
Под конец было упомянуто, что AspectJ лучше не использовать на бизнес-логике — вас все будут ненавидеть. Но это не означает, что AspectJ бесполезен! С его помощью можно отлавливать, например, когда бросаются исключения определенного типа — и либо логгировать их особым способом, либо высылать е-мейл админу "эта штука опять сломалась".
Презентация длилась два с половиной часа, но смотрелась на одном дыхании — настолько живо и интересно её подавали, так что кто ещё не смотрел — настоятельно рекомендую.
И ещё...
--------
### Java Licensing Tips
От [Юрия](https://live.jugru.org/en/speakers/c0V7V4lnDtbF2On7Ny8WS/). Разобрал тонкости в обновлении с JDK\_8\_202 на 203 — начиная с этой версии надо платить деньги в Оракл. Лучший совет здесь — советуйтесь с юристами, как именно это работает для вас, но вообще есть три варианта:
1. Не обновляться, остаться на версии 202
2. Мигрировать на OpenJDK со свободной лицензией
3. Провести внутренний аудит, разобраться где что нужно, попробовать уменьшить количество лицензий, начать платить
С точки зрения Оракл — "использование — факт установки JDK/JRE на ваш сервер продукции". Да, даже если вы ею не пользуетесь. Лицензии надо покупать на физические ядра процессора.
Например, если у вас есть сервер с двумя процессорами Intel Xenon E3 — 2680 v4, и у каждого процессора 14 физических ядер работает и Hyper Threading — на каждом из ядер по 2 логических ядра. В этом случае нужно купить 28 (физические ядра на обоих процессорах) *0.5 (коэффициент процессора из таблицы) = 14 лицензий. (*Поправил [Toofast73](https://habr.com/ru/users/toofast73/) в комментариях\*)
Всякие облака или кубернетес — всё равно плати. Если JDK установлено для какого-то продукта Oracle (например, DB/WebLogic), то платить не надо, но и другим приложениям нельзя использовать этот JDK.
На обычных пользователей — платить надо по пользователю. Один пользователь сидит на 5 компьютерах — одна лицензия, пять пользователей сидят на одном компьютере — 5 лицензий.
### How to tell "no" to an architect? Tips for sizing a microservice
[Андрей](https://twitter.com/Minimbl) довольно адекватно высказался по поводу микросервисов, что процесс их проектирования не должен быть безумным процессом рисование стрелочек и коробочек, где каждая коробочка — свой микросервис. Если какие-то части продукта связаны, и одна часть не может быть изменена без другой — надо ли разбивать их на два микросервиса, когда можно оставить всё в одном? В конце концов, разбить один сервис в несколько вы всегда успеете.
### Will robots replace programmers?
Довольно интересный рассказ [Тагира](https://twitter.com/tagir_valeev), где он анализирует тренды развития инструментов программирования. На мой взгляд, доклад скорее оптимистичный — да, тупой рутинной работы становится меньше, но и робот никогда не сможет точно отловить все нюансы. Скорее всего будущее — в тандеме между разработчиком и вспомогательными инструментами, часть из которых будет разработана с использованием техник машинного обучения.
Заключение
----------
Теперь, спустя три, кажется, недели могу сказать, что конференция была просто отличной. Для себя я узнал много нового, добавил всех докладчиков, кого нашел, в твиттере, успел даже попробовать кое-что у себя на проектах. Жаль, не было времени походить по залам в игровом виде, но думаю, это уже на другой раз можно будет отложить.
Этот конспект я делал на английском, слушая оригинальные трансляции. Не был уверен в том, нужны ли они кому-то, но оказалось, что интерес был — поэтому перевёл обратно на русский и получил эту статью. Сам я синьор не настоящий, опыта маловато, и я допускаю, что допустил неточности в некоторых темах. Тем более при переводе терминов на русский — сам я всю жизнь работаю на английском, переводить не привык. Тем не менее я очень надеюсь, что я не исказил смысла оригинальных презентаций, и не внёс никаких ошибок от себя. Но если что — пишите, всё исправлю! | https://habr.com/ru/post/531666/ | null | ru | null |
# Linux Unified Key Setup: как защитить флэшки и внешние диски от взлома
Посмотрим, как с помощью системы на базе спецификации Linux Unified Key Setup (LUKS) и утилиты Cryptsetup можно зашифровать флэш-накопители, внешние жёсткие диски и прочие переносные устройства, хранящие дорогую вашему сердцу информацию.
Чаще всего, пользователи рассуждают достаточно просто: накопители в безопасности, пока их никто не украл. Некоторые идут в размышлениях дальше: если для входа в систему нужно знать пароль — злоумышленнику будет сложно получить доступ к данным на украденном диске. Успокаиваясь на этой мысли, они забывают задать себе важный вопрос: к чему именно мешает получить доступ их пароль на самом деле?
Во многих случаях они всего лишь служат для разблокировки пользовательского сеанса. И тогда злоумышленник может забрать данные с диска, не зная пользовательский пароль: он просто обойдётся без разглядывания заставки на вашем рабочем столе.
Особенно хорошо это понимают специалисты, которые сталкивались с последствиями такой недальновидности и сделали соответствующие выводы. Доступ к необходимой информации можно получить, подключив к машине свой внешний загрузочный диск, и после некоторых успешных манипуляций читать диск пользователя, как открытую книгу.
Если время сильно ограничено, злодеи действительно могут украсть накопитель и взять работу на дом. Особенно легко это им удаётся, если он внешний и подключён через USB. В этой статье речь пойдёт о простом инструменте, позволяющем защитить от несанкционированного доступа данные на внешних накопителях. Даже если они уже попали в руки к злоумышленникам. Речь пойдёт о шифровании дисков в операционных системах семейства Linux.
Linux Unified Key Setup ([LUKS](https://gitlab.com/cryptsetup/cryptsetup/blob/master/README.md)) — это система шифрования дисков, которая хранит данные в зашифрованном физическом разделе. Зашифровать их помогает модуль ядра dm-crypt, позволяющий создавать виртуальное блочное устройство, с которым взаимодействует пользователь.
Если пользователь хочет записать данные на виртуальное устройство, они на лету шифруются и записываются на диск. Если же он хочет читать с виртуального устройства, данные, хранящиеся на физическом диске, дешифруются и передаются в открытом виде через виртуальный диск пользователю. Данные остаются под защитой и в том случае, когда диск подключают к другому компьютеру.
### Шифрование на этапе инсталляции
Проще всего выполнить полное шифрование диска, выбрав соответствующую опцию в процессе установки операционной системы. Большинство современных Linux-дистрибутивов позволяют это сделать. Здесь не буду расписывать в деталях, так как статья посвящена шифрованию внешних накопителей (далее я подробно буду рассматривать именно его).
*Изображение*: Seth Kenlon, CC BY-SA 4.0
После установки у вас будет зашифрованный диск. Перед загрузкой системы потребуется ввести парольную фразу. Если захотите извлечь диск или получить к нему доступ из другой операционной системы, нужно выполнить дешифрацию с помощью той же системы LUKS.
### Шифрование внешних накопителей
Внешние накопители созданы для того, чтобы их подключали к разным устройствам, быстро обмениваясь информацией, таскали с собой по работе и иногда… теряли. Я находил случайно оставленные диски в USB-портах компьютеров в вестибюле отелей, в принтерах бизнес-центров, диски, потерянные в учебных аудиториях и даже в прачечной. Вряд ли их владельцы хотели бы, чтобы кто-то нашёл эти накопители и добрался до рабочих документов или личных архивов.
LUKS вместе с утилитой Cryptsetup позволяет шифровать внешние накопители почти так же просто, как и при инсталляции ОС.
### Как это сделать с помощью LUKS
**ВАЖНО:** внешний накопитель должен быть либо пустым, либо содержать ненужные вам данные. Так что, если оба этих условия не выполнены, нулевым шагом должен стать бэкап.
#### 1. Подключите и найдите свой внешний диск
Я для примера взял небольшую флэшку. Представим, что путь к ней выглядит как /dev/sdX. Утилита lsblk покажет мне вот такую информацию о блочных устройствах:
```
$ lsblk
sda 8:0 0 111.8G 0 disk
sda1 8:1 0 111.8G 0 part /
sdb 8:112 1 57.6G 0 disk
sdb1 8:113 1 57.6G 0 part /mydrive
sdX 8:128 1 1.8G 0 disk
sdX1 8:129 1 1.8G 0 part
```
Всё правильно, моя флэшка обнаружена. Да, это именно она. Я точно знаю, что её размер 1.8Gb. В списке всего один диск (disk) с таким размером (ему соответствует один раздел part).
Я уделяю такое внимание этой, казалось бы, мелочи, так как дисков может быть много. И в случае ошибки на следующем шаге вы сотрёте с другого диска данные, которые вам всё ещё нужны.
#### 2. Очистите диск
На этом шаге я обнуляю таблицу разделов диска:
```
$ sudo dd if=/dev/zero of=/dev/sdX count=4096
```
Это, конечно, необязательно, но я люблю это состояние чистого листа.
#### 3. Отформатируйте диск под LUKS
Используем для этого утилиту Cryptsetup. Её подкоманда luksFormat запускает первый этап создания зашифрованного раздела LUKS (позже мы создадим там файловую систему).
После этого появится предупреждение об удалении всех данных (которые могли всё ещё оставаться на диске). Кроме того, вас попросят придумать и ввести парольную фразу для диска.
```
$ sudo cryptsetup luksFormat /dev/sdX
WARNING!
========
This will overwrite data on /dev/sdX irrevocably.
Are you sure? (Type uppercase yes): YES
Enter passphrase:
Verify passphrase:
```
#### 4. Откройте LUKS-том
Процесс создания зашифрованного раздела завершён. Теперь для продолжения работы с диском нужно вводить парольную фразу. Открыть произвольный LUKS-том (то есть, подключить виртуальное блочное устройство) можно с помощью подкоманды open.
```
$ cryptsetup open /dev/sdX vaultdrive
```
Я придумал фразу (а точнее, просто пароль в одно слово) «vaultdrive». У вас будет какой-то свой вариант. Чтобы посмотреть список открытых томов, нужно вывести содержимое каталога /dev/mapper:
```
$ ls /dev/mapper
control vaultdrive
```
Чтобы закрыть LUKS-том vaultdrive нужно написать:
```
$ cryptsetup close vaultdrive
```
После этого он исчезнет из каталога /dev/mapper.
#### 5. Создайте файловую систему
```
$ sudo mkfs.xfs -f -L myvault /dev/mapper/vaultdrive
```
Создайте файловую систему, чтобы иметь возможность хранить свои данные на диске. Я выбрал XFS, но это далеко не единственный вариант: можно использовать, например, ext4 или JFS. И многие другие.
#### Финал: монтирование LUKS-тома
Можно делать это через терминал. Например, мы хотим использовать для нашей цели директорию /mnt/hd
```
$ sudo cryptsetup open /dev/sdX vaultdrive
$ sudo mount /dev/mapper/vaultdrive /mnt/hd
```
А рабочий стол KDE, например, позволяет указать диск для монтирования в специальном разделе с настройками. Но и там я тоже должен вводить пароль или парольную фразу, прежде чем произойдёт монтирование.
*Изображение*: Seth Kenlon, CC BY-SA 4.0
### P.S.
А какие инструменты для шифрования внешних дисков на Linux используете вы? Какие инструменты используете для аналогичных задач на macOS и Windows?
---
[Недорогие VDS](https://macloud.ru/?partner=8q1iv114w4) для любых задач. Используем новейшее железо, лучший дата-центр в Москве уровня надёжности TIER IV, бесплатно предоставляем защиту от DDoS-атак на любом тарифном плане, который можно создать самостоятельно в течение минуты.
*Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!*
[](https://macloud.ru/?partner=habr_footer) | https://habr.com/ru/post/552040/ | null | ru | null |
# Удобный способ тестирования React-компонентов
Я написал построитель дополнительных отчетов (custom reporter) для Jest и выложил на [GitHub](https://github.com/gnemtsov/jest-snapshots-book). Мой построитель называется Jest-snapshots-book, он создает HTML-книгу снимков компонентов React-приложения.
В статье речь пойдет о том, что такое Jest, snapshot-тестирование, для чего вообще понадобился дополнительный построитель отчетов и как их писать. В основном все это относится к тестированию React-компонентов, но теоретически можно применять при работе с любыми сериализуемыми данными.
React-компонент пагинатор
-------------------------
Для примера в статье будем тестировать компонент-пагинатор (**Paginator**). Он является частью нашего проекта-заготовки для создания бессерверных приложений в AWS ([GitHub](https://github.com/gnemtsov/ab-app)). Задача такого компонента — выводить кнопки для перехода по страницам таблицы или чего-то еще.
Это простой функциональный компонент без собственного состояния (stateless component). В качестве входных данных он получает из props общее количество страниц, текущую страницу и функцию-обработчик нажатия на страницу. На выходе компонент выдает сформированный пагинатор. Для вывода кнопок используется другой дочерний компонент **Button**. Если страниц много, пагинатор показывает их не все, объединяя их и выводя в виде многоточия.
**Код компонента-пагинатора**
```
import React from 'react';
import classes from './Paginator.css';
import Button from '../../UI/Button/Button';
const Paginator = (props) => {
const { tp, cp, pageClickHandler } = props;
let paginator = null;
if (tp !== undefined && tp > 0) {
let buttons = [];
buttons.push(
pageClickHandler(event, 'back'))}>
←
);
const isDots = (i, tp, cp) =>
i > 1 &&
i < tp &&
(i > cp + 1 || i < cp - 1) &&
(cp > 4 || i > 5) &&
(cp < tp - 3 || i < tp - 4);
let flag;
for (let i = 1; i <= tp; i++) {
const dots = isDots(i, tp, cp) && (isDots(i - 1, tp, cp) || isDots(i + 1, tp, cp));
if (flag && dots) {
flag = false;
buttons.push(
...
);
} else if (!dots) {
flag = true;
buttons.push(
pageClickHandler(event, i))}>
{i}
);
}
}
buttons.push(
pageClickHandler(event, 'forward'))}>
→
);
paginator =
{buttons}
}
return paginator;
}
export default Paginator;
```
**Код компонента-кнопки**
```
import React from 'react';
import classes from './Button.css';
const button = (props) => (
{props.children}
);
export default button;
```
Jest
----
Jest — это известная opensource-библиотека для модульного тестирования кода JavaScript. Она была создана и развивается благодаря Facebook. Написана на Node.js.
В общих чертах смысл тестирования сводится к тому, что вам нужно придумать входные параметры для вашего кода и тут же описать выходные данные, которые ваш код должен выдать. При выполнении тестов Jest выполняет ваш код с входными параметрами и сверяет результат с ожидаем. Если он совпал, тест пройдет, а если нет — не пройден.
Маленький пример с сайта [jestjs.io](https://jestjs.io).
Допустим, у нас есть модуль Node.js, который представляет собой функцию складывающую два числа (файл **sum.js**):
```
function sum(a, b) {
return a + b;
}
module.exports = sum;
```
Если наш модуль сохранен в файле, для его тестирования нам нужно создать файл **sum.test.js**, в котором написать такой код для тестирования:
```
const sum = require('./sum');
test('adds 1 + 2 to equal 3', () => {
expect(sum(1, 2)).toBe(3);
});
```
В данном примере с помощью функции **test** мы создали один тест с именем **'adds 1 + 2 to equal 3'**. Вторым параметром в функцию **test** мы передаем функцию, которая собственно и выполняет тест.
Тест состоит в том, что мы выполняем нашу функцию **sum** с входными параметрами **1** и **2**, передаем результат в функцию Jest **expect()**. Затем с помощью функции Jest **toBe()** переданный результат сравнивается с ожидаемым (**3**). Функция **toBe()** относится к категории проверочных функций Jest (matchers).
Для выполнения тестирования достаточно перейти в папку проекта и вызвать **jest** в командной строке. Jest найдет файл с расширением **.test.js** и выполнит тест. Вот такой результат он выведет:
```
PASS ./sum.test.js
✓ adds 1 + 2 to equal 3 (5ms)
```
Enzyme и snapshot-тестирование компонентов
------------------------------------------
Snapshot-тестирование — это относительная новая возможность в Jest. Смысл заключается в том, что с помощью специальной проверочной функции мы просим Jest сохранить снимок нашей структуры данных на диск, а при последующих выполнениях теста сравнивать новые снимки с ранее сохраненным.
Снимок в данном случае не что иное, как просто текстовое представление данных. Например, вот так будет выглядеть снимок какого-нибудь объекта (ключ массива тут является названием теста):
```
exports[`some test name`] = `
Object {
"Hello": "world"
}
`;
```
Вот так выглядит проверочная функция Jest, которая выполняет сравнение снимков (параметры необязательные):
```
expect(value).toMatchSnapshot(propertyMatchers, snapshotName)
```
В качестве **value** может выступать любая сериализуемая структура данных. В первый раз функция **toMatchSnapshot()** просто запишет снимок на диск, в последующие разы она уже будет выполнять сравнение.
Чаще всего такая технология тестирования используется именно для тестирования React-компонентов, а еще более точно, для тестирования правильности рендеринга React-компонентов. Для этого в качестве **value** нужно передавать компонент после рендеринга.
[Enzyme](http://airbnb.io/enzyme/) — это библиотека, которая сильно упрощает тестирование React-приложений, предоставляя удобные функции рендеринга компонентов. Enzyme разработан в Airbnb.
Enzyme позволяет рендерить компоненты в коде. Для этого есть несколько удобных функций, которые выполняют разные варианты рендеринга:
* полный рендеринг (как в браузере, full DOM rendering);
* упрощенный рендеринг (shallow rendering);
* статический рендеринг (static rendering).
Не будем углубляться во варианты рендеринга, для snapshot-тестирования достаточно статического рендеринга, которое позволяет получить статический HTML-код компонента и его дочерних компонентов:
```
const wrapper = render();
```
Итак, мы рендерим наш компонент и передаем результат в **expect()**, а затем вызываем функцию **.toMatchSnapshot()**. Функция **it** — это просто сокращенное имя для функции **test**.
```
...
const wrapper = render();
it(`Total = ${tp}, Current = ${cp}`, () => {
expect(wrapper).toMatchSnapshot();
});
...
```
При каждом выполнении теста **toMatchSnapshot()** сравнивает два снимка: ожидаемый (который был ранее записан на диск) и актуальный (который получился при текущем выполнении теста).
Если снимки идентичны, тест считается пройденным. Если в снимках есть различие, тест считается не пройденным, и пользователю показывается разница между двумя снимками в виде diff-а (как в системах контроля версий).
Вот пример вывода Jest, когда тест не пройден. Тут мы видим, что у нас в актуальном снимке появилась дополнительная кнопка.
В этой ситуации пользователь должен решить, что делать. Если изменения снимка запланированные ввиду изменения кода компонента, то он должен перезаписать старый снимок новым. А если изменения неожиданные, значит нужно искать проблему в своем коде.
Приведу полный пример для тестирования пагинатора (файл **Paginator.test.js**).
Для более удобного тестирования пагинатора я создал функцию **snapshoot(tp, cp)**, которая будет принимать двa параметрa: общее количество страниц и текущую страницу. Эта функция будет выполнять тест с заданными параметрами. Дальше остается только вызывать функцию **snapshoot()** с различными параметрами (можно даже в цикле) и тестировать, тестировать…
```
import React from 'react';
import { configure, render } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';
import Paginator from './Paginator';
configure({ adapter: new Adapter() });
describe('Paginator', () => {
const snapshoot = (tp, cp) => {
const wrapper = render();
it(`Total = ${tp}, Current = ${cp}`, () => {
expect(wrapper).toMatchSnapshot();
});
}
snapshoot(0, 0);
snapshoot(1, -1);
snapshoot(1, 1);
snapshoot(2, 2);
snapshoot(3, 1);
for (let cp = 1; cp <= 10; cp++) {
snapshoot(10, cp);
}
});
```
Зачем понадобился построитель дополнительных отчетов
----------------------------------------------------
Когда я начал работать с этой технологией тестирования, чувство недоделанности изначального подхода не покидало меня. Ведь снимки можно просматривать только в виде текста.
А что если какой-нибудь компонент при рендеринге дает много HTML-кода? Вот компонент-пагинатор, состоящий из 3 кнопок. Снимок такого компонента будет выглядеть так:
```
exports[`Paginator Total = 1, Current = -1 1`] = `
←
1
→
`;
```
Сперва нужно убедиться, что исходная версия компонента правильно рендерится. Не очень-то удобно это делать, просто просматривая HTML-код в текстовом виде. А ведь это всего три кнопки. А если нужно тестировать, например, таблицу или что-то еще более объемное? Причем для полноценного тестирования нужно просматривать множество снимков. Это будет довольно неудобно и тяжело.
Затем, в случае не прохождения теста, вам нужно понять, чем отличается внешний вид компонентов. Diff их HTML-кода, конечно, позволит понять, что изменилось, но опять-таки возможность воочию посмотреть разницу не будет лишней.
В общем я подумал, что надо бы сделать так, чтобы снимки можно было просматривать в браузере в том же виде, как они выглядят в приложении. В том числе с примененными к ним стилями. Так у меня появилась идея улучшить процесс snapshot-тестирования за счет написания дополнительного построителя отчетов для Jest.
Забегая вперед, вот что у меня получилось. Каждый раз при выполнении тестов мой построитель обновляет книгу снимков. Прямо в браузере можно просматривать компоненты так, как они выглядят в приложении, а также смотреть сразу исходный код снимков и diff (если тест не пройден).
Построители дополнительных отчетов Jest
---------------------------------------
Создатели Jest предусмотрели возможность написания дополнительных построителей отчетов. Делается это следующим образом. Нужно написать на Node.JS модуль, который должен иметь один или несколько из этих методов: **onRunStart**, **onTestStart**, **onTestResult**, **onRunComplete**, которые соответствуют различным событиями хода выполнения тестов.
Затем нужно подключить свой модуль в конфиге Jest. Для этого есть специальная директива **reporters**. Если вы хотите дополнительно включить свой построитель, то нужно добавить его в конец массива **reporters**.
После этого Jest будет вызывать методы из вашего модуля при наступлении определенных этапов выполнения теста, передавая в методы текущие результаты. Код в данных методах собственно и должен создавать дополнительные отчеты, которые вам нужны. Так в общих чертах выглядит создание дополнительных построителей отчетов.
Как устроен Jest-snapshots-book
-------------------------------
Код модуля специально не вставляю в статью, так как буду еще его улучшать. Его можно найти на моем GitHub, это файл [src/index.js](https://github.com/gnemtsov/jest-snapshots-book/blob/master/src/index.js) на странице проекта.
Мой построитель отчета вызывается по завершению выполнения тестов. Я поместил код в метод **onRunComplete(contexts, results)**. Он работает следующим образом.
В свойстве **results.testResults** Jest передает в эту функцию массив результатов тестирования. Каждый результат тестирования включает путь к файлу с тестами и массив сообщений с результатами. Мой построитель отчета ищет для каждого файла с тестами соответствующий файл со снимками. Если файл снимков обнаружен, построитель отчета создает HTML-страницу в книге снимков и записывает ее в папку snapshots-book в корневой папке проекта.
Для формирования HTML-страницы построитель отчета с помощью рекурсивной функции **grabCSS(moduleName, css = [], level = 0)** собирает все стили, начиная с самого тестируемого компонента и дальше вниз по дереву всех компонентов, которые он импортует. Таким образом, функция собирает все стили, которые нужны для корректного отображения компонента. Собранные стили добавляются в HTML-страницу книги снимков.
В своих проектах я использую CSS-модули, поэтому не уверен, что это будет работать, если CSS-модули не используются.
В случае, если тест пройден, построитель вставляет в HTML-страницу iFrame со снимком в двух вариантах отображения: исходный код (снимок, как он есть) и компонент после рендеринга. Вариант отображения в iFrame меняется по клику мышкой.
Если же тест не был пройден, то все сложнее. Jest предоставляет в этом случае только то сообщение, которое он выводит в консоль (см. скриншот выше).
Оно содержит diff-ы и дополнительные сведения о не пройденном тесте. На самом деле в этом случае мы имеем дело в сущности с двумя снимками: ожидаемым и актуальным. Если ожидаемый у нас есть — он хранится на диске в папке снимков, то актуальный снимок Jest не предоставляет.
Поэтому пришлось написать код, который применяет взятый из сообщения Jest diff к ожидаемому снимку и создает актуальный снимок на основе ожидаемого. После этого построитель выводит рядом с iFrame ожидаемого снимка iFrame актуального снимка, который может менять свое содержимое между тремя вариантами: исходный код, компонент после рендеринга, diff.
Вот так выглядит вывод построителя отчета, если установить для него опцию verbose = true.
Полезные ссылки
---------------
* [Jest-snapshots-book](https://github.com/gnemtsov/jest-snapshots-book/)
* [Исходный код модуля](https://github.com/gnemtsov/jest-snapshots-book/blob/master/src/index.js)
* [Варианты рендеринга Enzyme](https://airbnb.io/enzyme/docs/api/)
* [Snapshot-тестирование](https://jestjs.io/docs/en/snapshot-testing)
* [Директива reporters конфига Jest](https://jestjs.io/docs/en/configuration.html#reporters-array-modulename-modulename-options)
PS
--
Snapshot-тестирования не достаточно для полноценного тестирования React-приложения. Оно покрывает только рендеринг ваших компонентов. Нужно еще тестировать их функционирование (реакции на действия пользователей, например). Однако snapshot-тестирование — это очень удобный способ быть уверенным, что ваши компоненты рендерятся так, как было задумано. А jest-snapshots-book делает процесс чуточку легче. | https://habr.com/ru/post/421647/ | null | ru | null |
# Легкая публикация PEAR-пакетов
Скажу сразу: у меня создание PEAR-канала и публикация пакета заняли около часа. Но, если отбросить все тупиковые способы, сэкономить на гуглении, и не использовать сомнительные утилиты, то вполне возможно уложиться в 10 минут.
У PHP программистов больше поводов не любить PEAR, чем любить. Действительно, создается впечатление, что за последние 5 лет ни библиотеки в репозиториях, ни сам инсталлятор, практически не изменились.
Тем не менее, до сих пор, установить PHP-бибиотеку проще всего посредством PEAR. Это, конечно, при условии, что она будет одинаково востребована для всей системы. Например, такие продукты, как PHPUnit и Docblox устанавливаются именно через PEAR, и крайне неудобно устанавливать их другими способами: например, клонированием GitHub репозитория.
Скорее всего у вас есть библиотека, которой вы бы хотели поделиться с сообществом. Ну или когда-то появится. Это не важно. Важно то, что рано или поздно вам захочется сделать так, чтобы ваш продукт можно было установить всего в 2 команды…
Такое вот вступление. Дальше будут чисто практические рекомендации.
Одна из них: документация с сайта pear.php.net может не только помочь, но и навредить. Разбираться во всех этих PEAR, PEAR2, Pyrus, PEAR\_PackageFileManager2, а также в структуре package.xml, равносильно изучению служебных инструкций какой-нибудь атомной станции. Вот увидите, мы сможем обойтись без всего этого. Кроме того, мы ограничены во времени, а на изучение лишних деталей 10 минут нам точно не хватит. И часа тоже.
Мы будем прагматиками, рационалистами, ну и просто лентяями.
Например, нам лень создавать свой PEAR-сервер где-то у себя на хостинге. Да и зачем? Лучше приспособить под это дело GitHub.
Для начала нам понадобится [Pirum](http://pirum.sensiolabs.org/). Это легковесный менеджер PEAR-каналов.
Устанавливается он, как ни странно, тоже через PEAR:
```
$ pear channel-discover pear.pirum-project.org
$ pear install pirum/Pirum
```
Сам сервер, настроенный под GitHub можно взять тут: [github.com/saucelabs/pear](https://github.com/saucelabs/pear)
Следуем инструкции:
Создаем репозиторий pear на гитхабе.
Создаем локальный репозиторий:
```
$ mkdir pear
$ cd pear
$ git init
$ git remote add origin git@github.com:[username]/pear.git
```
Создаем конфигурационный файл pirum.xml:
```
xml version="1.0" encoding="UTF-8" ?
[username].github.com/pear
[channel name]
[shortname]
http://[username].github.com/pear
```
Выполняем команды
```
$ pirum build .
$ git add .
$ git commit -m "Initial server build"
```
Заливаем наш репозиторий на гитхаб, под видом гитхаб страниц:
```
$ git branch -m master gh-pages
$ git push origin gh-pages
```
Напомню, гитхаб позволяет вам захостить свой статический сайт, для него и используется специальная ветка: gh-pages.
После того как мы залили репозиторий на сервер, по адресу https://[username].github.com/pear уже будет находится новый канал.
Там, кстати и инструкции его использованию. Жаль только поставить оттуда пока нечего.
Исправим этот недочет. Нам нужен правильно созданный pear-пакет для нашей библиотеки.
Создать его поможет утилита [Pearfarm](http://pearfarm.org/). Это не только утилита, а ещё и сайт с хостингом pear-пакетов, но к сожалению, особой популярностью он не пользуется.
По сути, нам и не нужно было бы проходить вышеизложенные шаги, если бы было больше уверенности в Pearfarm.
Впрочем, сама утилита работает и существенно упрощает жизнь при создании пакета с нуля.
Устаналиваеем её… Правильно, тоже через PEAR:
```
$ pear install pearfarm.pearfarm.org/pearfarm
```
В каталоге с вашей библиотекой выполните команду:
```
$ pearfarm init
```
Она создает файл pearfarm.spec, назовем его метапакетом. По сути это PHP-файл, который в удобной форме определяет настройки для создания пакета.
Вот он:
```
php
$spec = Pearfarm_PackageSpec::create(array(Pearfarm_PackageSpec::OPT_BASEDIR = dirname(__FILE__)))
->setName('[dirname]')
->setChannel('TODO: Release channel here')
->setSummary('TODO: One-line summary of your PEAR package')
->setDescription('TODO: Longer description of your PEAR package')
->setReleaseVersion('0.0.1')
->setReleaseStability('alpha')
->setApiVersion('0.0.1')
->setApiStability('alpha')
->setLicense(Pearfarm_PackageSpec::LICENSE_MIT)
->setNotes('Initial release.')
->addMaintainer('lead', 'TODO: Your name here', 'TODO: Your username here', 'TODO: Your email here')
->addGitFiles()
->addExecutable('[dirname]')
;
```
Вам остается пройтись по всем полям и заполнить их. Обратите внимание как легко заполняется лицензия! По умолчанию в пакет попадут все файлы из гит-репозитория, можете убрать некоторые из них с помощью метода addExcludeFilesRegex().
Больше информации по конфигурции тут: [pearfarm.org/help/spec](http://pearfarm.org/help/spec)
После заполнения всех полей подключимся к нашему pear-каналу:
```
$ pear channel-discover [username].github.com/pear
```
И создадим пакет.
```
$ pearfarm build
```
И если всё прошло хорошо, на выходе вы получите файл package.xml (конфигурация пакета для PEAR) и свежий билд вашей библиотеки в архиве.
Добавляем билд на сервер:
```
$ pirum add [путь-к-нашему-pear-репозиторию] [путь-к-билду]
```
Заливаем обновленный сервер на гитхаб:
```
$ git add .
$ git commit -m "first package added"
$ git push origin gh-pages
```
Готово! Теперь вы можете с легкостью публиковать свои open-source библиотеки и больше не прятать их в недрах локальных веб-серверов.
А чтобы убедиться в том, что всё работает, давайте зайдем на:
http://[username].github.com/pear/
И увидим, что наш пакет уже там. Все команды для установки вашей библиотеки тоже там указаны.
Создавайте полезные библиотеки, публикуйте их, пишите о них на Хабре.
Спасибо за внимание.
Также отмечу, что:
— На винде всё работает.
— Не стоит использовать верхний регистр в названии сервера каналов. PEAR с ними не дружит. | https://habr.com/ru/post/134833/ | null | ru | null |
# Разбираемся в сортах реактивности
Здравствуйте, меня зовут Дмитрий Карловский и я… прилетел к вам на турбо-реактивном самолёте. Основная суть реактивного двигателя изображена на картинке.
Тут, казалось бы, хаотичное взаимодействие между молекулами, приводит к тому, что улетающие молекулы опосредованно передают импульс корпусу двигателя. Что ж, давайте подумаем, как реактивные принципы решают или наоборот усугубляют проблемы в программировании. Сравним различные подходы к реактивному программированию. И вытащим на поверхность все их подводные камни.
Это — текстовая расшифровка выступления на [SECON.Weekend Frontend'21](https://vk.com/event207371976). Вы можете [посмотреть видео запись](https://youtu.be/__iGudoQUN8), [прочитать как статью](https://github.com/nin-jin/slides/tree/master/reactivity), либо [открыть в интерфейсе проведения презентаций](https://nin-jin.github.io/slides/reactivity/).
Человек-реактив
===============
Сперва вкратце о себе:
* 🎶 15 лет во фронтенде
* 🧪 6 лет с реактивами
* 😭 Пилил на Angular, RXJS и MobX
* ✨ Свои реактивные либы с уникальными фичами
* 💞 Целый фреймворк на их основе ($mol)
Реактивность я крутил вдоль и поперёк, словил на этой почве кучу инсайтов, которыми с вами далее и поделюсь.
Огнеопасно!
===========
Я постараюсь быть максимально объективен, но… возможны побочные эффекты.
* 💥 Жжение в нижних отделах спины
* 👐 Зуд на кончиках пальцев
* 📢 Повышение громкости речевого аппарата
* 🧠 Усиленная напряжённость в области извилин
Надеюсь вы хорошо подкрепились, ибо доклад будет долгим, насыщенным и во многом противоречащим привычной картине мира.
Виды активностей
================
Начнём издалека. Какие бывают виды активностей в нашем коде?
* 🌠Интерактивность
* 🚀Реактивность
🌠Интерактивность
----------------
Система выполнила только то, что просили… И ждёт дальнейших команд.
Все остальные части системы, если на них посмотреть, теперь находятся в неактуальном состоянии. Так что требуется явно пойти и попросить их тоже обновиться.
🚀Реактивность
-------------
Система выполнила то, что просили… Плюс сама обновила всё приложение, так как знает как разные состояния зависят друг от друга.
Теперь, если посмотреть на любое состояние, оно будет соответствовать внесённым изменениям. Хотя мы явно этого не просили.
Что нужно для реактивности?
===========================
Реактивность позволяет значительно снизить сложность реализации надёжных программ. Поэтому давайте разберём, что нам потребуется для её реализации:
* 📦Состояния
* 🎬Акции
* 💨Реакции
* 💫Инварианты
* 🌉Каскад
* 🧙♂️Рантайм
📦Состояния
----------
Прежде всего нам нужны *состояния* (states) — контейнеры, хранящие некоторые значения.
🎬Акции
------
Сами по себе состояния бесполезны, пока мы не можем с ними взаимодействовать. Поэтому нам нужны *действия* (actions), чтобы их изменять.
💨Реакции
--------
Но изменение состояний, без возможности их увидеть, тоже не имеет смысл. Поэтому нам нужны *реакции* (reactions) — некоторые процедуры, которые запускаются при изменении состояния и производят побочные эффекты.
💫Инварианты
-----------
Если побочным эффектом реакции является обновление другого состояния, то мы получаем *инвариант* (invariant) — соотношение, между состояниями, которое сохраняется неизменным при любых изменениях этих состояний.
Инвариант может быть выражен явно, как, например, формула в электронной таблице. Так и собираться в коде из других абстракций. Например, как комбинация из обработчика события, стрима трансформаций и побочного эффекта. Или, например, шаблон, формирующий DOM из параметров компонента.
🌉Каскад
-------
Прелесть инвариантов в том, что мы можем провязать ими все состояния приложения в единый граф.
Таким образом изменение одного состояния *каскадно* (cascaded) отразится на всём приложении автоматически. То есть мы получили ту самую реактивность.
🧙♂️Рантайм
-----------
И чтобы реактивность, наконец, заработала, нам нужен некоторый *рантайм* (runtime), который будет отслеживать изменения одних состояний и обновлять значения других в соответствии с заданными нами инвариантами.
Если вы не понимаете как он работает, то для вас реактивность будет выглядеть как магия. Но стоит только разобраться, и это становится ещё одной технологией в вашем арсенале.
Общие пожелания к реактивности
==============================
Давайте сформулируем, какие качества мы хотим получить от реактивности, а какие, наоборот, избежать:
* 🤹♂️ Отсутствие ненужных вычислений
* 🐵 Стабильность поведения
* 🐘 Минимальное потребление памяти
* 💫 Согласованность состояний
🤹♂️ Отсутствие ненужных вычислений
-----------------------------------
Лишние вычисления сами по себе постепенно замедляют приложение. Но это пол беды. Каждое лишнее вычисление приводит к другим лишним вычислениям. В результате чего лишние вычисления растут как снежный ком.
Поэтому, чем раньше мы их остановим, тем меньше ресурсов суммарно потратим. А значит получим более отзывчивое приложение, меньше жрущее батарейку.
🐵 Стабильность поведения
------------------------
После изменения состояния, результат должен быть такой же, как старт с нуля в этом же состоянии. Иначе реальное поведение у пользователя может отличаться от того, на котором отлаживает разработчик.
Звучит, вроде бы, самоочевидно, но вы ужаснётесь, когда узнаете, что стабильность поведения почти нигде не гарантируется. В результате возможна ситуация, когда программист взял тот же самый код, открыл те же самые окошки, ввёл те же самые значения… но у пользователя баг есть, а у программиста он не воспроизводится. И тут начинается весёлая отладка.
🐘 Минимальное потребление памяти
--------------------------------
Важно понимать, что вся эта реактивность весьма не бесплатна. Помимо собственно значений, приходится хранить разную мета-информацию, объём которой может быть в несколько раз больше.
Возьмём, например, V8 и посмотрим сколько требуют памяти разные типы данных в самом оптимистичном случае, когда JIT всё максимально оптимизировал.
| Value | Place | Cost |
| --- | --- | --- |
| Obj | Heap | 12 |
| Array | Heap | 24 |
| Unit | Inplace | 4 |
| Int | Inplace | 4 |
| Float | Heap | 12 |
| BigInt | Heap | 16+ |
| String | Heap | 12+ |
| Ref | Inplace | 4 |
| Closure | Heap | 24 |
| Context | Heap | 16 |
То, что лежит в Heap кушает дополнительные 4 байта на ссылку (Ref). Unit — это всякие undefined, null, false, true и прочие малые невариативные примитивные значения. Int после миллиарда хранится уже как Float, мантисса которого — 48 бит. Обратите внимание, что это уже ссылочный тип, как и BigInt, а значит кушает дополнительно 4 байта на ссылку. Контекст для замыкания хранится, только если функция замкнута на какие-либо переменные. Размер контекста, соответственно, зависит от числа этих переменных. Как видно (Inplace), каждая переменная добавляет к контексту по 4 байта.
Несложно заметить, что объекты относительно дёшевы. Массивы уже подороже, ибо это фактически составные объекты. А вот замыкания — это очень дорогие штуки сами по себе, даже без учёта хранимых в них данных.
Приведу несколько примеров расчёта потребления памяти:
```
function make_ints_state( ... state: number[] ) {
return { get: ()=> state }
}
const state1 = make_ints_state( 777 )
// Ref + Obj + Ref + Closure + Ref + Context + Ref + Array + Int
// 4 + 12 + 4 + 24 + 4 + 16 + 4 + 24 + 4 = 96
const state2 = { state: 777 }
// Ref + Obj + Int
// 4 + 12 + 4 = 20
const state3 = 777
// Int
// 4
```
Резюмируя: в зависимости от выбранных абстракций, потребление памяти может отличаться на порядок. И если разница между 1 и 10 мегабайтами не особо заметна. То разница между 100 мегабайтами и гигабайтом заметна будет однозначно. В лучшем случае всё будет тормозить. А в худшем приложение просто закрешится.
Пример из жизни: открываем в Google Docs спецификацию XPath на 200 страниц и получаем пол гигабайта потребления памяти.
Или другой пример: я сейчас работаю над новой реализацией реактивности. И пока летел вчера в самолёте, медитировал над этой табличкой. В результате, я сообразил, как уменьшить потребление памяти в 2 раза, превратив объект с двумя массивами в… просто один массив. Разумеется, мне для этого потребовалось так не модное сейчас наследование.
💫 Согласованность состояний
---------------------------
Ну и, конечно же, все состояния приложения должны быть согласованы между собой в любой момент времени.
Если пользователь (или другая программная система), пусть даже на мгновение, увидит рассогласование, то в лучшем случае он будет обескуражен. В худшем — и вы, и он потеряете деньги, репутацию и прочие плюшки.
Аспекты реактивности
====================
Теперь разберём различные аспекты реализации реактивности, на которые стоит обратить внимание при выборе архитектуры, библиотек и фреймворков:
* **Style**: Стилистика кода
* **Watch**: Наблюдение за изменениями
* **Dupes**: Эквивалентные изменения
* **Origin**: Инициатор пересчёта
* **Tonus**: Энергичность реакций
* **Order**: Порядок реакций
* **Flow**: Конфигурация потоков данных
* **Error**: Нештатные ситуации
* **Cycle**: Циклические зависимости
* **Depth**: Ограничение глубины
* **Atomic**: Атомарность изменений
* **Extern**: Внешние взаимодействия
Style: Стилистика кода
----------------------
Условно можно выделить 3 стиля написания кода:
* 🧐Proc: Процедурный
* 🤯Func: Функциональный
* 🤓Obj: Объектный
Разные библиотеки могу смешивать их в разных пропорциях, но как правило есть чёткое тяготение к одному из них.
### 🧐Proc: Процедурный стиль
Тут эпизодически запускается процедура обновления, которая читает одни состояния, вычисляет другие и записывает их. Напишем простейшую, хоть и не очень эффективную, реализацию:
```
let Name = 'Jin'
let Count
let Short
setInterval( ()=> {
Count = Name.length
} )
setInterval( ()=> {
Short = Count < 4
} )
```
Примерно так описываются инварианты, например, в Meteor и Angular по дефолту. Разумеется они запускают пересчёт не на каждую миллисекунду, а более оптимально, но общую суть это слабо меняет: рантайм периодически перезапускает инварианты, не зная какие состояния могут быть ими изменены. А ведь актуальные значения этих состояний могут нам быть не интересны, но вычисляются они в любом случае. Поэтому такой подход получается всё равно не очень эффективным.
### 🤯Func: Функциональный стиль
На волне хайпа многие упарываются по чистым функциям, превращая свой код в головоломку:
```
const Name = new BehaviorSubject( 'Jin' )
const Count = Name.pipe(
map( Name => Name.length ),
distinctUntilChanged(),
debounceTime(0),
share(),
)
const Short = Count.pipe(
map( Count => Count < 4 )
distinctUntilChanged(),
debounceTime(0),
share(),
)
```
Что и зачем делает этот код на RxJS не сможет сходу сказать даже опытный *стример*. А это ведь самый простой пример, далёкий от реальной жести.
Однако, умные программисты очень любят головоломки. Поэтому они тратят кучу времени на изучение хитрых абстракций, одинаково далёких как от того, как работает машина, так и от того, как работает мозг человека. Они пишут лаконичный, но замысловатый код. И гордятся тем, что они понимают то, что мало кто ещё способен понять. На проекте же это сказывается скорее негативно, привнося излишнюю сложность туда, где и без того полно не простых вещей.
Раньше я тоже писал хитрый код, но жизнь меня научила, что лучше писать максимально простой код, доступный даже новичку в программировании, а не только победителям олимпиад по информатике.
Кроме того, обилие замыканий, свойственных функциональному коду, приводит к повышенному потреблению памяти.
### 🤓Obj: Объектный стиль
Тут программа состоит из множества объектов, обладающих состояниями, связанных инвариантами в единый граф. Код в этом стиле выглядит так же, как и обычный ООП код, но с добавлением реактивных мемоизаторов:
```
class State {
@mem Name( next = 'Jin' ) {
return next
}
@mem Count() {
return this.Name().length
}
@mem Short() {
return this.Count() < 4
}
}
```
Многие, наверняка, слышали утверждение, что "инвалидация кешей — один из сложнейших вопросов в программировании". Так вот, в реактивном рантайме, такой вопрос вообще не стоит.
Этот подход мне видится наиболее оптимальным, так как он хорошо укладывается в то, как мыслит человек (а ему привычно взаимодействовать с объектами), и в то, как работает компьютер (объект — это просто мутабельная структура в памяти). Рантайм чётко понимает какой метод какое состояние вычисляет. А объектная декомпозиция позволяет легко это всё масштабировать. Именно поэтому объектный стиль и используется в $mol, MobX и Vue.
Watch: Наблюдение за изменениями
--------------------------------
Как рантайм может узнать об изменениях?
* 🔎Polling: Периодическая сверка
* 🎇Events: Возникновение события
* 🤝Links: Список подписчиков
### 🔎Polling: Периодическая сверка
Состояния хранят лишь значения и всё. Рантайм периодически сверяет текущее значение с предыдущим. И если они отличаются — запускает реакции.
```
// sometimes
if( state !== state_prev ) reactions()
```
Так, например, работает Angular, Svelte, React. Беда этого подхода в том, что на каждый чих выполняется большой объём работы только лишь для того, чтобы выяснить, что почти ничего не поменялось.
Вам может показаться, что обычное сравнение — это плёвая операция. И это действительно так в синтетических бенчмарках. Но в реальности состояния разбросаны по памяти, что даёт посредственное использование процессорных кешей. А вишенка на торте — такие сверки приходится выполнять после каждой реакции, чтобы выяснить, что именно оные поменяли в состоянии.
### 🎇Events: Возбуждение события
Каждое состояние хранит дополнительно список функций обработчиков изменения. При каждом изменении состояния вызываются все подписчики.
```
// on change
for( const reaction of this.reactions ) {
reaction()
}
```
Это может быть инициировано вручную, через сеттер или прокси. Но в любом случае состояние ничего больше не знает про соседние состояния, а взаимодействие всегда одностороннее. Это сильно ограничивает возможные алгоритмы оптимизации. А также усложняет отладку, ведь чтобы узнать кто там от кого как зависит — это целый квест.
А самое печальное: хранение массива из замыканий кушает много памяти. И с этим ничего не сделать.
### 🤝Links: Список подписчиков
Состояния хранят прямые ссылки друг на друга, образуя глобальный граф. Массивы ссылок — это относительно экономно по памяти, ведь каждая ссылка — это всего 4-8 байта. Для коммуникации с соседями достаточно просто пробежаться по массиву и дёрнуть нужный метод у соседнего стейта.
```
// on change
for( const slave of this.slaves ) {
slave.obsolete()
}
// on complete
for( const master of this.masters ) {
master.finalize()
}
```
В первом примере вы видите, что при изменении одного состояния мы говорим всем зависимым, что они устарели. А во втором, что при завершении вычисления одного состояния, мы говорим всем зависимостям, что вычисление закончено, и можно освободить кеши, которые они могли держать на случай повторного обращения. Таких вариантов взаимодействия может быть много, что даёт максимум гибкости в поддерживаемых алгоритмах.
Кроме того, при отладке, гораздо проще ходить по прямым ссылкам между объектами, чем выцеплять нужную информацию из захваченных замыканиями контекстов.
Dupes: Эквивалентные изменения
------------------------------
Порой значение меняется на эквивалентное. И тут есть разные подходы к отсечению вырожденных вычислений..
* 👯♀️Every: Реакция на каждое действие
* 🆔Identity: Сравнение по ссылке
* 🎭Equality: Структурное сравнение
### 👯♀️Every: Реакция на каждое действие
В библиотеках типа RxJS каждое значение является уникальным событием, что приводит к ненужному запуску реакций.
```
777 != 777
```
Чтобы этого не происходило, нужно писать дополнительный код, который часто забывают, и потом огребают.
### 🆔Identity: Сравнение по ссылке
Многие библиотеки всё же умеют сравнивать значения. И если состояние не поменялось, то реакции не срабатывают. А если поменялось, даже на эквивалентное значение, то срабатывают.
```
777 == 777
[ 1, 2, 3 ] != [ 1, 2, 3 ]
```
Если мы нафильтровали новый массив, с тем же содержимым, то скорее всего нам не нужно запускать каскад вычислений. Но вручную уследить за всеми такими местами — мало реалистично.
### 🎭Equality: Структурное сравнение
Наиболее продвинутые библиотеки, типа $mol\_atom2, делают глубокое сравнение нового и старого значения.
```
777 == 777
[ 1, 2, 3 ] == [ 1, 2, 3 ]
[ 1, 2, 3 ] != [ 3, 2, 1 ]
```
Это позволяет отсекать лишние вычисления как можно раньше — в момент внесения изменений. А не в момент рендеринга заново сгенерированного VDOM в реальный DOM, как это часто происходит в React, чтобы узнать, что в доме-то менять и нечего.
Глубокое сравнение — это, безусловно, сама по себе более дорогая операция, чем просто сравнение двух ссылок. Однако, рано или поздно, сравнить всё содержимое всё равно придётся. Но гораздо быстрее это сделать пока данные рядом, а не когда они разлетятся по тысяче компонент в процессе рендеринга.
Origin: Инициатор пересчёта
---------------------------
Не смотря на то, что начинается всё с того, что кто-то что-то поменял, финальное решение пересчитывать ли тот или иной инвариант может принимать как зависимость, так и зависимое состояние.
* 🥌Push: Зависимость проталкивает
* 🚂Pull: Зависимый затягивает
### 🥌Push: Зависимость проталкивает
При изменении зависимости безусловно срабатывают реакции, которые вычисляют и пишут в зависимые состояния новые значения. Так, например, работает RxJS, Effector и другие процедурные/функциональные библиотеки/фреймворки.
И это отлично работает для статичного графа инвариантов. Однако, в любом не совсем тривиальном приложении у нас есть динамика. Ну, банально: если мы переключаемся между страницами, то надо освободить ресурсы предыдущей страницы (и в частности отписаться от изменения данных) и захватить ресурсы для новой страницы (и в частности подписаться на изменения данных).
То есть наш граф инвариантов должен уметь меняться в процессе пересчёта этих инвариантов. А это значит, что действуя по принципу проталкивания мы будем часто попадать в ситуации вида: долго-долго вычисляли какое-то значение, а оно в итоге никому не понадобилось, ибо потребитель был уничтожен.
### 🚂Pull: Зависимый затягивает
При обращении к зависимому состоянию, происходит вычисление инварианта, который вытягивает значения из зависимостей и возвращает актуальное значение. Так работают $mol\_atom2, CellX, MobX и Vue.
Тут уже чисто логически нам всегда известно, что если вычисление произошло, то его результат кому-то нужен. А если не нужен, то и вычисления не произойдёт. Поэтому подход с затягиванием видится мне более практичным.
Tonus: Энергичность вычислений
------------------------------
Вычислять зависимые состояния можно как можно раньше, а можно как можно позже, вплоть до отказа от вычислений, если это возможно.
* 🍔Instant: Мгновенные
* ⏰Defer: Отложенные
* 🦥Lazy: Ленивые
### 🍔Instant: Мгновенные реакции
В таких библиотеках, как RxJS, пересчёт зависимых состояний происходит сразу же при изменении зависимости. Если нам нужно изменить несколько состояний подряд, то это может привести к лишним вычислениям.
Более того, эти лишние промежуточные вычисления производят неконсистентное состояние, вычисляемое частично из уже обновлённых состояний, а частично из ещё не обновлённых. А неконсистентное состояние, пусть даже и временно, — это очень опасная штука. В лучшем случае пользователь будет наблюдать *глитчи* — визуальное мерцание. В худшем — приложение будет работать не корректно и сыпать разнообразными ошибками.
### ⏰Defer: Отложенные реакции
Чтобы избежать *глитчей* пересчёт может откладываться на потом, чтобы выполнять его лишь один раз, сколько бы зависимостей ни было обновлено.
Однако, пересчёт будет произведён в любом случае, даже если результат нам не пригодится.
### 🦥Lazy: Ленивые реакции
В моделях реактивности с затягиванием возможно ленивое вычисление инвариантов — только в момент, когда зависимое состояние действительно потребовалось.
При изменении исходных состояний, мы не вычисляем зависимые и даже не планируем их вычисление, а лишь помечаем их как устаревшие. И если впоследствии к ним обратиться, то они начнут вычисляться.
Это одновременно и самый экономный подход и самый консистентный, так как гарантирует, что, когда бы мы ни обратились к состоянию, полученное значение будет актуальным.
Order: Порядок реакций
----------------------
С порядком исполнения реакций есть свои особенности, которые зачастую отдаются на откуп рандому. Однако, давайте разберём все возможные варианты:
* 📰Subscribe: По времени подписки
* 🧨Event: По времени возникновения события
* 📶Deep: По глубине зависимости
* 👨💻Code: По положению в программе
### 📰Subscribe: Реагирование по времени подписки
Какая реакция появилась раньше, та и срабатывает раньше. В любом нетривиальном приложении, список реакций меняется со временем, а значит выстроиться они могут практически в любом порядке.
Получается скрытое состояние, влияющее на работу приложения через разный порядок побочных эффектов, которые могут давать различные взаимные наводки. Получаем нестабильность поведения, что осложняет отладку и тестирование.
Это — типичная беда большинства библиотек.
### 🧨Event: Реагирование по времени возникновения события
Предположим нам удалось тем или иным способом зафиксировать порядок подписок. Однако, есть и другой источник нестабильности — порядок совершения действий.
Явно или неявно изменяя состояния в разном порядке мы опять же можем получить разный порядок срабатывания реакций. К сожалению, большинство библиотек подвержено и этой проблеме.
### 📶Deep: По глубине зависимости
Некоторые библиотеки используют так называемую *топологическую сортировку графа*, чтобы пересчитывать инварианты в оптимальном порядке от менее зависимых к более зависимым.
В данном примере `Post` меняется на такой, к которому у нас нет доступа. Сначала будет обновлено содержимое этой страницы, что мало того, что приведёт к лишним пересчётам, так они ещё и могут закончиться ошибками или просто мусором в качестве побочных эффектов. И только потом, при при вычислении `Page` будет выяснено, что `PostPage` надо вообще уничтожить, а вместо неё следует отобразить сообщение об ошибке доступа `Forbidden`.
Обратите внимание, что существование `Title` и `Body` зависит от значения `Page`. Но сами значения `Title` и `Body` от значения `Page` уже не зависят. И наоборот, значение `Page` не зависит от значения `Title` и `Body`. То есть связь между ними нереактивная. Но она есть. И это уже связь "владелец — имущество". То есть значение `Page` владеет реактивными состояниями `Title` и `Body`, а значит и контролирует их время жизни.
Одним лишь анализом реактивного графа эту проблему не решить. Разве что можно дополнить его графом владения. Но это потребует ещё большего усложнения логики рантайма. И я не уверен, что топологическую сортировку такого двойного графа можно осуществить с приемлемой алгоритмической сложностью. Иначе вся эта наша борьба за эффективность будет работать медленнее, чем куда более тупая, но простая архитектура.
### 👨💻Code: Реагирование по положению в программе
Предпочтительнее, чтобы реакции отрабатывали в том порядке, который в явном виде задан в коде. Это гарантирует, что владелец будет актуализирован раньше, чем всё, чем он владеет.
Тут уже сначала будет обновлён `Allow`, потом `Page`, что приведёт к потере `PostPage` и, как следствие, уничтожению `PostPage` со всеми состояниями внутри, без их вычисления.
Flow: Конфигурация потоков данных
---------------------------------
В реактивной системе все состояния связаны друг с другом инвариантами в единый граф. Когда мы что-то меняем с одной стороны этого графа, рантайм обеспечивает каскадный пересчёт зависимых состояний. Такие последовательности пересчётов являются ни чем иным, как *информационными потоками* (data flow). Чем более эти потоки прямолинейны, чем меньше они разветвляются и задевают нерелевантные изменениям состояния, тем эффективней работает система. И тут есть два подхода к оптимизации информационных потоков.
* 🦽Manual: Ручная
* 🚕Auto: Автоматическая
### 🦽Manual: Ручная конфигурация информационных потоков
В библиотеках на основе проталкивания, автоматизировать потоки сложно, поэтому тут процветает ручное управление ими. А значит мы получаем ошибки двух типов.
Во-первых, мы можем забыть на что-то подписаться, в результате чего получаем неконсистентность. В примере мы забыли подписаться на `Title`, и при его изменении, `Greeting` не пересчитывается.
Во-вторых, мы можем забыть от чего-то отписаться, в результате чего получаем лишние вычисления. В примере мы забыли отписаться от `Name`, и при его изменении, `Greeting` вычисляется заново, но получает то же самое значение.
Но, если с ошибками ещё можно как-то совладать, то со сложностью ручных оптимизаций справиться уже не просто. Для банального логического ветвления нужно руками реализовать фактически транзистор, где у нас есть управляющий поток, который переключает выход между двумя входами. Для циклов и непрямой адресации же всё становится настолько сложно, что [мало кто вообще способен адекватно это описать](https://qna.habr.com/q/427478). В итоге всё сводится к тому, что, вместо точечных пересчётов, идёт пересчёт многих состояний на любой чих, что довольно медленно.
### 🚕Auto: Автоматическая конфигурация информационных потоков
В библиотеках, основанных на затягивании, обычно применяется автотрекинг зависимостей. Это мало того, что гораздо надёжней, так ещё и крайне просто для прикладного программиста. Ему не надо думать о потоках данных вообще — они динамически конфигурируются рантаймом наиболее оптимальным (для данного состояния приложения) образом.
Тут прикладные программисты делятся на два лагеря: одни боятся этой "магии" ибо не понимают как она работает, другие же просто не парятся — работает и работает, одной головной болью меньше.
Ну и в сторонке стоит лагерь тех, кто просто знает как оно работает и использует это знание с пользой. Ведь как известно: любая достаточно развитая технология неотличима от магии… для непосвящённого человека.
Практика показывает, что (при автоматизации) прикладного кода получается на порядки меньше, сам он гораздо проще и надёжнее, а приложение работает быстрее.
Error: Нештатные ситуации
-------------------------
Очень часто программисты не думают про нештатные ситуации. Особенно печально, когда это не прикладники, а авторы библиотек и фреймворков.
Например, когда я готовил этот материал, я спросил в чате Эффектора, как ведёт себя система при возникновении исключений. На что мне ответили, что исключений в чистых функциях быть не должно (исключения, кстати, на самом деле чистоте не противоречат, но это уже другая история) и если ты их допустил, то сам дурак. Когда же я уточнил, знает ли автор вообще, как поведёт себя его библиотека в нештатной ситуации, меня обвинили в токсичности и забанили.
Ну да мы отвлеклись. Багов тоже быть не должно, как и прочих плохих вещей в жизни, однако, они порой случаются. По вине программиста, браузера, расширений к нему, операционной системы, звёздного ветра — не важно. Надо уметь держать удар, а не прятать голову в песок. Но в разных библиотеках какого только поведения мы ни встретим..
* 🎲Unstable: Нестабильная работа
* ⛔Stop: Прекращение работы
* 🦺Store: Индикация ошибки и ожидание восстановления
* ⏮Revert: Откат к стабильному состоянию
### 🎲Unstable: Нестабильная работа при ошибке
Часто, в случае исключения, приложение переходит в неконсистентное состояние, что приводит к нестабильной работе.
В примере, допустим, в имени закрался некорректный `codepoint`. И, допустим, попытка взять длину строки приводит в этом случае к исключению. Пример довольно синтетический, позже я покажу более реалистичные, но пока так.
И вот, при вычислении инварианта произошло исключение, из-за чего рантайм не обновил `Count`. В результате, все состояния распались на 2 подграфа, которые сами по себе-то консистентны, но между собой уже не согласованы.
### ⛔Stop: Прекращение работы при ошибке
Не менее странное решение — просто перестать функционировать, как это делает, например, RxJS. Если где-либо в стриме возникает исключение, то все стримы после него финализируются и уже никогда не заработают.
Эта стратегия годится для одиночной задачи — её либо сделал, либо упал с ошибкой. Но реактивность — оно для долгоживущих систем, постоянно что-то отображающих. А значит, если отвалится реактивность, то приложение просто сломается, никак не сигнализируя об этом пользователю.
Причём сломается лишь на половину. И чтобы восстановить работу потребуется перезапуск либо всего приложения, либо как минимум этой половины.
Случай из жизни: Со мной на этаже в гостинице заселилась толпа спортсменов. А это такие парни под 100 кг чистого мяса. И вот, забились мы с ними сегодня с утра в лифт, что ожидаемо привело к перегрузу. Лифт поднял лапки и сказал "всё".
Ну, ладно, парочка вышла — ничего не происходит. Ок, вышла ещё половина — тоже ничего. Таак, вышли все — лифт так и не заработал. И пришлось нам всем устроить сегодня пробежку по лестнице. Думаю софт для этого лифта написали на RxJS, не иначе.
### ⏮Revert: Откат к стабильному состоянию при ошибке
Библиотеки типа reatom в принципе не допускают неконсистентности, выполняя пересчёт инвариантов в рамках транзакции. Так что в случае чего, все состояния откатываются к последнему согласованному.
Формально звучит не плохо. Но для пользователя это ужасное поведение, ведь из-за одной паршивой овцы где-то в углу приложения, которая постоянно кидает исключения, всё наше приложение встаёт колом и никак не реагирует на действия пользователя. Или попросту — намертво виснет. Что никуда не годится.
### 🦺Store: Индикация ошибки и ожидание восстановления
Гораздо практичнее рассматривать ошибку как возможный результат вычисления, наравне с возвращаемым значением.
Тут все состояния, которые зависят от не корректного, тоже помечаются как не корректные. А система рендеринга может автоматически показывать индикатор сбоя для частей приложения, которые не удалось обновить. Ну, либо вы можете перехватить исключение и нарисовать своё красивое сообщение. В любом случае пользователь будет понимать, что происходит, и что на сбойную часть приложения не стоит полагаться. А вот другими частями вполне можно продолжать пользоваться.
Не смотря на то, что часть приложения сломана, состояние приложение всё ещё согласованно. Ибо сообщение об ошибке на выходе как раз таки согласуется с некорректными значением на входе.
При этом, устранение причины сбоя, автоматически восстановит корректную работу этой части приложения. Без дополнительных телодвижений со стороны программиста!
Cycle: Циклические зависимости
------------------------------
Иногда у нас могут получаться циклические зависимости. Порой мы их можем захотеть сделать намеренно. Например, при реализации конвертера между градусами Цельсия и Фаренгейта, где пользователь может менять любое из двух значений, а второе должно пересчитываться автоматически.
Однако, в подавляющем большинстве случаев циклически зависимости свидетельствуют о проблеме с логикой, так что их обычно стараются избегать. Благо логику даже конвертера градусов всегда можно переписать так, чтобы циклических зависимостей не было.
Итак, давайте рассмотрим, как разные системы реагируют на эту нештатную ситуацию.
* 🚫Unreal: Невозможны
* 💤Infinite: Бесконечный цикл
* 🎰Limbo: Произвольный результат
* 🌋Fail: Приводят к ошибке
### 🚫Unreal: Циклы невозможны
Довольно соблазнительна мысль сделать так, чтобы синтаксически невозможно было создавать циклы. Например, мы можем требовать при создании состояния, чтобы все его зависимости уже существовали. Как правило, это свойственно библиотекам с проталкиванием.
Звучит, вроде бы, не плохо. Однако вместе с водой мы выплеснули и ребёнка. То есть крайне ограничили себя в том, какую логику инвариантов мы способны описать. В частности, это практически ставит крест на динамической конфигурации потоков данных. Например, электронную таблицу на такой архитектуре реализовать уже не получится.
### 💤Infinite: Бесконечный цикл
Ряд библиотек просто уходят в бесконечный цикл, постоянно обновляя одни и те же состояния.
Для Angular и React, например, это типичное поведение. Там даже костыль есть — ограничение на число пересчётов одного инварианта. Но об этом мы ещё поговорим.
### 🎰Limbo: Произвольный результат цикла
Бывает и совсем странное решение — при косвенном обращении к тому стейту, который сейчас вычисляется, используется его предыдущее значение.
В зависимости от порядка вычислений, этот подход даёт разные результаты. То есть состояние мало того, что получается несогласованным, так ещё и поведение приложения становится не стабильным, а начинает зависеть от погоды на Марсе.
### 🌋Fail: Цикл приводит к исключению
Наилучшее решение — детектирование цикла в рантайме и выбрасывание исключения.
Далее обработка уже идёт так же, как и с любыми другими нештатными ситуациями. Так что тут особенно важно, чтобы система правильно работала с исключениями.
Depth: Ограничение глубины
--------------------------
Как правило, глубина зависимостей остаётся сравнительно не большой, не превышающей пары десятков состояний.
Но порой зависимости могут вырастать на неприличную глубину. Это особенно характерно для приложений, где сам пользователь может управлять тем, кто от кого и как зависит. Типичные примеры: электронная таблица или диаграмма Ганта.
И далеко не все модели реактивности вообще позволят вам это реализовать. А узнаёшь об этом порой лишь, когда уже поздно менять лошадей. И начинается костылеварение. Так что присмотримся к этому аспекту повнимательнее.
* 🚧Limit: Ограничена константой
* 🗻Stack: Ограничена стеком
* 🌌Heap: Не ограничена
### 🚧Limit: Глубина ограничена константой
Некоторые библиотеки борются с циклическими зависимостями путём введения ограничения на число пересчётов за раз. Обычно это десяток-другой пересчётов.
```
for( let i = 0; i < MAX_REPEATS; ++i ) {
if( !dirty ) return
changeDetection()
}
throw new Error( 'Too many change detection repeats' )
```
Это предотвращает полное зависание приложения. Но и капитально ограничивает глубину зависимостей. Электронную таблицу в таких условиях реализовывать будет больно.
### 🗻Stack: Глубина ограничена стеком
Чуть лучше обстоит ситуация с моделями реактивности, где нет никаких искусственных ограничений. Однако, они инициируют одни вычисления внутри других, что приводит к росту стека.
```
first() {
this.second()
}
second() {
this.third()
}
thisrd() {
this.etc()
}
```
А так как размер стека не бесконечен, то его хватает лишь для глубины в несколько тысяч состояний. Этого уже может хватить даже для средних электронных таблиц. Однако, стоит выйти за пределы стека, и всё, приехали, вылетает исключение.
Причём оно может вылететь, а может не вылететь в зависимости от того в каком порядке пошли пересчёты. То есть мы получаем ещё и нестабильность поведения. Например, это может проявляться так: при открытии приложения всё хорошо, но стоит изменить одно состояние, пересчёт глубоко зависимого от него падает.
Однако, преимущество такого подхода в том, что по стеку видно в каком порядке производился пересчёт, что может быть полезно при отладке.
### 🌌Heap: Не ограниченная глубина
Наилучший же вариант не наращивает стек, что позволяет ему работать с зависимостями произвольной глубины. Ну, на сколько хватит оперативки, конечно же.
```
while( reactions.length ) {
reactions.shift().execute()
}
```
К сожалению, тут стек-трейсы становятся уже малоинформативными. Но на помощь при отладке может прийти уже логирование, которое при желание можно даже подклеивать в стек-трейс вручную.
Atomic: Атомарность изменений
-----------------------------
Пока что мы говорили про нештатные ситуации при вычислении инвариантов. Однако, они могут возникнуть и на подлёте — во время внесения изменений в несколько исходных состояний одновременно. Давайте разберём, что тут может пойти не так...
* 👻Alone: Одного отдельного состояния
* 🦶Base: Для первичных состояний
* 🤼♂️Full: Для всех состояний
### 👻Alone: Атомарность изменения лишь одного состояния
Как правило, изменение одного состояния везде атомарно. То есть оно либо произойдёт, либо не произойдёт. Рассмотрим простой пример: нам надо обновить два состояния, но после обновления первого возникла нештатная ситуация.
```
Name = 'John'
Count = 4
Name = 'Jin'
throw 'function is not a function'
Count = 3 // still 4
```
В результате мы получаем несогласованное состояние приложения. Ведь одно состояние обновилось, а второе — нет.
Эту проблему можно обойти, если хранить оба значения в одном состоянии. Но это возможно не всегда.
### 🦶Base: Атомарность изменения первичных состояний
Хорошо, если рантайм поддерживает транзакции. Они гарантируют, что либо все исходные состояния получат свои обновления, и пойдут обновляться зависимые состояния, либо не изменится никто, и зависимые состояния обновляться тоже не пойдут.
```
Name = 'John'
Count = 4
@transaction update() {
this.Name = 'Jin' // will still 'John'
throw 'function is not a function'
this.Count = 3
}
```
### 🤼♂️Full: Атомарность изменения всех состояний
В некоторых библиотеках транзакцию могут откатить не только исключения возникшие непосредственно при внесении изменений, но и исключения в инвариантах, которые пошли вычисляться в результате внесённых изменений.
```
Name = 'John'
Count = 4
@derived get Greeting() {
// Fails on 'Jin' name
return this.Name.split('')[3].toUppercase()
}
@transaction update() {
this.Name = 'Jin' // will still 'John'
this.Count = 3 // will still 4
}
```
В примере, у нас есть вторичное состояние `Greeting`, которое при коротком имени кидает исключение, и не может быть вычислено. Рантайм, видя это, откатывает всю транзакцию. В результате, мы снова получаем ситуацию, когда одна кривая вьюшка где-нибудь в углу приложения не даёт нам обновить модель и всё приложение встаёт колом.
Extern: Внешние взаимодействия
------------------------------
Порой инвариант требует асинхронной коммуникации. Например, при тяжёлых расчётах в отдельном воркере. Большинство реактивных библиотек не поддерживает асинхронные инварианты, но есть и такие, которые поддерживают. Рассмотрим оба варианта..
* 🏊♂️Sync: Синхронные инварианты
* 🏇Async: (А)синхронные инварианты
### 🏊♂️Sync: Поддерживаются только синхронные инварианты
Если поддерживается лишь синхронная реактивность, а нам нужно выполнить какой-то асинхронный вызов, то он обычно идёт где-то в сторонке. Возьмём простой пример на RxJS..
```
const image = source_element.pipe( map( capture ) )
const data = image.pipe( map( recognize ) )
const text = data.pipe( map( data => data.text ) )
text.subscribe( text => {
output.innerText = text
} )
```
Функции `capture` и `recognize` асинхронные, так как первой надо дождаться загрузки изображения, а вторая запускает нейронки на пуле воркеров. Когда мы поменяем `source_element`, то `output.innerText` никак не поменяется. То есть состояния перестанут быть согласованными. И к согласованности они придут лишь когда все асинхронные операции завершатся.
Решается эта проблема обычно интерактивной установкой какого-нибудь флага `isLoading` вначале и интерактивным сбросом его в конце. И когда этот флаг поднят — реактивно рисуется индикатор ожидания.
Мало того, что это рутина, так она ещё и зачастую подвержена багам, когда на один индикатор завязывается несколько выполняемых задач. Что при интерактивной логике может вызывать так называемое *состояние гонки*.
### 🏇Async: Поддерживаются асинхронные инварианты
Если же поддерживаются и асинхронные инварианты, то рантайм поддерживает согласованность автоматически. Типичное решение — через механизм работы с нештатными ситуациями. Давайте напишем, как может выглядеть код с использованием, например, генераторов:
```
@computed
text*() {
const image = yield capture( this.source_element )
const data = yield recognize( image )
return data.text
}
```
Почему не асинхронные функции? Да потому, что они в JS сделаны через задницу. Вот авторам библиотек и приходится костылять на генераторах, которые сделаны через противоположное место, но тоже не через то, что следовало бы.
На самом деле можно обойтись даже и без генераторов. В $mol, Vue и React поддерживается SuspenseAPI, позволяющий писать псевдосинхронный код и не мучаться с `yield` и `await`. Ну да не важно, генераторы для моего повествования будут нагляднее.
Когда рантайм вызывает генератор `text` ему вместо строки йелдится промис. Он понимает, что финальный результат будет позже, подписывается на финализацию промиса, а тем временем помечает состояние как "ожидающее значения". Этот флаг ожидания распространяется на все зависимые состояния. А система рендеринга, видя это, автоматически рисует индикатор ожидания. Классно же!
Оценка практичности
===================
Давайте теперь возьмём все наши знания о реактивности и попробуем сформулировать, как могла бы выглядеть наиболее практичная модель реактивности. Какими свойствами она должна обладать, чтобы пользоваться ею было приятно, чтобы она доставляла нам минимум проблем, чтобы у пользователя всё было стабильно, быстро, и всегда было понятно, что происходит.
| Aspect | ✅Usable | ❌Unusable |
| --- | --- | --- |
| Style | 🤓Obj | 🧐Proc 🤯Func |
| Watch | 🤝Links | 🔎Polling 🎇Events |
| Dupes | 🎭Equality | 🆔Identity 👯♀️Every |
| Origin | 🚂Pull | 🥌Push |
| Order | 👨💻Code | 📰Subscribe 🧨Event 📶Deep |
| Flow | 🚕Auto | 🦽Manual |
| Aspect | ✅Usable | ❌Unusable |
| --- | --- | --- |
| Tonus | 🦥Lazy | 🍔Instant ⏰Defer |
| Error | 🦺Store | ⛔Stop ⏮Revert 🎲Unstable |
| Cycle | 🌋Fail | 💤Infinite 🎰Limbo 🚫Unreal |
| Depth | 🌌Heap | 🗻Stack 🚧Limit |
| Atomic | 🦶Base | 🤼♂️Full 👻Alone |
| Extern | 🏇Async | 🏊♂️Sync |
Давайте теперь возьмём разные известные библиотеки и фреймворки и посмотрим, насколько они близки к идеалу. Но сперва, небольшая ремарка...
Поведение по умолчанию
======================
Далее рассматривается лишь поведение по умолчанию и рекомендуемый автором стиль кода. Понятное дело, что всегда можно как-то обойти проблемы. Где-то поведение можно поменять параметром конфига. Где-то нужно не забывать писать дополнительный код тут и там. Где-то нужно креативить адские костыли. А где-то вообще придётся отказаться от одной библиотеки, и прикрутить сбоку другую.
Однако, важно понимать, что автор библиотеки, даже если он глубоко не прав, скорее всего имеет большую экспертизу, чем обычный прикладной разработчик. В этой теме вообще, и в своей библиотеке в особенности. Поэтому большинство стороннего кода с её помощью будет написано именно в каноничном стиле, рассчитанном на поведение по умолчанию. А любое отхождение от дефолта потребует дополнительного кода, который надо и не забыть написать, и потратить время, чтобы написать его правильно.
* 🎓 Выбор эксперта
* 🐭 Минимум кода
* 👀 Повышенное внимание
* 👾 Сторонний код
Дальнейшее сравнение, полезно не столько для того, чтобы понимать, какую либу надо срочно брать, а какую немедленно выбрасывать. Но и для того, чтобы понимать, к чему нужно быть готовым, затевая проект на той или иной технологии.
Какие-то аспекты могут быть для вас совершенно не важными. Некоторые могут оказаться оказаться *шоу-стоперами*. А некоторые можно легко обойти. И хорошо бы заранее подложить себе соломки, чтобы не заниматься потом мучительной отладкой и оптимизацией.
Реактивные библиотеки
=====================
| Lib | Style | Watch | Dupes | Origin | Tonus | Order | Flow | Error | Cycle | Depth | Atomic | Extern |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| CellX | 🤓✅ | 🤝✅ | 🆔❌ | 🚂✅ | 🦥✅ | 👨💻✅ | 🚕✅ | 🦺✅ | 🌋✅ | 🗻❌ | 🦶✅ | 🏇✅ |
| $mol\_atom2 | 🤓✅ | 🤝✅ | 🎭✅ | 🚂✅ | 🦥✅ | 👨💻✅ | 🚕✅ | 🦺✅ | 🌋✅ | 🗻❌ | 👻❌ | 🏇✅ |
| MobX | 🤓✅ | 🤝✅ | 🆔❌ | 🚂✅ | 🦥✅ | 👨💻✅ | 🚕✅ | 🦺✅ | 🌋✅ | 🗻❌ | 👻❌ | 🏊♂️❌ |
| ChronoGraph | 🧐❌ | 🤝✅ | 🆔❌ | 🚂✅ | ⏰❌ | 👨💻✅ | 🚕✅ | ⏮❌ | 🌋✅ | 🌌✅ | 🤼♂️❌ | 🏊♂️❌ |
| Reatom | 🤯❌ | 🤝✅ | 🆔❌ | 🚂✅ | 🦥✅ | 🧨❌ | 🦽❌ | ⏮❌ | 🚫❌ | 🗻❌ | 🤼♂️❌ | 🏊♂️❌ |
| Effector | 🤯❌ | 🤝✅ | 🆔❌ | 🥌❌ | 🍔❌ | 📰❌ | 🦽❌ | 🎲❌ | 💤❌ | 🗻❌ | 👻❌ | 🏊♂️❌ |
| RxJS | 🤯❌ | 🤝✅ | 👯♀️❌ | 🥌❌ | 🍔❌ | 📰❌ | 🦽❌ | ⛔❌ | 🚫❌ | 🗻❌ | 👻❌ | 🏊♂️❌ |
Тут видно два основных лагеря: "Объектное Реактивное Программирование" и "Функциональное Реактивное Программирование". Как видите, модный сейчас функциональный подход не очень практичен, в отличие от более олдскульного подхода с объектами.
Пока я готовил этот материал, побеждал, как обычно, $mol. Но за пару дней CellX вырвался таки вперёд. Ну да не страшно, я всё-равно пока не рекомендую завязываться на $mol\_atom2, ибо готовлю новую реализацию основанную на [Auto Wire JS Proposal](https://gist.github.com/nin-jin/6b9765fb9d0d50c2e1d37689008f5357), который позволяет разным реактивным библиотекам взаимодействовать как друг с другом, так и с нативным браузерным API через единые интерфейсы. Так что следите за новостями!
Стоит так же отметить, что сам по себе RxJS не про реактивность. Он, в основе своей, про контроль потока исполнения. Однако, с его помощью можно описывать инварианты, связывающие состояния, и тогда мы получаем реактивную систему.
Большое спасибо авторам библиотек за помощь в подготовке этой таблицы. Пишите мне, если хотите добавить и свою к сравнению. Я постараюсь поддерживать эту табличку в актуальном состоянии, если комьюнити, конечно, поможет мне уследить за всеми новостями.
Реактивные фреймворки
=====================
| Lib | Style | Watch | Dupes | Origin | Tonus | Order | Flow | Error | Cycle | Depth | Atomic | Extern |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Vue | 🤓✅ | 🤝✅ | 🆔❌ | 🚂✅ | 🦥✅ | 👨💻✅ | 🚕✅ | 🦺✅ | 🎰❌ | 🗻❌ | 👻❌ | 🏇✅ |
| React | 🧐❌ | 🔎❌ | 🆔❌ | 🥌❌ | ⏰❌ | 👨💻✅ | 🦽❌ | ⛔❌ | 🌋✅ | 🚧❌ | 👻❌ | 🏇✅ |
| Angular | 🧐❌ | 🔎❌ | 🆔❌ | 🥌❌ | ⏰❌ | 👨💻✅ | 🚕✅ | 🎲❌ | 🎰❌ | 🚧❌ | 👻❌ | 🏊♂️❌ |
| Svelte | 🧐❌ | 🔎❌ | 🆔❌ | 🥌❌ | ⏰❌ | 👨💻✅ | 🚕✅ | ⛔❌ | 🚫❌ | 🌌✅ | 👻❌ | 🏊♂️❌ |
Анализ фреймворков с точки зрения реактивности является несколько условным. Проявляется она обычно в двух аспектах: инварианты между состояниями одного компонента, и связь состояния одного компонента с параметрами другого.
Как видите, тут более популярна процедурщина, которая является тоже не самым практичным подходом. Самым практичным тут оказывается объектный Vue. Круче него только $mol, но отдельно как фреймворк его тут рассматривать нет смысла, ибо он просто использует библиотеку $mol\_atom2 в качестве кровеносной системы, а её мы уже разобрали ранее.
Важно отметить, что не стоит слепо доверять этим табличкам, ибо составлены они вручную. Я, конечно, старался всё отразить максимально точно, но мог где-то и накосячить. Поэтому...
Ещё по теме
===========
* [state-management-specification](https://github.com/artalar/state-management-specification) / Артём Арутюнян
* [A General Theory of Reactivity](https://github.com/kriskowal/gtor) / Kris Kowal
* [Объектное Реактивное Программирование](https://github.com/nin-jin/slides/tree/master/orp) @ FrontendConf'17
* [Квантовая механика вычислений на JS](https://github.com/nin-jin/slides/tree/master/fibers) @ HolyJS'18
У Артёма (автора Reatom) есть интересный проект по классификации стейт-менеджеров с помощью тестов. Это чуть более широкая тема, так как, например, Redux — это стейт-менеджер, но он не реактивный. Это просто транзакционное изменение дерева состояний и всё, никаких каскадных инвариантов между состояниями. Если вас заинтересовала эта тема, то подключайтесь к написанию тестов — это будет полезно для всего комьюнити.
Обстоятельная статья Криса Ковала рассматривает вопрос реактивности с иных позиций. На мой взгляд он не прав, но для расширения кругозора можно почитать.
На конец: пара моих выступлений, разбирающих преимущества ОРП и механику реализации асинхронных инвариантов, помогут ещё глубже закопаться в тему.
Хотите добавки?
===============
Для тех, кто добрался до конца, но ещё не устал, могу предложить глянуть так же и дискуссию о менеджерах состояний, которая развернулась после выступления, между мной и Сергеем Совой, мейнтейнером Effector-а.
Хотите больше точек зрения?
===========================
Если же и этого вам окажется мало, то приглашаю на прошлогоднюю дискуссию о стейт менеджерах в более расширенном составе..
Ещё не по теме
==============
Вот уже 10 лет я активно делюсь знаниями, идеями, пилю оупенсорс. И каждый мой материал — это оригинальная, и порой радикальная, идея, проверенная на практике. Так что стоит ознакомиться со всем этим, даже если не планируете использовать.
* [slides.hyoo.ru](https://slides.hyoo.ru/) — мои выступления (10+)
* [Core Dump](https://www.youtube.com/channel/UC-qEImMrqSLZ9KLee1JTcuw) — видео о фундаментальном (4+)
* [habhub.hyoo.ru](https://habhub.hyoo.ru/) — мои статьи (40+)
* [`_jin_nin_`](https://twitter.com/_jin_nin_) — новости о разработке (>9000)
Внести свою лепту
=================
Второй год я уже не работаю, а занимаюсь компьютерной наукой и оуперсорс проектами. Так что если вы найдёте мою работу полезной, то поблагодарить меня можно задонатив или даже запатронив...
* [yasobe.ru/na/mol](http://yasobe.ru/na/mol) — разовое спасибо
* [patreon.com/hyoo](https://www.patreon.com/hyoo) — постоянная поддержка
* [hyoo-ru/hyoo.ru/wiki](https://github.com/hyoo-ru/hyoo.ru/wiki) — наши открытые проекты
У нас, в гильдии $hyoo, много интересных проектов, которые вскоре должны перевернуть мир. Так что самый ценный вклад, который вы можете внести — это даже не деньги, а участие в проектах.
Мы хотим сделать экосистему тесно интегрированных веб-сервисов, использующих самые передовые и дешёвые технологии. И потеснить оупенсорсом нынешних интернет-гигантов. Присоединяйтесь и вы к нашей маленькой революции!
А ещё вы можете позвать меня провести семинар в вашей компании. Не только о реактивности, конечно. Мне есть что рассказать по многим вопросам. Причём не поверхностно, а с глубоким анализом.
Пишите письма!
==============
Вот теперь уж точно всё. Спасибо за внимание. Надеюсь сей разбор оказался для вас полезным.
А теперь, форсируем наши реактивные движки и летим в светлое будущее!
Из первых уст
-------------
* Было интересно наблюдать за спором сеньоров, из которого наблюдатель может для себя извлечь информационную пользу.
* Информативно и развернуто.
* Интересно и доходчиво.
* Сам интересуюсь этой темой много лет как хобби, а тут человек основательно этим занимался и подробно осветил тему.
 | https://habr.com/ru/post/586450/ | null | ru | null |
# Лайфхаки в веб-разработке
#### Ссылки открытия файлов в IDE
Это облегчит вам поиск нужного файла.
Вы сможете создавать ссылки на код прямо на странице ошибки. Или в журнале ошибок.
Сделайте ссылки в dev панели на класс контроллера и файл шаблона (или что там у вас?)
Клик на такую ссылку будет переносить вас в соответствующий файл открытой IDE.
Как сделать?
Зарегистрируйте протокол для открытия файла или класса в IDE
Я использую протокол «edit:» и такую схему URL
edit:className@project
edit:relativePath@project
Программа, зарегистрированная за этим протоколом, определяет абсолютный путь к файлу и передает его в IDE.
В Опере зарегистрировать протокол тривиально:
Настройки → Расшиненные → Программы → Добавить…
Выбираете протокол (двоеточия не нужны) и программу
Для других браузеров можно настроить в операционной системе.
В Windows это делается через реестр.
В Unix ~~через жопу~~ по-разному.
~~К сожалению, ни одна используемая мной IDE не поддерживает открытие файла на конкретной строке через CLI.
А было бы классно.~~
**upd:** vim умеет, спасибо [Stdit](https://habrahabr.ru/users/stdit/)
`vim -c line filename`
**upd:** IDE от Jetbrains тоже научились, спасибо [cuhuak](https://habrahabr.ru/users/cuhuak/)
> PHPStorm (да и, наверное, все IDE Jetbrains) умеет открывать файл на конкретной строке через CLI:
>
> `phpstorm --line N filename.`
>
>
>
> Причем, если у вас filename уже открыт и вы пытаетесь перейти на другую строку в этом файле, то IDE заботливо плавно проскролит в нужное место.
>
>
Я рад.
#### Короткий путь до файлов проекта
Путь вида /home/Ti/Project/projectname/www ломает клавиатуру
Программируя, нужно туда ходить или выполнять там программы.
На это место я создаю симлинку /w
Для документации проекта и всяких PSD я завожу путь /d
В Windows (привет, Document and Settings) тоже можно создавать симлинки или подключайте папки как диск.
#### Автоматические виртуальные хосты в веб сервере
В ручную заводить хосты — тратить время
У меня сделано [так](http://habrahabr.ru/blogs/webdev/127374/)
#### CLI советы
Я пользую Unix операционную систему (FreeBSD) и терминал это моя правая рука.
##### Набор скриптов для работы с проектами
При работе с большим количеством проектов, например, если вы работаете в веб-студии или вы фрилансер, скрипты спасут вашу жизнь.
Для каждого проекта создается простой конфиг настроек:
— опции деплоя
— параметры подключения к базе
— параметры SSH
— и т.д.
Я использую такие скрипты по управлению проектами:
* Создание
Создает конфиг проекта и открывает его на правку
* Изменение
Открывает на правку конфиг
* Создание базы данных
* Открытие
создает симлинки проекта:
/w на сорцы
/d на документацию, фотошоп и прочие файлы проекта
Было бы здорово если можно через CLI открывать проект в IDE
* Бэкап
Бекапит production
* Восстановление production из бекапа
* Клонирование
Копирует с проект с бэкапа в рабочую версию
* SSH на production
* MySQL локальный и на production
CLI к базе MySQL проекта
Удобно указывать после пайпа unix.
Напрмер, можно залить дамп SQL в базу
`$ pv dump.sql | pj-mysql projectname`
* Деплой
* Открытие класса/файла в IDE
* и некоторые другие
##### Настройка SHELL
Настройте свой shell на удобную подстановку комманд, подстановки имени проекта в скриптах, вывод информации по системе контроля версий.
#### Спасибо
В комментариях, предлагаю хабрачеловекам поделиться своими лайфхаками в веб-разработке.
#### Дополнения
##### Ссылка для переключения между dev и prod хостами
Сделайте ссылку в dev-панели для переключения между разрабатываемой локальной версией и рабочим, production, сайтом.
Или используйте другой инструмент для быстрого переключения между этими хостами.
#### Дополнения из комментариев
##### Маркировка цветом разных серверов (спасибо, [Stdit](https://habrahabr.ru/users/stdit/))
Раскрашивайте приглашения разных серверов в разные цвета. Например так (.bash\_profile):
`PS1='\e[32m\D{%Y-%m-%d %H:%M:%S} \w\e[0m\n\$ '`
##### Звуковое оповещение о критических ошибках (спасибо, [Stdit](https://habrahabr.ru/users/stdit/))
Если вы следите за логами через tail -f, добавляйте к сообщениям о критических ошибках символ №7 (\a).
Это добавит звуковой сигнал (Bell) в ваш терминал. | https://habr.com/ru/post/138496/ | null | ru | null |
# Консоль в массы. Переход на светлую сторону. Bash
Вступление
----------
Удобство использования того или иного инструмента заключается в том, насколько он помогает в решении конкретной задачи. Также важно, чтобы мы могли настроить этот инструмент под свои нужды. Приятным бонусом будет и тот факт, что мы можем расширить и дополнить новыми возможностями наш инструмент.
Мы добрались до самой интересной и увлекательной темы — это скрипты на `bash`. Когда вы запускаете терминал, внутри него работает специальная программа-оболочка — `shell` (англ) — интерпретатор команд. Shell понимает все команды, которые вы вводите с клавиатуры, и обрабатывает их. Также выводит сообщения об ошибках, следит за корректностью команд и их синтаксисом. Примером таких команд могут быть: *сменить директорию, создать новую директорию, добавить текстовый файл, отредактировать текстовый файл, сохранить изменения и другие*.
Программ-оболочек довольно много. Одна из первых удачных реализаций называется `sh`. Ее разработал Стивен Борн в 1977 году ([wiki](https://en.wikipedia.org/wiki/Bourne_shell)). В 99% случаев, когда вы работаете за компьютером под управлением `OS *nix`, оболочкой по умолчанию, которая обрабатывает команды, будет bash. Конечно, есть еще такая оболочка как `zsh` и другие, но это уже совсем другая история.
**Важный момент.** Данная статья не является исчерпывающим руководством по скриптам на bash. Главная цель — это рассмотреть основы программирования на bash, показать примеры, дать читателю базовые знания, которых хватит, чтобы двигаться дальше. В конце статьи есть полезные ссылки и вы сможете более подробно изучить данную тему.
Основы
------
Первый раздел посвящен основам. Рассмотрим с чего должен начинаться любой скрипт. Как определяются переменные и как менять значения этих переменных. Также разберемся как передавать аргументы скрипту и обрабатывать эти аргументы внутри скрипта. Следующий раздел — это ветвления. И последний, но не менее важный раздел — циклы.
Любой скрипт на bash должен начинаться со строки:
```
#!/bin/bash
```
Тем самым мы говорим интерпретатору какую программу вызвать, если скрипт исполняемый.
Для улучшения переносимости кода следует указывать такой вариант первой строки:
```
#!/usr/bin/env bash
```
Не гарантируется, что на различных системах путь к `bash` будет одинаковым. Указывая `env` мы защищаем себя от таких неожиданностей. Повторюсь, это в том случае, если вы планируете использовать свои скрипты на разных системах, компьютерах и т.д. Если такой необходимости нет, первый вариант отлично подойдет. Во всех примерах используется первый вариант.
По умолчанию все файлы, которые создает пользователь, не являются исполняемыми. Мы должны явно указать для конкретного файла этот параметр при помощи команды:
```
chmod +x
```
Можно запустить скрипт и без этого параметра при помощи команды:
```
bash
```
### Переменные
Переменная — это именованная область в памяти. Это значит, что у переменной есть имя и оно ссылается на определенную ячейку памяти компьютера. Обычно переменные используются для хранения какой-то информации. Любая переменная состоит из двух частей: имя и значение.
#### Имя переменной:
* буквы, цифры, знак нижнего подчеркивания (`_`)
* не может начинаться с цифры
#### Значение переменной:
* числа, строки (если есть пробелы, то в кавычках), отдельные символы
#### Создание (перезапись) переменной:
```
path="$HOME"
```
Обратите внимание, что перед знаком равно и после него не должно быть пробелов.
#### Чтение переменной:
```
"$path" или "${path}"
```
В большинстве случаев оба варианта работают одинаково. В отдельных случаях, при возникновении неоднозначности интерпретации, корректно будет работать только такая форма записи: `"${path}"`
#### Передача аргументов скрипту:
```
./script.sh arg1 arg2 arg3 … argN
```
#### Обработка аргументов внутри скрипта:
```
"$1" # первый аргумент
"$2" # второй аргумент
"$0" # имя скрипта
"$#" # количество аргументов
"$*" # все аргументы в виде одной строки (слова)
"$@" # аналогичен $*, но при этом каждый параметр представлен как отдельная строка (слово),
# т.е. параметры не подвергаются какой либо интерпретации
```
Ну что, пришло время написать первый скрипт. Как это и должно быть, скрипт будет выводить на экран пользователя строку «Hello, world!».
Вот так просто, на bash можно реализовать пример с «Hello, world!». Напоминаю, что все примеры вы можете найти в [репозитории](https://github.com/var-bin/terminalForCoder__WSD). Давайте рассмотрим еще один пример. На этот раз поработаем с переменными, а также с аргументами, которые пользователь передает скрипту.
Обратите внимание на то, что все программы, написанные на bash, обычно имеют расширение `.sh`.
Ветвления
---------
С основами и переменными немного разобрались. Теперь перейдем к ветвлениям. Для работы с ветвлениями в bash нам доступны следующие конструкции:
1. `if`
2. `if/else`
3. `if/elif/else`
4. `case/in/esac`
Первые три варианта схожи и каждая следующая конструкция дополняет предыдущую. Рассмотрим самый простой вариант:
Обратите внимание на то, что в конце каждой строки отсутствует точка с запятой. Есть возможность писать условия (и не только) в одну строку, тогда точка с запятой нужны.
При работе с ветвлениями нам нужно как-то проверять, пуста строка или нет, равно число нулю или не равно, работаем мы с файлом или это директория. Для таких задач в bash существует свой синтаксис. Я его разделил на четыре категории: строки, числа, файлы, логические. Давайте рассмотрим их.
#### Условия (строки):
#### Условия (числа/строки):
#### Условия (файлы):
#### Условия (логические):
Вариант `if/else` мы пропустим. А вот `if/elif/else` предлагаю рассмотреть на примере:
Скрипт ожидает получить на вход один аргумент — имя файла или имя директории. Дальше идет проверка, действительно ли это файл или директория. Если да, то выполняем удаление. Если переданный аргумент не является ни файлом ни директорией, выводим сообщение пользователю, что удаление невозможно.
Нам осталось рассмотреть последний вариант ветвления — это `case/in/esac`. Если проводить аналогию с JavaScript, то это вариант реализации `switch/case`. Рассмотрим эту конструкцию тоже на примере.
Данный скрипт ожидает получить два числовых аргумента: единицу и двойку. И в зависимости от того, какой аргумент будет первым, создается файл или директория. Также есть проверка на количество аргументов, которые передал пользователь. Количество аргументов не должно быть меньше двух. Если пользователь передал неверные аргументы, выводим ему сообщение об этом. За это отвечает значение по умолчанию.
Циклы
-----
Следующий раздел, который мы рассмотрим — это работа с циклами. Для организации циклов в арсенале bash присутствуют такие конструкции: `for/in` и `while`.
Давайте рассмотрим синтаксис `for/in`:
`i` — это название переменной, в которую будет передаваться элемент массива. `array` — это сам массив. На каждой последующей итерации `i` получает следующее значение из массива. Рассмотрим пример:
Есть список значений: `1 2 3 4 5`. Запускаем цикл, который проходится по всем значениям. Создаем переменную `file_name`. Потом проверяем существует ли файл с таким именем. Если файла нет — создаем его, если есть пропускаем шаг создания.
Вы могли заметить слово `continue` — это ключевое слово. Позволяет пропустить итерацию и продолжить работу дальше. Также есть ключевое слово `break` — прерывает выполнение скрипта. Используются эти ключевые слова только в контексте `if/else`.
Следующая конструкция, которую мы рассмотрим для работы с циклами, будет `while`:
Предлагаю сразу же рассмотреть пример:
В данном примере есть две строки с ключевым словом `read`. Рассмотрим более подробно как работают эти строки. А именно: строка номер двенадцать и строка номер восемь. Начнем со строки номер двенадцать. Пока переменная `$again` равна значению `"yes"`, программа просит ввести имя пользователя и выводит его на экран. После этого скрипт спрашивает, хотим ли мы продолжить. И так до тех пор, пока пользователь не введет любую другую строку вместо `yes` или просто нажмет `Enter`. Но гораздо интереснее код на строке номер восемь. Присутствует переменная `$name`, которая не объявлена до этого. Эта переменная создается динамически и потом считывается ее значение.
Полезные ссылки
---------------
1. [Basics of Bash](https://en.hexlet.io/courses/basics_of_bash)
2. [bash-handbook](https://github.com/denysdovhan/bash-handbook)
3. [Подводные камни Bash](https://habrahabr.ru/company/mailru/blog/311762/)
4. [Advanced Bash-Scripting Guide [en]](http://tldp.org/LDP/abs/html/) ( [Konkase](https://habr.com/ru/users/konkase/) спасибо за ссылку )
5. [Advanced Bash-Scripting Guide](http://www.opennet.ru/docs/RUS/bash_scripting_guide/) ( [aso](https://habr.com/ru/users/aso/) спасибо за ссылку )
6. [Shell Style Guide от Google](https://google.github.io/styleguide/shell.xml) ( [leoismyname](https://habr.com/ru/users/leoismyname/) спасибо за ссылку )
7. [В чём смысл и преимущества #!/usr/bin/env?](http://ru.stackoverflow.com/questions/541589/%D0%92-%D1%87%D1%91%D0%BC-%D1%81%D0%BC%D1%8B%D1%81%D0%BB-%D0%B8-%D0%BF%D1%80%D0%B5%D0%B8%D0%BC%D1%83%D1%89%D0%B5%D1%81%D1%82%D0%B2%D0%B0-usr-bin-env) ( [Borz](https://habr.com/ru/users/borz/) спасибо за ссылку )
8. [Learn the Command Line](https://www.codecademy.com/learn/learn-the-command-line)
9. [The Command Line Crash Course](https://learnpythonthehardway.org/book/appendixa.html)
10. [Linux Command Line in Русский](http://www.linuxguide.it/command_line/linux_commands_ru.html)
11. [Basic Unix commands](https://www.youtube.com/watch?v=3DA1grSp4mU)
Вместо заключения
-----------------
На этой позитивной ноте мы закончим знакомство с bash. Данной информации достаточно, чтобы реализовать простенькие скрипты, а также автоматизировать повседневные задачи.
Забегая немного наперед, скажу, что в следующей статье будет меньше теории и еще больше примеров, как автоматизировать рутинные задачи при помощи bash скриптов. Следите за обновлениями.
На этом все. Спасибо за внимание. Кто дочитал до конца, отдельное спасибо. До встречи в следующей статье.
**UPD.** Текст статьи обновлен на основании обсуждений в комментариях. Спасибо всем, кто принимал активное участие в обсуждениях. Вы сделали статью еще лучше. И не только статью. | https://habr.com/ru/post/319670/ | null | ru | null |
# Symfony 2.0, RequestHandler Component
На сайте [Symfony Components](http://components.symfony-project.org/) про компонент **RequestHandler** сказано примерно следующее:
> Гибкое микро-ядро для быстрых фреймворков.
>
>
Так ли это и что из себя представляет **RequestHandler** в Symfony 2 я попробую рассмотреть в этом топике.
Если взглянуть на процесс обработки запроса в [приложении](http://habrahabr.ru/blogs/symfony/89134/) на базе Symfony 2, а именно рассмотреть метод `run()` класса `Symfony\Foundation\Kernel`, то увидим что после формирования и сохранения в кеше либо загрузки из кеша DI контейнера, происходит получение из контейнера объекта обработчика запроса и вызов его метода `handle()` в параметрах, которому передается объект запроса, кстати также полученный из DI контейнера. Данный метод должен вернуть объект ответа у которого вызывается метод `send()` для отправки ответа. В общем первый удар при обработке запроса принимает на себя RequestHandler, он же возвращает объект ответа, поэтому я решил начать обзор компонентов входящих в состав Symfony 2 именно с него.
Для начала заглянем в `Symfony/Foundation/Resources/services.xml` так как именно здесь происходит описание сервиса RequestHandlerService в DI контейнере.
```
Symfony\Components\RequestHandler\RequestHandler
Symfony\components\RequestHandler\Response
...
```
Из этого описания становится ясно, что объект запроса создается просто `new Request()`, а объект обработчика запроса, как `new RequestHandler($dispatcher)`, где `$dispatcher` объект класса EventDispatcher, представляющий собой диспетчер событий.
Заглянув в Symfony/Components/RequestHandler мы увидим следующий набор файлов:
* `Exception/`: директория с классами исключений
+ `ForbiddenHttpException.php`: исключение кидаемое при 403 Forbidden
+ `HttpException.php`: базовый класс для исключений
+ `NotFoundHttpException.php`: исключение кидаемое при 404 Not Found
+ `UnauthorizedHttpException.php`: исключение кидаемое при 401 Unauthorized
* `Request.php`: класс запроса
* `RequestInterface.php`: интерфейс, который должен реализовать объект запроса
* `Response.php`: класс ответа
* `ResponseInterface.php`: интерфейс, который должен реализовать объект ответа
* `RequestHandler.php`: обработчик запроса
Ну в общем все почти очевидно. Многое ясно даже не заглядывая внутрь классов. Но все же коротко обо всем. Классы исключений, которые используются при возникновении соответствующих ситуаций, все что в них делается, так это прописывается сообщение и код ответа. `Request` — класс запроса, который разбирает переменные окружения, параметры и все что связано с запросом. `Response` — класс ответа, который содержит в себе тело ответва, формирует заголовки и все связанное с ответом. `RequestHandler` — это обработчик запроса. Пожалуй рассмотрим его подробнее.
Фактически все, что делает обработчик запроса это используя переданный ему в параметрах диспетчер событий (EventDispatcher) генерирует различные события, тем самым как бы оповещая приложения о различных этапах разбора запроса и формирования ответа. И в зависимости от реакции слушателей (listeners) на эти события завершает работу либо генерирует следующее событие.
Список событий, которые создает обработчик запросов:
* `core.request`
* `core.load_controller`
* `core.controller`
* `core.view`
* `core.response`
* `core.exception`: в случае возникновения исключений
То есть события отражают основные этапы разбора запроса и формирования ответа. `RequestHandler` проверяя реакцию приложения на события продолжает создавать события либо завершает работу. Соответственно приложение навешивая свои обработчики на те или иные события участвует в формировании ответа. При этом некоторые части приложения могут ничего не знать друг о друге.
Лучше, наверное это все попробовать на примере. Что в общем я сейчас и сделаю. Итак, разденем Symfony до гола, убрав все кроме ядра и навесим свой обработчик на событие `core.request`, заодно будет небольшая демонстрация гибкости фреймворка.
Пример будет на базе sandbox с обновленной версией Symfony, как создавалось окружение можно увидеть вот [здесь](http://habrahabr.ru/blogs/symfony/89134/).
Итак, начнем с конфигов. В файле `hello/config/config.yml` закоментируем все за исключением строки `kernel.config: ~`. Теперь поправим ядро приложения, файл `hello/HelloKernel.php`
```
# hello/HelloKernel.php
// убираем все бандлы, за исключения ядра и нашего приложения
public function registerBundles()
{
return array(
new Symfony\Foundation\Bundle\KernelBundle(),
new Application\HelloBundle\Bundle(),
);
}
```
Теперь, надо описать в DI контейнере необходимые параметры и сервисы, для этого сначала создадим свое расширение для DI контейнера, создаем директорию `src/Application/HelloBundle/DependencyInjection`, а в ней файл `HelloExtension.php` со следующим содержимым:
```
namespace Application\HelloBundle\DependencyInjection;
use Symfony\Components\DependencyInjection\Loader\LoaderExtension,
Symfony\Components\DependencyInjection\Loader\XmlFileLoader,
Symfony\Components\DependencyInjection\BuilderConfiguration,
Symfony\Components\DependencyInjection\Reference,
Symfony\Components\DependencyInjection\Definition;
class HelloExtension extends LoaderExtension
{
public function helloLoad($config)
{
$configuration = new BuilderConfiguration();
$loader = new XmlFileLoader(__DIR__.'/../Resources/config');
$configuration->merge($loader->load('hello.xml'));
return $configuration;
}
public function getAlias()
{
return 'hello';
}
public function getNamespace()
{
return 'http://poulikov.ru/schema/dic/hello';
}
public function getXsdValidationBasePath()
{
return __DIR__.'/../Resources/config/';
}
}
```
теперь зарегистрируем наше расширение:
```
# src/Application/HelloBundle/Bundle.php
// используем наше расширение
use Application\HelloBundle\DependencyInjection\HelloExtension;
...
// зарегистрируем расширение в контейнере
public function buildContainer(ContainerInterface $container)
{
Loader::registerExtension(new HelloExtension());
}
```
Наше расширение будет искать файл `hello.xml` по пути `src/Application/HelloBundle/Resources/config/hello.xml`
так что надо создать этот файл, с примерно таким содержимым:
```
Application\HelloBundle\Request\Parser
```
В этом файле мы определили сервис, который навешивается на прослушиваение события `core.request`
Теперь создадим парсер запроса:
```
# src/Application/HelloBundle/Request/Parser.php
namespace Application\HelloBundle\Request;
use Symfony\Components\DependencyInjection\ContainerInterface;
use Symfony\Components\EventDispatcher\Event;
use Symfony\Components\Routing\RouterInterface;
class Parser
{
protected $container;
public function __construct(ContainerInterface $container)
{
$this->container = $container;
}
public function register()
{
$this->container->getEventDispatcherService()->connect('core.request', array($this, 'resolve'));
}
public function resolve(Event $event)
{
$response = $this->container->getResponseService();
$response->setContent("Hello, World! I'm Symfony 2.0 lite");
$event->setReturnValue($response);
$event->setProcessed(true);
}
}
```
Теперь последний штрих, в конфиге `hello/config/config.yml` добавим строчку `hello.hello: ~`
Это всё! Теперь обратившись по любому адресу мы получим ответ:
Совершенно бесполезное приложение получилось. Но на этом примере легко показать как оно работает, подцепляться можно и к другим событиям. Все очень гибко и удобно. | https://habr.com/ru/post/89202/ | null | ru | null |
# Домашний Minecraft server в Azure часть 2 — Azure Automation
[В прошлой статье](https://habrahabr.ru/post/339034/) мы разворачивали майкрафт сервер в Azure с использованием 100% автоматизации процесса и прочих разных интересных современных практик DevOps. В этой статье мы ещё больше углубимся в **Azure IaaS** — в частности, используем на практике *Azure Automation* для мониторинга и актуализации конфигурации сервера.
### Предыдущая деплоймент схема
[Исходники](https://github.com/AndreyPoturaev/minecraft-in-azure/tree/v1.0.0)
Перед тем как приступать к следующей части — отвечу на пару вопросов по предыдущей
##### Причём тут DevOps?
Отвечаю — то, о чём я рассказывал в предыдущей и этой статье напрямую относится блоку Technology из [Gartner DevOps model](http://www.gartner.com/imagesrv/reprints/272900/272990/272990.pptx), а именно к *Infrastructure as Code*, *One-Step Deploy* и *Continuous Monitoring*.
##### Почему так сложно?
Отвечаю — статьи чисто технические и так планировалось изначально. Базовые знания по Azure для прочтения обязательны. Смысл статей в том, что в них (точнее в [github](https://github.com/AndreyPoturaev/minecraft-in-azure)) реализуется рабочий пример, который можно брать за основу, менять манкрафт на <вашу legacy систему> и начинать строить свои CD пайплайны в Azure.
### Новая деплоймент схема
#### Что поменялось
Как видно из картинки — добавился новый слой Management Tier и вот зачем: в предыдущей статье мы сделали автоматизированный деплой (в т.ч. инфраструктуры) и это хорошо. Но вот дальше мы никак не мониторим конфигурацию сервера во времени и это плохо.
Можно даже придумать ещё одно правило конфигурационного управления
> Вы всегда должны быть уверены, что конфигурация развернутого ПО и инфраструктуры соответствует вашим ожиданиям
Для того, чтобы помочь в реализации этого требования, существуют такие тулы как Puppet, Chef, ну и один модуль в Azure Automation.
В случае с Azure Automation работает это следующим образом:
1. Загружаем Powershell DSC файл в Azure
2. Регистрируем VM в Azure Automation, назначая ей загруженную ранее конфигурацию
3. Azure Automation конфигурирует VM, а затем периодически проверяет соответствие VM назначенной ей конфигурации
4. В случае несовпадении конфигурации, Azure Automation либо переконфигурирует VM, либо уведомляет о несоответствии
Чтобы это всё реализовать, надо:
1. Создать Automation account
2. Загрузить PowerShell DSC конфигурацию в Azure Automation
3. Загрузить зависимые powershell модули в Azure Automation
4. Скомпилировать PowerShell DSC конфигурацию
5. Зарегистрировать в Azure Automation VM, назначая ей скомпилированную ранее PowerShell DSC конфигурацию и флажок ApplyAndAutocorrect
Небольшая проблема заключается в том, что *ни один из этих шагов* на данный момент нельзя автоматизировать с помощью **Azure CLI 2**.
Поэтому нужная логика будет реализована на powershell и вызываться в конце [rollout.sh](https://github.com/AndreyPoturaev/minecraft-in-azure/blob/v2.0.0/rollout.sh)
#### Рассмотрим содержимое powershell скрипта [automation\_preparation.ps1](https://github.com/AndreyPoturaev/minecraft-in-azure/blob/v2.0.0/automation_preparation.ps1) подробнее по шагам
Сначала мы авторизуемся в azure (просто импортируем контекст из файла, для простоты. Предварительно мы должны его туда сохранить — это делается в [login\_manual.sh](https://github.com/AndreyPoturaev/minecraft-in-azure/blob/develop/login_manual.sh)).
```
Import-AzureRmContext -Path "$env:HOMEPATH/azureprofile.json"
```
Создаём Automation Account. Плана «Free» вполне достаточно.
```
New-AzureRmAutomationAccount -ResourceGroupName $env:GROUP -Name $env:AUTOMATION -Location $env:LOCATION -Plan Free
```
Загружаем нужные нашему DSC скрипту зависимости. Обратите внимание, что ContentLink должен ссылаться на nuget пакет. Операция загрузки модулей не синхронная, но всегда выполняется за предсказуемое время. Поставил sleep в конце, только чтобы не загромаждать код. На работе так делать **не надо** )
```
New-AzureRmAutomationModule -AutomationAccountName $env:AUTOMATION -ResourceGroupName $env:GROUP -Name xNetworking -ContentLink "https://www.powershellgallery.com/api/v2/package/xNetworking/5.1.0.0"
New-AzureRmAutomationModule -AutomationAccountName $env:AUTOMATION -ResourceGroupName $env:GROUP -Name xPSDesiredStateConfiguration -ContentLink "https://www.powershellgallery.com/api/v2/package/xPSDesiredStateConfiguration/7.0.0.0"
New-AzureRmAutomationModule -AutomationAccountName $env:AUTOMATION -ResourceGroupName $env:GROUP -Name xStorage -ContentLink "https://www.powershellgallery.com/api/v2/package/xStorage/3.2.0.0"
Start-Sleep -Seconds 60
```
Загружаем DSC конфигурацию (в отличии от предыдущей версии скрипта, нам не надо формировать zip с конфигурацией — достаточно загрузить ps1).
```
Import-AzureRmAutomationDscConfiguration -AutomationAccountName $env:AUTOMATION -ResourceGroupName $env:GROUP -SourcePath "$env:CONFIG_NAME.ps1" -Force -Published
```
Компилируем загруженную конфигурацию (в этот момент требуется инициализировать параметры конфигурации).
Операция не синхронная, время ожидания неопределено (видимо из-за плана Free), поэтому тут придётся организовать цикл.
```
$Params = @{"minecraftVersion"="$env:MVERSION";"accountName"="$env:STORAGE_ACCOUNT";"containerName"="$env:STORAGE_CONTAINER";"vmName"="$env:VM_NAME"}
$CompilationJob = Start-AzureRmAutomationDscCompilationJob -AutomationAccountName $env:AUTOMATION -ConfigurationName $env:CONFIG_NAME -Parameters $Params -ResourceGroupName $env:GROUP
while($CompilationJob.EndTime -eq $null -and $CompilationJob.Exception -eq $null)
{
$CompilationJob = $CompilationJob | Get-AzureRmAutomationDscCompilationJob
Start-Sleep -Seconds 3
}
```
Ну а дальше просто вызываем команду регистрации VM в Azure Automation как DSC Node.
Обратите внимание на параметр *ConfigurationMode* — если он равен ApplyAndMonitor — Azure Automation сконфигурирует VM только один раз, затем будет просто сообщать статус (Compliant, NotCompliant) соответствия фактической конфигурации VM описанной конфигурации в DSC.
```
Register-AzureRmAutomationDscNode -AzureVMName $env:VM_NAME `
-AzureVMResourceGroup $env:GROUP `
-AzureVMLocation $env:LOCATION `
-ResourceGroupName $env:GROUP -AutomationAccountName $env:AUTOMATION `
-NodeConfigurationName "$env:CONFIG_NAME.$env:VM_NAME" `
-ConfigurationMode ApplyAndAutocorrect `
-ActionAfterReboot ContinueConfiguration `
-RebootNodeIfNeeded $true `
-AllowModuleOverwrite $true
```
**Как всё это запустить из Windows**Нам нужен будет
* [Git и (обязательно) Git Bash](https://git-scm.com/downloads)
* [zip utility (прописать в PATH)](https://ranxing.wordpress.com/2016/12/13/add-zip-into-git-bash-on-windows/)
* [Azure CLI 2](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest)
* [Azure Powershell](https://docs.microsoft.com/ru-ru/powershell/azure/install-azurerm-ps?view=azurermps-4.4.0)
Запуск процедуры ролаута:
```
git clone https://github.com/AndreyPoturaev/minecraft-in-azure
cd minecraft-in-azure
git checkout v2.0.0
export MINESERVER_PASSWORD=
export MINESERVER\_DNS=
export MINESERVER\_STORAGE\_ACCOUNT=
. login\_manual.sh
. rollout.sh
```
Чтобы получить информацию о соответствии конфигурации VM требуемой можно зайти в созданный Automation Account → DSC Nodes.
И конечно это [не единственный вариант](https://docs.microsoft.com/ru-ru/azure/automation/automation-dsc-diagnostics).
### Как дебажить Powershell DSC
Напоследок напишу пару слов про дебаг этих чудо конфигураций, возможно кому-нибудь это сэкономит пару часов жизни )
Если DSC конфигурация не конфигурируется — причину можно посмотреть
* Зайдя в свойства DSC Extension виртуальной машины на портале и почитав там выдержку из логов:
* Зайдя на саму машину и продиагностировав DSC с помощью Powershell модуля [xDscDiagnostics](https://github.com/PowerShell/xDscDiagnostics)
#### Как продиагностировать проблему с помощью [xDscDiagnostics](https://github.com/PowerShell/xDscDiagnostics)
* Получить список последних запускавшихся джоб Get-xDscOperation
* Получить вывод определённой джобы Trace-xDscOperation -JobID
* Если в выводе не пишется нужная вам информация — то надо ещё раз форсировать конфигурирование через [Update-DscConfiguration](https://docs.microsoft.com/en-us/powershell/module/psdesiredstateconfiguration/update-dscconfiguration?view=powershell-5.1) с флагом -Verbose и опять с помощью xDscDiagnostics посмотреть логи | https://habr.com/ru/post/339906/ | null | ru | null |
# Кроссплатформенный многопоточный TCP/IP сервер на C++
Решил задаться целью написать простой в использовании и при этом быстрый многопоточного TCP/IP сервера на C++ и при этом кроссплатформенный — как минимум чтобы работал на платформах Windows и Linux без требования как-либо изменять код за пределами самописной библиотеки. Ранее, на чистом C++ без библиотек вроде Qt, сетевым программировнием не занимался, и предвещал себе долгое время мучений с платформо-зависимостью. Но как оказалось всё гораздо проще чем казалось на первый взгляд, ведь в основном интерфейсы сокетов обоих систем похожи как две капли воды и различаются лишь в мелких деталях.
Для начала определим общий для клиента и сервера заголовок:
**general.h**
```
#ifndef GENERAL_H
#define GENERAL_H
#ifdef _WIN32
#else
#define SD_BOTH 0
#endif
#include
#include
#include
#include
// IP 127.0.0.1
uint32\_t LOCALHOST\_IP = 0x0100007f;
// Код состояния сокета
enum class SocketStatus : uint8\_t {
connected = 0,
err\_socket\_init = 1,
err\_socket\_bind = 2,
err\_socket\_connect = 3,
disconnected = 4
};
// Буффер данных куда у нас будет приниматься данные от другой стороны
struct DataBuffer {
int size = 0;
void\* data\_ptr = nullptr;
DataBuffer() = default;
DataBuffer(int size, void\* data\_ptr) : size(size), data\_ptr(data\_ptr) {}
DataBuffer(const DataBuffer& other) : size(other.size), data\_ptr(malloc(size)) {memcpy(data\_ptr, other.data\_ptr, size);}
DataBuffer(DataBuffer&& other) : size(other.size), data\_ptr(other.data\_ptr) {other.data\_ptr = nullptr;}
~DataBuffer() {if(data\_ptr) free(data\_ptr); data\_ptr = nullptr;}
bool isEmpty() {return !data\_ptr || !size;}
operator bool() {return data\_ptr && size;}
};
// в последней версии библиотеки typedef от std::vector
// Тип сокета
enum class SocketType : uint8\_t {
client\_socket = 0,
server\_socket = 1
};
// Базовый класс TCP клиента
class TcpClientBase {
public:
typedef SocketStatus status;
virtual ~TcpClientBase() {};
virtual status disconnect() = 0;
virtual status getStatus() const = 0;
virtual bool sendData(const void\* buffer, const size\_t size) const = 0;
virtual DataBuffer loadData() = 0;
virtual uint32\_t getHost() const = 0;
virtual uint16\_t getPort() const = 0;
virtual SocketType getType() const = 0;
};
#endif // GENERAL\_H
```
Итак интерфейсы классов сервера и клиента(со стороны сервера) выглядят следующим образом:
**TcpServer.h**
```
#ifndef TCPSERVER_H
#define TCPSERVER_H
#include
#include
#include
#include
#include
#ifdef \_WIN32 // Windows NT
#include
#include
#else // \*nix
#include
#include
#include
#include
#include
#include
#endif
#include "general.h"
#ifdef \_WIN32 // Windows NT
typedef int SockLen\_t;
typedef SOCKADDR\_IN SocketAddr\_in;
typedef SOCKET Socket;
typedef u\_long ka\_prop\_t;
#else // POSIX
typedef socklen\_t SockLen\_t;
typedef struct sockaddr\_in SocketAddr\_in;
typedef int Socket;
typedef int ka\_prop\_t;
#endif
// Конфигурация Keep-Alive соединения
struct KeepAliveConfig{
ka\_prop\_t ka\_idle = 120;
ka\_prop\_t ka\_intvl = 3;
ka\_prop\_t ka\_cnt = 5;
};
// Класс Tcp сервера
struct TcpServer {
// Класс клиента сервера (реализация определена ниже)
struct Client;
// Тип обработчик данных клиента
typedef std::function handler\_function\_t;
// Тип обработчика подключения/отсоединения клиента
typedef std::function con\_handler\_function\_t;
// Коды статуса сервера
enum class status : uint8\_t {
up = 0,
err\_socket\_init = 1,
err\_socket\_bind = 2,
err\_scoket\_keep\_alive = 3,
err\_socket\_listening = 4,
close = 5
};
private:
// Сокет сервера
Socket serv\_socket;
// Порт сервера
uint16\_t port;
// Код статуса
status \_status = status::close;
// Обработчик данных от клиента
handler\_function\_t handler;
// Обработчик подключения клиента
con\_handler\_function\_t connect\_hndl = [](Client&){};
// Обработчик отсоединения клиента
con\_handler\_function\_t disconnect\_hndl = [](Client&){};
// Поток-обработчик подключений
std::thread accept\_handler\_thread;
// Поток ожидания данных
std::thread data\_waiter\_thread;
// Тип итератора клиента
typedef std::list>::iterator ClientIterator;
// Keep-Alive конфигурация
KeepAliveConfig ka\_conf;
// Список клиентов
std::list> client\_list;
// Мьютекс для синзронизации потоков подключения и ожидания данных
std::mutex client\_mutex;
// Для систем Windows так же требуется
// структура определяющая версию WinSocket
#ifdef \_WIN32 // Windows NT
WSAData w\_data;
#endif
// Включить Keep-Alive для сокета
bool enableKeepAlive(Socket socket);
// Метод обработчика подключений
void handlingAcceptLoop();
// Метод ожидания данных
void waitingDataLoop();
public:
// Упрощённый конструктор с указанием:
// \* порта
// \* обработчика данных
// \* конфигурации Keep-Alive
TcpServer(const uint16\_t port,
handler\_function\_t handler,
KeepAliveConfig ka\_conf = {});
// Конструктор с указанием:
// \* порта
// \* обработчика данных
// \* обработчика подключений
// \* обработчика отключений
// \* конфигурации Keep-Alive
TcpServer(const uint16\_t port,
handler\_function\_t handler,
con\_handler\_function\_t connect\_hndl,
con\_handler\_function\_t disconnect\_hndl,
KeepAliveConfig ka\_conf = {});
// Деструктор
~TcpServer();
// Заменить обработчик данных
void setHandler(handler\_function\_t handler);
// Getter порта
uint16\_t getPort() const;
// Setter порта
uint16\_t setPort(const uint16\_t port);
// Getter кода статуса сервера
status getStatus() const {return \_status;}
// Метод запуска сервера
status start();
// Метод остановки сервера
void stop();
// Метод для входа присоединения циклических потоков сервера
void joinLoop();
// Исходящее подключение от сервера к другому серверу
bool connectTo(uint32\_t host, uint16\_t port, con\_handler\_function\_t connect\_hndl);
// Отправить данные всем клиентам сервера
void sendData(const void\* buffer, const size\_t size);
// Отправить данные клиенту по порту и хосту
bool sendDataBy(uint32\_t host, uint16\_t port, const void\* buffer, const size\_t size);
// Отключить клиента по порту и хосту
bool disconnectBy(uint32\_t host, uint16\_t port);
// Отключить всех клиентов
void disconnectAll();
};
// Класс клиента (со стороны сервера)
struct TcpServer::Client : public TcpClientBase {
friend struct TcpServer;
// Мьютекс для синхронизации обработки данныз
std::mutex access\_mtx;
// Адрес клиента
SocketAddr\_in address;
// Сокет слиента
Socket socket;
// Код статуса клиента
status \_status = status::connected;
public:
// Конструктор с указанием:
// \* сокета клиента
// \* адреса клиента
Client(Socket socket, SocketAddr\_in address);
// Деструктор
virtual ~Client() override;
// Getter хоста
virtual uint32\_t getHost() const override;
// Getter порта
virtual uint16\_t getPort() const override;
// Getter кода статуса подключения
virtual status getStatus() const override {return \_status;}
// Отключить клиента
virtual status disconnect() override;
// Получить данные от клиента
virtual DataBuffer loadData() override;
// Отправить данные клиенту
virtual bool sendData(const void\* buffer, const size\_t size) const override;
// Определить "сторону" клиента
virtual SocketType getType() const override {return SocketType::server\_socket;}
};
#endif // TCPSERVER\_H
```
Как можно заметить на данном этапи зависимости операционных систем без особых проблем решаются при помощи макросов и псевдонимов типов данных. Так же в Windows части TcpServer-хедера присутствует структура для обозначения используемой версии WinSocket — `WSAData w_data;`(см. [WSAData](https://docs.microsoft.com/en-us/windows/win32/api/winsock/ns-winsock-wsadata))
Перейдём к реализации сервера:
**TcpServer.cpp**
```
#include "../include/TcpServer.h"
#include
#include
#include
#ifdef \_WIN32
// Макросы для выражений зависимых от OS
#define WIN(exp) exp
#define NIX(exp)
// Конвертировать WinSocket код ошибки в Posix код ошибки
inline int convertError() {
switch (WSAGetLastError()) {
case 0:
return 0;
case WSAEINTR:
return EINTR;
case WSAEINVAL:
return EINVAL;
case WSA\_INVALID\_HANDLE:
return EBADF;
case WSA\_NOT\_ENOUGH\_MEMORY:
return ENOMEM;
case WSA\_INVALID\_PARAMETER:
return EINVAL;
case WSAENAMETOOLONG:
return ENAMETOOLONG;
case WSAENOTEMPTY:
return ENOTEMPTY;
case WSAEWOULDBLOCK:
return EAGAIN;
case WSAEINPROGRESS:
return EINPROGRESS;
case WSAEALREADY:
return EALREADY;
case WSAENOTSOCK:
return ENOTSOCK;
case WSAEDESTADDRREQ:
return EDESTADDRREQ;
case WSAEMSGSIZE:
return EMSGSIZE;
case WSAEPROTOTYPE:
return EPROTOTYPE;
case WSAENOPROTOOPT:
return ENOPROTOOPT;
case WSAEPROTONOSUPPORT:
return EPROTONOSUPPORT;
case WSAEOPNOTSUPP:
return EOPNOTSUPP;
case WSAEAFNOSUPPORT:
return EAFNOSUPPORT;
case WSAEADDRINUSE:
return EADDRINUSE;
case WSAEADDRNOTAVAIL:
return EADDRNOTAVAIL;
case WSAENETDOWN:
return ENETDOWN;
case WSAENETUNREACH:
return ENETUNREACH;
case WSAENETRESET:
return ENETRESET;
case WSAECONNABORTED:
return ECONNABORTED;
case WSAECONNRESET:
return ECONNRESET;
case WSAENOBUFS:
return ENOBUFS;
case WSAEISCONN:
return EISCONN;
case WSAENOTCONN:
return ENOTCONN;
case WSAETIMEDOUT:
return ETIMEDOUT;
case WSAECONNREFUSED:
return ECONNREFUSED;
case WSAELOOP:
return ELOOP;
case WSAEHOSTUNREACH:
return EHOSTUNREACH;
default:
return EIO;
}
}
#else
// Макросы для выражений зависимых от OS
#define WIN(exp)
#define NIX(exp) exp
#endif
// Реализация конструктора сервера с указанием
// \* порта
// \* обработчика данных
// \* Keep-Alive конфигурации
TcpServer::TcpServer(const uint16\_t port,
handler\_function\_t handler,
KeepAliveConfig ka\_conf)
: TcpServer(port, handler, [](Client&){}, [](Client&){}, ka\_conf) {}
// Реализация конструктора сервера с указанием
// \* порта
// \* обработчика данных
// \* обработчика подключения
// \* обработчика отключения
// \* Keep-Alive конфигурации
TcpServer::TcpServer(const uint16\_t port,
handler\_function\_t handler,
con\_handler\_function\_t connect\_hndl,
con\_handler\_function\_t disconnect\_hndl,
KeepAliveConfig ka\_conf)
: port(port), handler(handler), connect\_hndl(connect\_hndl), disconnect\_hndl(disconnect\_hndl), ka\_conf(ka\_conf) {}
// Деструктор сервера
// автоматически закрывает сокет сервера
TcpServer::~TcpServer() {
if(\_status == status::up)
stop();
WIN(WSACleanup());
}
// Setter обработчика данных
void TcpServer::setHandler(TcpServer::handler\_function\_t handler) {this->handler = handler;}
// Getter порта
uint16\_t TcpServer::getPort() const {return port;}
// Setter порта
uint16\_t TcpServer::setPort( const uint16\_t port) {
this->port = port;
start();
return port;
}
// Реализация запуска сервера
TcpServer::status TcpServer::start() {
int flag;
// Если сервер запущен, то отключаем его
if(\_status == status::up) stop();
// Для Windows указываем версию WinSocket
WIN(if(WSAStartup(MAKEWORD(2, 2), &w\_data) == 0) {})
// Задаём адрес сервера
SocketAddr\_in address;
// INADDR\_ANY - любой IP адрес
address.sin\_addr
WIN(.S\_un.S\_addr)NIX(.s\_addr) = INADDR\_ANY;
// Задаём порт сервера
address.sin\_port = htons(port);
// Семейство сети AF\_INET - IPv4 (AF\_INET6 - IPv6)
address.sin\_family = AF\_INET;
// Создаём TCP сокет
if((serv\_socket = socket(AF\_INET, SOCK\_STREAM, 0)) WIN(== INVALID\_SOCKET)NIX(== -1))
return \_status = status::err\_socket\_init;
flag = true;
// Устанавливаем параметр сокета SO\_REUSEADDR в true (подробнее https://it.wikireading.ru/7093)
if((setsockopt(serv\_socket, SOL\_SOCKET, SO\_REUSEADDR, WIN((char\*))&flag, sizeof(flag)) == -1) ||
// Привязываем к сокету адрес и порт
(bind(serv\_socket, (struct sockaddr\*)&address, sizeof(address)) WIN(== SOCKET\_ERROR)NIX(< 0)))
return \_status = status::err\_socket\_bind;
// Активируем ожидание фходящих соединений
if(listen(serv\_socket, SOMAXCONN) WIN(== SOCKET\_ERROR)NIX(< 0))
return \_status = status::err\_socket\_listening;
\_status = status::up;
// Запускаем поток ожидания соединений
accept\_handler\_thread = std::thread([this]{handlingAcceptLoop();});
// Запускаем поток ожидания данных
data\_waiter\_thread = std::thread([this]{waitingDataLoop();});
return \_status;
}
// Реализация остановки сервера
void TcpServer::stop() {
\_status = status::close;
// Закрываем сокет
WIN(closesocket)NIX(close)(serv\_socket);
// Ожидаем завершения потоков
joinLoop();
// Вычищаем список клиентов
client\_list.clear();
}
// "Вхождение" в потоки ожидания
void TcpServer::joinLoop() {accept\_handler\_thread.join(); data\_waiter\_thread.join();}
// Создание подключение со стороны сервера
// (подключение аналогично клиентоскому, но обрабатывается
// тем же обработчиком, что и входящие соединения)
bool TcpServer::connectTo(uint32\_t host, uint16\_t port, con\_handler\_function\_t connect\_hndl) {
Socket client\_socket;
SocketAddr\_in address;
// Создание TCP сокета
if((client\_socket = socket(AF\_INET, SOCK\_STREAM, IPPROTO\_IP)) WIN(== INVALID\_SOCKET) NIX(< 0)) return false;
new(&address) SocketAddr\_in;
address.sin\_family = AF\_INET;
address.sin\_addr.s\_addr = host;
WIN(address.sin\_addr.S\_un.S\_addr = host;)
NIX(address.sin\_addr.s\_addr = host;)
address.sin\_port = htons(port);
// Установка соединения
if(connect(client\_socket, (sockaddr \*)&address, sizeof(address))
WIN(== SOCKET\_ERROR)NIX(!= 0)
) {
WIN(closesocket(client\_socket);)NIX(close(client\_socket);)
return false;
}
// Активация Keep-Alive
if(!enableKeepAlive(client\_socket)) {
shutdown(client\_socket, 0);
WIN(closesocket)NIX(close)(client\_socket)
}
std::unique\_ptr client(new Client(client\_socket, address));
// Запуск обработчика подключения
connect\_hndl(\*client);
// Добавление клиента в список клиентов
client\_mutex.lock();
client\_list.emplace\_back(std::move(client));
client\_mutex.unlock();
return true;
}
// Отправка данных всем клиентам
void TcpServer::sendData(const void\* buffer, const size\_t size) {
for(std::unique\_ptr& client : client\_list)
client->sendData(buffer, size);
}
// Отправка данных по конкретному хосту и порту
bool TcpServer::sendDataBy(uint32\_t host, uint16\_t port, const void\* buffer, const size\_t size) {
bool data\_is\_sended = false;
for(std::unique\_ptr& client : client\_list)
if(client->getHost() == host &&
client->getPort() == port) {
client->sendData(buffer, size);
data\_is\_sended = true;
}
return data\_is\_sended;
}
// Отключение клиента по конкретному хосту и порту
bool TcpServer::disconnectBy(uint32\_t host, uint16\_t port) {
bool client\_is\_disconnected = false;
for(std::unique\_ptr& client : client\_list)
if(client->getHost() == host &&
client->getPort() == port) {
client->disconnect();
client\_is\_disconnected = true;
}
return client\_is\_disconnected;
}
// Отключение всех клиентов
void TcpServer::disconnectAll() {
for(std::unique\_ptr& client : client\_list)
client->disconnect();
}
// Цикл обработки входящих подключений
// (исполняется в отдельном потоке)
void TcpServer::handlingAcceptLoop() {
SockLen\_t addrlen = sizeof(SocketAddr\_in);
// Пока сервер запущен
while (\_status == status::up) {
SocketAddr\_in client\_addr;
// Принятеи новго подключения (блокирующи вызов)
if (Socket client\_socket = accept(serv\_socket, (struct sockaddr\*)&client\_addr, &addrlen);
client\_socket WIN(!= 0)NIX(>= 0) && \_status == status::up) {
// Если получен сокет с ошибкой продолжить ожидание
if(client\_socket == WIN(INVALID\_SOCKET)NIX(-1)) continue;
// Активировать Keep-Alive для клиента
if(!enableKeepAlive(client\_socket)) {
shutdown(client\_socket, 0);
WIN(closesocket)NIX(close)(client\_socket);
}
std::unique\_ptr client(new Client(client\_socket, client\_addr));
// Запустить обработчик подключений
connect\_hndl(\*client);
// Добавить клиента в список клиентов
client\_mutex.lock();
client\_list.emplace\_back(std::move(client));
client\_mutex.unlock();
}
}
}
// Цикл ожидания данных
void TcpServer::waitingDataLoop() {
using namespace std::chrono\_literals;
while (true) {
client\_mutex.lock();
// Перебрать всех клиентов
for(auto it = client\_list.begin(), end = client\_list.end(); it != end; ++it) {
auto& client = \*it;
// Если unique\_ptr содержит объект клиента
if(client){
if(DataBuffer data = client->loadData(); data.size) {
// При наличии данных запустить обработку входящих данных в отдельном потоке
std::thread([this, \_data = std::move(data), &client]{
client->access\_mtx.lock();
handler(\_data, \*client);
client->access\_mtx.unlock();
}).detach();
} else if(client->\_status == SocketStatus::disconnected) {
// При отключении клиента запустить обработку в отдельном потоке
std::thread([this, &client, it]{
// Извлечь объект клиента из unique\_ptr в списке
client->access\_mtx.lock();
Client\* pointer = client.release();
client = nullptr;
pointer->access\_mtx.unlock();
// Запуск обработчика отключения
disconnect\_hndl(\*pointer);
// Удалить элемент клиента из списка
client\_list.erase(it);
// Удалить объект клиента
delete pointer;
}).detach();
}
}
}
client\_mutex.unlock();
// Ожидание 50 млисекунд так как в данном потоке
// не содержится блокирующих вызовов и данный
// цикл сильно повышает загруженность CPU
std::this\_thread::sleep\_for(50ms);
}
}
// Функция запуска и конфигурации Keep-Alive для сокета
bool TcpServer::enableKeepAlive(Socket socket) {
int flag = 1;
#ifdef \_WIN32
tcp\_keepalive ka {1, ka\_conf.ka\_idle \* 1000, ka\_conf.ka\_intvl \* 1000};
if (setsockopt (socket, SOL\_SOCKET, SO\_KEEPALIVE, (const char \*) &flag, sizeof(flag)) != 0) return false;
unsigned long numBytesReturned = 0;
if(WSAIoctl(socket, SIO\_KEEPALIVE\_VALS, &ka, sizeof (ka), nullptr, 0, &numBytesReturned, 0, nullptr) != 0) return false;
#else //POSIX
if(setsockopt(socket, SOL\_SOCKET, SO\_KEEPALIVE, &flag, sizeof(flag)) == -1) return false;
if(setsockopt(socket, IPPROTO\_TCP, TCP\_KEEPIDLE, &ka\_conf.ka\_idle, sizeof(ka\_conf.ka\_idle)) == -1) return false;
if(setsockopt(socket, IPPROTO\_TCP, TCP\_KEEPINTVL, &ka\_conf.ka\_intvl, sizeof(ka\_conf.ka\_intvl)) == -1) return false;
if(setsockopt(socket, IPPROTO\_TCP, TCP\_KEEPCNT, &ka\_conf.ka\_cnt, sizeof(ka\_conf.ka\_cnt)) == -1) return false;
#endif
return true;
}
```
Реализация для Linux и Windows практически идентична за исключением некотрых мест который без проблем обкладываются макросами. Теперь же мы перейдём непосредственно к реализации класса клиента:
**TcpServerClient.cpp**
```
#include "../include/TcpServer.h"
#ifdef _WIN32
// Макросы для выражений зависимых от OS
#define WIN(exp) exp
#define NIX(exp)
// Конвертировать WinSocket код ошибки в Posix код ошибки
inline int convertError() {
switch (WSAGetLastError()) {
case 0:
return 0;
case WSAEINTR:
return EINTR;
case WSAEINVAL:
return EINVAL;
case WSA_INVALID_HANDLE:
return EBADF;
case WSA_NOT_ENOUGH_MEMORY:
return ENOMEM;
case WSA_INVALID_PARAMETER:
return EINVAL;
case WSAENAMETOOLONG:
return ENAMETOOLONG;
case WSAENOTEMPTY:
return ENOTEMPTY;
case WSAEWOULDBLOCK:
return EAGAIN;
case WSAEINPROGRESS:
return EINPROGRESS;
case WSAEALREADY:
return EALREADY;
case WSAENOTSOCK:
return ENOTSOCK;
case WSAEDESTADDRREQ:
return EDESTADDRREQ;
case WSAEMSGSIZE:
return EMSGSIZE;
case WSAEPROTOTYPE:
return EPROTOTYPE;
case WSAENOPROTOOPT:
return ENOPROTOOPT;
case WSAEPROTONOSUPPORT:
return EPROTONOSUPPORT;
case WSAEOPNOTSUPP:
return EOPNOTSUPP;
case WSAEAFNOSUPPORT:
return EAFNOSUPPORT;
case WSAEADDRINUSE:
return EADDRINUSE;
case WSAEADDRNOTAVAIL:
return EADDRNOTAVAIL;
case WSAENETDOWN:
return ENETDOWN;
case WSAENETUNREACH:
return ENETUNREACH;
case WSAENETRESET:
return ENETRESET;
case WSAECONNABORTED:
return ECONNABORTED;
case WSAECONNRESET:
return ECONNRESET;
case WSAENOBUFS:
return ENOBUFS;
case WSAEISCONN:
return EISCONN;
case WSAENOTCONN:
return ENOTCONN;
case WSAETIMEDOUT:
return ETIMEDOUT;
case WSAECONNREFUSED:
return ECONNREFUSED;
case WSAELOOP:
return ELOOP;
case WSAEHOSTUNREACH:
return EHOSTUNREACH;
default:
return EIO;
}
}
#else
// Макросы для выражений зависимых от OS
#define WIN(exp)
#define NIX(exp) exp
#endif
#include
// Реализация загрузки данных
DataBuffer TcpServer::Client::loadData() {
// Если клиент не подключён вернуть пустой буффер
if(\_status != SocketStatus::connected) return DataBuffer();
using namespace std::chrono\_literals;
DataBuffer buffer;
int err;
// Чтение длинный данных в неблокирующем режиме
// MSG\_DONTWAIT - Unix флаг неблокирующего режима для recv
// FIONBIO - Windows-флаг неблокирующего режима для ioctlsocket
WIN(if(u\_long t = true; SOCKET\_ERROR == ioctlsocket(socket, FIONBIO, &t)) return DataBuffer();)
int answ = recv(socket, (char\*)&buffer.size, sizeof (buffer.size), NIX(MSG\_DONTWAIT)WIN(0));
// Обработка отключения
if(!answ) {
disconnect();
return DataBuffer();
} else if(answ == -1) {
// Чтение кода ошибки
WIN(
err = convertError();
if(!err) {
SockLen\_t len = sizeof (err);
getsockopt (socket, SOL\_SOCKET, SO\_ERROR, WIN((char\*))&err, &len);
}
)NIX(
SockLen\_t len = sizeof (err);
getsockopt (socket, SOL\_SOCKET, SO\_ERROR, WIN((char\*))&err, &len);
if(!err) err = errno;
)
// Отключение неблокирующего режима для Windows
WIN(if(u\_long t = false; SOCKET\_ERROR == ioctlsocket(socket, FIONBIO, &t)) return DataBuffer();)
// Обработка ошибки при наличии
switch (err) {
case 0: break;
// Keep alive timeout
case ETIMEDOUT:
case ECONNRESET:
case EPIPE:
disconnect();
[[fallthrough]];
// No data
case EAGAIN: return DataBuffer();
default:
disconnect();
std::cerr << "Unhandled error!\n"
<< "Code: " << err << " Err: " << std::strerror(err) << '\n';
return DataBuffer();
}
}
// Если прочитанный размер нулевой, то вернуть пустой буффер
if(!buffer.size) return DataBuffer();
// Если размер не нулевой выделить буффер в куче для чтения данных
buffer.data\_ptr = (char\*)malloc(buffer.size);
// Чтение данных в блокирующем режиме
recv(socket, (char\*)buffer.data\_ptr, buffer.size, 0);
// Возврат буффера с прочитанными данными
return buffer;
}
// Обработка отключения клиента
TcpClientBase::status TcpServer::Client::disconnect() {
\_status = status::disconnected;
// Если сокет не валидный прекратить обработку
if(socket == WIN(INVALID\_SOCKET)NIX(-1)) return \_status;
// Отключение сокета
shutdown(socket, SD\_BOTH)
// Закрытие сокета
WIN(closesocket)NIX(close)(socket);
// Установление в сокета не валидного значения
socket = WIN(INVALID\_SOCKET)NIX(-1);
return \_status;
}
// Отправка данных
bool TcpServer::Client::sendData(const void\* buffer, const size\_t size) const {
// Если сокет закрыт вернуть false
if(\_status != SocketStatus::connected) return false;
// Сформировать сообщение с длинной в начале
void\* send\_buffer = malloc(size + sizeof (int));
memcpy(reinterpret\_cast(send\_buffer) + sizeof(int), buffer, size);
\*reinterpret\_cast(send\_buffer) = size;
// Отправить сообщение
if(send(socket, reinterpret\_cast(send\_buffer), size + sizeof (int), 0) < 0) return false;
// Вычистить буффер сообщения
free(send\_buffer);
return true;
}
// Конструктор клиента
TcpServer::Client::Client(Socket socket, SocketAddr\_in address)
: address(address), socket(socket) {}
// Деструктор клиента с закрытием сокета
TcpServer::Client::~Client() {
if(socket == WIN(INVALID\_SOCKET)NIX(-1)) return;
shutdown(socket, SD\_BOTH);
WIN(closesocket(socket);)
NIX(close(socket);)
}
// Получить хост клиента
uint32\_t TcpServer::Client::getHost() const {return NIX(address.sin\_addr.s\_addr) WIN(address.sin\_addr.S\_un.S\_addr);}
// Получить порт клиента
uint16\_t TcpServer::Client::getPort() const {return address.sin\_port;}
```
Пример использования:
**main.cpp**
```
#include
// Парсинр IPv4-адреса и порта в std::string
std::string getHostStr(const TcpServer::Client& client) {
uint32\_t ip = client.getHost ();
return std::string() + std::to\_string(int(reinterpret\_cast(&ip)[0])) + '.' +
std::to\_string(int(reinterpret\_cast(&ip)[1])) + '.' +
std::to\_string(int(reinterpret\_cast(&ip)[2])) + '.' +
std::to\_string(int(reinterpret\_cast(&ip)[3])) + ':' +
std::to\_string( client.getPort ());
}
int main() {
// Создание экземпляра сервера
TcpServer server( 8080, [](DataBuffer data, TcpServer::Client& client){
std::cout << "("<
```
Источники:
* [Программирование сокетов в Linux](https://www.rsdn.org/article/unix/sockets.xml)
* [Простой и быстрый сервер на C/C++...](https://habr.com/ru/post/327574/)
* [Winsock Server Application](https://docs.microsoft.com/en-us/windows/win32/winsock/winsock-server-application)
* [Проект OpenNet: MAN socket (7) Макропакеты и соглашения (FreeBSD и Linux)](https://www.opennet.ru/man.shtml?topic=socket&category=7&russian=0)
**UPDATE:** Реализация многопоточного TCP-сервера представленная в данной статье имеет такой недостаток как "потокове голодание" при слишком большом колличестве подключённых к серверу клиентов, по скольку для обработки каждого клиента создаётся отдельный поток, который находится в состоянии активного ожидания данных от клиента. Для уменьшения влияния данного недостатка было принято решение изменить модель организации многопоточности приложения. Новая модель представлена на следующей схеме:
Как можно заметить, при данной модели организации многопоточности имеется всего один поток-обходчик, который проходит все клиенты и проверяет наличие пришедших от них данных. При условии найденых данных поток-обходчик переходит в состояние обработки данных клиента предварительно создав новый поток-обходчик, который идёт дальше. После обработки данных поток-обработчик переносит объект клиента в конец очереди ожидания и самоуничтожается.
Реализацию с применением данного исправления можно увидеть [в данном репозитории GitHub](https://github.com/gbytegear/TcpServer). Данный сервер рассчитан только для отправки бинарных данных по протоколу TCP, поскольку отправляет вместе с данными заголовок с их размером в байтах, так что для реализации HTTP-сервера данная реализация не подходит. Реализованно это именно так по причине того что TCP/IP — потоковый протокол, то есть данные идущие через TCP/IP никак не терминируются, что осложняет работу именно в случаях работы с сырыми данными, когда поток нельзя терминировать "завершающим символом", как это принято в текстовых потоках.
**UPDATE 2:** На текущий момент, реализация представленная в репозитории GitHub лишена недостатка с "потоковым голоданием". Операции чтения префикса размера бинарного пакета при получении пакета от клиента, а так же приёма новых соединения переведены в неблокирующий режим, а многопоточность реализована с помощью пула потоков. | https://habr.com/ru/post/503432/ | null | ru | null |
# Flexify плагин для выравнивания чего бы то ни было
Наверное каждый верстальщик, хотя бы раз в жизни сталкивался с версткой двух- или трех-колоночного макета. Хотя, сам макет сверстать несложно, если конечно колонки не различаются цветом фона, как например на хабре. А вот с разноцветными придется помучаться, потому что они имеют свойство тянуться по содержимому, а содержимое у соседних колонок, как правило, разной высоты.
Мне известны два способа решения этой проблемы:
— заключить обе колонки в контейнер, и поставить в фон двухцветную картинку;
— выставить колонкам одновременно вниз отрицательный марджин и положительный паддинг.
Оба способа имеют свои достоинства и недостатки, но сегодня я хочу рассказать выравнивании колонок с помощью плагина к JQuery — Flexify.
Flexify позволяет создавать полностраничные, подвижные слои в веб приложении, проще говоря, вы сможете выровнять нужные вам элементы на странице по высоте и ширине, назначать вертикальную или горизонтальную раскладку дочерних элементов блока, создавать строки и столбцы из элементов.
Flexify добавляет к Jquery функции **flow()** и **flex()**, после установки необходимых значений, нужно вызвать функцию: $(document).flexify().
Функция flow в качестве единственного аргумента принимает значения: 'vertical' или 'horizontal', эти значения определяют как именно будут растягиваться дочерние элементы. К примеру, приведенный ниже код, заставит все элементы, содержащиеся в html и body, раскладываться горизонтально:
`$(function () {
$('html, body').flow('horizontal');
$(document).flexify();
});`
Функция flex принимает два аргумента: значение растягивания и коэффициент. Значение растягивания — то что мы собираемся тянуть, например: margin-\*, padding-\*, border-\*, width, height, соответственно для позиционированных элементов: top, right, bottom, и left. Коэффициент растягивания — любое целое число больше 0, обычно 1.
Для того чтобы выровнять три колонки по высоте достаточно написать:
`$(function () {
$('#content, #sidebar, #sidebar2').flex('height', 1);
$(document).flexify();
});`
Как видно, пользоваться им достаточно просто и удобно. Плагин можно скачать [отсюда](http://plugins.jquery.com/project/Flexify), а ниже примеры его использования:
[Три колонки, выровнены по высоте](http://tim-ryan.com/projects/flexify/demos/expanding-cols.html)
[Центрированный блок с тянущимися полями и рамками](http://tim-ryan.com/projects/flexify/demos/centered-dimensions.html)
[Абсолютно позиционированный блок](http://tim-ryan.com/projects/flexify/demos/centered-position.html) | https://habr.com/ru/post/47895/ | null | ru | null |
# Cоздание прототипа социальной сети на ExtJS. Первые и не последние проблемы с ExtJS 4
Постоянно меняющиеся требования и сжатые сроки подтолкнули нас к использованию ExtJS 4 для создания прототипа.
Проблемы в ExtJS, с которыми мы столкнулись при разработке, едва ли превысили опыт, который мы получили при препарировании ExtJS.
В интернете много статей про ExtJS 4 уровня basic. Например очень порадовала эта статья [http://css.dzone.com/articles/how-use-extjs-4-jquery](http://css.dzone.com/articles/how-use-extjs-4-jquery "http://css.dzone.com/articles/how-use-extjs-4-jquery"). А вот серьезных “не кассовых” статей по решению (или созданию) каких-то проблем с помощью ExtJS не много.
Предлагаю вашему внимаю первую статью в рамках ExtJS patch lab… Ну и немного о самой соц. сети… совсем немного.
Для ленты постов решено было использовать **Ext.panel.Grid** с **Ext.data.Store**. Можно сказать это те фундаментальные вещи, ради которых и выбрали использование ExtJS.
Почему именно **grid**, а не **dataView** (в последствии конечное пришлось отказаться от грида в пользу вьюшки). У грида понравился визуальный режим сортировки и фильтрации данных, “бесконечный” скролл. Радость от предоставленных возможностей просто переполняла.
Ext.data.Store
==============
Данные приходят от сервера с помощью API вызова, далее в сыром виде передаются в метод **loadData** класса **Store**. Использовать встроеный в Store прокси не стали из-за наличия у нас API как у [Foursqure](https://github.com/praized/marelle/blob/master/src/api.coffee).
```
var myStore = Ext.create('Ext.data.Store', {
model: 'Post',
filterOnLoad: true,
idProperty: 'id',
filters: new Ext.util.Filter({
filterFn: function (item) {
return item.get("status") > 0;
}
})
});
…
API.Events.get().done(function(posts){
myStore.loadData(posts);
});
```
Модель Post из себя представляет наследника класса Ext.data.Model.
```
Ext.define('Post', {
extend: 'Ext.data.Model',
idProperty: 'id',
constructor: function (raw) {
return this.callParent([this.prepare(raw), raw[this.idProperty]]);
},
prepare: function (raw) {
…
}
});
```
В модели **Post** происходит подготовка сырых данных через метод **prepare**. В конструктор родительского класса данные приходят уже в обработанном виде.
Что происходит в методе **prepare**:
Например приведение даты поста из строки к объекту **Date**
```
this.data = new Date(this.data);
```
…получение строкового значения наименования поста из **typeId** через хэш таблицу соответствий
```
this.typeName = Dict.post.types[this.typeId];
```
И так далее...
**Store** хранит внутри себя данные в виде инстанцированных моделей, в методе **loadData** происходит проверка, если данные еще сырые, то передаем их в конструктор модели, и записываем ее у себя, и так с каждым элементом массива.
#### Приятная полезность #1
Таким образом **loadData** принимает как массив сырых объектов, так и уже инстанцированных моделей.
#### Особенность #1
При передачи в **loadData** единичного объекта произойдет ошибка, метод ожидает только массива, пусть даже из одного элемента.
#### Особенность #2
Объекты в **javascript** передаются по ссылке, поэтому переданные сырые данные в **loadData** станут массивом моделей.
```
API.Events.get().done(function(posts){
//posts is array of objects
myStore.loadData(posts);
//posts is array of Models
});
```
Если вам нужны исходные данные после загрузки в неизменном виде, используйте метод **Ext.Array.clone()**, но этот метод не поддерживает глубокого клонирования, как **jQuery.extend**.
#### Проблема #1
У метода **loadData** есть второй параметр **append** (append True to add the records to the existing records in the store, false to remove the old ones first). Т.е. от сервера приходят новые посты, мы их должны добавить к уже имеющимся. Для этого выставляем второй параметр **true**.
В нашем случае хранилище использует фильтрацию по загрузке (filterOnLoad = true)
Как работает фильтрация:
**Store** хранит все записи в двух коллекциях, основной – **data**, и в скрытой – **snapshot**. Ключ “filterOnLoad: true” в **Store** заставляет хранилище при загрузке данных любым способом проверять их на фильтрах и отбрасывать отфильтрованные в свое внутреннее хранилище **snapshot**.
Использование фильтров в Store и метод loadData несовместимы.
Листинг из файла ext-all-debug.js (Метод **loadRecords** используется **loadData**… и не только)
```
loadRecords: function(records, options) {
…
if (!options.addRecords) {
delete me.snapshot;
me.clearData();
}
me.data.addAll(records);
…
}
```
Вот здесь и кроется проблема, **options.addRecords** в нашем случае **true**, удаление **snapshot** не происходит, данные попадают только в основную коллекцию.
```
API.Posts.get().done(function(posts){
myStore.loadData(posts); //posts.length 8, filtered 2 entries
});
…
API.Posts.get().done(function(posts){
myStore.loadData(posts, true); //posts.length 10, filtered all entries
});
```
В этоге при первой загрузке прошли только 2 записи, а во втором все.
**me.data** содержит 2 + 10 записей, а **me.snapshot** только 8, т.к. данные из второго вызова не попали в скрытое хранилище.
Для того, чтобы пересортировать нашу коллекцию, нам нужно очистить старые фильтры и применить новые, нельзя просто “перечитать” фильтры (что очень и очень странно).
Метод mystore.clearFilter() убивает 10 последних записей, в итоге в хранилище у нас 8 записей.
#### Решение
```
loadRecords: function(records, options) {
…
if (!options.addRecords) {
delete me.snapshot;
me.clearData();
}
me.data.addAll(records);
//add records in snapshot too.
if (options.addRecords && me.snapshot) {
me.snapshot.addAll(records)
}
…
}
```
#### Проблема #2
Ключ **idProperty** не используется по назначению.
Поле **idProperty** это аналог первичного ключа в БД. В нашем случае данные имеют уникальный ключ ID, по которому свежие посты должны добавляться в хранилище. В случае изменения какого-то поста, например добавления к нему комментария мы должны обновить эту запись в хранилище. Метод **loadData** в режиме **append** с выставленным ключом idProperty = «id» должен решить эту проблему. Но на самом деле этот ключ не используется для этого, и мы не можем сделать объединение данных автоматом.
Покопавшись в исходникам я обнаружил что такой функционал присутствует, но попросту не используется. Метод me.data.addAll(records) может принимать не только массивы, но и объекты ключ-значение. Нужно лишь слегка модифицировать тот же метод **loadRecords** чтобы использовать эту возможность.
#### Решение
```
loadRecords: function(records, options) {
…
if (!options.addRecords) {
delete me.snapshot;
me.clearData();
}
me.data.addAll(records);
if (this.idProperty) {
var indexRecord = {};
for (i = 0; i < length; i++) {
indexRecord[records[i].data[this.idProperty]] = records[i];
}
me.data.addAll(indexRecord);
if (options.addRecords && me.snapshot) {
me.snapshot.addAll(indexRecord);
}
records = [];
for (key in indexRecord) {
records.push(indexRecord[key]);
}
length = records.length;
} else {
me.data.addAll(records);
if (options.addRecords && me.snapshot) {
me.snapshot.addAll(records);
}
}
…
}
```
После этим изменений в качестве ключа мы имеем значения **id**, и можем добавлять новые данные, они не будут дублироваться…
P.S. Не забываем, что лезть в исходники со своими правками плохо, используйте **Ext.override**. Таким образом вы избавляетесь от проблемы при обновлении версии фреймворка, вы просто пишите свой патч файл, и при исправлении в новой версии старой проблемы – вы удаляете свое решение из патча.
На горизонте рассмотрение проблемы синхронизации Store с его представлением, и что делать если представлений несколько.
Принимаются заявки, быть может есть какие-то более интересные проблемы и их решения. | https://habr.com/ru/post/129080/ | null | ru | null |
# Клонирование игры Lode Runner с первого ПК в СССР «БК-0010» плюс несколько слов о программировании игр в конце 80-х
Недавно я оказался в не совсем обычной для себя ситуации вынужденного безделья. Пару недель поваляв дурака, я стал чувствовать, что это не такое уж и веселое занятие, которое к тому же еще и стало переходить в скуку. И мне надо было себя занять чем-нибудь относительно полезным. Раньше мне периодически приходили в голову мысли о том, чтобы вернуть к жизни какую-нибудь старую игру из времен моей юности. Но я всегда гнал такие идеи прочь, так как понимал, что "*никому это теперь не надо*". Но сейчас у меня было свободное время и, главное, было желание. В результате для клонирования я выбрал один из вариантов игры **Lode Runner**, в который я когда-то играл на первом персональном компьютере времен позднего **СССР**, который назывался **БК-0010**. Не думаю, что многие о нем помнят, так как мир «железа» поменялся с тех времен очень сильно. Однако сам **Lode Runner** с этого **БК-0010** был достаточно уникален своими правилами среди других одноименных **Lode Runner**-ов. Эта версия игры была моей самой любимой, как мне кажется, по объективным причинам, хотя… может быть тут дело просто в ностальгии. В результате я сумел себя мотивировать тем, что "*лично мне*", а, возможно, и "*всему миру*", эта игра может быть интересна, и на её восстановление стоит потратить время ([ссылка на полученный результат](http://astralax.ru/projects/others/loderunner)).
Для начала взглянем на оригинал с **БК-0010** (хвала Интернету, в котором можно найти почти всё):
Правила игры достаточно просты. Необходимо собрать все сокровища в лабиринте, затем появится «дверь», через которую можно выйти на следующий уровень. Но выполнению этой благородной задачи мешают злые охранники, которые преследуют беззащитного главного героя. Хотя… есть у нашего героя одно секретное оружие — в кирпичном полу можно пробивать дырки, делая ловушки для охранников. Охранник проваливается в такую дырку и некоторое время считается пойманным. В этот небольшой промежуток времени главный герой может бегать охраннику по голове.
Отличительной особенностью версии игры на **БК-0010** было то, что главный герой дырявил кирпичи строго под собой, а не справа или слева, как это происходило, например, на **Lode Runner** с компьютера **ZX-Spectrum**. В результате можно было бежать вперед, оставляя за собой продырявленный пол, куда падали преследователи. И эта особенность как раз и выделяла для меня этот **Lode Runner** из всех других одноименных игр.
При полном клонировании в разработке есть как плюсы, так и минусы. Безусловным плюсом является то, что есть возможность заранее четко представить себе цель, также можно использовать игровые уровни, которые уже есть в версии для **БК-0010**. Минусы же заключаются в том, что поведение главного героя и охранников должно быть реализовано максимально близко к оригиналу. И если с главным героем всё более-менее ясно, то у охранников есть что-то наподобие **AI**, который имеет-таки массу мелких особенностей, требующих повторения в моем коде. Критические отклонения в поведении охранников могут сделать уровни с **БК-0010** неинтересными либо вообще непроходимыми. А это убивает весь смысл клонирования.
Начал я с того, что нашел в Интернете уже кем-то переделанный вариант **Lode Runner**-а с **БК-0010**. Однако маленько поиграв в него, я понял, что он похож только с виду. Несмотря на внешнюю схожесть, на мой взгляд, автор не дал себе труда поработать над поведением охранников, поэтому перемещались они не так, как это было в оригинале. А когда я «замуровал» одного из охранников в кирпичах, игра сбилась. Но в этой версии был важный для меня плюс — здесь присутствовал редактор уровней, и эти уровни также были старательно перерисованы из оригинала. А мне эти уровни как раз были очень нужны.
Несмотря на то, что игра была по современным меркам простенькой, она требовала, чтобы у неё был какой-то **интерфейс пользователя**, т.е. те же кнопки меню должны были как-то функционировать. Также у меня присутствовала *навязчивая идея* о том, чтобы игра была легко переносимой на разные платформы. К счастью для меня, я уже делал подобную оболочку для своей классической RTS **Земля онимодов** (статью о том как я её делал можно найти [тут](https://habrahabr.ru/post/280520/)). Оболочка эта имеет важную особенность — она не общается с **ОС** напрямую, а только через виртуальные функции, которые можно относительно легко заменить. Также оболочка имеет достаточно продвинутый **GUI**, который с виду может не сильно отличается от интерфейса **Windows**:
Запись/чтение файлов, файловые потоки, работа с мышью и клавиатурой, воспроизведение звука, вывод графики и управление режимами экрана — всё это также было предусмотрено в моей оболочке. Поэтому я пошел именно этим путем — решил допрограммировать к оболочке небольшую игру.
*Больше информации по этой оболочке можно найти в моей [прошлой статье](https://habrahabr.ru/post/327596/).*
Игра не требовала каких-то серьезных вычислительных мощностей, поэтому я решил не заморачиваться и рисовать графику процессором. Логика тут очень проста. Создаем поверхность в памяти, выводим туда картинку процессором, потом копируем эту поверхность на текстуру **DirectX** или **OpenGL** в видеопамяти и эту текстуру уже выводим на монитор. Такой подход хорош тем, что он максимально упрощает перенос между разными платформами. А так как бороться за быстродействие мне не придется, то я посчитал этот путь единственно правильным, тем более, что оболочка на текущий момент также строит своё изображение процессором.
Обычно я всем говорю, что если вы делаете игру с нуля, то нужно начинать с редактора ресурсов. Такой редактор, практически, должен позволять собирать персонажа из спрайтов и визуально прописывать все его характеристики. Однако в данном случае персонажи были устроены слишком просто, и поэтому я отошел от собственного правила, перейдя сразу к редактору уровней. В моем случае всё это выглядит так:
Здесь можно выбрать уровень для редактирования, создать новый или удалить надоевший. Само редактирование уровня также выглядит очень просто, так как лабиринт состоит всего лишь из нескольких деталей.
Естественно, что в начале у меня никакой графики не было — я надергал из Интернета каких-то иконок и превратил их во «временную графику». Живые объекты у меня также в начале представляли из себя статические картинки, которые, в прямом смысле, плавно ездили по уровню. Но такой подход позволил мне запрограммировать почти всю логику игры не прибегая к помощи художника. Художником, кстати, выступил мой старый друг Константин Иванов, который уже давно ничем подобным не занимался, так как в настоящий момент тратит свою жизнь на создание рекламных видеороликов в одной казанской компании. И эти видеоролики ему уже порядком надоели. Поэтому, к моему удивлению, он достаточно активно взялся за оформление моей явно некоммерческой затеи. В результате всё оформление нами было сделано за 2 ночи в сочетании в уничтожением алкогольной продукции. Тут надо уточнить, что сам я по графике ничего не делал — только предлагал и критиковал, а рисовал Константин.
Так как в оригинальном варианте игры персонажи представляли из себя нечто невнятное по причине малого количества пикселей на клетку уровня, то мы решили их поменять. Привидения вполне подходили на роль охранников, к тому же у них было большое достоинство — им не нужно ногами двигать во время перемещения, что упрощает рисование. А вот с главным героем так просто не получилось. Первый вариант, который выдал мне Константин, определенно напоминал мне «жидкого Терминатора» в миниатюре. И было очевидно, что ему надо не убегать от привидений, а охотиться на них. Однако сюжет игры требовал другого. В результате я дал Константину книгу Николая Козлова "*Истинная правда или учебник психолога по жизни*", а там куча иллюстраций примерно такого типа:
И через несколько минут он мне выдал нашу «колобчиху» , которую мы в результате и отправили на поиски сокровищ. На всякий случай уточняю, что Константин рисовал ей «ручки», а не «ушки», но визуально это не совсем очевидно.
Потом мы старательно переносили все уровни из оригинала в нашу игру. Я их открывал в той не самой удачной версии, о которой я упоминал ранее, затем нажимал **PRINTSCREEN**, закидывал в **Photoshop** и оттуда печатал на принтере. Да… перед печатью еще делал инверсию изображения, чтобы не заставлять принтер печатать много-много черного цвета. И, глядя на этот лист, я просто рисовал в своем редакторе уровней то же самое. После того, как все 26 уровней были перенесены, мы с удовольствием дорисовали несколько собственных.
Лично у меня самые большие сложности были из-за необходимости почти точно повторить алгоритм поведения охранников. Практически, приходилось играть и глазами выискивать в каких-то редких ситуациях неадекватность действий «спецслужбы лабиринта». И не так сложно было исправлять эти ситуации, как сложно было их обнаружить. Но мне очень хотелось сделать поведение аналогичным тому, что было в оригинале и, надеюсь, что это мне удалось.
Был когда-то в конце существования **СССР** такой мультфильм, который назывался "*Босой ученый*". Там один, ну, очень умный восточный мыслитель пошел на рынок за новыми ботинками. И там он увидел, что какой-то художник продает картины, на которых нарисованы всякая живность, в частности, там были и петухи. И мыслитель говорит художнику:
— У тебя же талант. Зачем ты его тратишь на то, чтобы рисовать петухов? Нарисовал бы лучше что-нибудь великое, например, бога.
А художник ему и отвечает:
— Бога нарисовать слишком просто, поэтому мне это неинтересно.
— Неужели ты считаешь, что бога нарисовать проще, чем какого-то там петуха? (возмутился мыслитель)
— Конечно, проще (отвечает художник). Бога же никто не видел. Нарисуй я его с рогами или без головы — никто не скажет, что я нарисовал его неправильно. А вот если я нарисую неправильно петуха, то все сразу скажут, что я не умею рисовать.
*(рассказал по памяти — смотрел мультик очень давно, но эта мысль мне определенно показалось дельной)*
В общем саму игру я осилил примерно за недельку, но потом добавляли графику и звук, рисовали уровни и, самое главное, я-таки решил поиграться в **кроссплатформенность**. До этого момента я никогда не писал приложений под **Linux** или **Mac OS** (хотя вру… под **Mac OS**, **iOS**, **Android** и **WinPhone** я делал примеры работы своего [движка спецэффектов](http://astralax.ru/titles), но это были отдельные проекты, а сейчас мне надо было портировать один и тот же продукт везде).
Я обнаружил, что мир **Linux**/**Unix** очень разнообразен и сильно отличается в мелочах, несмотря на общие правила. Разбираться с этим многообразием я для себя посчитал делом немыслимым, но портировать всё же очень хотелось. Поэтому я взял движок **SDL**, который, к счастью, берет на себя все эти тонкости работы различных юниксообразных **ОС**. Для портирования на **Linux** я поставил на виртуальную машину **Fedora-64** и в ней установил среду **Code::Blocks**. Дописал к своей оболочке новые классы, которые через виртуальные функции обращались бы к этому **SDL**. Создал объекты этих классов, вместо объектов классов, которые взаимодействовали с **Windows** и… собственно всё. К моему удивлению, виртуальная машина вполне воспроизводила игру в реальном времени, разве что звуки чуть-чуть запаздывали.
**Mac OS** сопротивлялся дольше **Linux**-а, так как я поленился переносить проект на **XCode** и установил в **Mac OS** тот же **Code::Blocks**. И тут я обнаружил, что отладчик-то не работает. Я понимал, что всё дело в какой-то мелочи, так как после **Linux**-а проект на **Mac OS** даже сразу собрался, но возможности запустить отладчик у меня всё равно не было, хотя я и попытался установить GDB. (Возможно, что у меня на **Mac**-е жутко древняя операционка **Lion**, и отсюда проистекают проблемы с отладчиком). В результате, я просто стал выводить сообщения в консоль. Оказалось, что проблема была в путях к папке с игрой и к папке для сохранения данных. Как только я исправил эти функции, игра запустилась.
Отдельное время у меня отняла задача по открытию в браузере ссылок. Как это делать в **Windows** я, конечно, знал:
```
void GPlatformWindows::OpenLink(const char* link)
{
ShellExecute(NULL, _T("open"), link, NULL, NULL, SW_MAXIMIZE);
}
```
А вот **Linux** порядком помотал мне нервы с этими ссылками. В результате я сделал так:
```
void GPlatformUnix::OpenLink(const char* link)
{
ToIconic(); // сворачиваем окно с игрой
#ifdef __APPLE__
// для MAC OS
CMagicString param="open ";
param+=link;
system(param);
#else
// для Linux
CMagicString param="xdg-open ";
param+=link;
param+=" &";
system(param);
#endif
}
```
Не уверен, что это самое лучшее решение, но оно в моем случае вполне работает.
**Итоги:**
Полученные результаты меня вполне устроили. Я сам с удовольствием поигрался в *свое творение* и считаю, что качество данного клона вполне приемлемое. Кроме того, я очень редко берусь за проекты, которые по своему объему очень мелкие. А малый объем работы приносит быстрый результат и, соответственно, ощущение «новой звездочки на крыле». Кроме того, мелкие проекты завершаются быстрее, чем они успевают надоесть.
Если будут желающие «*заценить*» данное произведение, то я записал небольшое видео на тему того, как правильно играть в мой **Lode Runner**:
*Совет по игре: чтобы дырявить пол лучше удерживать пробел, а не барабанить по нему.*
**Разработчики:**
— Программирование: **Алексей Седов** (он же **Odin\_KG**, он же студия **Astralax**)
— Графика: **Константин Иванов**
Платформы: **Windows**, **Linux**, **Mac OS**
Ссылка на страницу с игрой: [Lode Runner](http://astralax.ru/projects/others/loderunner)
### О программировании игр в стародавние времена (лирический раздел)
Я начинал интересоваться программированием почти в то же время, когда появлялись эти первые игры на первых компьютерах, доступных простому населению **СССР**. И эти первые игры произвели на меня гораздо большее впечатление, чем какая-либо современная высокотехнологичная коммерческая игра с огромным бюджетом и мощным пиаром. И тут всё очень понятно. Впервые я увидел компьютерную игру в тот же момент, когда я впервые узнал о существование компьютеров. Т.е. вот представьте себе следующее: человек знает про радио, телевизор и пылесос, но он вообще понятия не имеет, что на свете есть такая штука как компьютер. Узнал я это в «салоне компьютерных игр», куда отправились все мои тогдашние приятели по общему двору, чтобы посмотреть на эту диковинку. (Тогда как раз в стране стали появляться первые кооперативы, и салоны компьютерных игр скоро стали обычным бизнесом). И в этом салоне стояли как раз те самые **БК-0010** с черно-белыми маленькими телевизорами.
Поиграть на этом чуде стоило тогда 1 руб/час. И первое, что я увидел выглядело так:
Это игра **Land**, которая показала мне, что изображением на телевизоре, оказывается, можно управлять. И всё это называется «КОМПЬЮТЕР». Сейчас, оглядываясь назад, я предполагаю, что тогда мне было ориентировочно 13 лет.
Не знаю как бы сложилась моя жизнь, если бы я в своё время вот так вот не познакомился с компьютерными играми. Но тогда я, естественно, и мечтать не мог, что когда-нибудь смогу взять да и запросто сам создать компьютерную игру. К этому этапу я смог перейти только через пару лет, когда у меня появился первый самодельный компьютер **Специалист**. А вот и он, кстати:
Потом было несколько вариантов **ZX-Spectrum**, максимальным по навороченности из которых был **ATM-turbo**, но это всё растянулось по времени на несколько лет. **ATM-turbo** я себе смог позволить только уже когда учился на втором курсе (сэкономил 10 стипендий, чтобы купить радиодетали). По образованию, я, кстати, химик-технолог, и я очень рад, что в свое время не пошел учиться на программиста — академическая модель обучения, на мой взгляд, вырабатывает у учащегося жесткое отвращение к получению знаний в этой области.
Несмотря на то, что сейчас игры типа **Lode Runner** выглядят примитивными, когда-то они таковыми не являлись. И автору оригинала (насколько мне известно его зовут **А.Марков**) приходилось не так легко как мне с моим клонированием. В то время разработка велась совсем не такими методами как сейчас. Это станет понятно, если мы просто вспомним технические характеристики того же самого **БК-0010**.
**Процессор:** *К1801ВМ1* (щестнадцатиразрядный) с тактовой частотой **3 МГц**
**ОЗУ:** *16 килобайт*
**Видеопамять:** *16 килобайт* (на деле отдельной видеопамяти раньше не было — это часть того же самого ОЗУ, которая постоянно выводилась на монитор)
**ПЗУ:** *32 килобайта* (тут были Бейсик или Фокал, а также всякие системные функции)
**Устройство хранения информации:** *бытовой магнитофон и кассеты* (скорость загрузки примерно 10 килобайт в минуту)
**Устройство отображения:** *телевизор* (в редких случаях монитор)
Визуально **БК-0010** представлял из себя толстую клавиатуру, внутри которой находилось сразу всё.
Стоимость составляла 650 рублей (при зарплате инженера в 120 рублей, фрезеровщика в 200 рублей, а начальника в 300 рублей)
Я сам на этом БК-0010 никогда не программировал (он был слишком дорогой да и, на мой взгляд, не идеальный), но, по сути, я начинал примерно в то же время. И, я понимаю, что тогда разработчику нужно было, ох, как постараться, чтобы создать на таком железе и, самое главное, с имеющимися программными инструментами, что-то стоящее. Да и сам процессор физически был очень слаб — программист обычно считал такты, за которые выполняется та или иная команда, чтобы оптимизировать код. По-моему, на **БК-0010** были еще и какие-то проблемы с **ассемблером**, так как один мой знакомый программировал на **БК-0010** просто "*в кодах*". На деле, это значит, что забиваешь память цифрами, которые что-то значат для процессора, но визуально мало о чем говорят человеку. (Я этим в начале, кстати, тоже занимался, пока не узнал, что такое **ассемблер** и не набрал его ручками в виде списка байтов из одного журнала). Например, число 06 означало для процессора команду копирования содержимого регистра B в регистр A, что можно было записать на **ассемблере** в более понятном человеку виде как **MOV A,B** (для процессора **КР580ВА80**) или **LD A,B** (для процессора **Z-80**). Но это еще кое-как можно было запомнить, но дела с переходами по адресам обстояли еще хуже. При программировании в кодах нужно вписывать прямой адрес или смещение от текущего адреса до того, куда программа должна перескочить. А если приходилось вставлять в код изменения, то адреса сдвигались и надо было все адреса переходов расставлять заново. Некоторые для этих целей вставляли в код множество команд **ассемблера** NOP (код 00), которая просто ничего не делает — такие команды потом можно было заменить на что-то другое не трогая адреса.
Рисовать графику, кстати, тоже было негде. Я, например, в то время отмечал карандашом точки на миллиметровке, а потом переводил эти точки в байты и эти байты вводил в компьютер ручками. И не думаю, что у автора оригинального **Lode Runner**-а были какие-то сильно отличающиеся от моих возможности.
Я всё это к тому, что меня всегда удивляло часто пренебрежительное отношение к этим старым играм. Делать всё это было крайне сложно, и не у кого было спросить совета, так как разбирались в этом единицы, а Интернета тогда еще даже в планах не было. Единственный плюс, который, на мой взгляд, тогда присутствовал — это интерес к этой работе со стороны игроков. Людей с компьютерами было мало, но они были, скажем так, благодарными пользователями — появление новой игры вызывало интерес и игра быстро расходилась по тем же салонам компьютерных игр. И я не помню, чтобы кто-то когда-то говорил гадости на тему «какая отстойная игра» или что-то в этом духе. Короче, не было перенасыщения рынка, которое есть сейчас, что лично для меня всегда ставило под сомнение необходимость в создании новых игр. Ведь в реальности все существующие сейчас игры даже пересмотреть невозможно, не то что переиграть.
Также я не уверен, что раньше создание игр приносило какую-то ощутимую прибыль их создателям — думаю, что это было чистое творчество, которое сейчас, практически, уничтожено коммерческими отношениями в обществе. Тихо сдохли и радиолюбительство и интерес к муз.школе и вообще всё, что предполагает занятия чем-то не ради чистой прибыли.
Закончить я хотел бы словами благодарности в адрес разработчиков той эпохи (речь шла про отрезок времени: конец 80x — начало 90х). А также лично в адрес тов. Маркова, с которым я не знаком, но тем не менее его игра произвела на меня в возрасте 13-14 лет большое впечатление. Как не крути, именно эти энтузиасты стояли у истоков российского игростроя. Но главное, они зародили интерес к теме программирования у тех, кто «шел следом за ними». И я, в отличии от многих, понимаю, сколько это тогда требовало сил и терпения.
Благодарю за внимание!
Алексей Седов | https://habr.com/ru/post/335968/ | null | ru | null |
# Установка Oracle JDK 7 в Ubuntu 12.04
Приветствую всех обновившихся и тех кто планирует.
Как многие из вас знают, проприетарная ява была выпилина из официальных репозитариев.
Взамен, юзерам предложили пользоваться *OpenJDK*.
Однако со стабильностью работы последней имеются серьезные проблемы.
Но обо всем по порядку…
Сегодня, установив на сервер, новенький *proxmox 2.1*, обнаружил, что после обновки
своей системы у меня не работает консоль KVM.
Быстро сообразил, что нужно бы поставить jre и полез в терминал и недолго думая
устанавливаю *openjdk-6-jdk* c *icedtea-6-plugin* для работы апплетов.
Перезапускаю браузер, захожу на вкладочку веб-морды проксмокса, запускаю консоль.
На этом все собственно и закончилось, точнее наборот начались танцы, ибо вот неполный список
проблем с которыми я столкнулся используя как *openjdk-6-jdk*, так и *openjdk-7-jdk*:
1) При закрывании окна консоли, *Firefox* ложился целиком вместе с ним.
2) Инициализация апплета, происходит со 100% загрузкой ЦП, в момент которого браузер блокируется.
Продолжается довольно долго, из-за чего очень сильно бесит.
3) Куча всплывающих ошибок proxmox.
Надо признаться, это был мой первый опыт общения с OpenJDK и вероятно последний.
Наконец, я решил установить проприетарную яву, и полез терроризировать гугл,
рассказать как это сделать с минимальными потерями.
Оказывается, в сети уже подсуетились некоторые ребята и сделали ppa.
Я было обрадовался, но не тут то было.
После того как проследовав пошагово до пункта *sudo apt-get install*,
апт выдал мне ошибку «Errors were encountered while processing: oracle-java7-installer».
Опять полез в гугл и нашел как это вылечить. На случай, если кто-то попался, [привожу ссылку](http://askubuntu.com/questions/126372/sha256sum-mismatch-jdk-7u3-linux-x64-tar-gz-error-when-trying-to-install-orac), с излечиванием от этой болезни.
Найти решение в сети я отчаялся, поэтому решил пойти другим путем — проверенно рабочим.
Путем нехитрых манипуляций, мне удалось заставить все работать, при чем результаты приятно удивили.
В частности, проблемы как с производительностью, так и с крахом браузера исчезли.
#### Суть
Итак, у нас есть 2 варианта, того, как произвести установку, оставив систему чистой.
Прежде чем приступать, рекомендую вычистить систему от OpenJDK:
```
sudo apt-get purge openjdk*
```
Эта команда удалит всё, что имеет отношение ко всем версиям OpenJDK.
##### Способ номер 1.
Короткий и быстрый вариант(если у вас x86\_64),
где .deb пакет уже заранее подготовлен мной, выложен в сеть, и остается лишь скачать и установить его:
1) [Скачиваем пакет](http://narod.ru/disk/47531943001.02624632cd3be197653b724261967592/jdk_1.7.004-1_amd64.deb.html).
2) Выполняем в терминале 4 команды:
```
# Необходимо предварительно выполнить переход(команда cd) в директорию,
# куда производилась загрузка .rpm пакета.
sudo dpkg -i jdk_1.7.004-1_amd64.deb
mkdir -p ~/.mozilla/plugins
ln -s /usr/java/jdk1.7.0_04/jre/lib/amd64/libjavaplugin_jni.so ~/.mozilla/plugins/
ln -s /usr/java/jdk1.7.0_04/jre/lib/amd64/libnpjp2.so ~/.mozilla/plugins/
```
3) Перезапускаем браузер и радуемся сэкономленному времени.
Если конечно у вас стоит 64-битная версия панголина.
##### Способ номер 2, от начала до конца.
1) Идем на [сайт загрузок](http://www.oracle.com/technetwork/java/javase/downloads/index.html) Java SE, и качаем пакет(.rpm), согласно нашей архитектуре:
[Linux x86 (32-bit)](http://download.oracle.com/otn-pub/java/jdk/7u4-b20/jdk-7u4-linux-i586.rpm)
[Linux x64 (64-bit)](http://download.oracle.com/otn-pub/java/jdk/7u4-b20/jdk-7u4-linux-x64.rpm)
2) Устанавливаем alien, по сути это конвертер пакетов который перепакует скачанные .rpm пакеты в
нужный нам формат .deb, со своими хитростями.
```
sudo apt-get install alien
```
3) Натравливаем «чужого» на скачанный rpm.
```
sudo alien jdk-7u4-linux-x64.rpm --scripts
```
На данном этапе, будет сгенерирован .deb пакет, в той же директории.
4) Далее по накатанной, устанавливаем пакет, создаем симлинки и радуемся жизни.
```
sudo dpkg -i jdk_1.7.004-1_amd64.deb
mkdir -p ~/.mozilla/plugins
ln -s /usr/java/jdk1.7.0_04/jre/lib/amd64/libjavaplugin_jni.so ~/.mozilla/plugins/
ln -s /usr/java/jdk1.7.0_04/jre/lib/amd64/libnpjp2.so ~/.mozilla/plugins/
```
Сразу оговорюсь, что не стою на том, что виновата во всем OpenJDK, но опыты ставились
на свежеустановленной 12.04 и все проблемы разрешились после установки проприетарной версии. | https://habr.com/ru/post/143113/ | null | ru | null |
# Знакомство с Rome от создателей Babel — компилятор, сборщик, линтер, тесты в одном флаконе
Почти две недели назад вышла [запись в блоге](https://romefrontend.dev/blog/2020/08/08/introducing-rome.html) по поводу Rome.
Rome представляет собой целый набор инструментов — линтер, компилятор, сборщик, тест раннер и даже больше. Нацелен он на JS, TS, HTML, JSON, Markdown, CSS. Проект пытается унифицировать набор инструментов необходимых для фронт-енд разработки.
Rome монолитный и включает все традиционные инструменты фронт-енд экосистемы. Команда разработчиков называет это toolchain. Важным моментом является, то, что это не попытка объединить существующий набор инструментов, а разработать полностью новый набор инструментов. Все это должно быть в одном пакете и единой кодовой базой.
Rome разрабатывается как замена Babel, ESLint, Webpack, Prettier, Jest и прочих.
Посмотрим к чему это приведет, если честно меня устраивает некоторая конкуренция и «не монолитный» подход в инструментах разработки. Да, для новичка вход не очевиден, слишком большое изобилие инструментов, которые в большинстве своем взаимозаменяемы. Возможно в таком нюансе, Rome немного снизит порог входа.
### Текущее состояние
Rome находится в бете и уже справляется с некоторыми своими обязанностями. Например у линтера уже поддерживается 100 правил, включая те, что часто используемые при использовании Typescript и React. Полный список правил можно найти [тут](https://romefrontend.dev/docs/lint/rules/)
[Опенсорс проекта](https://github.com/romefrontend/rome) начался с начала года и у проекта уже 70 контрибьютеров и более 600 комитов. В целом проект развивается и пока каких либо затуханий не видно.
### Немного истории
В 2014 году был создан 6to5 (сейчас называется Babel). Это JavaScript транспайлер который копмпилировал новый код на ES6 в ES5. В тот момент проект не ставил каких либо целей, но с ростом популярности приходилось корректировать разработку.
6to5 переименовали в Babel и новой задачей было стать общей платформой для статических трансформаций JavaScript. Это означало систему плагинов и поддержку новых фичей будущих JavaScript стандартов и даже «proposals».
Команда разработчиков думала пойти еще дальше. Babel должен быть под капотом минифайеров, линтеров, форматтеров, подсветки синтаксиса, проверщиков типов, инструментов компиляции и так далее.
В 2016 году создатель Babel покинул проект. Со временем стало понятно, что подход с предоставлением широкого API (буквально всех внутренностей) слишком трудно поддерживать. Для поддержки вышеописанного инструментария, потребовалось бы переписать буквально все. Архитектура проекта связана с решениями которые автор делал еще в 2014 году, только изучая как работают парсеры AST и компиляторы. Изменения бы затронули большую часть API без возможности обратной совместимости.
Разработчики инструментов под JavaScript, тратят огромное количество времени на обработку исходного кода. Babel, ESlint, Webpack, частично занимаются одним и тем же.
Линтеры в экосистеме JavaScript равнозначны компиляторам. Оба принимают на вход исходный код, оба его обрабатывают и на выход выдают код и ошибки (если есть). Отличается лишь полученный код. В случае с линтером, это отформатированный исходный код с с исправлениями.
Чем сильней ваша инфрастуктура компиляции, тем сильней линтер. То же самое относится и к другим инструментам, которые так или иначе обрабатывают код. Мы можем создавать более мощные инструменты, используя общую базу, которую легко адаптировать.
> Rome — духовный преемник Babel. Я усвоил уроки и поставил четкие цели. Вместо того, чтобы предоставлять слишком объемный публичный API для других инструментов, мы собираем их все в одном месте. Я очень рад попробовать что-то новое, чего раньше не видел JavaScript и веб-экосистема.
— Sebastian McKenzie
### Использование
Rome можно установить используя Yarn или NPM:
```
yarn add rome
```
```
npm install rome
```
#### Создание проекта
Для того, что бы Rome смог найти ваши файлы, ему нужна конфигурация. Для автоматического создания проекта можно использовать:
```
rome init
```
Эта команда создаст директорию *.config* и поместит туда **rome.rjson**, с конфигурацией проекта.
Если у вас есть существующий проект, то можно сразу автоматически применить форматирование и исправления:
```
rome init --apply
```
> RJSON это расширение JSON, которое добавляет некоторые фичи. Например комментарии в JSONе.
Запустить линтер можно с помощью
```
rome check
```
### Линтинг
Rome разрабатывается с мыслью предоставления максимального количества информации для исправления ошибок. У проекта есть своего рода кредо:
Богатый UI (результат в консоли): Хорошо отформатированная информация, подсветка синтаксиса, ссылки, списки и прочее.
Исправления: Rome может исправить большое количество ошибок (как линтер) и применить их автоматически. Если есть несколько путей решения, то инструмент предоставляет вам выбор.
Процесс ревью: CLI интерактивно богат и позволяет прямо в консоли принимать решения по исправлениям и пробегаться по всем ошибкам.
Редакторы: Rome интегрируется с редакторами, что позволяет делать форматирование на сохранения, подсветку ошибок и тд.
Сохранность: Rome кеширует оригинальные файлы перед тем как сделать изменения. Используя **rome recover**, можно откатить исправления.
### Вместо заключения
Пока этот инструмент еще находится в активной разработке, но его уже как-то можно попробовать. Главное, что бы не получилось вот так:
[Офф документация](https://romefrontend.dev/) | https://habr.com/ru/post/515914/ | null | ru | null |
# Среда разработки PHP на базе Docker
Решение, которое позволит создать на локальном компьютере универсальную среду разработки на **PHP** за **30 — 40 минут**.
Почему Docker?
--------------
* Docker не является VM-системой, он не моделирует аппаратное обеспечение компьютера. Используя Docker вы получите минимальное потребление ресурсов. Docker-контейнеры взаимодействуют напрямую с ядром вашего компьютера (или ядром хоста), но при этом изолируют программу на уровне процесса.
* Высокая скорость развертывания. Вы можете использовать готовые docker-образы, которые устанавливаются и запускаются за секунды.
* Приложения, находящееся внутри docker-контейнеров, можно запустить на любом компьютере с установленным Docker, при этом окружение будет одинаковым.
* Возможность простой сегрегации пользовательских данных и контейнеров-сервисов. Если вы сломаете или удалите docker-контейнер, то данные не потеряются, так как они не будут принадлежать контейнеру. Контейнер выполняет лишь функцию сервиса, и не хранит данные, которые нельзя потерять между запусками.
* Вы можете очень быстро добавлять новые контейнеры, изменять их конфигурацию, запускать различные версии баз данных на одной машине.
Требования
----------
* Git.
* Docker engine 19.x и выше.
Возможности и особенности среды разработки
------------------------------------------
* Несколько версий **PHP — 7.3 и 7.1** с набором наиболее востребованных расширений.
* Возможность использовать для web-проектов разные версии **PHP**.
* Готовый к работе монитор процессов **Supervisor**.
* Предварительно сконфигурированный веб-сервер **Nginx**.
* Базы данных: **MySQL 5.7**, **MySQL 8**, **PostgreSQL** (latest), **MongoDB 4.2**, **Redis** (latest).
* Настройка основных параметров окружения через файл **.env**.
* Возможность модификации сервисов через **docker-compose.yml**.
* Последняя версия **docker-compose.yml**.
* Все docker-контейнеры базируются на официальных образах.
* Структурированный **Dockerfile** для создания образов **PHP**.
* Каталоги большинства docker-контейнеров, в которых хранятся пользовательские данные и параметры конфигурации смонтированы на локальную машину.
В целом, среда разработки удовлетворяет требованию — **при использовании Docker каждый контейнер должен содержать в себе только один сервис**.
**Репозиторий проекта**
[https://github.com/drandin/docker-php-workspace](https://github.com/drandin/docker-php-workspace?ref=vc.ru)
Структура проекта
-----------------
Рассмотрим структуру проекта.
```
├── .env-example
├── .gitignore
├── .ssh
├── README.md
├── docker-compose.yml
├── mongo
├── mysql-5.7
├── mysql-8
├── nginx
├── php-ini
├── php-workers
├── php-workspace
├── postgres
├── projects
└── redis
```
**Примечание**
В некоторых каталогах можно встретить пустой файл .**gitkeep**. Он нужен лишь для того, чтобы была возможность добавить каталог под наблюдение Git.
**.gitkeep** — является заполнением каталога, это фиктивный файл, на который не следует обращать внимание.
### .env-example
Пример файла с основными настройками среды разработки.
```
# Временная зона
WORKSPACE_TIMEZONE='Europe/Moscow'
# XDEBUG
DOCKER_PHP_ENABLE_XDEBUG='on'
# Настройки Nginx
# Порт, который следует использовать
# для соединения с локального компьютера
NGINX_PORT=80
# Настройки Redis
# Порт, который следует использовать
# для соединения с локального компьютера
REDIS_PORT=6379
# Настройки Postgres
POSTGRES_DB=test
POSTGRES_USER=pg_user
POSTGRES_PASSWORD=secret
POSTGRES_PORT=54322
# Настройки общие для MySQL 8.x и MySQL 5.7.x
MYSQL_ROOT_PASSWORD=secret
MYSQL_DATABASE=test
# Настройки MySQL 8.x
# Порт, который следует использовать
# для соединения с локального компьютера
MYSQL_8_PORT=4308
# Настройки MySQL 5.7.x
# Порт, который следует использовать
# для соединения с локального компьютера
MYSQL_5_7_PORT=4307
# Настройки MongoDB
# Порт, который следует использовать
# для соединения с локального компьютера
MONGO_PORT=27017
# Настройки PHP 7.3
# Внешний порт, доступен с локального компьютера
PHP_7_3_PORT=9003
# Настройки PHP 7.1
# Внешний порт, доступен с локального компьютера
PHP_7_1_PORT=9001
```
### .gitignore
Каталоги и файлы, в которых хранятся пользовательские данные, код ваших проектов и ssh-ключи внесены в. gitignore.
### .ssh
Этот каталог предназначен для хранения ssh-ключей.
### readme.md
Документация.
### docker-compose.yml
Документ в формате **YML**, в котором определены правила создания и запуска многоконтейнерных приложений **Docker**. В этом файле описана структура среды разработки и некоторые параметры необходимые для корректной работы web-приложений.
### mongo
Каталог базы данных MongoDB.
```
├── configdb
│ └── mongo.conf
├── db
└── dump
```
**mongo.conf**— Файл конфигурации **MongoDB**. В этот файл можно добавлять параметры, которые при перезапуске MongoDB будут применены.
**db** — эта папка предназначена для хранения пользовательских данных MongoDB.
**dump** — каталог для хранения дампов.
### mysql-5.7
Каталог базы данных MySQL 5.7.
```
├── conf.d
│ └── config-file.cnf
├── data
├── dump
└── logs
```
**config-file.cnf** — файл конфигурации. В этот файл можно добавлять параметры, которые при перезапуске MySQL 5.7 будут применены.
**data** — эта папка предназначена для хранения пользовательских данных MySQL 5.7.
**dump** — каталог для хранения дампов.
**logs** — каталог для хранения логов.
### mysql-8
Каталог базы данных MySQL 8.
```
├── conf.d
│ └── config-file.cnf
├── data
├── dump
└── logs
```
**config-file.cnf** — файл конфигурации. В этот файл можно добавлять параметры, которые при перезапуске MySQL 8 будут применены.
**data** — эта папка предназначена для хранения пользовательских данных MySQL 8.
**dump** — каталог для хранения дампов.
**logs** — каталог для хранения логов.
### nginx
Эта папка предназначена для хранения файлов конфигурации Nginx и логов.
```
├── conf.d
│ ├── default.conf
│ └── vhost.conf
└── logs
```
**default.conf** — файл конфигурации, который будет применён ко всем виртуальным хостам.
**vhost.conf** — здесь хранятся настройки виртуальных хостов web-проектов.
Рассмотрим **vhost.conf** подробнее:
```
server {
listen 80;
index index.php index.html;
server_name project-1.localhost;
error_log /var/log/nginx/project-1.error.log;
access_log /var/log/nginx/project-1.access.log combined if=$loggable;
root /var/www/project-1.ru;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location ~ \.php$ {
try_files $uri =404;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass php-7.3:9000;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_script_name;
}
}
server {
listen 80;
index index.php index.html;
server_name project-2.localhost;
error_log /var/log/nginx/project-2.error.log;
access_log /var/log/nginx/project-2.access.log combined if=$loggable;
root /var/www/project-2.ru;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location ~ \.php$ {
try_files $uri =404;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass php-7.1:9000;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_script_name;
}
}
```
В файле конфигурации описаны настройки для **двух** web-проектов —**project-1.localhost** и **project-2.localhost**.
Здесь следует обратить внимание на то, как производится перенаправление запросов к нужному docker-контейнеру.
Например, для проекта **project-1.localhost** указано:
```
fastcgi_pass php-7.3:9000;
```
**php-7.3** — название docker-контейнера, а **9000** — порт внутренней сети. Контейнеры между собой связаны через внутреннюю сеть, которая определена в файле docker-compose.yml.
### php-ini
В этом каталоге находятся файлы конфигурации PHP.
```
├── 7.1
│ └── php.ini
└── 7.3
└── php.ini
```
Для каждой версии **PHP** — свой файл конфигурации.
#### php-workers
Место для хранения файлов конфигурации **Supervisor**.
```
├── 7.1
│ └── supervisor.d
│
└── 7.3
└── supervisor.d
```
Для каждой версии PHP — могут быть добавлены свои файлы с настройками.
### php-workspace
Здесь хранится файл, в котором описаны действия, выполняемые при создании образов docker-контейнеров PHP.
```
└── Dockerfile
```
**Dockerfile** — это текстовый документ, содержащий все команды, которые следует выполнить для сборки образов PHP.
### postgres
Каталог для системы управления базами данных **PostgreSQL**.
```
├── .gitkeep
├── data
└── dump
```
**data** — эта папка предназначена для хранения пользовательских данных PostgreSQL.
**dump** — каталог для хранения дампов.
### projects
Каталог предназначен для хранения web-проектов.
Вы можете создать в это каталоге папки, и поместить в них ваши web-проекты.
Например:
```
project-1.ru
project-2.ru
...
```
Содержимое каталога projects доступно из контейнеров **php-7.1** и **php-7.3.**
Если зайти в контейнер php-7.1 или php-7.3, то в каталоге /var/www будут доступны проекты, которые расположены в projects на локальной машине.
### redis
Каталог key-value хранилища Redis.
```
├── conf
└── data
```
**conf** — папка для хранения специфических параметров конфигурации.
**data** — если настройки конфигурации предполагают сохранения данных на диске, то Redis будет использовать именно этот каталог.
Программы в docker-контейнерах PHP
----------------------------------
Полный перечень приложений, которые установлены в контейнерах **php-7.x**можно посмотреть в **php-workspace/Dockerfile**.
Здесь перечислим лишь некоторые, наиболее важные:
* bash
* htop
* curl
* Git
* Сomposer
* make
* wget
* NodeJS
* Supervisor
* npm
Начало работы
-------------
**1.** Выполните клонирование данного репозитория в любое место на вашем компьютере.
```
git clone https://github.com/drandin/docker-php-workspa
```
Перейдите в директорию, в которую вы клонировали репозиторий. Все дальнейшие команды следует выполнять именно в этой директории.
**2**. Скопируйте файл **.env-example** в **.env**
```
cp .env-example .env
```
Если это необходимо, то внесите изменения в файл **.env**. Измените настройки среды разработки в соответствии с вашими требованиями.
**3**. Выполните клонирование web-проектов в каталог projects.
Для примера, далее мы будем исходить из предположения, что у вас есть **2** проекта:
```
project-1.ru
project-2.ru
```
**project-1.ru** — будет работать на версии**PHP 7.3**, а **project-2.ru** — на **PHP 7.1**.
**4**. Отредактируйте настройки виртуальных хостов **Nginx**.
Файл конфигурации виртуальных хостов находится в каталоге **./nginx/conf.d/**.
**5**. Настройте хосты (доменные имена) web-проектов на локальной машине.
Необходимо добавить названия хостов web-проектов в файл **hosts** на вашем компьютере.
В файле **hosts** следует описать связь доменных имён ваших web-проектов в среде разработки на локальном компьютере и **IP** docker-контейнера **Nginx**.
На **Mac** и **Linux** этот файл расположен в **/etc/hosts**. На **Windows** он находится в **C:\Windows\System32\drivers\etc\hosts**.
Строки, которые вы добавляете в этот файл, будут выглядеть так:
```
127.0.0.1 project-1.localhost
127.0.0.1 project-2.localhost
```
В данном случае, мы исходим из того, что **Nginx**, запущенный в docker-контейнере, доступен по адресу **127.0.0.1** и web-сервер слушает порт **80**.
Не рекомендуем использовать имя хоста с .**dev** на конце в среде разработки. Лучшей практикой является применение других названий — **.localhost** или **.test**.
**6**. *[опционально, если это необходимо]* Настройте маршрутизацию внутри контейнеров web-проектов.
Web-проекты должны иметь возможность отправлять http-запросы друг другу и использовать для этого название хостов.
Из одного запущенного docker-контейнера **php-7.1** web-приложение **№ X**должно иметь возможность отправить запрос к другому web-приложению **№ Y**, которое работает внутри docker-контейнера **php-7.3**. При этом адресом запроса может быть название хоста, которое указано в файле**/etc/hosts** локального компьютера.
Чтобы это стало возможным нужно внутри контейнеров так же внести соответствующие записи в файл **/etc/hosts**.
Самый простой способ решить данную задачу — добавить секцию **extra\_hosts**в описание сервисов **php-7.1**и **php-7.3** в **docker-compose.yml**.
Пример:
```
...
php-7.1:
...
extra_hosts:
- 'project-1.localhost:IP_HOST_MACHINE'
- 'project-2.localhost:IP_HOST_MACHINE'
...
```
**IP\_HOST\_machine** — IP адрес, по которому из docker-контейнера доступен ваш локальный компьютер.
Если вы разворачиваете среду разработки на **Mac**, то внутри docker-контейнера вам доступен хост **docker.for.mac.localhost**.
Узнать **IP** адрес вашего **Mac** можно при помощи команды, который нужно выполнить на локальной машине:
```
docker run -it alpine ping docker.for.mac.localhost
```
В результате вы получите, что-то подобное:
```
PING docker.for.mac.localhost (192.168.65.2): 56 data bytes
64 bytes from 192.168.65.2: seq=0 ttl=37 time=0.286 ms
64 bytes from 192.168.65.2: seq=1 ttl=37 time=0.504 ms
64 bytes from 192.168.65.2: seq=2 ttl=37 time=0.801 ms
```
После того, как вам станет известен IP-адрес, укажите его в секции **extra\_hosts**в описание сервисов **php-7.1** и **php-7.3** в **docker-compose.yml**.
```
...
php-7.1:
...
extra_hosts:
- 'project-1.localhost:192.168.65.2'
- 'project-2.localhost:192.168.65.2'
...
```
**8**. Настройте параметры соединения с системами хранения данных.
**Хосты и порты сервисов**
Для того, чтобы настроить соединения с базами данных из docker-контейнеров **php-7.1** и **php-7.3** следует использовать следующие названия хостов и порты:
| | | |
| --- | --- | --- |
| **Сервис** | **Название хоста** | **Порт** |
| MySQL 5.7 | mysql-5.7 | 3308 |
| MySQL 8 | mysql-8 | 3308 |
| PostgreSQL | postgres | 5432 |
| MongoDB | mongo | 27017 |
| Redis | redis | 6379 |
Именно эти параметры следует использовать для конфигурации web-проектов.
**Для соединения с базами данных с локальной машины:**
* Хост для всех баз данных — **127.0.0.1**.
* Порты — значения указанные в **.env**.
**7**. Создайте контейнеры и запустите их.
Выполните команду:
```
docker-compose build && docker-compose up -d
```
Создание контейнеров займёт некоторое время. Обычно от 10 до 30 минут. Дождитесь окончания процесса. Ваш компьютер не должен потерять доступ в интернет.
Если вы всё сделали правильно, то контейнеры будут созданы и запущены.
Откройте **Docker Dashboard** и убедитесь в этом:
**8**. Создайте SSH-ключи.
Для работы web-проектов могут потребоваться SSH-ключи, например для того, чтобы из контейнера при помощи **Composer** можно было установить пакет из приватного репозитория.
Создать SSH-ключи можно при помощи следующей команды:
```
ssh-keygen -f ./.ssh/id_rsa -t rsa -b 2048 -C "your-name@example.com"
```
Вместо [your-name@example.com](mailto:your-name@example.com) укажите свой **Email**.
В папку **.ssh/** будут сохранены **2 файла** — публичный и приватный ключ.
**9**. Проверьте созданные docker-контейнеры.
Выполните команду:
```
docker ps
```
Если создание контейнеров прошло успешно, то вы увидите примерно такой результат:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
8d348959c475 docker-php-workspace_php-7.1 "docker-php-entrypoi…" 6 minuts ago Up 54 seconds 0.0.0.0:9001->9000/tcp php-7.1
a93399727ff6 docker-php-workspace_php-7.3 "docker-php-entrypoi…" 6 minuts ago Up 53 seconds 0.0.0.0:9003->9000/tcp php-7.3
5cd80ac95388 nginx:stable-alpine "/docker-entrypoint.…" 6 minuts ago Up 51 seconds 0.0.0.0:80->80/tcp nginx
70182bc9e44c mysql:5.7 "docker-entrypoint.s…" 6 minuts ago Up 54 seconds 33060/tcp, 0.0.0.0:4307->3306/tcp mysql-5.7
46f2766ec0b9 mysql:8.0.21 "docker-entrypoint.s…" 6 minuts ago Up 53 seconds 33060/tcp, 0.0.0.0:4308->3306/tcp mysql-8
a59e7f4b3c61 mongo:4.2 "docker-entrypoint.s…" 6 minuts ago Up 54 seconds 0.0.0.0:27017->27017/tcp mongo
eae8d62ac66e postgres:alpine "docker-entrypoint.s…" 6 minuts ago Up 53 seconds 0.0.0.0:54322->5432/tcp postgres
bba24e86778a redis:latest "docker-entrypoint.s…" 6 minuts ago Up 54 seconds 0.0.0.0:6379->6379/tcp redis
```
**10**. Установка зависимостей для web-приложений.
Если для работы web-приложений необходимо установить зависимости, например через менеджер пакетов **Composer** или **NPM**, то сейчас самое время сделать это.
В контейнерах **php-7.1** и **php-7.3** уже установлен и **Composer** и **NPM**.
Войдите в контейнер**php-7.1**:
```
docker exec -it php-7.1 bash
```
или **php-7.3**:
```
docker exec -it php-7.3 bash
```
Перейдите в рабочий каталог необходимого web-проекта и выполните требуемые действия.
Например, установите зависимости через **Composer** при помощи команды:
```
composer install
```
Вопросы и ответы
----------------
Несколько важных вопросов и ответов.
**Как зайти в работающий docker-контейнер?**
Выполните команду:
`docker exec -it container_name bash`
**container\_name** — имя контейнера.
**Как останавливать и удалить контейнеры и другие ресурсы среды разработки, которые были созданы?**
`docker-compose down`
**Как получить список всех контейнеров?**
`docker ps -a`
**Как получить подробную информацию о docker-контейнере?**
`docker inspect containername`
***container*****name** — имя контейнера.
**Как получить полный список расширений PHP, которые установлены в контейнере php-7.3?**
Если контейнер **php-7.3** запущен, то выполните команду:
`docker exec -it php-7.3 php -m`
**Как удалить все контейнеры?**
Удаление всех контейнеров:
`docker rm -v $(docker ps -aq)`
Удаление всех активных контейнеров:
`docker rm -v $(docker ps -q)`
Удаление всех неактивных контейнеров:
`docker rm -v $(docker ps -aq -f status=exited)`
Развёртывание дампов MySQL, PostgreSQL и MongoDB
------------------------------------------------
Если для работы web-проектов требуются перенести данные в хранилища, то следуйте описанным ниже инструкциям.
#### Как развернуть дамп PostgreSQL?
Выполните следующую команду на локальной машине:
```
docker exec -i postgres psql --username user_name database_name < /path/to/dump/pgsql-backup.sql
```
Или зайдите в контейнер postgres и выполните:
```
psql --username user_name database_name < /path/to/dump/pgsql-backup.sql
```
**user\_name** — имя пользователя. Значение postgres\_USER (см. файл .env).
**database\_name** — название базы данных. Значение postgres\_DB (см. файл .env).
#### Как развернуть дамп MySQL?
Существует два варианта.
**Вариант 1**
Если требуется создать дополнительных пользователей, то следует это сделать перед началом процедуры загрузки дампа.
В файле **mysql/conf.d/config-file.cnf** отключите лог медленных запросов **slow\_query\_log=0** или установите большое значение **long\_query\_time**, например 1000.
Если дамп сжат утилитой **gzip**, сначала следует распаковать архив:
`gunzip databases-dump.sql.gz`
Затем можно развернуть дамп, выполнив на локальном компьютере команду:
```
docker exec -i mysql mysql --user=root --password=secret --force < databases-dump.sql
```
Указывать пароль в командной строке — плохая практика, не делайте так в производственной среде.
**MySQL** выдаст справедливое предупреждение:
*mysql: [Warning] Using a password on the command line interface can be insecure*
Ключ **--force** говорит MySQL, что ошибки следует проигнорировать и продолжить развёртывание дампа. Этот ключ иногда может пригодится, но лучше его без необходимости не применять.
**Вариант 2**
Воспользоваться утилитой **Percona** **XtraBackup**.
**Percona XtraBackup** — это утилита для горячего резервного копирования баз данных MySQL.
О том, как работать с **XtraBackup** можно узнать по ссылке: [https://medium.com/@drandin/создание-резервной-копии-mysql-при-помощи-утилиты-xtrabackup-26bd3f843075](https://medium.com/@drandin/%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D1%80%D0%B5%D0%B7%D0%B5%D1%80%D0%B2%D0%BD%D0%BE%D0%B9-%D0%BA%D0%BE%D0%BF%D0%B8%D0%B8-mysql-%D0%BF%D1%80%D0%B8-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D0%B8-%D1%83%D1%82%D0%B8%D0%BB%D0%B8%D1%82%D1%8B-xtrabackup-26bd3f843075)
#### Как развернуть дамп MongoDB?
* Скопируйте фалы дампа в каталог **mongo/dump**.
* Войдите в контейнер **mongo**:
```
docker exec -it mongo sh
```
Выполните следующую команду, чтобы развернуть дамп базы **database\_name**:
```
mongorestore -d database_name /dump/databases/database_nam
```
**Git-репозиторий проекта:** <https://github.com/drandin/docker-php-workspace> | https://habr.com/ru/post/519500/ | null | ru | null |
# История о том как SVN copy победил SVN merge
Итак, сразу опишу нашу ситуацию и потом объясню почему дал этой статье такое глупое название :-)
Наша команда из 4х человек работает на одном проекте (пока не буду говорить, что за проект, надеюсь, напишу о нем позже)
У нас было 3 SVN ветки: Production (стабильная ветка, которая обслуживает запросы пользователей), Staging (промежуточная ветка), Trunk (девелоперская ветка).
В ходе итерации (работаем мы по скраму, [Scrum](http://ru.wikipedia.org/wiki/Scrum)), программисты коммитят в одну девелоперскую ветку (Trunk), после этого изменения и фитчи, накопленные, в ходе итерации переносятся на Staging ветку с помощью команды svn merge, где их тестируют и проверяют наши QA. Далее, чтобы не делать очередной мердж на продакшн (из Staging в Stable) с последующим паническим тестом на продакшене после мерджа. Все что я делал — это менял конфиги на нашем вебсервере.
`$HTTP["host"] =~ "^.*somehost.com$" {
.................
server.document-root = "/path/to/the/stable/branch"
....................
}
$HTTP["host"] =~ "^.*somehost.com.staging$" {
.................
server.document-root = "/path/to/the/staging/branch"
....................
}`
После релиза:
`$HTTP["host"] =~ "^.*somehost.com$" {
.................
server.document-root = "/path/to/the/staging/branch"
....................
}
$HTTP["host"] =~ "^.*somehost.com.staging$" {
.................
server.document-root = "/path/to/the/stable/branch"
....................
}`
Т.е. в конце итерации Stable и Staging менялись местами. Stable становился невидимым для пользователей, а бывший Staging — становился продакшеном, т.е именно на него заходят пользователи.
Так мы избавились от одного лишнего мерджа… Но этого нам показалось мало :-) Нет ничего более непредсказуемого, чем инженерная мысль…
Мы решили убрать и второй мердж, точней оставшийся.
Итак, условие задачи: мы имеем девелоперскую ветку, которая всегда содержит последние изменения и две ветки, каждая из которых поочередно выполняет роль продакшена.
Во время последнего мерджа с девела на стэйджинг мы столкнуль с большими проблемами, из-за того, что мы все используем разные операционные системы (Arch linux, Mac OS, Windows Vista), разные IDE (Eclipse, Net Beans, Notepad++, VIM :-)) ) И даже разные настройки внутри одинаковых редакторов (сейчас я собираюсь написать спецификацию о единых настройках редакторов). В связи с этим везде использовались разные символьные последовательности для перевода каретки, некоторые редакторы заменяют табы пробелами и т.д.
В связи с этим, во время мерджа мы не получили конфликтов, SVN все смерджил!!! Фактически одинаковые куски кода. И пришлось вручную все вычекивать, чтобы привести сорцы к желаемому виду.
Но в какой-то момент наши нервы не выдержали! И я просто дропнул staging ветку (svn delete staging), а потом мы просто скопировали текущую девелоперскую ветку (trunk) во вновь созданную (с помощью команды svn copy trunk staging). Все что оставалось сделать это поправить конфиги во вновь созданной ветке, и это все.
Поэтому как такового мерджа нет. В конце каждой итерации удаляется промежуточная ветка (svn delete staging)
И создается новая (svn copy trunk staging). И коммитятся конфиги к ней.
Единственное, что меня беспокоило, что размер репозитория будет быстро расти. Но… насколько я помню, SVN использует [Bubble-up](http://subversion.tigris.org/design.html#server.fs.struct.bubble-up) метод в частности и для создания ветвей, поэтому вновь созданная ветвь — всего лишь ссылки на уже существующую базовую. А изменения — это дифы с этой базовой ветви.
Поэтому и относительно размера репозитории я вполне спокоен.
Вот сейчас сижу пишу эту статью, а QA тестирует на staging наш проект :-)))
Интересно услышать ваши мнения по поводу такого подхода.
З.Ы.
На самом деле меня даже больше интересовали мнения по поводу мерджа в Git
Например, из слов Линуса Торвальдса: «Я знаю несколько компаний, которые внутри используют git, не подозревая об этом, потому что они все еще держат свои главные репозитории в Subversion, но многие разработчики затем импортируют код в git, потому что git действительно хорошо выполняет слияния. Так что вы можете взять дерево веток из Subversion, импортировать в git, позволить git сделать слияние, что было бы основной головной болью в Subversion, зафиксировать изменения и фактически экспортировать их назад в Subversion, и никто другой даже не узнает, что вы использовали git. Немного грустно, но я слышал о многих, работающих в компаниях в точности по этому сценарию.....»
[Git Google Talk](http://lib.custis.ru/index.php/%D0%9B%D0%B8%D0%BD%D1%83%D1%81_%D0%A2%D0%BE%D1%80%D0%B2%D0%B0%D0%BB%D1%8C%D0%B4%D1%81_%D0%BE_GIT_%D0%BD%D0%B0_Google_Talks) | https://habr.com/ru/post/62185/ | null | ru | null |
# Локализация в Silverlight
Локализация когда-то приходит в ваш интернациональный дом. Что бы вы ни построили — большой небоскреб или хижину дяди Тома — надо уметь разговаривать на языке жителей этого дома.
Если ваш Silverlight дом нуждается в локализации, милости просим, я постараюсь дать краски и кисточку, а плакаты рисуйте сами.
#### Проблема.
Для разработки настольного приложения проблем в использовании ресурсов нет, давно появилась возможность создания ResX файлов и использования второстепенных(satellite) сборок для конкретного языка. Silverlight эти функции достались по наследству, но в отличии от настольных приложений, необходимо помнить, что увеличивая количество локализированных ресурсов вы увеличиваете размер сборки. Вот и получается, что пользователь ждет загрузки, а часть загруженной информации ему и вовсе не нужна. С другой стороны, я про сервер, чем больше файл, тем больше нагрузка на сервер. Представьте, вам надо поправить ресурсы, а это означает что надо еще раз собирать и выкладывать полную сборку и пользователи будут опять её загружать, ибо с кеша вытянуть уже не получится. А лежали бы ресурсы отдельно зашел, поменял и все.
Обобщаем: любой лишний ресурс сборки требует лишнего времени пользователя, сервера, разработчика.
#### Обзор
Есть общие подходы, которые я использую в своём решение и с которыми я хотел бы ознакомить Вас.
Создание ресурса просто, но все же кратко об этом:
— добавляем новый элемент из контекстного меню на нужной папке в Solution Explorer (Add -> New Item);
— выделяем вкладку General;
— выбираем элемент Resources Files (или ищем в полном списке элемент с таким названием);
— вводим имя — ProjectResources;
— нажимаем add (или просто жмем Enter).
В нужной папке создался ресурс. Открываем дизайнер ресурсного файла двойным нажатием на файле в Solution Explorer. В появившейся сетке, в первой колонке пишем имя нашего ресурса — «Message», в следующую колонку вносим значение — «Hello World!».
**Обязательно!** не забыть сделать наш ресурс Public, для чего сменить в «Access Modifier» состояние Internal на Public.
На этом создание основного (neutral) ресурса заканчивается и мы можем переходить к следующей части «Мерлезонского балета» — созданию провайдера для ресурсов. Данный подход уже упоминался в топике [Программируем Reversi на Silverlight](http://habrahabr.ru/blogs/silverlight/87426/) и заключается он в создании класса с набором свойств, являющихся ресурсами.
> `1. public class ResProvider : INotifyPropertyChanged
> 2. {
> 3. static ProjectResources resources = new ProjectResources();
> 4.
> 5. public ProjectResources ProjectResources
> 6. {
> 7. get
> 8. {
> 9. return resources;
> 10. }
> 11. }
> 12.
> 13. #region INotifyPropertyChanged Members
> 14. // Implemention of interface.
> 15. #endregion
> 16. }
> \* This source code was highlighted with Source Code Highlighter.`
Используется в markup это так:
> `1. <UserControl>
> 2. <UserControl.Resources>
> 3. <Resources:ResProvider x:Key="ResProvider"/>
> 4. UserControl.Resources>
> 5. <Grid>
> 6. <TextBlock Text="{Binding Source={StaticResource ResProvider},Path=ProjectResources.Message}"/>
> 7. Grid>
> 8. UserControl>
> \* This source code was highlighted with Source Code Highlighter.`
При чем, если надо использовать данный провайдер для всего приложения, вы просто определяете его на уровне Application, то есть в App.xaml.
Основной ресурс готов, провайдер есть, теперь надо расширить ресурс дополнительными языками.
Для тех кто спросил «Как?»:
— вызываем контекстное меню на нужной папке в Solution Explorer (Add -> New Item);
— выделяем закладку General;
— создаем Resources Files с именем основного ресурса (в нашем случае ProjectResources);
— в конце добавляем имя нужной культуры — ProjectResources.ru-Ru.resx;
— нажимаем Add.
Создастся файл с нужным именем. Открываем ресурс в дизайнере, в первой колонке пишем имя совпадающие с базовым ресурсом, в нашем случае это — «Message», вторую колонку заполняем переведенным значением — «Привет Мир!».
Ничего нового я не придумал, фактически своим постом я описал два документа:
1. [How to: Add Resources to a Silverlight-based Application](http://msdn.microsoft.com/en-us/library/dd941931%28VS.95%29.aspx)
2. [Silverlight and localizing string data](http://timheuer.com/blog/archive/2009/08/26/silverlight-string-localization.aspx)
Для тех кто внимательно читал первый(или уже сталкивался с ним), из приведенных выше документов, скажу, что я специально умолчал о добавлении в xml проекта специальной секции , определяющей список языковых сборок, необходимых для включения в скомпилированный xap файл. Если вы добавите эту секцию, то ни как не уйдете от той проблемы, с которой я начал повествование — от использования лишних ресурсов.
#### Решение
Способ, который я разработал, к сожалению, не подходит тем, кто хочет одним состоянием чекбокса включить поддержку ленивой (lazy) загрузки ресурсов. О как закрутил. Короче — придется потрудиться что бы осушить пруд и добраться до желанной рыбки.
Во-первых, скачать последнюю версию библиотеки ResourceExtension с [codeplex](http://xresource4sl.codeplex.com/) и добавить её в референсы к Silverlight проекту.
Создание ресурсов не отличается от приведенного выше, поэтому я его опущу. Единственное, что требуется для ресурсов это добавить pre-build событие. Вызываем свойства Silverlight проекта. Открываем вкладку Build Events. В Pre-build вносим:
> `@ECHO off
>
> DEL "$(TargetPath)"
>
> FOR /F "delims=" %%i IN ('findstr /M /L /S /C:"global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager" "$(ProjectDir)\*.Designer.cs"') DO (
>
> DEL resource.gen
>
> FOR /F "usebackq delims=" %%j IN ("%%i") DO (
>
> ECHO. %%j > resourcecurrentrow.gen
>
> FOR /F "tokens=1,2\* delims=(=" %%k IN (resourcecurrentrow.gen) DO (
>
> IF "%%l" == " new global::System.Resources.ResourceManager" (ECHO %%k = new ResourceExtension.ResourceXManager(%%m)>>resource.gen ELSE (ECHO. %%j) >>resource.gen
>
> ))
>
> XCOPY resource.gen "%%i" /Q /Y /R /K
>
> )
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Этим действием, автоматически, во всех ресурсах проекта, подменяется класс ResourceManager на ResourceXManager, реализованный в библиотеке ResourceExtension.
К сожалению, этот код не работает без дополнительной секции FALSE в файле проекта. Добавить этот код надо в секцию .
Markup не претерпел ни каких изменений, все осталось на своих местах.
А вот провайдер видоизменился, теперь он является наследником класса CultureResourceProvider и приобрел метаданные на свойствах:
> `1. using ResourceExtension;
> 2. using ResourceExtension.Implementation;
> 3.
> 4. namespace ResourceExtensionExample.Resources
> 5. {
> 6. public class ResProvider: CultureResourcesProvider
> 7. {
> 8. private static ProjectResources projectResources = new ProjectResources();
> 9.
> 10. [ResourceProperty]
> 11. public ProjectResources ProjectResources
> 12. {
> 13. get { return projectResources; }
> 14. }
> 15. }
> 16. }
> \* This source code was highlighted with Source Code Highlighter.`
Финальный аккорд. Собираем. Включаем галочку для просмотра всех файлов и находим папку bin\Debug\ru-RU, которую мы должны переместить в папку ClientBin и положить рядом с xap файлом.
И, «легкое превращение в элегантные шорты»:
> `1. public partial class MainPage : UserControl
> 2. {
> 3. public MainPage()
> 4. {
> 5. InitializeComponent();
> 6. }
> 7.
> 8. private void Switch\_Click(object sender, RoutedEventArgs e)
> 9. {
> 10. ((ResProvider) Resources["ResProvider"]).Options.CultureInfo = new CultureInfo("ru-Ru");
> 11. }
> 12. }
> \* This source code was highlighted with Source Code Highlighter.`
позволит вам удобно загрузить ресурсы с русской локалью.
Если у вас, что-либо не получилось. Вы можете скачать пример и посмотреть, как там все реализовано.
Компонент находится в стадии alpha, поэтому ни каких претензий, вы используете его на свой страх и риск.
В данной реализации работают только строковые(strings) ресурсы.
Почему был выбран именно такой подход? Что внутри? Как работает? Я попытаюсь рассказать об этом во второй статье «Silverlight Resource Extension. Часть 2. Описательная», которую планирую закончить в обозримом будущем. | https://habr.com/ru/post/87450/ | null | ru | null |
# Шаблон Presenter в Laravel
Если вы используете Laravel в своем проекте достаточно долго, ваши модели, скорее всего, стали довольно большими. Со временем их становится все труднее поддерживать, т.к. они обрастают новым функционалом. Когда вы пишете код для каждого случая, где используются ваши модели, возникает соблазн "откормить" наши модели до тех пор, пока они не разжиреют.
В таких ситуациях мы можем воспользоваться паттерном Декоратор, который позволит нам выделить код, специфичный для каждого случая в отдельный класс. Например, мы можем использовать декораторы для того, чтобы разделить формирование представления для PDF-документа, CSV или ответа API.
Что такое Декоратор и что такое Презентер?
==========================================
Декоратор — это объект, который оборачивает другой объект для того, чтобы расширить его функционал. Он так же передает вызовы методов объекту, который был обернут, если их нет в декораторе. Декораторы могут быть полезны, когда вам нужно изменить поведение класса не прибегая к наследованию. Вы можете использовать их для того, чтобы добавить дополнительный функционал вашим объектам, как например логирование, контроль доступа и тому подобное.
Презентер — это разновидность Декоратора, используемая для приведения объекта к нужному виду (например для Blade-шаблона или ответа API).
Приведение коллекции пользователей к ответу API
===============================================
Предположим, у нас есть коллекция пользователей, которую мы должны вернуться в ответе API. В Laravel мы можем легко это реализовать, просто вернув саму коллекцию, которая затем будет преобразована в JSON. Давайте получим модели наших пользователей в контроллере:
```
php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
class UsersController extends Controller
{
public function index()
{
return User::all();
}
}</code
```
Метод `all` возвращает всех пользователей из базы данных. Модель User содержит в себе все поля таблицы. Пароли и другая важная информация так же находятся там. Кроме того, Laravel при выводе автоматически преобразует результат метода `all` в JSON.
Однако это не самый лучший вариант решения задачи. К примеру, на не нужно отправлять хеши паролей пользователей в ответе.
Также нам может не понравится, как выглядят даты `created_at` и `updated_at`. Или если наше поле `is_active` имеет тип `tinyint`, мы возможно захотим преобразовать ее в строку, либо в логическое значение.
Примечание: да-да, я знаю, что Eloquent позволяет скрыть поля модели при ее преобразовании в JSON, используя свойство $hidden у модели. Просто подыграйте мне.
Воспользуемся паттерном Presenter.
==================================
Сейчас, когда у нас есть коллекция моделей User, нам нужно понять, как передать их представлению, обернув их в декоратор. Нам понадобится класс, который будет выполнять роль Презентера. Наш класс UserPresenter в таком случае будет выглядеть следующим образом:
```
php
namespace App\Users;
class UserPresenter
{
protected $model;
public function __construct(Model $model)
{
$this-model = $model;
}
public function __call($method, $args)
{
return call_user_func_array([$this->model, $method], $args);
}
public function __get($name)
{
return $this->model->{$name};
}
public function fullName()
{
return trim($this->model->first_name . ' ' . $this->model->last_name);
}
}
```
Заметьте, что наш презентер получает свойства `first_name`, `last_name`, и `created_at` у модели, потому что этих свойств нет у презентера.
Я люблю тупые аналогии и это одна из них: декоратор это что-то вроде костюма Бэтмена на Брюсе Уейне. И у Бэтмена есть куча разных костюмов для разных ситуаций. Как и костюмы Бэтмена, мы можем использовать различные декораторы для разных ситуаций, где нам нужна модель User. Давайте переименуем наш декоратор во что-то более подходящее, например, ApiPresenter, а затем поместим его в папку Presenters. Так же мы выделим код, который можно переиспользовать, в отдельный класс Presenter:
```
php
namespace App\Presenter;
abstract class Presenter
{
protected $model;
public function __construct(Model $model)
{
$this-model = $model;
}
public function __call($method, $args)
{
return call_user_func_array([$this->model, $method], $args);
}
public function __get($name)
{
return $this->model->{$name};
}
}
```
Давайте добавим новый метод к `ApiPresenter`:
```
php
namespace App\Users\Presenters;
use App\Presenter\Presenter;
class ApiPresenter extends Presenter
{
public function fullName()
{
return trim($this-model->first_name . ' ' . $this->model->last_name);
}
public function createdAt()
{
return $this->model->created_at->format('n/j/Y');
}
}
```
Вы могли бы подумать, что можно использовать мутаторы Laravel для преобразования дат в нужный нам формат и избежать всей это возни с презентерами. Это возможно, если нам нужен только один вариант отображения.
Вы также можете сказать: "Я мог бы оставить поле `created_at` как есть и использовать несколько мутаторов для разных ситуаций. Например, `friendlyCreatedAt()`, `pdfCreatedAt()` и `createdAtAsYear()`". Главным аргументом против такого подхода является то, что ваша модель постепенно станет огромной и будет приносить нам много беспокойства. Мы можем переложить эту ответственность на отдельный класс, который будет приводить нашу модель к нужному виду.
Давайте добавим еще несколько методов к нашему презентеру:
```
php
namespace App\Users\Presenters;
class ApiPresenter
{
public function fullName()
{
return trim($this-model->full_name . ' ' . $this->model->last_name);
}
public function createdAt()
{
return $this->model->created_at->format('n/j/Y');
}
public function isActive()
{
return (bool) $this->model->is_active;
}
public function role()
{
if ($this->model->is_admin) {
return 'Admin';
}
return 'User';
}
}
```
Здесь мы приводим поле `is_active` нашей модели к логическому типу вместо `tinyint`. Также мы предоставляем API строковое представление роли пользователя.
Вернемся к нашему контроллеру. Теперь мы можем использовать презентер для построения ответа:
```
php
namespace App\Http\Controllers;
use App\Users\Presenters\ApiPresenter;
use App\Http\Controllers\Controller;
class UsersController extends Controller
{
public function show($id)
{
$user = new ApiPresenter(User::findOrFail($id));
return response()-json([
'name' => $user->fullName(),
'role' => $user->role(),
'created_at' => $user->createdAt(),
'is_active' => $user->isActive(),
]);
}
}
```
Это замечательно! Теперь API возвращает только нужную информацию и код стал выглядеть чище. Но еще лучше то, что если мы захотим использовать значение, которого нет в `ApiPresenter`, но есть в модели User мы можем просто вернуть его динамически из модели, как мы привыкли:
```
php
return response()-json([
'first_name' => $user->first_name,
'last_name' => $user->last_name,
'name' => $user->fullName(),
'role' => $user->role(),
'created_at' => $user->createdAt(),
'is_active' => $user->isActive(),
]);
```
Декорирование коллекции пользователей
=====================================
Декоратор это довольно мощный паттерн, который позволяет сохранять в вашем коде чистоту и порядок. Но как насчет первой ситуации, когда у нас была коллекция моделей? Мы можем пройтись по ней циклом и создать новый массив:
```
php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Users\Presenters\ApiPresenter;
class UsersController extends Controller
{
public function index()
{
$users = User::all();
$apiUsers = [];
foreach ($users as $user) {
$apiUser = new ApiPresenter($user);
$apiUsers[] = [
'first_name' = $apiUser->model->first_name,
'last_name' => $apiUser->model->last_name,
'name' => $apiUser->fullName(),
'role' => $apiUser->role(),
'created_at' => $apiUser->createdAt(),
'is_active' => $apiUser->isActive(),
];
}
return response()->json($apiUsers);
}
}
```
Все прекрасно, но выглядит это не очень красиво. Вместо этого я хочу воспользоваться макросами, которые позволяет создавать класс `Collection`:
```
php
Collection::macro('present', function ($class) {
return $this-map(function ($model) use ($class) {
return new $class($model);
});
});
```
Этот код можно поместить в сервис-провайдер вашего приложения. Теперь мы вызвать наш макрос, указав нужный презентер:
```
php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Users\Presenters\ApiPresenter;
class UsersController extends Controller
{
public function index()
{
$users = User::all()
-present(ApiPresenter::class)
->map(function ($user) {
return [
'first_name' => $user->first_name,
'last_name' => $user->last_name,
'name' => $user->fullName(),
'role' => $user->role(),
'created_at' => $user->createdAt(),
'is_active' => $user->isActive(),
];
});
return response()->json($users);
}
}
```
Каждая модель оборачивается в презентер. Если хотите, вы можете передать коллекцию другому декоратору, чтобы объединить несколько объектов в единый JSON.
Таким образом декораторы и презентеры являются мощным инструментом, которым мы располагаем. Их легко писать и они легко тестируются. Используйте их, когда это имеет смысл. Они могут помочь вам при рефакторинге.
Но это еще не все. Было бы круто, если бы могли вызвать метод present для отдельной модели. И если бы у нас был хелпер, который позволил бы нам обернуть модель в презентер.
Что же, позвольте мне представить вам пакет [Hemp/Presenter](https://github.com/davidhemphill/presenter). Он делает все то, о чем мы говорили, плюс ко всему он реализует те пожелания, о которых я говорил. И все это протестировано. Попробуйте и расскажите мне, что вы думаете о нем. Наслаждайтесь!
*Оригинал: <http://davidhemphill.com/blog/2016/09/06/presenters-in-laravel>* | https://habr.com/ru/post/309942/ | null | ru | null |
# Заделываем дыры в сервере приложений 1С и вокруг него
В сегодняшней статье я расскажу об уязвимостях сервера 1С в корпоративной сети.
Как показала практика, в инсталляциях с 1С все допускают одни и те же ошибки разной степени серьезности. Я не буду касаться очевидных вещей вроде установки обновлений, но пройдусь по специфике работы сервера приложений под Windows. Например, по возможности бесконтрольно манипулировать базами Microsoft SQL с помощью инструментов 1С.
> Исторически так сложилось, что редко когда системные администраторы и программисты 1С работают как одна команда. Чаще всего специалисты по 1С не вникают в тонкости системного администрирования, а сисадмины не стремятся постичь нюансы работы 1С.
И получается инфраструктура с «детскими болячками», очевидными для специалиста по ИБ ― ниже привожу личный ТОП таких проблем.
Запускаем сервер правильно
==========================
По умолчанию платформа 1С при установке создает специальную учетную запись с ограниченными правами, под которой работают службы сервера ― USR1CV8. Все идет хорошо, до тех пор пока не становятся нужны ресурсы сети: например, для автоматических выгрузок-загрузок. Учетная запись по умолчанию не имеет доступа на сетевые папки домена, поскольку является локальной.
В своей практике я встречал множество способов решения этой задачи: папки с доступом на запись для группы «Все», сервер 1С под учетной записью с правами администратора домена, явно прописанные в коде учетные данные для подключения сетевого ресурса. Даже запуск сервера 1С под пользовательской сессией как обычное приложение.
*Заходим на сервер по RDP, видим такое окно и получаем нервный тик.*
Конечно, «захардкоженые» пароли и сетевые ресурсы с анонимным доступом на запись встречаются редко. В отличие от работы сервера 1С из-под обычной доменной учетной записи. Разумеется, с возможностью выполнить произвольный код «на сервере».
Как известно любому 1С-нику, но не любому системному администратору, в обработках 1С есть два режима выполнения процедур: на сервере и на клиенте. Запущенная в «серверном» режиме процедура будет выполнена под учетной записью службы сервера приложений. Со всеми ее правами.
Если сервер 1С работает с правами администратора домена, то потенциальный вредитель сможет сделать с доменом что угодно. Разумным выходом станет создание специальной учетной записи ― по мотивам **USR1CV8**, только уже в домене. В частности, ей стоит разрешить вход только на определенные серверы в оснастке «Пользователи и Компьютеры Active Directory».
*Настройка входа только на разрешенные серверы.*
Не лишним будет и разрешить вход на сервер только в качестве службы, отключив возможность локального (интерактивного) входа в систему. Сделать это можно через локальные политики безопасности непосредственно на сервере, либо с помощью доменных групповых политик.
*Назначение прав пользователя в локальной политике безопасности.*
Все то же самое касается и учетной записи сервера Microsoft SQL. Седых волос может прибавиться от вредных привычек:
* запускать SQL с правами администратора компьютера или даже домена для удобного резервного копирования;
* включать возможность запуска исполняемых команд через хранимую процедуру **xp\_cmdshell** для переноса резервных копий на сетевые ресурсы через красивые планы обслуживания.
Подключаемся к SQL
==================
Регулярно в практике встречается подключение баз данных к серверу 1С под пользователем «SA» (суперпользователь в SQL). Вообще, это не так страшно как звучит, ведь пароль от SA захэширован в файле **1CV8Reg.lst** на сервере приложений. Хэш злоумышленник получить гипотетически может ― не забываем про права учетной записи сервера ― но расшифровка окажется долгой, особенно если использовать брутфорс.
Но все же не лишним будет настроить аудит доступа к этому файлу с уведомлением ответственных лиц.
> Другое дело, когда программистам 1С «делегируют» обязанности DBA. Опять же, из личного опыта: сервер SQL был в зоне ответственности программистов, как и интеграция внешнего сайта с базами 1С. Итогом был пароль SA в скриптах сайта.
Для собственного успокоения стоит поставить на SA сложный пароль или вовсе деактивировать эту учетную запись. На SQL тогда нужно включить доменную аутентификацию для управления и создать для 1С отдельное имя входа с правами на необходимые базы.
Если вы не хотите оставить возможность создавать базы SQL через интерфейс 1С, то новому пользователю хватит общей роли **public** и **db\_owner** непосредственно в базе 1С.
Это можно проделать через Management Studio или простым скриптом T-SQL:
```
USE
CREATE LOGIN 1c\_user WITH PASSWORD = 'VeryStrongPassword'
CREATE USER 1c\_user FOR LOGIN 1c\_user
ALTER ROLE db\_owner ADD MEMBER 1c\_user
GO
```
Пользователи 1С
===============
Правам пользователей в 1С почему-то мало кто уделяет внимание. А ведь пользователь с правами «Административные функции» или «Администрирование» запросто выгрузит базу в **.DT** через конфигуратор и унесет домой ― это подарит не одно мгновение волнительного счастья вашему руководству. Поэтому стоит поймать на рюмочку чая 1С-ника и посидеть совместно над базой, чтобы узнать, какие пользователи имеют подобные права. А заодно ― чем грозит понижение их полномочий.
*Право выгрузить базу у роли Полные Права в типовой 1С: Бухгалтерии 2.0.*
Следующий важный момент ― запуск внешних обработок. Как мы помним, в 1С можно запускать код с правами учетной записи сервера. Хорошо, если она не имеет административных прав на систему, но все равно стоит исключить возможность запуска подобных обработок для пользователей. И не забудьте попросить специалиста по 1С «встраивать» дополнительные отчеты и обработки в базу. Хотя не во всех обработках поддерживается встраивание ― эта возможность зависит от версии 1С.
*Проверить, какие типовые роли не имеют прав на открытие внешних обработок, можно в конфигураторе.*
> Все эти действия не только помогут защититься от потенциального «внутреннего вредителя», но и станут дополнительной преградой на пути [вирусов-шифровальщиков](https://habrahabr.ru/post/303922/), маскирующихся под обработки 1С.
Если все же необходим запуск внешних обработок, то неплохим вариантом контроля и подстраховки будет аудит их запуска. Штатного механизма аудита у 1С пока нет, но в сообществе уже придумали [несколько обходных маневров](http://kb.mista.ru/article.php?id=547). Внедрять эти механизмы стоит в паре со специалистом 1С, также как и настраивать [уведомления о событиях](https://infostart.ru/public/634491/) в журнале регистраций базы.
Отдельно отмечу возможность настройки доменной аутентификации пользователей вместо аутентификации 1С. И пользователям будет удобнее ― меньше паролей в их памяти снижает риск появления стикеров на мониторе.
Администратор кластера
======================
Итак, пользователи теперь не могут запускать обработки, учетная запись сервера максимально ограничена. Но есть и еще кое-что: учетная запись администратора кластера 1С, которая не создается по умолчанию.
Ее отсутствие опасно: любой человек с ноутбуком при открытом доступе к сетевым портам сервера (по умолчанию это TCP:1540) может создать там свою базу, и ограничений на запуск обработок не будет. А еще злодей сможет получить информацию по базам данных, по работающим пользователям, изменить параметры кластера и даже принудительно завершить работу определенных пользователей.
Пример скрипта на PowerShell, изгоняющего всех пользователей изо всех баз сервера:
```
$COMConnector = New-Object -ComObject V83.COMConnector
$agent = $COMConnector.ConnectAgent("servername")
$cluster = $agent.GetClusters()[0]
$agent.Authenticate($cluster,"", "")
$sessions = $agent.GetSessions($cluster)
Foreach ($session in $sessions) {
$agent.TerminateSession($cluster, $session)
}
```
Использование подобного способа работы с сервером 1С в благих целях уже упоминалось [в одной из предыдущих статей](https://habrahabr.ru/company/pc-administrator/blog/320852/).
Создать администратора кластера не просто, а очень просто ― достаточно щелкнуть правой кнопкой на пункте «администраторы» в управлении кластером 1С, создать нового администратора, задав логин и пароль.
*Создание администратора кластера 1С.*
Я коснулся лишь части недоработок при настройке 1С: Предприятия. Для самостоятельного изучения рекомендую почитать до сих пор не потерявшие актуальность материалы:
* [документ по вопросам ИБ](https://its.1c.ru/db/metod8dev#content:5816:hdoc) на сайте ITS;
* [статья по вопросам безопасности 1С: Предприятие 8.0](http://www.mista.ru/v8/security/) в сообществе mista.ru.
**Поделитесь в комментариях своими нестандартными решениями и курьезами при работе с системой 1С: Предприятие.** | https://habr.com/ru/post/349620/ | null | ru | null |
# Считаем скобочки на Oracle SQL
Все началось с того, что на сайте [codeforces.ru](http://codeforces.ru) в очередном Codeforces Round я увидел интересную задачку [“Скобочная последовательность”](http://codeforces.ru/contest/223/problem/A) и решать ее “неинтересным способом” никак не хотелось.
Вкратце условия задачи сводятся к нахождению в строке, состоящей только из символов «(», «)», «[» и «]», правильной cкобочной последовательности, содержащей как можно больше скобок «[».
Для начала превращаем нашу плоскую строчку в более удобное иерархическое представление:
```
with brackets as
(select '[[)]([][][][[()[()[()()]]]])]' b
from dual)
select substr(b,level,1) q,
level curr_pos,
level - 1 prev_pos
from brackets
connect by substr(b,level,1) is not null
```
В каждой строчке будет очередная скобка, позиция текущей скобки и позиция предыдущей скобки. С этим уже можно что-то сделать.
Осталось найти все правильные скобочные последовательности. Здесь начинается самое интересное.
Так как для определения правильности выражения у нас нет стека, в котором можно хранить скобочки, пришлось идти на “хитрость”.
Найдем все возможные последовательности, начинающиеся с «(» или «[» (остальные неправильные по умолчанию). Для каждой такой последовательности определим позицию первой и последней скобки и “уровень вложенности” последней скобки, т.е.:
```
«(» «1ый - уровень»
«(» «2ой – уровень»
.. ... .. ..
«]» «2ой – уровень»
.. ... .. .. .
```
* Уровень увеличивается, если: скобка открывается, а перед ней ничего не было, либо была любая открывающаяся;
* Уровень не изменяется, если скобка открывается, а перед ней была закрывающаяся, либо если скобка закрывается, а перед ней была открывающаяся;
* Уровень уменьшается, если скобка закрывается, а перед ней была закрывающаяся;
```
with brackets as
(select '[[)]([][][][[()[()[()()]]]])]' b
from dual) ,
all_brackets as
(select substr(b,level,1) q,
level curr_pos,
level-1 prev_pos
from brackets
connect by substr(b,level,1) is not null)
select replace(sys_connect_by_path(q,'-'), '-') str,
q,
connect_by_root(curr_pos) start_pos,
curr_pos end_pos,
sum( case
when (q = '(' or q = '[')
and (prior q is null)
then 1
when (q = '(' or q = '[')
and (prior q = '(' or prior q = '[')
then 1
when (q = '(' or q = '[')
and (prior q = ']' or prior q = ')')
then 0
when (q = ')' or q = ']')
and (prior q = '(' or prior q = '[')
then 0
when (q = ')' or q = ']')
and (prior q = ')' or prior q = ']')
then -1
end)
over (partition by connect_by_root(curr_pos)
order by connect_by_root(curr_pos), curr_pos) bracket_level
from all_brackets
connect by prior curr_pos = prev_pos
start with q = '(' or q = '['
```
С помощью этих данных мы можем определить, скобку “вредителя”, которая делает из правильной последовательности неправильную. Для этого просмотрим все полученные последовательности, и при “появлении” очередной скобки, найдем предыдущую скобку, находящуюся на одном уровне с текущей (Спасибо Oracle за аналитическую функцию lag). Неправильная последовательность получается, если на одном из уровней возникает одна из следующих ситуаций:
* закрывается закрытая скобка
* круглая скобка закрывает квадратную
* квадратная скобка закрывает круглую
Любая открывающаяся скобка на данной итерации не может “поломать” последовательность.
```
with brackets as
(select '[[)]([][][][[()[()[()()]]]])]' b
from dual) ,
all_brackets as
(select substr(b,level,1) q,
level curr_pos,
level - 1 prev_pos
from brackets
connect by substr(b,level,1) is not null),
brackets_comb as
(select replace(sys_connect_by_path(q,'-'), '-') str,
q,
connect_by_root(curr_pos) start_pos,
curr_pos end_pos,
sum( case
when (q = '(' or q = '[')
and (prior q is null)
then 1
when (q = '(' or q = '[')
and (prior q = '(' or prior q = '[')
then 1
when (q = '(' or q = '[')
and (prior q = ']' or prior q = ')')
then 0
when (q = ')' or q = ']')
and (prior q = '(' or prior q = '[')
then 0
when (q = ')' or q = ']')
and (prior q = ')' or prior q = ']')
then -1
end)
over (partition by connect_by_root(curr_pos)
order by connect_by_root(curr_pos), curr_pos) bracket_level
from all_brackets
connect by prior curr_pos = prev_pos
start with q = '(' or q = '[')
select start_pos,
end_pos,
str,
case
when q = ')'
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = '('
then 'ok'
when q = '('
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = ')'
then 'ok'
when q = '('
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = ']'
then 'ok'
when q = ']'
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = '['
then 'ok'
when q = '['
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = ']'
then 'ok'
when q = '['
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = ')'
then 'ok'
when lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) is null
and bracket_level > 0
then 'ok'
else 'not ok!'
end status
from brackets_comb bc
```
Таким образом, для каждого множества последовательностей, начинающихся с одной позиции (start\_pos) и упорядоченных по количеству скобок, мы нашли первую неверную последовательность.
В каждом таком множестве последовательностей “выкинем” последовательности после “неправильной”, и для всех оставшихся проверим, что открывшиеся скобки закрылись (для этого достаточно посчитать количество открывшихся и закрывшихся скобок каждого вида).
В результате останется найти ту единственную, а может и не единственную, ***её*** (нет, не девушку своей мечты, как вы могли подумать), скобочную последовательность с максимальным количеством «[».
Весь запрос:
```
with brackets as
(select '[[]])[([[]][[(]])]' b
from dual) ,
all_brackets as
(select substr(b,level,1) q,
level curr_pos,
level - 1 prev_pos
from brackets
connect by substr(b,level,1) is not null),
brackets_comb as
(select replace(sys_connect_by_path(q,'-'), '-') str,
q,
connect_by_root(curr_pos) start_pos,
curr_pos end_pos,
sum( case
when (q = '(' or q = '[')
and (prior q is null)
then 1
when (q = '(' or q = '[')
and (prior q = '(' or prior q = '[')
then 1
when (q = '(' or q = '[')
and (prior q = ']' or prior q = ')')
then 0
when (q = ')' or q = ']')
and (prior q = '(' or prior q = '[')
then 0
when (q = ')' or q = ']')
and (prior q = ')' or prior q = ']')
then -1
end)
over (partition by connect_by_root(curr_pos)
order by connect_by_root(curr_pos), curr_pos) bracket_level
from all_brackets
connect by prior curr_pos = prev_pos
start with q = '(' or q = '['),
brackets_comb_status as
(select start_pos,
end_pos,
str,
case
when q = ')'
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = '('
then 'ok'
when q = '('
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = ')'
then 'ok'
when q = '('
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos ) = ']'
then 'ok'
when q = ']'
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = '['
then 'ok'
when q = '['
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = ']'
then 'ok'
when q = '['
and lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) = ')'
then 'ok'
when lag(q) over (partition by start_pos, bracket_level
order by start_pos, bracket_level, end_pos) is null
and bracket_level > 0
then 'ok'
else 'not ok!'
end status
from brackets_comb bc)
select str "последовательность",
cnt "колличество [",
start_pos "позиция с",
end_pos "позиция по"
from (
select str,
start_pos,
end_pos,
length(regexp_replace(str,'[\)\(]',''))/2 cnt,
max(length(regexp_replace(str,'[\)\(]',''))/2) over (order by null) best_cnt
from (
select str,
start_pos,
end_pos,
nvl(
lag(
case
when status = 'ok' then null
else status
end
ignore nulls)
over (partition by start_pos order by start_pos, end_pos),
status
) status
from brackets_comb_status
)
where status = 'ok'
and length(replace(str,'[','')) = length(replace(str,']',''))
and length(replace(str,'(','')) = length(replace(str,')',''))
) result
where best_cnt = cnt
``` | https://habr.com/ru/post/151895/ | null | ru | null |
# Как поморгать 4 светодиодами на CortexM используя С++17, tuple и немного фантазии
Всем доброго здравия!
При обучении студентов разработке встроенного программного обеспечения для микроконтроллеров в университете я использую С++ и иногда даю особо интересующимся студентам всякие задачки для определения особо ~~больных на голову~~ одаренных учеников.
В очередной раз таким студентам была дана задача поморгать 4 светодиодами, используя язык С++ 17 и стандартную библиотеку С++, без подключения дополнительных библиотек, типа CMSIS и их заголовочных файлов с описанием структур регистров и так далее… Побеждает тот, у кого код в ROM будет занимать наименьший размер и меньше всего затрачено ОЗУ. Оптимизация компилятора при этом не должна быть выше Medium. Компилятор IAR 8.40.1.
Победитель ~~едет на Канары~~ получает 5 за экзамен.
Сам я до этого тоже эту задачу не решал, поэтому расскажу как её решили студенты и что получилось у меня. Предупреждаю сразу, навряд ли такой код можно будет использовать в реальных приложениях, потому и разместил публикацию в раздел «Ненормальное программирование», хотя кто знает.
### Условия задачи
Есть 4 светодиода на портах GPIOA.5, GPIOC.5, GPIOC.8, GPIOC.9. Ими нужно поморгать. Чтобы было с чем сравнивать мы взяли код написанный на Си:
```
void delay() {
for (int i = 0; i < 1000000; ++i){
}
}
int main() {
for(;;) {
GPIOA->ODR ^= (1 << 5);
GPIOC->ODR ^= (1 << 5);
GPIOC->ODR ^= (1 << 8);
GPIOC->ODR ^= (1 << 9);
delay();
}
return 0 ;
}
```
Функция `delay()` здесь чисто формальная, обычный цикл, её оптимизировать нельзя.
Предполагается, что порты уже настроены на выход и на них подано тактирование.
А также сразу скажу, что bitbanging не использовался, чтобы код был переносимым.
Этот код занимает 8 байт на стеке и 256 байт в ROM на Medium оптимизации
> 255 bytes of readonly code memory
>
> 1 byte of readonly data memory
>
> 8 bytes of readwrite data memory
255 байт из-за того, что часть памяти ушла под таблицу векторов прерывания, вызовы функций IAR для инициализации блока с плавающей точкой, всякие отладочные функции и функция \_\_low\_level\_init, где собственно порты настроились.
Итак, полные требования:
* Функция main() должна содержать как можно меньше кода
* Нельзя использовать макросы
* Компилятор IAR 8.40.1 поддерживающий С++17
* Нельзя использовать заголовочные файлы CMSIS, типа "#include «stm32f411xe.h»
* Можно использовать директиву \_\_forceinline для встраиваемых функций
* Оптимизация компилятора Medium
### Решение студентов
Вообще решений было несколько, я покажу только одно… оно не оптимальное, но мне понравилось.
Так как нельзя использовать заголовочные файлы, студенты первым делом сделали класс `Gpio`, который должен хранить ссылку на регистры порта по их адресам. Для этого они используют оверлей структуры, скорее всего идею взяли отсюда: [Structure overlay](https://blog.feabhas.com/2017/05/making-things-stuff-part-5/):
```
class Gpio {
public:
__forceinline inline void Toggle(const std::uint8_t bitNum) volatile {
Odr ^= bitNum ;
}
private:
volatile std::uint32_t Moder;
volatile std::uint32_t Otyper;
volatile std::uint32_t Ospeedr;
volatile std::uint32_t Pupdr;
volatile std::uint32_t Idr;
volatile std::uint32_t Odr;
//Проверка что структура выравнена
static_assert(sizeof(Gpio) == sizeof(std::uint32_t) * 6);
} ;
```
Как видно они сразу определили класс `Gpio` с атрибутами, которые должны быть расположены по адресам соответствующих регистров и метод для переключения состояния по номеру ножки:
Затем определили структуру для `GpioPin`, содержащую указатель на `Gpio` и номер ножки:
```
struct GpioPin
{
volatile Gpio* port ;
std::uint32_t pinNum ;
} ;
```
Затем они сделали массив светодиодов, которые сидят на конкретных ножках порта и пробежались по нему вызвав метод `Toggle()` каждого светодиода:
```
const GpioPin leds[] = {{reinterpret_cast(GpioaBaseAddr), 5},
{reinterpret\_cast(GpiocBaseAddr), 5},
{reinterpret\_cast(GpiocBaseAddr), 9},
{reinterpret\_cast(GpiocBaseAddr), 9}
} ;
struct LedsDriver {
\_\_forceinline static inline void ToggelAll() {
for (auto& it: leds) {
it.port->Toggle(it.pinNum);
}
}
} ;
```
**Ну собственно и весь код:**
```
constexpr std::uint32_t GpioaBaseAddr = 0x4002'0000 ;
constexpr std::uint32_t GpiocBaseAddr = 0x4002'0800 ;
class Gpio {
public:
__forceinline inline void Toggle(const std::uint8_t bitNum) volatile {
Odr ^= bitNum ;
}
private:
volatile std::uint32_t Moder;
volatile std::uint32_t Otyper;
volatile std::uint32_t Ospeedr;
volatile std::uint32_t Pupdr;
volatile std::uint32_t Idr;
volatile std::uint32_t Odr;
} ;
//Проверка что структура выравнена
static_assert(sizeof(Gpio) == sizeof(std::uint32_t) * 6);
struct GpioPin {
volatile Gpio* port ;
std::uint32_t pinNum ;
} ;
const GpioPin leds[] = {{reinterpret_cast(GpioaBaseAddr), 5},
{reinterpret\_cast(GpiocBaseAddr), 5},
{reinterpret\_cast(GpiocBaseAddr), 9},
{reinterpret\_cast(GpiocBaseAddr), 9}
} ;
struct LedsDriver {
\_\_forceinline static inline void ToggelAll() {
for (auto& it: leds) {
it.port->Toggle(it.pinNum);
}
}
} ;
int main() {
for(;;) {
LedsContainer::ToggleAll() ;
delay();
}
return 0 ;
}
```
Статистика их кода на Medium оптимизации:
> 275 bytes of readonly code memory
>
> 1 byte of readonly data memory
>
> 8 bytes of readwrite data memory
Хорошее решение, но памяти занимает много :)
### Решение мое
Я конечно решил не искать простых путей и решил действовать по серьезному :).
Светодиоды находятся на разных портах и разных ножках. Первое что необходимо, это сделать класс `Port`, но чтобы избавиться от указателей и переменных, которые занимают ОЗУ, нужно использовать статические методы. Класс порт может выглядеть так:
```
template
struct Port {
//здесь скоро что-то будет
};
```
В качестве параметра шаблона у него будет адрес порта. В заголовочнике `"#include "stm32f411xe.h"`, например для порта А, он определен как GPIOA\_BASE. Но заголовочники нам использовать запрещено, поэтому просто нужно сделать свою константу. В итоге класс можно будет использовать так:
```
constexpr std::uint32_t GpioaBaseAddr = 0x4002'0000 ;
constexpr std::uint32_t GpiocBaseAddr = 0x4002'0800 ;
using PortA = Port ;
using PortC = Port ;
```
Чтобы поморгать нужен метод Toggle(const std::uint8\_t bit), который будет переключать необходимый бит с помощью операции исключающее ИЛИ. Метод должен быть статическим, добавляем его в класс:
```
template
struct Port {
//сразу применяем директиву \_\_forceinline, чтобы компилятор воспринимал эту функцию как встроенную
\_\_forceinline inline static void Toggle(const std::uint8\_t bitNum) {
\*reinterpret\_cast(addr+20) ^= (1 << bitNum) ; //addr + 20 адрес ODR регистра
}
};
```
Отлично `Port<>` есть, он может переключать состояние ножки. Светодиод сидит на конкретной ножке, поэтому логично сделать класс `Pin`, у которого в качестве параметров шаблона будет `Port<>` и номер ножки. Поскольку тип `Port<>` у нас шаблонный, т.е. разный для разного порта, то передавать мы можем только универсальный тип T.
```
template
struct Pin {
\_\_forceinline inline static void Toggle() {
T::Toggle(pinNum) ;
}
} ;
```
Плохо, что мы можем передать любую чепуху типа `T` у которой есть метод `Toggle()` и это будет работать, хотя предполагается что передавать мы должны только тип `Port<>`. Чтобы от этого защититься, сделаем так, чтобы `Port<>` наследовался от базового класса `PortBase`, а в шаблоне будем проверять, что наш переданный тип действительно базируется на `PortBase`. Получаем следующее:
```
constexpr std::uint32_t OdrAddrShift = 20U;
struct PortBase {
};
template
struct Port: PortBase {
\_\_forceinline inline static void Toggle(const std::uint8\_t bit) {
\*reinterpret\_cast(addr ) ^= (1 << bit) ;
}
};
template ::value>> //Вот и защита
struct Pin {
\_\_forceinline inline static void Toggle() {
T::Toggle(pinNum) ;
}
} ;
```
Теперь шаблон инстанциируется, только если наш класс имеет базовый класс `PortBase`.
По идее уже можно использовать эти классы, давайте посмотрим, что получится без оптимизации:
```
using PortA = Port ;
using PortC = Port ;
using Led1 = Pin ;
using Led2 = Pin ;
using Led3 = Pin ;
using Led4 = Pin ;
int main() {
for(;;) {
Led1::Toggle();
Led2::Toggle();
Led3::Toggle();
Led4::Toggle();
delay();
}
return 0 ;
}
```
> 271 bytes of readonly code memory
>
> 1 byte of readonly data memory
>
> 24 bytes of readwrite data memory
Откуда взялись эти дополнительные 16 байт в ОЗУ и 16 байт в ROM. Они взялись из того, факта, что мы передаем в функцию Toggle(const std::uint8\_t bit) класса Port параметр bit, и компилятор, при входе в функцию main сохраняет на стеке 4 дополнительных регистра, через которые передает этот параметр, потом использует эти регистры в которых сохраняется значения номера ножки для каждого Pin и при выходе из main восстанавливает эти регистры из стека. И хотя по сути это какая-то полностью бесполезная работа, так как функции встроенные, но компилятор действует в полном соответствии со стандартом.
От этого можно избавиться убрав класс порт вообще, передать адрес порта в качестве параметра шаблона для класса `Pin`, а внутри метода `Toggle()` высчитывать адрес регистра ODR:
```
constexpr std::uint32_t OdrAddrShift = 20U;
template (addr + OdrAddrShift ) ^= (1 << bit) ;
}
} ;
using Led1 = Pin ;
```
Но это выглядит не совсем хорошо и удобно для пользователя. Поэтому будем надеяться, что компилятор уберет это ненужное сохранение регистров при небольшой оптимизации.
Ставим оптимизацию на Medium и смотрим результат:
> 251 bytes of readonly code memory
>
> 1 byte of readonly data memory
>
> 8 bytes of readwrite data memory
Вау вау вау… у нас на 4 байта меньше **сишного кода**
> 255 bytes of readonly code memory
>
> 1 byte of readonly data memory
>
> 8 bytes of readwrite data memory
Как такое может быть? Давайте взглянем на ассемблер в отладчике для С++ кода(слева) и Си кода(справа):
Видно, что во-первых, компилятор все функции сделал встроенные, теперь нет никаких вызовов вообще, а во вторых, он оптимизировал использование регистров. Видно, в случае с Си кодом, для хранения адресов портов компилятор использует то регистр R1, то R2 и делает дополнительную операции каждый раз после переключения бита (сохранить адрес в регистре то в R1, то в R2). Во втором же случае он использует только регистр R1, а поскольку 3 последних вызова на переключение всегда с порта C, то надобности сохранять тот же самый адрес порта С в регистре уже нет. В итоге экономится 2 команды и 4 байта.
Вот оно чудо современных компиляторов :) Ну да ладно. В принципе можно было на этом остановится, но пойдем дальше. Оптимизировать еще что-то, думаю, уже не выйдет, хотя возможно не прав, если есть идеи, пишите в комментариях. А вот с количеством кода в main() можно поработать.
Теперь хочется, чтобы все светодиоды были бы где нибудь в контейнере, и можно было бы вызывать метод, переключить все… Вот как-то так:
```
int main() {
for(;;) {
LedsContainer::ToggleAll() ;
delay();
}
return 0 ;
}
```
Мы не будем тупо вставлять переключение 4 светодиодов в функцию LedsContainer::ToggleAll, потому что это неинтересно :). Мы хотим светодиоды положить в контейнер и потом пройтись по ним и вызывать у каждого метод Toggle().
*Студенты использовали массив для того, чтобы хранить указатели на светодиоды.* Но у меня разные типы, например: `Pin`, `Pin`, и указатели на разные типы я хранить в массиве не могу. Можно сделать виртуальный базовый класс, для всех Pin, но тогда появится таблица виртуальных функций и ~~уделать~~ выиграть студентов мне не удастся.
Поэтому будем использовать кортеж. Он позволяет хранить у себя объекты разных типов. Выглядеть это дело будет выглядеть так:
```
class LedsContainer {
private:
constexpr static auto records = std::make_tuple (
Pin{},
Pin{},
Pin{},
Pin{}
) ;
using tRecordsTuple = decltype(records) ;
}
```
Отлично есть контейнер, он хранит все светодиоды. Теперь добавим в него метод `ToggleAll()`:
```
class LedsContainer {
public:
__forceinline static inline void ToggleAll() {
//сейчас придумаем как тут перебрать все элементы кортежа
}
private:
constexpr static auto records = std::make_tuple (
Pin{},
Pin{},
Pin{},
Pin{}
) ;
using tRecordsTuple = decltype(records) ;
}
```
Просто так пройтись по элементам кортежа нельзя, так как получение элемента кортежа должно происходить только на этапе компиляции. Для доступа к элементам кортежа есть темплейтный метод get. Ну т.е. если напишем так `std::get<0>(records).Toggle()`, то вызовется метод `Toggle()` для объекта класса `Pin`, если `std::get<1>(records).Toggle()`, то вызовется метод `Toggle()` для объекта класса `Pin` и так далее…
Можно было ~~утереть студентам нос~~ и просто написать так:
```
__forceinline static inline void ToggleAll() {
std::get<0>(records).Toggle();
std::get<1>(records).Toggle();
std::get<2>(records).Toggle();
std::get<3>(records).Toggle();
}
```
Но мы не хотим напрягать программиста, который будет поддерживать этот код и позволять делать ему дополнительную работу, тратя ресурсы его компании, скажем в случае, если появится еще один светодиод. Придется добавлять код в двух местах, в кортеж и в этот метод — а это нехорошо и владелец компании будет не очень доволен. Поэтому обходим кортеж с помощью методов помощников:
```
class class LedsContainer {
friend int main() ;
public:
__forceinline static inline void ToggleAll() {
// создаем последовательность индексов 3,2,1,0 и вызываем соответствующий метод, куда передается эта последовательность
visit(std::make_index_sequence::value>());
}
private:
\_\_forceinline template
static inline void visit(std::index\_sequence) {
Pass((std::get(records).Toggle(), true)...); // распаковываем в последовательность get<3>(records).Toggle(), get<2>(records).Toggle(), get<1>(records).Toggle(), get<0>(records).Toggle()
}
\_\_forceinline template
static void inline Pass(Args... ) {//Вспомогательный метод для распаковки вариативного шаблона
}
constexpr static auto records = std::make\_tuple (
Pin{},
Pin{},
Pin{},
Pin{}
) ;
using tRecordsTuple = decltype(records) ;
}
```
Выглядит страшновато, но я предупреждал в начале статьи, что способ ~~шизанутый~~ не очень обычный…
Вся эта магия сверху на этапе компиляции делает буквально следующее:
```
//Это вызов
LedsContainer::ToggleAll() ;
//Преобразуется в эти 4 вызова:
Pin().Toggle() ;
Pin().Toggle() ;
Pin().Toggle() ;
Pin().Toggle() ;
//А поскольку у нас метод Toggle() inline, то в это:
\*reinterpret\_cast(0x40020814 ) ^= (1 << 9) ;
\*reinterpret\_cast(0x40020814 ) ^= (1 << 8) ;
\*reinterpret\_cast(0x40020814 ) ^= (1 << 5) ;
\*reinterpret\_cast(0x40020014 ) ^= (1 << 5) ;
```
Вперед компилировать и проверять размер кода без оптимизации:
**Код который компилим**
```
#include
#include
#include
#include
#include
//#include "stm32f411xe.h"
#define \_\_forceinline \_Pragma("inline=forced")
constexpr std::uint32\_t GpioaBaseAddr = 0x4002'0000 ;
constexpr std::uint32\_t GpiocBaseAddr = 0x4002'0800 ;
constexpr std::uint32\_t OdrAddrShift = 20U;
struct PortBase
{
};
template
struct Port: PortBase
{
\_\_forceinline inline static void Toggle(const std::uint8\_t bit)
{
\*reinterpret\_cast(addr + OdrAddrShift) ^= (1 << bit) ;
}
};
template ::value>>
struct Pin
{
\_\_forceinline inline static void Toggle()
{
T::Toggle(pinNum) ;
}
} ;
using PortA = Port ;
using PortC = Port ;
//using Led1 = Pin ;
//using Led2 = Pin ;
//using Led3 = Pin ;
//using Led4 = Pin ;
class LedsContainer {
friend int main() ;
public:
\_\_forceinline static inline void ToggleAll() {
// создаем последовательность индексов 3,2,1,0 и вызываем соответствующий метод, куда передается эта последовательность
visit(std::make\_index\_sequence::value>());
}
private:
\_\_forceinline template
static inline void visit(std::index\_sequence) {
Pass((std::get(records).Toggle(), true)...);
}
\_\_forceinline template
static void inline Pass(Args... ) {
}
constexpr static auto records = std::make\_tuple (
Pin{},
Pin{},
Pin{},
Pin{}
) ;
using tRecordsTuple = decltype(records) ;
} ;
void delay() {
for (int i = 0; i < 1000000; ++i){
}
}
int main() {
for(;;) {
LedsContainer::ToggleAll() ;
//GPIOA->ODR ^= 1 << 5;
//GPIOC->ODR ^= 1 << 5;
//GPIOC->ODR ^= 1 << 8;
//GPIOC->ODR ^= 1 << 9;
delay();
}
return 0 ;
}
```
**Ассемблерный пруф, распаковалось как планировали:**
Видим, что по памяти перебор, на 18 байтов больше. Проблемы все те же, плюсом еще 12 байт. Не стал разбираться откуда они… может кто пояснит.
> 283 bytes of readonly code memory
>
> 1 byte of readonly data memory
>
> 24 bytes of readwrite data memory
Теперь тоже самое на Medium оптимизации и о чудо… получили код идентичный С++ реализации в лоб и оптимальнее Си кода.
> 251 bytes of readonly code memory
>
> 1 byte of readonly data memory
>
> 8 bytes of readwrite data memory
**Ассемблер**
Как видите победил я, и ~~поехал на Канары~~ и довольный отдыхаю в Челябинске :), но студенты тоже молодцы, экзамен сдали успешно!
[Кому интересно, код тут](https://onlinegdb.com/S1apkSaJH)
Где можно такое использовать, ну я придумал, например такое, у нас есть параметры в EEPROM памяти и класс описывающий эти параметры (Читать, писать, инициализировать в начальное значение). Класс шаблонный, типа `Param>`, `Param>` и нужно, например, все параметры сбросить в default значения. Как раз тут и можно все их положить в кортеж, так как тип разный и вызвать у каждого параметра метод `SetToDefault()`. Правда, если таких параметров будет 100, то ПЗУ отъестся много, зато ОЗУ не пострадает.
P.S. Надо признаться, что на максимальной оптимизации этот код по размеру получается такой же как на Си и на моем решении. И все потуги программиста по улучшению кода сводятся к одному и тому же коду на ассемблере.
P.S1 Спасибо [0xd34df00d](https://habr.com/ru/users/0xd34df00d/) за дельный совет. Можно упростить распаковку кортежа с помощью `std::apply()`. Код функции `ToggleAll()` тогда упроститься до такого:
```
__forceinline static inline void ToggleAll()
{
std::apply([](auto... args) { (args.Toggle(), ...); }, records);
}
```
К сожалению в IAR std::apply в текущей версии еще не реализован, но работать будет также, см [на реализацию с std::apply](https://onlinegdb.com/SJLu0aTyS) | https://habr.com/ru/post/457246/ | null | ru | null |
# Как сделать из сайта приложение и выложить его в Google Play за несколько часов. Часть 1/2: Progressive Web App
Наверное, все близкие к веб-разработке люди уже наслышаны о Progressive Web App. Ещё бы! Эта технология практически уравняла веб и мобильную разработку с точки зрения распространения продуктов и вовлечённости пользователей.
Да, современный фронтенд, написанный, например, на React, работает как приложение. Но вот только скачивается это приложение в браузер и запускается из него. В этом и заключается огромный гандикап, который всегда имела мобильная разработка. Давайте подумаем, чем с точки зрения обычного пользователя, «приложение» отличается от «сайта». Сразу в голову приходит, что приложение в телефоне, а сайт на компьютере. Но ведь есть мобильный браузер, так что сайт и в телефоне тоже. Тогда остаётся 3 существенных отличия:
1. Иконка приложения есть на главном экране смартфона.
2. Приложение открывается в отдельном окне.
3. Приложение отправляет push-уведомления.
Все 3 пункта снимаются благодаря Progressive Web App или PWA. Теперь, заходя на сайт из мобильного браузера, мы можем «скачать» его, после чего увидим иконку на главном экране. Кроме того, при запуске появляется заставка, как у мобильных приложений, и при желании можно настроить отправку push-уведомлений.
И казалось бы, всё прекрасно! Но увы, за 10 с лишним лет мобильной эпохи пользователи слишком сильно привыкли искать приложения в Google Play и App Store. Ломать привычки пользователей — дело неблагодарное, и потому ребята из Google (кстати, Google является разработчиком PWA) решили, что если гора не идёт к Магомеду, то… В общем, совсем недавно, 6 февраля 2019 года, они [обеспечили использование Trusted Web Activities](https://developers.google.com/web/updates/2019/02/using-twa) для выкладки веб-приложений в Google Play.
В статье из двух частей будет рассказано, как пройти полный путь от обычного веб-сайта до приложения в Google Play всего за считанные часы. Всё это будет показано на примере реального сервиса — [Скорочтец](https://skorochtec.ru/).
1. [Как сделать из сайта приложение и выложить его в Google Play за несколько часов. Часть 1/2: Progressive Web App](https://habr.com/ru/company/mailru/blog/450504/)
2. [Как сделать из сайта приложение и выложить его в Google Play за несколько часов. Часть 2/2: Trusted Web Activity](https://habr.com/ru/company/mailru/blog/450506/)
Lighthouse
==========
На входе у нас есть веб-сайт с мобильной вёрсткой:
Первым делом нужно установить расширение [Lighthouse](https://chrome.google.com/webstore/detail/lighthouse/blipmdconlkpinefehnmjammfjpmpbjk) в Google Chrome на своём рабочем компьютере. Это инструмент для анализа сайтов в целом и для проверки соответствия стандарту Progressive Web App в частности.
Далее открываем наш сайт, боевой или запущенный локально, и генерируем отчёт для него при помощи Lighthouse:
В разделе Progressive Web App отчёта вы должны увидеть примерно следующее:
Обратите внимание на раздел Installable. Во-первых, если вы запускаете сайт локально, а вам придётся это делать во время разработки и тестирования, то нужно использовать домен localhost и никакой другой. Благодаря этому будет удовлетворено требование «Use HTTPS», а точнее Lighthouse просто закроет глаза на него, и вы сможете полноценно тестировать свой PWA.
Кроме требования HTTPS, чтобы наше приложение превратилось в PWA и стало устанавливаемым, нужно подключить к сайту service worker и Web app manifest. Давайте сделаем это.
Service worker
==============
Технология [service workers](https://developer.mozilla.org/ru/docs/Web/API/Service_Worker_API/Using_Service_Workers) позволяет вашему сайту быть online даже тогда, когда сервер недоступен. Это такой посредник между клиентом и сервером, который перехватывает каждый запрос и в случае чего подсовывает данные из кэша в качестве ответа.
Для работы PWA достаточно базовой реализации service worker, которая выглядит следующим образом:
service-worker.js
```
// Должно быть true в production
var doCache = true;
// Имя кэша
var CACHE_NAME = 'my-pwa-cache-v2';
// Очищает старый кэш
self.addEventListener('activate', event => {
const cacheWhitelist = [CACHE_NAME];
event.waitUntil(
caches.keys()
.then(keyList =>
Promise.all(keyList.map(key => {
if (!cacheWhitelist.includes(key)) {
console.log('Deleting cache: ' + key)
return caches.delete(key);
}
}))
)
);
});
// 'install' вызывается, как только пользователь впервые открывает PWA
self.addEventListener('install', function(event) {
if (doCache) {
event.waitUntil(
caches.open(CACHE_NAME)
.then(function(cache) {
// Получаем данные из манифеста (они кэшируются)
fetch('/static/reader/manifest.json')
.then(response => {
response.json()
})
.then(assets => {
// Открываем и кэшируем нужные страницы и файлы
const urlsToCache = [
'/app/',
........
'/static/core/logo.svg*',
]
cache.addAll(urlsToCache)
console.log('cached');
})
})
);
}
});
// Когда приложение запущено, сервис-воркер перехватывает запросы и отвечает на них данными из кэша, если они есть
self.addEventListener('fetch', function(event) {
if (doCache) {
event.respondWith(
caches.match(event.request).then(function(response) {
return response || fetch(event.request);
})
);
}
});
```
Здесь реализованы обработчики для трёх событий: `install`, `activate` и `fetch`. Как только пользователь откроет сайт, на котором есть service worker, вызовется событие `install`. Это процедура установки сервис-воркера в браузер пользователя. В её обработчике в массиве `urlsToCache` вы можете указать страницы сайта, которые будут кэшироваться, включая статику. Затем вызывается `activate`, которое очищает ресурсы, использованные в предыдущей версии скрипта сервис-воркера. И теперь, когда сервис-воркер успешно установлен, он будет перехватывать каждое событие `fetch` и искать в кэше запрашиваемые ресурсы, прежде чем идти за ними на сервер.
Чтобы всё это заработало, нужно добавить скрипт для регистрации сервис-воркера в html-файлы. Так как Скорочтец является одностраничным приложением (SPA), то у него один единственный html, который после добавления указанного скрипта выглядит вот так:
index.html
```
Скорочтец
if ('serviceWorker' in navigator) {
window.addEventListener('load', function() {
navigator.serviceWorker.register('/service-worker.js').then(function(registration) {
// Registration was successful
console.log('ServiceWorker registration successful with scope: ', registration.scope);
}, function(err) {
// registration failed :(
console.log('ServiceWorker registration failed: ', err);
}).catch(function(err) {
console.log(err)
});
});
} else {
console.log('service worker is not supported');
}
```
Функция `navigator.serviceWorker.register('/service-worker.js')` принимает в качестве аргумента URL, по которому расположен файл сервис-воркера. Здесь не важно, как именно называется файл, но важно, чтобы он был расположен в корне домена. Тогда областью видимости сервис-воркера станет весь домен, и он будет получать события `fetch` из любой страницы.
Таким образом, расположив файл сервис-воркера по адресу [skorochtec.ru/service-worker.js](https://skorochtec.ru/service-worker.js) и добавив нужный скрипт в html, мы получаем следующую картину в отчёте Lighthouse:
Если сравнивать с предыдущим отчётом, то теперь у нас удовлетворён второй пункт и сайт отвечает 200 даже offline, а также в 5-м пункте мы видим, что сервис-воркер обнаружен, но вот стартовой страницы не хватает. Информация о стартовой странице и не только указывается в Web App Manifest, давайте добавим его!
Web App Manifest
================
[Манифест](https://developer.mozilla.org/ru/docs/Web/%D0%9C%D0%B0%D0%BD%D0%B8%D1%84%D0%B5%D1%81%D1%82) предоставляет информацию о нашем приложении: короткое и длинное имя, иконки всех размеров, стартовая страница, цвета и ориентация.
manifest.json
```
{
"short_name": "Скорочтец",
"name": "Скорочтец",
"icons": [
{
"src":"/static/core/manifest/logo-pwa-16.png",
"sizes": "16x16",
"type": "image/png"
},
{
"src":"/static/core/manifest/logo-pwa-32.png",
"sizes": "32x32",
"type": "image/png"
},
{
"src":"/static/core/manifest/logo-pwa-48.png",
"sizes": "48x48",
"type": "image/png"
},
{
"src":"/static/core/manifest/logo-pwa-72.png",
"sizes": "72x72",
"type": "image/png"
},
{
"src":"/static/core/manifest/logo-pwa-96.png",
"sizes": "96x96",
"type": "image/png"
},
{
"src":"/static/core/manifest/logo-pwa-144.png",
"sizes": "144x144",
"type": "image/png"
},
{
"src":"/static/core/manifest/logo-pwa-192.png",
"sizes": "192x192",
"type": "image/png"
},
{
"src":"/static/core/manifest/logo-pwa-512.png",
"sizes": "512x512",
"type": "image/png"
}
],
"start_url": "/app/",
"background_color": "#7ACCE5",
"theme_color": "#7ACCE5",
"orientation": "any",
"display": "standalone"
}
```
Последняя переменная указывает, что это будет отдельное приложение. Файл манифеста необходимо расположить на сайте (не обязательно в корне) и подключить его в html:
index.html
```
Скорочтец
if ('serviceWorker' in navigator) {
window.addEventListener('load', function() {
navigator.serviceWorker.register('/service-worker.js').then(function(registration) {
// Registration was successful
console.log('ServiceWorker registration successful with scope: ', registration.scope);
}, function(err) {
// registration failed :(
console.log('ServiceWorker registration failed: ', err);
}).catch(function(err) {
console.log(err)
});
});
} else {
console.log('service worker is not supported');
}
```
Давайте снова проанализируем сайт Lighthouse-ом:
Ура! Теперь у нас не просто сайт, а Progressive Web App! Возможно, вы заметили, что скорость загрузки резко подросла. Это никак не связано с тем, что мы делали, просто я заменил development-сборку React-приложения на production, чтобы отчёт выглядел максимально красиво.
Ну что ж, заходим на сайт из мобильного Chrome и что же мы видим?
Да! Можно открывать шампанское! Добавляем приложение на главный экран:
Бонусом получаем заставку при запуске, которая собирается из указанных в манифесте name, background\_color и иконки 512x512 в массиве icons:
К сожалению, цвет текста подбирается автоматически, что в случае Скорочтеца немного ломает стиль.
Ну и само приложение:
Ограничения
===========
На данный момент PWA поддерживается только в Chrome и Safari (начиная с iOS версии 11.3). Причём, Safari поддерживает эту технологию «по-тихому». Пользователь может добавить приложение на главный экран, но только никакого сообщения об этом нет, в отличие от Chrome.
Полезные советы и трюки
=======================
### 1. Предложение об установке на Safari
Поскольку в Apple этого не сделали (надеемся, что пока не сделали), то приходится реализовывать «руками». Получается вот такое:
Реализуется следующим JavaScript-кодом:
```
const isIos = () => {
const userAgent = window.navigator.userAgent.toLowerCase();
return /iphone|ipad|ipod/.test( userAgent );
};
// Проверяем, открыто ли приложение отдельно или в браузере
const isInStandaloneMode = () => ('standalone' in window.navigator) && (window.navigator.standalone);
// Если приложение открыто на iOS и в браузере, то предлагаем установить
if (isIos() && !isInStandaloneMode()) {
this.setState({ isShown: true }); // На примере React
}
```
### 2. Отслеживание установок
Это работает только в Google Chrome. Нужно добавить в html скрипт, отлавливающий событие appinstalled и, например, отправлять на свой сервер сообщение об этом:
```
window.addEventListener('appinstalled', (evt) => {
fetch(<your\_url>, {
method: 'GET',
credentials: 'include',
});
});
```
### 3. Правильный выбор start\_url
Обязательно нужно позаботиться о том, что url всех страниц приложения являются продолжением `start_url`, указанного в манифесте. Потому что, если вы укажете `"start_url": "/app/"`, а затем пользователь перейдёт на страницу, скажем, "/books/", то тут же покажет себя адресная строка браузера и весь пользовательский опыт сломается. Кроме того, человек почувствует себя обманутым: думал, что использует приложение, а это замаскированный браузер. И даже `theme_color` из манифеста, который окрасит интерфейс браузера в ваш фирменный цвет, не спасёт.
В случае Скорочтеца, все страницы, относящиеся к приложению, начинаются с /app/, поэтому таких казусов не возникает.
Что дальше?
===========
Ну что ж, теперь вы знаете, как забраться к пользователю на главный экран смартфона через ваш сайт. Но это только одна из дверей, и скорее всего не парадная. Во [второй части](https://habr.com/ru/company/mailru/blog/450506/) будет рассказано, как войти через парадную дверь: вы узнаете, как выложить ваше прогрессивное веб-приложение в Google Play.
Полезные ссылки
===============
* [Introduction to Progressive Web Apps (Offline First) — Part 1](https://auth0.com/blog/introduction-to-progressive-apps-part-one)
* [Introduction to Progressive Web Apps (Instant Loading) — Part 2](https://auth0.com/blog/introduction-to-progressive-web-apps-instant-loading-part-2)
* [Introduction to Progressive Web Apps (Push Notifications) — Part 3](https://auth0.com/blog/introduction-to-progressive-web-apps-push-notifications-part-3)
* [Разработка вашего первого Progressive Web App c React](https://tuhub.ru/posts/progressive-web-app-with-react)
* [9 amazing PWA secrets](https://www.creativebloq.com/features/9-amazing-pwa-secrets)
* [Progressive Web Apps on iOS are here](https://medium.com/@firt/progressive-web-apps-on-ios-are-here-d00430dee3a7)
* [Progressive Web Apps with React.js: Part I — Introduction](https://medium.com/@addyosmani/progressive-web-apps-with-react-js-part-i-introduction-50679aef2b12)
* [Progressive Web Apps with React.js: Part 2 — Page Load Performance](https://medium.com/@addyosmani/progressive-web-apps-with-react-js-part-2-page-load-performance-33b932d97cf2)
* [Progressive Web Apps with React.js: Part 3 — Offline support and network resilience](https://medium.com/@addyosmani/progressive-web-apps-with-react-js-part-3-offline-support-and-network-resilience-c84db889162c?source=user_profile---------11----------------)
* [Progressive Web Apps with React.js: Part 4 — Progressive Enhancement](https://medium.com/@addyosmani/progressive-web-apps-with-react-js-part-4-site-is-progressively-enhanced-b5ad7cf7a447)
* [A React And Preact Progressive Web App Performance Case Study: Treebo](https://medium.com/dev-channel/treebo-a-react-and-preact-progressive-web-app-performance-case-study-5e4f450d5299) | https://habr.com/ru/post/450504/ | null | ru | null |
# 30 полезностей для Firefox Developer Tools
Ниже приведены фичи и советы по использованию Firefox Developer Tools. Некоторые из них аналогичны возможностям инструментов в Chrome, для некоторых аналоги в других браузерах отсутствуют.
**Осторожно, под катом много тяжёлых гифок!**
---
Инспектор
=========
Поиск по CSS селектору
----------------------
Очень удобно использовать для:
* элементов с `z-index`, на которые не получается кликнуть
* визуально одинаковых элементов, для которых вы знаете селектор
Фильтр стилей
-------------
Вы можете отфильтровать правила CSS по любому селектору или свойству.
Для селекторов фильтр выделит цветом селекторы в списке правил. Для свойств инструмент развернёт все свойства, содержащие ваш фильтр, выделит их цветом, а так же скроет правила, где свойств из фильтра не содержится.
Выбор цвета и «Пипетка»
-----------------------
Кликните по любой точке с цветом в инспекторе, чтобы открыть удобный инструмент.
Смена представлений цвета
-------------------------
**Shift+клик** на цветной точке позволяет менять представление цвета (имя/hex/hsl/rgb).
**Shift+клик** на точке рядом с углом позволяет менять единицы измерения угла.
Редактирование кривых Безье функций времени
-------------------------------------------
Кликните на точке с искривлённой линией рядом со свойством функции времени, чтобы открыть удобный редактор. Там будут как предопределённые функции, так и возможность настроить свой вариант вручную.
---
Консоль
=======
Применение CSS
--------------
```
console.log(“#%c%s%c%s”, “color: #bada55”, “dev”, “color: #c55”, “tricks”)
```
Поддерживаются не все свойства, но [весьма много](https://developer.mozilla.org/en-US/docs/Web/API/Console#Styling_console_output).
Поиск по истории
----------------
Нажмите **CTRL+R** на Mac (и **F9** на Windows и Linux). После чего используйте **CTRL+R** / **CTRL+S** (**F9** / **SHIFT+F9**) для листания результатов вперёд / назад. В отличие от стрелочек, сочетания клавиш выше будут работать и между сессиями.
Скриншот страницы или её элемента
---------------------------------
```
:screenshot — fullpage
:screenshot — selector .css-selector
```
Гораздо удобнее просто указать селектор, чем пытаться точно выделить нужную область мышкой.
Переключение контекста JavaScript
---------------------------------
```
cd(iframe)
```
Вы можете переключаться на контекст **iframe** по селектору, используя **cd()**.
Метки в таймере
---------------
```
console.time(“#devtricks”)
console.timeEnd(“#devtricks”)
```
Запустить таймер — **console.time(“метка”)**,
остановить его - **console.timeEnd(“метка”)**.
---
Дебагер JavaScript
==================
Условные точки останова
-----------------------
Для создания точки надо сделать правый клик на номере строки. Точка будет активной только при выполнении условия.
Поиск по имени функции или номеру строки
----------------------------------------
Поиск по имени файла — **CMD + P** на Mac (и **CTRL + P** на Windows и Linux).
Напечатайте "**@"** в том же инпуте, чтобы искать по объявлению функции в файле.
Напечатайте **":**" в том же инпуте, чтобы быстро добраться до строки по её номеру.
Красивый вывод минифицированного кода
-------------------------------------
Нажмите на иконку **{}**, чтобы посмотреть красивый код вместо минифицированного.
Точки останова для URL
----------------------
Точка станет активной при попытке обратиться к урлу и покажет ответственный за обращение код.
Отключить точки останова
------------------------
Отключённые точки останутся доступны для включения и использования в будущем.
---
Сеть
====
Редактирование и пересылка HTTP запросов
----------------------------------------
Редактируйте отправленные запросы и оправляйте их заново.
Фильтр запросов
---------------
Фильтр по домену — **CMD + F** на Mac (или **CTRL + F** на Windows и Linux).
Если вам нужно найти все запросы, **без домена**, добавьте чёрточку (**-**) перед фильтром.
Ограничение скорости
--------------------
Проверьте как сайт будет загружаться при медленном интернете.
Горячее/Холодное профилирование
-------------------------------
Кликните по иконке с таймером, чтобы посмотреть производительность запросов, который делает сайт. Страница будет загружена дважды — без кэша (эмулируя первую загрузку) и с кэшом (эмулируя повторное обращение).
Сохранение/Загрузка HAR
-----------------------
Сохраняем совершённые запросы в [архивный формат](https://w3c.github.io/web-performance/specs/HAR/Overview.html). Удобно, чтобы обмениваться с коллегами по разработке.
---
Отзывчивый дизайн
=================
Кастомное устройство
--------------------
Просматривайте, как будет выглядеть сайт для устройств с кастомным разрешением.
Ограничение скорости
--------------------
Смотрим загрузку мобильной версии на мобильной скорости интернета.
Эмулирование тачей
------------------
За это отвечает маленькая иконка с «рукой». Эмулируются, в том числе долгие тапы.
Изменение User-Agent
--------------------
Не забудьте включить в настройках пункт «Перезагружать страницу при смене UA» — сэкономите время.
Выравнивание вьюпорта по левому краю
------------------------------------
Удобно, если хотите разместить панели справа (например, для дебага).
---
Инспектор хранилища
===================
Редактирование Cookies
----------------------
Сделайте двойной клик по ячейке, значение которой хотите поменять.
Удаление Cookies
----------------
Легче всего удалить куки, выделив их и нажав Backsapce.
Обратите внимание на опции контекстного меню. Очень удобной является опция «Удалить все для домена», но учтите, что домен должен быть точным (т.е. удаление кук для **.medium.com** не удалит их для **medium.com**)
Изменение Cookies в реальном времени
------------------------------------
Оранжевым мигают куки, которые только что были изменены.
Статические снимки для IndexedDB
--------------------------------
Увидеть изменения записей IndexedDB в реальном времени не получится, поэтому чтобы получить наиболее актуальный снимок БД, используйте кнопку «обновить».
Изменение отображаемых столбцов таблицы
---------------------------------------
Правый клик по заголовку таблицы поможет скрыть неинтересные столбцы.
---
На этом всё. Надеюсь, советы были вам полезны! | https://habr.com/ru/post/481036/ | null | ru | null |
# Как повысить качество кода в тестовом проекте
Качеством кода в тестах часто пренебрегают. Когда в совместной разработке участвуют десятки QA-инженеров, возникает острая необходимость ввести формализованные правила, чтобы все могли быстро ориентироваться в тестовом проекте. К тому же часто тесты пишутся по аналогии или копируются с небольшими изменениями. Когда счет тестов идет на тысячи, то код, написанный в плохом стиле, быстро распространяется. Для решения этих проблем в тестовом проекте Wrike мы уже больше двух лет используем связку инструментов PMD и Checkstyle. И она отлично работает. В этой статье хотим поделиться опытом по настройке этих инструментов, их использованию и кастомизации.
*В статье мы рассматриваем инструменты для контроля качества кода в тестовом проекте, который написан на Java с помощью фреймворка JUnit. В качестве системы хранения версий мы используем Git, а для сборки — Maven.*
Для команды QA Automation в Wrike проблема чистоты кода очень актуальна: в нашем тестовом проекте более 30 тысяч тестов, а контрибьютят в него более 70 человек.
Наиболее частые проблемы, с которыми мы сталкиваемся:
* Неиспользуемые или нежелательные импорты, переменные и private-методы.
* Большая длина строки и большой размер файла.
* Названия сущностей не в соответствии с договоренностями.
* Проблемы стилистического характера: пустые строки, несколько выражений на одной строке, отсутствие пробелов и т.п.
А еще есть проблемы, которые связаны со спецификой тестовых проектов:
* Неправильная разметка Epic/Feature/Story тестов.
* Необходимость проставления тегов некоторым группам тестов.
* Поддержка уникальности ID тестовых сценариев.
Для поддержания чистоты кода в компаниях часто используется практика ревью кода перед мержем ветки в мастер. Такой подход работает хорошо, но ревьюер — это человек, а человек может ошибиться. Хочется, чтобы на ревью приходил код без пропущенных пробелов, неправильно названных переменных и других подобных недостатков.
Практически все современные IDE поддерживают механизм инспекций в среде разработки без подключения внешних инструментов. Инструмент инспекций в популярной Intellij IDEA удобен для разработки, но достаточно тяжеловесный для организации процессов CI, поэтому этот вариант для нас не подошел. Также мы хотели сделать универсальный инструмент для всех разработчиков, а не только тех, которые используют Intellij IDEA.
Проверять практически все стилистические проблемы в коде нам в Wrike помогает инструмент [Checkstyle](https://checkstyle.sourceforge.io/). Но он не позволяет проверить логические кейсы — проставление аннотаций тестам, которые соответствуют определенным требованиям, проверка на неиспользуемые сущности в коде и т.д.
Для проверки логических ошибок мы используем [статический анализатор кода PMD](https://pmd.github.io/). Он позволяет проверять наиболее популярные кейсы, а также писать свои кастомные правила для любых проверок внутри файла. Но у него тоже есть недостаток — PMD может производить проверку файла только независимо от других файлов. Этого достаточно для большинства проверок, но мы не можем, например, проверить неиспользуемые public-методы, как в IDE.
Как подключить PMD и Checkstyle
-------------------------------
Существует несколько способов работы с PMD. Мы используем PMD Java API. Хоть этот способ не самый простой для подключения, он позволяет наиболее гибко настраивать проверки и обрабатывать результаты. Тонкости настройки PMD можно прочитать [в мануале](https://pmd.github.io/pmd-6.36.0/pmd_userdocs_tools_java_api.html).
PMD принимает список файлов для проверки и конфигурацию, в которой указаны нужные правила, и возвращает отчет в виде класса Report. Отчет можно вывести в консоль в читабельном виде.
Список правил для проверки хранится в XML-файле, туда же можно добавлять кастомные правила.
```
xml version="1.0"?
Ruleset of standard checks.
.\*/com/wrike/codestyle/.\*
...
...
```
Checkstyle, как и PMD, подключается через Maven:
```
com.puppycrawl.tools
checkstyle
8.41
```
Для запуска проверки необходимо передать в Main список файлов для проверки и путь к файлу для отчета. После выполнения файл отчета можно проанализировать. Если Checkstyle находит ошибки, он завершает исполняемую программу с кодом ошибки 1. В этом случае мы не сможем проанализировать файл отчета. Чтобы избежать этого, перед выполнением Checkstyle нужно переопределить SecurityManager таким образом, чтобы программа не заканчивала работу, а «бросала» исключение. Если исключение было «брошено», будем выводить ошибки из файла отчета в консоль.
Выглядит это так:
```
private void checkCodeStyle(Set fileSet) {
System.setSecurityManager(new SecurityManager() {
@Override
public void checkPermission(Permission perm) {
/\* Allow everything.\*/
}
@Override
public void checkExit(int status) {
/\* Don't allow exit with failed status code.\*/
if (status > 0) {
throw new CodeStyleViolationException();
}
}
});
try {
checkFilesWithCheckStyle(fileSet);
} catch (CodeStyleViolationException e) {
printViolation();
}
}
```
Список правил в Checkstyle также представляет собой XML-файл:
```
xml version="1.0"?
...
...
```
Список файлов, которые исключаются из проверки, хранится в отдельном XML-файле:
```
xml version="1.0"?
```
После того, как обе утилиты сконфигурированы, необходимо определить, какие файлы проверять. Не хочется прогонять проверки Checkstyle и PMD по всему проекту, если изменились всего несколько файлов. Для решения этой проблемы мы используем команду `git diff --name-only origin/master`. С ее помощью мы получаем список файлов для проверки, которые были изменены в этой ветке (в сравнении с мастером). Предварительно выполняется команда `git fetch`, которая «подтягивает» все изменения.
Чтобы не настраивать PMD и Checkstyle самостоятельно, вы можете воспользоваться [готовым проектом](https://github.com/wrike/PMDCheckstyleExample). В нем уже настроены все базовые проверки и кастомные правила, описанные в этой статье.
Для данного класса:
```
public class CommonTest {
@Test
public void test() {
if (true) {
;
}
}
}
```
Вывод проверок Checkstyle и PMD выглядит так:
Вывод проверок
```
2021-07-20 15:24:41,815 [main] ERROR com.wrike.codestyle.PMDTest -
Problems with PMD, found [2] violation(s)
2021-07-20 15:24:41,815 [main] ERROR com.wrike.codestyle.PMDTest - [
/src/test/java/com/wrike/tests/CommonTest.java
.(CommonTest.java:9)
at line `9` and column `13`
Do not use if statements that are always true or always false
UnconditionalIfStatement[
public class Foo {
public void close() {
if (true) { // fixed conditional, not recommended
// ...
}
}
}
]
check in https://pmd.github.io/pmd-6.33.0/pmd_rules_java_errorprone.html#unconditionalifstatement
-----------------------------------------------------------------------------
/src/test/java/com/wrike/tests/CommonTest.java
.(CommonTest.java:10)
at line `10` and column `13`
An empty statement (semicolon) not part of a loop
EmptyStatementNotInLoop[
public void doit() {
// this is probably not what you meant to do
;
// the extra semicolon here this is not necessary
System.out.println("look at the extra semicolon");;
}
]`
check in https://pmd.github.io/pmd-6.33.0/pmd_rules_java_errorprone.html#emptystatementnotinloop
-----------------------------------------------------------------------------
]
com.wrike.codestyle.PMDTest$PMDViolationException
...
2021-07-20 15:24:41,829 [main] INFO com.wrike.codestyle.CheckCodeStyleUtils -
List of 1 files for checking is:
/src/test/java/com/wrike/tests/CommonTest.java
Checkstyle ends with 1 errors.
2021-07-20 15:24:42,416 [main] ERROR com.wrike.codestyle.CheckStyleTest - [
/src/test/java/com/wrike/tests/CommonTest.java:7:5
.(CommonTest.java:7)
'METHOD_DEF' has more than 1 empty lines after. [EmptyLineSeparator]
----------------------------------------]
2021-07-20 15:24:42,417 [main] INFO com.wrike.codestyle.CheckStyleTest - 2021-07-20 15:24:42,417 [main] INFO com.wrike.codestyle.CheckStyleTest -
com.wrike.codestyle.CheckStyleTest$CodeStyleViolationException: Your code have [1] violation(s)! Please fix issue. Check logs for more information...
```
Как настроить кастомные правила
-------------------------------
С помощью стандартных правил PMD и Checkstyle можно проверить не все кейсы. Напишем несколько кастомных правил для PMD и подключим их к уже существующим проверкам. Для написания кастомных правил мы советуем ознакомиться с [документацией PMD](https://pmd.github.io/pmd-6.36.0/pmd_userdocs_extending_writing_rules_intro.html) по AST-классам и кастомным правилам.
**Уникальность тестов.** Для хранения истории прогонов тестов мы используем [Allure Server](https://youtu.be/O6X2-1uoqAw). Чтобы однозначно связать историю теста с конкретным тест-кейсом, мы используем собственную аннотацию `@TestCaseId`. Allure Server собирает историю теста, основываясь на его ID. В качестве уникального идентификатора можно было бы использовать имя теста, но оно может меняться, а ID — нет.
Для проверки уникальности теста и наличия у него ID мы используем два кастомных правила: `CheckDuplicateTestIdRule` и `TestMustHaveTestIdAnnotationRule`.
Правило TestMustHaveTestIdAnnotationRule проверяет наличие ID у каждого теста. Если у метода есть аннотации `@Test` или `@ParameterizedTest` из JUnit5, то он должен также иметь аннотацию `@TestCaseId`:
```
public class TestMustHaveTestIdAnnotationRule extends AbstractJavaRule {
@Override
public Object visit(final ASTMethodDeclaration node, final Object data) {
ASTAnnotation testAnnotation = node.getAnnotation(Test.class.getCanonicalName());
ASTAnnotation parameterizedTestAnnotation = node.getAnnotation(ParameterizedTest.class.getCanonicalName());
if (testAnnotation != null || parameterizedTestAnnotation != null) {
ASTAnnotation testCaseIdAnnotation = node.getAnnotation(TestCaseId.class.getCanonicalName());
if (testCaseIdAnnotation == null) {
addViolation(data, node);
}
}
return super.visit(node, data);
}
}
```
Правило `CheckDuplicateTestIdRule` проверяет, что ID во всем проекте не дублируются. Каждый метод проверяется отдельно, чтобы в отчете о проверке можно было вывести, в каком методе ошибка. Метод `findAllIds` ищет все ID один раз для всего правила.
```
public class CheckDuplicateTestIdRule extends AbstractJavaRule {
@Override
public Object visit(final ASTMethodDeclaration node, final Object data) {
ASTAnnotation testCaseIdAnnotation = node.getAnnotation(TestCaseId.class.getCanonicalName());
if (testCaseIdAnnotation != null) {
Map allIds = DuplicateTestCaseIdUtils.findAllIds();
ASTSingleMemberAnnotation memberAnnotation = (ASTSingleMemberAnnotation) testCaseIdAnnotation.getChild(0);
memberAnnotation.findDescendantsOfType(ASTLiteral.class).stream()
.map(ASTLiteral::getValueAsInt)
.filter(it -> allIds.get(it) > 1)
.forEach(it -> addViolation(data, node, it.toString()));
}
return super.visit(node, data);
}
}
```
Еще одно правило для тестов с ID — проверка количества ID для параметризованных тестов `ParametrizedTestIdsCountRule`. Количество ID должно быть строго равно количеству передаваемых наборов параметров, чтобы тесты не «терялись» и попадали в отчеты Allure. Для работы правила необходимо, чтобы метод provider находился в том же классе, что и тесты — это ограничение PMD, которое не получилось обойти.
Также мы решили отказаться от аннотации `@EnumSource`, потому что Enum может также находиться в другом файле. Вместо `@EnumSource` в тестовом проекте мы используем `@MethodSource`. Метод, который предоставляет параметры для теста, должен возвращать заранее вычисленный список, чтобы можно было посчитать количество необходимых ID. В случаях, когда невозможно выполнить все ограничения правила по объективным причинам, его можно подавить с помощью аннотации `@SuppressWarnings`. Код правила `ParametrizedTestIdsCountRule` можно посмотреть [в готовом проекте](https://github.com/wrike/PMDCheckstyleExample).
Все правила написаны, теперь подключим их к нашему проекту. Для этого создадим новый файл конфигурации `pmd-testcaseid-ruleset.xml` и заполним его:
pmd-testcaseid-ruleset.xml
```
xml version="1.0"?
Rules for check tests ids
You have to use @TestCaseId with @Test annotation.
1
There is a duplicate @TestCaseId.
1
Check that parameterized tests have the right count of test case ids.
1
```
**Разметка тестов.** Иногда хочется объединить группу тестов по какому-то признаку. Для этого в JUnit5 есть аннотация Tag. В тестовом проекте Wrike мы размечаем все скриншотные тесты отдельным тегом, чтобы запускать их отдельно от других тестов. Тест считается скриншотным, если он использует объект класса `ScreenshotSteps`.
Чтобы определить, что тест использует объект определенного класса, необходимо построить дерево вызовов методов и рекурсивно по нему пройтись. Если хотя бы один метод в иерархии использует объект класса `ScreenshotSteps`, то тест нужно разметить тегом.
Сокращенный код правила выглядит так:
Код правила ScreenshotTestMustHaveScreenshotTag
```
public class ScreenshotTestMustHaveScreenshotTag extends AbstractJavaRule {
private static final String SCREENSHOT_TAG = "SCREENSHOT_TEST";
private Map> screenshotMethodUsages;
private Map> methodUsages;
private final Set visitedMethods = new HashSet<>();
@Override
public Object visit(final ASTClassOrInterfaceDeclaration node, final Object data) {
if (nodeHasScreenshotTag(node)) {
return super.visit(node, data);
}
Optional>> screenshotStepsDeclaration = getScreenshotStepsDeclaration(node);
if (screenshotStepsDeclaration.isEmpty()) {
return super.visit(node, data);
}
Set screenshotMethods = getScreenshotMethods(screenshotStepsDeclaration);
methodUsages = getMethodUsages(node);
screenshotMethodUsages = methodUsages.entrySet().stream()
.filter(entry -> screenshotMethods.contains(entry.getKey()))
.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
Set allScreenshotMethods = dfsTree();
allScreenshotMethods.forEach(method -> {
Set extends Class<?> annotationSet = getAnnotations(method);
if ((annotationSet.contains(ParameterizedTest.class) || annotationSet.contains(Test.class))
&& !nodeHasScreenshotTag(method)) {
addViolation(data, method);
}
});
return super.visit(node, data);
}
}
```
Также для разметки тестов мы используем [Epic/Feature/Story](https://youtu.be/Y4I6Vp4sk_o) — популярный способ разметки тестов, который поддерживает Allure. В некоторых модулях проекта мы придерживаемся следующей концепции: тест должен иметь один `@Epic` и не более одной `@Feature` и `@Story`.
Для решения этой проблемы мы реализовали универсальное абстрактное правило, которое проверяет аннотации класса и методов:
Код правила TestShouldHaveOneEntity
```
public abstract class TestShouldHaveOneEntity extends AbstractJavaRule {
private static final String TEST_METHOD_JUNIT4_OR_JUNIT5 = "Test";
private final String entityAnnotation;
private final String multipleEntityAnnotation;
private final boolean mustHaveAnnotation;
public TestShouldHaveOneEntity(String annotationEntity, String multipleEntityAnnotation, boolean mustHaveAnnotation) {
super();
this.entityAnnotation = annotationEntity;
this.multipleEntityAnnotation = multipleEntityAnnotation;
this.mustHaveAnnotation = mustHaveAnnotation;
}
@Override
public Object visit(final ASTMethodDeclaration node, final Object data) {
Set annotationNameSet = getMethodAnnotations(node);
if (annotationNameSet.contains(TEST\_METHOD\_JUNIT4\_OR\_JUNIT5)) {
Set classAnnotationNameSet = getClassAnnotations(node);
if (annotationNameSet.stream().anyMatch(annotation -> annotation.equals(multipleEntityAnnotation))
|| classAnnotationNameSet.stream().anyMatch(annotation -> annotation.equals(multipleEntityAnnotation))) {
addViolation(data, node);
return super.visit(node, data);
}
boolean methodHasEntityAnnotation = annotationNameSet.stream().anyMatch(annotation -> annotation.equals(entityAnnotation));
boolean classHasEntityAnnotation = classAnnotationNameSet.stream().anyMatch(annotation -> annotation.equals(entityAnnotation));
if (mustHaveAnnotation && methodHasEntityAnnotation == classHasEntityAnnotation) {
addViolation(data, node);
return super.visit(node, data);
}
if (!mustHaveAnnotation && methodHasEntityAnnotation && classHasEntityAnnotation) {
addViolation(data, node);
}
}
return super.visit(node, data);
}
}
```
Теперь правила для `@Epic`, `@Feature` и `@Story` выглядят достаточно просто:
```
public class TestShouldHaveOnlyOneEpic extends TestShouldHaveOneEntity {
public TestShouldHaveOnlyOneEpic() {
super(Epic.class.getSimpleName(), Epics.class.getSimpleName(), true);
}
}
public class TestShouldHaveNoMoreThanOneStory extends TestShouldHaveOneEntity {
public TestShouldHaveNoMoreThanOneStory() {
super(Story.class.getSimpleName(), Stories.class.getSimpleName(), false);
}
}
public class TestShouldHaveNoMoreThanOneFeature extends TestShouldHaveOneEntity {
public TestShouldHaveNoMoreThanOneFeature() {
super(Feature.class.getSimpleName(), Features.class.getSimpleName(), false);
}
}
```
**Другие кастомные правила.** Еще одна проблема, с которой приходится сталкиваться — использование аннотации `@RepeatedTest` вместо `@Test`. Обычно такая аннотация используется для того, чтобы локально проверять тесты на стабильность. На ревью очень легко упустить этот момент, и тест будет запускаться несколько раз вместо положенного одного. Чтобы решить эту проблему, импорт `@RepeatedTest` запрещается специальным правилом. Если разработчик запушил ветку с этой аннотацией, ошибка будет выловлена на этапе пайплайна в CI.
```
public class ShouldNotImportRepeatedTest extends AbstractJavaRule {
private static final String REPEATED_TEST = RepeatedTest.class.getCanonicalName();
@Override
public Object visit(final ASTImportDeclaration node, final Object data) {
String nodeImportedName = node.getImportedName();
if (nodeImportedName.contains(REPEATED_TEST)) {
addViolation(data, node);
return super.visit(node, data);
}
return super.visit(node, data);
}
}
```
В тестовом проекте Wrike мы используем 62 проверки Checkstyle и 271 правило PMD, из которых 236 стандартных и 35 кастомных. Проверка всего проекта, состоящего из 38к тестов и 13к Java файлов, занимает меньше 10 минут. Однако практически всегда diff между веткой и мастером составляет менее 100 файлов, и проверка занимает 2-3 минуты.
Благодаря внедрению Checkstyle и PMD нам удается поддерживать чистоту в проекте и избегать логических ошибок.
Если вы хотите попробовать использовать связку PMD и Checkstyle, ищите проект с настроенными правилами [по этой ссылке](https://github.com/wrike/PMDCheckstyleExample).
А какие инструменты для поддержания порядка в кодовой базе используете вы? | https://habr.com/ru/post/574320/ | null | ru | null |
# Как иногда плохой код и антипаттерн решают
Привет %username%!
Сегодня я хотел бы рассказать о том, как мне помог в проекте плохой код.
Кому интересно, прошу под кат.
Достался мне в наследство проект на сопровождение. Не знаю кем писался, но этому человеку икается и по сей день. Суть такая — есть приложение для сбора фотоотчетов в магазине и их отправке руководству на сервак.
Все вроде просто, но были постоянные жалобы сотрудников на падение приложения при фотографировании. Анализ кода показал, что при вызове intent приложения камеры, Android убивал приложение из-за нехватки ресурсов и по возвращению результата в активити, последняя пересоздавалась и не содержала нужных для работы данных. Пересоздание активити просто не обрабатывалось. Ну да, есть же configChanges \*sarcasm\*
#### Шаг 1. Обработка пересоздания
Помучавшись 2 дня, поправив код, выкинув повторяющиеся фрагменты я принялся тестировать. Закинул в эмулятор taskkiller, запустил камеру, убил процесс. Фоткаю — красота!!! Все красиво, фотка есть. Нажимаю сохранить и… бабах) Приложение упало.
#### Шаг 2. Singleton — злое зло
Причина падения — нет данных о текущем отчете. Оказалось, что в приложении был чудо-синглтон, который хранил в себе ВСЕ! Абсолютно все критические данные, необходимые для работы приложения и даже больше. Это и токен авторизации, и 40 полей состояния отчета и ссылки на классы, описывающие отчет и геоданные юзера и еще пару коллекций Bitmap. В одно мгновение мы лишились всего, чего только можно было лишиться.
Результат был описан заказчику. Рефакторинг оценен, но столько денег у них не оказалось. При этом слезно попросили что-то сделать и наставить костылей.
#### Шаг 3. Меняем Singleton
Все, что пришло в голову — исправить синглтон так, чтобы он стал надежным и при этом абсолютно не поменялся его интерфейс. Придумано было следующее — все что только можно запихнуть в SharedPreferenses сохранялось туда.
```
public String getAuthToken() {
return getStingFromPref(AUTH_TOKEN);
}
.....
// и так далее.
```
Грубо, тупо, зато не нужно менять код во всем проекте и наш Singleton стал более устойчив (остались коллекции Bitmap, с которыми пока ничего не сделал). Все объекты, которые только можно сериализовать были сериализованы и тоже запихнулись в SharedPreferences.
Приложение ушло на тест, в прод и падения прекратились на 70% устройств. На остальных после отправки результата с камеры, пересоздавалась не текущая, а предыдущая активити в стеке. Для меня это пока загадка. Гуру — объясните в комментах.
Суть такая — Активити А стартует Активити Б с получением результата. Активити Б запускает intent камеры с получением результата.
Когда в процессе работы камеры процесс убивался, по созданию фотки пересоздавалась активити А. У активити Б не вызывался ни onCreate, ни onActivityResult. (P.S. Android 4.4)
goоgle и stackowerflow ответа не дали, пришлось идти другим путем и писать больше плохого кода.
Если пересоздать не получается, можно запретить убивать, подумал я и перешел к шагу 4.
#### Шаг 4. Финальный. Foreground-мусоровоз
Как же заставить Android не убивать процесс? Мои мысли были такими: «Если сказать операционке, что у нас есть важный foreground сервис, выполняющий важные нам вычисления ровно столько времени, сколько мы фоткам товар. Это определенно может сработать».
Так родился в проекте foreground-мусоровоз. Он гонял цикл от 0 до 60 и в теле засыпал на секунду. Как только приходил результат с камеры — сервис убивался. Приложение было собрано и отдано на тестирование.
Результат — KitKat оказался умнее и прибивал процесс. То-есть не изменилось ничего.
Я уже было отчаялся, когда мне в голову пришла еще одна мысль: «А если тупо сохранить ссылку на активити в синглтоне и вызвать startActivityForResult прямо из foreground-мусоровоза?». Я никогда так не делал и, надеюсь, больше не придется.
Приложение собрано, отдано в тест и… о чудо, процесс больше не закрывался.
Вместо заключения. Заказчик предупрежден, что у него плохое приложение и я сделал его еще хуже, но оно работает так как этого ждут сотрудники компании.
Напоследок. Расскажите про свой самый «плохой код» в карьере. Давайте поднимем друг другу настроение. | https://habr.com/ru/post/271703/ | null | ru | null |
# Дамп ShadowBrokers: разбираемся в содержимом директории «swift»
Всем привет! В пятницу 14 апреля рано утром в публичном доступе появился новый дамп инструментов и документов Агенства Национальной Безопасности США, украденных APT-группировкой TheShadowBrokers. В данной статье мы попытаемся разобраться, что же содержится в папке **swift** дампа.
Осторожно, под катом много картинок и текста.
Интересно, что на этот раз группировка выложила дамп на сервисе Steemit, сопроводив дамп текстом о том, как они разочарованы в президенте США Дональде Трампе, и озаглавив его "[Lost in translation](https://steemit.com/shadowbrokers/@theshadowbrokers/lost-in-translation)". Также интересным кажется и тот факт, что сам дамп выложен на сервисе Яндекс.Диск. Владельцем файла является пользователь с ником yurishitova.
Данный архив был расшифрован и выложен на [GitHub](https://github.com/misterch0c/shadowbroker).
### Что содержится в дампе?
Дамп состоит из трех директорий: oddjob, swift, windows. Ниже привожу листинг директорий.
**oddjob**`oddjob/
├── Binaries
│ ├── oddjob_builder
│ │ ├── bin
│ │ │ ├── oddjob_v3_x64.dll
│ │ │ ├── oddjob_v3_x64.exe
│ │ │ ├── oddjob_v3_x86.dll
│ │ │ └── oddjob_v3_x86.exe
│ │ ├── builder
│ │ │ └── oddjob_config_v3.exe
│ │ └── ODDJOB_BUilder_v3.hta
│ └── Payloads
│ ├── bigpayload.bin
│ ├── five_minute_beacon.bin
│ ├── greha_dll_x64.dll
│ ├── greha_dll_x86.dll
│ ├── OJ_Deleter_2.4.exe
│ ├── one_byte_payload.bin
│ ├── one_minute_beacon.bin
│ ├── process_list.bin
│ ├── two_minute_beacon.bin
│ └── zero_byte_payload.bin
├── Not-For-Release
│ ├── hashes.txt
│ ├── oddjob_v3_x64.dllstrings.txt
│ ├── oddjob_v3_x64.exestrings.txt
│ ├── oddjob_v3_x86.dllstrings.txt
│ └── oddjob_v3_x86.exestrings.txt
├── Testing-Docs
│ ├── ODDJOB_Testing.docx
│ └── tungsten_flame.txt
└── User-Docs
├── BITSversions.xlsx
└── How_to_setup_IIS_7_for_ODDJOB.docx
8 directories, 25 files`
**swift**`swift/
├── 00503_0_254.242_2013mar02
├── 00546_0_ensbdasa-09aug2013
├── 00553_0_ensbdpix3-09aug2013
├── 00554_0_ensbdpix4-09aug2013
├── 00555_0_ensbdrtr1-2013aug09
├── 00557_0_ENSBDVPN1-02AUG2013
├── 00558_0_ENSBDVPN2-02AUG2013
├── 00559_0_ENSBDVPN5-02AUG2013
├── 00560_0_ENSBDVPN6-02AUG2013
├── 00562_0_ENSBDSW01-02AUG2013
├── 00563_0_ENSBDSW02-02AUG2013
├── 00566_0_ENSBPVPN1.txt
├── 00566_1_ENSBPVPN2.txt
├── 00566_2_FW1-Configuration.txt
├── 00566_3_SW1-Configuration.txt
├── 00566_4_SW2-Configuration.txt
├── 00679_0_ENSBDVPN1-23AUG2013
├── 00687_0_ENSBDVPN2-23AUG2013
├── 00697_0_ENSBDVPN5-23AUG2013
├── 00702_0_ENSBDVPN6-23AUG2013
├── 00703_0_ensbdsslvpn1-system-2013aug15.cfg
├── 00705_0_254.229-2013sep06.txt
├── 00708_0_ensbdasa1-31aug2013
├── 00710_0_ensbdfw1-2013sep06
├── 00711_0_ensbdfw3-2013sep06
├── 00713_0_ensbdfw4-2013sep06
├── 00715_0_ensbdfw5-2013sep06
├── 00720_0_ensbdpix3-31aug2013
├── 00725_0_ensbdpix4-31aug2013
├── 00727_0_ensbdpix5-31aug2013
├── 00729_0_ensbdrtr1-2013sep06
├── 00734_0_ensbdsslvpn1-user-2013aug15.cfg
├── DNS Zone Trans 2013_10_11.txt
├── DNS Zone Trans 2013_10_17.txt
├── DSL1opnotes.txt
├── DSL2opnotes.txt
├── DSquery Belgium DC.xlsx
├── dsquery_Query_computers_from_MAIL001.txt
├── DSquey Dubai enDCBACKUP.xlsx
├── DSquey Egypt DC.xlsx
├── DSquey END boxes and MX servers.xlsx
├── DSqueyMain.xlsx
├── Eastnets_Huge_Map_05_13_2010.vsd
├── Eastnets_UAE_BE_Dec2010.vsd
├── Employee.txt
├── ~$$EN_DUBAI_ASA.~vsd
├── EN_DUBAI_ASA.vsd
├── EN_DUBAI_MAIN.vsd
├── EN Production net 01 AUG 2013_kdmoore.xlsx
├── EN Production net 01 AUG 2013.xlsx
├── ENSBDSSL1-2013SEP27.xml
├── ENSB DXB Passwords V2.4.xlsx
├── ENSBJVPN1_cfg.txt
├── ENSB UAE NW Topology V2.0.1339670413.vsd
├── FATags.txt
├── Important NOTES.txt
├── initial_oracle_exploit.sql
├── JEEPFLEA_MARKET_BE.xls
├── JEEPFLEA_MARKET Implants.xlsx
├── JEEPFLEA_MARKET Passwords V2.4.xlsx
├── JEEPFLEA_MARKET_UAE.xlsx
├── JF_M FIN Exfil.vsd
├── JFM_Status.pptx
├── Legend.pptx
├── list_of_saa_servers_8May2013.xlsx
├── NOC_firewall_passwords_30May2013.txt
├── Production.txt
├── ~$SB JO passwords V 2.docx
├── swift_msg_queries_all.sql
└── VPNFW_Plan.txt
0 directories, 70 files`
В директории **windows** содержится большое количество файлов, предлагаю читателю самостоятельно ознакомиться с ней, пройдя по ссылке выше на github. Уточню лишь, что данная директория содержит в себе фреймворки для эксплуатации, эксплойты и импланты, использованные АНБ для проникновения. При наличии интереса к данной тематике будет опубликовано продолжение статьи с разбором папки **windows** и её содержимого.
swift
-----
В процессе изучения содержимого директории сложилось впечатление, что это общая проектная папка, куда сотрудники складывали свои наработки и проектную документацию (судя по коду в скриптах из директории windows, предполагается, что эта папка автоматически маунтится к машине специалиста). По последним датам из различных файлов можно предположить, что содержимое было украдено в сентябре 2013 года, когда проект был еще в статусе полноценно кипящей работы. Исходя из текстовых и офисных файлов, можно сделать вывод, что атаке подверглась организация EastNets, связанная с разработкой финансового ПО и SWIFT.
**Описание EastNets с сайта SWIFT**EastNets Group is an international company specializing in creating software for financial organizations. Since its foundation, EastNets has been closely cooperating with SWIFT, participating in products, solutions and technological platforms development.
EastNets has created and is developing its core solution for Anti-Money Laundering and financing of terrorism (AML) en.SafeWatch, using its own expertise in secure data transmission, as well in service-oriented applications development.
EastNets Group offices are located in Brussels, Paris, New York, Los Angeles, Madrid, Hague and Luxembourg. With other regions, company is working via business partners’ network. Alliance Factors has been representing EastNets interests In Russia and CIS on an exclusive basis since 2004.
EastNets solutions users are the largest banks, including ING Bank, ABN Amro Bank, Bank of China, Credit Lyonnais Bank, Raiffeisen Bank, Hypovereinsbank, Nordea Group, Fortis Bank and many others.
Следующие файлы представляют из себя конфигурации сетевого оборудования, а именно:
**Cisco PIX**`00553_0_ensbdpix3-09aug2013
00554_0_ensbdpix4-09aug2013
00711_0_ensbdfw3-2013sep06
00713_0_ensbdfw4-2013sep06
00715_0_ensbdfw5-2013sep06
00720_0_ensbdpix3-31aug2013
00725_0_ensbdpix4-31aug2013
00727_0_ensbdpix5-31aug2013`
**Cisco ASA**`00546_0_ensbdasa-09aug2013
00566_2_FW1-Configuration
00708_0_ensbdasa1-31aug2013
00710_0_ensbdfw1-2013sep06`
**Маршутизатор Cisco**`00555_0_ensbdrtr1-2013aug09
00729_0_ensbdrtr1-2013sep06`
**Cisco switch**`00562_0_ENSBDSW01-02AUG2013
00563_0_ENSBDSW02-02AUG2013
00566_3_SW1-Configuration
00566_4_SW2-Configuration`
**Оборудование Juniper**`00503_0_254.242_2013mar02
00557_0_ENSBDVPN1-02AUG2013
00558_0_ENSBDVPN2-02AUG2013
00559_0_ENSBDVPN5-02AUG2013
00560_0_ENSBDVPN6-02AUG2013
00679_0_ENSBDVPN1-23AUG2013
00687_0_ENSBDVPN2-23AUG2013
00697_0_ENSBDVPN5-23AUG2013
00702_0_ENSBDVPN6-23AUG2013
00705_0_254.229-2013sep06`
Директория в числе прочих содержит файлы Microsoft Office, часть из них запаролена, брутфорс по известным словарям не дал результата:
*Файлы: ENSB DXB Passwords V2.4.xlsx, JEEPFLEA\_MARKET Passwords V2.4.xlsx*
Есть и презентация, созданная, судя по всему, для отчета о текущем статусе проекта. Презентация, судя по метаданным, создана 01.07.2013, последние изменения внесены 12.08.2013. Можно предложить, что примерно в эту дату и состоялся отчет.
*Файл: JFM\_Status.pptx*
Третья страница презентации говорит нам о неком JEEPFLEA\_POWDER, упоминаний о котором больше нет в архивах. Можно предположить, что данный проект называется JEEPFLEA и делится на этапы, из которых упомянуты только MARKET и POWDER. Далее в статье я буду использовать такое условное разделение.
Остановимся на этом поподробнее.
#### Первый слайд
Данный слайд многое говорит о проекте в целом. этап JEEPFLEA\_MARKET.
Цель этапа: отделения компании EastNets в Дубай, Бельгии и Египте.
Получено на данном этапе: 9 SAAs — могут иметься в виду внешние системы компании. Admins — могут иметься в виду админские доступы к внутренним системам.
Не известно, что означает Quad в презентации.
На слайде сообщается, что были получены доступы к пользовательской сети (employee network), а также планируется установка инструмента ZESTYLEAK на VPN-фаерволы компании. Исходя из открытых источников, ZESTYLEAK — имплант, входящий в состав FEEDTROUGH, разработанный АНБ для установки на сетевое оборудование марки Juniper. Упоминание о данном ПО есть в каталоге ANT (документы, опубликованные Эдвардом Сноуденом):
#### Третий слайд
На третьем слайде презентации говорится о планах этапа JEEPFLEA\_POWDER, на момент редактирования презентации особенных успехов у АНБ нет.
Цель этапа: филиалы компании BCG в Венесуэле и Панаме. Business Computer Group — реселлер компании EastNets в Венесуэле и Панаме.
**Описание BCG с сайта EastNets**[http://www.eastnets.com/Partners/Business\_Resellers/Americas\_copy1.aspx](http://)
Founded in 1994, BCG Business Computer Group is the strategic allied of EastNets for Latin America. Based in Panama and with an installed base of customers over 200 institutions distributed along all the Pacific Ocean Coast, BCG proudly renders Consultancy, Marketing, Sales and Support Service on behalf of EastNets. Our customers enjoy the comprehensive suite of products, such as SafeWatch Filtering, SafeWatch Profiling, Reporting, among others in the region.
Additionally, taking advantage of economy of scales inherited by BCG's Service Bureau PREMIER of SWIFT, small institutions have within their grasp EastNets Portfolio at competitive prices.
The above reasons made a definitive case for the compliance officers to join EastNets/BCG family of satisfied and happy users.
Geographical Coverage
Panama, Venezuela & the whole of Latin America except Brazil
Планы этапа: идет работа по компрометации машин администраторов с использованием имплантов SECONDDATE и IRONVIPER.
SECONDDATE — имплант для осуществления man-in-the-middle атаки с использованием веб-протоколов.
Доступно описание из документов, [опубликованных Сноуденом](https://search.edwardsnowden.com/docs/WILLOWVIXENandSECONDDATE2014-03-12nsadocs).
По всей видимости, имплант может представлять из себя некое подобие фреймворка [BeEF](http://beefproject.com/).
Продолжим изучать содержимое директории **swift**.
Во многих таблицах встречаются следующие интересные столбцы:
* **Implant/Implanted**.В данных столбцах записывается аббревиатура установленного на скомпрометированном хосте импланта, например FLAV — FlewAvenue.
* **PSP**. Антивирусное решение на хосте. [PSP](https://wikileaks.org/ciav7p1/cms/page_13762910.html) — Personal Security Products.
* **Trigger**. Содержат строку, которую необходимо послать оператору на скомпрометированный хост для вызова бэкдора. Данная строка задаётся при компиляции полезной нагрузки фреймворком DanderSpritz. Это позволяет скрывать присутствие импланта на целевой системе и получить к нему доступ по запросу.
* **Vulnerable**. В данный столбец записывается аббревиатура эксплойта, использованного для компрометации. Например ESAU — EsteemAudit.
В директории также присутствует множество таблиц с результатами запросов к домен-контроллерам корпоративной сети EastNets, в которых есть информация об имени хостов, установленной ОС и сервис пакам, фамилии и имена сотрудников и пр. служебная информация.
В директории имеются файлы, похожие на проектные заметки, а именно:
* Файлы с результатами трансфера DNS-зоны изнутри скомпрометированной сети. Судя по датам в названии файлов, трансфер зоны производился 11.10.2013 и 17.10.2013. *Файлы: DNS Zone Trans 2013\_10\_11.txt, DNS Zone Trans 2013\_10\_17.txt*
* *Заметки сотрудников, задействованных в проникновении.* В них имеются логи имплантов, полученные со скомпрометированных хостов, заметки о конфигурации имплантов, описаны шаги проникновения в некоторые хосты.
* Файлы DSL1opnotes.txt, DSL2opnotes.txt представляют из себя логи фреймворка DanderSpritz, по ним мы можем видеть некоторые операции по проникновению. В них мы можем увидеть идентификатор пользователя, задействованного в работах по проникновению:
`PROJECT=JEEPFLEA_MARKET
OPUSER=33159
OPSCHEDULE=13083019453124
SCRUBVER=6.007000008`
А вот так выглядит лог фреймворка DanderSpritz:
**Скрытый текст**`======================= T2
--- 192.168.200.52 --- ENSBDSL2
=======================
Win2k8 64 bit R2
1:25 PM 5/14/2013 PC2 target : 192.168.200.52
source : 192.168.200.11
final : 192.168.200.52
cb : 4378, 192.168.200.11
id : 0x100011b3c
key : jeepflea_market
ICMP : ICMP 8,0
Uptime:4 days, 16:6:5
Auditing:2013-05-14 13:30:17 z0.0.0.12] Security auditing dorked, do not stop command 798 or you will lose your blessing
PSP: Symantec Endpoint Protection 11
| 3756 | 560 | ------D:\Double-Take\DoubleTake.exe
grep -mask SPFILEACCESS.ORA -path D:\Alliance\Access\Database\database -pattern audit -nocase
cd c:\$Recycle.bin
put D:\DSZOPSDisk\Preps\swift_msg_queries_all.1368533247.sql -name C:\$Recycle.Bin\S-1-5-~1\$ICD12FA.txt
run -command "cmd.exe /q" -redirect
D:\alliance\access\database\bin\sqlplus.exe saauser/Aetq9f7CQtljCHtAmstCGF64C
1:59 PM 5/14/2013 -- disconnected when running the command
1:59 PM 5/14/2013 -- retriggered back on, checking logs
SQL>@$ICD12FA.txt
output file:$ICD12FB.txt
start:20130424
end:20130514
2:16 PM 5/14/2013 -- getting file
2:20 PM 5/14/2013 -- clean up
delete $ICD12FA.txt
delete $ICD12FB.txt
monitor packetredirect -listenport 3333 -raw
redirect -tcp -implantlisten 42316 -target 127.0.0.1 42316
dir -mask * -path c:\ -age 30m -recursive
prettych
quitanddelete
4:06 PM 5/14/2013 -- BURNED`
* *VSD файлы.* В основном это карты сети отделений EastNets в различных странах.
#### Документы Office
Некоторые файлы явно были созданы в самом EastNets и содержат соответствующие корпоративные пометки, в то время как другая часть файлов была создана непосредственно в АНБ, о чём говорят пометки с названием JEEPFLEA\_MARKET. В нескольких из таких файлов найдены метаданные, где раскрываются авторы документов, а также время создания и изменения документов. Исходя из этих данных, первый документ был создан 01.09.2011:
Тег NSA-FTS327 может говорить о принадлежности сотрудника Pecoraro Michael к подразделению Requirements & Targeting, которое в свою очередь входит в Tailored Access Operations (FTS32 — TAO).
Последние изменения в файл JEEPFLEA\_MARKET\_BE.xls (информация по отделению EastNets в Бельгии) внес некий Heidbreder Nathan S SSG NSA-F22.
Тег NSA-F22 может говорить о принадлежности сотрудника к подразделению F22: European Cryptologic Center (ECC), Германия.
В социальной сети LinkedIn зарегестрирован акканут, совпадающий по признакам на рассматриваемого сотрудника: nathan heidbreder, специальность значится как «Cryptologic Network Warfare Specialist at US Army». [Ссылка](https://www.linkedin.com/in/nathan-heidbreder-ba300b125/).
Поиск по твиттеру тоже дал результат: найден вероятный твиттер-аккаунт этого человека, зарегистрированный в 2014 году. Твиттер пуст и явно используется лишь для того, чтобы читать поток твитов из подписок. По подпискам этого твиттера можно предположить что данный твиттер-аккаунт и есть аккаунт этого человека.
Скриншот страницы [twitter.com/NHeidbreder](https://twitter.com/NHeidbreder):
Подписки пользователя в Twitter:
Скриншот страницы nathan heidbreder в Linkedin:
В процессе написания данной статьи аккаунты в Linkedin и Twitter были удалены, однако скриншоты сохранились.
Запрос в гугл по ключевым словам «nathan heidbreder us army» ведет на ресурс [corpsman.com](http://www.corpsman.com/2009/07/august-sgt-promotion-list-for-us-army/), где в списке фигурирует Heidbreder Nathan Scott.
Интересная деталь: твиттер [Austin Hurlock](https://twitter.com/ahurlo) был единственным подписчиком аккаунта @NHeidbreder в твиттере и аккаунтом, с которого была подтвержена компетенция «security» аккаунта nathan heidbreder в Linkedin.
На момент написания статьи аккаунт [Austin Hurlock](https://www.linkedin.com/in/austin-hurlock-518269123/) был доступен в Linkedin. В момент создания файлов по проекту JEEPFLEA, этот человек работал на должности Computer Network Defense Analyst в Marine Corps:
SQL
---
Помимо прочего в директории содержатся файлы с командами Oracle SQL для извлечения интересущей АНБ информации, приведу несколько примеров (*Файл initial\_oracle\_exploit.sql*):
```
select '"name","account_status","password","spare4"' from dual;
select '"'||name||'","'||account_status||'","'||u.password||'","'||spare4||'"' from user$ u, dba_users
where spare4 is not null
and username = name;
```
```
select '"SWIFT_Dates_In_Database"' from dual;
select substr(table_name,6,20) SWIFT_Dates_In_Database
from all_tables
where owner = 'SAAOWNER'
and table_name like 'MESG%'
and table_name not like '%YYYYMMDD%'
order by 1 desc
```
### Заключение
Уверен, что более глубокий анализ файлов данной директории смогут провести специалисты по форензике и OSINT, которым я не являюсь. На данный момент нет возможности уверенно утверждать что все вышеперечисленные события и предполагаемые исполнители действительно существовали. Однозначных доказательств аутентичности выложенных файлов не существует. Кроме того, тяжело сделать вывод о том, имеют ли какое-либо отношение данные люди к озвученным операциям спецслужб США.
Предлагаю хабраюзерам поучаствовать в дисскусии в комментариях.
*Андрей Рогожкин*
UPD: Коллеги подсказали, что аббревиатура **SAA** может означать [Swift Alliance Access](https://www.swift.com/our-solutions/interfaces-and-integration/alliance-access), комплекс обмена сообщениями, стоящий на стороне клиента. Т.е. возможно в ходе проекта были скомпрометированы 9 SAA у клиентов EastNets. | https://habr.com/ru/post/327114/ | null | ru | null |
# репостинг Twitter (или rss) в статус vkontakte.ru на Haskell
В данной статье речь пойдёт о небольшой программке, которая репостит твиты в статус во вконтакте.
Задача довольно простая и совершенно неоригинальная. Началось всё с того, что я прочитал статью на Хабре о том, как это [решается на python'е](http://habrahabr.ru/blogs/python/59236/) и аналогичную [статью про php](http://habrahabr.ru/blogs/php/59254/). В интернетах вроде бы даже какие-то онлайн сервисы есть специально для этой задачи. Но тут весь цимус в том, чтобы решить эту несложную задачу самому, используя свои любимые инструменты. Собственно решение на php появилось позже и с такой же целью.
Ну и на чём же писал я? На haskell, natürlich!
Дальше подробно расскажу о том, как я всё сделал и как это повторить. Никаких особых знаний для понимания, пожалуй, не требуется.
**Вступление**
В реализации решения мне помогли те две статьи и [статья про репостинг из rss в livejournal на хаскелле](http://sovety.blogspot.com/2009/03/scripting-in-haskell-just-beginning.html).
Сначала я хотел по-честному сделать работу с твиттером через [twitter-api](http://apiwiki.twitter.com/): потыкал соответствующую [библиотечку из hackage](http://hackage.haskell.org/package/hs-twitter), но она сходу не заработала и я её оставил — мне хотелось побыстрее получить результат и было лень копаться и разбираться, что я не так делаю. А поскольку твиттер транслируется по rss и чтение rss на haskell' е — уже решённая задача, я пошёл этим путём.
Тем более, что это более универсальное решение. Можно транслировать любой rss-канал во вконтакт. Можно даже сказать, что это не twitter2vkontakte, а rss2vkontakte.
Кроме того, я пользовался [vkontakte-api](http://userapi.ru/), а не парсил страницу в поисках статуса, как мои предшественники. Думаю, это плюс.
Остальное — это literate-haskell-код. То есть не код с комментариями, а подробные комментарии с кусочками кода, которые являются обычными исходниками на haskell'е. Этот пост можно просто сохранить целиком в файл с расширением .lhs и скормить интерпритатору/компилятору. Всё должно нормально работать.
Весь рабочий код здесь выделен вот такими символами: `>`
**Необходимые приготовления**
Предполагается, что компилятор Haskell и основной набор библиотек у Вас уже есть. Если нет, то это легко исправить — надо установить [Haskell Platform](http://hackage.haskell.org/platform/). Это очень просто.
Теперь, чтобы установить дополнительные библиотеки, достаточно набрать в консоли:
`cabal update
cabal install regex-tdfa curl feed utf8-string`
Дальше небольшой список импортов с краткими пояснениями.
Пару раз я использовал регулярные выражения:
`> **import** Text.Regex.TDFA ((=~))`
Один раз разрезал и склеивал список:
`> **import** Data.List (intercalate)`
Для всех интернет-запросов пользовался библиотекой curl:
`> **import** Network.Curl (curlGetString)
> **import** Network.Curl.Opts`
Читал и парсил rss-фиды:
`> **import** Text.Feed.Import (parseFeedString)
> **import** Text.Feed.Query (getFeedItems, getItemSummary)`
И даже разок кодировал строку в юникод:
`> **import** Codec.Binary.UTF8.String (encodeString)`
Дальше будет более содержательный код с более содержательными и, возможно, местами излишне подробными разъяснениями…
**Twitter через rss**
Первое, что нам понадобится — адрес нашей rss-ленты твитов. Его можно взять у себя на страничке в твиттере. Заведём для него отдельную константу:
`> feedUrl **=** "https://twitter.com/statuses/user\_timeline/22251772.rss"`
Как забирать rss-фиды и парсить, я подсмотрел в [статье про rss2lj](http://sovety.blogspot.com/2009/03/scripting-in-haskell-just-beginning.html). Но пользоваться этой библиотечкой я не стал. Там всё конечно хорошо сделано, но мне нужна одна простая функция, которая будет скачивать rss-фид, брать первый элемент и извлекать его содержание. И вот как я её сделал:
`> getTweet **::** IO String
> getTweet **=** **do**
> (_,feed) **<-** curlGetString feedUrl []
> return **$** getMsg **$** head **$** getItems feed
> **where**
> getItems **=** maybe (error "rss parsing failed!") getFeedItems **.** parseFeedString
> getMsg **=** maybe (error "rss-item parsing failed!") format **.** getItemSummary
> format **=** unwords **.** ("twitter:"**:**) **.** tail **.** words **.** encodeString`
Поясню, что в ней происходит. Функция `curlGetString :: URLString -> [CurlOption] -> IO (CurlCode, String)` берёт url-адрес, список опций, и выдаёт код операции (`CurlOk`, если всё прошло успешно) и ответ сервера. В данном случае, в качестве адреса мы указываем нашу twitter-rss ленту, и не даём никаких опций. На код завершения не обращаем внимания. А вот содержательную часть ответа обзываем feed.
Следующую строку надо читать справа налево: извлекаем элементы фида (`getItems feed`), получаем список, берём из него первый элемент (`head`), извлекаем из него собственно сообщение (`getMsg`) и возвращаем на выход.
А теперь поподробнее об этих функциях, в таком же порядке. Каждая из них написана в point-free-style, то есть без указания аргумента, просто как композиция (точка .) Других функций.
Композицию тоже можно читать справа налево, по точкам (: то есть в порядке применения фукнций: в `getItems` сначала применяется функция `parseFeedString` (из библиотеки Feed), она имеет тип (`String -> Maybe Feed`), то есть на вход получает строку со всякой кашей из rss-тегов, а выдаёт абстрактный тип фида, с которым уже можно что-то делать. Поскольку возвращается значение `Maybe Feed` («Может быть фид»), может статься, что парсер подавится, и вернёт `Nothing` — тогда мы выдаём ошибку с текстом «rss parsing failed!». Если же парсинг пройдёт удачно, мы получим значение (`Just фид`), и тогда применим к нему функцию `getFeedItems`, которая извлекает из фида элементы в виде списка. Это ветвление (`Nothing` или `Just ...`) реализуется стандартной функцией `maybe`.
После работы `getItems` мы получим список элементов фида: `[Item]`. Нам нужен только первый из них (то есть последний по дате). Берём его функцией `head`. И теперь хотим выковырять из него текст сообщения: `getMsg`.
Эта функция имеет схожую с `getItems` структуру: сначала применяется `getItemSummary`, которая возвращяет `Maybe String`. Если извлечь содержание не удалось, выдаём соответствующую ошибку. Иначе, форматируем полученное сообщение.
Форматирование (`format`) производится вкратце следующим образом (опять справа налево): кодируем строку в unicode, разбиваем на слова (по пробелам), выбрасываем первое слово, вставляем вместо него «twitter:» (по желанию), склеиваем обратно все слова в одну строку. Первое слово в rss-твитах — это всегда ваш ник. Поэтому мы его выкидываем.
Вот и всё с rss. Я, возможно, описал всё излишне подробно, но думаю, для любопытствующих, незнакомых с haskell'ем, это описание было содержательным.
**Vkontakte api**
Первым делом заведём несколько констант для работы с вконтактом:
`> email **=** "Ваш e-mail"
> uid **=** "Ваш user-id вконтакте"
> pass **=** "Ваш пароль"`
Это данные, соответствующие вашей регистрации во вконтакте.
Все операции осуществляются GET запросами на сервер (всё та же функция `curlGetString`), с соответствующими хитрыми адресами. Строятся они следующим образом:
базовый адрес (например [userapi.com/data](http://userapi.com/data)?) плюс список параметров в форме ключ=значение, разделённых амперсандами &.
Чтобы формировать такие адреса, напишем пару вспомогательных функций:
`> param **::** (String, String) **->** String
> param (key, value) **=** key **++** "=" **++** value **++** "&"`
Эта функция просто берёт пару (ключ, значение) и делает из неё строку нужного формата.
`> formUrl **::** String **->** [(String, String)] **->** String **->** String
> formUrl base opts sid **=** base **++** ( concatMap param (opts**++**[("id",uid)]) ) **++** sid`
Формируем url нужного формата из базового адреса `base`, списка опций `opts` (ввиде пар), и идентификатора сессии `sid` (о нём позже).
Содержательная часть находится в скобках: `map` берёт функцию и список, и применяет функцию к каждому элементу списка. То есть из списка пар `(ключ, значение)`, делает список строк `"ключ=значение&"`. А `concat` просто склеивает все эти строки в одну (`concatMap = concat . map`).
Для разных задач набор опций отличается, но во всех случаях нужно указывать идентификатор пользователя (`uid`), поэтому, чтобы не писать эту опцию каждый раз, мы добавляем её в определении этой функции.
Чтобы как-то работать с вконтактом, нужно сначала авторизоваться. Тогда сервер даст нам печеньки (cookies) и идентификатор сессии (sid = session id). Печеньками я пользоваться не стал, а вот sid нужен практически для любой операции с получением/изменением данных пользователя.
`> login **::** IO String
> login **=** **do**
> (_,headers) **<-** curlGetString authUrl [CurlHeader True]
> return ( headers **=~** "sid=[a-z0-9]\*" **::** String )
> **where**
> authUrl **=** formUrl "http://login.userapi.com/auth?"
> [("site","2"), ("fccode","0"),
> ("fcsid","0"), ("login","force"),
> ("email",email), ("pass",pass)] ""`
Адрес для аутентификации имеет кучу опций, назначение которых я не понял, но взял из документации и без них ничего не работает. Формируем этот адрес спомощью только что написанной функции `formUrl`, при этом в последние две опции вставляются наш email и пароль. А параметр sid остётся пустым — у нас его пока нет, и собственно ради него мы и написали функцию `login`.
Что в ней происходит: посылается curl-запрос, по адресу `authUrl`, который возвращает заголовки `headers` (для этого выставляется опция `CurlHeader`). В них собственно печеньки, адрес перенаправления и что-то ещё. Вот в адресе, куда нас посылает сервер, и спрятано то, что мы ищем. С помощью секретной техники регулярных выражений, из `headers` выдирается заветный session id, вида «sid=35dfe55b09b599c9fx622fcx8cd83a37».
На регулярных выражениях в haskell'е я останавливаться не буду — это отдельная тема. Можно считать, что это просто поиск подстроки нужного вида.
Замечательно! sid мы получили, теперь перед нами открыты все возможности api вконтакта. Для нашей задачи нужна только одна — изменение статуса.
В принципе любое взаимодествие с вконтактом будет свобиться к следующей команде:
`(_,answer) <- curlGetString someUrl []`
где `someUrl` — соотвествующий запрос (смотреть в документации), а `answer` — ответ сервера. Вот как выглядит запрос на изменение статуса:
`> setActivityUrl **::** String **->** String **->** String
> setActivityUrl text **=** formUrl "http://userapi.com/data?" [("act", "set\_activity"), ("text", text)]`
Обратите внимание на то, что третий параметр функции `formUrl` — `sid`, не указан. Это частичное применение — у функции 3 параметра, а мы дали только 2, значит получилась функция от оставшегося одного параметра. То есть `setActivityUrl` — функция не только от параметра `text` (собственно новый статус), но и от второго параметра `sid`, который как бы дописывается справа.
Ещё одна мелочь: в тексте твита будут пробелы, а это недопустимо для url-запроса. Поэтому мы сделаем простенькую функцию, заменяющую все пробелы, на %20:
`> escSpaces **=** intercalate "%20" **.** words`
Она разбивает строку на список слов, вставляет между соседними элементами этого списка строку "%20", а потом склеивает всё снова в одну строку (последние два действия делает функция `intercalate`).
Теперь мы можем собрать из уже обсуждённых частей, функцию изменения статуса:
`> setStatus **::** String **->** String **->** IO ()
> setStatus text sid **=** **do**
> (_,answer) **<-** curlGetString url []
> **if** answer **=~** "\"ok\":1" **::** Bool
> **then** putStrLn text
> **else** error "something is bad with vkontakte-api..."
> **where**
> url **=** setActivityUrl (escSpaces text) sid`
Можно было бы написать эту функцию и проще, в одну строку:
`setStatus text sid = curlGetString (setActivityUrl (escSpaces text) sid) []`
Но первый вариант нагляднее, там делается проверка ответа сервера — если ответ содержит `"ok":1`, то всё хорошо — статус сменился, о чём мы и сообщаем пользователю (себе то есть).
Всё! Теперь у нас есть все части мозаики и собрать её очень просто.
**main**
То, ради чего было были написаны все эти функции:
`> main **=** **do**
> tweet **<-** getTweet
> sid **<-** login
> setStatus tweet sid`
Выглядит до крайности просто, не правда ли? Тут уж комментарии излишни.
Думаю, что и все остальные функции выглядят достаточно понятно с моими пояснениями.
Статистики ради: ~40 LinesOfCode.
**Заключение**
Чтобы запустить этот код, надо как уже говорилось, просто сохранить весь пост в файл с расширением .lhs и набрать в консоли:
`runhaskell имя_файла.lhs`
Вот и всё.
Не знаю, нужно ли продолжение, рассказывающее о том, как автоматизировать этот запуск.
Лично для себя я (как пользователь Mac OS X) решил это созданием «Службы» в Automator и назначением горячей клавиши, для её быстрого вызова — это только автоматизация запуска, но для меня этого достаточно.
Надеюсь, это было кому-нибудь интересно читать. Жду Ваши вопросы/предложения/возражения (:
**upd:** переместил в тематический блог. | https://habr.com/ru/post/85894/ | null | ru | null |
# Пишем Penguin Daycare Simulator на Go (Google App Engine) и Lua (Corona SDK)
#### 1. Введение
Данный проект представляет собой простой пример использования Google App Engine в мобильном приложении.
Cерверная часть предоставляет список пингвинов в формате JSON. Мобильный клиент запрашивает этот список по HTTP или HTTPS.
Также серверная часть ведёт запись определённых событий в базу данных, а именно количество посещений конкретного пингвина и количество нажатий кнопок: скормить рыбку и почесать животик.
У каждого пингвина есть поля описания `Name`, `Bio` и поля счётчиков.
#### 2. Тонкости перевода
Думал как можно перевести Penguin Daycare Simulator на русский язык, но «детский сад» в качестве «daycare» не подходит, «дневной уход» тоже. Поэтому так и осталось без перевода.
#### 3. Подготовка
Если у вас не установлен Google App Engine Go SDK, то переходите по ссылке [Google App Engine](https://cloud.google.com/products/app-engine/), нажимайте «Try it now» и следуйте всем пунктам. Дайте имя своему проекту, выберите Go, скачайте и установите SDK. Убедитесь, что у вас корректно установлены переменные окружения (`PATH`, `GOROOT`, `GOPATH`, `APPENGINE_DEV_APPSERVER`), для этого в терминале у вас должна быть видна команда `goapp`. Забегая вперёд, скажу, что для загрузки простого проекта на сервер GAE и его запуска нужно выполнить команду `goapp deploy` в директории проекта. Она спросит у вас email гугло-аккаунта, на котором должен быть расположен проект. Важно чтобы имя проекта совпадало в app.yaml и на сайте. Но в данном проекте используются модули и процесс загрузки несколько отличается.
В качестве IDE для Go я рекомендую [LiteIDE](https://code.google.com/p/golangide/), а для Lua и Corona SDK — [ZeroBrane Studio](http://studio.zerobrane.com/). Скачать Corona SDK можно на их [сайте](https://developer.coronalabs.com/downloads/corona-sdk).
#### 4. Клинт-сервер
На картинке ниже представлена очень сложная схема общения между клиентом (слева) и сервером (справа).
Как видно клиент запрашивает только список пингвинов и отсылает только три события. Общение ведётся по HTTP, но можно использовать и HTTPS совершенно бесплатно. Это можно отнести к одному из плюсов использования GAE — нет необходимости платить за SSL сертификат и настраивать работу с ним.
Так как всё работает по HTTP, то можно непосредственно в браузере выполнять запросы без использования специального клиента.
[penguin-daycare-simulator.appspot.com](http://penguin-daycare-simulator.appspot.com)
Простое приветствие, не используется мобильным клиентом, но позволяет сказать работает ли сервис. Можете заменить http на https и убедиться, что так тоже работает.
[penguin-daycare-simulator.appspot.com/penguins](http://penguin-daycare-simulator.appspot.com/penguins)
Это самый важный запрос. С его помощью мобильный клиент получает список всех пингвинов, которые в данный момент находятся под присмотром.
Для более удобного просмотра этих данных я рекомендую расширение [JSONview](https://chrome.google.com/webstore/detail/jsonview/chklaanhfefbnpoihckbnefhakgolnmc) для Chrome.
[penguin-daycare-simulator.appspot.com/stat/visit](http://penguin-daycare-simulator.appspot.com/stat/visit)
[penguin-daycare-simulator.appspot.com/stat/fish](http://penguin-daycare-simulator.appspot.com/stat/fish)
[penguin-daycare-simulator.appspot.com/stat/bellyrub](http://penguin-daycare-simulator.appspot.com/stat/bellyrub)
Эти три запроса увеличивают соответствующие счётчики для какого-либо пингвина. `Id` пингвина передаётся в качестве POST параметра. Сервер ничего в ответ не возвращает, но вы можете, если хотите, добавить в ответ строку «OK» или другой сигнал успешного выполнения операции.
#### 5. Ещё скриншоты, больше скриншотов!
Уже перед публикацией статьи, вспомнил про этого пингвинчика:
**Смотреть позитиватор**
#### 6. Серверная часть — Google App Engine
Теперь можем перейти непосредственно к коду. Рассмотрим файловую структуру проекта на Go.
```
PenguinDaycareSimulatorServer/
├── default/
│ ├── app.go
│ ├── default.yaml
│ └── penguins.json
├── static/
│ ├── favicon.ico
│ └── static.yaml
└── dispatch.yaml
```
`default` и `static` — это модули. Проект для GAE может быть разбит на модули, а может работать и без них. В этом случае нужны только три файла: `app.yaml`, `app/app.go` и `penguins.json`. Изначально так и было в моём проекте (можно посмотреть первый коммит на GitHub), но мне захотелось добавить настройку `max_concurrent_requests`, которая отвечает за то, сколько одновременных запросов может обрабатывать один instance вашего приложения. Значение по умолчанию — всего 10. Go явно способен на большее. Максимальное значение — 500. При росте нагрузки и превышении этого значения, запускаются дополнительные копии вашего приложения и нагрузка распределяется между ними. Если хотите укладываться только в бесплатные квоты для GAE, то использование этой настройки крайне желательно. Если приложение не справляется с такой нагрузкой, то снижайте это значение и переходите на платный биллинг.
Так вот эта настройка доступна только для модулей. И в вашем приложении должно быть минимум 2 модуля, чтобы GAE посчитал его модульным.
`static` — очень простой модуль, без которого можно было бы и обойтись (если бы не ограничение GAE выше), его задача только в том, чтобы отдавать статично файл `favicon.ico`.
`default` — основной модуль, который и выполняет всю работу.
Файлы `*.yaml` — это настройки и описания. По одному на каждый модуль и один файл `dispatch.yaml`, который описывает какие URL какой модуль обрабатывает.
**dispatch.yaml**
```
application: penguin-daycare-simulator
dispatch:
- url: "*/favicon.ico"
module: static
- url: "*/"
module: default
```
**static.yaml**
```
application: penguin-daycare-simulator
module: static
version: 1
runtime: python27
api_version: 1
threadsafe: true
handlers:
- url: /favicon.ico
static_files: favicon.ico
upload: favicon.ico
```
**default.yaml**
```
application: penguin-daycare-simulator
module: default
version: 1
runtime: go
api_version: go1
automatic_scaling:
max_concurrent_requests: 500
handlers:
- url: /.*
script: _go_app
```
Обратите внимание, что в `static.yaml` runtime указан Python, а не Go. Это сделано потому, что GAE ругается, если пытаетесь загрузить модуль на Go без собственно Go файлов. Однако он не ругается на Python и PHP при такой ситуации.
**off topic**Внимательный читатель здесь может возразить мол «чем PHP хуже Python для отдачи статичных файлов» и попытаться развязать holywar, но Python лично мне ближе, поэтому и выбрал его. Любой другой может использовать PHP для этих целей. Конечно, это всё бессмысленно, так как ни Python, ни PHP не участвуют в этом процессе.
`handlers` в `default.yaml` указывает какие исполняемые файлы обрабатывает определённые URL. В нашем случае app.go обрабатывает все приходящие запросы (с учётом `dispatch.yaml`). Описание URL очень гибкое, использует регулярные выражения. Однако если для Python и PHP можно использовать разные файлы для обработки разных URL внутри одного модуля, то для Go это должен быть один единственный файл, который обозначается как "\_go\_app". Дальше уже внутри программы на Go можно выделить обработчики для разных URL и разбить всё приложение на несколько файлов, если необходимо.
Больше про настройку и yaml файлы можно почитать [тут](https://developers.google.com/appengine/docs/go/config/appconfig).
`penguins.json` — файл в формате JSON, содержащий в себе имена и описание всех используемых пингвинов.
**penguins.json**
```
[
{"id": "1",
"name": "Tux",
"bio": "Beloved Linux mascot"
},
{"id": "2",
"name": "Skipper",
"bio": "Small combat squad leader"
},
{"id": "3",
"name": "Lolo",
"bio": "Russian adventurer"
},
{"id": "4",
"name": "Gunter",
"bio": "The darkest character in Adventure Time"
},
{"id": "5",
"name": "The Penguin",
"bio": "Na, na, na, na, na, na, na, na, na, na... The Penguin! "
}
]
```
Добавление, редактирование пингвинов происходит через этот файл.
Теперь мы подошли к `app.go` — сердцу всего приложения. Полный листинг удобно смотреть сразу на GitHub — [app.go](https://github.com/Lerg/PenguinDaycareSimulatorServer/blob/master/default/app.go).
Упрощённая структура этого файла:
```
package app
Перечисление всех используемых библиотек.
import (...)
Структура каждого пингвина: Id, имя, описание, счётчики.
type penguin struct {...}
Слайс (массив) всех пингвинов.
var penguins []penguin
Структура записи в базу данных.
type penguinEntity struct {...}
Инициализация.
func init() {...}
Чтение penguins.json в слайс penguins.
func loadPenguinsJson() {...}
Обработчик / - вывод простого сообщения.
func rootHandler(w http.ResponseWriter, r *http.Request) {...}
Обработчик /penguins - вывод всех пингвинов со статистикой в формате JSON.
func penguinsHandler(w http.ResponseWriter, r *http.Request) {...}
Обработчик события /stat/visit - посещение пингвина.
func visitHandler(w http.ResponseWriter, r *http.Request) {...}
Обработчик события /stat/fish - кормление пингвина рыбкой.
func fishHandler(w http.ResponseWriter, r *http.Request) {...}
Обработчик события /stat/bellyrub - почёсывание пингвина по животику.
func bellyrubHandler(w http.ResponseWriter, r *http.Request) {...}
```
При запуске приложения первым делом запускается функция init(), которая производит чтение из файла penguins.json и устанавливает какая функция в ответе за разные запросы со стороны клиента. Вы уже могли ими воспользоваться по ссылкам в начале статьи.
`penguinsHandler()` сериализует слайс penguins в JSON формат функцией `json.Marshal()` и отдаёт клиентам через `fmt.Fprint()`.
`visitHandler()`, `fishHandler()`, `bellyrubHandler()` действуют по одной логике — берём пингвина из базы данных, увеличиваем на единицу соответствующий параметр и записываем обратно в базу данных. База данных — [Datastore](https://developers.google.com/appengine/docs/go/datastore/) — не является SQL совместимой, то есть она представляет собой NoSQL решение. Описание её работы достойно отдельной статьи.
Так как многие операции на GAE тарифицируются отдельно, в том числе и доступ к Datastore, то следует избегать излишнего использования ресурсов. Так, например, при запросе статистики по всем пингвинам совершенно необязательно предоставлять актуальные данные. Можно кэшировать этот запрос с временем жизни кэша скажем 10 минут. Для этого я ввёл дополнительную переменную `lastUpdateTime` — метку времени последнего обновления слайса `penguins`. А при каждом запросе `/penguins` я вызываю функцию `updatePenguinsStatistics()`, которая проверяет не истекло ли время жизни кэша и в цикле обновляет показания счётчиков для каждого пингвина в слайсе `penguins`.
Чтобы форсировать обновление вручную, я ввёл дополнительный запрос [/update](http://penguin-daycare-simulator.appspot.com/update) и соответствующий обработчик `updateHandler()`.
Каждый запрос обрабатывается в собственной goroutine, поэтому нужно защитить слайс `penguins` от возможной одновременной записи или чтения во время записи. Для этого используется `RWMutex` — мьютекс на чтение или запись. Его использование более эффективно, чем простого `Mutex`.
Для избежания платного потребления ресурсов, можно также ввести отложенную запись в базу данных, накапливая значения всех поступивших событий.
Для загрузки проекта на сервер GAE нужно выполнить три команды в терминале в директории проекта:
```
goapp deploy default/default.yaml
goapp deploy static/static.yaml
appcfg.py update_dispatch .
```
В дальнейшем при изменении app.go, необходимо только будет запускать `goapp deploy default/default.yaml`.
В заключении про серверную часть скажу, что для увеличения бесплатных лимитов я рекомендую подключить платный биллинг, но при этом задать максимальную стоимость в день равную $1. При этом некоторые бесплатные квоты увеличиваются, а вы всё ещё ничего не тратите.
#### 7. Клиентская часть — Corona SDK
Corona SDK — это кроссплатформенный фреймворк для разработки мобильный приложений под Android, iOS, Windows Phone (скоро) и HTML5 (в разработке). Использую данный продукт уже довольно давно, пишу игры как для клиентов в качестве фрилансера, так и для себя. Отмечу достойную скорость работы и быстроту создания приложений.
Начнём тоже с файловой структуры проекта. Файлов здесь больше, в основном за счёт иконок и картинок, поэтому убираю под спойлер.
**файловая структура**
```
PenguinDaycareSimulator/
├── images/
│ ├── penguins/
│ │ ├── 1.png
│ │ ├── 1@2x.png
│ │ ├── 2.png
│ │ ├── 2@2x.png
│ │ ├── 3.png
│ │ ├── 3@2x.png
│ │ ├── 4.png
│ │ ├── 4@2x.png
│ │ ├── 5.png
│ │ └── 5@2x.png
│ ├── background.jpg
│ ├── background@2x.jpg
│ ├── button-over.png
│ ├── button-over@2x.png
│ ├── button.png
│ ├── button@2x.png
│ ├── dot-off.png
│ ├── dot-off@2x.png
│ ├── dot.png
│ ├── dot@2x.png
│ ├── fish.png
│ ├── fish@2x.png
│ ├── hand.png
│ ├── hand@2x.png
│ ├── popup.png
│ └── popup@2x.png
├── lib/
│ ├── api.lua
│ ├── app.lua
│ └── utils.lua
├── scenes/
│ ├── choose.lua
│ ├── menu.lua
│ └── penguin.lua
├── Default-568h@2x.png
├── Icon-60.png
├── Icon-60@2x.png
├── Icon-72.png
├── Icon-72@2x.png
├── Icon-76.png
├── Icon-76@2x.png
├── Icon-Small-40.png
├── Icon-Small-40@2x.png
├── Icon-Small-50.png
├── Icon-Small-50@2x.png
├── Icon-Small.png
├── Icon-Small@2x.png
├── Icon-hdpi.png
├── Icon-ldpi.png
├── Icon-mdpi.png
├── Icon-ouya.png
├── Icon-xhdpi.png
├── Icon-xxhdpi.png
├── Icon.png
├── Icon@2x.png
├── build.settings
├── config.lua
└── main.lua
```
Можете пока обратить внимание только на Lua файлы.
`config.lua`, `build.settings` — файлы настройки проекта для Corona SDK. Указывают портретный или ландшафтный вид имеет приложение, опорное разрешение экрана, способ масштабирования и другие разные настройки. Если Corona SDK для вас в новинку, то можете не обращать пока внимание на эти файлы.
Также в корне вы найдёте кучу иконок под iOS и Android, плюс `Default-568h@2x.png` для корректной работы на iPhone 5. Внутри директории images/ есть обычные файлы и их удвоенные HD версии `@2x`. Сейчас в принципе уже можно не поддерживать устройства с экранами вроде iPhone 3GS, их процент очень мал, но тем не менее отличен от нуля. Для полноценной поддержки iPad Retina вам уже нужны будут `@4x` файлы и строчка в `config.lua`, но большинство игр и так нормально работают.
Corona SDK запускает приложение начиная с файла `main.lua`, в нём подключаются нужные библиотеки, объявляются некоторые переменные и происходит переход на сцену с кнопкой «Enter the Daycare». Все сцены (экраны) приложения хранятся в разных файлах и собраны в директории `scenes/`, а все пользовательские библиотеки я разместил в `lib/`. Разработчик волен располагать эти файлы как ему захочется, я предпочитаю так.
В `lib/` находятся `app.lua` и `utils.lua` — вместе это мой сборник полезных функций для работы с Corona SDK. В `app.lua` реализованы удобные обёртки над стандартными функциями Corona SDK для отображения картинок, текста, кнопок и др.
Переход из `main.lua` в `scenes/menu.lua` осуществляется через строчку
```
storyboard.gotoScene('scenes.menu')
```
Где, в свою очередь, уже выполняется запрос пингвинов на сервере. Вот основной кусок кода из `menu.lua`.
```
function scene:createScene (event)
local group = self.view
app.newText{g = group, text = 'Penguin Daycare', size = 32, x = _CX, y = _CY - 150}
app.newText{g = group, text = 'Simulator', size = 32, x = _CX, y = _CY - 110}
local pleaseWait = app.newText{g = group, text = 'Please Wait', size = 16, x = _CX, y = _CY}
local button = app.newButton{g = group, x = _CX, y = _CY,
text = 'Enter the Daycare',
onRelease = function()
storyboard.gotoScene('scenes.choose', {effect = 'slideLeft', time = app.duration})
end}
button.isVisible = false
app.api:getPenguins(function()
pleaseWait.isVisible = false
button.isVisible = true
end)
end
```
Создаются три строчки текста и одна кнопка. Кнопка спрятана до тех пор, пока мы не получим ответ от сервера. Сам запрос выполняется функцией `app.api:getPenguins()`, в качестве аргумента у неё callback-функция.
После нажатия на кнопку мы попадаем на сцену выбора пингвина, тоже приведу только основную часть кода из файла `choose.lua`.
```
function scene:createScene(event)
local group = self.view
self.backButton = app.newButton{g = group, x = _L + 10, y = _T + 10, w = 48, h = 32, rp = 'TopLeft',
text = 'Back',
fontSize = 14,
onRelease = function()
storyboard.gotoScene('scenes.menu', {effect = 'slideRight', time = app.duration})
end}
local function gotoPenguin(ind)
storyboard.gotoScene('scenes.penguin', {effect = 'slideLeft', time = app.duration, params = ind})
end
local slideView = newSlideView{g = group, x = 0, y = _CY, dots_y = 180, onRelease = gotoPenguin}
for i = 1, #app.api.penguins do
local p = app.api.penguins[i]
local slide = display.newGroup()
app.newImage('images/popup.png', {g = slide, w = 300, h = 335})
app.newImage('images/penguins/' .. p.id .. '.png', {g = slide, w = 200, h = 256})
app.newText{g = slide, x = 0, y = -140, text = p.name, size = 18, color = 'white'}
app.newText{g = slide, x = 0, y = 140, text = p.bio, size = 14, color = 'white', w = 220, align = 'center'}
slideView:addSlide(slide)
end
slideView:makeDots()
slideView:gotoSlide(1)
end
```
Здесь `newSlideView()` это функция, создающая простой виджет, с помощью которого можно пролистывать слайды с пингвинами. Код этого виджета располагается тут же в `choose.lua` в начале файла.
Для каждого пингвина создаётся слайд. Изображения пингвинов хранятся внутри приложения и соответствуют Id пингвинов. Это дело можно исправить путём хранения изображений на сервере GAE или любом другом. Для загрузки картинок из сети в Corona SDK есть функция `display.loadRemoteImage()` или более низкоуровневая `network.download()`.
По нажатию на слайд вызывается функция `gotoPenguin()`, которая получает номер (не `Id`) пингвина в массиве (table) всех полученных пингвинов. Эта функция производит переход на заключительную сцену `penguin.lua`, передавая этой сцене тот же самый аргумент.
**penguin.lua**
```
function scene:createScene(event)
local group = self.view
local background = app.newImage('images/background.jpg', {g = group, w = 384, h = 640, x = _CX, y = _CY})
self.backButton = app.newButton{g = group, x = _L + 10, y = _T + 10, w = 48, h = 32, rp = 'TopLeft',
text = 'Back',
fontSize = 14,
onRelease = function()
storyboard.gotoScene('scenes.choose', {effect = 'slideRight', time = app.duration})
end}
local ind = event.params
local p = app.api.penguins[ind]
local visitsLabel = app.newText{g = group, x = _CX, y = _T + 20, text = 'Visits: ' .. p.visit_count, size = 18, color = 'white'}
local fishLabel = app.newText{g = group, x = _CX, y = _T + 40, text = 'Fish: ' .. p.fish_count, size = 18, color = 'white'}
local bellyrubsLabel = app.newText{g = group, x = _CX, y = _T + 60, text = 'Belly rubs: ' .. p.bellyrub_count, size = 18, color = 'white'}
local penguin = app.newImage('images/penguins/' .. p.id .. '.png', {g = group, w = 200, h = 256, x = _CX, y = _CY - 25})
app.newButton{g = group, x = _CX - 80, y = _B - 50, w = 128, h = 48,
text = 'Fish',
fontSize = 14,
onRelease = function()
local fish = app.newImage('images/fish.png', {g = group, x = penguin.x, y = penguin.y + 200, w = 512, h = 188})
fish.alpha = 0.8
transition.to(fish, {time = 400, alpha = 1, y = penguin.y, xScale = 0.1, yScale = 0.1, transition = easing.outExpo, onComplete = function(obj)
transition.to(fish, {time = 400, alpha = 0, onComplete = function(obj)
display.remove(obj)
end})
end})
app.api:sendFish(p.id)
p.fish_count = p.fish_count + 1
fishLabel:setText('Fish: ' .. p.fish_count)
end}
app.newButton{g = group, x = _CX + 80, y = _B - 50, w = 128, h = 48,
text = 'Belly rub',
fontSize = 14,
onRelease = function()
local hand = app.newImage('images/hand.png', {g = group, x = penguin.x - 40, y = penguin.y + 30, w = 80, h = 80, rp = 'TopLeft'})
transition.to(hand, {time = 1200, x = penguin.x + 40, transition = easing.swing3(easing.outQuad), onComplete = function(obj)
display.remove(obj)
end})
app.api:sendBellyrub(p.id)
p.bellyrub_count = p.bellyrub_count + 1
bellyrubsLabel:setText('Belly rubs: ' .. p.bellyrub_count)
end}
app.api:sendVisit(p.id)
p.visit_count = p.visit_count + 1
visitsLabel:setText('Visits: ' .. p.visit_count)
end
```
В `penguin.lua` происходит загрузка фонового изображения, изображения выбранного пингвина, отображение нескольких текстовых меток и двух кнопок-действий. При нажатии на них происходит анимация действия и отправка запроса на сервер через функции `app.api:sendFish()` и `app.api:sendBellyrub()`. А `app.api:sendVisit()` вызывается сразу после создания сцены. После вызова каждой из этих функций обновляются соответствующие текстовые метки, даже если нет интернета. Это можно исправить, введя проверку на получение ответа от сервера по каждому запросу и предоставляя callback-функции.
Наконец, вся работа с сервером осуществляется в файле `lib/api.lua`.
**api.lua**
```
local _M = {}
local app = require('lib.app')
_M.hostname = 'http://penguin-daycare-simulator.appspot.com'
function _M:getPenguins(callback)
local url = '/penguins#' .. math.random(1000, 9999)
network.request(self.hostname .. url , 'GET', function (event)
if not event.isError then
local response = json.decode(event.response)
if response then
self.penguins = response
callback()
end
end
end)
end
function _M:sendVisit(id)
local url = '/stat/visit'
local request = {body = 'id=' .. id}
network.request(self.hostname .. url , 'POST', function (event)
if event.isError then
app.alert('Network error')
end
end, request)
end
function _M:sendFish(id)
local url = '/stat/fish'
local request = {body = 'id=' .. id}
network.request(self.hostname .. url , 'POST', function (event)
if event.isError then
app.alert('Network error')
end
end, request)
end
function _M:sendBellyrub(id)
local url = '/stat/bellyrub'
local request = {body = 'id=' .. id}
network.request(self.hostname .. url , 'POST', function (event)
if event.isError then
app.alert('Network error')
end
end, request)
end
return _M
```
Как можно было догадаться, работа с сервером производится простыми POST запросами. В случае `getPenguins()`, ответ от сервера конвертируется из JSON формата в массив (table) функцией `json.decode()` и помещается в поле (property) модуля.
Как видите, посылать POST запросы и реагировать на их ответы в Corona SDK очень просто. Соответственно очень простая вышла и сама интеграция с Google App Engine. Я не расписываю что делает каждая строчка, надеюсь синтаксис интуитивно понятен.
#### 8. Ссылки
Исходники лежат у меня на GitHub:
* Google App Engine — [github.com/Lerg/PenguinDaycareSimulatorServer](https://github.com/Lerg/PenguinDaycareSimulatorServer)
* Corona SDK — [github.com/Lerg/PenguinDaycareSimulator](https://github.com/Lerg/PenguinDaycareSimulator)
Можно установить клиентскую часть на Android 2.3.3+, вот [APK](http://188.226.45.254/tmp/PenguinDaycareSimulator.apk) ([mirror](https://dl.dropboxusercontent.com/u/55969280/PenguinDaycareSimulator.apk)).
Либо скачивайте Corona SDK, скачивайте исходники с GitHub и запускайте в Corona Simulator.
Спасибо [M0sTH8](https://habrahabr.ru/users/m0sth8/) за помощь в написании статьи.
Подписывайтесь на мой твиттер [@SergeyLerg](https://twitter.com/SergeyLerg)
На этом всё. Спасибо за внимание! | https://habr.com/ru/post/220031/ | null | ru | null |
# История одного толстого бинарника
*Привет. Меня зовут Марко (я системный программист в Badoo). И я представляю вашему вниманию перевод поста по Go, который мне показался интересным. Go действительно ругают за толстые бинарники, но при этом хвалят за статическую линковку и за удобство выкладки единственного файла. Если на современных серверах толстые бинарники – не проблема, то на встраиваемых системах – еще как. Автор описывает свою историю борьбы с ними в Go.*
Маленький размер файлов важен для приложений, работающих в условиях очень ограниченных ресурсов. В этой статье мы рассмотрим создание программы-агента, которая должна работать на разных маломощных устройствах. Ресурсы памяти и процессора у них будут невелики, и я даже не могу предсказать, насколько.
Бинарники Go отличаются маленьким размером и самодостаточностью: создав программу на Go, вы получаете единственный двоичный файл, в котором находится всё необходимое. Сравните с такими платформами, как Java, Node.js, Ruby и Python, где ваш код занимает лишь небольшую часть приложения, а всё остальное — куча зависимостей, которые тоже приходится упаковывать, если хочется получить самодостаточный пакет.
Несмотря на такое важное удобство, как возможность создавать самодостаточные бинарники, в Go нет встроенного инструментария, помогающего оценить размеры зависимостей, чтобы разработчики могли принимать взвешенные решения о том, включать эти зависимости в файл или нет.
Инструмент `gofat` поможет разобраться с размерами зависимостей в вашем Go-проекте.
### Создание IoT-агента
Я немного расскажу о том, как мы продумывали и создавали один из наших сервисов — IoT-агент, который будет развёртываться на маломощных устройствах по всему миру. И рассмотрим его архитектуру с операционной точки зрения.
Пример кода можно скачать отсюда: <https://github.com/jondot/fattyproject>
Во-первых, нам нужна хорошая CLI-эргономика, поэтому воспользуемся [`kingpin`](https://github.com/alecthomas/kingpin) — это POSIX-совместимая библиотека CLI-флагов и опций (мне настолько нравится эта библиотека, что я использовал её во многих своих проектах). Но на самом деле я воспользуюсь своим проектом [`go-cli-starter`](https://github.com/jondot/go-cli-starter), включающим в себя эту библиотеку:
```
$ git clone https://github.com/jondot/go-cli-starter fattyproject
Cloning into 'fattyproject'...
remote: Counting objects: 55, done.
remote: Total 55 (delta 0), reused 0 (delta 0), pack-reused 55
Unpacking objects: 100% (55/55), done.
```
Раз наша программа – это агент, то она должна работать постоянно. В качестве примера для этого мы воспользуемся циклом, который бесконечно выполняет ерундовую операцию.
```
for {
f := NewFarble(&Counter{})
f.Bumple()
time.Sleep(time.Second * 1)
}
```
Во время длительной работы в памяти накапливается всякий хлам — небольшие утечки памяти, забытые дескрипторы открытых файлов. Но даже крохотная утечка может превратиться в гигантскую, если приложение работает безостановочно годами. К счастью, в Go есть встроенные метрики и средство контроля за состоянием системы – [`expvars`](https://golang.org/pkg/expvar/). Это очень поможет при анализе внутренней кухни агента: поскольку он должен длительное время работать без остановки, время от времени мы будем анализировать его состояние — потребление процессора, циклы сбора мусора и так далее. Всё это будут для нас делать `expvars` и весьма удобный для решения подобных задач инструмент [`expvarmon`](https://github.com/divan/expvarmon).
Для использования `expvars` нам понадобится волшебный импорт. Волшебный – потому что в ходе импорта будет добавлен хэндлер к имеющемуся HTTP-серверу. Для этого нам нужен работающий HTTP-сервер из `net/http`.
```
import (
_ "expvar"
"net/http"
:
:
go func() {
http.ListenAndServe(":5160", nil)
}()
```
Раз наша программа превращается в сложный сервис, можем добавить ещё и библиотеку логирования с поддержкой уровней, чтобы получать информацию об ошибках и предупреждениях, а также понимать, когда программа работает штатно. Для этого воспользуемся [zap](https://github.com/uber-go/zap) (от компании Uber).
```
import(
:
"go.uber.org/zap"
:
logger, _ := zap.NewProduction()
logger.Info("OK", zap.Int("ip", *ip))
```
Сервис, безостановочно работающий на удалённом устройстве, который вы не контролируете и, вероятнее всего, не сможете обновлять, должен быть крайне устойчивым. Так что целесообразно заложить в него гибкость. Например, чтобы он мог исполнять кастомные команды и скрипты, то есть обеспечить механизм изменения поведения сервиса без его переразвёртывания или перезапуска.
Добавим средство запуска произвольного удалённого скрипта. Хотя это и выглядит подозрительно, но если это ваш агент или сервис, то вы можете подготовить встроенную runtime-песочницу для запуска кода. Чаще всего встраивают runtime-среды на JavaScript и Lua.
Мы воспользуемся встраиваемым JS-движком [otto](https://github.com/robertkrimen/otto).
```
import(
:
"github.com/robertkrimen/otto"
:
for {
:
vm.Run(`
abc = 2 + 2;
console.log("\nThe value of abc is " + abc); // 4
`)
:
}
```
Если предположить что контент, передающийся в `Run`, мы получаем извне, мы получили сложный и самообновляемый IoT-агент!
### Разбираемся с зависимостями двоичного файла Go
Итак, к чему мы пришли.
```
$ ls -lha fattyproject
... 13M ... fattyproject*
```
Будем считать, что нам нужны все добавленные зависимости, но в результате размер двоичного файла подбирается к 12 мегабайтам. Хотя это немного по сравнению с другими языками и платформами, однако с учётом скромных возможностей IoT-оборудования целесообразно будет уменьшить размер файла и затраты вычислительных ресурсов.
Давайте выясним, как добавляются зависимости в наш двоичный файл.
Для начала разберёмся с хорошо известным бинарником. [GraphicsMagick](http://www.graphicsmagick.org/) — современная вариация популярной системы обработки изображений `ImageMagick`. Вероятно, она у вас уже установлена. Если нет, то под OS X это можно сделать с помощью `brew install graphicsmagick`.
`otool` – альтернатива инструменту [ldd](http://man7.org/linux/man-pages/man1/ldd.1.html), только под OS X. С его помощью мы можем проанализировать двоичный файл и узнать, с какими библиотеками он слинкован.
```
$ otool -L `which convert`
/usr/local/bin/convert:
/usr/local/Cellar/imagemagick/6.9.3-0_2/lib/libMagickCore-6.Q16.2.dylib (compatibility version 3.0.0, current version 3.0.0)
/usr/local/Cellar/imagemagick/6.9.3-0_2/lib/libMagickWand-6.Q16.2.dylib (compatibility version 3.0.0, current version 3.0.0)
/usr/local/opt/freetype/lib/libfreetype.6.dylib (compatibility version 19.0.0, current version 19.3.0)
/usr/local/opt/xz/lib/liblzma.5.dylib (compatibility version 8.0.0, current version 8.2.0)
/usr/lib/libbz2.1.0.dylib (compatibility version 1.0.0, current version 1.0.5)
/usr/lib/libz.1.dylib (compatibility version 1.0.0, current version 1.2.5)
/usr/local/opt/libtool/lib/libltdl.7.dylib (compatibility version 11.0.0, current version 11.1.0)
/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1226.10.1)
```
Из списка можно вычленить и размер каждой зависимости:
```
$ ls -lha /usr/l/.../-0_2/lib/libMagickCore-6.Q16.2.dylib
... 1.7M ... /usr/.../libMagickCore-6.Q16.2.dylib
```
Можем ли мы таким образом получить достаточно полное представление о **любом** двоичном файле? Очевидно, что ответ — «нет».
По умолчанию Go линкует зависимости статично. Благодаря этому мы получаем единственный самодостаточный двоичный файл. Но это также означает, что `otool`, как и любой другой подобный инструмент, будет бесполезен.
```
$ cat main.go
package main
func main() {
print("hello")
}
$ go build && otool -L main
main:
```
Если всё же пытаться разобрать двоичный файл Go на его зависимости, то нам придётся воспользоваться инструментом, который понимает формат этих двоичных файлов. Давайте поищем что-то подходящее.
Для получения списка доступных инструментов воспользуемся `go tool`:
```
$ go tool
addr2line
api
asm
cgo
compile
cover
dist
doc
fix
link
nm
objdump
pack
pprof
trace
vet
yacc
```
Можем сразу обратиться к [исходным кодам этих инструментов](https://golang.org/src/cmd/). Возьмём, к примеру, nm, и посмотрим его [документацию пакета](https://golang.org/src/cmd/nm/doc.go). Я умышленно упомянул этот инструмент. Как оказалось, возможности `nm` очень близки к тому, что нам нужно, но этого всё-таки недостаточно. Он умеет выводить список символов и размеров объектов, но всё это бесполезно, если мы пытаемся составить общее представление о зависимостях двоичного файла.
```
$ go tool nm -sort size -size fattyproject | head -n 20
5ee8a0 1960408 R runtime.eitablink
5ee8a0 1960408 R runtime.symtab
5ee8a0 1960408 R runtime.pclntab
5ee8a0 1960408 R runtime.esymtab
4421e0 1011800 R type.*
4421e0 1011800 R runtime.types
4421e0 1011800 R runtime.rodata
551a80 543204 R go.func.*
551a80 543204 R go.string.hdr.*
12d160 246512 T github.com/robertkrimen/otto._newContext
539238 100424 R go.string.*
804760 65712 B runtime.trace
cd1e0 23072 T net/http.init
5e3b80 21766 R runtime.findfunctab
1ae1a0 18720 T go.uber.org/zap.Any
301510 18208 T unicode.init
5e9088 17924 R runtime.typelink
3b7fe0 16160 T crypto/sha512.block
8008a0 16064 B runtime.semtable
3f6d60 14640 T crypto/sha256.block
```
Хотя применительно к самим зависимостям указанные размеры (вторая колонка) могут быть точны, но в целом мы не можем просто взять и сложить эти значения.
### Gofat
Остался последний трюк, который должен сработать. Когда вы компилируете свой двоичный файл, Go генерирует промежуточные файлы для каждой зависимости, прежде чем статически слинковать их в единый файл.
Представляю вашему вниманию `gofat` — shell-скрипт, который является комбинацией кода на Go и некоторых Unix-инструментов. Он анализирует размеры зависимостей в двоичных файлах Go:
```
#!/bin/sh
eval `go build -work -a 2>&1` && find $WORK -type f -name "*.a" | xargs -I{} du -hxs "{}" | gsort -rh | sed -e s:${WORK}/::g
```
Если торопитесь, то просто скопируйте или скачайте этот скрипт и сделайте его исполняемым (`chmod +x`). Потом запустите скрипт без каких-либо аргументов в директории своего проекта, чтобы получить информацию о его зависимостях.
Давайте разберёмся с этой командой:
eval `go build -work -a 2>&1`
Флаг -a говорит Go, чтобы он игнорировал кэш и собирал проект с нуля. В этом случае все зависимости будут пересобраны принудительно. Флаг –work выводит рабочую директорию, так что мы можем её проанализировать (спасибо разработчикам Go!).
```
find $WORK -type f -name "*.a" | xargs -I{} du -hxs "{}" | gsort -rh
```
Затем мы с помощью инструмента `find` находим все файлы `*.a`, представляющие собой наши скомпилированные зависимости. Затем передаём все строки (месторасположения файлов) в `xargs`. Эта утилита позволяет применять команды к каждой передаваемой строке — в нашем случае в `du`, который получает размер файла.
Наконец, воспользуемся `gsort` (GNU-версия sort) для выполнения сортировки размеров файлов в обратном порядке.
```
sed -e s:${WORK}/::g
```
Убираем отовсюду префикс папки WORK и выводим на экран очищенную строку с данными по зависимости.
Переходим к самому интересному: что же занимает 12 Мб в нашем двоичном файле?
### Сбрасываем вес
В первый раз запускаем `gofat` применительно к нашему игрушечному проекту с IoT-агентом. Получаем такие данные:
```
2.2M github.com/robertkrimen/otto.a
1.8M net/http.a
1.4M runtime.a
960K net.a
820K reflect.a
788K gopkg.in/alecthomas/kingpin.v2.a
668K github.com/newrelic/go-agent.a
624K github.com/newrelic/go-agent/internal.a
532K crypto/tls.a
464K encoding/gob.a
412K math/big.a
392K text/template.a
392K go.uber.org/zap/zapcore.a
388K github.com/alecthomas/template.a
352K crypto/x509.a
344K go/ast.a
340K syscall.a
328K encoding/json.a
320K text/template/parse.a
312K github.com/robertkrimen/otto/parser.a
312K github.com/alecthomas/template/parse.a
288K go.uber.org/zap.a
232K time.a
224K regexp/syntax.a
224K regexp.a
224K go/doc.a
216K fmt.a
196K unicode.a
192K compress/flate.a
172K github.com/robertkrimen/otto/ast.a
172K crypto/elliptic.a
156K encoding/asn1.a
152K os.a
136K strconv.a
128K os/exec.a
128K github.com/Sirupsen/logrus.a
128K flag.a
112K vendor/golang_org/x/net/http2/hpack.a
104K strings.a
104K net/textproto.a
104K mime/multipart.a
```
Если поэкспериментируете, то заметите, что с `gofat` время сборки значительно увеличивается. Дело в том, что мы запускаем сборку в режиме `-a`, при котором всё пересобирается заново.
Теперь мы знаем, сколько места занимает каждая зависимость. Закатаем рукава, проанализируем и предпримем действия.
```
1.8M net/http.a
```
Всё, что связано с обработкой HTTP, тянет на 1,8 Мб. Пожалуй, можно это выкинуть. Откажемся от `expvar`, вместо этого будем периодически сбрасывать в лог-файл критически важные параметры и информацию о состоянии программы. Если это делать часто, то всё будет хорошо.
**Обновление:** С выходом Go 1.8 net/http стал весить 2,2 Мб.
```
788K gopkg.in/alecthomas/kingpin.v2.a
388K github.com/alecthomas/template.a
```
А это большой сюрприз: около 1 Мб занимает весьма удобная POSIX-фича для парсинга флагов. Можно от неё отказаться и использовать пакет из стандартной библиотеки, или даже вообще покончить с флагами и считывать конфигурацию из переменных окружения (а это тоже займёт какой-то объём).
`Newrelic` добавляет ещё 1,3 Мб, так что его тоже можно отбросить:
```
668K github.com/newrelic/go-agent.a
624K github.com/newrelic/go-agent/internal.a
```
`Zap тоже выкинем. Воспользуемся стандартным пакетом для логирования:
392K go.uber.org/zap/zapcore.a
`Otto`, будучи встраиваемым JS-движком, весит немало:
```
2.2M github.com/robertkrimen/otto.a
312K github.com/robertkrimen/otto/parser.a
172K github.com/robertkrimen/otto/ast.a
```
В то же время `logrus` занимает мало места для такой многофункциональной библиотеки журналирования:
```
128K github.com/Sirupsen/logrus.a
```
Можно оставить.
### Заключение
Мы нашли способ вычислить размеры зависимостей в Go и сэкономили около 7 Мб. И решили, что не будем использовать определённые зависимости, а вместо них возьмем аналоги из стандартной библиотеки Go.
Более того, скажу, что, если сильно постараться и поэкспериментировать с набором зависимостей, то мы можем ужать наш двоичный файл с изначальных 12 Мб до 1,2 Мб.
Заниматься этим не обязательно, потому что зависимости в Go и так невелики по сравнению с другими платформами. Но вам обязательно нужно иметь под рукой инструменты, которые помогут лучше понимать то, что вы создаёте. И если вы разрабатываете ПО для окружений с весьма ограниченными доступными ресурсами, то одним из таких инструментов может быть `gofat`.
P.S.: если хотите поэкспериментировать еще, вот референсный репозиторий: <https://github.com/jondot/fattyproject>. | https://habr.com/ru/post/322880/ | null | ru | null |
# Автоматизация согласования сетевых доступов
Предыстория
-----------
Мы против умолчательного открытия доступов из неопределенных источников, поэтому если кто-то получает новую сеть либо сервер, ему придется открыть все необходимые сетевые доступы, по умолчанию обычно никакие сетевые доступы не выдаются для создаваемых сетей. В первые же дни работы я понял, что не смогу достаточно быстро и корректно согласовывать десятки заявок в день вида:
Пример заявки произвольного видаПоэтому я поменял все что можно и теперь 17% доступов в среднем согласовывает бот, все заявки на сетевой доступ проходят этап согласования с безопасностью, а сами заявки на сетевой доступ выглядят так:
Пример заявки на открытие сетевого доступаВот как подобный доступ был бы согласован:
Пример работы ботаБот
---
Если не человек выполняет согласование, значит согласование выполняет программа.
Чтобы бот мог согласовывать максимально без ошибок, единственным выходом является написание для него строгих правил что можно, а что нет, никакой магии в виде искусственного интеллекта, по крайней мере у нас на данном этапе это так.
Так как какие же правила можно написать для бота?
Политика сетевой безопасности
-----------------------------
Я пришел к выводу, что нельзя просто писать правила которые придут в голову, поэтому я решил опираться на бумагу. Допустим бот отклонит, тогда если бот укажет ссылку на бумагу являющуюся основанием для отказа, то у инициатора согласования не останется шанса оспорить согласование в случае явно противоправного доступа, исключения конечно же из правил бывают. Такой бумагой стала политика сетевой безопасности.
Давайте рассмотрим пример нескольких положений такой политики сетевой безопасности:
Разрешенные межсервисные взаимодействия (вырезка из политики сетевой безопасности)Неправда ли неплохо? Мне кажется достаточно красивый способ написания политики сетевой безопасности. На картинке прямоугольник это граница VLAN.
Давайте рассмотрим несколько стрелок на изображении выше:
* доступ (1) из DMZ в DMZ другого VLAN (другой информационной системы) разрешен так как стрелка нарисована;
* доступ из DMZ в DB запрещен так как стрелка не нарисована;
* доступ из DMZ в APP разрешен так как стрелка нарисована;
* доступ (3) из APP в DB разрешен так как есть стрелка;
* доступ между APP и DMZ разрешен по любым портам так как есть стрелка;
* доступ из DB в DMZ запрещен так как стрелки нет;
* доступ из DB в APP запрещен так как стрелки нет;
* доступ (2) от пользователей к DMZ и APP серверам разрешен так как стрелка нарисована.
Теперь любой архитектор ПО, системный аналитик, прикладной администратор, системный администратор и другие знают как разрабатывать информационные системы в плане разрешенных сетевых взаимодействий.
Сетевой доступ
--------------
Напомним как выглядит правило на межсетевом экране уровня сети:
| | | | |
| --- | --- | --- | --- |
| Источник (SRC\_IP) | Получатель (DST\_IP) | Порт | Транспортный протокол |
| | | | |
Поскольку в источнике может быть объект состоящий из нескольких IP адресов, поэтому дадим нашим пользователям возможность открывать сетевые доступы как от точечного IP адреса либо сети, так и от группы в которой может быть любой набор IP адресов либо сетей. Ну и получателям может быть аналогичный набор параметров. Получаем таблицу которую необходимо видеть в согласованиях:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| SRC\_IP | SRC\_GRP | DST\_IP | DST\_GRP | Порт | Протокол |
| | | | | | |
Дополним сетевой доступ другими техническим полями и получим следующее:
Пример сетевого доступаМожно кликнуть на IP, на сеть и посмотреть связные доступы и другие параметры. Пример клика на IP:
Пример карточки IP адресаРеестр информационных систем
----------------------------
Компания должна вести реестр информационных активов, ИТ-активов, бизнес активов. В данном случае примем что информационная система о которой шла речь ранее и является бизнес активом. Соответственно информационные системы должны иметь набор ролей, одна из ролей должна отвечать за согласование сетевых доступов.
Таким образом, наш бот при согласовании сетевых доступов сможет ориентироваться дополнительно при согласовании и на наименования информационной системы. Здесь хочется отметить что если делаем исключение из сетевой политики, то его можно применить только для конкретной информационной системы.
Также каждый доступ мы автоматически сможем согласовывать с ответственными тех систем, IP адреса которых фигурируют в сетевых доступах, это важно - никто не получит сетевой доступ к твоему серверу если ты этого не желаешь, и наоборот - никто не откроет доступ с твоего сервера в неизвестном тебе направлении.
Реестр сетей
------------
Компания должна вести реестр сетей и соответствие каждой сети конкретной информационной системе. Про реестр я уже упоминал в [статье ранее](https://habr.com/ru/post/548310/), вот пример реестра сетей из него:
Пример реестра сетейТо есть не должно быть так, что существует сеть и она не принадлежит никому явно, что за нее никто не отвечает, а доступы, в которых фигурируют ее IP адреса, никто не согласовывает.
Правила бота
------------
На основе выше изложенного мы можем формировать правила автоматического согласования сетевых доступов на основе следующего:
1. IP адреса;
2. группы IP адресов;
3. система;
4. порт;
5. протокол;
6. действие: согласовать доступ, отклонить.
При написании правил воспользуемся форматом YAML и опишем для примера следующие (выделенные ранее цифрами 1,2,3) разрешенные сетевые доступы из политики сетевой безопасности.
Правило номер 1 (разрешен доступ из DMZ любой системы в DMZ любой другой системы):
```
PROM_allow:
comment: Разрешено в чужую DMZ по HTTPS по TCP
src:
purpose:
zones:
- PROM_DMZ # с сервера из любой DMZ сети любой системы
dst:
purpose:
zones:
- PROM_DMZ # можно к серверу в любой DMZ сети любой системы
ports: [443] # по порту 443
protocols: [TCP] # транспорт TCP
action: [allow] # согласовать доступ
```
Правило номер: 2 (разрешено пользователям системы обращаться к серверам своей системы):
```
USERS_allow:
comment: Согласовывать доступ своим пользователям
src:
purpose:
zones:
- USERS # из сетей помеченных как пользовательские
dst:
purpose:
zones:
- DMZ
- APP
ports: [any] # по всем портам
busines: same # вот этот параметр и отвечает за самое интересное:
# доступ разрешен только в свои DMZ сети
protocols: [TCP]
action: [allow]
```
Как вы понимаете любой доступ пользователей своей системы будет согласован к серверам своей системы так как указан порт "any", соответственно мы должны анализировать журнал согласованных доступов на предмет злоупотреблений.
Правило номер 3 (разрешен доступ в сегмент баз данных своей системы по портам SQL-net):
```
DB_allow:
comment: Разрешено в свою DB по SQL-net
src:
purpose:
zones:
- APP # с сервера из любой APP сети
dst:
purpose:
zones:
- DB # можно к серверу в любой DMZ сети
business: same # только со своего же сервера
ports: [1520-1525,5432] # только стандартные доступы к базе данных
protocols: [TCP] # транспорт TCP
action: [allow] # согласовать доступ
```
А теперь давайте напишем защитное правило запрещающее опасные доступы:
```
DB_BLOCK:
comment: Доступ из DB запрещен куда-либо
src:
purpose:
zones: [DB] # из сегмента баз данных
dst:
purpose:
groups: [APP,DMZ] # в сегменты приложений и демилитаризованную зону
ports: [any]
protocols: [any]
action: [deny] # действие: отклонить доступ при согласовании
```
Возвращаясь к первой заявке с которой началась статья получается такое правило:
```
ANY_to_KMS_allow:
comment: Разрешено до сервера активации лицензий KMS Microsoft
src:
purpose:
zones: [any] # конечно же реализована защита что any
dst: # это внутренние сети, а не внешние
purpose:
hosts: [192.168.2.111]
ports: [1688] # Разрешаем только порты KMS
protocols: [TCP]
action: [allow]
```
Приоритет правил
----------------
Естественно как правила межсетевого экранирования применяются к сетевым пакетам в последовательном порядке так и правила согласования этих правил писать необходимо в определенном порядке:
По умолчанию разрешающие правила (VIP правила разрешающие), например:
```
ANY_to_SIEM_0.3:
comment: Разрешено из ANY до серверов безопасников для журналирования по Syslog для целей SOC
src:
purpose:
zones: [any]
dst:
purpose:
hosts: [192.168.3.33]
ports: [514] # порт syslog
protocols: [UDP/TCP] #TCP на случай если строка лога большая
action: [allow]
```
По умолчанию запрещающие правила (100% запрещающие), например:
```
DB_Block:
comment: Запрещено из базы в интернет напрямую
src:
purpose:
zones:
- DB
dst:
purpose:
zones: INTERNET # кастомная своя зона
ports: [any] # запрещено по всем портам
protocols: [any] # запрещено по всем протоколам
action: [deny] # от слова совсем
```
Остальные разрешающие правила в перемешку с запрещающими, например, те что рассмотрены выше в предыдущем разделе статьи.
Согласовать нельзя досогласовать
--------------------------------
Начиная отклонять доступы неизбежно наткнетесь на следующие недовольства:
1. безопасник надеется на бота, теперь совсем не заходит в систему согласования и не смотрит новые согласования;
2. доступ отклонили, но инициатор уговорил безопасника согласовать доступ в качестве исключения, однако, согласовать придется по маршруту заново с ответственными за систему заново и только потом с безопасником системы;
3. другие.
Мы начали делать так: если 80% доступов в согласовании бот сопоставил с разрешающим правилом, то 80% доступов согласовываем, а остальные либо неизвестные либо запрещенные отклоняет. Естественно было недовольство из разряда "доступ нормальный, но вы его отклонили, почему?".
Тогда мы решили и переработали систему следующим образом:
1. все доступы, что попали под разрешающие правила - мы согласовываем;
2. все доступы, что попали под запрещающие правила - мы отклоняем;
3. все доступы, что не попали ни под одно правило - переносим их в новое согласование, но уже на тот же этап согласования с безопасником, то есть отдаются на ручное согласование.
Как итог, периодически нужно изучать ежедневный отчет на случай согласования чего либо нехорошего.
Статистика
----------
Статистика согласования доступовКак видно успехи всего лишь ~ 17% из-за того, что бот поддерживает обработку только правил межсетевого экрана уровня сети и правил на прокси-сервере, а правила NAT, правила на межсетевого экрана уровня хоста, правила наполнения групп не поддерживаются. Есть к чему стремиться, но при этом все сетевые доступы попадают в поле безопасника. | https://habr.com/ru/post/571650/ | null | ru | null |
# Создаем датасет для распознавания счетчиков на Яндекс.Толоке
Как-то два года назад, случайно включив телевизор, я увидел интересный [сюжет](https://www.vesti.ru/doc.html?id=2921101) в программе "Вести". В нём рассказывали о том, что департамент информационных технологий Москвы создает нейросеть, которая будет считывать показания счетчиков воды по фотографиям. В сюжете телеведущий попросил горожан помочь проекту и прислать снимки своих счетчиков на портал mos.ru, чтобы на них обучить нейронную сеть.
Если Вы — департамент Москвы, то выпустить ролик на федеральном канале и попросить людей прислать изображения счетчиков — не очень большая проблема. Но что делать, если Вы — маленький стартап, и сделать рекламу на телеканале не можете? Как получить 50000 изображений счетчиков в таком случае? На помощь приходит Яндекс.Толока!
[Яндекс.Толока](https://habr.com/ru/company/yandex/blog/305956/) — краудсорсинговая платформа, на которой люди со всего мира выполняют несложные задания, получая за это деньги. Например, толокеры могут [находить](https://habr.com/ru/company/yandex/blog/427605/) пешеходов на изображении, [обучать](https://habr.com/ru/company/yandex/blog/430034/) голосовых помощников и многое [другое](https://rb.ru/longread/yandex-toloka/). При этом разместить задания на Толоке могут не только сотрудники Яндекса, но и любой желающий.
Постановка задачи
-----------------
Итак, мы хотим создать нейронную сеть, которая по фотографии будет определять показания счетчиков. С чего начать, какие данные нам нужны?
Посовещавшись с коллегами, мы приходим к выводу, что для создания MVP нам нужно 1000 изображений счетчиков. При этом для каждого счетчика мы хотим знать текущие показания, а также координаты окна с цифрами.
Если Вы еще никогда не работали с Толокой, то советую прочитать [статью](https://habr.com/ru/company/ods/blog/358574/), которую я писал год назад. Так как текущая статья будет технически более сложная, то некоторые моменты, подробно описанные в прошлой статье, я буду опускать.
**Благодарности**Прошлая статья стала ТОП-2 в рейтинге статей от сообщества [ODS](https://ods.ai/). Спасибо, что комментируете и ставите плюсы!)
Часть 1. Получение изображений
------------------------------
Что может быть проще? Всего лишь нужно попросить человека открыть приложение Яндекс.Толока на своем телефоне и сфотографировать свой счетчик. Если бы я не работал несколько лет с Толокой, то моя инструкция звучала бы так: *"Вам нужно сфотографировать свой счетчик воды (горячей либо холодной) и прислать нам изображение"*.
К сожалению, при такой постановке задачи хороший датасет собрать не получится. Все дело в том, что данное ТЗ люди могут интерпретировать по-разному, так как в инструкции нет четких критериев правильно выполненного задания. Толокеры могут прислать:
* размытые изображения;
* изображения, на которых не видно показаний;
* изображения с несколькими счетчиками.
В блоге Толоки есть отличный [туториал](https://yandex.ru/blog/toloka/toloka-instruction), посвященный написанию инструкций. Следуя ему, у меня получилась такая инструкция:
В качестве входных параметров мы передаем id задания, а на выходе получаем файл img, в котором будет находиться изображение счетчика.
Интерфейс задания пишется всего в 2 строки!
При создании пула указываем время на выполнение задания, отложенную приемку и цену за задание 0.01$.
А чтобы люди по несколько раз не выполняли задание и не отправляли одинаковые фотографии, в блоке контроля качества запрещаем повторное выполнение задания.
Укажем, что нам нужны русскоговорящие пользователи, которые выполняют задание через мобильное приложение Яндекс.Толока.
Загружаем задания в пул.
Запускаем пул, радуемся и ждем ответов пользователей! Вот так выглядит наше задание со стороны толокера:
Часть 2. Приемка заданий
------------------------
Подождав пару часов, видим, что толокеры выполнили задание. Так как при отложенной приемке награждение выплачивается исполнителю не сразу, а замораживается на балансе у заказчика, то теперь мы должны проверить все присланные изображения. У добросовестных исполнителей принять задания, а исполнителям, которые прислали неподходящие под критерии изображения, отказать и написать причину отказа.
Если бы изображений было не очень много, то мы бы могли сами просмотреть и проверить все присланные изображения. Но мы же хотим получить тысячи и десятки тысяч изображений! Проверка такого объема заданий потребует существенного количества времени. Плюс данный процесс требует непосредственно нашего участия.
На помощь снова приходит Толока! Мы можем создать новое задание "Проверка изображений счетчиков" и просить других толокеров отвечать, подходит ли изображение под наши критерии или нет. Настроив один раз процесс, мы получим полностью автоматический сбор и валидацию данных! При этом сбор данных легко масштабируется, и, если нам нужно будет увеличить размер датасета в несколько раз, достаточно лишь нажать пару кнопок.
Звучит потрясающе и грандиозно, не правда ли?
Тогда пора претворять задумку в жизнь!
Первым делом определим критерии, по которым будем считать фотографию хорошей.
Фотография хорошая, если:
* На фотографии ровно один счетчик холодной либо горячей воды;
* Показания на счетчике отчетливо видны.
В иных случаях фотографию считаем плохой.
С критериями разобрались, теперь пишем инструкцию!
В качестве входных параметров передаем ссылку на изображение. На выходе будет два флага:
* check\_count — ответ на первый вопрос
* check\_quality — ответ на второй вопрос
В переменную value будут записываться показания счетчика.
Интерфейс этого задания занимает уже 14 строк.
Для повышения точности одно изображение будут проверять независимо друг от друга 5 толокеров, для этого поставим перекрытие 5. После этого мы будем смотреть как ответили 5 людей и считать, что верный вариант ответа тот, за который проголосовало большинство. Данное задание уже не будет иметь отложенную приемку.
Допустим к заданию 50% лучших исполнителей.
В заданиях без отложенной приемки выплату получают все, вне зависимости от того, выполняют они задание правильно или нет. Но мы же хотим, чтобы толокеры внимательно читали инструкцию, старались и выполняли задание верно. Каким образом можно этого добиться?
В Толоке есть два основных инструмента, которые позволяют поддерживать хорошее качество:
1. ***Обучение.*** Перед выполнением основного задания мы можем попросить толокеров пройти обучение. В пуле обучения людям даются задания, на которые мы заранее знаем правильные ответы. В случае, если человек ответил неправильно, ему показывается ошибка и объясняется, как нужно было ответить. После прохождения обучения мы видим с каким процентом заданий исполнитель справился и можем допустить к основному пулу заданий только тех, кто справился хорошо.
2. ***Блоки контроля качества.*** Может быть такая ситуация, что пул обучения исполнитель прошел на «отлично», мы его допустили к заданию, но через пять минут он ушел играть в футбол, оставив за компьютером своего трехлетнего брата. К счастью, в Толоке есть множество методов, которые позволяют следить за тем, как люди выполняют задания.
С пулом обучения все просто: достаточно добавить задания, разметить их в интерфейсе Яндекс.Толоки и указать порог прохождения, начиная с которого мы допускаем людей к основному заданию.
С блоками контроля качества все интереснее: их довольно много, но я остановлюсь на двух самых важных.
**Мнение большинства**
Мы даем задание 5-и независимым людям. И если четыре человека на вопрос отвечают "Да", а пятый отвечает "Нет", то пятый, вероятно, ошибся. Таким образом, мы можем смотреть, как ответы человека согласуются с ответами других людей, и блокировать пользователей, которые отвечают не так, как остальные.
**Контрольные задания**
Мы можем подмешивать в пул задания, на которые заранее знаем верный ответ. При этом задания контроля качества выглядят так же, как и обычные задания. На основе того, правильно ли человек отвечает на контрольные задания, мы можем экстраполировать и предполагать, правильно или нет он решает все остальные задачи, для которых мы ответов не знаем. Если человек отвечает плохо на контрольные задания, мы можем его заблокировать, а если хорошо, то выдать бонус.
Ура, задание создано! Вот так выглядит интерфейс со стороны исполнителя:
Часть 3. Объединение заданий
----------------------------
Отлично, задания готовы! Но возникает вопрос, как соединить задания между собой? Как сделать так, чтобы после первого задания запускалось второе?
Конечно, можно пошаманить с бубном и сделать это вручную через интерфейс Толоки, но есть способ проще и быстрее! В Яндекс.Толоке есть [API](https://yandex.ru/dev/toloka/doc/concepts/quickstart-docpage/), воспользуемся им и напишем скрипт на питоне!
**Я знаю, многие из вас не любят читать код, поэтому спрятал его под спойлер**
```
import pandas as pd
import numpy as np
import requests
import boto3
# Данная функция скачивает изображение из первого задания, загружает
# в Yandex Object Storage и возвращает ссылку на изображение
def load_image_on_yandex_storage(img_id):
session = boto3.session.Session(
region_name="us-east-1", aws_secret_access_key="", aws_access_key_id=""
)
s3 = session.client(
service_name="s3", endpoint_url="https://storage.yandexcloud.net"
)
file = requests.get(
url=URL_API + "attachments/%s/download" % img_id, headers=HEADERS
)
s3.put_object(Bucket="schetchiki", Key=img_id, Body=file.content)
return "https://storage.yandexcloud.net/schetchiki/%s" % img_id
# Указываем ключ к API, а также ID пула первого и второго задания
TOLOKA_OAUTH_TOKEN = ""
POOL_ID_FIRST = 7156932
POOL_ID_SECOND = 7006945
URL_API = "https://toloka.yandex.ru/api/v1/"
HEADERS = {
"Authorization": "OAuth %s" % TOLOKA_OAUTH_TOKEN,
"Content-Type": "application/JSON",
}
# Получаем список всех заданий из первого пула, которые ждут проверки
url_assignments = (
URL_API + "assignments/?status=SUBMITTED&limit=10000&pool_id=%s" % POOL_ID_FIRST
)
submitted_tasks = requests.get(url_assignments, headers=HEADERS).json()["items"]
# Заводим словари, чтобы помнить, как соотносятся id задания из первого пула
# и id задания из второго пула
url_to_first_id_map = {}
first_id_to_second_id_map = {}
json_second_task = []
# Для каждого задания из первого пула:
# * Запоминаем его id
# * Загружаем картинку в Yandex Object Storage
# * Оборачиваем параметры в json для второго задания
for task in submitted_tasks:
first_task_id = task["id"]
img_id = task["solutions"][0]["output_values"]["img"]
url_img = load_image_on_yandex_storage(img_id)
url_to_first_id_map[url_img] = first_task_id
json_second_task.append(
{"input_values": {"image": url_img}, "pool_id": POOL_ID_SECOND, "overlap": 5}
)
# Загружаем задания во второй пул
# "Не баг, а фича": добавлять через API задания в пул можно только тогда,
# когда сам пул создан через API
second_tasks_request = requests.post(
url=URL_API + "tasks?open_pool=true", headers=HEADERS, json=json_second_task
).json()
# В ответ нам выдали id вторых заданий.
# По ним мы сможем запросить ответы после завершения задания, поэтому запомним их
for second_task in second_tasks_request["items"].values():
second_task_id = second_task["id"]
img_url = second_task["input_values"]["image"]
first_task_id = url_to_first_id_map[img_url]
first_id_to_second_id_map[first_task_id] = second_task_id
# Эту функцию я писал ночью, утром я сам не смог понять, как она работает
# Она возращает ответы пользователей для конкретного поля
def unknown_fun(k):
return list(map(lambda t: t['solutions'][np.where(np.array(list(map(lambda x: x['id'], t['tasks']))) == second_task_id)[0][0]]['output_values'][k], second_task))
# Меняем keys и values местами
first_id_to_url_map = dict((v, k) for k, v in url_to_first_id_map.items())
db = []
# Выполняем этот код только после того, как задание 2 будет выполнено
for first_task_id in first_id_to_second_id_map:
# Для каждого проверяемого задания 1
second_task_id = first_id_to_second_id_map[first_task_id]
# Получаем результаты задания 2
url_assignments = (
URL_API + "assignments/?status=ACCEPTED&task_id=%s" % second_task_id
)
second_task = requests.get(url_assignments, headers=HEADERS).json()["items"]
# Получаем вектор ответов пользователей
value_list = unknown_fun("value")
check_count_list = unknown_fun("check_count")
check_quality_list = unknown_fun("check_quality")
# Если больше двух людей ответили на первый вопрос «нет»,
# то значит счетчика на изображении нет,
# либо на изображении несколько счетчиков. Отклоняем задание
if np.sum(check_count_list) < 3:
json_check = {
"status": "REJECTED",
"public_comment": "На фотографии должен быть ровно один счетчик холодной либо горячей воды",
}
# Если больше двух людей сказали, что показания не видны, отклоняем задание
elif np.sum(check_quality_list) < 3:
json_check = {
"status": "REJECTED",
"public_comment": "Показания на счетчике отчетливо не видны",
}
# В остальных случаях принимаем задание
else:
json_check = {
"status": "ACCEPTED",
"public_comment": "Изображение счетчика принято",
}
url = URL_API + "assignments/%s" % first_task_id
result_patch_request = requests.patch(url, headers=HEADERS, json=json_check)
# Найдем для принятых заданий самый частый ответ
(values, counts) = np.unique(value_list, return_counts=True)
ind = np.argmax(counts)
if counts[ind] > 3 and json_check["status"] == "ACCEPTED":
print(
"Показания счетчика: %s. Его подтвердили %d из 5 пользователей"
% (values[ind], counts[ind])
)
# Чтобы ничего не забыть и не потерять, записываем в массив
db.append(
{
"first_task_id": first_task_id,
"second_task_id": second_task_id,
"url_img": first_id_to_url_map[first_task_id],
"check_count_list": check_count_list,
"check_quality_list": check_quality_list,
"value_list": value_list,
}
)
# Сохраняем получившийся результат
pd.DataFrame(db).to_csv("result.csv")
```
Запускаем код и вот долгожданный результат: [датасет](https://yadi.sk/d/G5QqvHOj1u3SrA) из 871 изображений счетчиков готов.
Цена
----
Давайте оценим экономическую составляющую проекта.
За присланное изображение в первом задании мы предлагаем 0.01$.
К сожалению, если мы платим исполнителю 0.01$, нам придется отдать 0.018$.
Как это получается?
* Комиссия Яндекса равна min(0.005,20%). Для задания ценой 0.01$ комиссия будет 50%;
* НДС составляет 20%.
За проверку 10 изображений счетчиков мы платим 0.01$. При этом одно изображение проверяют 5 раз независимые люди. Итого, за проверку одного изображения мы отдаем: (0.01 x 5 / 10) x 1.2 x 1.5 = 0.009$.
Из 1000 присланных заданий было принято 871 изображение, а 129 было отклонено. Значит, чтобы получить датасет из 871 изображений, мы заплатили:
0.018$ x 871 + 0.009$ x 1000 = 25$ и для получения датасета в размере 50000 изображений понадобится 92000 руб. Это определенно дешевле, чем заказывать рекламу на федеральном канале!
Но и данную цифру реально уменьшить в несколько раз. Можно:
* Предлагать в первом задании делать не одно фото, а несколько. При этом поднять цену, тогда комиссия Яндекса будет не 50%, а 20%;
* Использовать динамическое перекрытие во втором задании. Если 4 из 5 людей дали одинаковый ответ, то уже не имеет смысла выдавать задание пятому человеку;
* Работать с Толокой как иностранное юридическое лицо. В этом случае вы не платите НДС.
Так как материала оказалось уж очень много, то мною было принято решение разбить статью на две части. В следующий раз мы поговорим с вами о том, как с помощью Толоки выделять объекты на изображениях и создавать датасеты для задач в области Computer Vision. А чтобы не пропустить, подписывайтесь и ставьте лайки!
**P.S.**
После прочтения статьи вам может показаться, что это скрытая реклама Яндекс.Толоки, но нет, это не так. Яндекс мне ничего не платил, да и, скорее всего, не заплатит. Я лишь хотел показать на выдуманном, но актуальном и интересном примере, как с помощью данного сервиса можно собрать быстро и недорого датасет под любую задачу, будь это задача распознавания котиков или обучения беспилотных автомобилей. | https://habr.com/ru/post/469633/ | null | ru | null |
# Трепещущий Kivy. Обзор возможностей фреймворка Kivy и библиотеки KivyMD
[Kivy](https://github.com/kivy/kivy) и [Flutter](https://github.com/flutter/flutter) — два фреймворка с открытым исходным кодом для кроссплатформенной разработки.
### **Flutter:**
* создан компанией Google и выпущенный в 2017 году;
* в качестве языка программирования использует Dart;
* не использует нативные компоненты, рисуя весь интерфейс внутри собственного графического движка;
### **Kivy:**
* создан сообществом Kivy в 2010 году;
* в качестве языка программирования использует Python и собственный декларативный язык для разметки UI элементов — KV Language;
* не использует нативные компоненты, рисуя весь интерфейс с помощью OpenGL ES 2.0 и SDL2;
Недавно на просторах Ютуба наткнулся на видео демонстрацию Flutter приложения — [Facebook Desktop Redesign built with Flutter Desktop](https://www.youtube.com/watch?v=Yix7Z9kFGQw&list=WL&index=2). Отличное демонстрационное приложение в стиле material design! И поскольку я один из разработчиков библиотеки [KivyMD](https://github.com/kivymd/KivyMD) (набор material компонентов для фреймворка Kivy) мне стало интересно, насколько просто будет сделать такой же красивый интерфейс. К счастью автор оставил ссылку на [репозиторий проекта](https://github.com/e200/my-flutter-challenges/tree/master/facebook_desktop).
Как вы думаете, какое приложение на вышеприведенных скриншотах написано с использованием Flutter и какое с помощью Kivy? Ответить сходу трудно, поскольку ярко выраженных отличий нет. Единственное, что сразу бросается в глаза (нижний скриншот) — в Kivy все еще нет нормального сглаживания. И это грустно, но не критично. Сравнивать мы будем отдельные элементы приложения и их исходный код на Dart (Flutter) и Python/KV language (Kivy).
Посмотрим теперь как выглядят компоненты изнутри…
### **StoryCard**
### **Kivy**
Разметка карточки на языке KV-Language:
Базовый Python класс:
```
from kivy.properties import StringProperty
from kivymd.uix.relativelayout import MDRelativeLayout
class StoryCard(MDRelativeLayout):
avatar = StringProperty()
story = StringProperty()
name = StringProperty()
def on_parent(self, *args):
if not self.avatar:
self.remove_widget(self.ids.avatar)
```
### **Flutter:**
```
import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
class Story extends StatefulWidget {
final String name;
final String avatar;
final String story;
const Story({
Key key,
this.name,
this.avatar,
this.story,
}) : super(key: key);
@override
_StoryState createState() => _StoryState();
}
class _StoryState extends State {
@override
Widget build(BuildContext context) {
return Container(
width: 150,
margin: const EdgeInsets.only(top: 30),
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(30),
boxShadow: [
BoxShadow(
color: Colors.black.withOpacity(0.3),
blurRadius: 20,
offset: Offset(0, 10),
),
],
),
child: Stack(
overflow: Overflow.visible,
fit: StackFit.expand,
children: [
ClipRRect(
borderRadius: BorderRadius.circular(30),
child: Image.network(
widget.story,
fit: BoxFit.cover,
),
),
if (widget.avatar != null)
Positioned.fill(
top: -30,
child: Align(
alignment: Alignment.topCenter,
child: Container(
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(30),
boxShadow: [
BoxShadow(
color: Colors.black.withOpacity(0.4),
blurRadius: 5,
offset: Offset(0, 3),
),
],
),
child: ClipRRect(
borderRadius: BorderRadius.circular(30),
child: Image.network(
widget.avatar,
fit: BoxFit.cover,
width: 60,
height: 60,
),
),
),
),
),
if (widget.avatar != null)
Positioned.fill(
child: Align(
alignment: Alignment.bottomCenter,
child: Row(
children: [
Expanded(
child: Container(
padding: const EdgeInsets.all(15),
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(30),
gradient: LinearGradient(
begin: Alignment.topCenter,
end: Alignment.bottomCenter,
colors: [
Colors.transparent,
Colors.black,
],
),
),
child: widget.name != null ? Text(
widget.name,
textAlign: TextAlign.center,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
color: Colors.white,
fontWeight: FontWeight.bold,
),
) : SizedBox(),
),
),
],
),
),
),
],
),
);
}
}
```
Как видим, код на Python и KV-Language получается вдвое короче. Исходный код проекта на Python/Kivy, который рассматривается в этой статье, имеет общий размер 31 килобайт. 3 килобайта из этого объема приходится на Python код, остальное — KV-Language. Исходный код на Flutter — 54 килобайт. Впрочем, здесь удивляться, кажется, нечему — Python один их самый лаконичных языков программирования в мире.
Мы не будем спорить о том, что лучше: описывать UI при помощи DSL языков или прямо в коде. В Kivy, кстати, также можно строить виджеты Python кодом, но это не очень хорошее решение.
### **TopBar**
**Flutter:**
**Kivy:**
Реализация этого бара, включая анимацию, на Python/Kivy заняла всего 88 строчек кода. На Dart/Flutter — 325 строк и 9 килобайт на диске. Посмотрим, что представляет из себя этот виджет:
Лого, три таба, аватар, три таба и один таб — кнопка настроек. Реализация таба с анимированным индикатором:
Анимация индикатора и смена типа курсора мыши реализована в Python файле в одноименном с правилом разметки классе:
```
from kivy.animation import Animation
from kivy.properties import StringProperty, BooleanProperty
from kivy.core.window import Window
from kivymd.uix.boxlayout import MDBoxLayout
from kivymd.uix.behaviors import FocusBehavior
class Tab(FocusBehavior, MDBoxLayout):
icon = StringProperty()
active = BooleanProperty(False)
def on_enter(self):
Window.set_system_cursor("hand")
def on_leave(self):
Window.set_system_cursor("arrow")
def on_active(self, instance, value):
Animation(
opacity=value,
width=self.width if value else 0,
d=0.25,
t="in_sine" if value else "out_sine",
).start(self.ids.separator)
```
Мы просто анимируем ширину и opacity индикатора в зависимости от состояния кнопки (active). Состояние кнопки устанавливается в главном классе экрана приложения:
```
class FacebookDesktop(ThemableBehavior, MDScreen):
def set_active_tab(self, instance_tab):
for widget in self.ids.tab_box.children:
if issubclass(widget.__class__, MDBoxLayout):
if widget == instance_tab:
widget.active = True
else:
widget.active = False
```
**Подробнее об анимации а Kivy:**
[Материальный дизайн. Создание анимаций в Kivy](https://habr.com/ru/post/528154/)
[Разработка мобильных приложений на Python. Создание анимаций в Kivy. Part 2](https://habr.com/ru/post/529364/)
**Реализация на Dart/Flutter.**
Поскольку кода очень много, я спрятал все под спойлеры:
**app\_logo.dart**
```
import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
class AppLogo extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Container(
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(10),
boxShadow: [
BoxShadow(
color: Colors.blue.withOpacity(.6),
blurRadius: 5,
spreadRadius: 1,
),
],
),
child: ClipRRect(
borderRadius: BorderRadius.circular(10),
child: Image.asset(
'assets/images/facebook_logo.jpg',
width: 30,
height: 30,
),
),
);
}
}
```
**avatar.dart**
```
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/widgets.dart';
class TopBarAvatar extends StatefulWidget {
@override
_TopBarAvatarState createState() => _TopBarAvatarState();
}
class _TopBarAvatarState extends State
with SingleTickerProviderStateMixin {
Animation \_animation;
AnimationController \_animationController;
@override
void initState() {
\_animationController = AnimationController(
vsync: this,
duration: Duration(milliseconds: 150),
);
\_animation = ColorTween(
begin: Colors.grey.withOpacity(.4),
end: Colors.blue.withOpacity(.6),
).animate(\_animationController);
\_animation.addListener(() {
setState(() {});
});
super.initState();
}
@override
Widget build(BuildContext context) {
return MouseRegion(
onHover: (event) {
setState(() {
\_animationController.forward();
});
},
onExit: (event) {
setState(() {
\_animationController.reverse();
});
},
cursor: SystemMouseCursors.click,
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 15),
child: Container(
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(15),
boxShadow: [
BoxShadow(
color: \_animation.value,
blurRadius: 10,
spreadRadius: 0,
),
],
),
child: ClipRRect(
borderRadius: BorderRadius.circular(15),
child: Image.asset(
'assets/images/avatar.jpg',
width: 50,
height: 50,
),
),
),
),
);
}
}
```
**button.dart**
```
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/widgets.dart';
class TopBarButton extends StatefulWidget {
final IconData icon;
final bool isActive;
final Function onTap;
const TopBarButton({
Key key,
this.icon,
this.isActive = false,
this.onTap,
}) : super(key: key);
@override
_TopBarButtonState createState() => _TopBarButtonState();
}
class _TopBarButtonState extends State
with SingleTickerProviderStateMixin {
Animation \_animation;
AnimationController \_animationController;
@override
void initState() {
\_animationController = AnimationController(
vsync: this,
duration: Duration(milliseconds: 150),
);
\_animation = ColorTween(
begin: Colors.grey.withOpacity(.6),
end: Colors.blue.withOpacity(.6),
).animate(\_animationController);
\_animation.addListener(() {
setState(() {});
});
super.initState();
}
@override
void didUpdateWidget(TopBarButton oldWidget) {
if (widget.isActive) {
\_animationController.forward();
} else {
\_animationController.reverse();
}
super.didUpdateWidget(oldWidget);
}
@override
Widget build(BuildContext context) {
return GestureDetector(
onTap: widget.onTap,
child: MouseRegion(
cursor: SystemMouseCursors.click,
child: Container(
height: 80,
child: Stack(
alignment: Alignment.center,
children: [
Padding(
padding: const EdgeInsets.symmetric(horizontal: 30),
child: Icon(
widget.icon,
color: \_animation.value,
),
),
Positioned(
bottom: -1,
child: Align(
alignment: Alignment.bottomCenter,
child: AnimatedContainer(
duration: Duration(milliseconds: 50),
curve: Curves.easeInOut,
decoration: BoxDecoration(
color: \_animation.value,
borderRadius: BorderRadius.circular(5),
boxShadow: [
BoxShadow(
color: \_animation.value,
blurRadius: 5,
offset: Offset(0, 2),
),
],
),
width: widget.isActive ? 50 : 0,
height: 4,
),
),
),
],
),
),
),
);
}
@override
void dispose() {
\_animationController.dispose();
super.dispose();
}
}
```
**widget.dart**
```
import 'package:facebook_desktop/screens/home/components/top_bar/app_logo.dart';
import 'package:facebook_desktop/screens/home/components/top_bar/avatar.dart';
import 'package:facebook_desktop/screens/home/components/top_bar/button.dart';
import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_feather_icons/flutter_feather_icons.dart';
class TopBar extends StatefulWidget {
@override
_TopBarState createState() => _TopBarState();
}
class _TopBarState extends State {
int \_selectedPage = 0;
@override
Widget build(BuildContext context) {
return Container(
color: Colors.white,
padding: const EdgeInsets.symmetric(
horizontal: 30,
),
child: Row(
children: [
Expanded(
flex: 1,
child: Align(
alignment: Alignment.centerLeft,
child: AppLogo(),
),
),
Expanded(
flex: 6,
child: Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
TopBarButton(
icon: FeatherIcons.home,
isActive: \_selectedPage == 0,
onTap: () {
setState(() {
\_selectedPage = 0;
});
},
),
TopBarButton(
icon: FeatherIcons.youtube,
isActive: \_selectedPage == 1,
onTap: () {
setState(() {
\_selectedPage = 1;
});
},
),
TopBarButton(
icon: FeatherIcons.grid,
isActive: \_selectedPage == 2,
onTap: () {
setState(() {
\_selectedPage = 2;
});
},
),
TopBarAvatar(),
TopBarButton(
icon: FeatherIcons.users,
isActive: \_selectedPage == 3,
onTap: () {
setState(() {
\_selectedPage = 3;
});
},
),
TopBarButton(
icon: FeatherIcons.zap,
isActive: \_selectedPage == 4,
onTap: () {
setState(() {
\_selectedPage = 4;
});
},
),
TopBarButton(
icon: FeatherIcons.smile,
isActive: \_selectedPage == 5,
onTap: () {
setState(() {
\_selectedPage = 5;
});
},
),
],
),
),
Expanded(
flex: 1,
child: Align(
alignment: Alignment.centerRight,
child: IconButton(
color: Colors.grey.withOpacity(.6),
icon: Icon(FeatherIcons.settings),
onPressed: () {},
),
),
),
],
),
);
}
}
```
**ChatCard** (Kivy, Flutter)
| | |
| --- | --- |
| | |
Анимация сдвига карточки происходит относительно родительского виджета (parent) при получении событий фокуса и анфокуса (on\_enter, on\_leave):
```
on_enter: Animation(x=root.parent.x + dp(12), d=0.4, t="out_cubic").start(root)
on_leave: Animation(x=root.parent.x + dp(24), d=0.4, t="out_cubic").start(root)
```
И базовый класс Python:
```
from kivy.core.window import Window
from kivy.properties import StringProperty
from FacebookDesktop.components.cards.fake_card import FakeCard
class ChatCard(FakeCard):
avatar = StringProperty()
text = StringProperty()
name = StringProperty()
def on_enter(self):
Window.set_system_cursor("hand")
def on_leave(self):
Window.set_system_cursor("arrow")
```
Реализация Python/Kivy — 60 строк кода, реализация Dart/Flutter — 182 строки кода.
**chat\_card.dart**
```
import 'package:ezanimation/ezanimation.dart';
import 'package:facebook_desktop/components/user_tile.dart';
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter_feather_icons/flutter_feather_icons.dart';
class ChatCard extends StatefulWidget {
final String image;
final String name;
final String message;
final EdgeInsets padding;
const ChatCard({
Key key,
this.image,
this.name,
this.message,
this.padding,
}) : super(key: key);
@override
_ChatCardState createState() => _ChatCardState();
}
class _ChatCardState extends State {
EzAnimation \_animation;
@override
void initState() {
\_animation = EzAnimation(
0.0,
-5.0,
Duration(milliseconds: 200),
curve: Curves.easeInOut,
context: context,
);
\_animation.addListener(() {
setState(() {});
});
super.initState();
}
@override
Widget build(BuildContext context) {
return Transform.translate(
offset: Offset(\_animation.value, 0),
child: MouseRegion(
cursor: SystemMouseCursors.click,
onEnter: (event) {
\_animation.start();
},
onExit: (event) {
\_animation.reverse();
},
child: Padding(
padding: widget.padding ?? const EdgeInsets.all(15),
child: Container(
width: 250,
padding: const EdgeInsets.all(15),
decoration: BoxDecoration(
color: Colors.white,
borderRadius: BorderRadius.circular(10),
boxShadow: [
BoxShadow(
color: Colors.black.withOpacity(.1),
blurRadius: 15,
offset: Offset(0, 8),
),
],
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
UserTile(
name: widget.name,
image: widget.image,
trailing: Icon(
FeatherIcons.messageSquare,
color: Colors.blue,
size: 14,
),
),
SizedBox(
height: 10,
),
Text(
widget.message,
style: TextStyle(color: Colors.grey, fontSize: 12),
maxLines: 3,
overflow: TextOverflow.ellipsis,
),
],
),
),
),
),
);
}
@override
void dispose() {
\_animation.dispose();
super.dispose();
}
}
```
**user\_tile.dart**
```
import 'package:facebook_desktop/screens/home/components/section.dart';
import 'package:flutter/material.dart';
class UserTile extends StatelessWidget {
final String name;
final String image;
final Widget trailing;
const UserTile({
Key key,
this.name,
this.image,
this.trailing,
}) : super(key: key);
@override
Widget build(BuildContext context) {
return Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Container(
margin: const EdgeInsets.only(right: 10),
decoration: BoxDecoration(
color: Colors.white,
borderRadius: BorderRadius.circular(10),
boxShadow: [
BoxShadow(
color: Colors.black.withOpacity(.1),
blurRadius: 5,
offset: Offset(0, 2),
),
],
),
child: ClipRRect(
borderRadius: BorderRadius.circular(5),
child: Image(
image: NetworkImage(
image,
),
fit: BoxFit.cover,
height: 50,
width: 50,
),
),
),
Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
SectionTitle(
title: name,
),
SizedBox(
height: 5,
),
Text(
'12 min ago',
style: TextStyle(color: Colors.grey),
),
],
),
if (trailing != null)
Expanded(
child: Align(
alignment: Alignment.topRight,
child: trailing
),
),
],
);
}
}
```
Но не все так просто, как кажется. В процессе я обнаружил, что в библиотеке KivyMD отсутствуют кнопки с типом «badge». В проекте на Flutter, кстати, тоже использовались кастомные кнопки. Поэтому для создания правой панели инструментов пришлось сделать такие кнопки самостоятельно.
Базовый Python класс:
```
from kivy.properties import StringProperty
from kivymd.uix.relativelayout import MDRelativeLayout
class BadgeButton(MDRelativeLayout):
icon = StringProperty()
text = StringProperty()
```
И уже создать левую панель инструментов:
Даже учитывая, что мне пришлось создавать кастомные кнопки типа «badge», код левой панели инструментов на Python/Kivy получился короче — 58 строк кода, реализация на Dart/Flutter — 97 строк.
**button.dart**
```
import 'package:flutter/material.dart';
class LeftBarButton extends StatelessWidget {
final IconData icon;
final String badge;
const LeftBarButton({
Key key,
this.icon,
this.badge,
}) : super(key: key);
@override
Widget build(BuildContext context) {
return GestureDetector(
child: Stack(
children: [
Container(
padding: const EdgeInsets.all(10),
child: Icon(
icon,
color: Colors.grey.withOpacity(.6),
),
),
if (badge != null)
Positioned(
top: 5,
right: 2,
child: Container(
padding: const EdgeInsets.all(3),
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(100),
color: Colors.blue,
),
child: Text(
badge,
style: TextStyle(
color: Colors.white,
fontSize: 10,
),
),
),
)
],
),
);
}
}
```
**widget.dart**
```
import 'package:facebook_desktop/screens/home/left_bar/button.dart';
import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_feather_icons/flutter_feather_icons.dart';
class LeftBar extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Container(
margin: const EdgeInsets.all(30),
padding: const EdgeInsets.all(5),
decoration: BoxDecoration(
color: Colors.white,
borderRadius: BorderRadius.circular(50),
boxShadow: [
BoxShadow(
color: Colors.grey.withOpacity(.1),
blurRadius: 2,
offset: Offset(0, 4),
)
],
),
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
LeftBarButton(
icon: FeatherIcons.mail,
badge: '10',
),
SizedBox(
height: 5,
),
LeftBarButton(
icon: FeatherIcons.search,
),
SizedBox(
height: 5,
),
LeftBarButton(
icon: FeatherIcons.bell,
badge: '20',
),
],
),
);
}
}
```
Безусловно я не умаляю достоинств фреймворка Flutter. Инструмент замечательный! Я всего лишь хотел показать Python разработчикам, что они могут делать те же самые вещи, что и во Flutter, но на их любимом языке программирования с помощью фреймворка Kivy и библиотеки KivyMD. Что касается мобильных платформ, то здесь стоит признать, что Flutter превосходит Kivy в скорости работы. Но это уже уже другая статья… Ссылка на репозиторий проекта [Facebook Desktop Redesign built with Flutter Desktop](https://github.com/HeaTTheatR/Articles/tree/main/FacebookDesktop) в реализации Python/Kivy/KivyMD. | https://habr.com/ru/post/546684/ | null | ru | null |
# Курс MIT «Безопасность компьютерных систем». Лекция 14: «SSL и HTTPS», часть 3
### Массачусетский Технологический институт. Курс лекций #6.858. «Безопасность компьютерных систем». Николай Зельдович, Джеймс Микенс. 2014 год
Computer Systems Security — это курс о разработке и внедрении защищенных компьютерных систем. Лекции охватывают модели угроз, атаки, которые ставят под угрозу безопасность, и методы обеспечения безопасности на основе последних научных работ. Темы включают в себя безопасность операционной системы (ОС), возможности, управление потоками информации, языковую безопасность, сетевые протоколы, аппаратную защиту и безопасность в веб-приложениях.
Лекция 1: «Вступление: модели угроз» [Часть 1](https://habr.com/company/ua-hosting/blog/354874/) / [Часть 2](https://habr.com/company/ua-hosting/blog/354894/) / [Часть 3](https://habr.com/company/ua-hosting/blog/354896/)
Лекция 2: «Контроль хакерских атак» [Часть 1](https://habr.com/company/ua-hosting/blog/414505/) / [Часть 2](https://habr.com/company/ua-hosting/blog/416047/) / [Часть 3](https://habr.com/company/ua-hosting/blog/416727/)
Лекция 3: «Переполнение буфера: эксплойты и защита» [Часть 1](https://habr.com/company/ua-hosting/blog/416839/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418093/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418099/)
Лекция 4: «Разделение привилегий» [Часть 1](https://habr.com/company/ua-hosting/blog/418195/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418197/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418211/)
Лекция 5: «Откуда берутся ошибки систем безопасности» [Часть 1](https://habr.com/company/ua-hosting/blog/418213/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418215/)
Лекция 6: «Возможности» [Часть 1](https://habr.com/company/ua-hosting/blog/418217/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418219/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418221/)
Лекция 7: «Песочница Native Client» [Часть 1](https://habr.com/company/ua-hosting/blog/418223/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418225/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418227/)
Лекция 8: «Модель сетевой безопасности» [Часть 1](https://habr.com/company/ua-hosting/blog/418229/) / [Часть 2](https://habr.com/company/ua-hosting/blog/423155/) / [Часть 3](https://habr.com/company/ua-hosting/blog/423423/)
Лекция 9: «Безопасность Web-приложений» [Часть 1](https://habr.com/company/ua-hosting/blog/424289/) / [Часть 2](https://habr.com/company/ua-hosting/blog/424295/) / [Часть 3](https://habr.com/company/ua-hosting/blog/424297/)
Лекция 10: «Символьное выполнение» [Часть 1](https://habr.com/company/ua-hosting/blog/425557/) / [Часть 2](https://habr.com/company/ua-hosting/blog/425561/) / [Часть 3](https://habr.com/company/ua-hosting/blog/425559/)
Лекция 11: «Язык программирования Ur/Web» [Часть 1](https://habr.com/company/ua-hosting/blog/425997/) / [Часть 2](https://habr.com/company/ua-hosting/blog/425999/) / [Часть 3](https://habr.com/company/ua-hosting/blog/426001/)
Лекция 12: «Сетевая безопасность» [Часть 1](https://habr.com/company/ua-hosting/blog/426325/) / [Часть 2](https://habr.com/company/ua-hosting/blog/427087/) / [Часть 3](https://habr.com/company/ua-hosting/blog/427093/)
Лекция 13: «Сетевые протоколы» [Часть 1](https://habr.com/company/ua-hosting/blog/427763/) / [Часть 2](https://habr.com/company/ua-hosting/blog/427771/) / [Часть 3](https://habr.com/company/ua-hosting/blog/427779/)
Лекция 14: «SSL и HTTPS» [Часть 1](https://habr.com/company/ua-hosting/blog/427783/) / [Часть 2](https://habr.com/company/ua-hosting/blog/427785/) / [Часть 3](https://habr.com/company/ua-hosting/blog/427787/)
Я думаю, что принуждение к использованию HTTPS объясняется беспокойством о пользователях, которые имеют слишком большую свободу действий в принятии решений относительно возможности использования сертификатов.
Еще одна проблема, которая проявляется на практике и которая также заставляет использовать HTTPS, это небезопасное вложение или смешанное содержимое интернет-страницы. Смысл этой проблемы в том, что безопасный сайт или любой веб-сайт, если на то пошло, может вставлять другие части контента в web-страницу.
Так что если у вас есть какой-то сайт, например foo.com/index.html, то он может обслуживаться по протоколу HTTPS, но внутри HTML-страницы у вас может быть много тегов, которые принуждают браузер перейти куда-то и сделать частью этой страницы какой-то чужой контент.
Тег такого сценария выглядит таким образом: | https://habr.com/ru/post/427787/ | null | ru | null |
# Организация деплоя в множество k8s окружений с помощью helmfile
[Helmfile](https://github.com/roboll/helmfile) — обёртка для [helm](https://github.com/helm/helm/), которая позволяет в одном месте описывать множество helm релизов, параметризовать их чарты для нескольких окружений, а также задавать порядок их деплоя.
О самом helmfile и примерах его использования можно почитать в [readme](https://github.com/roboll/helmfile/blob/master/README.md) и [best practices guide](https://github.com/roboll/helmfile/blob/master/docs/writing-helmfile.md).
> **Upd. 10/06/2022**: Со временем довёл до ума этот подход и получилось гораздо лучше и удобнее, чем описано в статье. При возможности напишу отдельный пост, а пока с примерами улучшенного варианта можно ознакомиться [здесь](https://github.com/zam-zam/helmfile-examples) и [здесь](https://github.com/zam-zam/zzamzam-k8s).
Мы же познакомимся с неочевидными способами описать релизы в helmfile
Допустим, у нас есть пачка helm-чартов (для примера пусть будет postgres и некое backend приложение) и несколько окружений (несколько kubernetes кластеров, несколько namespace'ов или несколько и того, и другого). Берём helmfile, читаем документацию и начинаем описывать наши окружения и релизы:
```
.
├── envs
│ ├── devel
│ │ └── values
│ │ ├── backend.yaml
│ │ └── postgres.yaml
│ └── production
│ └── values
│ ├── backend.yaml
│ └── postgres.yaml
└── helmfile.yaml
```
#### **`helmfile.yaml`**
```
environments:
devel:
production:
releases:
- name: postgres
labels:
app: postgres
wait: true
chart: stable/postgresql
version: 8.4.0
values:
- envs/{{ .Environment.Name }}/values/postgres.yaml
- name: backend
labels:
app: backend
wait: true
chart: private-helm-repo/backend
version: 1.0.5
needs:
- postgres
values:
- envs/{{ .Environment.Name }}/values/backend.yaml
```
У нас получилось 2 окружения: **devel**, **production** — в каждом находятся свои значения для helm чартов релизов. Мы будем деплоить в них так:
```
helmfile -n -e apply
```
Разные версии helm чартов в разных окружениях
---------------------------------------------
Что делать, если нам надо выкатывать разные версии бэкенда в разные окружения? Как параметризовать версию релиза? На помощь приходят значения окружения, доступные через `{{ .Values }}`
#### **`helmfile.yaml`**
```
environments:
devel:
+ values:
+ - charts:
+ versions:
+ backend: 1.1.0
production:
+ values:
+ - charts:
+ versions:
+ backend: 1.0.5
...
- name: backend
labels:
app: backend
wait: true
chart: private-helm-repo/backend
- version: 1.0.5
+ version: {{ .Values.charts.versions.backend }}
...
```
Разный набор приложений в разных окружениях
-------------------------------------------
Отлично, но что если нам не надо в `production` выкатывать postgres, потому что мы знаем, что не надо базу данных пихать в k8s и для прода у нас есть замечательный отдельный кластер postgres? Для решения этой проблемы у нас есть лейблы (labels)
```
helmfile -n -e devel apply
helmfile -n -e production -l app=backend apply
```
Это здорово, но лично я предпочту описывать, какие приложения разворачивать в окружении не с помощью аргументов запуска, а в описании самих окружений. Что делать? Можно поместить описание релизов в отдельную папку, в описании окружения завести список нужных релизов и "подцеплять" только нужные релизы, игнорируя остальные
```
.
├── envs
│ ├── devel
│ │ └── values
│ │ ├── backend.yaml
│ │ └── postgres.yaml
│ └── production
│ └── values
│ ├── backend.yaml
│ └── postgres.yaml
+ ├── releases
+ │ ├── backend.yaml
+ │ └── postgres.yaml
└── helmfile.yaml
```
#### **`helmfile.yaml`**
```
environments:
devel:
values:
- charts:
versions:
backend: 1.1.0
- apps:
- postgres
- backend
production:
values:
- charts:
versions:
backend: 1.0.5
- apps:
- backend
- releases:
- - name: postgres
- labels:
- app: postgres
- wait: true
- chart: stable/postgresql
- version: 8.4.0
- values:
- - envs/{{ .Environment.Name }}/values/postgres.yaml
- - name: backend
- labels:
- app: backend
- wait: true
- chart: private-helm-repo/backend
- version: {{ .Values.charts.versions.backend }}
- needs:
- - postgres
- values:
- - envs/{{ .Environment.Name }}/values/backend.yaml
+ ---
+ bases:
+ {{- range .Values.apps }}
+ - releases/{{ . }}.yaml
+ {{- end }}
```
#### **`releases/postgres.yaml`**
```
releases:
- name: postgres
labels:
app: postgres
wait: true
chart: stable/postgresql
version: 8.4.0
values:
- envs/{{ .Environment.Name }}/values/postgres.yaml
```
#### **`releases/backend.yaml`**
```
releases:
- name: backend
labels:
app: backend
wait: true
chart: private-helm-repo/backend
version: {{ .Values.charts.versions.backend }}
needs:
- postgres
values:
- envs/{{ .Environment.Name }}/values/backend.yaml
```
---
**Заметка**
При использовании `bases:` необходимо обязательно использовать yaml разделитель `---`, чтобы можно было шаблонизировать releases (и остальные части, типа helmDefaults) значениями из environments
---
В таком случае релиз postgres даже не попадёт в описание для production. Очень удобно!
Переопределяемые глобальные значения для релизов
------------------------------------------------
Конечно, здорово, что можно для каждого окружения задавать значения для helm чартов, но что если у нас описано несколько окружений, и мы хотим, допустим, задать одинаковый для всех `affinity`, но не хотим настраивать его по-умолчанию в самих чартах, которые хранятся в репах.
В таком случае мы могли бы для каждого релиза задать 2 файла с values: первый с дефолтными значениями, которые будут определять значения самого чарта, а второй со значениями для окружения, который в свою очередь уже будет переопределять дефолтные.
```
.
├── envs
+ │ ├── default
+ │ │ └── values
+ │ │ ├── backend.yaml
+ │ │ └── postgres.yaml
│ ├── devel
│ │ └── values
│ │ ├── backend.yaml
│ │ └── postgres.yaml
│ └── production
│ └── values
│ ├── backend.yaml
│ └── postgres.yaml
├── releases
│ ├── backend.yaml
│ └── postgres.yaml
└── helmfile.yaml
```
#### **`releases/backend.yaml`**
```
releases:
- name: backend
labels:
app: backend
wait: true
chart: private-helm-repo/backend
version: {{ .Values.charts.versions.backend }}
needs:
- postgres
values:
+ - envs/default/values/backend.yaml
- envs/{{ .Environment.Name }}/values/backend.yaml
```
#### **`envs/default/values/backend.yaml`**
```
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 1
podAffinityTerm:
labelSelector:
matchExpressions:
- key: app.kubernetes.io/name
operator: In
values:
- backend
topologyKey: "kubernetes.io/hostname"
```
Определение глобальных значений для helm чартов всех релизов на уровне окружения
--------------------------------------------------------------------------------
Допустим, у нас в нескольких релизах создаются несколько ingress — мы могли бы вручную для каждого чарта определить `hosts:`, но в нашем случае домен один и тот же, так почему же его не вынести в некую глобальную переменную и просто подставлять её значение в чарты? Для этого те файлы с values, которые мы хотим параметризовать, должны будут иметь расширение `.gotmpl`, чтобы helmfile знал, что его надо прогнать через шаблонизатор.
```
.
├── envs
│ ├── default
│ │ └── values
- │ │ ├── backend.yaml
- │ │ ├── postgres.yaml
+ │ │ ├── backend.yaml.gotmpl
+ │ │ └── postgres.yaml.gotmpl
│ ├── devel
│ │ └── values
│ │ ├── backend.yaml
│ │ └── postgres.yaml
│ └── production
│ └── values
│ ├── backend.yaml
│ └── postgres.yaml
├── releases
│ ├── backend.yaml
│ └── postgres.yaml
└── helmfile.yaml
```
#### **`helmfile.yaml`**
```
environments:
devel:
values:
- charts:
versions:
backend: 1.1.0
- apps:
- postgres
- backend
+ - global:
+ ingressDomain: k8s.devel.domain
production:
values:
- charts:
versions:
backend: 1.0.5
- apps:
- backend
+ - global:
+ ingressDomain: production.domain
---
bases:
{{- range .Values.apps }}
- releases/{{ . }}.yaml
{{- end }}
```
#### **`envs/default/values/backend.yaml.gotmpl`**
```
ingress:
enabled: true
paths:
- /api
hosts:
- {{ .Values.global.ingressDomain }}
```
#### **`envs/default/values/postgres.yaml.gotmpl`**
```
ingress:
enabled: true
paths:
- /
hosts:
- postgres.{{ .Values.global.ingressDomain }}
```
---
**Заметка**
Очевидно, что ingress в чарте postgres — это нечто крайне сомнительное, поэтому в статье это приведено просто в качестве сферического примера в вакууме и для того, чтобы не вводить в статью какой-то новый релиз только ради описания ingress
---
Подстановка секретов (secrets) из значений окружения
----------------------------------------------------
По аналогии с вышеприведённым примером можно подставлять и зашифрованные с помощью [helm secrets](https://github.com/futuresimple/helm-secrets) значения. Вместо того, чтобы для каждого релиза создавать свой файл secrets, в котором определять для чарта зашифрованные значения, мы можем просто определить в релизном default.yaml.gotmpl значения, которые будут браться из переменных, заданных на уровне окружений. А значения, которые нам не надо ни от кого скрывать, можно уже спокойно переопределить в значениях релиза в конкретном окружении.
```
.
├── envs
│ ├── default
│ │ └── values
│ │ ├── backend.yaml
│ │ └── postgres.yaml
│ ├── devel
│ │ ├── values
│ │ │ ├── backend.yaml
│ │ │ └── postgres.yaml
+ │ │ └── secrets.yaml
│ └── production
│ ├── values
│ │ ├── backend.yaml
│ │ └── postgres.yaml
+ │ └── secrets.yaml
├── releases
│ ├── backend.yaml
│ └── postgres.yaml
└── helmfile.yaml
```
#### **`helmfile.yaml`**
```
environments:
devel:
values:
- charts:
versions:
backend: 1.1.0
- apps:
- postgres
- backend
- global:
ingressDomain: k8s.devel.domain
+ secrets:
+ - envs/devel/secrets.yaml
production:
values:
- charts:
versions:
backend: 1.0.5
- apps:
- backend
- global:
ingressDomain: production.domain
+ secrets:
+ - envs/production/secrets.yaml
---
bases:
{{- range .Values.apps }}
- releases/{{ . }}.yaml
{{- end }}
```
#### **`envs/devel/secrets.yaml`**
```
secrets:
elastic:
password: ENC[AES256_GCM,data:hjCB,iv:Z1P6/6xBJgJoKLJ0UUVfqZ80o4L84jvZfM+uH9gBelc=,tag:dGqQlCZnLdRAGoJSj63rBQ==,type:int]
...
```
#### **`envs/production/secrets.yaml`**
```
secrets:
elastic:
password: ENC[AES256_GCM,data:ZB/VpTFk8f0=,iv:EA//oT1Cb5wNFigTDOz3nA80qD9UwTjK5cpUwLnEXjs=,tag:hMdIUaqLRA8zuFBd82bz6A==,type:str]
...
```
#### **`envs/default/values/backend.yaml.gotmpl`**
```
elasticsearch:
host: elasticsearch
port: 9200
password: {{ .Values | getOrNil "secrets.elastic.password" | default "password" }}
```
#### **`envs/devel/values/backend.yaml`**
```
elasticsearch:
host: elastic-0.devel.domain
```
#### **`envs/production/values/backend.yaml`**
```
elasticsearch:
host: elastic-0.production.domain
```
---
**Заметка**
Кстати, `getOrNil` — специальная функция для go шаблонов в helmfile, которая, даже если `.Values.secrets` не будет существовать, не выкинет ошибку, а позволит в результате с помощью функции `default` подставить значение по-умолчанию
---
Заключение
----------
Описанные вещи кажутся довольно очевидными, но информация по удобному описанию деплоя в несколько окружений с помощью helmfile очень скудна, а я люблю IaC(Infrastructure-as-Code) и хочу иметь чёткое описание стейта деплоя.
В заключение хочу добавить, что переменные для окружения default можно в свою очередь параметризовать переменными окружения ОС некоего раннера, с которого будет запускаться деплой, и таким образом получить динамические окружения
#### **`helmfile.yaml`**
```
environments:
default:
values:
- global:
clusterDomain: {{ env "CLUSTER_DOMAIN" | default "cluster.local" }}
ingressDomain: {{ env "INGRESS_DOMAIN" }}
``` | https://habr.com/ru/post/491108/ | null | ru | null |
# Zabbix 3.X: мониторинг контролеров Adaptec в Windows Server (Hyper-V Core)
Доброго времени суток, %habrauser%! Сегодня займемся укрощением своих кривых ручонок и попробуем настроить мониторинг контролеров Adaptec на Hyper-V (core 2012r2) хостах при помощи Zabbix 3.2, PowerShell и консольной утилиты [Adaptec RAID Controller Command Line Utility](http://download.adaptec.com/pdfs/user_guides/cli_v1_00_19187_users_guide.pdf) предназначенной для мониторинга и управления контролерами Adaptec.
И так, план действий таков: Zabbix агент получает с сервера список параметров для обработки, затем агент активной проверкой c использованием пользовательского параметра инициирует запуск PowerShell скрипта с полученным параметром. Скрипт запускает Adaptec RAID Controller Command Line Utility с переданным ему параметром, фильтрует вывод консольной утилиты и выдает только нужные нам данные (модель, состояние, состояние логического хранилища, состояние физических дисков, S/N дисков, предупреждения S.M.A.R.T. на дисках), затем агент передает данные на сервер.
Приступим — загружаем/клонируем [репозиторий](https://github.com/sysbes/zabbix-adaptec) с необходимыми компонентами.
Распаковываем все в C:\zabbix-adaptec\. Добавляем нужные нам пользовательские параметры в конец zabbix-agentd.conf:
**пользовательские параметры**
```
#Adaptec
UserParameter=adaptec.allinfo,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "allinfo"
UserParameter=adaptec.model,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "model"
UserParameter=adaptec.status,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "status"
#Adaptec Logical Device 0 Status
UserParameter=adaptec.ldstatus,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "ldstatus"
#Adaptec Physical Device Info
UserParameter=adaptec.pd0state,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd0state"
UserParameter=adaptec.pd0sn,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd0sn"
UserParameter=adaptec.pd0smart,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd0smart"
UserParameter=adaptec.pd1state,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd1state"
UserParameter=adaptec.pd1sn,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd1sn"
UserParameter=adaptec.pd1smart,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd1smart"
UserParameter=adaptec.pd2state,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd2state"
UserParameter=adaptec.pd2sn,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd2sn"
UserParameter=adaptec.pd2smart,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd2smart"
UserParameter=adaptec.pd3state,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd3state"
UserParameter=adaptec.pd3sn,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd3sn"
UserParameter=adaptec.pd3smart,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd3smart"
UserParameter=adaptec.pd4state,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd4state"
UserParameter=adaptec.pd4sn,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd4sn"
UserParameter=adaptec.pd4smart,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd4smart"
UserParameter=adaptec.pd5state,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd5state"
UserParameter=adaptec.pd5sn,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd5sn"
UserParameter=adaptec.pd5smart,powershell.exe -file "C:\zabbix-adaptec\zabbix-adaptec.ps1" "pd5smart"
```
Импортируем шаблон в Zabbix: template-adaptec.xml и вешаем его на нужный хост.
Перезапускаем агент и ждем данные!
В шаблоне имеем:
Controller Status, Logical Device 0 — satus, Physical Device from 0 to 5 state and S.M.A.R.T. warnings, S/N of devices и настроенные триггеры. | https://habr.com/ru/post/323042/ | null | ru | null |
# DI для полностью переиспользуемых JSX-компонентов
Привет, меня зовут Сергей и мне интересна проблема переиспользования компонент в вебе. Глядя на то, как [пытаются](https://habrahabr.ru/company/docsvision/blog/335988/) применить SOLID к реакту, я решил продолжить эту тему и показать, как можно достичь хорошей переиспользуемости, развивая идею [внедрения зависимостей](https://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8) или DI.
DI как основа для построения фреймворка, применительно к вебу, довольно молодой подход. Что бы тут было понятней о чем идет речь, начну c привычных для react-разработчиков вещей.
От контекстов к DI
------------------
Уверен, что многие использовали [контексты](https://facebook.github.io/react/docs/context.html) при работе с react. Если не напрямую, то наверняка через [connect](http://redux.js.org/docs/basics/UsageWithReact.html#implementing-container-components) в redux или [inject](https://github.com/mobxjs/mobx-react#provider-and-inject) в mobx-react. Суть в том, что в одном компоненте (MessageList) мы объявляем нечто в контексте, а в другом (Button) — говорим, что хотим получить это нечто из контекста.
```
const PropTypes = require('prop-types');
const Button = ({children}, context) =>
{children}
;
Button.contextTypes = {color: PropTypes.string};
class MessageList extends React.Component {
getChildContext() {
return {color: "purple"};
}
render() {
return Ok;
}
}
```
Т.е. один раз в родительском компоненте задается `context.color`, а далее он автоматически пробрасывается любым нижележащим компонентам, в которых через contextTypes объявлена зависимость от color. Таким образом Button можно кастомизировать без прокидывания свойств по иерархии. Причем на любом уровне иерархии можно через `getChildContext() ...` переопределить color для всех дочерних компонент.
Такой подход лучше изолирует компоненты друг от друга, упрощая их настройку и переиспользование. В примере выше, достаточно в родительском компоненте определить color и все кнопки поменяют цвет. Причем компонент Button может быть в другой библиотеке, которую при этом не надо рефакторить.
Однако, для реакта, в виду недостаточной продуманности, этот подход пока развит слабо. Напрямую его использовать разработчики не рекомендуют:
> It is an experimental API and it is likely to break in future releases of React
написано в документации. Оно experimental в текущем виде уже достаточно давно и ощущение, что разработка зашла в тупик. Контексты в компонентах сцеплены с инфраструктурой (getChildContext), псевдотипизацией через PropTypes и больше похожи на [service locator](https://en.wikipedia.org/wiki/Service_locator_pattern), который некоторые считают [антипаттерном](https://habrahabr.ru/post/270005/). Роль контекстов, на мой взгляд, недооценена и в реакте второстепенная: [локализация и темизация](https://twitter.com/dan_abramov/status/749715530454622208), а также биндинги к библиотекам вроде redux и mobx.
В других фреймворках подобные инструменты развиты лучше. Например, в vue: [provide/inject](https://vuejs.org/v2/api/#provide-inject), а в angular, его [angular di](https://angular.io/guide/dependency-injection) это уже полноценный навороченный DI с поддержкой типов typescript. По-сути, начиная с Angular второй версии, разработчики попытались переосмыслить опыт бэкенда (где DI уже давно существует) применительно к фронтенду. А что если попытаться развить аналогичную идею для реакта и его клонов, какие проблемы бы решились?
Прибивать или нет, вот в чем вопрос
-----------------------------------
В полноценном реакт/redux-приложении не всё делают через redux-экшены. Состояние какой-нибудь малозначительной галочки удобнее реализовать через setState. Получается — через redux громоздко, а через setState не универсально, но проще, т.к. он всегда под рукой. Статья [You Might Not Need Redux](https://medium.com/@dan_abramov/you-might-not-need-redux-be46360cf367) известного автора, как бы говорит "если вам не нужно масштабирование — не используйте redux", подтверждая эту двойственность. Проблема в том, что это сейчас не нужно, а завтра может быть понадобится прикрутить логирование состояния галочки.
В другой статье того же автора, [Presentational and Container Components](https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0), говорится примерно, что "Все компоненты равны (Presentational), но некоторые равнее (Container)" и при этом высечены в граните (прибиты к redux, mobx, relay, setState). Кастомизация Container компонента усложняется — не предполагается его переиспользовать, он уже прибит к реализации состояния и контексту.
Что бы как-то упростить создание Container-компонент, придумали [HOC](https://facebook.github.io/react/docs/higher-order-components.html), но по-сути мало что поменялось. Просто чистый компонент стали комбинировать через connect/inject с чем-то вроде redux, mobx, relay. А полученный монолитный Container использовать в коде.
Иными словами, говорим Presentational и Container, а подразумеваем — переиспользуемый и непереиспользуемый. Первый удобно кастомизировать т.к. все точки расширения в свойствах, а второй — рефакторить, т.к свойств меньше, за счет его прибитости к стейту и некоторой логике. Это — некий компромисс по решению двух противоположных проблем, плата за который — разделение компонент на два типа и жертвование принципом [открытости/закрытости](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D1%82%D0%BE%D1%81%D1%82%D0%B8/%D0%B7%D0%B0%D0%BA%D1%80%D1%8B%D1%82%D0%BE%D1%81%D1%82%D0%B8).
Например, как в статье [Заменяй и властвуй — подход SOLID](https://habrahabr.ru/company/docsvision/blog/335988/), где предлагается делать большинство компонент максимально простыми, ухудшая их целостность. Но, сложные компоненты из простых все-равно надо будет где-то собирать и при этом остается вопрос как их кастомизировать. Т.е. проблема переносится на другой уровень.
```
this.setState({ dialogOpen: false })} />
this.setState({ dialogOpen: false })} />
Dialog header
Some content
this.setState({ dialogOpen: false })} key="cancel">
{resources.Navigator\_ButtonClose}
{resources.Navigator\_ButtonSelect}
```
Если все же условиться, что эти оконечные компоненты мы не кастомизируем, то в реальности получается большое кол-во шаблонного кода, когда ради замены одной Button, весь компонент строится заново. Полноценный SOLID при таком подходе невозможен. Всегда будут компоненты-биндинги к стейту, которые нельзя расширить без модификации и компоненты-шаблоны без логики внутри и этим сложные в использовании.
Прототип
--------
Развивая идею внедрения зависимостей, можно решить некоторые из этих проблем. Разберем решение на основе вот такого примера:
```
// @flow
// @jsx lom_h
// setup...
class HelloService {
@mem name = ''
}
function HelloView(props: {greet: string}, service: HelloService) {
return
{props.greet}, {service.name}
{ service.name = e.target.value }} />
}
// HelloView.deps = [HelloService]
ReactDOM.render(, document.getElementById('mount'))
```
[fiddle](https://jsfiddle.net/1xy4vy18/1/)
Здесь есть одна универсальная форма компонента в виде функции, независимо от того, работает он с состоянием или нет. Контексты используют типы. Из них автоматически генерируются описания зависимостей с помощью [babel-plugin-transform-metadata](https://github.com/zerkalica/babel-plugin-transform-metadata). Аналогично typescript, который это делает, правда, только для классов. Хотя можно описывать аргументы и вручную: `HelloView.deps = [HelloService]`
Lifecycle
---------
А как же быть с жизненным циклом компонента? А так ли нужна низкоуровневая работа с ним в коде? Посредством HOC как раз пытаются убрать эти lifecycle methods из основного кода, например, как в [relay/graphql](https://facebook.github.io/relay/docs/guides-root-container.html#renderloading).
Идея в том, что актуализация данных — это не ответственность компонента. Если у вас загрузка данных происходит по факту доступа к этим данным (например, используется lazyObservable из [mobx-utils](https://github.com/mobxjs/mobx-utils#lazyobservable)), то componentDidMount в этом случае не нужен. Если надо прикрутить jquery-плагин, то есть свойство refs в элементе и т.д.
Предположим, что универсальный компонент, свободный от vendor lock-in реакта, теперь есть. Пусть, мы даже выделили его в отдельную библиотеку. Осталось решить, как расширять и настраивать то, что приходит в контекст. Ведь HelloService — это некая реализация по-умолчанию.
Поди туда — не знаю куда, принеси то — не знаю что
--------------------------------------------------
Что если компоненты, в силу частых изменений требований, та часть приложения, где инкапсуляция начинает мешать. Не сама по себе конечно, а в том виде, как она сегодня реализована практически во всех фреймворках: в виде шаблона, композиции функций или JSX.
Представим на секунду, что в случае любого компонента нельзя заранее сказать, что у него будет кастомизироваться. И нужен способ менять любую внутреннюю часть компонента без рефакторинга (принцип открытости/закрытости), при этом не ухудшая его читабельности, не усложняя его исходную реализацию и не вкладываясь в переиспользуемость изначально (нельзя все предвидеть).
Например, без DI можно проектировать, подразумевая кастомизацию через наследование. Т.е. дробить содержимое на мелкие методы, теряя при этом в наглядности и иерархии. О минусах этого подхода пишет автор в статье [Идеальный UI фреймворк](https://habrahabr.ru/post/276747/):
```
class MyPanel extends React.Component {
header() { return {this.props.head} }
bodier() { return {this.props.body} }
childs() { return [ this.header() , this.bodier() ] }
render() { return {this.childs()}
}
```
```
class MyPanelExt extends MyPanel {
footer() { return {this.props.foot} }
childs() { return [ this.header() , this.bodier() , this.footer() ] }
}
```
Надо сказать, что этот автор ([@vintage](https://habrahabr.ru/users/vintage)), придумал формат [tree](https://habrahabr.ru/post/248147/), который позволяет описать вышеприведенный пример с сохранением иерархии. Несмотря на то, что многие критикуют этот формат, у него есть преимущество как раз в виде переопределяемости даже самых мелких деталей без специального разбиения на части и рефакторинга. Иными словами, это бесплатная (почти, кроме постижения новой необычной концепции) буковка O в SOLID.
Полностью перенести этот принцип на JSX невозможно, однако частично реализовать его через DI можно попытаться. Смысл в том, что любой компонент в иерархии — это еще и точка расширения, слот, если рассуждать в терминах vue. И мы в родительском компоненте можем поменять его реализацию, зная его идентификатор (исходная реализация или интерфейс). Примерно так работают многие контейнеры зависимостей, позволяя ассоциировать реализации с интерфейсами.
В js/ts, в runtime, без усложнений или внедрения строковых ключей, ухудшающих безопасность кода, нельзя ссылаться на интерфейс. Поэтому следующий пример не заработает в flow или typescript (но аналогичный заработает в C# или Dart):
```
interface ISome {}
class MySome implements ISome {}
const map = new Map()
map.set(ISome, MySome)
```
Однако, можно ссылаться на абстрактный класс или функцию.
```
class AbstractSome {}
class MySome extends AbstractSome {}
const map = new Map()
map.set(AbstractSome, MySome)
```
Т.к. создание объектов и компонент происходит внутри DI-контейнера, а там внутри может быть подобный map, то любую реализацию можно переопределить. А т.к. компоненты, кроме самых примитивных — функции, то их можно подменять на функции с таким же интерфейсом, но с другой реализацией.
Например, TodoResetButtonView является частью TodoView. Требуется переопределить TodoResetButtonView на кастомную реализацию.
```
function TodoResetButtonView({onClick}) {
return reset
}
function TodoView({todo, desc, reset}) {
return - todo.finished = !todo.finished}
/>{todo.title} #{todo.id} ({desc.title})
reset
}
```
Предположим у нас нет возможности править TodoView (он в другой библиотеке и мы не хотим его трогать, нарушая open/close принцип и заново тестировать 11 других проектов, которые его использовали со старой кнопкой).
Поэтому создаем новую кнопку и клонируем существующий TodoView, заменяя ее в клоне. Это наследование, только наглядность не нарушается — остается иерархия и не нужно специально заранее проектировать TodoView так, что бы можно было заменить кнопку.
```
function ClonedTodoResetButtonView({onClick}) {
return cloned reset
}
const ClonedTodoView = cloneComponent(TodoView, [
[TodoResetButtonView, ClonedTodoResetButtonView]
], 'ClonedTodoView')
const ClonedTodoListView = cloneComponent(TodoListView, [
[TodoView, ClonedTodoView]
], 'ClonedTodoListView')
ReactDOM.render(, document.getElementById('mount'));
```
[fiddle](https://jsfiddle.net/w7fzp1z8/14/)
Переопределять иногда надо не только компоненты, но и их зависимости:
```
class AbstractHelloService {
name: string
}
function HelloView(props: {greet: string}, service: AbstractHelloService) {
return
{props.greet}, {service.name}
{ service.name = e.target.value }} />
}
class AppHelloService {
@mem name = 'Jonny'
}
function AppView() {
return
}
AppView.aliases = [
[AbstractHelloService, AppHelloService]
]
```
[fiddle](https://jsfiddle.net/1xy4vy18/4/)
HelloView получит экземпляр класса AppHelloService. Т.к. `AppView.aliases` для всех дочерних компонент переопределяет AbstractHelloService.
Есть конечно и минус подхода "все кастомизируется" через наследование. Т.к. фреймворк предоставляет больше точек расширения, то, больше ответственности по кастомизации перекладывается на того, кто использует компонент, а не проектирует его. Переопределяя части компонента "таблица", без осознания смысла, можно ненароком превратить его в "список", а это плохой признак, т.к. является [искажением исходного смысла](https://habrahabr.ru/post/325478) (нарушается [LSP](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B8_%D0%91%D0%B0%D1%80%D0%B1%D0%B0%D1%80%D1%8B_%D0%9B%D0%B8%D1%81%D0%BA%D0%BE%D0%B2) принцип).
Разделение состояния
--------------------
По-умолчанию, состояние в зависимостях компонента будет выделено под каждый компонент. Однако действует общий принцип: все определяемое в компонентах выше — имеет приоритет над нижележащими зависимостями. Т.е. если зависимость впервые используется в родительском компоненте, то она будет жить вместе с ним и все нижележащие компоненты, ее запросившие, получат именно родительский экземпляр.
```
class HelloService {
@mem name = 'John'
}
function HelloView(props: {greet: string}, service: HelloService) {
return
{props.greet}, {service.name}
{ service.name = e.target.value }} />
}
class AppHelloService {
@mem name = 'Jonny'
}
function AppView(_, service: HelloService) {
return
}
```
[fiddle](https://jsfiddle.net/1xy4vy18/3/)
В такой конфигурации, оба HelloView разделяют общий экземпляр HelloService. Однако, без HelloService в AppView, на каждый дочерний компонент будет свой экземпляр.
```
function AppView() {
return
}
```
Подобный принцип, когда можно управлять, какому компоненту принадлежит объект, используется в [иерархическом DI](https://angular.io/guide/hierarchical-dependency-injection) ангулара.
Стили
-----
Я не утверждаю, что подход css-in-js единственно правильный для использования в веб. Но и тут можно применить идею внедрения зависимостей. Проблема аналогична вышеописанной с redux/mobx и контекстами. Например, как и во многих подобных библиотеках, стили jss прибиваются к компоненту через обертку injectSheet и компонент связывается с конкретной реализацией стилей, с react-jss:
```
import React from 'react'
import injectSheet from 'react-jss'
const styles = {
button: {
background: props => props.color
},
label: {
fontWeight: 'bold'
}
}
const Button = ({classes, children}) => (
{children}
)
export default injectSheet(styles)(Button)
```
Однако, эту прямую зависимость от jss и ему подобных можно убрать, перенеся эту ответственность на DI. В коде приложения достаточно определить функцию со стилями, как зависимость компонента и пометить ее соответственно.
```
// ... setup
import {action, props, mem} from 'lom_atom'
import type {NamesOf} from 'lom_atom'
class Store {
@mem red = 140
}
function HelloTheme(store: Store) {
return {
wrapper: {
background: `rgb(${store.red}, 0, 0)`
}
}
}
HelloTheme.theme = true
function HelloView(
_,
{store, theme}: {
store: Store,
theme: NameOf
}
) {
return
color via css {store.red}: { store.red = Number(target.value) }}
/>
}
```
[fiddle](https://jsfiddle.net/w7fzp1z8/17/)
Такой подход для стилей обладает всеми преимуществами DI, таким образом обеспечивается темизация и реактивность. В отличие от [переменных в css](https://developer.mozilla.org/ru/docs/Web/CSS/Using_CSS_variables), здесь работают типы в flow/ts. Из минусов — накладные расходы на генерацию и обновление css.
Итог
----
В попытке адаптировать идею внедрения зависимостей для компонентов, получилась библиотека [reactive-di](https://github.com/zerkalica/reactive-di). Простые примеры в статье постронены на ее основе, но есть и [более сложные](http://zerkalica.github.io/rdi-examples/), с загрузкой, обработкой статусов загрузки, ошибок и т.д. Есть todomvc [бенчмарк](http://mol.js.org/app/bench/#bench=https%3A%2F%2Fzerkalica.github.io%2Futb%2Fbenchmark%2F/sample=preact-mobx~preact-raw~preact-reactive-di) для react, preact, inferno. В котором можно оценить оверхед от использования reactive-di. Правда, на 100 todos, погрешность измерений у меня была больше, чем этот оверхед.
Получился упрощенный Angular. Однако есть ряд особенностей, reactive-di
1. Умеет интегрироваться с реактом и его клонами, оставаясь совместимым с legacy-компонентами на чистом реакте
2. Позволяет писать на одних чистых компонентах, не оборачивая их в mobx/observe или подобное
3. Хорошо работает с типами в flowtype не только для классов, но и для компонент-функций
4. Ненавязчив: не требуется кучи декораторов в коде, компоненты абстрагируются от react, его можно поменять на свою реализацию, не затрагивая основной код
5. Настраивается просто, не нужно региситрации зависимостей, provide/inject-подобных конструкций
6. Позволяет доопределять содержимое компонента без его модификации, c сохранением иерархии его внутренностей
7. Позволяет ненавязчиво, через интерфейсы, интегрировать css-in-js решения в компоненты
Почему до сих пор идею контекстов не развивали в этом ключе? Скорее всего непопулярность DI на фронтенде объясняется не повсеместным господством flow/ts и отсутствием стандартной поддержки интерфейсов на уровне метаданных. Попытками скопировать сложные реализации с других backend-ориентированных языков (как InversifyJS клон Ninject из C#) без глубокого переосмысления. А также пока недостаточным акцентом: например, некоторое подобие DI есть в react и vue, но там эти реализации являются неотделимой частью фреймворка и роль их второстепенная.
Хороший DI — это еще половина решения. В примерах выше часто мелькал декоратор `@mem`, который необходим для управления состоянием, построенном на идее [ОРП](https://habrahabr.ru/post/330466/). С помощью mem можно писать код в псевдосинхронном стиле, с простой, по-сравнению с mobx, обработкой ошибок и статусов загрузки. Про него я расскажу в следующей статье. | https://habr.com/ru/post/338666/ | null | ru | null |
# Маршрутизация в socks. Еще один способ
Рассмотрим еще один способ маршрутизации локальной сети через «socks-прокси». В отличии от [предыдущего способа](http://habrahabr.ru/post/345418/) с «redsocks», в этом, будет рассмотрена возможность маршрутизации на сетевом уровне (сетевой модели OSI), по средствам пакета «badvpn-tun2socks». Данная статья ориентирована на создание и постоянное использование такого маршрутизатора на базе ОС «Debian stretch».
*Советую [другой способ](https://habr.com/ru/post/491568/) с использованием systemd-networkd.*
Прежде чем перейти к описанию настройки системы, предоставлю [ссылку на исходники badvpn](https://code.google.com/archive/p/badvpn/downloads) (может кому-то понадобится).
Итак, после скачивания и сборки пакета, предлагаю сразу создать сервис systemd со следующим содержанием:
```
cat /etc/systemd/system/tun2socks.service
[Unit]
Description=Start tun2socks
[Service]
ExecStart=/путь/к/badvpn-tun2socks --tundev tun0 --netif-ipaddr 10.0.0.2 --netif-netmask 255.255.255.0 --socks-server-addr 127.0.0.1:1080
[Install]
WantedBy=multi-user.target
```
Здесь, в параметре запуска "*--socks-server-addr 127.0.0.1:1080*" видно, что «tun2socks» будет направлять запросы по адресу socks-прокси сервера. (К примеру, ssh-tunnel из [предыдущего способа](http://habrahabr.ru/post/345418/)).
Параметры "*--netif-ipaddr 10.0.0.2*" и "*--netif-netmask 255.255.255.0*", отвечают за создание «маршрутизатора tun2socks» с адресом 10.0.0.2, на который будут приходить запросы с виртуального интерфейса, указанного в параметре "*--tundev tun0*".
Для понимания, приведу скромную схему:
```
+----------+ +-----------+ +----------------+ +------------+
| tun0 |____| tun2socks |___| socks |______| ssh-server |
| 10.0.0.1 | | 10.0.0.2 | | 127.0.0.1:1080 | | *pubic ip* |
+----------+ +-----------+ +----------------+ +------------+
|
+----------+ +-----------+ +----------------+
| NAT |____| dhcpd/ |___| LAN |
| iptables | | wlp6s0 | | 192.168.1.0/24 |
+----------+ +-----------+ +----------------+
```
"**tun0**" это виртуальный интерфейс, который необходимо настроить в системе, на него будут приходить запросы из локальной сети\хоста. Сделаем это стандартным для Debian способом:
```
cat /etc/network/interfaces
auto lo
auto wlp6s0
auto tun0
# Беспроводной интерфейс
iface wlp6s0 inet static
address 192.168.1.2
netmask 255.255.255.0
gateway 192.168.1.1
wpa-driver wext
wpa-conf /etc/wpa_supplicant.conf
# Остановка службы tun2socks
pre-down systemctl stop tun2socks
# Удаление виртуального интерфейса
pre-down ip tuntap del dev tun0 mode tun
# Создание виртуального интерфейса
pre-up ip tuntap add dev tun0 mode tun user root
# Запуск службы tun2socks
pre-up systemctl start tun2socks &
# Виртуальный интерфейс
iface tun0 inet manual
# Назначить ip адрес
pre-up ip addr add dev tun0 10.0.0.1/24
# Добавить действующий шлюз по умолчанию для DNS сервера
up ip route add via 192.168.1.1
# Тоже самое для SSH сервера
up ip route add via 192.168.1.1
# Удалить действующий шлюз по умолчанию
up ip route del default
# Добавить шлюз по умолчанию через интерфейс tun2socks
up ip route add default via 10.0.0.2
```
Как видно из листинга, созданной ранее службой «tun2socks», управляет состояние интерфейса «wlp6s0». Сделано это, потому что, запущенная служба «tun2socks», работает в связке с виртуальным интерфейсом «tun0», поэтому, становится невозможным удаление виртуального интерфейса, без остановки службы и как следствие нормальной работы системы инициализации сетевых интерфейсов.
Следует обратить внимание на строчки "*up ip route add via 192.168.1.1* " и "*up ip route add via 192.168.1.1* ". В них, вместо значений "" и "" следует указать ip адреса используемых DNS и SSH серверов, и заменить ip адрес «192.168.1.1» согласно действующему шлюзу по умолчанию.
Не помешает включить поддержку маршрутизации на уровне ядра, в файле /etc/sysctl.conf:
```
net.ipv4.ip_forward=1
```
И применить изменения командой:
```
sysctl -p /etc/sysctl.conf
```
На этом, настройка tun2socks будет завершена, после перезапуска службы сетевых интерфейсов, весь исходящий TCP трафик с хоста, будет направляться через socks-прокси сервер. Следующим и последним шагом будет маршрутизация локальной сети, с помощью dhcp сервера, установку и настройку которого, я рассмотрел в [предыдущем способе](http://habrahabr.ru/post/345418/), а также настройка NAT с помощью iptables.
Необходимо создать файл следующего содержания:
```
cat /etc/iptables.test.rules
*filter
-A FORWARD -i tun0 -o wlp6s0 -m state --state RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -i wlp6s0 -o tun0 -j ACCEPT
COMMIT
*nat
-A POSTROUTING -o tun0 -j MASQUERADE
COMMIT
```
Если требуется, изменить названия интерфейсов согласно своей системе и применить его командой:
```
iptables-restore < /etc/iptables.test.rules
```
Проверить работу из локальной сети, если все устраивает, сохранить правила:
```
iptables-save > /etc/iptables.rules
```
Добавить скрипт в:
```
cat /etc/network/if-pre-up.d/iptables
#!/bin/sh
iptables-restore < /etc/iptables.rules
```
И сделать его исполняемым:
```
chmod +x /etc/network/if-pre-up.d/iptables
```
Теперь эти правила будут применяться после загрузки, а в вашем распоряжении окажется маршрутизатор на базе Debian, отлично подходящий для обхода цензуры и/или защиты соединений локальной сети. | https://habr.com/ru/post/347168/ | null | ru | null |
# 12 малоизвестных фактов о CSS
*Предлагаю читателям «Хабрахабра» перевод статьи [«12 Little-Known CSS Facts (The Sequel)»](http://www.sitepoint.com/12-little-known-css-facts-the-sequel/). Она совсем недавно была упомянута в [дайджесте интересных материалов из мира веб-разработки и IT](http://habrahabr.ru/company/zfort/blog/263007/).*
*Update: немного «шлифанул» перевод напильником. Выражаю благодарность всем неравнодушным читателям.*
Внимание! Под катом почти 1.5 Мб картинок и много интересных ссылок.
Итак, начнём-с…
#### 1. В свойстве `border-radius` можно использовать slash-синтаксис.
Об этом уже [писалось](http://www.sitepoint.com/setting-css3-border-radius-with-slash-syntax/) 4 года назад, но многие новички и даже некоторые опытные разработчики не знают о существовании этой «фишки».
Верите или нет, но следующий код валиден:
```
.box {
border-radius: 35px 25px 30px 20px / 35px 25px 15px 30px;
}
```
Такой подход немного обескураживает в первый раз. Вот объяснение из спецификации:
> Если значения указаны и «до», и «после» слеша, то значения «до» устанавливают горизонтальный радиус, а значения «после» « вертикальный.
>
> Если slash отсутствует, то значения обоих радиусов считаются одинаковыми.
>
>
В спецификации также приводится следующая диаграмма:
Использование slash-а при указании значений позволит вам создавать несимметричные скругленные углы. Если хотите более подробно изучить эту тему, то почитайте указанную выше [статью](http://www.sitepoint.com/setting-css3-border-radius-with-slash-syntax/) или, даже лучше, попробуйте [интерактивное демо от MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/Tools/Border-radius_generator).
Большинство генераторов border-radius-ов не позволяют устанавливать дополнительные значения. Из всех найденных таких генераторов только MDN-овский это умеет.
#### 2. Свойство `font-weight` может принимать «относительные» значения.
Чаще всего свойство `font-weight` принимает значение normal или bold. Иногда встречаются и целочисленные значения, кратные ста, такие как 100, 200 и т.д. до 900.
Но два возможных значения часто забывают — `bolder` и `lighter`.
Согласно спецификации, эти ключевые слова устанавливают шрифта жирнее или тоньше по сравнению с унаследованным. Такая возможность работы с отображением текста важна, если используемый шрифт имеет несколько вариантов «веса», а не только «жирный» и «нормальный».
В значениях веса, кратным ста, «жирный» равен 700, а «нормальный» — 400. Таким образом, если вы хотите установить вес в 300, то значение `lighter`, примененное к тексту, который унаследовал нормальный вес 400, установит как раз нужный вес. Если более «легкого» варианта шрифта нет (т.е. 400 — самый тонкий вариант шрифта), то те же 400 и останется, и от использования `lighter` эффекта не будет.
В [примере](http://codepen.io/SitePoint/pen/domZLx) используется шрифт [Exo 2](https://www.google.com/fonts/specimen/Exo+2), который имеет 18 различных стилей, но из них нужны только некурсивные варианты шрифта — этого достаточно для всех числовых весовых значений.
В демке используется 12 вложенных box-элементов с различными значениями `font-weight` включая `bolder` и `lighter`, так что эффект от применения этих ключевых слов очевиден. Ниже приведены использованные стили. Обратите внимание на комментарии в коде и учтите, что каждый следующий элемент находится внутри предыдущего.
**Много css-кода из демки**
```
.box {
font-weight: 100;
}
.box-2 {
font-weight: bolder; /* maps to 400 */
}
.box-3 {
font-weight: bolder; /* maps to 700 */
}
.box-4 {
font-weight: 400;
}
.box-5 {
font-weight: bolder; /* maps to 700 */
}
.box-6 {
font-weight: bolder; /* maps to 900 */
}
.box-7 {
font-weight: 700;
}
.box-8 {
font-weight: bolder; /* maps to 900 */
}
.box-9 {
font-weight: bolder; /* maps to 900 */
}
.box-10 {
font-weight: lighter; /* maps to 700 */
}
.box-11 {
font-weight: lighter; /* maps to 400 */
}
.box-12 {
font-weight: lighter; /* maps to 100 */
}
```
В данном примере `bolder` и `lighter`, в конечном итоге, устанавливают следующие значения веса: 100, 400, 700 и 900. С девятью различными css-стилями при использовании этих ключевых слов не получится добиться значений 200, 300, 500, 600 и 800.
Это происходит из-за того, что вы указываете браузеру выбрать следующий вариант шрифта, который «жирнее» или «легче». А браузер выбирает не просто «следующий более жирный» или «следующий более тонкий» вариант, а «жирный» и «легкий» по отношению к текущему унаследованному варианту. Но, если самый «легкий» вариант шрифта имеет вес 300, например, как у [Open Sans](https://www.google.com/fonts/specimen/Open+Sans), а унаследованное значение равнялось 400, то при использовании «lighter» получится 300.
Такое поведение может сбивать с толку, но если вы «поиграетесь» с демо-примером, то всё встанет на свои места.
#### 3. Существует свойство `outline-offset`
Свойство outline довольно широко известно из-за использования при дебагинге (из-за него [страница не «расползается»)](http://www.impressivewebs.com/css-things-that-dont-occupy-space/). В спецификации, однако, добавлено свойство `outline-offset`, которые делает ровно то, что и означает — указывает сдвиг внешней границы от элемента.
В [демо](http://codepen.io/SitePoint/pen/VLXyZw) при изменении положения ползунка меняется и величина сдвига границы. В примере указаны значения от 0px до 30px, но вы можете изменить пределы на своё усмотрение. Обратите внимание, на то, что свойство `outline` — сокращенное свойство и не включает в себя `outline-offset` и его придется указывать отдельно.
Главным недостатком свойства `outline-offset` является тот факт, что оно поддерживается всеми браузерами кроме Internet Explorer (даже в IE 11 его нет).
#### 4. Существует свойство `table-layout`
Не стоит путать это свойство с `display: table`.
Т.к. `table-layout` — не самая простая «фишка» CSS для понимания, давайте сначала обратимся к спецификации, а потом посмотрим на демо:
> При таком подходе вертикальное выравнивание таблицы зависит не от содержимого ячейки, а от ширины таблицы, ширины колонки и границ или отступов между ячейками.
>
>
Возможно, это первый раз в истории спецификации W3C, когда что-то так сложно понять.
Но, если серьёзно, использование [демо](http://codepen.io/SitePoint/pen/vORpYN) поможет.
В приведенном примере видно преимущество использования значения `fixed` для `table-layout` по сравнению со значением `auto`. Использование такого подхода не панацея, но всегда неплохо знать о такой возможности при использовании таблиц с ячейками различной ширины.
Chris Coyier написал замечательную [статью об использовании длинных строк в таблицах](https://css-tricks.com/fixing-tables-long-strings/) в прошлом году, в которой данная тема раскрывается очень хорошо.
#### 5. Свойство `vertical-align` работает по разному в ячейках таблиц и других элементах
Если вы занимаетесь разработкой сайтов с середины двухтысячных или раньше или знаете достаточно много о HTML и email-письмах, то вы, возможно, предполагаете, что свойство `vertical-align` является обычным улучшением старого [HTML4-аттрибута `valign`](http://www.w3.org/TR/html401/struct/tables.html#adef-valign), который сайчас указан как [устаревший и несоответствующий стандарту HTML5](http://www.w3.org/TR/html5/obsolete.html#non-conforming-features).
Но свойство `vertical-align` в CSS работает не совсем так. Но не в таблицах. Что, по-моему, достаточно странно, но я полагаю, это лучше, чем свойство, вообще не работающее в таблицах.
Итак, какова разница при использовании этого свойства в обычных элементах и ячейках таблиц?
Если `vertical-align` применяется НЕ к ячейкам таблиц, то оно работает по следующим правилам:
* Применимо только к `inline` или `inline-block` элементам;
* Не влияет на содержимое элемента, а только меняет его положение относительно других `inline` и `inline-block` элементов
* На свойсто могут влиять настройки текста или шрифта, такие как `line-height` и размер смежных `inline` и `inline-block` элементов.
[Демо](http://codepen.io/SitePoint/pen/zGWpxy).
Свойство `vertical-align` установлено у поля ввода input. При нажатии на кнопки значение свойства меняется. Обратите внимание, что все эти значения различны.
Примите во внимание, что данная демка — лишь поверхностный взгляд на vertical-align. Более глубокое его рассмотрение можно изучить [тут](http://christopheraue.net/2014/03/05/vertical-align/).
Когда `vertical-align` применяется к ячейке таблицы, то оно работает совсем по-другому. В частности, данное свойство применяется и к содержимому ячеек.
[Демо](http://codepen.io/SitePoint/pen/KpoZdo).
Как показано в примере, для `vertical-align` есть только 4 варианта значения, которые применимы к ячейкам таблицы, кроме того значение `baseline` влияет и на ячейки того же уровня, что и ячейка, к которой свойство применено.
#### 6. Псевдо-элемент `::first-letter` умнее, чем вы думаете
Псевдо-элемент `::first-letter` позволяет вам стилизовать первую букву элемент (*примечание переводчика — привет, капитан!*), например, красиво выделить её как в [печатных книгах](https://en.wikipedia.org/wiki/Initial) много лет назад.
Браузеры достаточно хорошо поддерживают стандарт относительно этой «первой буквы». Впервые этот псевдо-элемент я увидел в твите [Matt Andrews](https://twitter.com/andrewsmatt/status/497704502167076864), хотя он явно подразуемевает, что это всё таки плохая «фишка». [Демо](http://codepen.io/SitePoint/pen/KpoZjE).
Это здорово, что 4 крупных браузера отображают этот псевдо-элемент одинаково, потому что, по-моему, это и есть правильный вариант отображения. Выглядело бы странным, если бы какой-нибудь символ, такой как одиночная скобочка, воспринимался как «первая буква» — это скорее можно было бы считать «первым символом», который достоин собственного нового псевдо-класса.
#### 7. Вы можете использовать «невалидные» символы в качестве разделителей в перечне классов элемента
Этот подход обсуждал [Ben Edvard в 2013 году](http://beneverard.co.uk/blog/using-slashes-within-the-html-class-attribute/), и, я думаю, стоит подробнее рассмотреть этот вопрос.
Ben писал об использование slash («/») в качестве разделителя HTML-классов по группам для того, чтобы сделать код более читаемым и проще сканируемым. Автор указывает, что несмотря на то, что неэкранированный slash является «невалидным» символом, браузеры его просто игнорируют, а не выдадут ошибку.
Допустим, у вас такой HTML-код:
```
```
При использовании slash-ей получается следующее:
```
```
Вы можете использовать любой символ (валидный или не очень) для получения того же эффекта:
```
```
Все перечисленные варианты работают нормально, в чем можно убедится, посмотрев [демо](http://codepen.io/SitePoint/pen/NqYyNe)
Конечно же, эти разделители не могут быть использованы в css-стилях как классы. Следующий код является неправильным и не применится к элементу:
```
./ {
color: blue;
}
```
Если вы вынуждены использовать подобные символы в названиях своих css-классов, то можно использовать [вот этот инструмент](https://mothereff.in/css-escapes). Таким образом, вышеуказанный код будет работать, если его преобразовать до такого:
```
.\/ {
color: blue;
}
```
Если продолжать эту тему, то Unicode-символы вообще не должны быть экранированы и можно творить разные безумные вещи:
```
. {
color: hotpink;
}
.★ {
color: yellow;
}
```
```
```
Кроме того, вы можете «экранировать» и эти символы тоже, вместо того чтобы использовать их напрямую. Следующие css-строки аналогичны предыдущим:
```
.\2665 {
color: hotpink;
}
.\2605 {
color: yellow;
}
```
#### 8. Количество повторов анимации может принимать дробные значения
При описании анимации можно использовать свойство `animation-itereation-count` для того, чтобы указать, какое количество раз анимация будет проиграна:
```
.example {
animation-iteration-count: 3;
}
```
Вышеуказанный код говорит, что анимация будет проигрываться 3 раза. Но, возможно, вы не знали, что можно указывать и дробные значения:
```
.example {
animation-iteration-count: .5;
}
```
В этом случае анимация будет проиграна лишь на половину первой итерации. В демо на [CodePen](http://codepen.io/SitePoint/pen/VLXQmM) верхнему кружку указано количество итераций 1, а нижнему — .5
Длительность итерации определяется не по изменению значений свойств во течение анимации, а именно по времени и с учетом сглаживания. В вышеупомянутом примере используется функция с линейной зависимостью от времени — `linear`.
Но [в этом примере](http://codepen.io/SitePoint/pen/PqRxov) уже применяется сглаживание:
Обратите внимание на то, что второй кружок прошел больше половины пути до остановки из-за другой временной функции.
Если вы разбираетесь в различных функциях сглаживания, то заметите, что при использовании `ease-in-out` второй кружок займет то же итоговое положение, что и при использовании `linear`.
#### 9. Анимация, записанная в краткой форме может не работать из-за своего названия
Некоторые разработчики заметили это случайно, хотя в спецификации есть соответствующее предупреждение. Давайте рассмотрим следующую анимацию:
```
@keyframes reverse {
from {
left: 0;
}
to {
left: 300px;
}
}
.example {
animation: reverse 2s 1s;
}
```
Заметьте, я использую название анимаци `reverse`. На первый взгляд, всё хорошо, но давайте посмотрим на [живой пример](http://codepen.io/SitePoint/pen/OVvayK).
Анимация не работает, т.к. `reverse` — валидное ключевое слово для свойства `animation-direction`. Так же анимация не будет работать при использовании в краткой форме в названии других ключевых слов. Но всё работает хорошо при использовании «полной» формы описания.
К ключевым словам-значениям `animation-direction`, «ломающими» анимации, стоит отнести и ключевые слова, относящиеся к [функциям сглаживания](http://drafts.csswg.org/css-transitions-1/#single-transition-timing-function), а так же `infinite`, `alternate`, `running`, `paused` и так далее.
#### 10. В селекторе можно указать диапазон элементов.
Не знаю, кто начал это первым использовать, но первым я увидел [это демо](http://bittersmann.de/samples/08-15) от [Gunnar Bittersmann](https://twitter.com/g16n). Допустим, у вас есть список из 20 элементов и нужно выбрать элементы с 7 по 14 включительно. Это можно сделать вот так:
```
ol li:nth-child(n+7):nth-child(-n+14) {
background: lightpink;
}
```
[Демо](http://codepen.io/SitePoint/pen/wamQGv).
В Safari из-за бага такой приём работать не будет. Однако, решение всё таки есть — Matt Pomaski починил это. Нужно всего лишь перечислить элементы выборки в другом порядке:
```
ol li:nth-child(-n+14):nth-child(n+7) {
background: lightpink;
}
```
Этот код использует цепочку связанных псевдо-классов. Хотя выражение немного запутанное, ключевые числа 7 и 14 в нём используются без изменений.
Постараюсь объяснить, как это работает. Первая часть выражения говорит: «выбрать седьмой элемент, а потом все ПОСЛЕ него». А вторая часть — «выбрать четырнадцатый элемент, а потом все ДО него». Т.к. части связаны, то на пересечении запросов получается требуемый диапазон.
Для более детального рассмотрения этой темы рекомендуется почитать [более раннюю статью](http://www.impressivewebs.com/css3-pseudo-class-expressions/).
#### 11. Псевдо-элементы могут быть применены к некоторым «пустым» элементам
Наверняка вы пробовали использовать псевдо-элементы с изображениями или input-ами. Но это не работает с «замещаемыми» элементами (*примечание переводчика — в [комментариях](http://habrahabr.ru/post/263169/#comment_8508761) к этому переводу [SelenIT2](https://habrahabr.ru/users/selenit2/) постарался объяснить, что же это за зверь такой*). Я думаю, многие разработчики предполагают, что пустые элементы (те, у которых нет закрывающего тега) так же попадают в эту категорию. Но это не так.
Вы можете использовать псевдо-элементы вместе с [некторыми пустыми элементами](http://www.w3.org/TR/html5/syntax.html#void-elements), которые не являются «замещаемыми». Например,
---
в [этом демо](http://codepen.io/SitePoint/pen/ZGxmpK).
Цветная область является тегом
---
и его двумя псевдо-элементами `::before` и `::after`. Интересно, что подобного результата не получилось добиться от тега
, который тоже не является «замещаемым». | https://habr.com/ru/post/263169/ | null | ru | null |
# Различия асинхронной и многопоточной архитектуры на примере Node.js и PHP
В последнее время наблюдается рост платформ, построенных на асинхронной архитектуре. На асинхронной модели построен самый быстрый в мире веб-сервер nginx. Активно развивается шустрый серверный javascript в лице Node.js. Чем же хороша эта архитектура? Чем она отличается от классической многопоточной системы? На эту тему было написано огромное множество статей, но полного понимания предмета они дали далеко не всем. Часто приходится наблюдать споры вокруг Node.js vs PHP+apache. Многие не понимают, почему некоторые вещи можно сделать на Node.js, но нельзя на PHP или наоборот — почему вполне правильный рабочий код на PHP сильно замедлится в Node.js, а то и повесит ее. В данной статье я бы хотел еще раз подробно объяснить разницу в их архитектуре. В качестве примеров двух систем, возьмем вебсервер с PHP и Node.js.
Многопоточная модель
--------------------
Эта модель известна каждому. Наше приложение создает некоторое количество потоков (пул), передавая каждому из них задачу и данные для обработки. Задачи выполняются параллельно. Если потоки не имеют общих данных, то у нас не будет накладных расходов на синхронизацию, что делает работу достаточно быстрой. После завершения работы поток не убивается, а лежит в пуле, ожидая следующей задачи. Это убирает накладные расходы на создание и удаление потоков. Именно по такой системе и работает вебсервер с PHP. Каждый скрипт работает в своем потоке. Один поток обрабатывает один запрос. Потоков у нас достаточно большое количество, медленные запросы забирают поток надолго, быстрые — обрабатываются почти мгновенно, освобождая поток для другой работы. Это не позволяет медленным запросам забирать все процессорное время, заставляя подвисать быстрые запросы. Но у такой системы есть определенные ограничения. Может возникнуть ситуация, когда к нам придет большое количество медленных запросов, например работающих с БД или файловой системой. Такие запросы заберут себе все потоки, что сделает невозможным выполнение других запросов. Даже если запросу нужно всего 1мс на выполнение — он не будет вовремя обработан. Это можно решить увеличением числа потоков, чтобы они могли обработать достаточно большое количество медленных запросов. Но к сожалению потоки обрабатываются ОС, ей же выделяется и процессорное время. Поэтому чем больше потоков мы создаем, тем больше накладных расходов на их обработку и тем меньше процессорного времени выделяется каждому потоку. Ситуация усугубляется самим PHP — блокирующие операции работы с БД, файловой системой, вводом-выводом так же тратят процессорное время, не выполняя в этот момент никакой полезной работы. Тут мы поподробнее остановимся на особенностях блокирующих операций. Представим себе такую ситуацию: у нас имеется несколько потоков. Каждый обрабатывает запросы, состоящие из 1мс обработки самого запроса, 2мс на доступ и получение данных из БД и 1мс рендеринга полученных данных. Всего на каждый запрос мы тратим, таким образом, 4мс. При отправке запросов к БД поток начинает ожидать ответа. Пока данные не вернутся — поток никакой работы выполнять не будет. Это 2мс простоя на запрос в 4мс! Да, мы не можем сделать рендеринг страницы, не получив данные из базы. Мы обязаны ждать. Но ведь при этом мы получаем 50% простоя процессора! А сюда сверху можно накинуть дополнительные расходы ОС на выделение процессорного времени каждому потоку. И чем потоков больше — тем больше этих расходов. В итоге мы получаем довольно большое время простоя. Это время напрямую зависит от длительности запросов к БД и файловой системе. Лучшее решение, которое позволяет нам полностью загрузить процессор полезной работой это переход к архитектуре, использующей неблокирующие операции.
Асинхронная модель
------------------
Менее распространенная модель, нежели многопоточная, но имеющая не меньшие возможности. Асинхронная модель построена на очереди событий (event-loop). При возникновении некоторого события (пришел запрос, выполнилось считывание файла, пришел ответ от БД) оно помещается в конец очереди. Поток, который обрабатывает эту очередь, берет событие с начала очереди, и выполняет связанный с этим событием код. Пока очередь не пуста процессор будет занят работой. По такой схеме работает Node.js. У нас имеется единственный поток, обрабатывающий очередь событий (с модулем cluster — поток будет уже не один). Почти все операции неблокирующие. Блокирующие тоже имеются, но их использование крайне не рекомендуется. Далее вы поймете почему. Возьмем тот же пример с запросом 1+2+1мс: из очереди сообщений берется событие, связанное с приходом запроса. Мы обрабатываем запрос, тратим 1мс. Далее делается **асинхронный неблокирующий** запрос к базе данных и управление сразу же передается дальше. Мы можем взять из очереди следующее событие и выполнить его. К примеру мы возьмем еще 1 запрос, проведем обработку, пошлем запрос к БД, вернем управление и проделаем то же самое еще один раз. И тут приходит ответ БД на самый первый запрос. Событие, связанное с ним помещается в очередь. Если в очереди ничего не было — он сразу же выполнится, данные отрендерятся и отдадутся назад клиенту. Если в очереди что-то есть — придется подождать обработку других событий. Обычно скорость обработки одного запроса будет сравнима со скоростью обработки многопоточной системой и блокирующими операциями. В худшем случае — на ожидание обработки других событий потратится время, и запрос обработается медленнее. Но зато в тот момент, пока система с блокирующими операциями просто ждала бы 2мс ответа, система с неблокирующими операциями успела выполнить еще 2 части 2х других запросов! Каждый запрос может выполняться чуточку медленнее в целом, но в единицу времени мы можем обработать гораздо больше запросов. Общая производительность будет выше. Процессор всегда будет занят полезной работой. При этом на обработку очереди и переходе от события к событию тратится гораздо меньше времени, чем на переключение между потоками в многопоточной системе. Поэтому асинхронные системы с неблокирующими операциями должны иметь не больше потоков, чем количество ядер в системе. Node.js изначально вообще работал только в однопоточном режиме, и для полного использования процессора приходилось вручную поднимать несколько копий сервера и распределять нагрузку между ними, например, с помощью nginx. Сейчас для работы с несколькими ядрами появился модуль cluster (на момент написания статьи все еще имеющий статус experimental). Вот тут и проясняется ключевое отличие двух систем. Многопоточная система с блокирующими операциями имеет большое время простоя. Чрезмерное количество потоков может создать много накладных расходов, недостаточное же количество может привести к замедлению работы при большом количестве медленных запросов. Асинхронное приложение с неблокирующими операциями использует процессорное время эффективнее, но более сложно при проектировании. Особенно сильно это сказывается на утечках памяти — процесс Node.js может работать очень большое количество времени, и если программист не позаботится об очистке данных после обработки каждого запроса, мы получим утечку, что постепенно приведет к необходимости перезагрузки сервера. Также существует асинхронная архитектура с блокирующими операциями, но она гораздо менее выгодна, что можно будет увидеть далее на некоторых примерах. Выделим особенности, которые необходимо учитывать при разработке асинхронных приложений и разберем некоторые ошибки, возникающие у людей при попытке разобраться с особенностями асинхронной архитектуры.
#### Не используйте блокирующие операции. Никогда
Ну по крайней мере пока не поймете полностью архитектуру Node.js и не сможете аккуратно работать с блокирующими операциями.
При переходе с PHP на Node.js у некоторых людей может возникнуть желание писать код в таком же стиле, как и раньше. Действительно, если нам надо сперва считать файл, и только потом приступить к его обработке, то почему мы не можем написать следующий код:
```
var fs = require('fs');
var data = fs.readFileSync("img.png");
response.write(data);
```
Этот код правильный и вполне рабочий, но он использует блокирующую операцию. Это значит что до тех пор, пока файл не будет прочитан, очередь сообщений обрабатываться не будет и Node.js будет просто висеть, не совершая никакой работы. Это полностью убивает основную идею. В то время, пока файл читается, мы могли бы выполнять другую работу. Для этого мы используем следующую конструкцию:
```
var fs = require('fs');
fs.readFile("img.png", function(err, data){
response.write(data);
});
```
Разберем ее подробнее: у нас происходит асинхронное чтение из файла, при вызове функции чтения управление сразу же передается дальше, Node.js обрабатывает другие запросы. Как только файл будет считан — вызывается анонимная функция, переданная в readFile вторым параметром. А точнее событие, связанное с ней, ложится в очередь и когда очередь доходит до нее — выполняется. Таким образом, мы не нарушаем последовательность действий: сперва считывается файл, потом обрабатывается. Но при этом мы не занимаем процессорное время ожиданием, а позволяем обрабатывать другие события в очереди. Это обстоятельство очень важно помнить, так как всего несколько неаккуратно вставленных синхронных операций могут сильно просадить производительность.
Используйте такой код, и вы безнадежно убьете event-loop:
```
var fs = require('fs');
var dataModified = false;
var myData;
fs.readFile("file.txt", function(err, data){
dataModified = true;
myData = data+" last read "+new Date();
});
while (true){
if(dataModified)
break;
}
response.write(myData);
```
Такой кусок кода будет занимать все процессорное время себе, не давая обработаться другим событиям. Пока проверка не завершится успешно, цикл будет повторяться, и никакой другой код не выполнится. Если вам необходимо дождаться какого-либо события то… используйте события!
```
var fs = require('fs');
var events = require('events');
var myData;
var eventEmitter = new events.EventEmitter();
fs.readFile("file.txt", function(err, data){
myData = data+" last read "+new Date();
eventEmitter.emit('dataModified', myData);
});
eventEmitter.on('dataModified', function(data){
response.write(data);
});
```
Опять-таки, этот код выполнится только после выполнения определенного условия. Только эта проверка не запускается в цикле — код, выполняющий наше условие, с помощью функции emit вызывает событие, на которое мы вешаем обработчик. Объект events.EventEmitter отвечает за создание и обработку наших событий. eventEmitter.on отвечает за выполнение кода, при возникновении определенного события.
На этих примерах можно увидеть, как неосторожное использование блокирующего кода останавливает обработку очереди событий и соответственно стопорит работу всего Node.js. Для предотвращения таких ситуаций используйте асинхронный код, завязанный на событиях. Используйте асинхронные операции вместо синхронных, используйте асинхронные проверки наступления некоторого события.
#### Не используйте больших циклов для обработки данных. Используйте события
Что произойдет, если у нас возникает необходимость использовать громадный цикл работы с данными? Что если у нас должен быть цикл, работающий в течении жизни всей программы? Как мы уже выяснили выше — большие циклы приводят к блокировке очереди. Когда потребность в цикле все же возникает, мы заменяем его на создание событий. Каждая итерация цикла создает событие для последующей итерации, положив его в очередь. Таким образом, мы пропустим все события, которые ждали в очереди своего часа и после их обработки приступим к новой итерации, не блокируя очередь.
```
function incredibleGigantCycle(){
cycleProcess();
process.nextTick(incredibleGigantCycle);
}
```
Данный код выполнит тело цикла и создаст событие для следующей итерации. Никакой блокировки очереди событий в таком случае не будет.
#### Не создавайте больших операций, занимающих много процессорного времени
Иногда возникает потребность в обработке громадного объема данных или выполнение ресурсоемкого алгоритма (хотя писать злой матан на Node.js — не лучшая идея). Такая функция может занимать много процессорного времени (скажем, 500мс) и пока она не выполнится, много маленьких запросов будут простаивать в очереди. Что делать если такая функция все-таки есть и отказаться от нее мы никак не можем? В таком случае выходом может стать разбиение функции на несколько частей, которые будут вызываться поочередно как события. Эти события будут ложиться в конец очереди, тогда как события сначала могут пройти, не дожидаясь, пока наш увесистый алгоритм выполнится полностью. В вашем коде не должно быть больших последовательных кусков, не разбитых на отдельные события. Конечно есть еще выход в виде создания своего модуля на си, но это уже из другой оперы, не относящейся к вопросам асинхронного проектирования.
#### Внимательно следите за тем, какой тип функции вы используете
Читайте документацию, для того чтобы понять используете ли вы синхронную или асинхронную, блокирующую или неблокирующую функцию. В Node.js принято именовать синхронные функции с постфиксом Sync. В асинхронных функциях обработчик события по завершению функции обычно передается последним параметром и именуется callback. Если же вы используете асинхронную функцию там, где хотели использовать синхронную, у вас могут возникнуть ошибки.
```
var fs = require('fs');
fs.readFile("img.png", function(err, data){
});
response.write(data);
```
Разберем данный код. Начинается неблокирующее считывание файла асинхронным способом. Управление сразу же передается дальше — записывается ответ пользователю. Но при этом файл еще не успел считаться. Соответственно мы отдадим пустой ответ. Не забывайте, что при работе с асинхронными функциями, код для обработки результата функции всегда должен располагаться внутри callback-функции. Иначе результат работы непредсказуем.
#### Разберитесь с преимуществами асинхронных запросов
Иногда встречаются вопросы, почему приходится писать «спагетти-код» на Node.js, постоянно вкладывая друг в друга callback'и, когда на PHP все идет четко последовательно? Ведь алгоритм и там и там один и тот же.
Разберем следующий код:
```
$user->getCountry()->getCurrency()->getCode()
```
и
```
user.getCountry(function(country){
country.getCurrency(function(currency){
console.log(currency.getCode())
})
})
```
И там и там обработка пойдет только после завершения всех 3х запросов. Но тут имеется существенное различие: в PHP наши запросы к базе будут блокирующими. Сперва выполняется первый запрос, имеется некоторое время простоя процессора. Потом второй запрос с простоем, аналогично третий. При асинхронной неблокирующей архитектуре мы посылаем первый запрос, начинаем выполнение каких-либо других операций, связанных с другими событиями. Когда запрос от БД возвращается — обрабатываем его, формируем второй, отсылаем, продолжаем обработку других событий. В итоге и там и там получим 3 последовательно выполненных запроса. Но в случае с PHP у нас будет некоторый простой процессора, тогда как Node.js выполнит еще некоторое количество полезного кода, и может даже успеет обработать несколько запросов, не требующих обращения к БД.
Заключение
----------
Такие особенности Node.js необходимо знать и понимать, иначе при переходе на него с PHP вы можете не только не улучшить производительность своего проекта, но и существенно ее ухудшить. Node.js это не только другой язык и другая платформа, это другой тип архитектуры. Если вы будете соблюдать все особенности асинхронной архитектуры — вы получите преимущества от Node.js. Если вы будете упорно продолжать писать свои программы так, как писали бы их на PHP — не ждите от Node.js ничего, кроме разочарования. | https://habr.com/ru/post/150788/ | null | ru | null |
# Гибкая авторизация с помощью Casbin и PERM. Практический пример
После написания предыдущей статьи по [языку PERM и библиотеке Casbin](https://habr.com/ru/post/539778/), возникли [вопросы](https://habr.com/ru/post/539778/#comment_22609026). Причем не у одного человека, и я хотел ответить сначала в комментарии, но понял, что объем материала выходит за рамки обычного комментария, поэтому изложу этот ответ в виде отдельной статьи.
Я долго не мог понять ту конкретную конструкцию, которая сидела в голове у вопрошающих, но в конечном итоге после уточняющих вопросов получил ответы, компиляцию которых приведу в цитате.
> А как с такими DSL решается задача «показать список объектов, которые я могу видеть? Надо же в SQL-запрос это как-то транслировать, не выгребать же все записи с БД.
>
>
>
> Есть интерфейс на сайте, показывающий список чего-либо. Скажем — статей в админке CMS. Статей с базе — десятки тысяч, но обычно пользователь имеет доступ только к десятку. Как достать из БД статьи, которые видны конкретному пользователю? Ну, если мы все правила что кому видно — вынули из кода в какой-то DSL?
>
> Другими словами — как написать запрос типа
>
>
>
> select \* from articles a
>
> join roles r on r.userId = currentUserId
>
> where article.owner = currentUserId
>
> OR (r.role in ['admin', 'supevisor']) — админ всего
>
> OR (r.domain = currentDomainId AND r.role in ['domain-admin', 'domain-supervisor']) — админ домена
>
>
>
> У меня такие правила в коде, в виде LINQ-выражений, и я такую задачу решать умею. А возникает такая задача даже чаще, чем «проверить есть ли доступ к одному выгруженному с память объекту»
Надеюсь, я правильно понял эту конструкцию и в ходе обратного реверсинженеринга, мне удалось вытащить исходные данные для решения данной задачи. Для начала обойдемся без использования мультитенатности (домены), так как они усложняют задачу и соответственно понимание. Пример их использования я приводил в прошлой статье.
Сначала я опишу ту реализацию, которая сидит в голове у вопрошающего, чтобы вы тоже ее понимали, а затем мы эту реализацию трансформируем в решение с использованием Casbin.
Описание задачи
---------------
У нас имеется CMS, в которую пользователи через админпанель могут добавлять статьи. В адмике пользователь с ролью `user` может видеть только свои статьи. Статьи других людей он не может видеть, если только ему не присвоена роль `admin` или `supervisor`. Пользователь с ролью `supervisor` может видеть и редактировать все статьи, а `admin` имеет все те же права что и `supervisor`, но кроме этого, еще может и удалять любые статьи.
### Структура, схема и содержимое БД:
Структура БД нашей CMS:
Содержимое таблицы пользователей — **Users**:
Пользователям присвоены следующие роли:
Содержимое таблицы — **Roles**:
Как мы видим, Piter является администратором, а Bob — супервизором. Alice обычный пользователь, может видеть, создавать и редактировать только свои статьи.
Содержимое таблицы со статьями — **Articles**:
Исходя из вопроса, выборка осуществляется для администратора (Piter, id=3) таким образом:
```
select * from articles a
left join roles r on r.userId = 3
where a.owner = 3
OR (r.role in ('admin', 'supevisor'))
```
Выборка для супервизора (Bob, id=2) таким образом:
```
select * from articles a
left join roles r on r.userId = 2
where a.owner = 2
OR (r.role in ('admin', 'supevisor'))
```
А выборка для пользователя (Alice, id=1) выглядит так:
```
select * from articles a
left join roles r on r.userId = 1
where a.owner = 1
OR (r.role in ('admin', 'supevisor'))
```
Давайте теперь попробуем использовать другой подход к авторизации, на базе библиотеки Casbin.
Подход с использованием Casbin
------------------------------
Для начала давайте определимся что ресурс в подходе PERM — это не столько ***экземпляр сущности***, сколько сама **сущность**.
Т.е. когда мы описываем модель авторизации, под ресурсом в нашем примере подразумевается сама сущность (таблица) Статья. А не конкретная запись из этой таблицы (с Id=1 например).
Дальше необходимо уточнить, что те роли, которые используются в описании этой задачи — это не классические роли из подхода RBAC.
Роли RBAC описывают те разрешения, которые можно выполнить с сущностью. Например в классическом RBAC роль `user` могла бы только читать статьи, роль `author` могла бы наследовала роль `user` (т.е. чтение статей), и еще могла бы редактировать и создавать новые статьи, а роль `admin` могла бы наследовать все предыдущие разрешения и плюс еще удалять статьи.
В описанной же нами выше задаче, по сути, все эти все роли не отличаются друг от друга. И `user` и `supervisor` и `admin` имеют одни и те же права, один набор разрешений — каждый носитель любой из ролей может создавать, редактировать или удалять статьи. Разница только в области видимости, `user` может видеть в админке только свои статьи, и соответственно редактировать их и удалять. А `admin` и `supervisor` не только свои, но еще и чужие.
И в этом заключается большой минус модели RBAC, так это статичная модель авторизации, и с ее помощью вообще невозможно выразить бизнес-правила, в которых используются атрибуты, значения которых заранее не известны и вычисляются в процессе работы.
Об этом подробно уже было рассказано в статье [Подходы к контролю доступа: RBAC vs. ABAC](https://habr.com/ru/company/custis/blog/248649/)
А те роли, что мы используем (`user`, `supervisor`,`admin`) — это так называемые — `динамические роли`. Термин не официальный, и зачастую каждый подразумеваем под ним свое. Они реализуются различными способами, и описанное вопрошающим решение, которое я привел в начале статьи — один из таких подходов.
### Выборка значений с учетом "динамических ролей"
Для начала давайте определим модель политики RBAC (`rbac_model.conf`), ее [подробное описание](https://habr.com/ru/post/539778/#primer-2-kontrol-dostupa-na-osnove-roley-rbac) я привел в предыдущей статье:
```
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[role_definition]
g = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act
```
Далее, мы убираем таблицу ролей **Roles**. Роли у нас теперь будут описаны в хранилище политик. Это может быть как обычный `*.csv` файл, так и таблица в базе данных. Для простоты я буду использовать cvs файл `rbac_policy.csv`:
```
p, user, article, read
p, user, article, modify
p, user, article, create
p, user, article, delete
g, supervisor, user
g, admin, supervisor
g, 1, user
g, 2, supervisor
g, 3, admin
```
Суть здесь такая, что мы даем роли `user` права на чтение, модификацию, создание и удаление статей. Затем роль `supervisor` наследует права роли `user.` А роль `admin` наследует права роли `supervisor`.
Далее пользователю alice(1) мы присваиваем роль `user`, bob(2) у нас `supervisor`, а piter(3) — `admin`.
В принципе этого достаточно, чтобы решить проблему, которую описывал автор вопроса.
Этот код конечно не для продакшена, а для демонстрации. Для продакшена я советую использовать [cross-cutting concern](https://lurumad.github.io/cross-cutting-concerns-in-asp-net-core-with-meaditr) с [CQRS+MediatR](https://docs.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/microservice-application-layer-implementation-web-api)
```
public IList GetArticlesForAdminPanel(int currentUserId)
{
var e = new Enforcer("CasbinConfig/rbac\_model.conf", "CasbinConfig/rbac\_policy.csv");
var obj = "article";
var act = "read";
//Сначала проверяем, что пользователь имеет права на чтение статей
if (e.Enforce(currentUserId.ToString(), obj, act))
{
//Получаем список ролей пользователя
var currentUserRoles = e.GetRolesForUser(currentUserId.ToString());
//Проверяем, является ли пользователем админиом или супервизором
var isAdmin = currentUserRoles.Any(x => x == "admin" || x == "supervisor");
//Если админ, вернуть все записи, иначе только те, которые принадлежат пользователю
if (!isAdmin) return \_context.Articles.Where(x => x.OwnerId == currentUserId).ToList();
else return \_context.Articles.ToList();
}
else
{
// отклонить запрос, показать ошибку
throw new Exception("403. У вас нет прав для чтения статей");
}
}
```
Тадам! Задача решена, ответ на вопрос дан.
Редактирование статей с учетом "динамических ролей"
---------------------------------------------------
Теперь же пойдем еще дальше. Мы получили список статей, отобразили в админке, и попытаемся отредактировать какую-нибудь статью. И нам соответственно надо проверить, имеем ли мы права чтобы ее отредактировать, пользователь с ролью `user` может отредактировать только свои статьи, `supervisor` и `admin` могут отредактировать все статьи.
Для этого определяем новую модель, называем ее `rbac_with_abac_model.conf`:
```
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[role_definition]
g = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = (r.sub == r.obj.OwnerId.ToString() || g(r.sub, "supervisor")) && g(r.sub, p.sub) && r.act == p.act
```
Данная модель не сильно отличается от модели чтения, за исключением секции `[matchers]`, в ней мы конструкцию `r.obj == p.obj` заменили на `(r.sub == r.obj.OwnerId.ToString() || g(r.sub, "supervisor"))`. Это следует читать как *r.sub (id пользователя) должен совпадать с полем r.obj.OwnerId (id владельца обновляемой записи) или r.sub должен принадлежать группе "supervisor"*. Поскольку группа `admin` наследует все права группы `supervisor` то и члены группы `admin` будут соответствовать этому правилу.
Файл с политиками остается прежним, его мы не меняем. Теперь смотрим как это выглядит в коде:
```
public void UpdateArticle(int currentUserId, Article newArticle)
{
var e = new Enforcer("CasbinConfig/rbac_with_abac_model.conf", "CasbinConfig/rbac_policy.csv");
var act = "modify";
//Проверяем, что пользователь имеет права на редактирование статьи
if (e.Enforce(currentUserId.ToString(), newArticle, act))
{
//Обновляем, и сохраняем изменения
_context.Articles.Update(newArticle);
_context.SaveChanges();
}
else
{
// отклонить запрос, показать ошибку
throw new Exception("403. Недостаточно прав");
}
}
```
Здесь стоит обратить внимание на то, что мы в метод `e.Enforce` передаем вторым параметром объект, который представляет из себя экземпляр класса `Article`.
Ну и последний шаг — попытаемся удалить статью.
Удаление статьи
---------------
Бизнес-правило у нас здесь такое, что пользователь с ролью `user` может удалить свою статью, `supervisor` — не имеет прав удалять чужие статьи, а `admin` такое право имеет.
Опишем теперь это бизнес-правило в модели политики PERM, в файле `delete_model.conf`:
```
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[role_definition]
g = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = (r.sub == r.obj.OwnerId.ToString() || g(r.sub, "admin")) && g(r.sub, p.sub) && r.act == p.act
```
Она не сильно отличается от предыдущей политике редактирования, за тем исключением, что удалять чужие статьи мы разрешили только роли `admin`. Если носитель роли `supervisor` попытается удалить чужую статью, у него выйдет ошибка превышения полномочий.
Как и в случае с моделью, код мало чем отличается от предыдущего примера на редактирование:
```
public void DeleteArticle(int currentUserId, Article deleteArticle)
{
var e = new Enforcer("CasbinConfig/delete_model.conf", "CasbinConfig/rbac_policy.csv");
var act = "delete";
//проверяем, что пользователь имеет права на удаление статьи
if (e.Enforce(currentUserId.ToString(), deleteArticle, act))
{
//Удаляем статью
_context.Articles.Remove(deleteArticle);
_context.SaveChanges();
}
else
{
// отклонить запрос, показать ошибку
throw new Exception("403. Недостаточно прав");
}
}
```
Резюме
------
Надеюсь, данный пример продемонстрировал гибкость, универсальность и удобство использования **библиотеки Casbin и языка PERM** для построения решений по разделению доступа и авторизации.
Еще отмечу, что как сами модели политики, так и правила политики могут храниться в БД. И предусмотрена [возможность фильтрации правил](https://casbin.org/docs/en/policy-subset-loading), если их большое множество, и это может стать узким местом в высоконагруженных приложениях.
Casbin под капотом использует библиотеку [DynamicExpresso.Core](https://github.com/davideicardi/DynamicExpresso) для интерпретации простых выражений C# при сопоставлении правил политик с входными значениями, что позволяет эффективно использовать Casbin даже в самых сложных сценариях авторизации.
Не смотря на свою молодость, Casbin активно развивается, используется во множестве проектов, обрастает полезными инструментами и API. Такими например как [UI для управления политиками](https://casbin.org/docs/en/admin-portal).
Полностью работоспособный и самодостаточный код примера, который я использовал для написания данной статьи я [разместил у себя на Github](https://github.com/pprometey/casbin-demo), можете скачать и поиграться, если есть интерес и желание.
Полезные ссылки
---------------
* [Список адаптеров к хранилищам, где можно хранить правила политик](https://casbin.org/docs/en/adapters)
* [Способы загрузки модели политики в класс Enforcer](https://casbin.org/docs/en/model-storage)
* [Интеграция Casbin c ASP.NET Core, для авторизации через атрибуты контроллеров](https://github.com/casbin-net/casbin-aspnetcore) | https://habr.com/ru/post/540454/ | null | ru | null |
# PVS-Studio впечатлен качеством кода Abbyy NeoML
На днях компания ABBYY опубликовала исходный код своего фреймворка NeoML. Нам предложили проверить эту библиотеку с помощью PVS-Studio. Это интересный проект с точки зрения анализа, так что мы не стали откладывать его в долгий ящик. Чтение этой статьи не займет у вас много времени, так как проект оказался высокого качества :).
Исходный код [NeoML](https://www.abbyy.com/neoml/) можно найти на [GitHub](https://github.com/neoml-lib). Этот фреймворк является кроссплатформенным и предназначен для реализации моделей машинного обучения. Он используется разработчиками компании ABBYY для решения задач компьютерного зрения, обработки естественного языка, в том числе обработки изображений, анализа документов и так далее. В настоящее время поддерживаются такие языки программирования как C++, Java, Objective-C, и скоро к этому списку должен добавиться Python. Основной язык, на котором был написан сам фреймворк, это С++.
Запуск анализа
--------------
Запустить анализ на этом фреймворке было очень просто. После генерации проекта Visual Studio в CMake я запустила анализ PVS-Studio в Visual Studio на интересующие нас проекты из Solution, исключая сторонние библиотеки. Помимо самого NeoML в решении присутствовали еще такие библиотеки от ABBYY как NeoOnnx и NeoMathEngine. Их я также включила в список проектов, для которых запускался анализ.
Результаты анализа
------------------
Конечно же очень хотелось найти какие-нибудь страшные ошибки, но… код оказался достаточно чистым и предупреждений было получено всего-ничего. Вполне вероятно, что при разработке уже использовался статический анализ. Многие из предупреждений были срабатываниями одних и тех же диагностик на схожие участки кода.
Например, в этом проекте очень часто происходит вызов виртуального метода из конструктора. В целом это опасный подход. На такие случаи реагирует диагностика [V1053](https://www.viva64.com/ru/w/v1053/): *Calling the 'foo' virtual function in the constructor/destructor may lead to unexpected result at runtime*. В общей сложности было выдано 10 таких предупреждений. Подробнее о том, почему это опасная практика и какие проблемы она вызывает можно почитать в этой статье Скотта Майерса "[Never Call Virtual Functions during Construction or Destruction](https://www.artima.com/cppsource/nevercall.html)". Однако, по всей видимости разработчики понимают, что они делают, и ошибок здесь нет.
Также есть 11 предупреждений среднего уровня диагностики [V803](https://www.viva64.com/ru/w/v803/) из раздела "микрооптимизаций". Эта диагностика рекомендует заменить постфиксный инкремент на префиксный, если предыдущее значение итератора не используется. В случае постфиксного инкремента создается лишний временный объект. Конечно же это не является ошибкой, просто маленькая [деталь](https://www.viva64.com/ru/b/0093/). Если такая диагностика неинтересна, то при использовании анализатора можно её попросту выключить. Ну и в принципе, набор "микро-оптимизаций" и выключен по умолчанию.
Собственно, думаю вы понимаете, что раз мы дошли до разбора в статье таких мелочей, как инкремент итератора, то значит вообще всё хорошо и мы просто не знаем к чему попридираться.
Очень часто некоторые диагностики могут быть неприменимы или неинтересны для пользователя и лучше не есть кактус, а потратить немного времени на настройку анализатора. Подробнее о шагах, которые стоит предпринять для того, чтобы сразу подобраться поближе к наиболее интересным срабатываниям анализатора, можно почитать в нашей статье "[Как быстро посмотреть интересные предупреждения, которые выдает анализатор PVS-Studio для C и C++ кода?](https://www.viva64.com/ru/b/0633/)"
Среди срабатываний из раздела "микрооптимизаций" также есть интересные предупреждения диагностики [V802](https://www.viva64.com/ru/w/v802/), которая рекомендует расположить поля структуры по убыванию размеров типов, что позволяет снизить размер структуры.
[V802](https://www.viva64.com/ru/w/v802/) On 64-bit platform, structure size can be reduced from 24 to 16 bytes by rearranging the fields according to their sizes in decreasing order. HierarchicalClustering.h 31
```
struct CParam {
TDistanceFunc DistanceType;
double MaxClustersDistance;
int MinClustersCount;
};
```
Всего лишь поменяв местами поле *MaxClustersDistance* с типом *double* и перечислитель *DistanceType* можно снизить размер структуры с 24 до 16 байт.
```
struct CParam {
double MaxClustersDistance;
int MinClustersCount;
TDistanceFunc DistanceType;
};
```
*TDistanceFunc* это *enum*, так что его размер эквивалентен *int* или меньшему типу, поэтому его стоит перенести в конец структуры.
Опять же это не ошибка, но если пользователю интересно заняться микрооптимизациями или если они в принципе важны для проекта, такие срабатывания анализатора позволяют быстро найти места для хотя бы первичного рефакторинга.
В целом весь код написан аккуратно и разборчиво, но диагностика [V807](https://www.viva64.com/ru/w/v807/) указала на пару мест, которые можно сделать чуть более оптимальными и читабельными. Приведу наиболее наглядный пример:
[V807](https://www.viva64.com/ru/w/v807/) Decreased performance. Consider creating a reference to avoid using the same expression repeatedly. GradientBoostFullTreeBuilder.cpp 469
Обращение к *curLevelStatistics[i]->ThreadStatistics[j]* можно заменить на обращение к отдельной переменной. В этой цепочке нет вызова каких-то сложных методов, так что особой оптимизации здесь может и не будет, но код, на мой взгляд, будет читаться куда проще и выглядеть компактнее. К тому же, при поддержке этого кода в дальнейшем будет явно видно, что необходимо обращение именно по этим индексам и ошибки здесь нет. Для наглядности приведу код с заменой на переменную:
```
auto threadStatistics = curLevelStatistics[i]->ThreadStatistics[j];
if(threadStatistics.FeatureIndex != NotFound ) {
if( threadStatistics.Criterion > criterion
|| ( .... ))
{
criterion = threadStatistics.Criterion;
curLevelStatistics[i]->FeatureIndex = threadStatistics.FeatureIndex;
curLevelStatistics[i]->Threshold = threadStatistics.Threshold;
curLevelStatistics[i]->LeftStatistics = threadStatistics.LeftStatistics;
curLevelStatistics[i]->RightStatistics = threadStatistics.RightStatistics;
}
}
```
Заключение
----------
Как видите, с точки зрения статического анализа, кодовая база этого фреймворка оказалось очень чистой.
Стоит понимать, что один запуск анализа на активно разрабатываемый проект слабо отражает необходимость в статическом анализе, так как многие ошибки, особенно если они были критическими, уже были обнаружены и другими путями, но куда более затратными по времени и ресурсам. Чуть подробнее этот момент был разобран в статье "[Ошибки, которые не находит статический анализ кода, потому что он не используется](https://www.viva64.com/ru/b/0639/)".
Но даже с учетом этого факта, на NeoML было выдано мало предупреждений, и я хочу выразить уважение качеству кода в этом проекте, вне зависимости от того использовался ли разработчиками статический анализ или нет.
[](https://www.viva64.com/en/b/0746/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Victoria Khanieva. [PVS-Studio Impressed by the Code Quality of ABBYY NeoML](https://www.viva64.com/en/b/0746/). | https://habr.com/ru/post/509182/ | null | ru | null |
# Интеграция Siri или «Вот что мне удалось найти в вашем приложении»
На WWDC 2016 Apple представила миру SiriKit — API для работы с голосовым помощником.
Если вы не смотрели [WWDC сессию про SiriKit](https://developer.apple.com/videos/play/wwdc2016/217/) и ждёте, что сможете использовать Siri в любом приложении, то вам стоит знать, что на данный момент поддерживается всего несколько типов сервисов:
1) Аудио и видео вызовы,
2) Сообщения,
2) Платежи,
3) Поиск фото,
4) Тренировки,
5) Поездки (бронирование).
Также, как гласит документация, существуют возможность взаимодействия с автомобилем с помощью CarPlay (INSetClimateSettingsInCarIntent, INSetSeatTemperatureInCarIntent, etc.).
Таким образом, Siri можно дать команду "<позвони тому-то, отправь сообщение, поищи фото, etc.> через <название вашего приложения>".
Все устроено таким образом, что взаимодействовать напрямую с нейросетью не придется — SDK предоставляет простые протоколы и набор легковесных классов для передачи информации в методах. Разработчику остается только реализовать эти протоколы.
Для ленивых в конце статьи ссылка на демо-приложение (отправляем с помощью Siri сообщение своим друзьям из ВК).
Краеугольный камень SiriKit — Intent (андроид-разработчики, привет!). Объект класса INIntent (или его наследников) — это входные данные, которые генерирует Siri. Сам INIntent не содержит в себе ничего помимо идентификатора. Роль контекста делегирована его сабклассам. Конкретный сабкласс зависит от типа приложения. Например, для приложения с тренировками INStartWorkoutIntent содержит информацию о цели — сколько времени нужно провести за тем или иным упражнением, где происходит тренировка и так далее. Для фото сервиса можно использовать интент INSearchForPhotosIntent, в котором содержится геотег (CLPlacemark), дата создания фото, список людей на фото и т.д.
Для обработки входящего интента разработчику понадобится создавать объекты класса INIntentResolutionResult (или его сабклассов).
Существует три стадии обработки входной информации:
* уточнение (resolve),
* подтверждение (confirm),
* выполнение действия (handle).
На каждой из этих стадий мы получаем интент и должны возвращать соответствующий INIntentResolutionResult.
Например, если мы разрабатываем приложение-месседжер, то на стадии уточнения мы однозначно определяем пользователей, которым мы отправляем сообщение (resolveRecipientsForSendMessage), содержимое сообщения (resolveContentForSendMessage). На стадии подтверждения мы проверяем (confirmSendMessage), что все готово для отправки (например, пользователь авторизован). И наконец, на стадии выполнения (handleSendMessage), мы отправляем сообщение выбранным адресатам.
На любом этапе есть два варианта развития сценария: позитивный и негативный. Выбор пути делегирован разработчику: Siri предоставляет обработанные данные в виде объекта интента, а какой результат вернуть системе решает программист.
### Intents Extension
Чтобы ваше приложение поддерживало работу с Siri понадобится добавить в InfoPlist ключ NSSiriUsageDescription с текстом, поясняющим конечному пользователю, зачем вашему приложению доступ к Siri (по аналогии с NSLocationUsageDescription для геолокации).
И запросить permission:
```
[INPreferences requestSiriAuthorization:^(INSiriAuthorizationStatus status) {
}];
```
После этого нужно добавить в проект таргет с типом IntentsExtension.
После добавления таргета, обратите внимание на его структуру. Входная точка для интентов — объект класса INExtension. Внутри экземпляра класса в методе (handlerForIntent) выбирается какой объект будет обрабатывать входящий интент. В InfoPlist таргета прописываются название класса-наследника INExtension и поддерживаемые типы интентов. Также можно указать, какие из типов интентов будут недоступны на заблокированном экране.
Для обработки конкретного типа интента требуется реализовать специализированный протокол в вашем классе (например, INSendMessageIntentHandling). Протокол содержит в себе методы, необходимые для прохождения вышеописанных этапов (resolve, confirm, handle).
Рассмотрим реализацию класса обработчика для интента отправки сообщения.
Как было описано выше, на первом этапе (уточнение) требуется однозначно определить пользователей и содержимое сообщения. Если говорить о контенте сообщения, то в большинстве случаев достаточно знать, что оно не пустое. Но с адресатами не всё так просто. В интенте мы можем получить список пользователей, которых распознала Siri. Это массив объектов класса INPerson. Для каждого адресата необходимо найти соответствие в списке существующих адресатов.
Существует три варианта развития событий:
* соответствия нет — негативный сценарий;
* одно соответствие — однозначность подтверждена;
* более одного соответствия — нужно предоставить пользователю возможность выбрать правильный контакт из списка (INPersonResolutionResult -> disambiguationWithPeopleToDisambiguate).
**Примечание** — после выбора пользователя в случае disambiguation, повторно будет выполнен метод resolveRecipientsForSendMessage. При проверке совпадения пользователей нужно учитывать, что метод может быть вызван несколько раз.
На этапе подтверждения мы проверяем необходимые условия для возможности отправки сообщения. И наконец, в методе handleSendMessage (финальная стадия) выполняется отправка сообщения. На каждом из этапов есть позитивный и негативный сценарий работы.
Siri не всегда понимает, что мы хотим сказать. Чтобы ей помочь, можно использовать Vocabulary — словарь терминов. Они бывают двух видов: статические и динамические. В первом случае мы предоставляем специальный AppIntentVocabulary.plist, в котором записаны общие термины. Динамический словарь заполняется специализированными терминами для текущего пользователя:
```
[[INVocabulary sharedVocabulary] setVocabularyStrings:[usersNames copy] ofType:INVocabularyStringTypeContactName];
```
За словарь отвечает не Intent Extension, а основное приложение. То есть свои дополнительные термины нужно указать до запуска расширения Siri.
### Intents UI Extension
Помимо логики обработки данных, SiriKit предоставляет возможность изменить интерфейс отображения данных. Для этого существует Intents UI Extension. По аналогии с Intents Extension, InfoPlist UI-таргета содержит в себе список поддерживаемых интентов, а также название storyboard-файла.
**Примечание** — для любого интента в UI-расширении будет создан один и тот же контроллер (entry point в storyboard). Для делегирования логики отображения рекомендуется использовать дочерние контроллеры (child view controllers). Базовый контроллер должен поддерживать протокол INUIHostedViewControlling, в котором определен метод конфигурирования интерфейса — configureWithInteraction. Рассмотрим параметры этого метода.
* interaction (INInteraction) содержит интент и статус его обработки. По классу передаваемого интента мы можем инстанцировать соответствующий контроллер;
* context (INUIHostedViewContext) позволяет определить, используется ли Siri напрямую, или же задействуются Maps;
* completion (блок завершения), в который требуется передать размер (CGSize) отображаемого контроллера (сниппета). Размер ограничен минимумом (hostedViewMinimumAllowedSize) и максимумом (hostedViewMaximumAllowedSize), значения которых определены системой в категории NSExtensionContext (INUIHostedViewControlling).
Помимо основного протокола INUIHostedViewControlling, существует дополнительный протокол INUIHostedViewSiriProviding, который позволяет контролировать отображение стандартных интерфейсов Siri для сообщений (displaysMessage) и карт (displaysMap). В требованиях Apple по созданию интерфейсов для Siri есть запрет на отображение в сниппетах рекламы. Если вы планируете использовать анимацию, то рекомендуется выполнять её во viewDidAppear.
Для передачи данных между основным приложением и экстеншенами как и прежде нужно использовать Application groups (пример в демо).
### Скриншоты
### Ссылки
[SiriKit Programming Guide](https://developer.apple.com/library/prerelease/content/documentation/Intents/Conceptual/SiriIntegrationGuide/index.html)
[Демо-приложение](https://github.com/geor-kasapidi/Siri-VK-Demo) | https://habr.com/ru/post/303886/ | null | ru | null |
# Полезности Mercurial
Думаю, почти все читающие знают, что такое Mercurial — это распределённая система контроля версий, для исходного кода и других (преимущественно текстовых) файлов. Многие ей пользуются, и знают основные команды, как то удаление/добавление файлов, создание коммита и отправка локальных изменений в другие репозитории. Однако, Mercurial имеет множество не столь известных функций и команд, которые часто достаточно полезны и удобны. Некоторые из них можно использовать сразу после установки по-умолчанию, некоторые нужно включить в настройках, а для других может потребоваться скачать дополнительное расширение.
Краткий список того, о чём пойдёт речь в статье:
* hg serve (hgweb) — встроенный веб-сервер
* расширения pager, progress и color
* hg [c]record — выбор отдельных изменений для коммита
* revsets и filesets — поиск коммитов и файлов с запросами любой сложности
* hg evolve — Changeset Evolution или же «изменяемая история»
#### hg serve (hgweb)
В стандартную поставку Mercurial входит веб-сервер, который позволяет быстро просмотреть репозиторий с удобным интерфейсом в любом браузере — для этого достаточно, находясь в папке с репозиторием, выполнить `hg serve`, и зайти на `localhost:8000` (стандартный порт — 8000). Так можно просматривать почти всю информацию, которая доступна через обычный интерфейс командной строки. При этом с другого компьютера по сети можно использовать `hg clone` с адресом запущенного hgweb для клонирования.
Конечно, было бы странно, если бы веб-сервер можно было использовать только для этого — и это не так. Hgweb можно настроить так, чтобы он обрабатывал сразу несколько репозиториев, например из одной папки, а также поставить перед ним nginx или другой сервер (вариантов коммуникации хватает — обычный http через порт, или к примеру wcgi). Тонкости конфигурации рассмотрены в частности в официальной вики Mercurial. Важная функция, которой иногда не хватает в hgweb — авторизация пользователей и права на чтение/запись — также может быть реализована установкой и настройкой дополнительного frontend сервера. Например, я использую для этого обычную http-авторизацию в nginx, который запрещает любой неавторизованный доступ к приватным репозиториям, а также push в публичные.
Что касается внешнего вида, то в комплекте поставляется несколько тем на выбор, по-умолчанию используется «paper».
Примеры: [selenic.com/hg](http://selenic.com/hg) — официальный репозиторий, [hg.python.org](http://hg.python.org) — репозитории Python, [hg.aplavin.ru](https://hg.aplavin.ru) — мои (в основном) репозитории.
#### Расширения pager, progress, color
Эти расширения входят в установку Mercurial, и для использования достаточно включить их в настройках. Для этого нужно добавить в файл `~/.hgrc` секцию расширений:
```
[extensions]
pager =
progress =
color =
```
(да, после знаков равенства ничего нет). Эти расширения делают работу с CLI-интерфейсом несколько более удобной: выводы многих команд становятся цветными, во время длительных операций выводится прогрессбар, а длинные простыни команд вроде `hg log` можно прокручивать — они открываются в стандартном pager'e (обычно это `less`). К сожалению, страницы помощи (`hg help`) открываются как и раньше, и для их удобного просмотра нужно вручную дописывать `| less`. Эти расширения не включены по-умолчанию, как говорит автор Mercurial, из-за иногда встречающихся неожиданных проблем с ними, в частности на Windows.
#### hg [c]record
Часто после долгого редактирования исходников бывает удобнее разбить внесённые изменения на несколько коммитов, а не делать один большой. В стандартной поставке Mercurial для этого есть расширение `record`, которое достаточно просто включить в настройках для использования. После этого собственно для выбора изменений нужно будет выполнить `hg record` и в текстовом интерфейсе выбрать нужные части.
Однако, это расширение не очень удобное и подходит только для эпизодических правок. Если вы пользуетесь такой функцией чаще, лучше скачать и подключить другое расширение, не из стандартного комплекта: [crecord](https://bitbucket.org/edgimar/crecord/wiki/Home). Оно предоставляет достаточно удобный для использования псевдографический интерфейс (пример от его автора: ). Конечно, есть и полностью графические утилиты для этого (мне, например, понравилась [qct](http://qct.sourceforge.net/), написанная на Qt), но для простых правок прямо «на месте» в консоли crecord вполне удобен.
#### revsets
Mercurial использует язык запросов, который можно использовать для сколь угодно сложных критериев поиска коммитов, причём он поддерживается во всех командах, которые работают с коммитами (а скоро будет и в hgweb). Например, почти «классический» пример — есть некоторый коммит, в котором исправлен баг, и нужно найти релизы в которые этот багфикс попал. Предполагая, что для задания релизов используются теги (все проекты, которые видел, так и делают), такой запрос можно сформулировать как `'tag() and descendants(x)'` или `'tag() and x::'` (где `x` — идентификатор коммита). То есть, если выполнить `hg log 'tag() and x::'`, мы увидим все искомые релизы. Подробная информация о синтаксисе и всех имеющихся функциях — `hg help revsets` или [на официальном сайте](http://selenic.com/hg/help/revsets).
#### filesets
Filesets представляет собой также язык запросов, аналогичный revsets, но для задания файлов (для соответствующих команд, которые работают с файлами). Используется он почти аналогично, только в начале нужно добавлять `set:`, чтобы не было путаницы с обычными именами файлов. Что касается поддерживаемых функций, то они также есть в стадартной помощи: `hg help filesets`.
#### Changeset Evolution
Расширение [evolve](https://bitbucket.org/marmoute/mutable-history/overview) — экспериментальное, которое сейчас разрабатывает (в основном) один из членов команды Mercurial. Оно экспериментальное из-за пока ещё окончательно не решённых вопросов с UI и производительностью в некоторых случаях, а не из-за недостатка стабильности (вообще говоря, часть кода, связанного с его функциями, находится в самом Mercurial, но не работает по-умолчанию). В частности, это расширение используется в самом официальном репозитории Mercurial.
Changeset Evolution при подключение не только добавляет новые команды, но и изменяет поведение стандартных (и из других расширений) — тех, которые каким-либо образом редактируют историю: `commit --amend, rebase, histedit` и некоторые другие. При использовании `evolve` никакие коммиты полностью не удаляются из репозитория (за исключением команды `strip`, предназначенной как раз для полного удаления, которое всё же может пригодиться). Любое редактирование истории просто помечает более ненужные коммиты как удалённые (точнее, устаревшие — `obsolete`), а новые коммиты — как заменившие их. Таким образом, всегда можно найти любую версию изменения, которая когда-то раньше существовала.
Также, из дополнительных получаемых «плюшек» — возможность редактирования изменений, уже отправленных в публичный репозиторий. Причём те, кто имеет его локальную копию, при загрузке новых изменений также получат информацию об удалённых (устаревших) коммитах и их локальных репозитории так же изменятся (при условии, конечно, что у них тоже включено это расширение). Без `evolve` такого достить нельзя.
#### Заключение
Вообще, в Mercurial есть и другие «продвинутые» возможности, но в этой статье я постарался описать те из них, которые могут пригодиться многим пользователям, и которыми люди не пользуются часто из-за незнания. Также хотелось бы добавить, что в Mercurial очень строгая политика обратной совместимости — все вносимые изменения не затрагивают имеющуюся функциональность, а добавляют новую. Очень старая версия на сервере может работать с новым клиентом, и наоборот (разумеется, неподдерживаемые в старой версии функции работать не будут). Такая серьёзная обратная совместимость касается всех команд и функций, видимых пользователю, то есть внутреннее API может меняться (но без весомых причин этого тоже не делают).
Сам я использую Mercurial на базовом уровне уже несколько лет, а в этом году участвую в Google Summer of Code с [проектом](http://www.google-melange.com/gsoc/project/google/gsoc2013/aplavin/37001) улучшения `hgweb`. Попутно, общаясь с разработчиками, узнал и начал использовать в частности описанные в этой статье функции. | https://habr.com/ru/post/188418/ | null | ru | null |
# Негативный опыт заказа iPhone 4 в Apple Store UK — как разочаровать клиента
Решил поделиться впечатлениями от заказа нескольких iPhone 4 в английском Apple Store, больно и обидно ударившим меня сразу об четыре бампера.
Все начиналось хорошо: сайт Apple Store предлагал немедленно приобрести iPhone 4 и получить его уже через 3 недели.
Выбрав из опций легендарный фирменный бампер, я не мешкая добавил iPhone в корзину.
Для удовлетворения потребностей коллектива, мне требовалось шесть штук и я поправил количество.
«Дефицит» не без гордости подумал я, увидев проявившееся сообщение:
«A maximum of 2 iPhones can be purchased per customer order. Please adjust the total quantity of iPhones to continue».
Что делать, раз только две штуки в одном заказе можно — сделаем три заказа по две штуки.
Тут мне подумалось, что могут потребоваться логины сотрудников, если Apple Store не позволит сделать несколько заказов на один логин, но все прошло без проблем. Деньги с кредитки списались, через пару часов на почту пришли три подтверждения.
Поставку обещают через три недели. Ждем с нетерпением.
Прошла **неделя**. Сегодня приходят письма, что два заказа из трех аннулированы:
`Dear ...,
Thank you for your interest in Apple Products.
To ensure that all customers are given equal opportunity to acquire this product, we have limited the amount available per customer. Our records indicate you have placed a previous order. Therefore this Order has been cancelled.
We apologise for any inconvenience caused.
Kind regards,
The Apple Store`
С легким раздражением пишу вежливый ответ ~~чемберле~~ Apple Store, с просьбой восстановить заказы, ибо для живых людей заказано, а не чтобы солить.
Через пару часов в ящике пара новых сообщений с заголовками «Your Apple Order W123456 Has Been Shipped».
Не верю своим глазам, заглядываю внутрь и ужасаюсь: мне высланы **четыре фирменных бампера БEЗ iPhone'ов**.
Такого глубокого разочарования я не испытывал давно. Что было не так и чего я, как клиент, ожидал бы:
— Списали с кредитки 3750 фунтов сразу, хотя поставка ожидается только через три недели.
Имело бы смысл зарезервировать товар, проинформировать клиента о поступлении и, только потом, предложить оплатить.
— Подтвердили заказ, и аннулировали его через неделю.
Я бы ожидал, что любые проверки соблюдения условий происходят до подтверждения заказа.
— Заказ аннулировали, а деньги пока не вернули — неделя времени уже потеряна, а трехнедельный срок будет считаться снова. Для нового заказа необходимо выложить дополнительные деньги.
— Аннулировали заказ выборочно по своему усмотрению, не смотря на опцию «Items will be shipped when all items are available».
Тут у них железная логика: в заказе были iPhone (нет в наличии) и бампер. iPhone аннулировали, а вместе с ним, и единственное препятствие на пути клиента к заветному бамперу.
Вот оно, кем яблоко-то надкусано… | https://habr.com/ru/post/98641/ | null | ru | null |
# Беспроводные локальные сети или как работает Wi-Fi по стандарту IEEE 802.11. Лабораторная работа в Packet Tracer
**Введение**
В данной статье в лабораторных работах изучается технология беспроводных локальных сетей по стандарту IEEE 802.11. Стандарт IEEE был разработан институтом инженеров по электротехнике и электронике (Institute of Electrical and Electronic Engineers). Отсюда он и получил своё название. Данный стандарт определяет локальные сети Ethernet; поэтому модель TCP/IP не определяет сети Ethernet в своих запросах на комментарии, а ссылается на документы IEEE Ethernet. Все работы будут выполняться в программе Cisco Packet Tracer.
**Концепция беспроводных сетей**
Многие пользователи регулярно пользуются услугами и устройствами беспроводных локальных сетей (Wireless LAN — WLAN). На текущий момент времени растёт тенденция использования портативных устройств, таких как ноутбуки, планшеты, смартфоны. Также сейчас активно развиваются концепции «умного дома», большинство устройств которого подключаются «по воздуху». В связи с этим возникла потребность беспроводного подключения во всех людных местах: на работе, дома, в гостинице, в кафе или книжном магазине. С ростом количества беспроводных устройств, которые подключаются через сеть WLAN, выросла популярность беспроводных сетей.
Ниже представлена упрощённая схема работы сети в «Доме книги» на Невском проспекте в Санкт-Петербурге.
Портативные компьютеры посетителей взаимодействуют с устройством WLAN, называемым беспроводной точкой доступа (Access Point). Точка доступа использует радиоканал для отправки и получения фреймов (отдельных, законченных HTML-документов, которые вместе с другими HTML-документами могут быть отображены в окне браузера) от клиентского устройства, например, компьютера. Кроме того, точка доступа подключена к той же сети Ethernet, что и устройства, обеспечивающие работу магазина, следовательно, и покупатели, и сотрудники могут искать информацию на дистанционных веб-сайтах.
**Сравнение беспроводных локальных сетей с локальными сетями**
Беспроводные локальные сети во многом похожи с локальными сетями, например, оба типа сетей позволяют устройствам взаимодействовать между собой. Для обеих разновидностей сетей работает стандарт IEEE (IEEE 802.3 для сетей Ethernet и 802.11 — для беспроводных сетей). В обоих стандартах описан формат фреймов сети (заголовок и концевик), указано, что заголовок должен иметь длину 6 байтов и содержать МАС-адреса отправителя и получателя. Оба стандарта указывают, как именно устройства в сети должны определять, когда можно передавать фрейм в среду, а когда нельзя.
Основное отличие двух типов сетей состоит в том, что для передачи данных в беспроводных сетях используется технология излучения энергии (или технология излучения радиоволн), а в сетях Ethernet используется передача электрических импульсов по медному кабелю (или импульсов света в оптическом волокне). Для передачи радиоволн не нужна специальная среда работы, обычно говорят, что «связь происходит по воздуху», чтобы подчеркнуть, что никакой физической сети не надо. В действительности любые физические объекты на пути радиосигнала (стены, металлические конструкции и т.п.) являются препятствием, ухудшающим качество радиосигнала.
**Стандарты беспроводных локальных сетей**
IEEE определяет четыре основных стандарта WLAN 802.11: 802.11a, 802.11b, 802.11g и 802.11n.
Наибольшее влияние на стандарты беспроводных сетей оказали следующие четыре организации (см. таблицу ниже)
**Сравнение стандартов WLAN**
**Термины** — DSSS (Direct sequence spread spectrum — Метод прямой последовательности для расширения спектра)
— OFDM (Orthogonal frequency-division multiplexing — мультиплексирование с ортогональным частотным разделением каналов)
Помимо основных стандартов из таблицы существуют дополнительные стандарты, которые указаны ниже.
**Дополнительные стандарты**• **802.11** — изначальный 1 Мбит/с и 2 Мбит/c, 2,4 ГГц и ИК стандарт (1997).
• **802.11c** — процедуры операций с мостами; включен в стандарт IEEE 802.1D (2001).
• **802.11d** — интернациональные роуминговые расширения (2001).
• **802.11e** — улучшения: QoS, пакетный режим (packet bursting) (2005).
• **802.11h** — распределённый по спектру 802.11a (5 GHz) для совместимости в Европе (2004).
• **802.11i** — улучшенная безопасность (2004).
• **802.11j** — расширения для Японии (2004).
• **802.11k** — улучшения измерения радиоресурсов.
• **802.11l** — зарезервирован.
• **802.11m** — поправки и исправления для всей группы стандартов 802.11.
• **802.11o** — зарезервирован.
• **802.11p** — WAVE — Wireless Access for the Vehicular Environment (беспроводной доступ для среды транспортного средства).
• **802.11q** — зарезервирован, иногда его путают с 802.1Q.
• **802.11r** — быстрый роуминг.
• **802.11s** — ESS Wireless mesh network[en] (Extended Service Set — расширенный набор служб; Mesh Network — многосвязная сеть).
• **802.11u** — взаимодействие с не-802 сетями (например, сотовыми).
• **802.11v** — управление беспроводными сетями.
• **802.11w** — Protected Management Frames (защищенные управляющие фреймы).
• **802.11x** — зарезервирован и не будет использоваться. Не нужно путать со стандартом контроля доступа IEEE 802.1X.
• **802.11y** — дополнительный стандарт связи, работающий на частотах 3,65-3,70 ГГц. Обеспечивает скорость до 54 Мбит/с на расстоянии до 5000 м на открытом пространстве.
• **802.11ac** — новый стандарт IEEE. Скорость передачи данных — до 6,77 Гбит/с для устройств, имеющих 8 антенн. Утверждён в январе 2014 года.
• **802.11ad** — новый стандарт с дополнительным диапазоном 60 ГГц (частота не требует лицензирования). Скорость передачи данных — до 7 Гбит/с
Также присутствуют две рекомендации. Буквы при них заглавные.
• **802.11F** — Inter-Access Point Protocol (протокол обмена служебной информацией для передачи данных между точками доступа. Данный протокол является рекомендацией, которая описывает необязательное расширение IEEE 802.11, обеспечивающее беспроводную точку доступа для коммуникации между системами разных производителей).
• **802.11T** — Wireless Performance Prediction (WPP, предсказание производительности беспроводного оборудования) — методы тестов и измерений (метод представляет собой набор методик, рекомендованных IEEE для тестирования сетей 802.11: способы измерений и обработки результатов, требования, предъявляемые к испытательному оборудованию).
Основные устройства и условные знаки в работе с Wi-Fi
1. Точка доступа – это беспроводной «удлинитель» проводной сети
2. Роутер – это более «умное» устройство, которое не просто принимает и передает данные, но и перераспределяет их согласно различным установленным правилам и выполняет заданные команды.
3. Облако – настроенная часть сети
4. Wi-Fi соединение
5. Прямая линия — кабель (витая пара)
**Основные способы использования Wi-Fi**
1. **Wi-Fi мост** – соединение двух точек доступа по Wi-Fi
2. **Wi-Fi роутер** – подключение всех устройств к роутеру по Wi-Fi (вся сеть подключена беспроводным способом).
3. **Wi-Fi точка доступа** – подключение части сети для беспроводной работы
**Задания лабораторной работы.**
1. Создать и настроить второй и третий вариант использования Wi-Fi в Cisco Packet Tracer.
2. Настроить мост между двумя точками доступа (первый вариант использования Wi-Fi) на реальном оборудовании.
**Выполнение лабораторной работы.**
**Задание №1 (вариант сети №2)**
1. Создадим на рабочем поле Packet Tracer Wi-Fi маршрутизатор (он же Wi-Fi роутер)
2. Создадим маршрутизатор от провайдера (допустим, название провайдера – «Miry-Mir»). Я выбрал маршрутизатор Cisco 1841.
3. Соединяем их кросс-кабелем (пунктирная линия), так как устройства однотипные (роутеры). Соединяем так: один конец в Router1 в FastEthernet 0/0, а другой конец в Wireless Router0 в разъём Internet, так как Router1 раздаёт нам Интернет.
4. Настроим Интернет роутер (Router1) для работы с сетью. Для этого перейдём в настройки роутера дважды кликнув по нему и перейдём во вкладку CLI (Command Line Interface).
В диалоге «Would you like to enter the initial configuration dialog? [yes/no]:» (Вы хотите войти в начальное диалоговое окно конфигурации) пишем «no».
Пишем следующую последовательность команд:
`Router>en
Router#conf t
Router(config)#int fa0/0
Router(config-if)#ip address 120.120.0.1 255.255.255.0
Router(config-if)#no shut
Router(config-if)#end
Router#wr mem`
По традиции, рассмотрим их по порядку.
> 1) En – enable. Расширенный доступ к конфигурации
>
> 2) Conf t – Configuration terminal. Открывает терминал настройки
>
> 3) int fa0/0 – interface fastEthernet0/0. Переходим к настройки указанного порта (в нашем случае к fastEthernet0/0)
>
> 4) ip address 120.120.0.1 255.255.255.0 – задаётся IP адрес и его маска. Адрес – 120.120.0.1 (допустим, это адрес нам дал провайдер), маска – /24.
>
> 5) no shut – no shutdown. Включить, настроенный нами, интерфейс
>
> 6) End – завершения настройки.
>
> 7) wr mem – write memory. Сохранение конфигураций.
Соединение установлено.
5. Настроим беспроводной роутер (Wireless Router0) для работы с сетью. Для этого, как и в случае с предыдущим роутером, перейдём в настройки роутера дважды кликнув по нему. Во вкладках выберем графический интерфейс пользователя (GUI — graphical user interface). Такой режим будет отображён при вводе в любом браузере адреса роутера.
Выставим следующие настройки:
`Internet Connection Type – Static IP
Internet IP Address – 120.120.0.2
Subnet Mask – 255.255.255.0
Default Gateway – 120.120.0.1
Router IP – 192.168.0.1
Subnet Mask (Router IP) – 255.255.255.0
Start IP Address – 192.168.0.100
Maximum numbers of Users – 50`
И внизу страницы нажимаем кнопку **«Save settings»**
Разбор настроек:
Мы выбрали статический IP, так как провайдер выдал нам белый IP адрес (120.120.0.1/24). Путь по умолчанию (Default Gateway) – это адрес роутера от провайдера. Адрес роутера со стороны беспроводных устройств – 192.168.0.1/24. Роутер будет раздавать IP с 100 по 150.
6. Переходим во вкладку Wireless, то есть беспроводное подключение.
Выставляем следующие настройки:
`Network Mode – Mixed
Network Name (SSID) – Habr
Radio Band – Auto
Wide Channel – Auto
Standard Channel – 1 – 2.412GHz
SSID Broadcast – Disabled`
И внизу страницы нажимаем кнопку **«Save settings»**
Разбор настроек:
> Режим работы роутера мы выбрали смешанный, то есть к нему может подключиться любое устройство, поддерживающее типы роутера (в эмуляторе Cisco Packer Tracer – это g, b и n). Имя сети мы выставили Habr. Ширину канала роутер выберет сам (есть возможность выбрать либо 20, либо 40 мегагерц). Частота в эмуляторе доступна только 2,4GHz её и оставим. Имя сети мы скрыли, то есть устройства не увидят нашей сети Wi-Fi, пока не введут её название.
7. Настроим защиту нашего роутера. Для этого перейдём во вкладку Security и в пункте «Security Mode» выберем WPA2 Personal, так как WPA – уязвимая защита. Выбирать WPA2 Enterprise, тоже, не стоит, так как для ей работы нам потребуется радиус сервер, которым мы не занимались. Алгоритм шифрования оставляем AES и вводим кодовое слово. Я выставил Habrahabr.
8. Добавим 3 устройства, как на схеме (смартфон, ноутбук и компьютер). Затем заменим разъёмы под rj-45 на Wi-Fi антенну (в смартфоне по умолчанию антенна).
9. Во вкладке Config выстави настройки, которые выставлялись на роутере. Данную операцию необходимо проделать на всех устройствах.
10. Переходим на рабочий стол любого компьютера и открываем командную строку.
11. Проверим какие адреса роутер выдал устройствам. Для этого введём команду ipconfig.
Как видно на скриншоте, роутер выдаёт адреса от 192.168.0.100 до 192.168.0.150.
12. Проверяем работоспособность сети из любого устройства командой ping. Пинговать будем 2 адреса – адрес роутера (192.168.0.1) и белый адрес (120.120.0.1), то есть проверим сможет ли устройство выйти в Интернет.
Снова, всё работает.
В итоге у нас получилась Wi-Fi сеть, которая изображена во втором варианте использования
**Задание №1 (вариант сети №3)**
1. Откроем готовый [проект](https://drive.google.com/open?id=1Ykr6gTj5ugUl0LkZHZD54YBhJNOCtseq) из [предыдущей лабораторной работы](https://habrahabr.ru/post/351332/) по PAT.
2. Создадим точку доступа на рабочем поле программы и соединим её со свитчем. При желании точку доступа можно настроить (Port 0 – это физический порт, а Port 1 – беспроводной)
3. Создадим ещё один VLAN для беспроводной точки доступа.
4. Добавим в настройках роутера 0 VLAN 4, а также добавим его в access лист для выхода в интернет.
Так как это мы проделывали в предыдущих лабораторных работах (по [VLAN](https://habrahabr.ru/post/350720/) и [PAT](https://habrahabr.ru/post/351332/)), подробно останавливаться не буду, но пропишу все команды на устройствах
Свитч
`Switch>en
Switch#conf t
Switch(config)#vlan 4
Switch(config-vlan)#name Wi-Fi
Switch(config-vlan)#exit
Switch(config)#interface FastEthernet0/5
Switch(config-if)#switchport access vlan 4`
Роутер (сабинтерфейс)
`Router>en
Router#conf t
Router(config)#int fa0/1.4
Router(config-subif)#encapsulation dot1Q 4
Router(config-subif)#ip address 192.168.4.1 255.255.255.0
Router(config-subif)#no shutdown
Router(config-subif)#end`
Роутер (DHCP (Dynamic Host Configuration Protocol — протокол динамической настройки узла). Сетевой протокол, позволяющий компьютерам автоматически получать IP-адрес и другие параметры, необходимые для работы в сети TCP/IP)
`Router#conf t
Router(config)#ip dhcp pool Wi-Fi-pool
Router(dhcp-config)#network 192.168.4.0 255.255.255.0
Router(dhcp-config)#default-router 192.168.4.1
Router(dhcp-config)#exit
Router(config)#ip dhcp excluded-address 192.168.4.1
Router(config)#end`
Здесь остановлюсь поподробнее, так как ранее мы не встречались с данным параметром.
> Router(config)#ip dhcp pool Wi-Fi-pool – создание пула (набора) dhcp адресов
>
> Router(dhcp-config)#network 192.168.4.0 255.255.255.0 – сеть, в которой реализуется dhcp, и её маска
>
> Router(dhcp-config)#default-router 192.168.4.1 – адрес по умолчанию (он же адрес роутера)
>
> Router(config)#ip dhcp excluded-address 192.168.4.1 – исключение адреса роутера из раздачи по dhcp
Роутер (access лист)
`Router(config)#ip access-list standard HABRAHABR
Router(config-std-nacl)#permit 192.168.4.0 0.0.0.255
Router(config-std-nacl)#exit
Router(config)#int fa0/1.4
Router(config-subif)#ip nat inside
Router(config-subif)#end`
Добавим смартфон на рабочую область Packet Tracer и пропингуем ПК, сервер и Интернет, то есть 192.168.2.2, 192.168.3.2, 120.120.53.1.
Как видно, всё работает.
**Задание №2 (вариант сети №1)**
К сожалению, в Packet Tracer нет возможности создать Wi-Fi мост (он же репитер или повторитель), но мы сделаем это простое действие на реальном оборудовании в графической среде.
Оборудование, на котором будут проводиться настройки – роутер ASUS RT-N10 и, так называемый, репитер TP-LINK TL-WA850RE.
Перейдём к настройке роутера Asus. Для этого откроем браузер и введём адрес роутера (по умолчанию он сам откроется)
Переходим во вкладку «Беспроводная сеть» и выставим настройка как на скринжоте ниже.
Переходим во вкладку «ЛВС» (локальная вычислительная сеть) и выставляем следующие настройки.
Переходим в главную вкладку. Там мы можем посмотреть наш MAC-адрес
Переходим к настройке репитора TP-LINK
Нам автоматически устройство выдаст главное меню и режим быстрой настройки. Нажмём «Выход» и выполним настройку сами.
Переходим во вкладку «Сеть» и выставим следующие настройки.
Переходим во вкладку «Беспроводной режим» и настраиваем входной и выходной поток.
Во вкладке «Профиль» мы видим все созданные нами профили. Нажмём кнопку «Изменить»
Настроим безопасность выходной сети добавлением ключа WPA2.
Переходим в главное меню и выбираем пункт «Подключить» в «Беспроводном соединении». Далее последует настройка моста. Возможно потребуется ввод пароля от роутера Asus.
После нажатия кнопки будет загрузка конфигураций
И вуаля! Всё готово!
Для того, чтобы не путаться к какому устройству подключаться, можно скрыть SSID на роутере Asus
Проверяем подключение по кабелю
Пинг успешен.
Проверка по Wi-Fi.
Успешно.
И просмотрим финальную конфигурацию, при подключении к ретранслятору.
 | https://habr.com/ru/post/351564/ | null | ru | null |
# Как я создавал файл конфигурации DHCP из таблицы Excel при помощи Python
Я решил поставить DHCP сервер на Linux, но была небольшая проблема, у нас не было текущего DHCP сервера (все ip были статическими), карты сети, списка ip и mac адресов. Я сканировал сеть получил список mac и ip, распечатал и мы с коллегой пошли записывать фамилии тех, у кого эти mac адреса. Потом я внес все это в таблицу excel (таблица 1).
| |
| --- |
| Таблица 1 |
| Кабинет | Имя ПК | ФИО | IP | MAC |
| 1 | 1-1 | Иванов ИванИванович | 192.168.0.10 | 00:00:00:00:00:00 |
Полгода спустя я все-таки решил заняться установкой DHCP сервера. Для резервирования ip надо было прописать это все в config. Но из-за того, что в таблице было примерно 75 строк с mac, ip, фамилиями, было как-то лень прописывать это все вручную и я решил создать python скрипт, который сам все это сделает.
Пример файла dhcp.conf:
```
host Lastname {
hardware ethernet 00:00:00:00:00:00;
fixed-address 192.168.0.1;
}
```
* **Lastname** - Фамилия пользователя.
* **hardware ethernet** - MAC адрес.
* **fixed-address** - ip адрес для резервирования.
Текущая таблица не подходила из-за того, что ФИО в ней полно. Я создал новую таблицу (таблица 2) и переписал фамилии на латиницу.
| |
| --- |
| Таблица 2 |
| name | mac | ip |
| Ivanov | 00:00:00:00:00:00 | 192.168.0.10 |
Далее я начал писать скрипт на python, получилось 3 варианта скрипта.
> Библиотеки **xlrd** и **pandas** 1строчку в таблице excel не включают в список считая ее оглавлением столбцов.
>
>
---
### Вариант 1
Хотел использовать библиотеку pandas но она не завелась и решил использовать списки. Для того что бы заключить все строки в скобки воспользовался инструментом excel. С протяжкой формулы.
```
="'"&A1&"'," - для столбца name
="'"&B1&"'," - для столбца mac
="'"&C1&"'," - для столбца ip
```
Получилось так (таблица 3).
| |
| --- |
| Таблица 3 |
| name | mac | ip |
| 'Ivanov' | '00:00:00:00:00:00', | '192.168.0.10' |
Далее внес это все в списки и просто пробегался циклом.
```
mac=['00:00:00:00:00:00', ...]
ip=['192.168.0.10', ...]
name=['Ivanov', ...]
def write():
with open("dhcp.conf", 'w') as f:
for i,j,k in zip(Config.name, Config.mac, Config.ip):
f.write(f"host {i}" + " {\n\thardware ethernet" + f" {j};" + "\n\tfixed-address " + f"{k};" + "\n}\n\n")
if __name__ == '__main__':
write()
```
Создаем 3 списка:
* **mac** - для mac адресов
* **ip** -для ip адресов
* **name** - для фамилий пользователей
```
mac=['00:00:00:00:00:00', ...]
ip=['192.168.0.10', ...]
name=['Ivanov', ...]
```
Создаем функцию:
```
def write():
```
Открываем файл dhcp.conf в режиме записи:
```
with open("dhcp.conf", 'w') as f:
```
Проходимся циклом по спискам. **zip** - функция берёт на вход несколько списков и создаёт из них список (кортеж):
```
for i,j,k in zip(Config.name, Config.mac, Config.ip):
```
Записываем в файл:
```
f.write(f"host {i}" + " {\n\thardware ethernet" + f" {j};" + "\n\tfixed-address " + f"{k};" + "\n}\n\n")
```
Вызываем функцию:
```
if __name__ == '__main__':
write()
```
---
### Вариант 2
Пользовался таблицей 2 и библиотекой xlrd.
Библиотека не поддерживает xlsx формат поэтому пришлось сохранить файл в формат xls.
```
import xlrd
def write():
loc = (r"C:\path\to\file\filename.xls")
sheet = xlrd.open_workbook(loc).sheet_by_index(0)
with open("dhcp.conf", 'w') as f:
for i in range(sheet.nrows):
f.write(f"host {sheet.cell_value(i, 0)}" + " {\n\thardware ethernet" + f" {sheet.cell_value(i,1)};" + "\n\tfixed-address " + f"{sheet.cell_value(i,2)};" + "\n}\n\n")
if __name__ == '__main__':
write()
```
Импортируем библиотеку для возможности ее использования:
```
import xlrd
```
Объявляем функцию:
```
def write():
```
Открываем excel и лист с индексом 0:
```
loc = (r"C:\path\to\file\filename.xls")
sheet = xlrd.open_workbook(loc).sheet_by_index(0)
```
Данный фрагмент можно записать во так:
```
sheet = xlrd.open_workbook(r"C:\path\to\file\filename.xls").sheet_by_index(0)
```
Открываем файл на запись:
```
with open("dhcp.conf", 'w') as f:
```
Пробегаемся циклом по количеству строк. Где '**sheet.nrows'** показывает количество строк:
```
for i in range(sheet.nrows):
```
Записываем в файл. **sheet.cell\_value(i, 0)** - считываем значение с поля где **i** - строка, **0** - столбец:
```
f.write(f"host {sheet.cell_value(i, 0)}" + " {\n\thardware ethernet" + f" {sheet.cell_value(i,1)};" + "\n\tfixed-address " + f"{sheet.cell_value(i,2)};" + "\n}\n\
```
Вызываем функцию:
```
if __name__ == '__main__':
write()
```
---
### Вариант 3
Пользовался таблицей 2 и библиотекой pandas.
```
import pandas as pd
def write():
excel = pd.read_excel(r'C:\path\to\file\filename.xlsx')
with open("dhcp.conf", 'w') as f:
for i, j, k in zip(excel["Name"].tolist(), excel["MAC"].tolist(), excel["IP"].tolist()):
f.write(f"host {i}" + " {\n\thardware ethernet" + f" {j};" + "\n\tfixed-address " + f"{k};" + "\n}\n\n")
if __name__ == '__main__':
write()
```
Подключаем библиотеку. **as** - создание псевдонима:
```
import pandas as pd
```
Создаем функцию:
```
def write():
```
Считываем данные из excel:
```
excel = pd.read_excel(r'C:\path\to\file\filename.xlsx')
```
Открываем файл для чтения:
```
with open("dhcp.conf", 'w') as f:
```
Пробегаемся циклом по спискам:
```
for i, j, k in zip(excel["Name"].tolist(), excel["MAC"].tolist(), excel["IP"].tolist()):
```
Выбираем столбцы, у которого название 'Name', 'mac', 'ip'. Создаем из них список:
```
excel["Name"].tolist(), excel["MAC"].tolist(), excel["IP"].tolist
```
Что бы посмотреть, как pandas видит оглавление excel используется следующая строчка:
```
print (excel.columns.ravel())
```
Записываем в файл:
```
f.write(f"host {i}" + " {\n\thardware ethernet" + f" {j};" + "\n\tfixed-address " + f"{k};" + "\n}\n\n
```
Вызываем функцию:
```
if __name__ == '__main__':
write()
```
Вывод всех вариантов скриптов в dhcp.conf:
```
host Ivanov {
hardware ethernet 00:00:00:00:00:00;
fixed-address 192.168.0.10;
}
```
Надеюсь, кому-нибудь это будет полезно.
PS: это моя первая статья | https://habr.com/ru/post/682558/ | null | ru | null |
# Простой многопользовательский текстовый редактор с end-to-end шифрованием
### Введение
На сегодняшний день защита информации является одной из приоритетных задач IT-индустрии, особенно учитывая то, что для прослушивания трафика в наше время практически не нужно иметь специализированных знаний – в Интернете достаточно и программного обеспечения, и подробных руководств.
Поэтому мною была поставлена и решена задача написания сервиса для обмена файлов, спроектированного таким образом, что бы он был максимально защищен от атак «человека в середине» — файлы, передаваемые через сервис не должны были уходить с сетевой карты конечного устройства в незашифрованном виде, а дешифрация, соответственно, должна была происходить на машине конечного получателя.
### Выбор инструментов
Для написания серверной части приложения мною был выбран язык программирования Javа в сочетании с фреймворком для веб-разработки Wicket. Это не единственный инструментарий, на котором можно было реализовать поставленные задачи, но данного стека вполне достаточно для их решения, а Wicket помимо всего прочего предоставляет весьма удобный интерфейс для работы с компонентами веб-страниц. Фронтенд не подразумевал наличия в себе чего-то сложного – я не ставил перед собой задачи разработать красивый и дружелюбный интерфейс, в большем приоритете была логика приложения, поэтому я ограничился классической связкой HTML/CSS/JS.
Сервер запущен на Ubunty 18.04, в Docker контейнере — но о конфигурировании сервера речь подробнее пойдет чуть ниже – с помощь контейнера сервлетов Apache Tomcat. Остальные технологии, необходимые для построения подобного приложения если понадобятся, будут упомянуты по ходу статьи.
### Конфигурирование сервера
Как уже упоминалось, приложение расположено на linux-сервере, в частности, на Ubunty 18.04. Для того, что бы изолировать систему от остальных приложений, а так же упростить развертывание, было принято решение контейнеризировать процесс – с помощь Doсker выделить приложению некоторое количество CPU и памяти, список открытых портов, а все остальное – закрыть. Я не буду подробно описывать установку и настройку сервиса Docker, однако ключевые моменты упомянуть должен.
Предполагается, что все команды выполняются с правами администратора.
Для начала потребовалось установить и запустить соответствующую службу, командами
```
# apt install docker-сe
# systemctl start docker
# systemctl enable docker
```
После этого скачаем и запустим образ операционной системы – больше от контейнера нам на данный момент ничего не надо:
```
#docker search ubuntu
#docker pull ubuntu
#docker run -it ubuntu
```
Стиль приглашения к вводу должен был измениться – теперь мы находимся в контейнере и можем работать без опасения за реальное окружение. Возможно, некоторых пакетов, к которыми мы привыкли на реальной машине в контейнере будет не хватать, но процедура их установки ничем не отличается от установки пакета на реальную машину, поэтому на этом заострять внимание я не буду. Далее предполагается, что все действия выполняются внутри контейнера.
### Настройка контейнера сервлетов Tomcat
Итак, на данный момент мы предполагаем, что работаем на чистой операционной системе, где все по умолчанию. Для того, что бы иметь возможность хостить на ней Java приложение, на нее нужно установить непосредственно jdk и jvm, и задать переменные окружения с путями установки. Соответственно, тут я приведу лишь ключевые команды, более подробно процесс установки Java на Linux можно рассмотреть в сети.
Для установки JDK и JRE, а затем – настойка переменной окружения JAVA\_HOME требуется ввести соответственно вот эти команды:
```
#apt install openjdk-8-jdk
#apt install openjdk-8-jre
#export JAVA_HOME “путь_к_дикектории_установки_JAVA”
```
Дальше можно перейти непосредственно к установке Tomcat.
Ключевое, на что стоит обратить внимание – на выдачу прав менеджера и администратора – по умолчанию нельзя администрировать приложения удаленно, не на локальной машине. В остальном же все стандартно – загрузка и установка пакета и запуск службы.
### Написание программы
Программа, как уж упоминалось выше, будет состоять из серверной и клиентской части. Кратко рассмотрим клиентскую часть, максимальный интерес представляет файл Editor и функции шифрования.
Однако обо всем по порядку.
Начнем с клиентской части.
По задумке, она должна давать доступ к списку файлов, сохраненных на сервере. Так как решение должно было быть дешевым, я передавал список файлов в виде текста для неактивного текстбокса, и прикрепил снизу форму для выбора названия файла для открытия.
*Рис. 1 – Интерфейс хранилища файлов*
При вводе имени файла в строку ввода файл открывается в другом окне – в редакторе. Java-код страницы, отображающей список файлов:
```
File directory = new File(wayToDirs);
String files = new String();
directory.mkdirs();
for (File i : directory.listFiles())
files+=i.getName()+"\n";
TextArea listOfFiles = new TextArea("files", Model.of(""));
listOfFiles.setEnabled(false);
listOfFiles.setDefaultModelObject(files);
add(listOfFiles);
```
Соответствующий ему HTML-код еще более тривиален:
```
Открыть
```
Как уже говорилось выше, интерес предсавяет непосредственно страница с редактором и с шифрованием. Там происходит открытие, изменение, шифрация и дешифрация требуемого файла, а так же его сохранение.
*Рис. 2 – интерфейс редактора*
Начнем с серверной части – она проще для понимания. С точки зрения сервера, приложение должно по клику на клавишу принять текст из окна ввода текста, приянть имя файла из соответствующей строки и сохранить получившийся документ. Собственно, это и происходит в нижеизложенном листинге.
```
TextField wayToSaveFile = new TextField("wayToSaveFile", Model.of(""));
Button saveButton = new Button("save")
{
@Override
public void onSubmit() {
super.onSubmit();
File file = new File(DirectoryInterface.wayToDirs+"/" + wayToSaveFile.getInput());
try
{
FileWriter fw = new FileWriter(file);
fw.write(textArea.getDefaultModelObject().toString());
fw.close();
}
catch (Exception e) {
System.out.println(e.getMessage());
debud.setDefaultModelObject(e.getMessage());
}
}
};
```
Но на момент сохранения –файл уже зашифрован. Для этого в клиентской части реализованы кнопки «Зашифровать» и «Дешифровать», служащие для шифрации и дешифрации. Шифрация происходит по алгоритму Виженера, о нем я чуть больше скажу отдельно, но в функциях он показан.
Соответсвенно, клиентский код выглядит так:
```
function encryptFun(){
let outputString = "";
let inputString = document.getElementById("text").value;
let password = document.getElementById("passwordTextField").value;
for (let i = 0; i<inputString.toString().length-1; i++)
outputString+=(String.fromCharCode((inputString.toString().charCodeAt(i)+256-password.toString().charCodeAt(i%password.toString().length))%256));
document.getElementById("text").value = outputString;
return outputString;
};
function decryptFun(){
let outputString = "";
let inputString = document.getElementById("text").value;
let password = document.getElementById("passwordTextField").value;
for (let i = 0; i<inputString.toString().length-1; i++)
outputString+=(String.fromCharCode((inputString.toString().charCodeAt(i)+256+password.toString().charCodeAt(i%password.toString().length))%256));
document.getElementById("text").value = outputString;
return outputString;
};
…
Save
Зашифровать
Расшифровать
```
Таким образом, после нажатия на кнопку шифрации, текст в поле ввода подменяется на текст, возвращенный функцией шифрования – и наоборот.
Текущая версия приложения не позволяет определить автоматически, является ли текст зашифрованным, поэтому зашифрованным считается всякий текст, не являющийся связным.
### Алгоритм шифрации
Мною был выбран алгоритм шифрования Виженера – являющийся вариацией шифра Цезаря с переменным сдвигом по ключевому слову. На вход алгоритму подается исходный текст и ключ произвольной длинны. Тогда i-ый член исходного текста сдвигается на порядковый номер в алфавите j-ого символа пароля, где j = i%(длину пароля). Алгоритм не является самым оптимальным или устойчивым к анализу, однако при достаточной длине пароля обеспечивает некоторую надежность.
Согласно материалам из литературы о криптоанализе, шифр Виженера «размывает» характеристики частот появления символов в тексте, но некоторые особенности появления символов в тексте остаются. Главный недостаток шифра Виженера состоит в том, что его ключ повторяется. Поэтому простой криптоанализ шифра может быть построен в два этапа:
1. Поиск длины ключа. Можно анализировать распределение частот в зашифрованном тексте с различным прореживанием. То есть брать текст, включающий каждую 2-ю букву зашифрованного текста, потом каждую 3-ю и т. д. Как только распределение частот букв будет сильно отличаться от равномерного (например, по энтропии), то можно говорить о найденной длине ключа.
2. Криптоанализ. Совокупность l шифров Цезаря (где l — найденная длина ключа), которые по отдельности легко взламываются.
Тесты Фридмана и Касиски могут помочь определить длину ключа.
Более подробное обсуждение взлома Виженера опять-таки выходит за рамки данной статьи.
### Выводы
В рамках данной статьи был разобран алгоритм написания приложения, обеспечивающего безопасное хранение и передачу по сети текстовых файлов, требующих общего доступа.
Некоторые решения, озвученные выше являются спорными или не оптимальными, но базовая логика и фундаментальные вещи обозначены.
[github.com/Toxa-p07a1330/encriptedStorage](https://github.com/Toxa-p07a1330/encriptedStorage) | https://habr.com/ru/post/485430/ | null | ru | null |
# «Слабые» ссылки в CPython
Модуль weakref позволяет создавать "слабые" ссылки на объекты.
"Слабой" ссылки не достаточно, чтобы объект оставался "живым": когда на объект ссылаются только "слабые" ссылки, сборщик мусора удаляет объект и использует память для других объектов. Однако, пока объект не удалён, "слабая" ссылка может вернуть объект, даже если не осталось обычных ссылок на объект.
Один из примеров использования "слабых" ссылок - это реализация кэшей, содержащих большие объекты, когда нежелательно, чтобы объект оставался в памяти только потому, что на него есть ссылки из кэша.
Например, если у вас есть несколько больших объектов картинок, вы можете ассоциировать с каждой картинкой название. Если вы будете использовать обычный словарь для отображения названий на картинки, объекты будут оставаться "живыми" только потому, что они являются значениями в словаре. Использование WeakValueDictionary, предоставленного в модуле weakref, является альтернативой. В таком случае, когда не останется обычных ссылок на картинку, сборщик мусора удалит её, и соответствующая запись в словаре будет удалена.
WeakKeyDictionary и WeakValueDictionary используюют "слабые" ссылки в своей реализации и устанавливают callback функции на "слабые" ссылки, которые сообщают словарю, когда ключ или значение удаляется сборщиком мусора. WeakSet реализует интерфейс множества как WeakKeyDictionary.
Finalize предоставляет простой путь зарегистрировать cleanup функцию, которая вызывается, когда объект удаляется. Это проще, чем установить callback функцию на "слабую" ссылку, поскольку модуль автоматически гарантирует, что finalizer не будет удалён до того, как будет удалён объект.
Для большинства программ использование этих типов контейнеров и finalize - это всё, что нужно. Обычно не нужно создавать "слабые" ссылки вручную. Низкоуровневый механизм предоставлен для расширенного использования.
Не на все объекты могут ссылаться слабые ссылки. Среди объектов, на которые можно ссылаться, есть экземпляры классов, функции (кроме тех, которые написаны с использованием C расширения), методы объектов, множества, frozensets, некоторые объекты файлов, генераторы, типы объектов, сокеты, arrays, deques, регулярные выражения, и code objects. В версии CPython 3.2 добавлена поддержка для thread.lock, thread.Lock и code objects.
Некоторые встроенные типы, такие как list и dict, явно не поддерживают "слабые" ссылки, но на их подкласссы могут ссылаться "слабые" ссылки.
```
class Dict(dict): pass
obj = Dict(red=1, green=2, blue=3)
```
Некоторые другие встроенные типы, такие как tuple и int не поддерживают "слабые" ссылки, даже их подкласы.
Каждый объект, на который могут ссылаться "слабые" ссылки, содержит атрибут \_ \_ weakref \_ \_, который является "слабой" ссылкой (или "слабым" прокси-объектом) и так же является первым объектов в двухсвязном списке всех "слабых" ссылок и "слабых" прокси-объектов.
Когда в данном типе присутствует атрибут \_ \_ slots \_ \_, "слабые" сылки не доступны до тех пор, пока атрибут \_ \_ weakref \_ \_ явно не присутствует в списке \_ \_ slots \_ \_.
### class weakref.ref(object[, callback])
Возвращает "слабую" ссылку на объект. Оригинальный объект может быть получен, если он ещё не удалён; если же он уже удалён, то ссылка вернёт None. Если callback передан, он будет вызван перед удалением объекта; ссылка будет передана единственным параметров в функцию callback; оригинальный объект больше не будет доступен.
Можно создавать несколько "слабых" ссылок на один объект. Функции callback, зарегистрированные для одного объекта, будут вызваны с самого последнего добавленного до самого первого.
Исключения, выброшенные в callback, будут выведены в стандартный поток ошибок, но не будут проброшены выше; они обрабатываются точно так же как исключения, выброшенные в методе \_ \_ del \_ \_.
"Слабые" ссылки являются хэшируемыми, если сам объект является хэшируемым. Они будут возвращать хэш, даже если оригинальный объект уже удалён. Если функция hash() первый раз вызвана только после удаления оригинального объекта, то вызов выбросит исключение TypeError.
"Слабые" ссылки можно сравнивать на равенство, но не на порядок. Если их оригинальные объекты ещё "живы", две "слабые" ссылки имеют тот же результат при сравнении на равенство, что и их объекты (несмотря на callback). Если хотя бы один оригинальный объект удалён, то ссылки будут равны друг другу, если являются одним и тем же объектом.
#### \_ \_ callback \_ \_
В версии CPython 3.4 появился атрибут \_ \_ callback \_ \_ (только для чтения). Он возвращает функцию callback, относящуюся к данной "слабой" ссылке. Если он не был установлен или оригинальный объект удалён, то атрибут вернёт None.
### weakref.proxy(object[, callback])
Возвращает прокси-объект. Во многих случаях лучше использовать прокси, чем "слабые" ссылки, потому что этот вариант не требует разыменования. Возвращаемый объект имеет тип ProxyType или CallableProxyType в зависимости от того, является ли оригинальный объект вызываемым. Прокси-объекты не являются хэшируемыми ни смотря на оригинальный объект. Параметр callback является таким же, как в функции ref().
### weakref.getweakrefcount(object)
Возвращает количество "слабых" ссылок и прокси-объектов на объект.
### weakref.getweakrefs(object)
Возвращает список "слабых" ссылок и прокси-объектов на объект.
### class weakref.WeakKeyDictionary([dict])
Класс отображения, у которого ключи являются "слабыми" ссылками. Элементы словаря будут удалены, когда больше нет обычных ссылок на ключ.
#### WeakKeyDictionary.keyrefs()
Возвращает итерируемый объект "слабых" ссылок на ключ.
### class weakref.WeakValueDictionary([dict])
Класс отображения, у которого значения являются "слабыми" ссылками. Элементы словаря будут удалены, когда больше нет обычных ссылок на значение.
#### WeakValueDictionary.valuerefs()
Возвращает итерируемый объект "слабых" ссылок на значение.
### class weakref.WeakSet([elements])
Класс множества, который содержит "слабые" ссылки на свои элементы.
### class weakref.WeakMethod(method)
В версии CPython 3.4 для ref добавлен подкласс, который иммитирует "слабую" ссылку на bound метод. Поскольку bound метод является недолговечным, обычная "слабая" ссылка здесь не подходит. WeakMethod содержит специальный код, который воссоздаёт bound метод до тех пор, пока объект или исходная функция не "умрут".
```
>>> class C:
... def method(self):
... print("method called!")
...
>>> c = C()
>>> r = weakref.ref(c.method)
>>> r()
>>> r = weakref.WeakMethod(c.method)
>>> r()
>
>>> r()()
method called!
>>> del c
>>> gc.collect()
0
>>> r()
>>>
```
### class weakref.finalize(obj, func, /, \*args, \*\*kwargs)
Возвращает вызываемый finalizer объект, который вызывается, когда оригинальный объект удаляется сборщиком мусора. В отличие от обычной "слабой" ссылки, finalizer всегда будет существовать до тех пор, пока ссылаемый объект не будет удалён.
finalizer считается "живым" до тех пор, пока он не вызван (явно или сборщиком мусора). Вызов "живого" finalizer возвращает результат вычисления func(\*args, \*\*kwargs), в то время как вызов "умершего" finalizer возвращает None.
Когда программа завершается, каждый оставшийся живой finalizer будет вызван, если его атрибут atexit не установлен в False. Они вызываются в обратном порядке от создания.
#### \_ \_ call \_ \_()
Если self "жив", то отмечает finalizer "умершим" и возвращает результат вызова func(\*args, \*\*kwargs). Если self "умер" - возвращает None.
#### detach()
Если self "жив", то отмечает finalizer "умершим" и возвращает кортеж (obj, func, args, kwargs). Если self "умер" - возвращает None.
#### peek()
Если self "жив", то возвращает кортеж (obj, func, args, kwargs). Если self "умер" - возвращает None.
#### alive
Свойство, которое возвращает True, если finalizer "жив", иначе - False.
#### atexit
Изменяемое свойство, которое по-умолчанию True. Когда программа завершается, она вызывает оставшиеся finalizers, у которых atexit установлено в True.
### Finalizer
Главное преимущество использования finalize заключается в том, что не нужно следить за тем, чтобы finalizer оставался "живым". Например:
```
>>> import weakref
>>> class Object: pass
...
>>> kenny = Object()
>>> weakref.finalize(kenny, print, "You killed Kenny!")
>>> del kenny
You killed Kenny!
```
finalizer может быть вызван явно, но только единожды.
```
>>> def callback(x, y, z):
... print("CALLBACK")
... return x + y + z
...
>>> obj = Object()
>>> f = weakref.finalize(obj, callback, 1, 2, z=3)
>>> assert f.alive
>>> assert f() == 6
CALLBACK
>>> assert not f.alive
>>> f() # callback not called because finalizer dead
>>> del obj # callback not called because finalizer dead
```
Вы можете отменить регистрацию finalizer, используя detach метод. Он удаляет finalizer и возвращает аргументы, переданные в конструктор при создании.
```
>>> obj = Object()
>>> f = weakref.finalize(obj, callback, 1, 2, z=3)
>>> f.detach()
(<...Object object ...>, , (1, 2), {'z': 3})
>>> newobj, func, args, kwargs = \_
>>> assert not f.alive
>>> assert newobj is obj
>>>> assert func(\*args, \*\*kwargs) == 6
CALLBACK
```
Если вы не установите значение atexit в False, то finalizer будет вызван при завершении программы, если объект ещё жив.
```
>>> obj = Object()
>>> weakref.finalize(obj, print, "obj dead or exiting")
>>> exit()
obj dead or exiting
``` | https://habr.com/ru/post/599411/ | null | ru | null |
# (Архив) Matreshka.js — Введение
**Статья устарела. В [новой документации](http://ru.matreshka.io/) содержится самая актуальная информация из этого поста. См. [bindNode](http://ru.matreshka.io/#Matreshka-bindNode) и [on](http://ru.matreshka.io/#Matreshka-bindNode).**
Приветствую всех читателей и писателей хабра.
Хочу познакомить вас с компактным фреймворком, который позволяет несколько изменить взгляд на структурирование приложений. В «Матрешку» вложено чуточку магии, раскрыть которую позволит серия статей, озаглавленных следующим образом:
* **Введение**
* [Наследование](http://habrahabr.ru/post/200078/)
* [MK.Object](http://habrahabr.ru/post/196886/)
* [MK.Array](http://habrahabr.ru/post/198212/)
* [Matreshka.js v0.1](http://habrahabr.ru/post/217241/)
* [Matreshka.js v0.2](http://habrahabr.ru/post/231333/)
* [Реализация TodoMVC](http://habrahabr.ru/post/231347/)
Код для привлечения внимания:
```
mk.on( 'change:x', function() {
alert( 'x is changed to ' + this.x );
});
mk.x = 2; // alerts "x is changed to 2"
```
И это работает в… IE8.
##### Что такое Матрешка?
**Матрешка, как фреймворк**
Компактный размер и легкая в изучении архитектура даёт возможность строить крупные расширяемые приложения. Этим сегодня никого не удивишь, но я постараюсь.
**Матрешка, как библиотека**
Если фичи, предоставляемые Матрешкой вам понравятся, то не обязательно менять свой код. Матрешкой можно пользоваться, как набором классов с интересными методами.
**Матрешка, как платформа для создания собственного фреймворка**
Матрешка — расширяемый фреймворк общего назначения, который не позиционируется, как MVC, MVVM или %your\_design\_pattern% фреймворк, поэтому программист имеет возможность реализовать собственную архитектуру, которая будет уметь желаемый набор шаблонов проектирования.
##### Зачем?
Мне часом надоело думать о представлении и о том, чтоб его менять написанным мной кодом. Все костыли синхронизации данных и представления в Javascript вызывают у меня негативные чувства, и амбициозной, направленной в будущее, целью Матрешки является возможность полностью забыть о том, что у нас есть UI, оперируя только данными. Конечно же, решить эту задачу невозможно на 100%, но мы, программисты, должны выжимать максимум из данных нам инструментам, дабы сделать код чище, короче и гибче. Пора встряхнуть свой код и стать злым.
**Гифка для привлечения внимания**
#### Привязка данных
Известно, что, клиентские приложения в браузере требуют синхронизации между данными и представлением. Классическая задача: есть данные:
```
var o = { x: 2 };
```
Есть `select`, который должен менять эти данные:
```
1
2
3
```
Если использовать чистый JS + jQuery код мы напишем примерно следующее:
```
$( 'select' ).on( 'change', function() {
o.x = +this.value;
});
```
Затем, когда хотим поменять данные, пишем:
```
o.x = 1;
$( 'select' ).val( o.x );
```
Это не очень хорошо, так как заставляет устанавливать значение сразу для двух «атомов»: свойства и элемента.
Эту проблему решают по разному: Backbone (MVC) разделяет приложение на модель (Model, Collection), представление (HTML код) и контроллер (View). Knockout и Angular (MVVM) привязывают данные, используя практику, перекочевавшую из .NET в клиентский веб: часть логики, заменяющая контроллер (в данном случае ViewModel) пишется в HTML коде (прошу прощения, если описание неверно). Есть еще куча фреймворков, за которыми не угонишься.
Матрешка привязывает данные к представлению таким образом, что, во первых, программист не трогает HTML код (в отличие от MVVM), во вторых, программист перестаёт думать о событиях HTML элемента для изменения модели (в отличие от Backbone).
```
var mk = new Matreshka; // или new MK; помните, что MK === Matreshka, это обычное сокращение
mk.bindNode( 'x', 'select', {
on: 'change',
getValue: function() {
return this.value;
},
setValue: function( v ) {
this.value = v;
}
});
```
Если мы хотим поменять данные, то просто пишем:
```
mk.x = 2;
```
Такой код не только присвоит иксу двойку, но и поменяет состояние селекта, установив ему `.value = 2`.
И это без использования методов, типа `.set`.
[jsbin.com/jikewipi/2/edit](http://jsbin.com/jikewipi/2/edit)
Что здесь произошло?
```
mk.bindNode( 'x', 'select' ... )
```
Метод `bindNode`, как ни странно, отвечает за привязку элемента к свойству. Первый аргумент — ключ объекта, второй — селектор, в данном случае `'select'`. Тип второго аргумента — любое значение, которое принимается jQuery: селектор, чистый элемент, jQuery объект, NodeList, массив элементов… То есть, `'select'` можно заменить на `$( 'select' )` или `document.getElementsByTagName( 'select' )` или `document.querySelector( 'select' )`.
Третий аргумент — самое интересное, разберем по порядку.
```
on: 'change'
```
Отвечает на вопрос: «Какое событие должно произойти на элементе, чтобы мы взяли значение из элемента и присвоили соответствующему свойству?»
```
getValue: function() {
return this.value;
}
```
Отвечает на вопрос: «Каким образом извлечь значение элемента?», возвращая значение.
```
setValue: function( v ) {
this.value = v;
}
```
Отвечает на вопрос: «Как нам установить значение для элемента?», где `v` — значение (в данном случае, `2`).
Ссылка на доку: [finom.github.io/matreshka/docs/Matreshka.html#bindElement](http://finom.github.io/matreshka/docs/Matreshka.html#bindElement)
Усложним задачу. Скажем, у нас есть слайдер из jQuery UI: [api.jqueryui.com/slider](http://api.jqueryui.com/slider/) и у нас появилась задача привязать его к нашим данным. Смотрим документацию и видим событие `"slide"`, которое срабатывает при перетаскивании ползунка.
Во-первых, перед привязкой объявим слайдер:
```
```
```
$( ".slider" ).slider({ min: 0, max: 100 });
```
Во-вторых объявляем экземпляр Матрешки:
```
var mk = new Matreshka();
```
Дальше вызываем привязку:
```
mk.bindNode( 'x', '.slider', {
on: 'slide', // событие, по которому из элемента извлекается значение
getValue: function() {
return $( this ).slider( 'option', 'value' ); // как вытащить значение из элемента (см. документацию jQuery ui.slider)?
},
setValue: function( v ) {
$( this ).slider( 'option', 'value', v ); // как установить значение для элемента (см. документацию jQuery ui.slider)?
}
});
```
Теперь, когда мы вызовем следующий код…
```
mk.x = 44;
```
… позиция слайдера изменится.
И наоборот, когда мы перетащим ручку слайдера, наш `mk.x` изменится.
**UPD**: Начиная с версии 0.2, третий аргумент имеет новый ключ `'initialize'`, который позволяет проинициализировать элемент перед его привязкой. [См. статью о 0.2](http://habrahabr.ru/post/231333/). Код теперь выглядит так:
```
mk.bindNode( 'x', '.slider', {
initialize: function() {
$( this ).slider({ min: 0, max: 100 });
},
on: 'slide',
getValue: function() {
return $( this ).slider( 'option', 'value' );
},
setValue: function( v ) {
$( this ).slider( 'option', 'value', v );
}
});
```
Еще немного усложним задачу, добавив HTML элемент, выводящий значение:
```
Value is
```
И привяжем его к `'x'`:
```
mk.bindNode( 'x', '.output .x', {
setValue: function( v ) {
this.innerHTML = v;
}
});
```
Как видно, у опций привязки элемента отсутствует свойство `"on"` и метод `"getValue"`. Это значит, что из элемента `".output .x"` мы не будем извлекать значение, а только устанавливать.
Мы можем привязать к одному свойству несколько элементов. Обратное утверждение тоже верно: мы можем привязывать к одному элементу много свойств. Просто помните, что Матрешка умеет привязывать элементы по правилу «многие ко многим».
Результат: [jsbin.com/bulobuhu/7/edit](http://jsbin.com/bulobuhu/7/edit) (откройте вкладку Console и попробуйте изменить `x`, например, напишите `mk.x = 42;`)
Отлично, мы привязали два элемента, но получили кучу избыточного кода (на мой взляд). Что, если у нас будет много слайдеров? Каждый раз писать…
```
mk.bindNode( property, element, {
on: 'slide',
getValue: function() {
return $( this ).slider( 'option', 'value' );
},
setValue: function( v ) {
$( this ).slider( 'option', 'value', v );
}
});
```
… не очень красиво.
Что делать? Надо запомнить общие черты элементов, которые будут проверяться при привязке элементов. Было бы удобно сделать так:
```
mk.bindNode( 'x', '.slider' );
```
Как это сделать? У Матрешки есть статичное свойство ~~`MK.elementProcessors`~~ `MK.defaultBinders` (переименовано), которое является массивом функций. Функции принимают аргумент `el`, являющийся проверяемым элементом, и содержат условие: если элемент соответствует некоторому правилу, то возвращаем объект опций, которые в примерах `.bindNode` выше, являются третьим аргументом.
Для любого слайдера есть одно правило: каждый имеет класс `ui-slider`. Поэтому наша функция-условие будет выглядеть так (**UPD**: не забудьте, о свойстве `'initialize'`):
```
function( el ) {
if( $( el ).hasClass( 'ui-slider' ) ) {
return {
on: 'slide',
getValue: function() {
return $( this ).slider( 'option', 'value' );
},
setValue: function( v ) {
$( this ).slider( 'option', 'value', v );
}
};
}
}
```
Пример, надеюсь, достаточно прост: мы проверяем, является ли элемент слайдером и, если да, возвращаем опции.
Вставляем функцию в массив `MK.defaultBinders`:
```
MK.elementProcessors.push( function( el ) {
if( $( el ).hasClass( 'ui-slider' ) ) {
return {
on: 'slide',
getValue: function() {
return $( this ).slider( 'option', 'value' );
},
setValue: function( v ) {
$( this ).slider( 'option', 'value', v );
}
};
}
});
```
Ссылка на доку: [finom.github.io/matreshka/docs/Matreshka.html#defaultBinders](http://finom.github.io/matreshka/docs/Matreshka.html#defaultBinders)
После этого, имея хоть сотню слайдеров, в функции `.bindNode` мы определяем только лишь свойство и привязываемый элемент:
```
```
```
$( ".slider1, .slider2" ).slider({ min: 0, max: 100 });
var mk = new Matreshka();
mk.bindNode({
x1: '.slider1',
x2: '.slider2'
});
```
Результат: [jsbin.com/celarefu/2/edit](http://jsbin.com/celarefu/2/edit)
Обратите внимание на то, как в примере по ссылке привязан вывод:
```
mk.bindNode({
x1: '.output .x1',
x2: '.output .x2'
}, MK.binders.innerHTML() );
```
`MK.binders` — статичное свойство, содержащее кастомные функции-привязчики, которые должны возвращать объект описанный выше (со свойствами `on, setValue, getValue`). Объект можно расширять собственными биндерами.
`MK.binders.innerHTML` — функция, возвращающая опции привязки к обычному html элементу, меняя его `innerHTML`.
Дока: [finom.github.io/matreshka/docs/Matreshka.binders.html#innerHTML](http://finom.github.io/matreshka/docs/Matreshka.binders.html#innerHTML)
Почему бы не создать правило, которое меняет `.innerHTML` для любого элемента, не соответствующего ни одному другому правилу? Одним словом: удобство. Иногда есть нужда привязывать элементы, для которых не требуется установка значения, но об этом в следующей статье.
По умолчанию `MK.defaultBinders` содержит одну функцию, проверяющую элемент на соответствие тривиальным правилам, давая возможность использовать простые элементы (`select`, `textarea`, `input[type="text"]`, `input[type="checkbox"]`, `input[type="radio"]`).
Например,
```
...
```
Используя такой код:
```
mk.bindNode( 'x', '.my-select' );
```
… Матрешка сама узнает, когда, как добыть, как установить значение элемента, так как используется самый обычный `select`.
Пример: [jsbin.com/tepiyoso/2/edit](http://jsbin.com/tepiyoso/2/edit) (нажимайте, изменяйте текст инпутов и взгляните на исходник)
**Крититка подхода с селектором по классу**Два дня назад я [запостил анонс](http://javascript.ru/forum/project/42461-frejjmvork-matreshka-js.html) Матрешки на форум javascript.ru. Пользователь **nerv\_** обоснованно описал критику подхода с селекторами, приведя код на AngularJS.
> Получается, нужно следить как минимум за служебными селекторами.
>
> И получается что все «биндинги» необходимо писать в js коде. А их, как правило, много, вместо того, чтобы задать декларативно — дешево и сердито.
>
>
Я согласен, что при большом количестве привязываемых элементов нужно следить за тем, чтоб не изменить классы привязаных элементов, поэтому, в таком случае, возможно, подойдет указание ключей в UI:
```
```
Деревянный способ:
```
$( '[data-key]' ).each( function() {
this.bindNode( this.getAttribute( 'data-key' ), this );
});
```
Правильный способ (подробнее о методе `.each` в статье об `MK.Object`):
```
this.each( function( v, key ) {
this.bindNode( key, this.$( '[data-key=' + key + ']' ) );
});
```
Эти два способа можно назвать первыми шагами к паттерну MVVM, который можно реализовать на базе Матрешки. Готовится пруф в виде плагина и статьи о нем.
Я предпочитаю разграничивать «комплексные» элементы приложения таким образом, чтоб каждый элемент являлся элементарным классом (что я имею в виду, будет понятнее в статье о наследовании), привязок в котором не так много. Возможно, мой подход сильно деформирован убеждением о том, что JS код и HTML должны быть максимально разграничены: верстальщик верстает, а программист, если и вносит, то только минимальные и необходимые изменения.
#### События
Матрешка содержит в себе генератор событий, который работает так же, как и в Backbone.js. Изначально, фреймворк писался под собственные нужды, поэтому часть кода, отвечающая за события, была позаимствована как раз из этого фреймворка. Но код этих методов оказался очень стабильным, поэтому было решено его оставить.
```
var mk = new Matreshka();
mk.on( 'someevent', function( a, b ) {
alert( a + ', ' + b );
});
mk.trigger( 'Hello', 'World!' ); // alerts "Hello, World!"
```
Знакомо?
Ссылка на документацию: [finom.github.io/matreshka/docs/Matreshka.html#on](http://finom.github.io/matreshka/docs/Matreshka.html#on)
Одной из вкусных возможностей, указанных в начале поста является отслеживание события изменения свойства:
```
var mk = new Matreshka();
mk.on( 'change:x', function() {
alert( 'New x value is ' + this.x );
});
mk.x = 5; //alerts "New x value is 5"
```
Мы так же можем привязать свойство к какому-нибудь элементу и отслеживать изменение его значения:
```
1
2
3
```
```
var mk = new Matreshka();
mk.bindNode( 'x', '.my-select' );
mk.on( 'change:x', function() {
alert( 'x is now ' + this.x );
});
```
Здесь прослеживается огромная разница в подходах: раньше мы отслеживали изменения DOM элемента, а сейчас мы отслеживаем изменения данных, так как нам важны исплючительно данные, состояни элементов изменяются сами по себе.
Попробуйте сами: [jsbin.com/dadakeba/1/edit](http://jsbin.com/dadakeba/1/edit)
#### Использование метода `.set`
Метод `.set` просто присваивает значение заданному свойству. Он используется для двух целей:
1. Передача свойств в объект события `change:*key*` (например флага `"silent"`). **UPD:** Флагов стало больше.
```
mk.on( 'change:x', function( evtOpts ) {
alert( evtOpts.myFlag );
});
mk.set( 'x', 5, { myFlag: 'blah' } ); // устанавливает свойство и вызывает событие "change:x"
mk.set( 'x', 42, { silent: true } ); // устанавливает свойство и не вызывает никаких событий
```
Обратите внимание, что даже если передан флаг `silent: true`, значение привязанного элемента всё равно изменится.
2. Сокращение кода. В метод `.set` можно передать объект со свойствами.
```
mk.set( { x1: 1, x2: 2 } );
mk.set( { x1: 3, x2: 4 }, { silent: true } );
```
#### Где взять?
Репозиторий на github: [github.com/finom/matreshka](https://github.com/finom/matreshka) (код фреймворка находится в папке `build/`)
~~Матрешка требует наличия jQuery, хотя планируется убрать зависимость от неё.~~ Начиная с верссии 0.1, jQuery не требуется.
#### В завершение
Я познакомил вас с основными фишками, которые несет в себе Матрешка. Остальные функции вы можете найти в [документации](http://finom.github.io/matreshka/docs/Matreshka.html). Там же вы найдете другие, не менее важные методы:
[`.off`](http://finom.github.io/matreshka/docs/Matreshka.html#off), отключающий заданные события
[`.remove`](http://finom.github.io/matreshka/docs/Matreshka.html#remove), удаляющий свойство
[`.define`](http://finom.github.io/matreshka/docs/Matreshka.html#define), навешивающий кастомные акцессоры
[`.defineGetter`](http://finom.github.io/matreshka/docs/Matreshka.html#defineGetter), навешивающий геттер на элемент
[`.bound`](http://finom.github.io/matreshka/docs/Matreshka.html#bound), [`.boundAll`](http://finom.github.io/matreshka/docs/Matreshka.html#boundAll), возвращающие элемент или коллекцию элементов, соответственно, привязанных к свойству
[`.unbindElement`](http://finom.github.io/matreshka/docs/Matreshka.html#unbindElement), разрывающий связь между свойством и элементом
… и другие.
##### Почему версия 0.0.X?
Просто потому, что проект, несмотря на то, что разрабатывается более года под другим именем, впервые представлен только сейчас (в этой статье).
##### Что дальше?
В следующей статье я расскажу, как написать своё первое приложение, используя Матрешку не просто как набор удобных функций, а как полноценный фреймворк, основанный на классах, и расскажу, почему именно классы (я знаком со здешним негодованием по поводу сего вопроса).
Дальше будет рассказано о классах `MK.Array` и `MK.Object`, отвечающих за данные.
После этого, если читателю интересно, я расскажу, как же работает магия, и как мне удалось реализовать поддержку `Object.defineProperty` в IE8.
Огромное спасибо всем, кто смог прочесть статью до конца. Желаю удачи и успешного кодинга. | https://habr.com/ru/post/196146/ | null | ru | null |
# Как с помощь Raspberry PI вырастить фасоль, и снять TimeLapse видео
Приветствую вас господа!
Как-то раз, ребенку в школе задали вырастить фасоль, чтобы посмотреть во что она прорастает и как из боба вырастает растение.
У меня сразу возникла идея сделать [TimeLapse](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BC%D0%B5%D0%B4%D0%BB%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BA%D0%B8%D0%BD%D0%BE%D1%81%D1%8A%D1%91%D0%BC%D0%BA%D0%B0) видео, как оно там все растет.
Но КАК это сделать, имеющийся фотоаппарат не позволяет собой управлять ~~гад~~.
Наличие любопытной кошки — усугубляло ситуацию…
В шкафу тем временем пылился без дела подарок друзей — Raspberry PI…
##### в посте нет Rocket science, просто описание задачи, пути её решения и итоговый результат.
### Собственно описание задачи
1. надо снять как растет фасоль
2. все опыты делать на окне — растениям нужно солнце
3. кошка зверь любопытный и есть шанс что она все развалит
4. сколько это продлится — не очень понятно
5. это явно одноразовая задача
фото не подходит, в загашнике нашлась вебкамера Logitech C200, для защиты от кошки решил соорудить полку на окне (чтоб вредина не достала), единственное свободное окно нашлось на кухне, как следствие — рядом которым можно делать всё нужное.
стационарный комп еще и гудит прилично, спасть с таким в одной комнате не очень приятно.
вспомним Филеаса Фогга, и одну из его цитат
> Используй то, что под рукою, и не ищи себе другое. (16 серия, «В Новом Орлеане»)
и тут я вспоминаю что у меня есть raspberry pi ;)
и его можно использовать вместо большого компа!
и это полноценный Linux комп!
вот наш герой на посту
что у PI очень удобно, то чтобы он перестал быть медиаплеером (raspbnc) и стал просто Linux (raspbian)
достаточно просто сменить SD карточку (благо этого добра хватает, а 2 гига ему за глаза)
т.е. по инструкции с сайта ставим на карточку распбиан, подключаем к телевизору, конфигурим (без графики)
отключаем от телевизора, все остальные действия делаем по ssh,
так как время которое это все будет работать — не известно, будем считать что все плохо, и писать на внешнюю флешку
на полочке нет интернета!, подходящей wifi карточки тоже нет,
ну ладно, пусть стоит автономно, будем иногда выдергивать флешку и смотреть что получилось.
т.е. надо все заранее сконфигурировать и сделать эту штуку максимально автономной
далее ищем пакет который умеет снимать скриншоты с вебкама
находим [fswebcam](http://www.firestorm.cx/fswebcam/), ставим его из репозитория, проверяем, работает!
дальше пишем скрипт, который пускается из крона 1 раз в минуту!
**скрипт который дергаем из крона do.sh**
```
#!/bin/sh
path='/mnt'
killall blink1.sh >/dev/null
sudo sh -c 'echo 1 >/sys/class/leds/led0/brightness'
if [ -c /dev/video0 ]
then
fswebcam -q -c /home/pi/plant/config.cfg --flip v $path/plant/`date +%Y%m%d-%H%M%S.jpg`
fi
sudo sh -c 'echo 0 >/sys/class/leds/led0/brightness'
/home/pi/plant/blink1.sh &
sync
```
**скрипт который мигает лампочкой blink1.sh**
```
#!/bin/sh
sudo sh -c 'echo none >/sys/class/leds/led0/trigger'
n=1
while test $n -le 30
do
sudo sh -c 'echo 1 >/sys/class/leds/led0/brightness'
sleep 0.5
sudo sh -c 'echo 0 >/sys/class/leds/led0/brightness'
sleep 0.5
n=$(($n + 1))
done
n=1
while test $n -le 15
do
sudo sh -c 'echo 1 >/sys/class/leds/led0/brightness'
sleep 0.25
sudo sh -c 'echo 0 >/sys/class/leds/led0/brightness'
sleep 0.25
sudo sh -c 'echo 1 >/sys/class/leds/led0/brightness'
sleep 0.25
sudo sh -c 'echo 0 >/sys/class/leds/led0/brightness'
sleep 0.25
n=$(($n + 1))
done
```
собственно основной скрипт переключает лампочку в режим управления юзером (по умолчанию она мигает при обращении к флешке, мы же используем ее как индикатор)
далее он делает фото нашего растения
а дальше вызывает скрипт который мигает лампочкой
скрипт — чистая мигалка, для удобства пользователя
30 сек с частотой 1 раз в секунду
15 сек с частотой 2 раза в секунду
а потом гаснет
этот скрипт гарантированно работает < 60 секунд, он перезапускается из основного скрипта раз в минуту.
по индикатору видно в каком состоянии сейчас PI (и когда наконец можно вытянут временно флешку)
осталось мелочь,
полочка была сделана из отходов игры Каркассон (остались картонные листы с дырками)
которые были с помощью скотча собраны в достаточно для нашей задачи крепкую полочку
и на ней был сооружено место где будет стоять предмет, и где крепить камеру!
из ниток были сделаны веревки необходимой длины, и это все повешено на окно!
выглядит это всё
вот «предметный стол» крупнее
это все было оставлено на несколько дней, ночью включал лампочку…
#### финальная обработка
по окончании процесса получили папку с кучей фото,
отобрали нужный диапазон
а делее применяем магию ffmpeg (теперь известного как avconv)
```
avconv -f image2 -r 30 -i src/f%04d.jpg -c:v libx264 -r 30 out2.mp4
```
этот волшебный скрипт берет из папки src файлы с именами f0001.jpg и дальше, и делает .mp4 файл с частотой 30 кадров в секунду.
файлы из вида YYYYMMDD-HHMM.jpg в fNNNNN.jpg переименовываем простейшим скриптом, тут эт не очень интересно.
ну и в итоге вот что получилось
#### трудности и выводы
о чем не думалось в начале,
по странной причине вебкамера на PI не захотела снимать кадры 640x480, только 320x200, может питания мало?
без мигалкой светодиодом было не понятно работает ли оно!
очень рекомендую делать индикатор работы
растение в итоге вылезло из кадра, надо изучать вопрос заранее и делать соответствующее оборудование
солнце — ну ОЧЕНЬ яркое, камеру клинит ;)
по хорошему надо было бы, взять нормальную камеру
правильное постоянное освещение
поставить правильно росток
правильно смонтировать (добавить музыку)
но и то что получилось очень познавательно!
рост идет и ночью!
Raspberry PI очень удобная штука для домашних игрушек!
p.s. про ошибки пожалуйста для начала в личку!
p.p.s. задавайте вопросы! | https://habr.com/ru/post/180227/ | null | ru | null |
# Интегрируем Webpack в Visual Studio 2015
В статье я расскажу как сделать работу с webpack из Visual Studio удобнее, а именно: автоматический запуск webpack при открытии проекта, бандлинг при изменении файлов и оповещение об ошибках на рабочем столе.
Установка
=========
Установим webpack, если он у вас еще не установлен.
```
npm install webpack babel-loader babel-core --save-dev
```
Далее установим дополнение [Webpack Task Runner](https://visualstudiogallery.msdn.microsoft.com/5497fd10-b1ba-474c-8991-1438ae47012a) (Tools -> Extensions & Updates).
Конфигурационный файл
=====================
После установки дополнения в Visual Studio появится новый шаблон WebPack Configuration File.
Добавим его в наш проект.
Шаблонный `webpack.config.js` выглядит так:
```
"use strict";
module.exports = {
entry: "./src/file.js",
output: {
filename: "./dist/bundle.js"
},
devServer: {
contentBase: ".",
host: "localhost",
port: 9000
},
module: {
loaders: [
{
test: /\.jsx?$/,
loader: "babel-loader"
}
]
}
};
```
В `entry` указываем входную точку нашего js проекта, в `output` указываем куда сохранять готовый бандл.
Если у вас несколько входных точек (например, вы разрабатываете компоненты для разных страниц), то в `entry` можно передать несколько файлов вот так:
```
entry: {
file1: "./src/file1.js",
file2: "./src/file2.js"
}
```
Чтобы сохранить несколько бандлов изменим поле `output`.
```
output: {
path: path.join(__dirname, "./dist"),
filename: "[name].js"
}
```
В итоге, на выходе получим два бандла: `file1.js` и `file2.js`.
Базовая настройка завершена. Чтобы убедиться что все работает запустим `Run-Development` из Task Runner.
Так как вручную запускать `Run-Development` не удобно, мы заставим webpack следить за изменениями в файлах. Для этого у него есть режим `--watch`. Запускать webpack в этом режиме будем каждый раз при открытии проекта. Добавим строчку
`///`
в начало `webpack.config.js` и все готово. Да, так просто!
Оповещение о результатах сборки
===============================
Добавим оповещения о результатах сборки. Будем использовать [WebpackNotifierPlugin](https://www.npmjs.com/package/webpack-notifier).
Установим его с помощью команды:
`npm install --save-dev webpack-notifier`
Модифицируем наш `webpack.config.js` файл
```
var WebpackNotifierPlugin = require('webpack-notifier');
module.exports = {
// ...
plugins: [
new WebpackNotifierPlugin()
]
};
```
Теперь при удачной сборке, на рабочем столе появится вот такое уведомление:
На этом все. У webpack есть еще live-reloading и profiling, их рассмотрим в следующий раз.
Спасибо за внимание. | https://habr.com/ru/post/278103/ | null | ru | null |
# Новые версии Mail.Ru Агента
`в течение последних суток запустили сразу три новых версии клиентов Mail.Ru Агента - для Windows (5.5), J2ME (3.5) и Symbian. все они уже доступны для загрузки с официального сайта.
**Windows*** возможность использования произвольного количества учетных записей Mail.Ru и ICQ одновременно (включая проверку новой почты сразу в нескольких ящиках Mail.Ru);
* конференции (два режима - любой участник может пригласить любых новых участников, либо набор участников определяется создателем конференции);
* микроблоггинг (статусные сообщения Mail.Ru Агента транслируются еще и на веб-проекты Мой Мир и Блоги).
**J2ME*** поддкржка протокола ICQ и произвольного количества учетных записей (аналогично Windows-клиенту);
* карты и пробки (с поддержкой GPS для телефонов, в которых есть приемник);
* значительный рефакторинг GUI.
**Symbian*** карты и пробки (позиционирование по GPS и LBS);
* информер на стартовом экране (погода, пробки, курсы валют);
* анимированные меню, поддержка системных скинов;
* поиск контактов Mail.Ru по анкетным данным.
Наиболее "вирусными" фичами являются, конечно, конференции и микроблоггинг. Реальное влияние на глобальное коммьюнити станет заметно в течение следующей недели, но даже у нас в офисе уже случилось настоящее безумие: позабыв про общую офисную почтовую рассылку, все стали остервенело постить сообщения в микроблоги, параллельно объединяясь в конференции типа "Обед", "Отдел такой-то" и т.д. Очень, конечно, приятно делать не высосанный из пальца, а реально востребованный людьми функционал.
И, конечно, хочется особенно отметить клиент для Symbian - продукт, по функционалу уникальный в своем роде. Мультипротокольность (Mail.Ru Агент, ICQ, XMPP), почтовый клиент с поддержкой произвольного количества ящиков, карты с пробками, информеры, возможность кастомизации.. В части мобильного мессаджинга мы объективно являемся лидерами, конкурируя, наверное, только со Скайпом, что очень приятно сознавать.
Теперь немного багфиксов по результатм тестирования, массовый апдейт всех пользователей и - в отпуск. :) Нам очеь нужна помощь сообщества в тестировании и доработках - пожалуйста, рассказывайте нам о своих впечатлениях.` | https://habr.com/ru/post/60922/ | null | ru | null |
# Композиция протоколов для инъекции зависимостей
Мне нравится использовать композицию и инъекцию зависимостей, но когда каждая сущность начинает инъектится несколькими зависимости, получается некое нагромождение.
Проект растет и приходится инъектить все больше зависимостей в объекты, рефакторить методы помногу раз, Xcode не особо с этим помогает, как мы знаем.
Но есть более управляемый способ.
*Статья будет полезна тем, кто только начал использовать DI или вообще его не использует, и еще не особо знаком с IoC. Подход применим и к другим языкам, но т.к автор пишет на Swift, все примеры будут на нем (прим. пер.)*
Проблема
--------
Предположим, есть объект, которому вдруг становится нужен провайдер `ImageProvider`, напишем что-то вроде этого:
```
class FooCoordinator {
let imageProvider: ImageProvider
init(..., imageProvider: ImageProvider)
///...
}
```
Довольно просто и удобно + это позволит подменить провайдер в тестах.
По мере роста кодовой базы, появляется все больше зависимостей, каждая из которых заставляет:
* рефакторить место, где она используется
* добавлять новую переменную
* писать некоторое количество бойлерплейта
например, по прошествии нескольких месяцев у объекта может появится 3 зависимости:
```
class FooCoordinator {
let imageProvider: ImageProvider
let articleProvider: ArticleProvider
let persistanceProvider: PersistanceProvider
init(..., imageProvider: ImageProvider, articleProvider: ArticleProvider, persistanceProvider: PersistanceProvider) {
self.imageProvider = imageProvider
self.articleProvider = articleProvider
self.persistanceProvider = persistanceProvider
///...
}
///...
}
```
Поскольку, обычно в проекте больше чем один класс, то тот же самый паттерн повторяется множество раз.
И надо не забывать, что нужно где-то хранить ссылки на все эти зависимости, например, в `AppController` или `Flow Coordinator`.
Такой подход неминуемо приводит к боли. Боль может мотивировать использовать не совсем правильные решения, Синглтоны например.
*Но нам же нужна простая и легкая поддержка кода, со всеми преимуществами инъекции кода.*
Альтернатива
------------
Мы можем использовать композицию протоколов *(интерфейсов)*, чтобы повысить читаемость и качество обслуживания кода.
Давайте опишем базовый контейнер протокола для любой зависимости которая у нас будет:
```
protocol Has{Dependency} {
var {dependency}: {Dependency} { get }
}
```
*Меняем {Dependency} на имя объекта*
Например для `ImageProvider` это будет выглядеть так:
```
protocol HasImageProvider {
var imageProvider: ImageProvider { get }
}
```
Swift позволяет составлять композицию из протоколов используя оператор `&`, это означает, что наши сущности теперь могут содержать просто одно хранилище зависимостей:
```
class FooCoordinator {
typealias Dependencies = HasImageProvider & HasArticleProvider
let dependencies: Dependencies
init(..., dependencies: Dependencies)
}
```
Теперь в `AppController` или `Flow Coordinator` (Или что там используется для создания сущностей) можно спрятать все зависимости под одним контейнером в виде структуры:
```
struct AppDependency: HasImageProvider, HasArticleProvider, HasPersistanceProvider {
let imageProvider: ImageProvider
let articleProvider: ArticlesProvider
let persistanceProvider: PersistenceProvider
}
```
И все зависимости приложения теперь будут хранится в контейнере, который не имеет какой либо логики или чего-то магического, просто структура.
Этот подход повышает читабельность, так же все зависимости хранятся вместе, но что более важно — это то, что код конфигурации всегда один и тот же, не зависимо какие из зависимостей нужны вашему объекту:
```
class FlowCoordinator {
let dependencies: AppDependency
func configureViewController(vc: ViewController) {
vc.dependencies = dependencies
}
}
```
Каждый объект описывает только те зависимости которые ему реально нужны, и он получит только их.
Например, если нашему `FooCoordinator` понадобится `ImageProvider`, то он прокинет `AppDependency` структуру, а проверка типов в Swift обеспечит доступ только к `ImageProvider`
Если в дальнейшем понадобится больше зависимостей, например `PersistanceProvider`, то просто нужно добавить её в наш `typealias`:
```
class FooCoordinator {
typealias Dependencies = HasImageProvider & HasArticleProvider & HasPersistanceProvider
}
```
На этом всё.
У такого подхода есть ряд преимуществ:
* Зависимости четко определены и всегда консистентны, в любом объекте, по всему проекту
* Когда зависимости объекта меняются, нужно поменять только `typealias`
* Не нужно трогать ни инициализатор ни функции конфигурации.
* Любой из объектов, благодаря системе проверки типов в Swift, получает только те зависимости, которые ему нужны. | https://habr.com/ru/post/326712/ | null | ru | null |
# Какое тестовое задание выдать джависту? Лучше просто поговорить
Всем привет, меня зовут Сергей, я руковожу группой серверных программистов студии Whalekit и активно занимаюсь наймом в эту группу. Сервер пишем на Java — соответственно, нанимаем мы тоже джавистов.
В 2016 году мы выдавали кандидатам тестовое задание, успешным кандидатам назначалось техническое собеседование.
В 2018 мы добавили 45-минутный «мотивирующий на выполнение тестового задания» этап, чтобы кандидаты лучше понимали, соответствует ли вакансия их ожиданиям.
В 2021 мы полностью отказались от тестовых заданий.
Но обо всем по порядку.
---
Получать выполненные тестовые задания здорово: можно оценить технические навыки и сформировать обширное представление об опыте кандидата, релевантном вакансии. Если, конечно, тестовое релевантно вакансии.
> В студии Whalekit мы делаем мобильные игры с богатой метой (апгрейд оружия и персонажей, кланы, прокачка базы, списки лидеров, подбор оппонента по elo-рейтингу). Добрая половина работы серверных программистов — это написание новых и доработка существующих сервисов хранения. Мы храним профиль игрока в MongoDB и обновляем под распределенным локом на redis. В сервисе хранения наград используем постгрес с изоляцией транзакций repeatable read. Есть сервисы, которые просто хранят состояние в redis, а есть такие, логика которых реализована на lua для атомарного исполнения внутри redis.
>
> Наше тестовое выглядит так:
>
> *Написать и покрыть тестами класс, считающий лайки, которые ставят игроки друг другу, и сохраняющий их количество в базу данных (интерфейс ниже). Базу данных выбрать самостоятельно с учетом того, что система должна работать под большой нагрузкой и масштабироваться горизонтально. Реализовать на Java.*
>
> `interface LikeService {
> void like(String playerId);
> long getLikes(String playerId);
> }`
>
> В выполненных заданиях мы смотрели, в основном, на корректность конкурентного обновления счетчика, обработку ошибок, качество тестов и сам подход к написанию тестов. Так удается сформировать достаточное представление об опыте кандидата в написании такого рода сервисов хранения, очень релевантного целому классу наших задач.
>
>
Но и проблем с тестовыми множество. Начнем с того, что, поскольку время на выполнение задания не фиксируется, наниматель не может нормировать результат по времени. Более того, не все выполняют задание самостоятельно.
Бывает и так, что кандидат тратит много времени и сил на тестовое, но не получает преимущества. В сложной архитектуре больше шансов допустить ошибку.
> Например, простым в реализации решением будет выбор MongoDB в качестве базы данных. Горизонтальное масштабирование в MongoDB есть из коробки: достаточно использовать playerId в качестве ключа шардирования. Атомарность обновления счетчика также можно переложить на встроенный функционал базы данных — скажем, используя команду updateOne и оператор $inc. Для тестов можно выбрать любой привычный подход — модульные тесты с моками на MongoDB-драйвере, функциональные тесты на реальной MongoDB, запускаемой в Testcontainers, и т. д.
>
> На этом можно остановиться, а идеи по дальнейшим оптимизациям оставить для обсуждения на предстоящем собеседовании. Но кандидат не хочет останавливаться — и решает добавить в свой класс in-memory батчинг лайков, а в базу данных батчи записывать отдельным потоком по таймеру. Тут-то и возникает множество сложностей и ошибок. Потеря консистентности чтения, так как у разных экземпляров сервиса собственные батчи. Ошибки синхронизации наполняющих батч потоков и потока, записывающего данные в БД. Снижение надежности из-за возможной потери целого батча при падении сервиса или просто из-за таймаута при попытке записи в БД. Обилие такого рода проблем скорее добавляет минусов при просмотре тестового задания, чем плюсов за старания.
>
>
Главная же и всеобъемлющая проблема в том, что, чем опытнее и востребованнее на рынке кандидат, тем меньше он хочет тратить время и силы на тестовое, понимая, что выполнение тестового — довольно неблагодарное занятие.
В попытке снизить «неблагодарность тестового» мы добавили дополнительный этап собеседования между созвоном с рекрутером и выдачей тестового задания. На этом мотивирующем собеседовании мы сначала расспрашиваем о том, что для кандидата важно на новой работе, а потом подробно рассказываем, как это реализовано у нас. Большинство кандидатов задают вопросы про команду и процессы, стек технологий, состав сервисов, нагрузку и размер БД, какие крупные задачи есть в работе, что запланировано на ближайшие полгода.
Это неплохо работало до 2021. После отсева кандидатов, чьи ожидания не совпали с ответами, отказов выполнять тестовое было меньше 10%.
Однако с пандемией востребованность джавистов сильно возросла. Возросла и важность быстрого принятия решения о найме. Получая тестовые задания, кандидаты уже имеют на руках несколько хороших офферов. Многие крупные компании пошли по пути сокращения процедуры найма до офферов за один день.
Так, двигаясь в ногу со временем, мы отказались от тестовых.
Конечно, не хотелось отказываться от полноценного впечатления о квалификации, которое кандидат мог продемонстрировать в тестовом задании. Поэтому мы переформулировали ключевые моменты, на которые смотрели в тестовом, в открытые вопросы.
> Вместо тестового я теперь голосом обсуждаю с кандидатом его опыт написания тестов, опыт горизонтального масштабирования сервисов и БД. Озвучиваю проблему гонки read-modify-write, если непонятно, могу показать пример кода. Спрашиваю возможные пути решения как с точки зрения практического опыта, так и с точки зрения кругозора.
>
>
Отказавшись от тестового, мы существенно сократили время принятия решения по найму. Если раньше от первого разговора с рекрутером до выставления оффера, с учетом времени на выполнение тестового задания, проходило в среднем 2-3 недели, то теперь мы вполне укладываемся в неделю. Помимо разговора с рекрутером и презентации оффера, технический этап собеседования выродился в два часовых разговора, которые в особом случае можно превратить в один двухчасовой.
Быстрые офферы — в духе времени. Отказавшись от старых методов, вы получаете возможность конкурировать в найме. А собеседование становится более неформальным: все любят рассказывать про свой опыт.
*Избавьтесь от тестового, пока не поздно!*
А вы готовы выполнять тестовое, и в каком случае? Как вам офферы за один день? На что вы обращаете внимание при найме в свою команду? | https://habr.com/ru/post/658435/ | null | ru | null |
# Книга «Node.js в действии. 2-е издание»
[](https://habrahabr.ru/company/piter/blog/351602/) Второе издание «Node.js в действии» было полностью переработано, чтобы отражать реалии, с которыми теперь сталкивается каждый Node-разработчик. Вы узнаете о системах построения интерфейса и популярных веб-фреймворках Node, а также научитесь строить веб-приложения на базе Express с нуля. Теперь вы сможете узнать не только о Node и JavaScript, но и получить всю информацию, включая системы построения фронтэнда, выбор веб-фреймворка, работу с базами данных в Node, тестирование и развертывание веб-приложений.
Технология Node все чаще используется в сочетании с инструментами командной строки и настольными приложениями на базе Electron, поэтому в книгу были включены главы, посвященные обеим областям. Внутри поста будет рассмотрен отрывок «Хранение данных в приложениях»
Node.js ориентируется на невероятно широкий спектр разработчиков со столь же разнообразными потребностями. Ни одна база данных или технология хранения данных не способна удовлетворить большинство сценариев использования, обслуживаемых Node. В этой главе предоставлен широкий обзор возможностей хранения данных наряду с некоторыми важными высокоуровневыми концепциями и терминологией.
### 8.1. Реляционные базы данных
На протяжении почти всего времени существования веб-технологий реляционные базы данных занимали ведущее место в области хранения данных. Эта тема уже рассматривается во многих других книгах и образовательных программах, поэтому мы не будем тратить много времени на ее рассмотрение.
Реляционные базы данных, базирующиеся на математических концепциях реляционной алгебры и теории множеств, известны с 1970-х годов. Схема (schema) определяет формат различных типов данных и отношения, существующие между этими типами. Например, при построении социальной сети можно создать типы данных User и Post и определить отношения «один ко многим» между User и Post. Далее на языке SQL (Structured Query Language) формулируются запросы к данным типа «Получить все сообщения, принадлежащие пользователю с идентификатором 123», или на SQL: SELECT \* FROM post WHERE user\_id=123.
### 8.2. PostgreSQL
MySQL и PostgreSQL (Postgres) остаются самыми популярными реляционными базами данных для приложений Node. Различия между реляционными базами данных в основном эстетические, поэтому этот раздел в равной степени относится и к другим реляционным базам данных — например, MySQL в Node. Но сначала разберемся, как установить Postgres на машине разработки.
### 8.2.1. Установка и настройка
Сначала нужно установить Postgres в вашей системе. Простой команды npm install для этого недостаточно. Инструкции по установке зависят от платформы. В macOS установка сводится к простой последовательности команд:
```
brew update
brew install postgres
```
Если в вашей системе поддержка Postgres уже установлена, вы можете столкнуться с проблемами при попытке обновления. Выполните инструкции для своей платформы, чтобы произвести миграцию существующих баз данных, либо полностью сотрите каталог базы данных:
```
# WARNING: will delete existing postgres configuration & data
rm –rf /usr/local/var/postgres
```
Затем инициализируйте и запустите Postgres:
```
initdb -D /usr/local/var/postgres
pg_ctl -D /usr/local/var/postgres -l logfile start
```
Эти команды запускают демона Postgres. Демон должен запускаться каждый раз, когда вы перезагружаете компьютер. Возможно, вам строит настроить автоматическую загрузку демона Postgres при запуске; во многих сетевых руководствах можно найти описание этого процесса для вашей операционной системы.
В составе Postgres устанавливаются некоторые административные программы командной строки. Ознакомьтесь с ними; необходимую информацию можно найти в электронной документации.
### 8.2.2. Создание базы данных
После того как демон Postgres заработает, необходимо создать базу данных. Эту процедуру достаточно выполнить всего один раз. Проще всего воспользоваться программой createdb из режима командной строки. Следующая команда создает базу данных с именем articles:
```
createdb articles
```
Если операция завершается успешно, команда ничего не выводит. Если база данных с указанным именем уже существует, команда ничего не делает и сообщает об ошибке.
Как правило, приложения в любой момент времени подключены только к одной базе данных, хотя можно настроить сразу несколько баз данных в зависимости от режима, в котором работает база данных. Во многих приложениях различаются по крайней мере два режима: режим разработки и режим реальной эксплуатации.
Чтобы удалить все данные из существующей базы данных, выполните команду dropdb с терминала, передав ей имя базы данных в аргументе:
```
dropdb articles
```
Чтобы снова использовать базу данных, необходимо выполнить команду createdb.
### 8.2.3. Подключение к Postgres из Node
Самый популярный пакет для взаимодействия с Postgres из Node называется pg. Его можно установить при помощи npm:
```
npm install pg --save
```
Когда сервер Postgres заработает, база данных будет создана, а пакет pg установлен, вы сможете переходить к использованию базы данных из Node. Прежде чем вводить какие-либо команды к серверу, необходимо создать подключение к нему, как показано в листинге 8.1
```
const pg = require('pg');
const db = new pg.Client({ database: 'articles' }); ← Параметры конфигурации подключения.
db.connect((err, client) => {
if (err) throw err;
console.log('Connected to database', db.database);
db.end(); ← Закрывает подключение к базе данных, позволяя процессу node завершиться.
});
```
Подробную документацию по pg.Client и другим методам можно найти на вики-странице пакета pg на [GitHub](https://github.com/brianc/node-postgres/wiki).
### 8.2.4. Определение таблиц
Чтобы хранить данные в PostgreSQL, сначала необходимо определить таблицы и формат данных, которые в них будут храниться. Пример такого рода приведен в листинге 8.2 (ch08-databases/listing8\_3 в архиве исходного кода книги).
Листинг 8.2. Определение схемы
```
db.query(`
CREATE TABLE IF NOT EXISTS snippets (
id SERIAL,
PRIMARY KEY(id),
body text
);
`, (err, result) => {
if (err) throw err;
console.log('Created table "snippets"');
db.end();
});
```
### 8.2.5. Вставка данных
После того как таблица будет определена, в нее можно вставить данные запросами INSERT (листинг 8.3). Если значение id не указано, то PostgreSQL выберет его за вас. Чтобы узнать, какой идентификатор был выбран для конкретной записи, присоедините условие RETURNING id к запросу; идентификатор будет выведен в строках результата, переданного функции обратного вызова.
Листинг 8.3. Вставка данных
```
const body = 'hello world';
db.query(`
INSERT INTO snippets (body) VALUES (
'${body}'
)
RETURNING id
`, (err, result) => {
if (err) throw err;
const id = result.rows[0].id;
console.log('Inserted row with id %s', id);
db.query(`
INSERT INTO snippets (body) VALUES (
'${body}'
)
RETURNING id
`, () => {
if (err) throw err;
const id = result.rows[0].id;
console.log('Inserted row with id %s', id);
});
});
```
### 8.2.6. Обновление данных
После того как данные будут вставлены, их можно будет обновить запросом UPDATE (листинг 8.4). Количество записей, задействованных в обновлении, будет доступно в свойстве rowCount результата запроса. Полный пример для этого листинга содержится в каталоге ch08-databases/listing8\_4.
Листинг 8.4. Обновление данных
```
const id = 1;
const body = 'greetings, world';
db.query(`
UPDATE snippets SET (body) = (
'${body}'
) WHERE id=${id};
`, (err, result) => {
if (err) throw err;
console.log('Updated %s rows.', result.rowCount);
});
```
### 8.2.7. Запросы на выборку данных
Одна из самых замечательных особенностей реляционных баз данных — возможность выполнения сложных произвольных запросов к данным. Запросы выполняются командой SELECT, а простейший пример такого рода представлен в листинге 8.5.
Листинг 8.5. Запрос данных
```
db.query(`
SELECT * FROM snippets ORDER BY id
`, (err, result) => {
if (err) throw err;
console.log(result.rows);
});
```
### 8.3. Knex
Многие разработчики предпочитают работать с командами SQL в своих приложениях не напрямую, а через абстрактную надстройку. Это желание вполне понятно: конкатенация строк в команды SQL может быть громоздким процессом, который усложняет понимание и сопровождение запросов. Сказанное особенно справедливо по отношению к языку JavaScript, в котором не было синтаксиса представления многострочных строк до появления в ES2015 шаблонных литералов (см. <https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Template_literals>). На рис. 8.1 показана статистика Knex с количеством загрузок, доказывающих популярность.
Knex — пакет Node, реализующий облегченную абстракцию для SQL, известную как построитель запросов. Построитель запросов формирует строки SQL через декларативный API, который имеет много общего с генерируемыми командами SQL. Knex API интуитивен и предсказуем:
```
knex({ client: 'mysql' })
.select()
.from('users')
.where({ id: '123' })
.toSQL();
```
Этот вызов создает параметризованный запрос SQL на диалекте MySQL:
```
select * from `users` where `id` = ?
```
### 8.3.1. jQuery для баз данных
Хотя стандарты ANSI и ISO SQL появились еще в середине 1980-х годов, большинство баз данных продолжает использовать собственные диалекты SQL. PostgreSQL является заметным исключением: эта база данных может похвастать соблюдением стандарта SQL:2008. Построитель запросов способен нормализировать различия между диалектами SQL, предоставляя единый унифицированный интерфейс для генерирования SQL в разных технологиях. Такой подход обладает очевидными преимуществами для групп, регулярно переключающихся между разными технологиями баз данных.
В настоящее время Knex.js поддерживает следующие базы данных: PostgreSQL; MSSQL; MySQL; MariaDB; SQLite3; Oracle.
В табл. 8.1 сравниваются способы генерирования команды INSERT в зависимости от выбранной базы данных.
Таблица 8.1. Сравнение команд SQL, сгенерированных Knex, для разных баз данных
Knex поддерживает обещания (promises) и обратные вызовы в стиле Node.
### 8.3.2. Подключение и выполнение запросов в Knex
В отличие от многих других построителей запросов, Knex также может подключаться и выполнять запросы к выбранному драйверу базы данных за вас.
```
db('articles')
.select('title')
.where({ title: 'Today's News' })
.then(articles => {
console.log(articles);
});
```
По умолчанию запросы Knex возвращают обещания, но они также поддерживают соглашения обратного вызова Node с использованием .asCallback:
```
db('articles')
.select('title')
.where({ title: 'Today's News' })
.asCallback((err, articles) => {
if (err) throw err;
console.log(articles);
});
```
В главе 3 мы взаимодействовали с базой данных SQLite непосредственно при помощи пакета sqlite3. Этот API можно переписать с использованием Knex. Прежде чем запускать этот пример, сначала проверьте из npm, что пакеты knex и sqlite3 установлены:
```
npm install knex@~0.12.0 sqlite3@~3.1.0 --save
```
В листинге 8.6 sqlite используется для реализации простой модели Article. Сохраните файл под именем db.js; он будет использоваться в листинге 8.7 для взаимодействия с базой данных.
Листинг 8.6. Использование Knex для подключения и выдачи запросов к sqlite3
```
const knex = require('knex');
const db = knex({
client: 'sqlite3',
connection: {
filename: 'tldr.sqlite'
},
useNullAsDefault: true ← Выбор этого режима по умолчанию лучше работает при смене подсистемы баз данных.
});
module.exports = () => {
return db.schema.createTableIfNotExists('articles', table => {
table.increments('id').primary(); ← Определяет первичный ключ с именем «id», значение которого автоматически увеличивается при вставке.
table.string('title');
table.text('content');
});
};
module.exports.Article = {
all() {
return db('articles').orderBy('title');
},
find(id) {
return db('articles').where({ id }).first();
},
create(data) {
return db('articles').insert(data);
},
delete(id) {
return db('articles').del().where({ id });
}
};
```
Листинг 8.7. Взаимодействие с API на базе Knex
```
db().then(() => {
db.Article.create({
title: 'my article',
content: 'article content'
}).then(() => {
db.Article.all().then(articles => {
console.log(articles);
process.exit();
});
});
})
.catch(err => { throw err });
```
SQLite требует минимальной настройки: вам не нужно загружать демон сервера или создавать базы данных за пределами приложения. SQLite записывает все данные в один файл. Выполнив предыдущий код, вы увидите, что в текущем каталоге появился файл articles.sqlite. Чтобы уничтожить базу данных SQLite, достаточно удалить всего один файл:
```
rm articles.sqlite
```
SQLite также поддерживает режим работы в памяти, при котором запись на диск вообще не осуществляется. Этот режим обычно используется для ускорения выполнения автоматизированных тестов. Для настройки режима работы в памяти используется специальное имя файла :memory:. При открытии нескольких подключений к файлу :memory: каждое подключение получает собственную изолированную базу данных:
```
const db = knex({
client: 'sqlite3',
connection: {
filename: ':memory:'
},
useNullAsDefault: true
});
```
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/product_by_id/96424749)
» [Оглавление](https://storage.piter.com/upload/contents/978549603212/978549603212_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978549603212/978549603212_p.pdf)
Для Хаброжителей скидка 20% по купону — **Node.js** | https://habr.com/ru/post/351602/ | null | ru | null |
# Zabbix 2.2: Мониторинг температуры процессора Windows машины
 **Немного о себе и о рабочей среде**Работаю инженером в компании из двух человек, обслуживаем десяток муниципальных и коммерческих предприятий с парком компьютеров до 100 штук из них 99% windows машин. Занимаемся всем от прокладки сети до настройки информационных систем. Работы много и иногда очень хочется сделать свою жизнь чуточку проще и вот, в очередной такой момент, я столкнулся с системой мониторинга zabbix. При первом знакомстве с zabbix, меня переполняли эмоции и фантазии о мониторинге всего на свете. Первой была идея предотвращения физических неисправностей путем отслеживания основных показателей железа, например температуру или напряжение, поскольку мне видится весьма логичным и экономически выгодным, поменять термопасту или начать подбирать замену уставшей технике до того как пользователь сообщит о её преждевременной кончине или страшных тормозах.
Система мониторинга Zabbix действительно очень мощная и гибкая, но, к сожалению, далеко не все аспекты для отслеживания доступны из стандартных коробочных шаблонов. Таким образом, моя фантазия с треском разбилась об стену отсутствия штатных инструментов мониторинга температур в Windows.
Процесс поиска в интернете поставил меня перед фактом, что вытащить температуры железа без сторонних средств нельзя. При поиске этих самых средств, я [столкнулся](https://www.zabbix.com/forum/showthread.php?t=19014) с популярной утилитой [SpeedFan](http://www.almico.com/speedfan.php), которая умеет собирать данные о температуре устройств, скорости вентиляторов, напряжений. Но получить от неё готовые к обработке данные без установки еще одной утилиты нет возможности. Плюс ко всему они не open source и требует активации компонента SNMP протокола. Вывод: попробовать на windows сервере без IMPI можно, но как вариант массового распространения в сети – не годен. Дальнейший поиск навел на программы [hwmonitor](http://www.cpuid.com/softwares/hwmonitor-pro.html) и [aida64](http://www.aida64.com/) — монстры, крупногабаритные и платные.
##### OpenHardwareMonitor
Уже почти отчаявшись, зацепился за [короткое сообщение](https://www.zabbix.com/forum/showpost.php?p=143811&postcount=12) на англоязычном форуме zabbix. Рекомендовали небольшую [open source](http://openhardwaremonitor.org/license/) утилиту [OpenHardwareMonitor](http://openhardwaremonitor.org/) — она имеет графический интерфейс и умеет считывать температуру устройств с датчиков. И самое главное её автор, по [просьбе трудящихся написал консольную версию](https://code.google.com/p/open-hardware-monitor/issues/detail?id=230)(последняя версия 28.10.2012), выводящую информацию в готовой для обработки форме.
**Версия с GUI**:
**Консольная версия**:
Консольная версия состоит из двух файлов, exe исполняемого файла и dll библиотеки.
* OpenHardwareMonitorReport.exe
* OpenHardwareMonitorLib.dll
Где брать данные мы поняли, теперь нужно наладить поставки значений показателей Zabbix серверу.
##### Настройка сервера
Для начала на сервер для узла сети добавим новый элемент данных:
Назовем его: CPU Temperature. (Температура процессора)
Тип: Zabbix агент
Ключ: Temperature.CPU[0]. (Название не принципиально, главное чтобы с конфигом агента совпадал).
Интерфейс узла сети: ip\dns. (Узел, который будем мониторить).
Тип информации: Числовой (целое положительное)
Тип данных: Десятичный
Интервал обновлений (в сек): 3600. (На скриншоте стоит 10 сек, для временной проверки).
На сервере закончили, переходим к конфигурации клиента.
##### Настройка клиента
Нестандартные данные мы будем отправлять через Zabbix agent в конфиге(zabbix\_agentd.conf) которого предусмотрены так называемые пользовательские параметры – UserParameters вида:
```
UserParameter=ключ[*],команда
```
Команда, через которую мы получим значение, обрабатывается на стороне клиента. Zabbix сервер будет получать ключ с присвоенным ему значением. В статье имеется в виду, что агент у вас уже установлен в виде службы и дружит с сервером.
В конец конфиг файла агента добавляем:
```
UserParameter=Temperature.CPU[*], C:\OpenHardwareMonitor\CPUTemperature.bat
```
CPUTemperature.bat — написанный мной batch файл который вытаскивает из OpenHardwareMonitor, среднюю температуру по процессору. В программе эта строка называется CPU Package.
В C:\OpenHardwareMonitor лежат 3 файла:
* OpenHardwareMonitorReport.exe
* OpenHardwareMonitorLib.dll
* CPUTemperature.bat
**Содержимое CPUTemperature.bat** **Здесь мой старый код** Инвалид на костылях.
```
@echo off
del /s C:\OpenHardwareMonitor\*.txt >nul 2>null
call start /B /wait C:\OpenHardwareMonitor\OpenHardwareMonitorReport.exe >> C:\OpenHardwareMonitor\OpenHardwareMonitorReport.txt
find "CPU Package :" C:\OpenHardwareMonitor\OpenHardwareMonitorReport.txt | find "temperature" >>C:\OpenHardwareMonitor\Result.txt
for /f "tokens=7 delims= " %%i in (C:\OpenHardwareMonitor\Result.txt) do echo %%i >> C:\OpenHardwareMonitor\temp.txt
TYPE C:\OpenHardwareMonitor\temp.txt
```
Взываю к habra-сообществу о помощи в преобразовании этого ужаса в нормальный программный код без костылей из текстовых файлов.
Тем не менее, со своей задачей скрипт справляется.
**Обновлено:** Новый код от уважаемого [cawaleb](https://habrahabr.ru/users/cawaleb/)
```
@echo off
for /F "usebackq tokens=7-10" %%a in (`C:\OpenHardwareMonitor\OpenHardwareMonitorReport.exe`) do echo %%b %%c %%d| findstr .*lpc.*\/temperature\/0>nul && set temper=%%a
echo %temper%
```
Для процессоров intel так же справедлив вариант с find вместо findstr и регулярным выражением:
```
@echo off
for /F "usebackq tokens=7-10" %%a in (`C:\OpenHardwareMonitor\OpenHardwareMonitorReport.exe`) do echo %%b %%c %%d| find "/intelcpu/0/temperature/0">nul && set temper=%%a
echo %temper%
```
Скрипт возвращает значение в виде десятичного числа.
После этого изменения конфиг файла и размещения всех файлов и скриптов, перезагружаем службу zabbix agent.
Начинаем получать значения на сервер:
##### Заключение
Решена задача по извлечения температуры CPU. По той же схеме можно получить температуру GPU. Но по-прежнему остро стоят вопросы определения скорости работы вентиляторов, напряжения на бп, а так же вопрос есть ли способ проверки состояния северного и южного мостов.
**Обновление:** Добавлен код для CPUTemperature.bat предложенный уважаемым [Cawaleb](https://habrahabr.ru/users/cawaleb/). Не забудьте поблагодарить его, за то, что отозвался помочь! | https://habr.com/ru/post/228095/ | null | ru | null |
# Развертывание Mercurial репозиториев через FastCGI с использованием Nginx на FreeBSD
Поддался я влиянию моды и захватывающим перспективам DVCS с недавних пор. Это вытолкнуло меня с наезженной колеи Subversion + Trac и заставило искать новые схемы как хранить исходные тексты в разных компаниях. И предоставлять для них удобный доступ разработчикам, заказчикам и другим заинтересованным личностям.
Так сложилось, что я специализируюсь во FreeBSD и не так хорошо разбираюсь в Linux'ах. И еще предпочитаю где можно использовать Nginx вместо Apache httpd. Поэтому решил я сделать для себя унифицированную архитектуру, которая позволит хранить неограниченное количество репозиториев и разграничивать для них доступ различных группам людей на этой платформе.
Само собой, Bitbucket — наше все. Но у любого разработчика есть закрытые проекты, которые в паблик выкладывать не хотелось бы. Можно, конечно, платить $50 в месяц за возможность хостить 25 проектов на bitbucket'е. Я лично считаю, что лучше эти деньги потратить на dedicated сервер и поднять себе сколько угодно проектов. Будет не так удобно, но зато свое и с возможностью тюнинга, бекапа и других вкусностей.
#### Постановка задачи
Необходимо иметь хранилище репозиториев Mercurial с возможностью доступа к ним через web. Права доступа должны указываться чтение/запись для конкретных пользователей.
#### Конкретно по пунктам
* Репозитории должны храниться в директории /usr/home/www/repos/
* Настройки Mercurial хранятся в /usr/home/www/repos/cgi/
* Хостинг происходит на локальном сервере. Поэтому доступ только по протоколу http. Снаружи доступ будет по https обслуживаться уже другим сервером так-же на базе nginx и перебрасываться на локальный на 80-й порт.
* Допустим, сервер будет называться dev.example.com. Список репозиториев должен быть доступен по адресу
```
http://dev.example.com/hg/
```
#### Установка необходимых компонентов
Детально о методах развертывания нескольких репозиториев можно ознакомиться на [официальной странице](http://mercurial.selenic.com/wiki/HgWebDirStepByStep). Для этого используется cgi скрипт hgwebdir.cgi. Мы, само-собой, будем использовать его FastCGI версию hgwebdir.fcgi.
Mercurial не включает в поставку самодостаточного FastCGI сервера, который можно запустить на нужном порту. Предполагается, что hgwebdir.fcgi будет запущен средствами apache httpd или lighttpd. Чтоб решить эту задачу, воспользуемся fastcgi wrapper'ом spawn-fcgi.
Итак, первым делом устанавливаем следующие порты* www/spawn-fcgi
* devel/mercurial
* www/nginx
* www/py-flup
#### Настраиваем hgwebdir
Копируем дефолтный скрипт в нашу директорию с настройками
`sudo -u www mkdir /usr/home/www/cgi/
cp /usr/local/share/mercurial/www/hgwebdir.fcgi /usr/home/www/cgi/`
Редактируем наш hgwebdir.fcgi. У меня он выглядит вот так
`#!/usr/bin/env python
from mercurial import demandimport; demandimport.enable()
from mercurial.hgweb.hgwebdir_mod import hgwebdir
from flup.server.fcgi import WSGIServer
WSGIServer(hgwebdir('/usr/home/www/cgi/hgweb.config')).run()`
Далее в фале конфигурации /usr/home/www/cgi/hgweb.config прописываем пути к коллекциям и настройку адреса
`[collections]
/usr/home/www/repos = /usr/home/www/repos
[web]
baseurl = /hg`
Параметр baseurl говорит о том, что все ссылки, которые будет генерировать hgwebdir будут содержать /hg вначале пути (помните, у нас адрес, по которому должны быть доступны репозитории dev.example.com/hg/)
#### Настраиваем spawn-fcgi
В файле конфигурации FreeBSD /etc/rc.conf добавляем следующие строки
`# Mercurial
spawn_fcgi_enable="YES"
spawn_fcgi_app="/usr/local/bin/python"
spawn_fcgi_app_args="/usr/home/www/cgi/hgwebdir.fcgi"
spawn_fcgi_pidfile="/var/run/hg.pid"
spawn_fcgi_bindsocket="/var/run/hg.socket"`
В качестве spawn\_fcgi\_app можно указать сам скрипт, а не путь к интерпретатору питона. Но тогда сервис не будет корректно останавливаться, т.к. системные скрипты будут искать процесс с именем hgwebdir.fcgi чтоб остановить, а реально процесс называется python, т.к. hgwebdir.fcgi — это программа, запускаемая с помощью интерпретатора.
Теперь можно запускать демона
`sudo /usr/local/etc/rc.d/spawn-fcgi start`
#### Настраиваем nginx
В файле конфигурации /usr/local/etc/nginx/nginx.conf создайте новую секцию server примерно следующего содержания
```
server {
listen 80;
server_name dev.example.com;
set_real_ip_from 172.16.224.1;
real_ip_header X-Forwarded-For;
location / {
root /usr/local/www/nginx;
index index.html index.htm;
}
location /hg {
if ($uri ~ /hg(/.*)$) {
set $path $1;
}
client_max_body_size 100M;
fastcgi_pass unix:/var/run/hg.socket;
include fastcgi_params;
fastcgi_param PATH_INFO $path;
fastcgi_param REMOTE_USER $remote_user;
auth_basic "Mercurial repositories";
auth_basic_user_file hg_htpasswd;
}
}
```
В этом месте будьте предельно внимательны. Nginx по умолчанию не устанавливает переменных, которые необходимы для коректной работы с mercurial. Поэтому я постараюсь объяснить значение каждой строки. Мне они давались изучением исходников mercurial'а :)
*set\_real\_ip\_from*, *real\_ip\_header* — как я упоминал выше, внешний https доступ обслуживает отдельный nginx, стоящий на сервере, который смотрит в мир. Чтоб на нашем локальном сервере в логи попадали реальные адреса клиентов, а не адрес этого внешнего сервера, который проксирует запросы, и были добавлены эти директивы.
*if блок* и переменная *PATH\_INFO* — для определения репозитория, к которому идет обращение, hgwebdir использует переменную PATH\_INFO. Нам нужно отрезать начало пути /hg, т.к. в противном случае hgwebdir будет думать, что вы пытаетесь обратиться к репозиторию под именем «hg». Здесь нужно быть внимательным и для вычисления PATH\_INFO использовать переменную nginx'а $uri, а не $request\_uri, как упоминают некоторые мануалы в интернете. Т.к. $request\_uri содержит в себе еще и $args помимо пути. И если передать его в PATH\_INFO, то вы будете получать 404 Not Found при попытке работать с репозиторием.
*client\_max\_body\_size* — по умолчанию, максимальная длина запроса к nginx 1М. Естественно, если вы попытаетесь закомитить изменений больше, чем на 1М, или сделать первоначальный push большого репозитория, то запрос не пройдет. Поэтому этот размер увеличен до 100М. Думаю, в большинстве случаев этого достаточно.
*include fastcgi\_params* — подключаем другие стандартные переменные типа QUERY\_STRING и т.д.
*REMOTE\_USER* — в этой переменной hgwebdir ожидает получить имя пользователя.
Ну и последние две строчки — настройка http basic auth авторизации.
Все, теперь можете поправить другие, не связанные с hg параметры в nginx.conf (например, куда логи складывать) и запускать веб сервер.
Добавляем `nginx_enable="YES"` в /etc/rc.conf и делаем `sudo /usr/local/etc/rc.d/nginx start`
#### Пример создания репозитория
Теперь мы готовы создать первый репозиторий. Все делается от пользователя www, т.к. именно под ним работает nginx и hgwebdir и ему нужны права на запись в эту директорию. Давайте сделаем репозиторий test. Дадим права на чтение пользователю user1 и права на чтение/запись пользователю user2.
`# Идем в директорию с репозиториями
cd /usr/home/www/repos
# Создаем новый репозиторий
sudo -u www hg init test
# Добавляем пользователей в nginx
# -c - создать файл
# htpasswd - из пакета www/apache22
sudo htpasswd -b -c /usr/local/etc/nginx/hg_htpasswd user1 pass1
sudo htpasswd -b /usr/local/etc/nginx/hg_htpasswd user2 pass2`
Редактируем test/.hg/hgrc чтоб он выглядел так
`[web]
# Нам не нужен ssl, поскольку о нем заботится nginx
push_ssl = False
allow_push = user2
allow_read = user1,user2`
Готово, можно проверять доступ.
#### Вместо заключения
Помимо повального мигрирования с subversion на mercurial я сейчас пристально смотрю на redmine вместо trac. Мне понравилась идея, что пользователи могут сами регистрироваться и создавать проекты. К сожалению, я не нашел готового решения как сделать автоматическое создание hg репозитория для созданного проекта. Причем с клонированием прав доступа по описанной в этой статье схеме. Если кто-то знает — буду благодарен за ссылочку. В любом случае, я собираюсь решить эту задачу в ближайшем будущем либо написанием плагина к redmine, либо более другим/правильным способом.
Если вам понравилась эта статья и вы бы хотели увидеть продолжение, оставляейте отзывы. Я тогда поделюсь новым знаниями интеграции нашего нового окружения с redmine. | https://habr.com/ru/post/90066/ | null | ru | null |
# Ввод в программу иерархического списка
Появилась задача — вводить в web-приложение элементы иерархического списка (например КЛАДР).
Когда работал с [drupal](http://drupal.org), видел там модуль [Hierarchical Select](http://drupal.org/project/hierarchical_select), реализующий эту функциональность.
Но хотелось сделать самому — для того, чтоб не привязываться к системам, которые мне полностью не понятны и вообще, интересно.
Поиск готового решения, не завязанного на какую-то существующую систему, дал что-то вроде
[этого](http://www.flooble.com/scripts/hier.php), что не устроило.
Топик не претендует на новизну и особую сложность исполнения.
Сделал за 2 часа.
Захотел поделится.
Возможно, кому-то пригодится.
Максимально все документировал и функции, описывающие источник данных, вынес в 2 метода:
— поиск детей (один уровень) по родителю
— поиск всех родителей ребенка по иерархии вверх
чтобы желающие могли использовать это для своих нужд.
Возможно, что-то подобное где-то и было, но быстро я это не нашел.
Итак, приступим.
Сразу ссылка на работающий пример и исходные коды
[Пример](http://xn--90aa2bbj.xn--p1ai/select_hierarhy/)
Можно быстро переписать на свой источник данных (достаточно изменить 2 метода в классе)
**Постановка задачи:**
* Использовать набор динамически генерируемых select-ов
* При выборе узла, подгружается очередной элемент с детьми.
* Дать возможность пользователю возможность двигаться по дереву дальше или остановить свой выбор на этом узле, не выбирая дочерний
* Если элемент уже выбран, и его нужно отредактировать, необходимо загрузить набор элементов, содержащих путь к выбранному узлу
то есть, инициализировать
* Генерация без перезагрузки страницы — ajax
* Иерархических списков разного вида может быть много и они не должны конфликтовать
**Функционал по модулям:**
* Представление контейнера, содержащее все необходимые данные
* javaScript, реагирующий на изменения и запрашивающий элементы, генерируемые «на лету»
* Модуль сборки динамического содержимого
**Последовательность изложения:**
1. Описать необходимые и достаточные данные, которые должно генерировать приложение, к которому это подключается
2. Описание javaScript
3. Класс, обслуживающий запросы ajax
4. Как все это работает
5. Обработка результата
**1. Что нужно сделать с приложением**
* Иметь подключенный javascript [jQuery](http://jquery.com/)
и скрипт обработки иерархии
```
```
* Для каждого списка на странице:
```
```
* Скопировать в корень сайта файл ajax.php
**2. Описание javaScript**
```
// инициализаторы
$(document).ready(function() {
/**
* Перебрать все контейнеры и инициализировать их элементами первого уровня
*/
$('.select_hierarhy_container').each(function() {
selecHierarhyInit(this);
});
});
/**
* Инициализировать контейнер, содержащий в себе иерархический список. Получает:
* id (containerId), значение по умолчанию (initValue) и загружает в контейнер
* все, что нужно динамически
*
* @param v_container
* объект-контейнер
*/
function selecHierarhyInit(v_container) {
var container = $(v_container);
var containerId = container.attr('id');
var initValue = container.children('input').val();
container.load('ajax.php?container_id=' + containerId + '&init_id='
+ initValue);
}
/**
* Загрузить следующий узел со списком детей для выбранного в v_obj, родителя
* Сначала из изменившегося списка получить параметры: id контейнера
* (containerId) текущий уровень иерархии узла с выбранным элементом (level)
* идентификатор выбранного элемента (parent_id) Удаляет всех детей ниже по
* иерархии, чем измененный (если они были, значит нужно уничтожить для
* уточнения выбора) Запросить контент со списком детей
*
* @param v_obj
* объект со списком select, который изменился
*/
function selecHierarhygetChilds(v_obj) {
obj = $(v_obj);
var containerId = obj.parents('.select_hierarhy_container').attr('id');
var parent_id = obj.val();
obj.nextAll().remove();
$.ajax({
url : 'ajax.php?container_id=' + containerId + '&parent_id='
+ parent_id,
success : function(data) {
$('#' + containerId).append(data);
}
});
}
```
**3. Класс, обслуживающий запросы ajax**
```
/**
* Класс, обслуживающий механизм рекурсивных элементов ввода.
*
* После отправки формы можете взять последний элемент в массиве
* $_POST[$selectName] если он не пуст. Если пуст - предпоследний.
* Реализация такого источника данных (массив, который вшит внутрь файла)
* приводится исключительно в качестве примера и использовать
* на практике довольно бессмысленно (на мой взгляд)
* Скорее всего, источником данных, будет база данных
*
* @author dibrovsd
*/
class HerarhySelect {
// имя select-а
private $selectName;
/**
* @param string $selectName название select-а, который нужно генерировать
*/
public function __construct($selectName) {
$this->selectName = $selectName;
}
/**
* Получить один уровень
* @param int $parentId идентификатор родительского узла
*/
public function getContent($parentId) {
return $this->generateSelect($parentId);
}
/**
* Получить инициализированноые значения списков
* Начиная с указанной ноды, загружаются все родительский узлы
* (снизу вверх)
* Если инициализирующее значение пусто, загружает подчиненные
* корню узлы (один уровень) и добавляет дочерний, по отношению к инициализирующему, уровень
* @param int $nodeId инициализирующее значение
*/
public function getInit($nodeId) {
if($nodeId == '') {
return $this->getContent(-1);
}
else {
$s = null;
$parents = $this->getDataParentsList($nodeId);
foreach($parents as $parentId => $childId) {
$s .= $this->generateSelect($parentId, $childId);
}
$s .= $this->generateSelect($nodeId);
return $s;
}
}
/**
* Генерировать список из детей $parentId, отметив выбранным узел $childId
* @param int $parentId идентификатор родительского узла
* @param int $childId
*/
private function generateSelect($parentId, $childId = null) {
// если детей нет - выйти
$childs = $this->getDataChilds($parentId);
if($childs == null) {
return;
}
$s = '
';
foreach($childs as $id => $value) {
$s .= ''.
$value.'';
}
$s .='';
return $s;
}
/**
* Источник данных. Возвращает ассоциативную хэш-таблицу
* со списком детей
* для переданого родительского узла
*
* Поместите сюда ваш метод получения данных.
* Это может быть любая база данных, web-сервис
* или какой-то массив (как в этом примере)
*
* @param int $parentId Идентификатор родительского узла
*/
private function getDataChilds($parentId) {
$dataSource = $this->getDataArray();
if(!isset($dataSource[$parentId])) {
return null;
}
else {
return $dataSource[$parentId];
}
}
/**
* Получить список родителей по иерархии сверху вниз,
* пока не дойдем до $childId
* Каждый элемент массива - это очередной вниз уровень иерархии
* В ключе идентификатор родителя, в значении - ребенок этого уровня
*
* Делаем (для этого источника данных) за счет раскручивания иерархии снизу
* вверх и потом реверс полученого хэша
* Сделайте для своего источника данных свою реализацию:
* Для Oracle иерархическим запросом,
* Для PostgreSQL рекурсивным запросом
* Для других БД рекурсивной функцией, запрашивающей узел за узлом
* (если они не содержат механизма работы с иерархией)
*
* @param int $child
* @return int:int id родителя : id ребенка,
* которого нужно пометить выбраным в списке элементов,
* подчиненных родителю
*/
private function getDataParentsList($childId) {
$dataSource = $this->getDataArray();
$result = array();
$currentChild = $childId;
// Ищем в цикле родителя за родителем.
// Если родитель не нашелся, мы достигли вершины иерархии
do {
$isParentFind = false;
foreach($dataSource as $idParent => $childs) {
if(isset($childs[$currentChild])) {
$result[$idParent] = $currentChild;
$isParentFind = true;
$currentChild = $idParent;
break;
}
}
}
while($isParentFind);
return array_reverse($result, true);
}
/**
* Функция - поставщик статического набора данных.
* Нужно только для примера, так как, скорее всего,
* источником данных будет база данных,
* а не это извращение
*/
private function getDataArray() {
return array(
-1 => array(1 => 'test1', 2 => 'test2', 3 => 'test3'),
1 => array(4 => 'test1_1', 5 => 'test1_2', 6 => 'test1_3'),
4 => array(7 => 'test2_1', 8 => 'test2_2', 9 => 'test2_3'),
9 => array(10 => 'test2_1_1', 11 => 'test2_1_2', 12 => 'test2_1_3')
);
}
}
```
**4. Как все это работает**
При загрузке страницы, когда модель документа полностью сформирована,
срабатывает инициализирующий код javascript
и для каждого контейнера загружает инициализирующие данные
с помощью функции selecHierarhyInit(объект\_контейнера)
Эта функция запрашивает контент, передавая
— идентификатор контейнера, который равен названию элемента ввода
— инициализирующий идентификатор узла иерархии
PHP-класс, получая в функцию getInit($id) этот идентификатор, обрабатывает его.
Если он пуст, то загружает один уровень со списком узлов, подчиненных корню иерархии (я использую «заглушку» -1)
Если нет, то сканирует иерархию вверх от инициализирующего узла, а потом инвертирует полученный словарь,
получая «сверзу вниз» и передает массив на распечатывание
Далее это содержимое (список списков или один список) возвращается javaScript-у, который записывает его в контейнер,
удаляя инициализирующее значение, которое нам больше не нужно
Если оператор изменил select, то вызывается функция selecHierarhygetChilds, которая получает параметром
объект изменившегося списка, выбирает из него параметры:
Удаляет все списки, которые находятся после изменившегося,
потому что при изменении родителя, его детей нужно пересобрать заново
запрашивает у PHP getContent(id) список дочерних, по отношению к этому, узлов и добавляет полученное после (все дети были удалены)
изменившегося списка
**5. Обработка результата**
обойдусь без комментариев
```
if(isset($_POST['sendForm'])) {
$data1 = array_reverse($_POST['field_1']['new']);
$data2 = array_reverse($_POST['field_2']['new']);
$val1 = $data1[0] == '' ? $data1[1] : $data1[0];
$val2 = $data2[0] == '' ? $data2[1] : $data2[0];
}
else {
$val1 = null;
$val2 = 12;
}
``` | https://habr.com/ru/post/132594/ | null | ru | null |
# 8 недооцененных команд Git, которые должен знать каждый программист (помимо привычных pull, push, add, commit)
### 1. Переименовываем локальную ветку
Если вы сделали опечатку, когда вводили имя ветки, вам поможет вот такая команда.
```
// Примечание: опустите символы < и >, а слова разделите дефисом (-)
git branch -m
eg:- git branch -m new-new-branch
```
### 2. Изменяем upstream-ветку
Эта команда позволяет отправить локальную ветвь в новую удаленную ветку.
```
git push origin -u
```
### 3. Приводим локальную ветку в соответствие с удаленной
Иногда внесешь массу изменений в локальную ветку, а в итоге понимаешь, что от них стало только хуже. Знакомо? Не переживайте, с этим многие сталкивались. В такой ситуации вам поможет вот эта команда.
```
// замените staging именем ветки, до которой хотите сбросить
git reset --hard origin/staging
```
### 4. Удаляем последний коммит с сохранением сделанной работы
Удивительно, как мало программистов знают об этой команде. Она помогает избавиться от глупых опечаток, которые иногда закрадываются в коммиты.
```
git reset --soft HEAD~1
```
### 5. Удаляем последний коммит вместе со сделанной работой
Используйте эту команду, если напортачили по полной. Не переживайте — не ошибается лишь тот, кто ничего не делает.
```
git reset --hard HEAD~1
```
### 6. Откладываем изменения
Если вам нужно поработать с другой веткой, но вы не хотите коммитить изменения в текущей, вам пригодится команда stash.
```
git stash
```
### 7. Восстанавливаем отложенные изменения: возвращаемся к ветке и используем команду...
```
git stash apply
```
Имейте в виду, что команда
```
git stash apply
```
не удаляет запись из списка отложенных командой stash. Если вы хотите восстановить работу и сразу удалить ее из списка, используйте команду
```
git stash pop
```
### 8. Возвращаемся к предыдущему коммиту, отменяем перебазирование
Ошибки при перебазировании (rebase) — обычное дело. Если вы допустили такую ошибку, вам помогут команды ниже. Используйте reflog, чтобы найти указатель HEAD нужного коммита.
```
// Сначала найдите нужный указатель HEAD
git reflog
// Замените 5 на нужный вам номер указателя HEAD
// Будьте очень внимательны, не перепутайте номера
git reset --hard "HEAD@{5}"
```
---
> Материал подготовлен в рамках курса ["PHP Developer. Basic"](https://otus.pw/Gf8D/).
>
> Всех желающих приглашаем на двухдневный интенсив [«Пишем форму авторизации с нуля»](https://otus.pw/g6uu/). На интенсиве мы:
> - Сверстаем форму регистрации по макетам;
> - Научимся работать с позиционированием, шрифтами, флексбоксами- Напишем обработчик формы регистрации с сохранением данных в БД и их валидацией;
> - Сделаем страницу для просмотра зарегистрированных пользователей.
>
>
> [**РЕГИСТРАЦИЯ**](https://otus.pw/g6uu/)
>
> | https://habr.com/ru/post/567706/ | null | ru | null |
# Делаем консоль чуточку удобнее
Практически все Javascript-программисты пользуются консолью в браузерах. Консоль встроена в Хром, Оперу, IE и устанавливается с Firebug в Фоксе.
Но у неё есть пару неудобств, которые можно очень легко исправить. Это:
* Ошибки, когда консоль не определена
* Невозможность использовать вне контекста
* Невозможность отключить во время production
* некроссбраузерность
Исправим эти проблемы легко и быстро!
В первую очередь нам необходимо подменить объект консоли на свой объект. Оригинальную консоль сохраним в переменной `original`
```
(function () {
var global = this;
var original = global.console;
// переопределяем консоль
var console = global.console = {};
})();
```
Теперь необходимо реализовать все методы оригинальной консоли, если они есть:
```
(function () {
var global = this;
var original = global.console;
var console = global.console = {};
// список методов
var methods = ['assert', 'count', 'debug', 'dir', 'dirxml', 'error', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log', 'markTimeline', 'profile', 'profileEnd', 'table', 'time', 'timeEnd', 'trace', 'warn'];
// обход все элементов массива в обратном порядке
for (var i = methods.length; i--;) {
// обратите внимание, что обязательно необходима анонимная функция,
// иначе любой метод нашей консоли всегда будет вызывать метод 'assert'
(function (methodName) {
// определяем новый метод
console[methodName] = function () {
// только если консоль доступна и есть нужный метод
if (original && methodName in original) {
// вызываем оригинальный метод консоли
original[methodName].apply(original, arguments);
}
};
})(methods[i]);
}
})();
```
Таким образом мы не только избавились от ошибок в случае неопределённой консоли, но и решили вторую проблему — возможность использования консоли вдали от контекста, например:
```
// При клике вызвать console.log
$('#my-element').click(console.log);
// Короткий алиас
var log = console.log;
for (var i = 0; i < 10; i++) log(i);
```
Без нашего переопределения что в первом, что во втором случае мы бы получили ошибку "`Illegal invocation`".
Следующее, что нам необходимо сделать — это добавить возможность отключение дебага во время production. Это делается двумя строчками:
```
(function () {
// ..
var console = global.console = {};
console.production = false;
// ...
console[methodName] = function () {
// только если консоль доступна и есть нужный метод И ЕСЛИ ЭТО НЕ РАБОЧИЙ КОД
if (original && methodName in original && !console.production) {
// вызываем оригинальный метод консоли
original[methodName].apply(original, arguments);
// ..
})();
```
Теперь, чтобы отключить дебаг-информацию, достаточно, будет вызвать следующий код где-то во время инициализации нашего приложения:
```
console.production = true;
```
Особенности браузеров
---------------------
#### Говноосёл
IE 8 и IE 9 как всегда отличились. Если вызвать следующий код:
```
alert(typeof console.log);
```
То нормальные браузеры выведут «function», а осёл — «object». У `object` нету метода `apply`, потому самый простой способ обойти этот баг — вызвать метод из прототипа функции. Немного магии:
```
original[methodName].apply(original, arguments);
// заменяем на:
Function.prototype.apply.call(original[methodName], original, arguments);
```
#### Firebug
[Firebug не позволяет переопределить стандартную переменную](http://habrahabr.ru/blogs/javascript/116852/#comment_3829571). Потому решается очень простым фиксом. Перед присвоением необходимо удалить свойство:
```
var original = global.console;
var console = global.console = {};
// =>
var original = global.console;
delete global.console;
var console = global.console = {};
```
Добавляем новые методы
----------------------
Многие знают, что в *самых прогрессивных браузерах* нету методов time и timeEnd. Портируем их из Firebug:
```
// ...
var original = global.console;
var console = global.console = {};
if (original && !original.time) {
original.time = function(name, reset){
if (!name) return;
var time = new Date().getTime();
if (!console.timeCounters) console.timeCounters = {};
var key = "KEY" + name.toString();
if(!reset && console.timeCounters[key]) return;
console.timeCounters[key] = time;
};
original.timeEnd = function(name){
var time = new Date().getTime();
if(!console.timeCounters) return;
var key = "KEY" + name.toString();
var timeCounter = console.timeCounters[key];
if (timeCounter) {
var diff = time - timeCounter;
var label = name + ": " + diff + "ms";
console.info(label);
delete console.timeCounters[key];
}
return diff;
};
}
// список методов
var methods = // ...
```
Теперь даже ишаки научились считать время.
Окончательный код у нас получился следующим:
```
(function () {
var global = this;
var original = global.console;
if ('console' in global) delete global.console;
var console = global.console = {};
console.production = false;
if (original && !original.time) {
original.time = function(name, reset){
if (!name) return;
var time = new Date().getTime();
if (!console.timeCounters) console.timeCounters = {};
var key = "KEY" + name.toString();
if(!reset && console.timeCounters[key]) return;
console.timeCounters[key] = time;
};
original.timeEnd = function(name){
var time = new Date().getTime();
if(!console.timeCounters) return;
var key = "KEY" + name.toString();
var timeCounter = console.timeCounters[key];
if (timeCounter) {
var diff = time - timeCounter;
var label = name + ": " + diff + "ms";
console.info(label);
delete console.timeCounters[key];
}
return diff;
};
}
var methods = ['assert', 'count', 'debug', 'dir', 'dirxml', 'error', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log', 'markTimeline', 'profile', 'profileEnd', 'table', 'time', 'timeEnd', 'trace', 'warn'];
for (var i = methods.length; i--;) {
(function (methodName) {
console[methodName] = function () {
if (original && methodName in original && !console.production) {
Function.prototype.apply.call(original[methodName], original, arguments);
}
};
})(methods[i]);
}
})();
```
Теперь консоль не вызывает ошибок, её можно использовать вне контекста, отключать на боевом сервере и считать время в IE)
Пользуйтесь на здоровье, лицензия на код — LGPL/MIT, лицензия на текст — [CC BY 3.0](http://creativecommons.org/licenses/by/3.0/)
Github: [github.com/theshock/console-cap](https://github.com/theshock/console-cap) | https://habr.com/ru/post/116852/ | null | ru | null |
# WD MyBook Live — расширение стандартной функциональности
Не секрет, что в данное время наличие дома нескольких компьютеров и прочих устройств, работающих с сетью в той или иной мере (телефоны, телевизоры, iptv-приставки, медиаплееры, etc) стало для многих нормой вещей. Обычно, в таком случае всё подобное железо соединено в сеть с общим выходом в интернет. Возникает вопрос о каком-то общем хранилище информации, в роли которого обычно выступает постоянно включенный компьютер, роутер с внешним диском или специализированное устройство. В общем, каким-либо образом организуется NAS, на котором уже «проживают» семейные и личные фото, любимая музыка, фильмы, и много чего другого. Каким именно образом организуется NAS — дело личного выбора каждого. Я, например, приобрёл [WD My Book Live](http://www.wdc.com/ru/products/products.aspx?id=280) на 2ТБ, о котором и поведу дальнейший рассказ.
Прочитав несколько обзоров данного устройства, я выяснил, что «внутри» находится полноценный Debian Linux с возможностью доступа по ssh. Радости моей не было предела — мало того, что я получаю 2ТБ сетевого хранилища мод мои скромные нужды, так ещё есть возможность расширить заводскую функциональность, например, поставить туда web-сервер, поднять своё интернет-радио, ну и всё, что взбредёт в голову и реализовано в Linux. В крайнем случае — собрать или написать нужную программу самому.
Реальность, как это обычно бывает, разбила очередную пару розовых очков. Начну с того, что внутри всё-таки Linux. Debian 5 Lenny (который уже oldstable). Обновить его нельзя, так как может отвалиться поддержка железа SoC на котором, собственно и реализовано устройство. Доустановить нужные мне программы оказалось тоже довольно проблематично — некоторые из них в Debian 5 либо ещё отсутствуют, либо имеют настолько старые версии, что в них отсутствует нужна мне функциональность, либо, просто не установятся, так как пакетный менеджер не сможет поставить нужные им зависимости, не разрушив при этом работающую систему.
Результат «вскрытия» оказался печален, конечно, но не смертелен — это же Linux, в нём можно решить одну и ту же задачу разными способами. Следующим моим шагом стало создание резервной копии текущей прошивки, дабы мои эксперименты не привели к программной «смерти» устройства и походу в СЦ, которого в моём городе, кажется, и нет вовсе…
Помучив поисковики, наткнулся на [инструкцию по снятию резервной копии](http://mybookworld.wikidot.com/backup-images-of-mybook), основную часть которой приведу:
1) Получить доступ по ssh
http:///UI/ssh — url вводить руками, ссылки в интерфейсе на него нет
2) Заходим через PuTTY на устройство
пользователь=root
пароль=welc0me
(естественно, следует поменять пароль на свой, командой passwd)
3) Сохраняем MBR и информацию о свободном месте в начале диска устройства (сохранит быстро, размер архива — 440 байт):
```
dd if=/dev/sda bs=15728640 count=1 | bzip2 > /DataVolume/shares/Public/SDA_MBR_FREESPACE.bz2
```
4) Сохраняем разделы (их два, так как используется soft-raid) c текущей прошивкой, предупреждаю, процесс долгий:
```
dd if=/dev/sda1 | bzip2 > /DataVolume/shares/Public/SDA1_IMA.bz2
dd if=/dev/sda2 | bzip2 > /DataVolume/shares/Public/SDA2_IMA.bz2
```
Должно выдать что-то наподобии:
1 — SDA1\_IMA.bz2 file:
3999744+0 records in
3999744+0 records out
2047868928 bytes (2.0 GB) copied, 2212.34 s, 926 kB/s
filesize = 595MB
2 — SDA2\_IMA.bz2:
3999744+0 records in
3999744+0 records out
2047868928 bytes (2.0 GB) copied, 1914.37 s, 1.1 MB/s
5) Сливаем полученые архивы на свой компьютер или в другое надёжное место…
Итак, резервная копия сделана и сохранена на другом носителе, продолжим.
На сайте с инструкцией по бэкапу [наткнулся на упоминание Optware](http://mybookworld.wikidot.com/optware), но mpd оттуда у меня работать в режиме вещания не захотел, хотя htop и mc установились и заработали корректно. Optware мне показалось явно недостаточно. Захотелось большего.
Инструкции по автоустановке различных feature-pack'ов мне, почему-то, откровенно не понравились. Наверное тем, что добавляли обилие различных web-конфигураторов, в которых я не видел необходимости. В этот момент в мою порядком уставшую голову пришла мысль, после которой мне стало дико стыдно за то, что я иногда причисляю себя к линуксоидам — chroot.
Chroot с полноценной системой внутри позволит мне запускать всё, что есть в репозитории выбранного дистрибутива! С горем пополам (почему-то репозитории Lenny работали нестабильно, а потом — вообще перестали отдавать список пакетов) я установил [debootstrap](http://wiki.debian.org/Debootstrap), c помощью которого поставил в чруте нормальный Debian (testing – в погоне за «свежими» версиями), написал скрипты, которые монтировали мои шары внутрь чрута и запускали нужные мне сервисы.
Вроде бы всё хорошо и мне можно успокоиться, но тут я вспомнил, что обновление прошивки перетирает напрочь весь системный раздел и уничтожит все мои костыли и подпорки. Что ж, всё, что я сделал, было перенесено на раздел с данными и смонтировано в рабочую систему через mount --bind, написан ещё один скрипт, который возвращал все настройки на место, благо, обновление прошивки не убирало доступ по ssh.
Подумав, что у других хозяев подобных железок могут возникнуть такие же проблемы, я [выложил своё творение на googlecode](http://code.google.com/p/mybooklive/) с возможностью лёгкой установки. Может, кому-то пригодится, хотя ещё сыровато, конечно. | https://habr.com/ru/post/141120/ | null | ru | null |
# Создаем прототип для Sentiment Analysis с помощью Python и TextBlob
Что важно для команды разработчиков, которая только начинает строить систему, базирующуюся на машинном обучении? Архитектура, компоненты, возможности тестирования с помощью интеграционных и юнит тестов, сделать прототип и получить первые результаты. И далее к оценке трудоемкости, планированию разработки и реализации.
В этой статье речь пойдет как раз о прототипе. Который был создан через некоторое время после разговора с Product Manager: а почему бы нам не «пощупать» Machine Learning? В частности, NLP и Sentiment Analysis?
«А почему бы и нет?» — ответил я. Все-таки занимаюсь backend-разработкой более 15 лет, люблю работать с данными и решать проблемы производительности. Но мне еще предстояло узнать, «насколько глубока кроличья нора».
Выделяем компоненты
-------------------
Чтобы как-то очертить набор компонентов, реализующих логику нашего ML-ядра, взглянем на простой пример реализации сентимент-анализа, один из множества, доступных на GitHub.
**Один из примеров реализации сентимент-анализа на Python**
```
import collections
import nltk
import os
from sklearn import (
datasets, model_selection, feature_extraction, linear_model
)
def extract_features(corpus):
'''Extract TF-IDF features from corpus'''
# vectorize means we turn non-numerical data into an array of numbers
count_vectorizer = feature_extraction.text.CountVectorizer(
lowercase=True, # for demonstration, True by default
tokenizer=nltk.word_tokenize, # use the NLTK tokenizer
stop_words='english', # remove stop words
min_df=1 # minimum document frequency, i.e. the word must appear more than once.
)
processed_corpus = count_vectorizer.fit_transform(corpus)
processed_corpus = feature_extraction.text.TfidfTransformer().fit_transform(
processed_corpus)
return processed_corpus
data_directory = 'movie_reviews'
movie_sentiment_data = datasets.load_files(data_directory, shuffle=True)
print('{} files loaded.'.format(len(movie_sentiment_data.data)))
print('They contain the following classes: {}.'.format(
movie_sentiment_data.target_names))
movie_tfidf = extract_features(movie_sentiment_data.data)
X_train, X_test, y_train, y_test = model_selection.train_test_split(
movie_tfidf, movie_sentiment_data.target, test_size=0.30, random_state=42)
# similar to nltk.NaiveBayesClassifier.train()
model = linear_model.LogisticRegression()
model.fit(X_train, y_train)
print('Model performance: {}'.format(model.score(X_test, y_test)))
y_pred = model.predict(X_test)
for i in range(5):
print('Review:\n{review}\n-\nCorrect label: {correct}; Predicted: {predict}'.format(
review=X_test[i], correct=y_test[i], predict=y_pred[i]
))
```
Разбирать такие примеры — это отдельный челлендж для разработчика.
Всего лишь 45 строк кода, и сразу 4 (четыре, Карл!) логических блока:
1. Загрузка данных для обучения модели (строки 25-26)
2. Подготовка загруженных данных — feature extraction (строки 31-34)
3. Создание и обучение модели (строки 36-39)
4. Тестирование обученной модели и вывод результата (строки 41-45)
Каждый из этих пунктов достоин отдельной статьи. И уж точно требует оформления в отдельном модуле. Хотя бы для нужд юнит-тестирования.
Отдельно стоит выделить компоненты подготовки данных и обучения модели.
В каждый из способов сделать модель точнее вложены сотни часов научного и инженерного труда.
Благо, для того, чтобы быстро начать с NLP, есть готовое решение – библиотеки [NLTK](http://www.nltk.org) и [TextBlob](https://textblob.readthedocs.io/en/dev/). Второе является оберткой над NLTK, которая делает рутинную работу – делает feature extraction из тренировочного набора, а затем обучает модель при первом запросе классификации.
Но прежде чем обучить модель, необходимо подготовить для нее данные.
Готовим данные
--------------
### Загружаем данные
Если говорить о прототипе, то загрузка данных из CSV/TSV файла элементарна. Вы просто вызываете функцию **read\_csv** из библиотеки pandas:
```
import pandas as pd
data = pd.read_csv(data_path, delimiter)
```
Но это не будут данные, готовые к использованию в модели.
Во-первых, если немного абстрагироваться от csv-формата, то нетрудно ожидать, что каждый источник будет предоставлять данные со своими особенностями, и, следовательно, нам потребуется некая, зависящая от источника, подготовка данных. Даже для простейшего случая CSV-файла, чтобы просто его распарсить, нам надо знать разделитель.
Кроме этого, следует определить, какие записи являются позитивными, а какие негативными. Конечно, это информация указана в аннотации к датасетам, которые мы хотим использовать. Но дело в том, что в одном случае признаком pos/neg является 0 или 1, в другом – логическое True/False, в третьем — это просто строка pos/neg, а в каком-то случае вообще кортеж целых чисел от 0 до 5. Последнее актуально для случая мультиклассовой классификации, но кто сказал, что такой набор данных нельзя использовать для бинарной классификации? Нужно просто адекватно обозначить границу позитивного и негативного значения.
Мне бы хотелось попробовать модель на разных наборах данных, при этом требуется, чтобы после обучения модель возвращала результат в каком-то одном формате. А для этого следует привести ее разнородные данные к единому виду.
Итак, можно выделить три функции, необходимых нам на этапе загрузки данных:
1. Подключение к источнику данных – для CSV, в нашем случае это реализовано внутри функции read\_csv;
2. Поддержка особенностей формата;
3. Предварительная подготовка данных.
Вот так это выглядит в коде.
```
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import logging
log = logging.getLogger()
class CsvSentimentDataLoader():
def __init__(self, file_path, delim, text_attr, rate_attr, pos_rates):
self.data_path = file_path
self.delimiter = delim
self.text_attr = text_attr
self.rate_attr = rate_attr
self.pos_rates = pos_rates
def load_data(self):
# Здесь данные вычитываются из csv или tsv файла
data = pd.read_csv(self.data_path, self.delimiter)
data.head()
# Отбрасываются все колонки,
# кроме текста и классифицирующего атрибута
data = data[[self.text_attr, self.rate_attr]]
# Значения классифицирующего атрибута
# приводятся к текстовым значениям ‘pos’ и ‘neg’
data[self.rate_attr] = np.where(
data[self.rate_attr].isin(self.pos_rates), 'pos', 'neg')
return data
```
Был сделан класс **CsvSentimentDataLoader**, которому в конструкторе передается путь к csv, разделитель, наименования текстового и классифицирующего атрибутов, а также перечень значений, советующих позитивному значению текста.
Сама загрузка происходит в методе **load\_data**.
### Разделяем данные на тестовый и тренировочный наборы
Ок, мы загрузили данные, но нам их еще надо разделить на тренировочный и тестовый наборы.
Делается это функцией **train\_test\_split** из библиотеки **sklearn**. Эта функция может принимать на вход множество параметров, определяющих, как именно этот dataset будет разделен на train и test. Эти параметры значительно влияют на получаемые тренировочные и тестовые наборы, и, вероятно, нам будет удобно сделать класс (назовем его SimpleDataSplitter), который будет управлять этими параметрами и агрегировать в себе вызов этой функции.
```
from sklearn.model_selection import train_test_split # to split the training and testing data
import logging
log = logging.getLogger()
class SimpleDataSplitter():
def __init__(self, text_attr, rate_attr, test_part_size=.3):
self.text_attr = text_attr
self.rate_attr = rate_attr
self.test_part_size = test_part_size
def split_data(self, data):
x = data[self.text_attr]
y = data[self.rate_attr]
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size = self.test_part_size)
return x_train, x_test, y_train, y_test
```
Сейчас этот класс включает в себя простейшую реализацию, которая при разделении будет учитывать только один параметр – процент записей, который следует взять в качестве тестового набора.
### Датасеты
Для обучения модели я использовал свободно доступные наборы данных в формате CSV:
* Amazon Alexa Reviews Data Set, можно [найти на Kaggle](https://www.kaggle.com/sid321axn/amazon-alexa-reviews)
* [Sentiment Labelled Sentences Data Set](https://archive.ics.uci.edu/ml/datasets/Sentiment+Labelled+Sentences) от Калифорнийского университета
И чтобы было еще чуть удобнее, для каждого из датасетов я сделал класс, который загружает данные из соответствующего CSV-файла и разбивает их на тренировочный и тестовый наборы.
```
import os
import collections
import logging
from web.data.loaders import CsvSentimentDataLoader
from web.data.splitters import SimpleDataSplitter, TdIdfDataSplitter
log = logging.getLogger()
class AmazonAlexaDataset():
def __init__(self):
self.file_path = os.path.normpath(os.path.join(os.path.dirname(__file__), 'amazon_alexa/train.tsv'))
self.delim = '\t'
self.text_attr = 'verified_reviews'
self.rate_attr = 'feedback'
self.pos_rates = [1]
self.data = None
self.train = None
self.test = None
def load_data(self):
loader = CsvSentimentDataLoader(self.file_path, self.delim, self.text_attr, self.rate_attr, self.pos_rates)
splitter = SimpleDataSplitter(self.text_attr, self.rate_attr, test_part_size=.3)
self.data = loader.load_data()
x_train, x_test, y_train, y_test = splitter.split_data(self.data)
self.train = [x for x in zip(x_train, y_train)]
self.test = [x for x in zip(x_test, y_test)]
```
Да, для загрузки данных получилось немного больше, чем 5 строк кода в исходном примере.
Зато теперь появилась возможность создавать новые датасеты, жонглируя источниками данных и алгоритмами подготовки тренировочного набора.
Плюс отдельные компоненты гораздо удобнее при юнит-тестировании.
Тренируем модель
----------------
Модель обучается довольно долго. И это надо делать один раз, при старте приложения.
Для этих целей был сделан небольшой враппер, позволяющий загрузить и подготовить данные, а также обучить модель в момент инициализации приложения.
```
class TextBlobWrapper():
def __init__(self):
self.log = logging.getLogger()
self.is_model_trained = False
self.classifier = None
def init_app(self):
self.log.info('>>>>> TextBlob initialization started')
self.ensure_model_is_trained()
self.log.info('>>>>> TextBlob initialization completed')
def ensure_model_is_trained(self):
if not self.is_model_trained:
ds = SentimentLabelledDataset()
ds.load_data()
# train the classifier and test the accuracy
self.classifier = NaiveBayesClassifier(ds.train)
acr = self.classifier.accuracy(ds.test)
self.log.info(str.format('>>>>> NaiveBayesClassifier trained with accuracy {}', acr))
self.is_model_trained = True
return self.classifier
```
Сначала получаем тренировочные и тестовые данные, затем делаем feature extraction, и наконец обучаем классификатор и проверяем точность на тестовом наборе.
Тестируем
---------
При инициализации получаем лог, судя по которому, данные загрузились и модель была успешно обучена. Причем обучена с весьма неплохой (для начала) точностью – 0.8878.
Получив такие цифры, я был весьма воодушевлен. Но моя радость, к сожалению, была не долгой. Модель, обученная на этом сете, является непробиваемым оптимистом и в принципе не способна распознавать негативные комментарии.
Причина этого — в данных обучающего набора. Количество позитивных отзывов в сете – более 90 %. Соответственно, при точности модели около 88 % негативные отзывы просто попадают в ожидаемые 12% неверных классификаций.
Иными словами, при таком обучающем наборе просто невозможно натренировать модель для распознавания негативных комментариев.
Чтобы действительно убедиться в этом, я сделал юнит-тест, который прогоняет классификацию отдельно для 100 позитивных и 100 негативных фраз из другого набора данных — для тестирования я взял [Sentiment Labelled Sentences Data Set](https://archive.ics.uci.edu/ml/datasets/Sentiment+Labelled+Sentences) от Калифорнийского университета.
```
@loggingtestcase.capturelogs(None, level='INFO')
def test_classifier_on_separate_set(self, logs):
tb = TextBlobWrapper() # Going to be trained on Amazon Alexa dataset
ds = SentimentLabelledDataset() # Test dataset
ds.load_data()
# Check poisitives
true_pos = 0
data = ds.data.to_numpy()
seach_mask = np.isin(data[:, 1], ['pos'])
data = data[seach_mask][:100]
for e in data[:]:
# Model train will be performed on first classification call
r = tb.do_sentiment_classification(e[0])
if r == e[1]:
true_pos += 1
self.assertLessEqual(true_pos, 100)
print(str.format('\n\nTrue Positive answers - {} of 100', true_pos))
```
Алгоритм для тестирования классификации позитивных значений следующий:
* Загружаем тестовые данные;
* Берем 100 записей с меткой ‘pos’
* Каждую из них прогоняем через модель и подсчитываем кол-во верных результатов
* Выводим итоговый результат в консоль
Аналогично делается подсчет для негативных комментариев.
**Результат**
Как и предполагалось, все негативные комментарии распознались как позитивные.
А если натренировать модель на датасете, использованном для тестирования – **Sentiment Labelled**? Там распределение негативных и позитивных комментариев – ровно 50 на 50.
**Меняем код и тест, запускаем**
Уже что-то. Фактическая точность на 200 записей из стороннего набора – 76%, при точности классификации негативных комментариев – 79%.
Конечно, 76% — сгодится для прототипа, но недостаточно для продакшена. Это значит, что потребуется предпринимать дополнительные меры для повышения точности алгоритма. Но это уже тема для другого доклада.
Итоги
-----
Во-первых, получилось приложение с десятком классов и 200+ строк кода, что несколько больше исходного примера на 30 строк. И следует быть честным — это лишь наметки на структуру, первое прояснение границ будущего приложения. Прототип.
И этот прототип дал возможность осознать, насколько велика дистанция между подходами к коду с точки зрения специалистов по Machine Learning и с точки зрения разработчиков традиционных приложений. И в этом, на мой взгляд, заключается основная сложность для девелоперов, решивших попробовать машинное обучение.
Следующая вещь, которая может поставить новичка в ступор – данные не менее важны, чем выбранная модель. Это было наглядно показано.
Далее, всегда остается вероятность, что обученная на одних данных модель покажет себя неадекватно на других, или в какой-то момент ее точность начнет деградировать.
Соответственно, требуются метрики контроля состояния модели, гибкость при работе с данными, технические возможности скорректировать обучение на лету. И так далее.
Как по мне, все это следует учитывать еще при проектировании архитектуры и выстраивании процессов разработки.
В общем, «кроличья нора» оказалась не только весьма глубокой, но и чрезвычайно хитро проложенной. Но тем интереснее для меня, как разработчика, изучать эту тему в дальнейшем. | https://habr.com/ru/post/457168/ | null | ru | null |
# Сто раз сломай, один раз поправь или Как мы улучшали тестирование отказоустойчивости и восстановления API
Привет, хабровчане!
Меня зовут Нурыев Асхат, я ведущий инженер по автоматизации в DINS. За время работы в компании я участвовал в решении множества сложных задач. В этой статье я поделюсь историей улучшения процесса и автоматизации тестирования высокой доступности и восстановления после отказа подсистемы API, состоящей из множества компонент.
Статья будет полезна всем, кто интересуется тестированием отказоустойчивости и высокой доступности и хочет знать, как можно его организовать и автоматизировать. В ней я расскажу, какие проблемы у нас возникли, как мы их решали, и, конечно, о результатах.
А проблем было немало, в самом начале проекта я даже не знал, как к нему подступиться. Для нашей команды это был первый опыт подобного рода.
Началось все как обычно: одним прекрасным утром ко мне подошел менеджер и спросил, не хочу ли я заняться одной интересной задачей. К тому времени у меня уже был опыт организации перфоманс-тестирования и вообще улучшения процессов в команде, так что я, конечно, согласился. А когда он объяснил, чем именно предстоит заняться, глаза у меня загорелись! Только подумайте: построить HA тестирование целой подсистемы — есть где развернуться, проявить изобретательность!
### Большие планы
Как выяснилось чуть позже, в компании уже был процесс HA тестирования, но работал он не очень хорошо. Зачастую результаты появлялись после релиза, когда исправлять ошибки тяжело. Нужно было разобраться, что происходит, и организовать тестирование нашей подсистемы API так, чтобы тестирование проходило в разумные сроки и не требовало слишком много ресурсов.
Чтобы лучше понять всю сложность задачи, которая перед нами стояла, приведу некоторые цифры:
* API имеет более 1000 точек входа.
* Более 30-ти видов сервисов участвуют в обработке запросов и каждый из них устанавливается как минимум в 2-х, а как максимум в 15-ти экземплярах.
* Наши сервисы устанавливаются как на реальном железе, так и на виртуалках и, конечно, в Docker контейнерах.
* На момент начала нашей работы тестирование занимало 3-4 месяца.
Вот так выглядит архитектурная диаграмма этой системы (в реальности такая «красота» разворачивается еще и в куче дата-центров).
### В самом начале
Первый этап проекта — это продумать, как все организовать. После этого можно просить помощи у команд разработки. На данном этапе я работал самостоятельно.
Очень хотелось разобраться:
* Как все организовано?
* Почему тестирование проходит так долго?
* Какие сценарии отказов проверяют коллеги?
Чтобы ответить на все эти вопросы, я пошел общаться с ребятами из разных команд, задействованных в тестировании.
В первую очередь я решил узнать про сценарии отказов, ведь это именно то, что нужно было проверять. Своеобразные тест-кейсы высокой доступности.
Как выяснилось, со сценариями все было хорошо. Команда Operations провела серьезную работу по сбору статистики всевозможных сбоев и отказов на продакшн системе, проанализировала результаты и выделила наиболее опасные и частые сценарии.Условно их можно было разделить на отказы отдельного сервиса:
* падение сервиса,
* переполнение диска,
* отключение питания машины или просто выход из строя сетевой карты.
И отказы, которые затрагивают сразу большие куски системы:
* отключение питания дата-центра,
* разрыв связи между разными дата-центрами,
* отключение сети внутри дата-центра и т.п.
Ребята знали, как воспроизвести эти отказы в лабах, и время от времени проверяли, как все работает.
Для тех, кому интересно, вот часть этих отказов:
| | | | |
| --- | --- | --- | --- |
| **N** | **Type** | **Name** | **Description** |
| 1 | Location | service-survival-mode | Put all servers in survival mod |
| 2 | Location | db-block-network | Block network on database host |
| 3 | Location | block-internal-network | Emulate core switch deny |
| 4 | Location | stop | Shutdown all VHS hosts |
| 5 | Location | block-network | Disable main rtr in location |
| 6 | Location | block-network-between-locations | Block network between locations |
| 7 | Location | stop-ccm-master | Stop ccm master in location |
| 8 | Location | stop-all-ccm | Stop all ccm nodes |
| 9 | Location | stop-all-ccs | Stop all ccs nodes |
| 10 | For Docker service | block-network | Block network to docker service |
| 11 | For Docker service | stop-service | Scale to 0 by CCM |
| 12 | For Docker service | kill | |
| 13 | For Docker service | restart-container | Restart service by CCM |
| 14 | For Virtual Machine | kill | Kill main process of service |
| 15 | For Virtual Machine | stop | Stop service |
| 16 | For Virtual Machine | stop-server | Shutdown VMs |
| 17 | For Virtual Machine | block-network | Disable network for VMs |
| 18 | For Virtual Machine | disk-congestion | Disk-congestion on VMs |
### Процесс тестирования
В общем и целом с отказами разобрался. Настало время проанализировать процессы. И вот тут я увидел несколько проблем:
* Во-первых, довольно много времени уходило на синхронизацию между командами из разных офисов, согласование удобных дат и времени для всех команд.
* Во-вторых, каждый отказ выполнялся вручную, а после отказа проводилась полная проверка окружения с прогоном smoke-тестов и их разбором.
* В-третьих, разбор этих тестов занимал много времени.
В общем, процесс происходил по следующей схеме, и каждая итерация могла растянутся на несколько дней:
Первоначальная схема тестирования### Gatling спешит на помощь
Как улучшить синхронизацию между командами или вовсе избежать ее? Слету решение я не нашел. Но для начала решил поработать с тестами.
Функциональные тесты плохо подходят для проверки высокой доступности. Нужно очень точно выбирать время запуска тестов и имитации отказа. Такая последовательность действий приводит к частым синхронизациям и ожиданиям.
Хотелось чего-то попроще и побыстрее, поэтому я решил заменить функциональные тесты на нагрузочные. Такой подход может скрыть некоторые функциональные ошибки. Но ведь мы проверяем нечто совсем иное, нам важно понять, как система ведет себя при сбоях. Как отрабатывают механизмы восстановления после отказа. Как много запросов при этом ломаются, сколько времени проходит до восстановления.
К счастью, нагрузочные тесты уже были готовы, хоть и не в полном объеме, но для проверки концепции их хватило. По сути нужно было сделать профиль для тестирования с минимальной нагрузкой и максимальным покрытием по сервисам внутри системы.
Дело недолгое, если есть опыт.
Теперь можно запустить тесты фоном и проводить имитации отказов и восстановление без дополнительных манипуляций и ожиданий. Все результаты попадут в отчет нагрузочного тестирования.
Так мы и стали делать. Я запускал джобу с перфоманс тестами и давал сигналы команде Operations для запуска отказов.
Однако довольно скоро я столкнулся с новой проблемой — тяжело вручную искать время отказа в отчете и разбираться, каким сценарием вызваны падения. Очень долго и неудобно, особенно если нужно проверить десятки сервисов и сценариев.
И тут я вспомнил, что в Gatling можно включить запись результатов в реальном времени, это должно помочь.
* Включил запись результатов в реальном времени в Influx.
* Подготовил дашборд в Grafana.
А чтобы было легче найти отказы, попросил Operations отмечать время запуска сценария отказа или восстановления там же в Grafana при помощи аннотаций.
В результате получились такие графики:
Изначально мы ставили только одну аннотацию на запуск отказа и одну на восстановление, но быстро сообразили, что такая разметка не дает полной картины, и стали выставлять по 2 метки — отдельно время запуска сценария и время его завершения.Сразу видно, что после отказа появились ошибки, а после восстановления — пропали. Значит, тут есть баги, — подумали мы и бросились к разработчикам, но не тут-то было.
На самом деле часть API должна быть доступна при всех видах отказов, а часть — нет, и требуются некоторые дополнительные действия, чтобы они заработали. Важно понимать, какие конкретно запросы падают в тех или иных сценариях.
К счастью, и тут помог Gatling. Мы подготовили дополнительные графики и сразу увидели падающие вызовы.
Мониторинг нагрузки в реальном времени с разбиением по API позволяет быстро найти источник ошибокНамного лучше, сразу все видно! Но все равно получается долго…
По-прежнему необходимо договариваться, нужно ждать пока у команды Operations появится время, чтобы запускать все эти сценарии и выставлять аннотации.
Тогда мы решили двигаться дальше и запилить сервис, который сам выполнял бы все отказы. Для новых сервисов в компании есть прекрасные готовые шаблоны — бери и добавляй свою логику.
### Сервис генерации отказов
Логика сервиса отказов — поломка и восстановления системы. То есть нужно интегрировать DGS с инфраструктурными сервисами, такими как VSphere, Marathon, сетевыми устройствами и даже с ИБП. Однако инфраструктурой у нас занимаются Operations, и чтобы все заработало, сперва нужно получить соответствующие доступы.
В итоге мы договорились работать над проектом вместе, чтобы оперативно решать все возникающие проблемы.
Сервис решили назвать DGS — Disaster Generator Service.Получилась следующая схема:
На момент создания сервиса у нас использовалась связка mesos/marathon. Хотя сейчас мы используем Spinnaker и Kubernetes с helmchart-ами, изначально сервис выглядел именно так.
Но часть отказов нельзя было воспроизвести при помощи сервисов. Нужно было как-то ломать хосты изнутри (забивать диск данными или убивать процесс), как это делали раньше вручную. Мы решили закинуть эти скрипты на Ansible-сервер, который мог бы выполнять их по запросу.
Первую версию сервиса я написал в кооперации с коллегой из команды Operations.
Он добавлял нужные скрипты на Ansible и выдавал права на доступ к различным сервисам.
И тут вылезла еще одна проблема. Оказалось, что запустить скрипты недостаточно, нужно убедится, что они отработали правильно. Зачастую запуски отказов не приводили к реальными отказам системы. Нужно было тщательно следить за корректностью работы скриптов и правильно использовать коды возврата в них.
Какое-то время ушло на отладку скриптов и сценариев, зато потом тестирование пошло намного проще. Запустил перфоманс-тесты через Jenkins пайплайн и сиди дергай curl-ом API для поломки/восстановления сервисов, классно!
### Магия пайплайнов
Уже на этом этапе время тестирования подсистемы API уменьшилось до 2-3 недель.
Тесты молотили без остановки, отказы запускались и откатывались по запросу к DGS, но анализировать результаты по прежнему было сложно.
Графики в Grafana отлично подходят для мониторинга текущего состояния, однако их явно недостаточно для полноценного анализа прогона.
Да и запускать отказы руками тоже со временем надоедает. Кроме того, приходится делать перерывы на ночь, что существенно замедляет весь процесс.
Следующим шагом стало создание Jenkins-пайплайна, запускающего все необходимые сценарии по списку, мы назвали его тест-планом. Он состоял из списка сервисов и списка отказов — к каждому сервису применяются все подходящие ему сценарии. То есть к сервису в докере применяются сценарии докера, а к сервису на виртуалке — сценарии отказа виртуалки.
Реализовать пайплайн было несложно, так что в скором времени все тесты стали выполняться за 3-4 дня.
Путь к API формируется на основе uri-сервиса и имени сценария, просто и понятно.
Пример файла с тест-планом для тестирования высокой доступности и восстановления после отказа
Пример файла с тест-планом
```
{
"testPlan": {
"minutesBetweenDisasters": 5,
"dgsUri": "http://service.name:8080/restapi/",
"dgsAuthToken": "test",
"services": [
"sap",
"asp",
. . .
],
"dockerServices": [
"abc",
"Bcd",
. . .
],
"locations": [
"loc71",
"Loc72",
. . .
],
"serviceTestCases": [
{
"failScenario": "service/block-network",
"recoveryScenario": "service/recover-network"
},
{
"failScenario": "service/stop-server",
"recoveryScenario": "service/start-server"
},
{
"failScenario": "service/stop",
"recoveryScenario": "service/start"
},
{
"failScenario": "service/kill",
"recoveryScenario": "service/recover"
},
{
"failScenario": "service/disk-congestion",
"recoveryScenario": "service/disk-recover-congestion"
}
],
"dockerServiceTestCases": [
{
"failScenario": "docker/stop-service",
"output": "instances",
"recoveryScenario": "docker/start-service",
"input": "dockerInstanceQuantity"
},
{
"failScenario": "docker/restart-container",
"recoveryScenario": "autorecovery"
},
{
"failScenario": "docker/block-network",
"recoveryScenario": "docker/recover-network"
}
],
"locationTestCases": [
{
"failScenario": "location/block-network",
"recoveryScenario": "location/recover-network"
},
{
"failScenario": "location/block-network-between-locations",
"recoveryScenario": "location/recover-network-between-locations"
},
{
"failScenario": "location/switchover",
"recoveryScenario": "autorecovery"
}
]
}
}
```
#### Отчеты, отчеты и снова отчеты
Теперь тестирование проходило достаточно быстро, но анализ результатов вызывал головную боль.
Проблема в том, что отчет о тестировании мы получали только в самом конце, когда все тесты уже прошли. Нельзя начать анализ, пока автоматизация еще работает.
А когда она заканчивает работу, мы получаем десятки, а то и сотни сценариев, которые исполнялись последние несколько дней, слишком много для анализа.
А что если собрать данные не останавливая тесты? Gatling пишет статистику выполнения в simulation.log файл. Что если отрезать соответствующий кусок, и по нему сгенерировать отчет?
После некоторых экспериментов удалось получить вполне приемлемый отчет за сессию поломки компонента. Для этого сделали скрипт.
Скрипт для нарезки логов Gatling-симуляции для генерации промежуточного отчета.
```
#!/bin/bash
SIZE=0
if [[ -d results/report ]]
then
rm -rf results/report
fi
DIR=( `ls results | grep "ha"` )
if [[ -f simulation-backup.log ]]
then
SIZE=( `cat simulation-backup.log | wc -l`) && echo "Backup lines: "$SIZE
cp results/$DIR/simulation.log simulation-backup.log
echo "Simulation file lines: " && wc -l results/$DIR/simulation.log
tail -n +$SIZE simulation-backup.log >simulation-parts.log
echo "Parts file lines: " && wc -l simulation-parts.log
else
cp results/$DIR/simulation.log simulation-backup.log
fi
if [[ -f simulation-result.log ]]
then
rm -f simulation-result.log
fi
if [[ $SIZE -gt 0 ]]
then
head -n1 results/$DIR/simulation.log > simulation-result.log
ls | grep parts | grep -v 00 | xargs -I{} cat {}>>simulation-result.log
else
cp simulation-backup.log simulation-result.log
fi
echo "Result has lines: " && wc -l simulation-result.log
ls | grep parts | xargs -I{} rm -f {}
mkdir -p results/report
cp simulation-result.log results/report/simulation.log
```
Чтобы запускать этот скрипт в нужные моменты, пришлось доработать джобу с перфоманс-тестами. И я добавил в нее запуск параллельного стейджа с апрувом и входными параметрами для задания названия сценария.
Основной стейдж пайплайна запускал перфоманс-тесты, а другой ждал ввода данных. Когда сценарий отказа заканчивался, джоба оркестратор посылала запрос к джобе с тестами, чтобы она отрезала кусок лога симуляции и сгенерировала отчет.
Небольшие отчеты гораздо проще анализировать и передавать командам разработкиИз отчета видно, когда именно происходили изменения в системе и к каким последствиям они приводили. Слева видно, как запустился отказ и ненадолго появились ошибки, при восстановлении ошибок уже не было, но увеличилось время ответа
Отлично, теперь можно начинать разбор после первого же отказа! Прогон тестов занимает те же 3-4 дня, но анализировать результаты можно прямо в процессе выполнения.
В результате пришли к следующей схеме работы:
Схема тестирования с учетом автоматизацииКазалось бы, на этом все, можно остановиться. Однако на практике все несколько сложнее. Иногда происходит что-то непредвиденное и восстановление сервисов не отрабатывает. Или же находятся ошибки в некоторых сервисах, и нужно привлекать разработчиков, обновлять систему, а потом перезапускать тесты. В общем, нужно больше гибкости при запуске.
Поэтому я еще немного доработал джобы, вынес больше параметров запуска, и если основной прогон показывал, что есть проблемы, можно было просто перезапустить тестирование отдельного сервиса или отказа.
### Мониторинг
Высокая доступность на продакшене зависит не только от правильного автоматического переключения трафика и прочих способов автоматической обработки отказов, но и от системы мониторинга и оповещения.
В каждой системе есть части, которые в силу разных причин нельзя восстановить автоматически. То есть для восстановления полноценной работы требуется вмешательство инженера. Но для того, чтобы человек узнал, что нужно что-то делать, нужно его оповестить. Именно для этого и делают мониторинг с многочисленными графиками и алертами.
Отсюда возникла идея собрать все триггеры, срабатывающие во время отказов, в дополнительный отчет.
На момент реализации тестирования большая часть сервисов использовала для мониторинга Zabbix. Довольно громоздкая и немного устаревшая система, но с довольно развитым API. Оказалось, что собрать сработавшие алерты из мониторинга — тривиальная задача.
История срабатывания и восстановления алертов вместе с отчетом об ошибках в API из перфоманс сессии позволяет понять соответствует ли система ожиданиям. Для отслеживания регресса, можно считать число ошибок на тех или иных API и отмечать (не)срабатывание и (не)восстановление алертов.
### Коротко о главном
Статья получилась обзорной и не затрагивает глубоких аспектов тестирования и деталей разработки отказов. Но надеюсь, все же будет полезной для тех, кто захочет сделать что-то подобное у себя.
Если кому то захочется узнать больше деталей, пишите в комментариях.
Приведу краткий список действий, которые помогли нам организовать тестирование у себя и, возможно, помогут и вам:
1. Найти самые вероятные сценарии отказов на продакшене.
2. Проанализировать текущий процесс тестирования.
3. Использовать непрерывный поток запросов перфоманс-тестов вместо разовых запусков функциональных.
4. Настроить дашборды для анализа результатов в реальном времени.
5. Автоматизировать все, что имеет смысл автоматизировать.
5.1 Генерацию отказов и восстановления системы
5.2 Jenkins пайплайны для управления процессом
6. Улучшить генерацию отчетов, чтобы можно было начать анализ результатов как можно раньше.
7. Собрать данные мониторинга о сработавших алертах.
И самое главное, запускать это все регулярно, чтобы ловить ошибки в лабах, а не на продакшене. | https://habr.com/ru/post/647137/ | null | ru | null |
# jBitTorrent API 1.0, исправленный и дополненный
Недавно я [описывал библиотеку jBitTorrent](http://habrahabr.ru/blogs/java/117116/#habracut) для Java, с помощью которой можно работать с файлами по протоколу BitTorrent.
В той же статье был блок описания проблем, встречанных при использовании этой библиотеки, ведь она не обновлялась еще с 2009 года.
Пользователь [sadyjka](https://habrahabr.ru/users/sadyjka/) предложил мне самому пофиксить эти баги, и вот я нашел немного времени для этого. Исправлены следующие проблемы:
* Недочет при добавлении множественных файлов в генерируемый торрент-файл
* Ошибка при закачке файлов
В первом случае я реализовал добавление папки на генерацию торрент-файла, во втором случае попросту убрал вызов метода, генерирующего исключение. Насколько я понял его логику из кода, он не особо и нужен (обработка рейтинга пиров).
Более полные описания этих ошибок можно найти в статье по ссылке, указанной выше.
Признаюсь честно, с этим кодом мне пришлось несколько суток разбираться, поэтому я мог немножко наговнокодить.
Проблему в `printData` я не стал убирать, ибо метод также не критичен, а просмотрев исходник, увидел, что идет доступ к списочным элементам, которые в том классе не использовались.
Извиняюсь, что не на SourceForge лежат мои фиксы, ибо автор оказался весьма занятым.
[Исходники](http://xbox.od.ua/uploads/jBittorrentAPI.src.tar.gz)
[JAR](http://xbox.od.ua/uploads/jBitTorrent API.jar)
**UPD**
По просьбе [debacle](https://habrahabr.ru/users/debacle/) сделал [репозиторий на GitHub](https://github.com/purplexcite/jBitTorrent-API). | https://habr.com/ru/post/117526/ | null | ru | null |
# Руководство по решению проблем с памятью в Ruby
Наверняка есть везучие Ruby-разработчики, которые никогда не страдали от проблем с памятью. Но всем остальным приходится тратить невероятно много сил, чтобы разобраться, почему использование памяти вышло из-под контроля, и устранить причины. К счастью, если у вас достаточно современная версия Ruby (начиная с 2.1), то вам доступны замечательные инструменты и методики для решения распространённых проблем. Мне кажется, что оптимизация памяти может приносить радость и удовлетворение, но я могу быть одинок в своём мнении.
Как бывает со всеми формами оптимизации, возможно, это приведёт к усложнению кода. Так что не сто̒ит этим заниматься, если вы не получите измеряемые и значительные преимущества.
Все описанные ниже процедуры выполнены с помощью канонического MRI Ruby 2.2.4, но и другие версии 2.1+ должны работать аналогично.
Это не утечка памяти!
=====================
Когда возникает проблема с памятью, то сперва в голову приходит только одно — утечка. Например, вы можете увидеть в веб-приложении, что после запуска сервера повторяющиеся вызовы одной и той же функции с каждым разом потребляют всё больше памяти. Конечно, случаются и в самом деле утечки, но я готов спорить, что куда чаще встречаются проблемы, которые выглядят как утечки, но ими не являются.
Рассмотрим выдуманный пример: раз за разом будем создавать и сбрасывать большой массив хешей. Вот часть кода, которая будет использоваться в разных примерах в этой статье:
```
# common.rb
require "active_record"
require "active_support/all"
require "get_process_mem"
require "sqlite3"
ActiveRecord::Base.establish_connection(
adapter: "sqlite3",
database: "people.sqlite3"
)
class Person < ActiveRecord::Base; end
def print_usage(description)
mb = GetProcessMem.new.mb
puts "#{ description } - MEMORY USAGE(MB): #{ mb.round }"
end
def print_usage_before_and_after
print_usage("Before")
yield
print_usage("After")
end
def random_name
(0...20).map { (97 + rand(26)).chr }.join
end
```
Строим массив:
```
# build_arrays.rb
require_relative "./common"
ARRAY_SIZE = 1_000_000
times = ARGV.first.to_i
print_usage(0)
(1..times).each do |n|
foo = []
ARRAY_SIZE.times { foo << {some: "stuff"} }
print_usage(n)
end
```
[get\_process\_mem](https://github.com/schneems/get_process_mem) — удобный способ получить информацию о памяти, используемой текущим Ruby-процессом. Мы видим описанное выше поведение: постепенное увеличение потребления памяти.
```
$ ruby build_arrays.rb 10
0 - MEMORY USAGE(MB): 17
1 - MEMORY USAGE(MB): 330
2 - MEMORY USAGE(MB): 481
3 - MEMORY USAGE(MB): 492
4 - MEMORY USAGE(MB): 559
5 - MEMORY USAGE(MB): 584
6 - MEMORY USAGE(MB): 588
7 - MEMORY USAGE(MB): 591
8 - MEMORY USAGE(MB): 603
9 - MEMORY USAGE(MB): 613
10 - MEMORY USAGE(MB): 621
```
Но если выполнить больше итераций, то рост потребления прекратится.
```
$ ruby build_arrays.rb 40
0 - MEMORY USAGE(MB): 9
1 - MEMORY USAGE(MB): 323
...
32 - MEMORY USAGE(MB): 700
33 - MEMORY USAGE(MB): 699
34 - MEMORY USAGE(MB): 698
35 - MEMORY USAGE(MB): 698
36 - MEMORY USAGE(MB): 696
37 - MEMORY USAGE(MB): 696
38 - MEMORY USAGE(MB): 696
39 - MEMORY USAGE(MB): 701
40 - MEMORY USAGE(MB): 697
```
Это говорит о том, что мы имеем дело не с утечкой. Либо утечка так мала, что мы её не замечаем по сравнению с остальной используемой памятью. Но непонятно, почему после первой итерации растёт потребление памяти. Да, мы создаём большой массив, но потом корректно его обнуляем и начинаем создавать новый такого же размера. Разве нельзя взять ту же память, которая использовалась предыдущим массивом?
Нет.
Помимо настройки сборщика мусора вы не можете управлять временем его запуска. В нашем примере `build_arrays.rb` мы видим, что новые распределения памяти делаются до того, как сборщик мусора уберёт наши старые, сброшенные объекты.
**Не волнуйтесь, если обнаружите неожиданное увеличение потребления памяти вашим приложением. Тому может быть множество причин, не только утечки.**
Должен отметить, что речь не идёт о каком-то кошмарном управлении памятью, характерном для Ruby. Но вопрос в целом имеет отношение ко всем языкам, использующим сборщики мусора. Чтобы удостовериться в этом, я воспроизвёл приведённый пример на Go и получил аналогичный результат. Правда, там используются библиотеки Ruby, которые могли стать причиной этой проблемы с памятью.
Разделяй и властвуй
===================
Итак, если нам нужно работать с большими объёмами данных, то мы обречены терять кучу оперативной памяти? К счастью, это не тот случай. Если взять предыдущий пример и уменьшить размер массива, то мы обнаружим, что потребление памяти выровняется раньше.
Это означает, что если мы можем разбить нашу работу на более мелкие фрагменты и обработать, чтобы исключить одновременное использование большого количества объектов, то мы избежим сильного увеличения потребления памяти. К сожалению, для этого часто приходится взять чистый и красивый код и превратить его в более громоздкий, который делает всё то же самое, но эффективнее с точки зрения памяти.
Изолирование горячих точек потребления памяти
=============================================
Часто в коде источник проблемы с памятью не столь очевиден, как в примере `build_arrays.rb`. Необходимо сначала изолировать причину и только затем приступать к её изучению, потому что легко можно сделать ошибочные выводы о причине проблемы.
Обычно для выявления проблем с памятью я использую два подхода, зачастую комбинируя:
* оставляю код без изменений и оборачиваю его в профилировщик;
* отслеживаю использование памяти процессом, убирая/добавляя разные части кода, которые могут быть причиной проблемы.
Здесь в качестве профилировщика я воспользуюсь [memory\_profiler](https://github.com/SamSaffron/memory_profiler) (также популярен [ruby-prof](https://github.com/ruby-prof/ruby-prof)), а для мониторинга возьму [derailed\_benchmarks](https://github.com/schneems/derailed_benchmarks), имеющий некоторые замечательные возможности, характерные для Rails.
Вот пример кода, использующего большой объём памяти. Здесь не ясно с ходу, на каком этапе потребляется больше всего:
```
# people.rb
require_relative "./common"
def run(number)
Person.delete_all
names = number.times.map { random_name }
names.each do |name|
Person.create(name: name)
end
records = Person.all.to_a
File.open("people.txt", "w") { |out| out << records.to_json }
end
```
С помощью [get\_process\_mem](https://github.com/schneems/get_process_mem) можно быстро выяснить, что больше всего памяти используется при создании записей `Person`.
```
# before_and_after.rb
require_relative "./people"
print_usage_before_and_after do
run(ARGV.shift.to_i)
end
```
Результат:
```
$ ruby before_and_after.rb 10000
Before - MEMORY USAGE(MB): 37
After - MEMORY USAGE(MB): 96
```
В этом коде есть несколько мест, которые могут отнимать много памяти: создание большого массива строк, вызов `#to_a` для создания большого массива из объектов Active Record (не лучшая идея, но это сделано ради демонстрации) и сериализация массива из объектов Active Record.
Выполним профилирование кода, чтобы понять, где осуществляются распределения памяти:
```
# profile.rb
require "memory_profiler"
require_relative "./people"
report = MemoryProfiler.report do
run(1000)
end
report.pretty_print(to_file: "profile.txt")
```
Обратите внимание, что `run` здесь скармливается в десять раз меньшее количество, чем в предыдущем примере. Профилировщик сам по себе потребляет много памяти, и это может привести к её исчерпанию во время профилирования кода, который уже занял большой объём.
Файл получается довольно длинным, включает в себя распределение и удержание памяти и объектов в gem’е, файлы, а также уровни размещения. Настоящее обилие информации, в которой есть пара интересных частей:
```
allocated memory by gem
-----------------------------------
17520444 activerecord-4.2.6
7305511 activesupport-4.2.6
2551797 activemodel-4.2.6
2171660 arel-6.0.3
2002249 sqlite3-1.3.11
...
allocated memory by file
-----------------------------------
2840000 /Users/bruz/.rvm/gems/ruby-2.2.4/gems/activesupport-4.2.6/lib/activ
e_support/hash_with_indifferent_access.rb
2006169 /Users/bruz/.rvm/gems/ruby-2.2.4/gems/activerecord-4.2.6/lib/active
_record/type/time_value.rb
2001914 /Users/bruz/code/mem_test/people.rb
1655493 /Users/bruz/.rvm/gems/ruby-2.2.4/gems/activerecord-4.2.6/lib/active
_record/connection_adapters/sqlite3_adapter.rb
1628392 /Users/bruz/.rvm/gems/ruby-2.2.4/gems/activesupport-4.2.6/lib/activ
e_support/json/encoding.rb
```
Большинство распределений происходят внутри Active Record. Похоже, это указывает либо на создание экземпляров всех объектов в массиве `records`, либо на сериализацию с помощью `#to_json`. Далее мы можем протестировать использование памяти без профилировщика, убрав подозрительные места. Мы не можем отключить извлечение `records`, так что начнём с сериализации.
`# File.open("people.txt", "w") { |out| out << records.to_json }`
Результат:
```
$ ruby before_and_after.rb 10000
Before: 36 MB
After: 47 MB
```
Похоже, именно здесь потребляется больше всего памяти: соотношение между до и после составляет 81%. Можно посмотреть, что будет, если мы перестанем принудительно создавать большой архив записей.
```
# records = Person.all.to_a
records = Person.all
# File.open("people.txt", "w") { |out| out << records.to_json }
```
Результат:
```
$ ruby before_and_after.rb 10000
Before: 36 MB
After: 40 MB
```
Потребление памяти тоже снижается, хотя и на порядок меньше, чем при отключении сериализации. Теперь нам известен главный виновник, и можно принять решение об оптимизации.
Хотя это и выдуманный пример, описанные здесь подходы применимы и в реальных задачах. Результаты профилирования могут не дать внятного результата и конкретного источника проблемы, да к тому же могут быть интерпретированы неверно. Так что лучше дополнительно проверить реальное использование памяти, включая и отключая части кода.
Далее мы рассмотрим некоторые распространённые ситуации, когда использование памяти становится проблемой, и узнаем, какие оптимизации можно сделать.
Десериализация
==============
Проблемы с памятью часто возникают при десериализации больших объёмов данных из XML, JSON или других форматов сериализации данных. Методы вроде `JSON.parse` или `Hash.from_xml` из Active Support крайне удобны, но если данных много, то в память может загрузиться гигантская структура.
Если у вас есть контроль над источником данных, вы можете ограничить объём получаемой информации, добавив фильтрацию или поддержку загрузки частями. Но если источник внешний или вы не можете его контролировать, то можно воспользоваться потоковым десериализатором. В случае с XML можно взять [Ox](https://github.com/ohler55/ox), а для JSON подойдёт [yajl-ruby](https://github.com/brianmario/yajl-ruby). Судя по всему, они работают примерно одинаково.
**То, что у вас ограниченный объём памяти, не означает, что вы не можете безопасно парсить большие XML- или JSON-документы. Потоковые десериализаторы позволяют постепенно извлекать то, что вам нужно, сохраняя низкое потребление памяти.**
Вот пример парсинга XML-файла размером 1,7 Мб с помощью `Hash#from_xml`.
```
# parse_with_from_xml.rb
require_relative "./common"
print_usage_before_and_after do
# From http://www.cs.washington.edu/research/xmldatasets/data/mondial/mondial-3.0.xml
file = File.open(File.expand_path("../mondial-3.0.xml", __FILE__))
hash = Hash.from_xml(file)["mondial"]["continent"]
puts hash.map { |c| c["name"] }.join(", ")
end
$ ruby parse_with_from_xml.rb
Before - MEMORY USAGE(MB): 37
Europe, Asia, America, Australia/Oceania, Africa
After - MEMORY USAGE(MB): 164
```
111 Мб на файл 1,7 Мб! Совершенно неуместное соотношение. А вот версия с потоковым парсером.
```
# parse_with_ox.rb
require_relative "./common"
require "ox"
class Handler < ::Ox::Sax
def initialize(█)
@yield_to = block
end
def start_element(name)
case name
when :continent
@in_continent = true
end
end
def end_element(name)
case name
when :continent
@yield_to.call(@name) if @name
@in_continent = false
@name = nil
end
end
def attr(name, value)
case name
when :name
@name = value if @in_continent
end
end
end
print_usage_before_and_after do
# From http://www.cs.washington.edu/research/xmldatasets/data/mondial/mondial-3.0.xml
file = File.open(File.expand_path("../mondial-3.0.xml", __FILE__))
continents = []
handler = Handler.new do |continent|
continents << continent
end
Ox.sax_parse(handler, file)
puts continents.join(", ")
end
$ ruby parse_with_ox.rb
Before - MEMORY USAGE(MB): 37
Europe, Asia, America, Australia/Oceania, Africa
After - MEMORY USAGE(MB): 37
```
Потребление памяти увеличивается незначительно, и теперь мы можем обрабатывать гораздо более крупные файлы. Но компромисса избежать не удалось: теперь у нас 28 строк кода обработки, который раньше был не нужен. Это повышает вероятность ошибок, так что в производстве эту часть нужно дополнительно тестировать.
Сериализация
============
Как мы видели в главе про изолирование горячих точек потребления памяти, сериализация может проводить к большим потерям. Вот ключевая часть из приведённого выше примера `people.rb`.
```
# to_json.rb
require_relative "./common"
print_usage_before_and_after do
File.open("people.txt", "w") { |out| out << Person.all.to_json }
end
```
Если запустить его с базой данных на 100 000 записей, то мы получим:
```
$ ruby to_json.rb
Before: 36 MB
After: 505 MB
```
Здесь проблема с `#to_json` заключается в том, что он создаёт экземпляр объекта для каждой записи, а затем кодирует в JSON. Можно существенно снизить потребление памяти, если генерировать JSON запись за записью, чтобы в каждый отрезок времени существовал только один объект записи. Похоже, этого не умеет делать ни одна из популярных Ruby JSON библиотек, и обычно рекомендуется вручную создавать JSON-строку. Хороший API для этого предоставляет gem [json-write-stream](https://github.com/camertron/json-write-stream), и тогда наш пример можно конвертировать:
```
# json_stream.rb
require_relative "./common"
require "json-write-stream"
print_usage_before_and_after do
file = File.open("people.txt", "w")
JsonWriteStream.from_stream(file) do |writer|
writer.write_object do |obj_writer|
obj_writer.write_array("people") do |arr_writer|
Person.find_each do |people|
arr_writer.write_element people.as_json
end
end
end
end
end
```
В очередной раз оптимизация потребовала написать больше кода, но результат того стоит:
```
$ ruby json_stream.rb
Before: 36 MB
After: 56 MB
```
Быть ленивым
============
Начиная с Ruby 2.0 появилась замечательная возможность делать ленивые перечислители (lazy enumerator). Это позволяет сильно уменьшить потребление памяти при вызове цепочки методов перечислителя. Начнём с неленивого кода:
```
# not_lazy.rb
require_relative "./common"
number = ARGV.shift.to_i
print_usage_before_and_after do
names = number.times
.map { random_name }
.map { |name| name.capitalize }
.map { |name| "#{ name } Jr." }
.select { |name| name[0] == "X" }
.to_a
end
```
Результат:
```
$ ruby not_lazy.rb 1_000_000
Before: 36 MB
After: 546 MB
```
На каждой стадии цепочки выполняется итерация по всем элементам и создаётся новый массив, у которого есть вызываемый им следующий метод в цепочке, и т. д. Давайте посмотрим, что происходит, когда мы делаем это ленивым способом, просто добавляя вызов `lazy` в получаемый из `times` перечислитель:
```
# lazy.rb
require_relative "./common"
number = ARGV.shift.to_i
print_usage_before_and_after do
names = number.times.lazy
.map { random_name }
.map { |name| name.capitalize }
.map { |name| "#{ name } Jr." }
.select { |name| name[0] == "X" }
.to_a
end
```
Результат:
```
$ ruby lazy.rb 1_000_000
Before: 36 MB
After: 52 MB
```
Наконец-то пример, дающий нам огромный выигрыш в потреблении памяти без добавления большого количества кода! Обратите внимание, что если нам не нужно в конце аккумулировать результаты, например если каждый элемент был сохранён в базу данных и может быть забыт, то памяти будет тратиться ещё меньше. Для получения результата перечислителя в конце цепочки просто добавьте финальный вызов `force`.
Также нужно отметить, что сначала вызывается `times`, а потом `lazy`, ведь первый потребляет очень мало памяти, всего лишь возвращая перечислитель, который генерирует целочисленное при каждом вызове. Так что если в начале цепочки вместо массива можно использовать перечислитель, то это также является плюсом, снижая потребление памяти.
**Удобно держать всё в огромных массивах и коллекциях (map), но в реальных ситуациях это допускается только в редких случаях.**
Создавать enumerable для ленивой обработки данных можно, например, при работе с данными, разделёнными на страницы. Вместо того чтобы запрашивать все страницы и класть их в один большой массив, можно выдавать их через перечислитель, который замечательно прячет все подробности разбиения на страницы. Например, так:
```
def records
Enumerator.new do |yielder|
has_more = true
page = 1
while has_more
response = fetch(page)
response.records.each { |record| yielder record }
page += 1
has_more = response.has_more
end
end
end
```
Заключение
==========
Мы дали характеристику использованию памяти в Ruby, рассмотрели несколько основных инструментов для отслеживания проблем с памятью, разобрали частые ситуации и способы оптимизации. Рассмотренные ситуации не претендуют на полноту охвата и иллюстрируют самые разные проблемы, с которыми я лично сталкивался. Однако главный результат статьи — попытка задуматься о том, как код влияет на потребление памяти. | https://habr.com/ru/post/305426/ | null | ru | null |
# Сохранность Registry своими руками
Недавно пострадал от потери NTUser.dat и с ним всего HKCU под Windows7 да так, что Windows Restore не помог — пришлось подниматься из бакапа месячной давности. В результате сильно озаботился вопросом резервирования реестра. Как выяснилось, Win7/Vista никакого резервирования «чисто» реестра (в отличии от XP) не предлагают. В этом посте расскажу о том, что можно сделать своими руками по этому поводу с помошью утилиты **ERUNT** и **User Profile Hive Cleanup Service** (UPHClean). В завершение привожу пример того, как это сделал я.
**Историческая справка.**
Registry, каким мы его знаем, впервые появился в Win95, и сразу стало понятно, что терять/портить его не стоит. Благо, в OC семейства Win9x реестр автоматически бекапился при старте системы. При этом держалось от двух (Win95) до пяти (Win98/ME) уровней отката. Ручной бакап тоже не представлял проблем, т.к. достаточно было перегрузить компьютер в DOS-режиме и скопировать несколько файлов в безопасное место. Также Microsoft предоставляла утилиту ERU, которая бакапила реестр прямо из Windows.
С приходом Win2000 и ее производных (WinXP/Vistal/7) ситуация изменилась в корне. В системах на основе NT файлы Registry (C:\Windows\System32\Config и %userprofile%\ntuser.dat) всегда открыты и используются. В итоге стали проявляться неприятные баги, некоторые из которых встречаются и по сей день. Почти все они являются последствиями одного сценария: какая-то программка открывает ключ в Registry и забывает его закрыть. В результате, может происходить ряд интересных побочных эффектов:
\* Во-первых, если не закрыт ключ в HKCU, logoff\перезагрузка/выключение компьютера может занять оооооочень много времени — Windows терпеливо ждет, пока все программы освободят HKCU, чтобы отлогинить пользователя (чего не происходит, если глючная программка прописана как системный сервис).
\* Во-вторых, некоторые изменения так и не «сбрасывались» в реестр, и в итоге не сохранялись после перезагрузки. Особенно сильно это напрягало корпоративных пользователей с Roaming профайлами, которым зачастую приходилось, к примеру, каждый раз наблюдать сообщение «Please wait while Windows configures <программка>» при запуске какого-нибудь офисного приложения. В результате в Vista/W7 мы имеем файлы транзакций реестра (regtrans-ms), которые иногда занимают больше места, чем сами файлы реестра :)
\* В худшем случае при перезагрузке нарушалась целостность реестра и можно было лишиться хайва целиком (чаще всего, опять же, HKCU). Это, кстати, продолжается по сей день, довольно много шума поднимается по поводу сервиса обновляющего Google Chrome, который любит открывать много дескрипторов и забывает закрывать некоторые из них.
Проблема была настолько серьезной, что Microsoft выпустила специальный сервис "[User Profile Hive Cleanup Service](http://www.microsoft.com/download/en/details.aspx?id=6676)", который насильно отключает всех от registry при перезагрузке (правда, только для HKCU/ntuser.dat). Очень рекомендую.
Все это показало насколько целостность реестра критична для систем на базе WinNT. Тем не менее,
* В NT/2000 вообще нет автоматического бакапа реестра.
* В WinXP бакап реестра производится только в процессе общего резервирования системы (если выбрать Backup System State). При этом файлы ОС (~500MB) кладутся в указанный пользователем каталог, а резервная копия реестра оказывается в C:\Windows\Repair, откуда ее надо скопировать ручками (ну, или удалить 500М барахла, если вам нужно было забакапить только реестр). К сожалению, графический интерфейс Windows не позволяет выбирать подкаталоги в NUL :)
* В Vista/W7 бакап производится в VHD всего целиком; System Restore, как выяснилось, недостаточно надежен, а \Windows\Repair нет впомине. **\*\*UPD\*\***Зато есть аналогичный ему \Windows\System32\Config\RegBack, который обновляется раз в 10 дней силами Task Scheduler'a. Спасибо [добрым людям из комментов](#comment_4772892). Правда, там только системный реестр.
Другого простого способа бакапить реестр не было, и его пришлось придумать. Так появилась ERUNT (ERU для NT).
**ERUNT.**
[ERUNT](http://www.larshederer.homepage.t-online.de/erunt/) была разработана немецким специалистом по имени **Lars Hederer**, и, собственно, резервирует реестр любой WinNT-подобной ОС (NT/2K/2K3/XP/Vistal/7) в заданный каталог «по-живому» (т.е. не при перезагрузке, а в любое время в процессе работы ОС).
Подробности применения можно почитать в файле [readme](http://www.larshederer.homepage.t-online.de/erunt/erunt.txt), я же расскажу о том, чем она понравилась лично мне, и как я ее использую.
* Обладает GUI и CLI для резервирования и восстановления. Очень удобно использовать GUI для тестирования, а потом закатать все в параметры командной строки и создать Task (о чем ниже). Аналогично для воостановления: для полного восстановления можно сделать простой батник, для каких-то особенных ситуаций можно запустить GUI и выбрать то, что нужно.
* Позволяет выбирать хайвы (системные и пользовательские) — можно бакапить: систему, профайл пользователя, профайлы других пользователей, все вместе. Вначале у меня был план «бакапить все раз в неделю, бакапить профайл каждый день», но программка работает настолько быстро, и бакапы занимают настолько мало места, что теперь просто бакаплю все каждый день.
* Восстанавливает реестр из специального загрузчика или Windows Recovery Console. Обычно, хватает консоли (т.к., фактически происходит банальная перезапись файлов).
* Устанавливается через инсталлер, но, вроде, никаких файлов за пределы своего каталога не кладет, так что годна к portable-применению. В каталоге хранится .INI файл, в который можно записать значения по умолчанию, что позволяет уменьшить количество задаваемых каждый раз ключей командной строки. В любом случае, утилита восстановления работает полностью независимо.
* Куча интересных опций автоматизированного бакапа. Для себя сделал следующее:
+ В каталоге D:\Install\\_\_Backups\RegBackup-ERUNT\ создаются подкаталоги с датой-временем в нужном мне формате (прим. RegBackup-ERUNT\2012-04-19-17.00.04\).
+ В каждом таком подкаталоге лежат, собственно, хайвы registry и утилита восстановления (чтобы не напрягаться).
+ Хранится история бакапов за 30 дней (можно настроить по количеству, скажем, 5 последних, или по времени). Старые удаляются автоматически (отключаемо).
+ Если сегодня бакап уже делали — второй (третий, и т.д.) раз пропускается. (полезно, т.к. в Task Scheduler'е стоит опция «если пропущено время запуска задачи — запустить при первой возможности», таким образом могут быть запущены два бакапа за день).
+ Стандартные опции вроде тихого режима и т.д.
+ Особенно впечатлило то, что в тоге я избавился от большей части ключей командной строки, т.к. значения, по умолчанию выставленные автором, делают как раз то, что мне нужно! :) Остальное было выставлено в INI-файле и в итоге огромная командная строка была сведена к AUTOBACK.EXE <имя каталога для бакапов>\#Date#-#Time#.
В завершение прилагаю ERUNT.INI и .XML для Task Scheduler'a.
ERUNT.INI (в каталог с ERUNT):
```
[ERUNT]
DefaultDestinationFolder=D:\Install\__Backups
DateFormat=yyyy/mm/dd
DateSeparator=-
TimeFormat=hh:mm:ss
TimeSeparator=.
```
ERUNT.XML (импортируется в Task Scheduler, подправьте имя юзера и пути):
```
xml version="1.0" encoding="UTF-16"?
2012-04-01T21:27:40.026817
APCNB\apc
2012-04-01T17:00:00
PT1H
true
1
APCNB\apc
S4U
HighestAvailable
IgnoreNew
false
true
true
true
false
true
false
true
true
false
false
false
false
false
PT1H
7
PT1H
3
C:\bin\ERUNT\AUTOBACK.EXE
D:\Install\\_\_Backups\RegBackup-ERUNT\#Date#-#Time#
C:\bin\ERUNT\
```
В общем, автор утилиты занимается этим вопросом с 2001 года и свое дело знает — очень рекомендую к применению! | https://habr.com/ru/post/142558/ | null | ru | null |
# Эта база данных в огне…
Позвольте мне рассказать техническую историю.
Много лет назад я разрабатывал приложение со встроенными в него функциями совместной работы. Это был удобный экспериментальный стек, в котором использовался полный потенциал раннего React и CouchDB. Он в реальном времени синхронизировал данные по JSON [OT](https://en.wikipedia.org/wiki/Operational_transformation). Его использовали во внутренней работе компании, однако широкая применимость и потенциал в других сферах были очевидными.
Пытаясь продать потенциальным клиентам эту технологию, мы столкнулись с неожиданным препятствием. В демонстрационном видео наша технология выглядела и работала отлично, тут никаких проблем. Видео показывало именно то, как оно работает, и в нём ничего не имитировалось. Мы придумали и закодировали реалистичный сценарий применения программы.
На самом деле это и стало проблемой. Наше демо работало именно так, как имитировали работу своих приложений все остальные. Если конкретно, то информация мгновенно передавалась от А к Б, даже если это большие медиафайлы. После входа в систему каждый пользователь видел новые записи. При помощи приложения разные пользователи могли совместно работать чётко над одними и теми же проектами, даже в случае прерывающегося Интернет-подключения где-нибудь в деревне. В неявной форме подобное подразумевается в любом нарезанном в After Effects видео о продукте.
Несмотря на то, что все знали, для чего нужна кнопка Refresh, никто совершенно не понимал, что веб-приложения, которые они просят нас создавать, обычно подвержены своим ограничениям. И что если они больше не понадобятся, то опыт пользователя будет совершенно иным. В основном они замечали, что можно «чатиться», оставляя собеседникам заметки, поэтому задавались вопросом, чем это отличается, например от Slack. Уф-ф-ф!
Дизайн повседневных синхронизаций
---------------------------------
Если у вас уже есть опыт разработки ПО, то вам должна действовать на нервы необходимость помнить, что большинство людей не может просто взглянуть на изображение интерфейса и понять, что он будет делать при взаимодействии с ним. Не говоря уже о том, что происходит внутри самой программы. Знание о том, что *может* произойти — во многом результат знания того, что не может произойти и что не должно происходить. Для этого требуется [ментальная модель](https://uxdesign.cc/design-of-everyday-things-chapter-01-summary-and-keypoints-664d426a11e0) не только того, что делает ПО, но и того, как согласованы и общаются между собой отдельные его части.
Классическим примером этого является пользователь, в течение двадцати минут смотрящий на *spinner.gif*, гадая, когда же наконец завершится работа. Разработчик бы понял, что процесс, вероятно, завис, и что gif никогда не пропадёт с экрана. Эта анимация имитирует выполнение работы, но не связана с её состоянием. В подобных случаях некоторые технари любят закатывать глаза, поражаясь степени заблуждения пользователей. Однако заметьте, кто из них указывает на вращающиеся часы и говорит, что они на самом деле стоят неподвижно?
В этом и состоит суть ценности реального времени. В наши дни базы данных реального времени по-прежнему используются крайне мало, и многие относятся к ним с подозрением. Большинство таких баз данных активно склоняется к стилю NoSQL, из-за чего обычно используют решения на основе Mongo, о которых лучше забыть. Однако для меня это означает комфорт работы с CouchDB, а также изучение проектирования структур, которые будет способен заполнять данными не только какой-нибудь бюрократ. Думаю, что я трачу своё время оптимальнее.
Но настоящая тема этого поста — то, что я использую сегодня. Не по своему выбору, а из-за равнодушно и слепо применяемой корпоративной политики. Поэтому я приведу Совершенно Честное и Беспристрастное сравнение двух тесно связанных продуктов для работы с базами данных реального времени Google.
В названиях обоих есть слово Fire. Одно я вспоминаю с нежностью. Второе для меня — другой вид огня. Я не тороплюсь говорить их названия, потому что как только я это сделаю, мы столкнёмся с первой большой проблемой — именами.
Первый называется *Firebase Real-Time Database*, а второй — *Firebase Cloud Firestore*. Оба они являются продуктами из *Firebase suite* Google. Их API называются, соответственно, `firebase.database(…)` и `firebase.firestore(…)`.
Так получилось потому, что *Real-Time Database* — это просто исходный *Firebase* до его покупки Google в 2014 году. Затем в Google решили в качестве параллельного продукта создать *копию* Firebase на основе big data компании, и назвали её Firestore with a cloud. Надеюсь, вы ещё не запутались. Если всё-таки запутались, не волнуйтесь, я сам переписывал эту часть статьи десять раз.
Потому что нужно указывать *Firebase* в вопросе о Firebase, и *Firestore* в вопросе о Firebase, по крайней мере, чтобы вас поняли несколько лет назад на Stack Overflow.
Если бы существовала награда за самый худший нейминг программных продуктов, то этот случай определённо стал бы одним из претендентов. Расстояние Хэмминга между этими названиями настолько мало, что запутывает даже опытных инженеров, чьи пальцы печатают одно название, хотя голова думает о другом. Это с треском провалившиеся планы, придуманные с самыми благими намерениями; они исполнили пророчество о том, что база данных будет в огне. И я ничуть не шучу. Человек, придумавший такую схему наименований, стал причиной крови, пота и слёз.
Пиррова победа
--------------
Можно было бы подумать, что Firestore — это *замена* Firebase, его потомок следующего поколения, но это было бы заблуждением. Firestore гарантированно не подходит на роль замены Firebase. Похоже, кто-то вырезал из него всё интересное, а большую часть оставшегося запутал разными способами.
Однако беглый взгляд на два продукта может сбить вас с толку: кажется, что они делают одно и тоже, через в основном одинаковые API и даже в одной и той же сессии баз данных. Различия малозаметны и обнаруживаются только при тщательном сравнительном изучении пространной документации. Или когда пытаешься портировать идеально работающий на Firebase код, чтобы он работал с Firestore. Уже тогда ты выясняешь, что интерфейс базы данных загорается, как только пытаешься выполнить перетаскивание мышью в реальном времени. Повторюсь, я не шучу.
Клиент Firebase вежлив в том смысле, что он буферизует изменения и выполняет автоматический повтор попыток обновления, при которых приоритет отдаётся последней операции записи. Однако Firestore имеет ограничение в 1 операцию записи на документ на пользователя в секунду, и это ограничение налагается сервером. При работе с ним вы сами должны найти способ обойти его и реализовать ограничитель частоты обновлений, даже когда вы просто пытаетесь создать своё приложение. То есть Firestore — это база данных реального времени без клиента реального времени, которая маскируется под него с помощью API.
На этом мы начинаем видеть первые признаки смысла существования Firestore. Возможно, я ошибаюсь, но подозреваю, что кто-то высоко в руководстве Google посмотрел после покупки на Firebase и просто сказал: «Нет, боже мой, нет. Это неприемлемо. Только не под моим руководством».
Он явился из своих покоев и провозгласил:
*«Один большой документ JSON? Нет. Вы разделите данные на отдельные документы, каждый из которых будет размером не более 1 мегабайта».*
Похоже, что такое ограничение не переживёт первого столкновения с любой достаточно мотивированной базой пользователей. Вы знаете, что это так. У нас на работе, например, есть полторы с лишним тысяч презентаций, и это Совершенно Нормально.
При таком ограничении вы будете вынуждены смириться с тем фактом, что один «документ» в базе данных не будет похож ни на один объект, который пользователь мог бы назвать документом.
*«Массивы массивов, которые могут рекурсивно содержать другие элементы? Нет. Массивы будут содержать только объекты или числа фиксированной длины, как задумано Господом».*
Поэтому если вы надеялись поместить в свою Firestore GeoJSON, то обнаружите, что это невозможно. Недопустимо ничего неодномерного. Надеюсь, вы любите Base64 и/или JSON внутри JSON.
*«Импорт и экспорт JSON по HTTP, инструменты командной строки или панель администратора? Нет. Вы сможете только экспортировать и импортировать данные в Google Cloud Storage. Так, кажется, оно сейчас называется. И когда я говорю „вы“, то обращаюсь только к тем, кто имеет полномочия Project Owner. Все остальные могут пойти и создать тикеты.»*
Как видите, модель данных FireBase описать легко. Она содержит один огромный документ JSON, связывающий ключи JSON с путями URL. Если вы запишете при помощи `HTTP PUT` в `/` FireBase следующее:
```
{
"hello": "world"
}
```
То `GET /hello` вернёт `"world"`. В основном это работает именно так, как вы ожидаете. Коллекция объектов FireBase `/my-collection/:id` эквивалентна словарю JSON `{"my-collection": {...}}` в корне, содержимое которого доступно в `/my-collection`:
```
{
"id1": {...object},
"id2": {...object},
"id3": {...object},
// ...
}
```
Это работает отлично, если каждая вставка имеет ID без коллизий, для чего в системе есть стандартное решение.
Другими словами, база данных на 100% совместима с JSON (\*) и отлично работает с HTTP, например, с CouchDB. Но в основном вы используете её через API реального времени, который абстрагирует websockets, авторизацию и подписки. Панель администратора имеет обе возможности, позволяя и выполнять редактирование в реальном времени, и импорт/экспорт JSON. Если в своём коде вы будете придерживаться того же, то удивитесь, какой объём специализированного кода пропадёт, когда вы поймёте, что patch и diff JSON позволяют решить 90% рутинных задач по обработке постоянного состояния.
Модель данных Firestore похожа на JSON, но отличается от него в некоторых критически важных аспектах. Я уже упоминал отсутствие массивов внутри массивов. Модель sub-collections заключается в том, чтобы они были концепциями первого класса, отдельными от содержащего их документа JSON. Поскольку для этого не существует готовой сериализации, для получения и записи данных требуется специализированный путь выполнения кода. Для обработки собственных коллекций необходимо писать свои скрипты и инструменты. Панель администратора позволяет вам вносить только небольшие изменения по одному полю за раз, и не имеет возможностей импорта/экспорта.
Они взяли базу данных NoSQL реального времени и превратили её в медленную не-SQL с автообъединением и отдельным столбцом не-JSON. *Что-то в духе GraftQL*.
Горячий Java
------------
Если Firestore должен был стать более надёжным и масштабируемым, то ирония в том, что среднестатистический разработчик получит менее надёжное решение, чем при выборе FireBase «из коробки». То ПО, которое необходимо Ворчливому Администратору Базы Данных, требует такого уровня усилий и калибра специалистов, что это просто нереалистично для ниши, в которой, предположительно, должен быть хорош продукт. Это похоже на то, как HTML5 Canvas совсем не является заменой Flash, если нет инструментов разработки и проигрывателя. Более того, Firestore погрязла в стремлении к чистоте данных и стерильной валидации, что просто не соответствует тому, как средний бизнес-пользователь *любит работать*: для него всё необязательно, потому что до самого конца всё является черновиком.
Основной недостаток FireBase в том, что клиент был создан на несколько лет раньше своего срока, ещё до того, как большинство веб-разработчиков узнало об иммутабельности. Из-за этого FireBase предполагает, что вы будете изменять данные, а потому не использует преимущества обеспечиваемой пользователем иммутабельности. Кроме того, он не использует данные повторно в передаваемых пользователю снэпшотах, из-за чего выполнять diff намного сложнее. Для крупных документов его механизм транзакций на основе изменяемых diff просто неадекватен. Ребята, у нас ведь уже есть `WeakMap` в JavaScript. Это удобно.
Если придать данным нужную форму, и не делать деревья слишком объёмными, то эту проблему можно обойти. Но мне любопытно, стал бы FireBase гораздо интереснее, если бы разработчики выпустили по-настоящему хороший клиентский API, использующий иммутабельность в сочетании с серьёзным практическим советом по структуре баз данных. Вместо этого они, похоже, попытались починить то, что не сломано, и от этого стало хуже.
Я не знаю всей логики, лежавшей в основе создания Firestore. Рассуждения о мотивах, возникающих внутри чёрного ящика — это тоже часть развлечения. Такое противопоставление двух чрезвычайно похожих, но несравнимых баз данных встречается довольно редко. Как будто кто-то подумал: *«Firebase — это просто функция, которую мы можем эмулировать в Google Cloud»*, но при этом ещё не открыл для себя концепцию определения требований реального мира или создания полезных решений, удовлетворяющих всем этим требованиям. *«Пусть об этом думают разработчики. Просто сделайте UI красивым… А можно добавить больше огня?»*
Я понимаю пару вещей о структурах данных. Я точно вижу, что концепция «всё в одном большом дереве JSON» — это попытка абстрагировать из базы данных любое ощущение крупномасштабной структуры. Ожидать, что ПО просто справится с любым сомнительным фракталом структуры данных — это просто безумие. Мне не нужно даже представлять, насколько плохо всё может быть, я проводил жёсткие аудиты кода и *видел такое, что вам, людям, и не снилось*. Но я также знаю, как выглядят хорошие структуры, [как их использовать](https://acko.net/blog/apis-are-about-policy) и [почему это нужно делать](https://acko.net/blog/software-development-as-advanced-damage-control/). Я могу представить мир, в котором Firestore казалась бы вполне логичной, а создавшие её люди считали бы, что проделали хорошую работу. Но мы живём не в этом мире.
Поддержка построения запросов в FireBase плоха по любым стандартам, её практически не существует. Она определённо требует улучшения или хотя бы пересмотра. Но Firestore ненамного лучше, поскольку она ограничена теми же одномерными индексами, которые есть в простой SQL. Если вам нужны запросы, которые люди выполняют с хаотичными данными, то требуется полнотекстовый поиск, фильтры на несколько диапазонов и произвольный задаваемый пользователем порядок. При внимательном изучении функции простого SQL сами по себе слишком ограничены. Кроме того, единственные SQL-запросы, которые люди могут выполнять в продакшене — это быстрые запросы. Вам понадобится специализированное решение для индексирования с продуманными структурами данных. Для всего остального, по крайней мере, должно быть инкрементное map-reduce или что-то подобное.
Если вы поищите информацию об этом в документах Google, то вам, надеюсь, укажут в направлении чего-то типа BigTable и BigQuery. Однако все эти решения сопровождаются таким объёмом густого жаргона корпоративных продаж, что вы быстро вернётесь назад и начнёте искать что-то другое.
Последнее, что вам нужно в случае базы данных реального времени — это нечто созданное людьми и для людей, работающих по шкале окладов для руководства.
*(\*) Это шутка, нет такого понятия, как [совместимость с JSON на 100%](http://seriot.ch/parsing_json.php).*
---
#### На правах рекламы
Подыскиваете [VDS](https://vdsina.ru/cloud-servers?partner=habr130) для отладки проектов, сервер для разработки и размещения? Вы точно наш клиент :) Посуточная тарификация серверов самых различных конфигураций, антиDDoS и лицензии Windows уже включены в стоимость.
[](https://vdsina.ru/cloud-servers?partner=habr130) | https://habr.com/ru/post/522672/ | null | ru | null |
# Проверка проекта Microsoft Orleans с помощью PVS-Studio
Введение
--------
Всем доброго времени суток.
Вначале маленький Disclaimer для сомневающихся: да, за этот пост я, возможно, получу лицензию на PVS-Studio для проверки открытого проекта Microsoft Orleans. А может и не получу, как фишка ляжет-с. Нет, с компанией "СиПроВер" я напрямую никак не связан и написал этот пост по своей инициативе.
А теперь перейдем к сути.
[PVS-Studio 6.0](http://www.viva64.com/ru/pvs-studio/), как заявляет официальный сайт компании, это статический анализатор кода, ориентированный на простоту использования и поиск ошибок на этапе написания кода.
И относительно недавно, компания зарелизила версию, поддерживающую проверку C# проектов. Чем мы собственно и будем проверять проект Microsoft Orleans.
Кстати, команда PVS-Studio тоже проверяла проект Orleans на предмет выявленных ошибок, но я их немного опередил и они любезно предоставили мне свою КДПВ ("картинку для привлечения внимания") с неизменно радующим единорогом.
---
Что такое проект Orleans, Виртуальные актеры и в чем их профит.
---------------------------------------------------------------
[Microsoft Orleans](https://github.com/dotnet/orleans) это framework, который построен на концепции виртуальных актеров. Терминология Orleans немного отличается от других подобных фреймворков (Akka.Net, Service Fabric, Erlang Actors): Актеры называются **Grains** (ака зерна), а сервера, участвующие в кластере — **Silo**.
Преимущество виртуальных актеров в том, что в любой момент ваш код может получить у Orleans Runtime прокси для обращения к конкретному Grain по его интерфейсу и Id. При вызове методов прокси посылается сообщение кластеру из нескольких серверов, где оно будет доставленому Grain-у с заданным Id. Runtime гарантирует, что такой Grain будет создан в единственном экземпляре на одном из серверов и последующие вызовы будут доставлены ему. Runtime также автоматически удаляет из памяти (деактивирует) Grain-ы, которые не получали вызовов заданное время, таким образом постоянно собирая "мусор". Если сервер на котором находилось ранее ваше "зерно", ушел в оффлайн — Runtime быстро поднимет инстанс на другом и вы ничего не заметите, кроме небольшой задержки. Если вызов должен прийти на тот же самый сервер — Runtime это оптимизирует и вызов будет локальным.
Собственно, профит виртуальных актеров в том, что это все очень легко масштабируется в облаках:
Silo пингуют друг друга и определяют когда кто-то недоступен, перераспределяют зерна "павшего камрада" между собой и все такое. Кластер радостно живет и доступен, пока есть хотя бы одно активное Silo, и при подключении новых участников — они получат свой диапазон "зерен" и начнут активно обрабатывать запросы. А свой код вы пишите, используя привычный ООП-подход. Получается такой, как бы "Distributed C#/.NET".
Еще сам рантайм дает гарантии что при выполнении метода на зерне, никакой другой вызов не на то же самое зерно не прийдет, т.е. рантайм гарантирует single-threaded выполнение вашего кода, что позволяет меньше думать о всяких не-thread-safe ситуациях и больше сосредоточиться на написании полезной бизнес-логики.
Вообще, там еще много других интересных вещей, таких как заменяемые провайдеры хранилища, messaging, pub-sub и другие полезные вещи для разработки приложений под облачные (или распределенные on-prem) платформы.
Подробней с проектом можно ознакомиться здесь — [Microsoft Orleans@GitHub](http://dotnet.github.io/orleans/). Microsoft Orleans неплохо протестирован и в масштабных проектах — этот фреймворк используется на бакенде игр Halo 4 и Halo 5 — собирает информацию о всех играх, аггрегирует статистику и т.д.
---
Почему захотелось проверить Orleans
-----------------------------------
Ну во-первых, мы сами используем Orleans для создания нашей облачной платформы в Drawboard и хочется полагаться на удобный и надежный фреймворк.
Во-вторых, концепции и гарантии, заложенные в Orleans, довольно нетривиальны и от их реализации зависит качество работы кластера.
В-третьих — было просто интересно попробовать PVS-Studio с С# — команда продукта пишет отличные статьи про проверку С++ проектов, а вот C# был как-то обделен вниманием до последнего времени.
---
Результаты проверки
-------------------
Проект Microsoft Orleans развивается очень динамично и, очевидно, разовая проверка хоть и поможет найти сомнительные места — в длинной перспективе на общее качество повлияет не сильно.
Итак, по состоянию на момент мержа PR #1288 `4/02/2016 2:43:26 PM, Commit hash: 7c1e35466fde08fcf1c2caf64fa304d25e60e045` PVS-Studio (версия 6.01.15638.1) выдала:
* 18 High-severity предупреждений
* 7 Medium-severity предупреждений
* 58 Low-severity предупреждений
Трудно сказать хорошо это или плохо, потому как это нельзя сравнивать с другими проектами, проверенными PVS-Studio — разная сложность, количество кода, компетентность разработчиков и множество других факторов.
Но в целом — выглядит не самым худшим результатом, количество подозрительных мест не выражается трех или четырехзначным числом — все просмотреть и обработать можно за день.
Посмотрим, найдет ли PVS-Studio что-то серьезное.
И еще — вот таблица, которая показывает разделение ошибок между основным кодом (Runtime и вспомогательные проекты) и кодом в тестах:
| Severity | Total | Runtime | Tests |
| --- | --- | --- | --- |
| High | 18 | 12 `*` | 6 |
| Medium | 7 | 4 | 3 |
| Low | 58 | 13 | 45 |
`*` — 4 предупреждения на неправильное использование Replace в одном методе, 3 предупреждения в малоиспользуемом коде. Итого ~5 на которые стоит обратить внимание.
Я пройдусь, в основном, по ошибкам в Runtime, т.к. ошибки в тестах обычно менее критичны. Хотя они могут создать иллюзию, что все ОК, но на самом деле в реальности все будет не так радужно ...
### Критичные предупреждения, обнаруженные в проекте
Начнем с самой интересной и оказавшейся довольно серьезной. Разработчики проекта, оказывается, тоже столкнулись с проблемой, восходящей корнями к этому багу
> (это из Gitter-чата проекта о найденной проблеме):
>
> ...an embarrassing bug in SanitizeTableProperty that IIRC puzzled us recently.
>
> ...were sure the sanitization worked.
PVS-Studio выдала вот такое предупреждение:
> **V3010 The return value of function 'Replace' is required to be utilized. AzureStorageUtils.cs 278,279,280,281**
И по указанном адресу находился *(баг уже исправлен)* метод:
```
public static string SanitizeTableProperty(string key)
{
// Remove any characters that can't be used in Azure PartitionKey or RowKey values
key.Replace('/', '_'); // Forward slash
key.Replace('\\', '_'); // Backslash
key.Replace('#', '_'); // Pound sign
key.Replace('?', '_'); // Question mark
if (key.Length >= 1024)
throw new ArgumentException(string.Format("Key length {0} is too long to be an Azure table key. Key={1}", key.Length, key));
return key;
}
```
Довольно классный баг, прямо snake oil *(… и тут медленно пришло прозрение что этот баг скорей всего вылезал и в нашем коде пару раз....)*.
Параметр key типа string, к тому же передается в метод. Строки в .NET immutable, так что сколько бы раз мы не вызывали `key.Replace` — значение не изменится.
Следующая неплохая находка -
> **V3006 The object was created but it is not being used. The 'throw' keyword could be missing: throw new InconsistentStateException(FOO). MemoryStorageGrain.cs 129**
```
if (currentETag != null)
{
string error = string.Format("Etag mismatch during {0} for grain {1}: Expected = {2} Received = null", operation, grainStoreKey, currentETag.ToString());
logger.Warn(0, error);
new InconsistentStateException(error);
}
```
Новое исключение создается, но не выбрасывается. Т.е. если при записи присылается Etag=null и это первая запись, ошибки не происходит. Чуть ниже в том же методе другое исключение все же выбрасывается — т.е. у нас тут пропущенная проблема.
Еще одно предупреждение:
> **V3005 The 'jsonSettings' variable is assigned to itself. AzureTableStorage.cs 104**
При чтении конфигурации настройки сериализации в переменной jsonSettings инициализируются 2 раза:
```
if (useJsonFormat)
{
jsonSettings = jsonSettings = OrleansJsonSerializer.SerializerSettings;
}
```
Не сильно критичная проблема, по мне так выглядит как результат рефакторинга — в "прошлой жизни" одна из этих переменных скорей всего называлась по-другому. Потом отдельную переменную для дефолтных настроек убрали, а присвоение осталось.
Следующее (false alarm в нашем случае):
> \*\*V3022 Expression 'USE\_DEBUG\_CONTEXT\_PARAMS && arguments != null && arguments.Length > 0' is always false. GrainReference.cs 480\*\*\*
```
[NonSerialized] private const bool USE_DEBUG_CONTEXT_PARAMS = false;
...
if (USE_DEBUG_CONTEXT_PARAMS && arguments != null && arguments.Length > 0)
{
...
}
```
Отладочный флаг, компилятор оптимизирует эту ветку if. Не очень критично, из контекста понятно что произойдет. Но проверять такие места все же полезно — чтобы убедиться что важный и нужный код не будет "с-оптимизирован".
Это предупреждение найдено в малоиспользуемом коде, поэтому этот участок не вызывал особых проблем, но мог бы:
> **V3025 Incorrect format. A different number of format items is expected while calling 'Format' function. Expected: 3. Present: 2. Program.cs 169,183**
```
WriteStatus(string.Format("**Calling DeleteGrain({0}, {1}, {2})", silo, grainId));
WriteStatus(string.Format("**Calling LookupGrain({0}, {1}, {2})", silo, grainId));
```
Может показаться, что это не такая уж и существенная ошибка, ну логгер, ну что-то не запишет. Но нет. На самом деле тут вылетит —
`FormatException: Index (zero based) must be greater than or equal to zero and less than the size of the argument list.`
А следующее предупреждение может сигнализировать о реальных проблемах в логике кода, в Orleans это, к счастью, только логгирование -
> **V3033 It is possible that this 'else' branch must apply to the previous 'if' statement. Interner.cs 251**
```
private void InternCacheCleanupTimerCallback(object state)
{
...
long numRemoved = numEntries - internCache.Count;
if (numRemoved>0)
if (logger.IsVerbose) logger.Verbose(ErrorCode.Runtime_Error_100296, "Removed {0} / {1} unused {2} entries in {3}", numRemoved, numEntries, internCacheName, clock.Elapsed);
else
if (logger.IsVerbose2) logger.Verbose2(ErrorCode.Runtime_Error_100296, "Removed {0} / {1} unused {2} entries in {3}", numRemoved, numEntries, internCacheName, clock.Elapsed);
}
```
Это стилистически сложно оформленный код — не очень понятно, что хотели сделать. Разобраться конечно можно, но такой стиль не только ломает глаза читающему код, но и открывает возможности для всяких неприятных багов, подобных сюрпризу от Apple.
> Apple certificate check bug:
>
> if ((err = SSLHashSHA1.update(&hashCtx, &serverRandom)) != 0)
>
> goto fail;
>
> if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0)
>
> goto fail;
>
> goto fail;
Для того чтобы такие вещи не появлялись — есть StyleCop и много других методов "принуждения к правильному стилю". И их тоже полезно использовать.
Еще одно предупреждение, тоже незначительное в данном случае, просто избыточная проверка. Но если проверка вычислительно "дорогая" — стоит от нее избавиться.
> **V3053 An excessive expression. Examine the substrings '/bootstrap' and '/boot'. ClientGenerator.cs 310**
```
else if (arg.StartsWith("/bootstrap") || arg.StartsWith("/boot")){...}
```
На этом критические ошибки, которые достойны внимания, заканчиваются и впереди еще немного `Medium` и побольше `Low`.
### Найденные ошибки средней тяжести
Первым идет пример предупреждения, который, может быть как сигналом проблемы, так и поводом для холивара.
> **V3054 Potentially unsafe double-checked locking. Use volatile variable(s) or synchronization primitives to avoid this. StreamImpl.cs 142, 144**
Пример кода немного порезан, оставлены только основные участки с некоторыми комментариями.
```
private readonly object initLock; // need the lock since the same code runs in the provider on the
...
internal IAsyncBatchObserver GetProducerInterface()
{
->> // not so сanonical double-checked locking, effectively doing the same,
if (producerInterface != null) return producerInterface;
lock (initLock)
{
if (producerInterface != null)
return producerInterface;
if (provider == null)
provider = GetStreamProvider();
producerInterface = provider.GetProducerInterface(this);
}
return producerInterface;
}
internal IInternalAsyncObservable GetConsumerInterface()
{
->> // Canonical double-checked locking
if (consumerInterface == null)
{
lock (initLock)
{
if (consumerInterface == null)
{
if (provider == null)
provider = GetStreamProvider();
consumerInterface = provider.GetConsumerInterface(this);
}
}
}
return consumerInterface;
}
```
Тут у нас два примера применения [Double-checked locking](https://en.wikipedia.org/wiki/Double-checked_locking) паттерна. *Чак Норрис мира .NET* (aka Jon Skeet) в статье [Implementing the Singleton Pattern in C#](http://csharpindepth.com/Articles/General/Singleton.aspx) приводит более изящную и надежную реализацию, если нужен синглтон.
Я еще хотел написать что:
> Но вот лично у меня этот код вызывает еще одно сомнение: во всех статьях и примерах этот паттерн всегда использует `lock` на `static` объект, и вот я не очень уверен, что его можно применять на non-`static` локах с гарантированно надежным результатом…
Но, после общения с разработчиками и чтения вот этой статьи [Sayonara volatile by Joe Duffy](http://joeduffyblog.com/2010/12/04/sayonara-volatile/), соглашусь, что т.к. в нашем случае это не синглтон, допустимо использование не-статического поля. И без volatile.
Вообще, изучая эту ошибку, я открыл для себя такую "банку червей", что уже даже не знаю — проблема ли это в коде или конкретно с этой диагностикой у PVS-Studio.
Но сам факт, что инструмент может ловить такие паттерны вообще — это, имхо, здорово. И надеюсь, что в будущем мы увидим больше изощренных предупреждений, хороших и разных.
Переходим к еще одному неплохому примеру, баг, который очень плохо ловится человеком, но легко — анализатором:
> **V3022 Expression 'n1 == 0 && n1 != 0' is always false. Unsigned type value is always >= 0. Probably the '||' operator should be used here. UniqueKey.cs 113**
```
private static UniqueKey NewKey(ulong n0, ulong n1, Category category, long typeData, string keyExt)
{
// in the string representation of a key, we grab the least significant half of n1.
// therefore, if n0 is non-zero and n1 is 0, then the string representation will always be
// 0x0 and not useful for identification of the grain.
if (n1 == 0 && n1 != 0)
throw new ArgumentException("n0 cannot be zero unless n1 is non-zero.", "n0");
```
Тут надо было проверить n0!=0, как и написано в комментарии к этому коду, а в текущей реализации проверка всегда false. Опять же, хороший Coding-style мог бы помочь в данном случае — если бы переменные не назывались `n0` и `n1`, а например `firstHalf` и `secondhHalf` — ошибка бы бросалась в глаза более явно. Сравните:
```
if (firstHalf == 0 && secondHalf != 0)
vs
if (secondHalf == 0 && secondHalf != 0)
```
Предупреждение об одинаковом коде в двух разных методах —
> **V3013 It is odd that the body of 'IncrementMetric' function is fully equivalent to the body of 'DecrementMetric' function (1079, line 1095). TraceLogger.cs 1079**
Spaced Copy-Paste, между этими 2-мя методами есть еще и правильная реализация
декремента, который уменьшает метрику.
```
public override void IncrementMetric(string name, double value)
{
foreach (var tc in TelemetryConsumers.OfType())
{
->> tc.IncrementMetric(name, value);
}
}
...
public override void DecrementMetric(string name, double value)
{
foreach (var tc in TelemetryConsumers.OfType())
{
->> tc.IncrementMetric(name, value);
}
}
```
То же самое, но в тестах:
> **V3013 It is odd that the body of 'StartTimer' function is fully equivalent to the body of 'StopTimer' function (183, line 188). TimerOrleansTest.cs 183**
```
public Task StartTimer(string timerName)
{
if (persistant) return persistantGrain.StartTimer(timerName);
else return grain.StartTimer(timerName);
}
public Task StopTimer(string timerName)
{
if (persistant) return persistantGrain.StartTimer(timerName);
else return grain.StartTimer(timerName);
}
```
Этот привет от Ctrl+C, Ctrl+V в тестах может иметь и худшие последствия — тесты будут false-positive.
Сложный код в тестах может выдавать одну ошибку на 10 или 100 запусков, тогда такой тест еще и вызывает раздражение :
> **V3032 Waiting on this expression is unreliable, as compiler may optimize some of the variables. Use volatile variable(s) or synchronization primitives to avoid this. LoggerTest.cs 468**
```
// Wait until the BulkMessageInterval time interval expires before wring the final log message - should cause bulk message flush
while (stopwatch.Elapsed <= TraceLogger.BulkMessageInterval)
{
Thread.Sleep(10);
}
```
Честно говоря, я сам не очень хорошо понимаю, как и почему цикл здесь может превратиться в бесконечный, но пример в описании этого предупреждения на сайте PVS-Studio более понятный [V3032](http://www.viva64.com/en/d/0419/print/).
Не очень большая проблема, т.к. код в тестах, но даже в теории — произвольно падающие тесты или надолго зависающие — не самая приятная штука.
И опять странный код в тестах -
> **V3051 An excessive type check. The object is already of the 'Exception' type. PersistenceGrainTests.cs 178**
```
catch (AggregateException ae)
{
exceptionThrown = true;
Exception e = ae.GetBaseException();
->> if (e is Exception)
{
// Expected error
}
else
{
throw e;
}
}
```
Исключение никогда не будет выкинуто повторно, потому что в ветку `else` код никогда не попадет. Критичность зависит от контекста, в тестах может и не так страшно, а в другом коде — чистой воды бага
### Неопасные (low-severity) ошибки
Довольно много замечаний PVS-Studio обнаружила в тестах, но просмотрев большинство из них, можно сделать вывод, что критических или high-impact проблем среди них нет. Просто комплексно протестировать такой продукт довольно сложно и часто приходится идти на разные ухищрения, чтобы вызвать определенное поведение системы.
Например вот:
> **V3008 The 'promise' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 91, 84. TestInternalGrains ErrorGrain.cs 91**
```
// the grain method returns OK, but leaves some unobserved promise
-->>Task promise = Task.Factory.StartNew(() =>
{
if (!doThrow)
return 0;
logger.Info("About to throw 1.");
throw new ArgumentException("ErrorGrain left Immideate Unobserved Error 1.");
});
-->>promise = null;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
return Task.FromResult(11);
```
Проверяется поведение кода с таском, который собран GC.
Из того, на что еще стоит обратить некоторое внимание (эти ошибки могут привести к некорректным ожиданиям при тестах):
> **V3013 It is odd that the body of 'ProduceSequentialSeries' function is fully equivalent to the body of 'ProduceParallelSeries' function (618, line 625). StreamingGrain.cs 618**
```
public override async Task ProduceSequentialSeries(int count)
{
await base.ProduceParallelSeries(count);
State.Producers = _producers;
await WriteStateAsync();
}
public override async Task ProduceParallelSeries(int count)
{
await base.ProduceParallelSeries(count);
State.Producers = _producers;
await WriteStateAsync();
}
```
У специального класса для тестирования методы, предназначенные для генерации последовательных и параллельных серий событий, всегда генерируют параллельные. Может это и ОК, но тогда семантика внутри теста вводит в заблуждение.
> **V3013 It is odd that the body of 'TestInitialize' function is fully equivalent to the body of 'TestCleanup' function (44, line 52). ConfigTests.cs 44**
```
[TestInitialize]
public void TestInitialize()
{
TraceLogger.UnInitialize();
GrainClient.Uninitialize();
GrainClient.TestOnlyNoConnect = false;
}
[TestCleanup]
public void TestCleanup()
{
TraceLogger.UnInitialize();
GrainClient.Uninitialize();
GrainClient.TestOnlyNoConnect = false;
}
```
В тестах конфигурации при инициализации и при завершении зачем-то дважды проводится ДЕ-инициация примитивов.
> **V3043 The code's operational logic does not correspond with its formatting. The statement is indented to the right, but it is always executed. It is possible that curly brackets are missing. RequestContextTest.cs 87,97,111,155,181**
```
if(msg.RequestContextData != null) foreach (var kvp in msg.RequestContextData)
{
headers.Add(kvp.Key, kvp.Value);
};
```
И все-таки, я большой сторонник строгих Coding-style правил. Ну или хотя бы автоматического принуждения к стилю, путем StyleCop, Resharper или CodeFormatter. Это ничего не стоит, но позволяет не ломать глаза.
**V3052 The original exception object 'ae' was swallowed. Stack of original exception could be lost. GrainReferenceCastTests.cs 212**
```
catch (AggregateException ae)
{
Exception ex = ae.InnerException;
while (ex is AggregateException) ex = ex.InnerException;
throw ex;
}
```
Теряем стек AggregatedException. Я понимаю, что для случаев с другими исключениями это плохо, но мы в нашем проекте точно так же "раскручиваем" AggregatedException. Я бы записал это в false-positive если в catch секции именно AggregatedException.
### Оценка критичности найденых багов разработчиками проекта.
Из всех отправленных отчетов об ошибках, спустя 3 часа 5 отмечены как bug, 1 критический с `Replace` исправлен. Довольно неплохой улов для 20 минут статического анализа в автоматическом режиме.
Почему Code analysis это не очередной favour of the month.
----------------------------------------------------------
---
Проект Orleans развивается очень интенсивно, частота коммитов очень высокая, Gihub это подтверждает — [Orleans-contributors](https://github.com/dotnet/orleans/graphs/contributors). За время написания статьи, я проверил проект несколько раз, сохраняя логи анализа. В том числе разными версиями PVS Studio (6.0 и 6.01).
Вот сравнение разных логов:
| Priority | 28 Янв | 2 Фев | 4 Фев v6.01 | Comments |
| --- | --- | --- | --- | --- |
| High | 19 | 21 | 18 | За два дня -3 критичные ошибки — что хорошо. Но, например, 2 из них были аналогами V3025 описанной выше. Можно было бы даже не чекинить такой код. |
| Medium | 4 | 4 | 7 | За эти же 2 дня +3 предупреждения средней тяжести. |
| Low | 52 | 46 | 58 | И +12 новых участков неаккуратного кода. |
Как видно из таблицы, критические ошибки появляются и исчезают за очень короткое время. Куда как удобней отлавливать их в результате анализа сразу после билда, а не после часов дебага или падения продакшена — экономит время и нервы программиста. Это, конечно, банальность из серии *"Лучше быть богатым и здоровым, чем бедным и больным"*, но если еще есть программисты, которые не используют хоть какой-нибудь доступный статический анализатор кода — "You're doing it wrong" ...
В плане удобства использования — интеграция у PVS-Studio с Visual Studio 2015 довольно простая — в контекстном меню Solution Explorer на С# файле, проекте, или корневом solution есть пункт `Analyze with PVS-Studio` с хорошо заметной зеленой иконкой. Довольно легко найти. Если только в этом контекстном меню нету еще 100500 пунктов от других расширений. Было бы интересно увидеть какой-нибудь вспомогательный nuget пакет, который бы умел легко запускать анализ из командной строки, чтобы можно было открыть Package Manger Console или build.cmd и сказать `PVS-Solution` или `PVS-Project Orleans`, ну и в будущем это все как-то встроилось в xproj механизмы нового CoreCLR.
Хотя, для быстрого запуска хватает и `Ctrl+Q, PVS ... Down, Down, Down, Down, Enter` :).
Заключение
----------
---
Современные реалии разработки задают очень высокую планку в скорости развития — все стараются бежать вперед очень быстро, чтобы хотя бы оставаться на уровне конкурентов в отрасли. Естественно, что с такой скоростью развития можно что-то упустить или написать небрежно. Обширный набор тестов хорошо помогает в определении проблемных мест и регрессий, но это тоже не панацея — в тестах бывают ошибки, да и создание такого набора, как и поддержание его в актуальном состоянии требует времени и усилий.
Любой статистический анализатор, будь то предупреждения Visual Studio, анализатор Resharper'а или PVS-Studio, это еще один инструмент в коллекции разработчика и помощник при обнаружении потенциальных проблем с кодом. Используйте хотя бы то, что доступно бесплатно. Например, на всех наших проектах по умолчанию включен режим Treat Warnings as Errors, что помогает писать код чуть более дисциплинированно. Это ничего не стоит программисту, но может сберечь его от выстрелов себе в ногу. Современные анализаторы использовать очень легко, в большинстве случаев всё отлично работает "из коробки" и единственное, что может хоть как-то оправдать не-использование анализаторов, это вопрос цены.
NB: *Автор благодарит команду PVS-Studio за предоставленную временную лицензию для тестирования.*
Всем прочитавшим — Happy and bug-free programming! | https://habr.com/ru/post/276727/ | null | ru | null |
# Книга «Spring Boot 2: лучшие практики для профессионалов»
[](https://habr.com/ru/company/piter/blog/506872/)Привет, Хаброжители! Хотите повысить свою эффективность в разработке корпоративных и облачных Java-приложений?
Увеличьте скорость и простоту разработки микросервисов и сложных приложений, избавившись от забот по конфигурации Spring.
Используйте Spring Boot 2 и такие инструменты фреймворка Spring 5, как WebFlux, Security, Actuator, а также фреймворк Micrometer, предоставляющий новый способ сбора метрик.
### Фреймворк тестирования Spring
Одна из основных идей фреймворка Spring — поощрение создания разработчиками простых и слабо связанных классов, программирование интерфейсов, благодаря чему программное обеспечение становится более надежным и лучше расширяемым. Фреймворк Spring предоставляет инструменты, упрощающие модульное и интеграционное тестирование (на самом деле, если вы действительно программируете интерфейсы, для тестирования функциональности приложений Spring вам не нужен). Другими словами, необходимо, чтобы приложение можно было протестировать с помощью систем тестирования JUnit или TestNG на основе объектов (создаваемых просто с помощью оператора new — без Spring или какого-либо другого контейнера).
В фреймворк Spring включено несколько пакетов, предназначенных для модульного или интеграционного тестирования приложений. Для модульного тестирования предназначено несколько имитационных объектов (Environment, PropertySource, JNDI, Servlet; реактивные утилиты тестирования ServerHttpRequest и ServerHttpResponse), с помощью которых можно производить изоляционное тестирование кода.
Одна из чаще всего используемых возможностей тестирования в фреймворке Spring — интеграционное тестирование. Основные его задачи:
* управление кэшированием контейнера Spring IoC в промежутке между выполнениями тестов;
* управление транзакциями;
* внедрение зависимостей экземпляров тестовых объектов;
* создание предназначенных специально для Spring базовых классов.
Фреймворк Spring обеспечивает легкий способ тестирования посредством интеграции в тесты контекста приложения (ApplicationContext). Модуль тестирования Spring предлагает несколько способов использования ApplicationContext, программным образом и с помощью аннотаций.
* Аннотация BootstrapWith. Аннотация уровня класса, предназначенная для конфигурации начальной загрузки фреймворка TestContext Spring.
* Аннотация @ContextConfiguration. Определяет метаданные уровня класса, задающие способ загрузки и настройки ApplicationContext для интеграционных тестов. Это совершенно необходимая для ваших классов аннотация, поскольку именно здесь ApplicationContext загружает все определения компонентов.
* Аннотация @WebAppConfiguration. Аннотация уровня класса, указывающая, что загружаемым для интеграционного теста контекстом приложения должно быть WebApplicationContext.
* Аннотация @ActiveProfile. Аннотация уровня класса, указывающая, какой из профилей определения компонентов должен быть активным при загрузке ApplicationContext для интеграционного теста.
* Аннотация @TestPropertySource. Аннотация уровня класса, предназначенная для задания местоположений файлов свойств и встраиваемых свойств, добавляемых в набор объектов PropertySource в Environment для загружаемого для интеграционного теста ApplicationContext.
* Аннотация @DirtiesContext. Указывает, что используемый ApplicationContext был «загрязнен» во время выполнения теста (например, модифицирован или поврежден путем изменения состояния компонента-одиночки) и должен быть закрыт.
Это далеко не все аннотации, существует множество других (@TestExecutionListeners, [Commit](https://habr.com/ru/users/commit/), [Rollback](https://habr.com/ru/users/rollback/), @BeforeTransaction, @AfterTransaction, [Sql](https://habr.com/ru/users/sql/), [Sql](https://habr.com/ru/users/sql/)Group, [Sql](https://habr.com/ru/users/sql/)Config, [Timed](https://habr.com/ru/users/timed/), [Repeat](https://habr.com/ru/users/repeat/), @IfProfileValue и т. д.).
Как вы видите, существует множество вариантов тестирования с помощью фреймворка Spring. Обычно всегда используется аннотация @RunWith, связывающая воедино все элементы фреймворка тестирования. Например:
```
@RunWith(SpringRunner.class)
@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
@ActiveProfiles("dev")
@Transactional
public class ToDoRepositoryTests {
@Test
public void ToDoPersistenceTest(){
//...
}
}
```
Теперь взглянем, как следует использовать фреймворк тестирования Spring и какие возможности предоставляет Spring Boot.
### Фреймворк тестирования Spring Boot
Spring Boot использует мощь фреймворка тестирования Spring, расширяя старые и добавляя новые аннотации и возможности, благодаря которым для разработчиков тестирование значительно упрощается.
Чтобы начать применять все возможности тестирования Spring Boot, необходимо лишь добавить в приложение зависимость spring-boot-starter-test с указанием области видимости test (scope test). В сервисе Spring Initializr эта зависимость уже добавлена.
Зависимость spring-boot-starter-test обеспечивает возможность использования нескольких фреймворков тестирования, очень хорошо согласующихся с возможностями тестирования Spring Boot: JUnit, AssertJ, Hamcrest, Mockito, JSONassert и JsonPath. Конечно, существуют и другие фреймворки тестирования, отлично работающие с модулем Spring Boot Test; просто соответствующие зависимости нужно указывать вручную.
Spring Boot предоставляет аннотацию @SpringBootTest, упрощающую тестирование приложений Spring. Обычно при тестировании приложения Spring необходимо добавить несколько аннотаций для тестирования конкретной возможности или функциональности приложения, но не в Spring Boot — хотя для тестирования все равно нужно указать аннотацию @RunWith(SpringRunner.class); если этого не сделать, любые новые аннотации тестирования Spring Boot будут проигнорированы. У аннотации @SpringBootTest есть полезные для тестирования веб-приложений параметры, например RANDOM\_PORT и DEFINED\_PORT.
Следующий фрагмент кода представляет собой каркас теста Spring Boot.
```
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTests {
@Test
public void exampleTest() {
...
}
}
```
### Тестирование конечных точек веб-приложения
Spring Boot предоставляет удобный способ тестирования конечных точек: имитационную среду под названием класс MockMvc:
```
@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class MockMvcToDoTests {
@Autowired
private MockMvc mvc;
@Test
public void toDoTest() throws Exception {
this.mvc
.perform(get("/todo"))
.andExpect(status().isOk())
.andExpect(content()
.contentType(MediaType.APPLICATION_JSON_UTF8));
}
}
```
Можно также воспользоваться классом TestRestTemplate.
```
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ToDoSimpleRestTemplateTests {
@Autowired
private TestRestTemplate restTemplate;
@Test
public void toDoTest() {
String body = this.restTemplate.getForObject("/todo", String.class);
assertThat(body).contains("Read a Book");
}
}
```
В этом коде показан тест, запускающий полноценный сервер и использующий экземпляр класса TestRestTemplate для обращения к конечной точке /todo. Здесь мы предполагаем, что возвращается объект String (это не лучший способ тестирования возврата JSON; не волнуйтесь, далее мы покажем, как использовать класс TestRestTemplate правильно).
### Имитация компонент
Модуль тестирования Spring Boot предоставляет аннотацию @MockBean, описывающую имитационный объект Mockito для компонента в ApplicationContext. Другими словами, можно создать имитацию нового компонента Spring или заменить уже существующее определение, добавив эту аннотацию. Помните: все это происходит внутри ApplicationContext.
```
@RunWith(SpringRunner.class)
@SpringBootTest
public class ToDoSimpleMockBeanTests {
@MockBean
private ToDoRepository repository;
@Test
public void toDoTest() {
given(this.repository.findById("my-id"))
.Return(new ToDo("Read a Book"));
assertThat(
this.repository.findById("my-id").getDescription())
.isEqualTo("Read a Book");
}
}
```
### Тестовые срезы Spring Boot
Одна из важнейших возможностей Spring Boot — выполнение тестов без необходимости в какой-то определенной инфраструктуре. Модуль тестирования Spring Boot включает так называемые срезы (slices), предназначенные для тестирования конкретных частей приложения без использования сервера или СУБД.
### Аннотация @JsonTest
В модуле тестирования Spring Boot есть аннотация @JsonTest, упрощающая сериализацию/десериализацию JSON-объектов и проверяющая, все ли работает корректно. @JsonTest автоматически настраивает поддерживаемое средство JSON-отображения, в зависимости от найденной по пути к классам библиотеки: Jackson, GSON или JSONB.
```
@RunWith(SpringRunner.class)
@JsonTest
public class ToDoJsonTests {
@Autowired
private JacksonTester json;
@Test
public void toDoSerializeTest() throws Exception {
ToDo toDo = new ToDo("Read a Book");
assertThat(this.json.write(toDo))
.isEqualToJson("todo.json");
assertThat(this.json.write(toDo))
.hasJsonPathStringValue("@.description");
assertThat(this.json.write(toDo))
.extractingJsonPathStringValue("@.description")
.isEqualTo("Read a Book");
}
@Test
public void toDoDeserializeTest() throws Exception {
String content = "{\"description\":\"Read a Book\",\"completed\":
true }";
assertThat(this.json.parse(content))
.isEqualTo(new ToDo("Read a Book", true));
assertThat(
this.json.parseObject(content).getDescription())
.isEqualTo("Read a Book");
}
}
```
Для тестирования контроллеров без использования полноценного сервера можно воспользоваться предлагаемой Spring Boot аннотацией @WebMvcTest, которая автоматически настраивает инфраструктуру Spring MVC и ограничивает список просматриваемых компонентов следующими: [Controller](https://habr.com/ru/users/controller/), [Controller](https://habr.com/ru/users/controller/)Advice, @JsonComponent, Converter, GenericConverter, Filter, WebMvcConfigurer и HandlerMethodArgumentResolver; благодаря этому вы будете знать, так ли работают ваши контроллеры, как ожидалось.
Важно понимать, что помеченные как [Component](https://habr.com/ru/users/component/) компоненты не просматриваются при использовании этой аннотации, но при необходимости можно применить аннотацию @MockBean.
```
@RunWith(SpringRunner.class)
@WebMvcTest(ToDoController.class)
public class ToDoWebMvcTest {
@Autowired
private MockMvc mvc;
@MockBean
private ToDoRepository toDoRepository;
@Test
public void toDoControllerTest() throws Exception {
given(this.toDoRepository.findById("my-id"))
.Return(new ToDo("Do Homework", true));
this.mvc.perform(get("/todo/my-id").accept(MediaType.APPLICATION_
JSON_UTF8))
.andExpect(status().isOk()).andExpect(content().
string("{\"id\":\"my-id\",\"description\":\"Do Homework\",
\"completed\":true}"));
}
}
```
### Аннотация @WebFluxTest
Для реактивных контроллеров Spring Boot предоставляет аннотацию @WebFluxTest. Эта аннотация автоматически настраивает инфраструктуру модуля Spring WebFlux и ищет только [Controller](https://habr.com/ru/users/controller/), [Controller](https://habr.com/ru/users/controller/)Advice, @JsonComponent, Converter, GenericConverter и WebFluxConfigurer.
Важно понимать, что помеченные как [Component](https://habr.com/ru/users/component/) компоненты не просматриваются при использовании этой аннотации, но при необходимости вы можете применить аннотацию @MockBean.
```
@RunWith(SpringRunner.class)
@WebFluxTest(ToDoFluxController.class)
public class ToDoWebFluxTest {
@Autowired
private WebTestClient webClient;
@MockBean
private ToDoRepository toDoRepository;
@Test
public void testExample() throws Exception {
given(this.toDoRepository.findAll())
.Return(Arrays.asList(new ToDo("Read a Book"), new
ToDo("Buy Milk")));
this.webClient.get().uri("/todo-flux").accept(MediaType.
APPLICATION_JSON_UTF8)
.exchange()
.expectStatus().isOk()
.expectBody(List.class);
}
}
```
### Аннотация @DataJpaTest
Для тестирования JPA-приложений модуль тестирования Spring Boot предоставляет аннотацию @DataJpaTest, производящую автоконфигурацию встроенных баз данных, размещаемых в оперативной памяти. Она ищет [Entity](https://habr.com/ru/users/entity/) и не загружает никаких компонентов [Component](https://habr.com/ru/users/component/). Кроме того, она предоставляет вспомогательный класс TestEntityManager, ориентированный на тестирование, очень похожий на класс JPA EntityManager.
```
@RunWith(SpringRunner.class)
@DataJpaTest
public class TodoDataJpaTests {
@Autowired
private TestEntityManager entityManager;
@Autowired
private ToDoRepository repository;
@Test
public void toDoDataTest() throws Exception {
this.entityManager.persist(new ToDo("Read a Book"));
Iterable toDos = this.repository.
findByDescriptionContains("Read a Book");
assertThat(toDos.iterator().next()).toString().contains("Read a Book");
}
}
```
Учтите, что при тестировании с помощью @DataJpaTest используются встроенные СУБД в оперативной памяти. Для тестирования же с настоящей базой данных необходимо снабдить класс теста аннотацией @AutoConfigureTestDatabase(replace=Replace.NONE).
```
@RunWith(SpringRunner.class)
@DataJpaTest
@AutoConfigureTestDatabase(replace=Replace.NONE)
public class TodoDataJpaTests {
//...
}
```
### Аннотация @JdbcTest
Эта аннотация очень похожа на @DataJpaTest; единственное отличие — она выполняет ориентированные исключительно на JDBC тесты. Она производит автоматическую настройку встроенной СУБД, размещаемой в оперативной памяти, и класса JdbcTemplate, пропуская при этом все снабженные аннотацией [Component](https://habr.com/ru/users/component/) классы.
```
@RunWith(SpringRunner.class)
@JdbcTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public class TodoJdbcTests {
@Autowired
private NamedParameterJdbcTemplate jdbcTemplate;
private CommonRepository repository;
@Test
public void toDoJdbcTest() {
ToDo toDo = new ToDo("Read a Book");
this.repository = new ToDoRepository(jdbcTemplate);
this.repository.save(toDo);
ToDo result = this.repository.findById(toDo.getId());
assertThat(result.getId()).isEqualTo(toDo.getId());
}
}
```
### Аннотация @DataMongoTest
Для тестирования приложений MongoDB модуль тестирования Spring Boot предоставляет аннотацию @DataMongoTest. Она производит автоматическую настройку встроенного размещаемого в оперативной памяти сервера Mongo, если он доступен; если же нет, необходимо добавить нужные свойства spring.data.mongodb.\*. Она также производит настройку класса MongoTemplate и ищет аннотации @Document. Компоненты [Component](https://habr.com/ru/users/component/) пропускаются.
```
@RunWith(SpringRunner.class)
@DataMongoTest
public class TodoMongoTests {
@Autowired
private MongoTemplate mongoTemplate;
@Test
public void toDoMongoTest() {
ToDo toDo = new ToDo("Read a Book");
this.mongoTemplate.save(toDo);
ToDo result = this.mongoTemplate.findById(toDo.getId(),ToDo.class);
assertThat(result.getId()).isEqualTo(toDo.getId());
}
}
```
При потребности во внешнем сервере MongoDB (невстроенном, размещаемом в оперативной памяти) добавьте в аннотацию @DataMongoTest параметр excludeAutoConfiguration = EmbeddedMongoAutoConfiguration.class.
```
@RunWith(SpringRunner.class)
@DataMongoTest(excludeAutoConfiguration = EmbeddedMongoAutoConfiguration.class)
public class ToDoMongoTests {
// ...
}
```
### Аннотация @RestClientTest
Еще одна важная аннотация — @RestClientTest, предназначенная для тестирования REST-клиентов. Эта аннотация автоматически производит настройки для поддержки Jackson, GSON и JSONB, а также настраивает класс RestTemplateBuilder и добавляет поддержку MockRestServiceServer.
```
@RunWith(SpringRunner.class)
@RestClientTest(ToDoService.class)
public class ToDoRestClientTests {
@Autowired
private ToDoService service;
@Autowired
private MockRestServiceServer server;
@Test
public void toDoRestClientTest()
throws Exception {
String content = "{\"description\":\"Read a Book\",\"completed\":
true }";
this.server.expect(requestTo("/todo/my-id"))
.andRespond(withSuccess(content,MediaType.APPLICATION_JSON_UTF8));
ToDo result = this.service.findById("my-id");
assertThat(result).isNotNull();
assertThat(result.getDescription()).contains("Read a Book");
}
}
```
Существует множество других доступных для использования срезов. Главное, запомнить: для тестирования необязательна полная инфраструктура со всеми запущенными серверами. Упростить тестирование приложений Spring Boot позволяют срезы.
### Об авторе
**Фелипе Гутьеррес** (Felipe Gutierrez) — архитектор ПО, получивший дипломы бакалавра и магистра в области вычислительной техники в Институте технологий и высшего образования города Монтеррей, Мексика. У Гутьерреса более 20 лет опыта в сфере IT, он разрабатывал программы для компаний из множества вертикально интегрированных отраслей, таких как государственное управление, розничная торговля, здравоохранение, образование и банковское дело. В настоящее время он работает в компании Pivotal, специализируясь на PAS и PKS для Cloud Foundry, фреймворке Spring, нативных облачных приложениях Spring, Groovy и RabbitMQ, помимо прочих технологий. Он также был архитектором ПО в таких крупных компаниях, как Nokia, Apple, Redbox и Qualcomm. Гутьеррес — автор книг Spring Boot Messaging (Apress, 2017) и Introducing Spring Framework (Apress, 2014).
### О научных редакторах
*Оригинальное издание*
**Мануэль Жордан Элера** (Manuel Jordan Elera) — разработчик-самоучка и исследователь, обожает изучать новые технологии для своих экспериментов и новых их сочетаний. Мануэль получил премии Springy Award Community Champion и Spring Champion 2013. Немногое имеющееся у него свободное время он посвящает чтению Библии и сочинению музыки на гитаре. Мануэль известен под интернет-псевдонимом dr\_pompeii. Он осуществлял научную редактуру многих книг, включая Pro Spring, 4-е издание (Apress, 2014)1, Practical Spring LDAP (Apress, 2013), Pro JPA 2, 2-е издание (Apress, 2013) и Pro Spring Security (Apress, 2013).
*Русскоязычное издание*
**Валерий Алексеевич Дмитрущенков** работает в IT более 35 лет. Разрабатывал программное обеспечение для множества компаний и отраслей, руководил многими комплексными проектами, включая разработку, внедрение и сопровождение автоматизированных систем. Участвовал в создании крупных проектов для государственных органов, реализованных международными организациями: ООН, USIAD, World Bank в России, Косово, Молдавии и Армении.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/spring-boot-2-luchshie-praktiki-dlya-professionalov?_gs_cttl=120&gs_direct_link=1&gsaid=82744&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544611587/978544611587_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611587/978544611587_p.pdf)
Для Хаброжителей скидка 25% по купону — **Spring Boot**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/506872/ | null | ru | null |
# Ошибка, которая сохранилась в Windows с 1974 года
Сейчас 2018 год, а это сообщение — ошибка, сохранившаяся с 1974 года. Ограничение, которое встречается даже в самой последней Windows 10, появилось ещё ДО «ЗВЁЗДНЫХ ВОЙН». Баг древний как Уотергейт.
В те времена только изобрели штрих-коды, в Америке работала лишь одна телефонная компания, Тед Банди ещё бегал на свободе, а рекорд Бейба Рута по хоум-ранам стоял последние дни.
Когда появился этот баг, по телевизору ещё не показывали «Колесо Фортуны» (российский аналог: «Поле чудес», 1990 год — прим. пер.). Никто не видел «Шоу ужасов Рокки Хоррора», а Стивен Спилберг снял несколько телефильмов и один полноэкранный фильм, провалившийся в кинопрокате (но картина «Дуэль» получила несколько кинопремий — прим. пер.). По NBC не показывали «Субботним вечером в прямом эфире», а «Эдмунд Фицджеральд» ещё перевозил железную руду (гигантский сухогруз с экипажем затонул 9 ноября 1975 года — прим. пер.).
КОГДА ИЗОБРЕЛИ ЭТУ ГЛУПУЮ «ФИЧУ», НА ЭКРАНЫ ТОЛЬКО ВЫШЛА ВТОРАЯ ЧАСТЬ «КРЁСТНОГО ОТЦА».
Так почему это произошло? В то время уже пять лет как вышел Unix с хорошей идеей «всё является файлом», что открывало дверь для множества возможностей: запись в сокеты, конвейер, консоль и прочее с теми же командами и инструкциями.
Идею реализовал Гэри Килдалл в CP/M в 1974 году. Она позволяет классные вещи, такие как копирование данных с последовательного порта в текстовый файл или печать текстового файла прямо из командной строки!
В Unix это делается через специальные файлы, существующие в специальных папках, как /dev/tty для консоли или /dev/lp0 для первого принтера. Вы можете получить бесконечный поток нулей из /dev/zero, случайные байты из /dev/random и т.д.!
Но вот проблема: CP/M предназначена для 8-битных компьютеров с небольшим объёмом памяти и без жёстких дисков. В лучшем случае у вас есть 8-дюймовый дисковод для гибких дисков. Какие директории? Они вам не понадобятся. Просто используете разные диски.
Но без директорий вы не можете поместить свои файлы в каталог /dev/. То есть они просто повсюду. Так что если вам нужно распечатать файл foo.txt, вводим команду `PIP LST:=FOO.TXT`, что копирует foo.txt в «файл» LST, который является принтером. И это работает везде, потому что нет никаких директорий! Всё просто.
Но как насчёт расширений? Тут проблема: программы любят добавлять к файлам свои расширения. Поэтому если программа говорит «Введите имя файла, чтобы сохранить листинг», есть возможность указать LST для распечатки или PTP для выбивания на перфоленте (потому что это 1974 год, помните?). Но программа может попытаться поставить .TXT в конце имени файла! LST.TXT — это же не принтер, верно?
Неа. Хак всё равно работает. Специальные устройства транслируются на все расширения, так что CON зарезервировано для клавиатуры даже в случае CON.TXT или CON.WAT, или CON.BUG.
Да уж. Это реальный хак, но он нужен только некоторым маленьким микрокомпьютерам с 4 КБ оперативной памяти, кого это волнует?
Операционка CP/M получила широкое распространение в конце 70-х и начале 80-х. Это была одна из основных ОС для бизнеса. Она определила стандартный интерфейс, так что вы могли написать код CP/M на NorthStar Horizon — и запустить его на Seequa Chameleon.
Отсутствие универсального графического стандарта не позволяло писать для него много игр (хотя есть релизы Infocom), так что стандарт использовался в основном в деловой среде.
Но рынок был большой: естественно, IBM хотела его охватить для нового проекта под названием «PC», который они делали в начале 1980 года.
IBM намеревалась выпустить IBM PC с несколькими операционными системами и ожидала, что CP/M станет «основной». Но CP/M для x86 появилась только через 6 месяцев после запуска IBM PC… и стоила $240 против $40 для DOS.
Таким образом, подавляющее большинство пользователей в конечном итоге купили Microsoft PC-DOS — новую версию операционной системы, изначально разработанную компанией Seattle Computer Products. MS купила проект Тима Патерсона и развила его в PC-DOS (который позже переименуют в MS-DOS, если вы не в курсе).
Система Тима Патерсона называлась QDOS (Quick and Dirty Operating System, «быстрая и грязная операционная система»). Её написали по-быстрому, потому что CP/M ещё не вышла под x86, и QDOS пыталась преодолеть некоторые ограничения CP/M. Эта система определённо во многих отношениях копировала CP/M.
Среди прочих была позаимствована концепция специальных файлов и отсутствие каталогов, потому что это была полезная функция CP/M. Таким образом, в QDOS и PC-DOS 1.0 тоже есть AUX, PRN, CON, LPT и т.д.!
Для PC-DOS 2.0, выпущенной в 1983 году для нового IBM XT, компания Microsoft значительно обновила PC-DOS. В IBM XT имелся жёсткий диск, поэтому в PC-DOS добавили поддержку каталогов. Нужно ведь навести порядок в куче файлов на огромном жёстком диске 10 МБ, очевидно!
Но вот проблема: пользователи уже используют эти специальные файлы с момента выпуска PC DOS 1.0 двумя годами ранее. Написано программное обеспечение с их поддержкой! В продакшн ушли пакетные файлы.
С появлением директорий Microsoft теперь могла сделать папку C:\DEV… но не сделала.
Не в последний раз Microsoft пожертвовала здравым смыслом ради обратной совместимости. Специальные файлы теперь могут быть в ЛЮБОМ КАТАЛОГЕ и С ЛЮБЫМ РАСШИРЕНИЕМ. Так что ваша команда `DIR > LPT` для печати листинга файлов продолжит работать в C:\DOS, как она работала в A:\.
Конечно, мы не запускаем DOS 2.0… Но Windows 95 построили поверх DOS. Естественно, она унаследовала это поведение (как и Windows 1/2/3 ранее). Windows 95 больше нет! Текущая ветвь Windows основана на Windows NT, а не Win95.
Однако Windows NT стремилась сохранить совместимость с программами DOS/Windows, поэтому XP объединила две ветви. Так что эти специальные файлы всё ещё работают, СПУСТЯ СОРОК ЧЕТЫРЕ ГРЁБАНЫХ ГОДА.
Можете сами попробовать! Откройте Проводник, создайте новый текстовый файл и назовите его con.txt, aux.txt или prn.txt.
Вам скажут ИЗВИНИ, ДРУГ…
Гэри Килдалл позаимствовал отличную идею из Unix и приспособил её для микрокомпьютеров с 4 КБ памяти без каталогов — это случилось так давно, что у родившихся тогда детей уже могут быть свои дети, которые имеют право покупать алкоголь, но мы по-прежнему не имеем права назвать файл con.txt.
Microsoft [приводит полный список](https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file) запрещённых названий: CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, LPT9.
Для ещё большего кайфа, попытка доступа к C:\con\con (или C:\aux\aux) на win95 мгновенно покажет синий экран. Это было весело даже в 1995 году, потому что багу исполнился 21 год! Представьте, что какая-то ошибка сохраняется настолько долго?
Бонус: вот фотография Тима Патерсона на VCF:W в августе этого года, он рассказывает об истории DOS.
Если вам интересно, как у меня появился «запрещённый» файл, который нельзя скопировать, то скажу. Эти имена специальных устройств реализуются на уровне ОС, а не на уровне файловой системы. Таким образом, это совершенно допустимые имена файлов NTFS, а я использовал диск NTFS под Linux.
Похоже, что OS/2 тоже не реализовала эти специальные имена, потому что на одном из дисков от IBM есть файлы AUX.H в комплекте OpenGL.
Так что сегодня я попытался сделать резервную копию этого диска NTFS на основной ПК и ОП-ПА, НЕВОЗМОЖНО СКОПИРОВАТЬ ВСЕ ФАЙЛЫ ИЗ-ЗА БАГА СТАРШЕ, ЧЕМ БОЛЬШИНСТВО ЧИТАТЕЛЕЙ ЭТОЙ СТАТЬИ.
Несколько примечаний:
1. CP/M на самом деле не использовала эти специальные имена так просто, как я описал. Похоже, что я или не знал, или забыл об этом факте. На самом деле они должны сопровождаться двоеточием, как имена дисков, то есть PRN: — это принтер, PRN — нет.
2. CP/M не реализовала их на уровне ОС, как в DOS! Они были просто включены в PIP, команду копирования файлов. Поэтому там не работал трюк DOS сохранения в файл PRN.TXT с автоматической печатью. Я не имел в виду, что CP/M так делала, а только DOS, но видимо не ясно выразился.
3. В PC DOS 1.0 на самом деле не было редиректов или конвейера, так что вы не сможете сделать такой редирект, как я предложил. Забыл об этом. Их добавили в PC DOS 2.0 в 1983 году. Хотя PC DOS 1.0 поддерживала копирование в/из специальных файлов, поэтому общий тезис правильный, даже если пример неудачный.
В любом случае, спасибо за отклики на эту статью! Не ожидал, что она так взорвётся, я просто накропал пару абзацев, когда пришёл домой сильно уставший и увидел сообщение об ошибке из-за бага 44-летней давности.
И если что, я не собирался кричать «Windows SUCKS». Обратная совместимость, в общем, хорошая вещь. На самом деле, я хотел бы больше обратной совместимости, а не меньше.
Но меня просто поразил этот баг из древности, который выскочил во время копирования с USB 3.0 SSD на другой SSD в Windows 10.
Это как будто живёшь на космической станции — а тут появляется лошадь.
tl; dr:
Your browser does not support HTML5 video. | https://habr.com/ru/post/428734/ | null | ru | null |
# Насколько хорошо у вас настроен OSPF/IS-IS или помогатор для сетевых инженеров
Коллеги-сетевики, привет. К написанию данной статьи меня сподвигли задачи, с которыми приходилось сталкиваться во время работы с OSPF/IS-IS и тот набор решений, к которому я в конечном итоге пришел. Речь идет о насущном вопросе сетевых инженеров, когда приходится применять настройки на живой сети (пусть и с программируемым откатом на крайний случай) без возможности посмотреть как это отразится на всей сети в целом. Если отдельные команды и сценарии еще можно проверить в лабе, то получить полную реплику сети практически невозможно. В связи с этим я задался вопросом о наличии инструмента, который позволял бы строить слепок сети и рассчитывать её реакцию на ранее примененные настройки. Об этом сегодняшний туториал.
Теория. Задачи. Практика
------------------------
Весь слепок сети (правильнее сказать слепок area) уже содержится компактно на каждом L3-устройстве в Link-State DataBase (LSDB) OSPF/IS-IS протокола. Достаточно лишь подключиться к одному устройству, сохранить её в текстовый файл и все связности в рамках одной области (area) у вас уже есть. Если областей несколько, то собрать LSDB с каждой из них. Далее достаточно правильно распарсить и построить математический граф с L3 устройствами в качестве нод (vertex) и OSPF/IS-IS соседством в качестве линков (edge) между ними. Имея такой граф, мы можем у себя на ПК делать с ним все, что захотим: удалять линки и изменять метрики на них, удалять сами ноды, строить маршруты и все это не затрагивая реальную сеть. К слову сказать на реальной сети можно и так посмотреть как будет проходить путь через tracert/traceroute/mtr, но не все устройства, в частности файерволы, покажут себя в этом выводе ([пример №1](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%E2%84%961)). А также нет никакой возможности посмотреть какой будет резервный (backup) маршрут, если тот или иной участок из этого пути упадет. Именно это покажет нам граф-модель, в которой достаточно удалить edge и построить маршрут между теми же самыми устройствами заново. Тогда наикратчайший маршрут в измененной модели будет являться резервным маршрутом для нашего первоначального слепка сети ([пример №2](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%E2%84%962)).
Представим, что сеть представляет собой совокупность разных по дизайну топологий: hub-and-spoke для подключения удаленных офисов и full или partial mesh между hub-ами. Каждый удаленный офис имеет основной (Primary) и запасной (Secondary,Backup) маршрутизатор и вы планируете перезагрузить secondary устройство. Повлияет ли это как-то на активный трафик? Если это резервный девайс, то через него не должно ничего проходить, но как это проверить? Оказывается достаточно просто — необходимо из каждой удаленной локации построить наикратчайший маршрут до нашей локации, где мы планируем провести работы, и тем самым убедиться используется ли secondary устройство для активного трафика или нет ([пример №3](#example_3)). Дальше-больше, что, если мы действительно обнаружили такой трафик с таким flow, как нам это поменять? Тогда нам не обойтись без изменения метрик (cost) на сети.
Много достоинств у Link-State протоколов и мы уже оценили одно из них, когда одно устройство содержит в себе всю информацию по конкретной области, но есть и особенности, с которыми приходится считаться. В частности метрика назначается и принадлежит интерфейсу, а не префиксу, как это обстоит у BGP. Поэтому если мы изменили метрику на одном интерфейсе, то могли повлиять на traffic flow во всей area. Но рано или поздно менять метрики приходится и если на интерфейсе на данный момент выставлена метрика 10, то как это повлияет на распределение трафика, если выставить не 10, а 9 или 11? Вы уже наверное догадались, что и в этот раз мы можем себе позволить сделать это на графе и посмотреть реакцию сети на наши изменения ([пример №4](#example_4)).
Сеть как живой организм — все в нем внутри тесно связан, взаимодействует между собой и состояние на «вчера» может отличаться от состояния текущего. Поэтому было бы неплохо также иметь возможность сравнивать состояние сети в разные отрезки времени. Имея копии LSDB, переведенные в граф, мы теперь уже можем сравнивать их и понимать: какие новые появились подсети, какие, наоборот, пропали, а также выявлять новые и старые L3-устройства ([пример №5](#example_5)).
Прежде чем переходить к разбору примеров, хотелось бы остановиться на архитектуре найденного решения, на основе которого построена демонстрационная часть.
### Архитектура. Безопасность
Решение представляет собой веб сервис, состоящий из Open-Source проектов:
* Nginx,
* MongoDB,
* Topolograph.
Благодаря контейнеризации, все составные части описаны в одном конфигурационном [файле](https://github.com/Vadims06/topolograph-docker/blob/master/docker-compose.yml) и запускаются одной `docker compose up -d` командой на Linux или Windows хосте. Такой подход имеет еще одно преимущество — безопасность, поскольку все загруженные данные о сети сохраняются в локальной MongoDB базе. Также данный сервис может быть помещен в DMZ зону, где разрешены только входящие HTTP запросы до Nginx, но запрещены все исходящие запросы за пределы зоны.
Используемые open-source решенияНа рисунке изображена архитектура решения, которая запускается в среде Docker. При этом сервис может и не иметь доступа к сети, поскольку для построения графа необходим лишь текстовый файл с описанием OSPF/IS-IS LSDB.
### Визуализация OSPF/IS-IS сети
#### Сбор LSDB с устройств различных вендоров
Для получения математической модели (графа) сети, необходимо сперва получить Link-State DataBase (LSDB) с реального устройства. Разные производители по-разному смотрят на формат вывода LSDB, но стоит отметить, что подавляющее большинство из них поддерживают RFC 2328.
| | | | |
| --- | --- | --- | --- |
| **Vendor** | **LSA1** | **LSA2** | **LSA5** |
| Cisco | show ip ospf database router | show ip ospf database network | show ip ospf database external |
| Quagga | show ip ospf database router | show ip ospf database network | show ip ospf database external |
| Juniper | show ospf database router extensive | no-more | show ospf database network extensive | no-more | show ospf database external extensive | no-more |
| Bird | show ospf state all | show ospf state all | show ospf state all |
| Nokia | show router ospf database type router detail | show router ospf database type network detail | show router ospf database type external detail |
| Mikrotik | /routing ospf lsa print detail file=lsa.txt | /routing ospf lsa print detail file=lsa.txt | /routing ospf lsa print detail file=lsa.txt |
| Huawei | display ospf lsdb router | display ospf lsdb network | display ospf lsdb ase |
| Paloalto | show routing protocol ospf dumplsdb | show routing protocol ospf dumplsdb | show routing protocol ospf dumplsdb |
| Ubiquiti | show ip ospf database router | show ip ospf database network | show ip ospf database external |
| Allied Telesis | show ip ospf database router | show ip ospf database network | show ip ospf database external |
Таблица с перечнем команд для сбора OSPF Link State DB. LSA1 и LSA2 являются обязательными для построения графа, в то время как LSA5 — опционален.
| | |
| --- | --- |
| **Vendor** | **Command** |
| Cisco | show isis database detail |
| Juniper | show isis database extensive |
| Nokia | show router isis database detail |
| Huawei | display isis lsdb verbose |
Таблица с перечнем команд для сбора IS-IS Link State DB.
#### Построенный граф на основе OSPF/IS-IS вывода LSDB
Чтение LSDB, её парсинг и построение графа считается успешным, если после загрузки файла с Link-State базой, отобразится топология сети. Граф динамический и интерактивный, то есть его можно перетянуть в нужное место на поле или выбрать ноду, до/с которой построить маршрут, нажав на нужную ноду правой кнопкой.
граф сети Жирной линией на графе отображены множественные (2 и более) связности между двумя нодами.
#### Построение кратчайшего пути. Пример №1
В самом начале статьи описывалась задача с построением актуальных путей между двумя устройствами. Результат расчета пути представлен на рисунке ниже. Дополнительно описывается маршрут с указанием каждого L3-устройства на сети (в трассировке используется OSPF RID (router ID)), а также метрика маршрута.
наикратчайшие пути с 123.14.14.14 до 123.123.30.30На картинке выше изображены 4 наикратчайших маршрута (ECMP, Equal cost multipath) от L3 устройства с RID 123.14.14.14 до 123.123.30.30 с метрикой 41.
Представим также, что Вы знаете только IP адрес отправителя и IP адрес получателя. Для построения маршрута нужно знать на каком из L3-устройств затерминирована подсеть отправителя и получателя, и чтобы не тратить время на поиск, можно сразу начать вводить IP адреса в поле Focus/From и To. Терминирующие их устройства подставятся автоматически.
#### Нахождение резервного маршрута. Пример №2
Мы теперь знаем как выглядит наикратчайший маршрут, давайте посмотрим какой будет резервный путь, если устройство 123.10.10.10 потеряет связность с 123.30.30.30. Для этого достаточно лишь нажать на синий линк пути.
резервный путь от 123.14.14.14 до 123.123.30.30При потери связности между двумя устройствами, резервный путь будет состоять из четырех ECMP путей, иметь стоимость 50 и будет проходить через устройства 123.31.31.31 — 123.11.11.11.
#### Построение карты доступности устройства. Пример №3
Представим, что нода 123.30.30.30 основная, а 123.31.31.31 — резервная. Наша задача заключается в том, чтобы проверить доступность группы устройств слева от устройства 123.30.30.30 из любой точки нашей сети. Этого можно достичь при включенной опции «`Print Minimum Shortest Tree (MST) for the node`» и выбора меню «Build the shortest path **to** this node».
все наикратчайшие пути до ноды 123.123.30.30 На рисунке выше изображены все наикратчайшие пути до ноды 123.123.30.30. Нода 123.30.30.30 действительно является основной для входящего трафика.
#### Построение карты сетевой доступности до всех устройств сети
Продолжая пример с активным и резервным роутером выше, теперь давайте убедимся, что это справедливо и для исходящего трафика. Для этого построим наикратчайшие пути от устройства 123.123.30.30 до всех нод в сети при выборе «`Build the shortest path from this node`».
Все исходящие пути ноды 123.123.30.30По полученной диаграмме выше можно заметить, что резервный маршрутизатор 123.31.31.31 также используется для исходящего трафика. Получается, что мы нашли асимметричный трафик на нашей сети.
Для того, чтобы находить участки с несимметричными путями, можно воспользоваться отчетом, который сделает вышеупомянутые проверки для каждого устройства в графе и на выходе предоставить список несимметричных путей (при их наличии).
Доступные отчеты о сетиВсе отчеты о сети помещены под графой Analytics. На момент написания статьи их представлено пять. Чуть подробнее об отчетах будет написано ниже.
#### Отчет о несимметричных путях на сети. Пример реальной сети
Когда отчет завершит проверку на наличие несимметричных путей, то появится список (слева) нод, относительно которых замечены такие маршруты. Если выбрать одну из нод в списке, то на графе будет отображена дельта во всех исходящих и во всех входящих маршрутах.
На рисунке изображен найденный отчетом несимметричный маршрут относительно ноды 10.5.0.115. Можно заметить как разительно отличается входящий и исходящий маршрут для этой ноды. Для реального трафика это может быть разное время прохождения пакета, что выражается в увеличенном джиттере.
### Реакция сети на изменения в ней
В [примере №2](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%E2%84%962) текущей статьи мы увидели какой будет резервный маршрут при падении связности между 123.10.10.10 и 123.30.30.30. Для получения этих данных нам пришлось построить наикратчайший маршрут между удаленными устройствами графа и с имитировать падение линка. Для случаев, когда нам хотелось бы увидеть картину в целом как перестроится OSPF/IS-IS граф, если мы на время выключим тот или иной линк, сделан режим `NetworkReactionOnFailure`. В этом режиме мы можем увидеть через какие устройства будут перенаправлены наикратчайшие пути после изменений на сети, а через какие устройства маршруты больше строиться не будут. Стоит отметить, что backend topolograph оперирует именно числом наикратчайших маршрутов через ноду и не привязывает это как-то к объему трафика, так как не располагает такой информацией. Однако мы можем предположить, что чем больше будет проложено маршрутов через ноду, то и трафика через неё будет в конечном итоге больше. Рассмотрим это на примере.
#### Реакция сети на потерю линка
Если граф уже успешно загружен и выбран режим `NetworkReactionOnFailure`, то при нажатии на любой линк графа будет эмулироваться ситуация с его выключением. При этом серые стрелки показывают то, что на указанном направлении будет снижение числа построенных через этот линк путей, а синяя линия, наоборот, их увеличение.
реакция сети на потерю связностиНа рисунке выше с эмулировано падение связности между нодой 123.30.30.30 и 123.10.10.10, при этом объем «трафика» в направлении от 123.11.11.11 до 123.31.31.31 увеличится на 200%, а в обратном направлении от 123.31.31.31 до 123.11.11.11 только лишь на 100%. В чем может быть причина?
Это связано с тем, что на линке 123.30.30.30 — 123.10.10.10 указаны разные метрики.
OSPF метрика между 123.30.30.30 и 123.10.10.10Из-за того, что стоимость до ноды 123.10.10.10 — 1, в то время, как в обратном направлении - 10, нижний линк через ноды 123.31.31.31 и 123.11.11.11 неравномеренно использовался. По этой причине на нем будет в два раза больше увеличение «трафика» при падении верхнего линка (отмеченного красным). Еще одной подсказкой где трафика станет больше или меньше может служить масштаб (ширина) стрелки, чем она шире, тем бОльше изменений.
#### Реакция сети на изменение метрики (cost). Пример №4
Помимо того, что можно имитировать падение связности, можно также посмотреть на реакцию сети на изменение стоимости на интерфейсе.
Имеем все тот же граф с асимметрично назначенными метриками и давайте посмотрим куда перенаправится трафик, если мы вместо стоимости 1, выставим стоимость 12 на интерфейсе.
реакция сети на измение метрики на интерфейсеНа диаграмме выше прогнозировано указано, что трафик предпочтет следовать через нижние устройства 123.31.31.31 и 123.11.11.11, поскольку верхний путь теперь имеет уже худшую метрику, чем на нижнем пути. Таким образом, изменив заранее метрику на верхнем линке, мы можем эвакуировать трафик с этого направления и перевести его на альтернативное.
#### Реакция сети на падение устройства
При проведении работ на сети нередки случаи, когда нужно вывести трафик с устройства, перезагрузить его, при этом трафик должен перенаправится в нужном для нас направлении. В этом нам может помочь все тот же режим `NetworkReactionOnFailure`.
эмулирование падения ноды 123.123.101.101С эмулируем падение ноды 123.123.101.101 через соответствующий пункт контекстного меню правой кнопки мыши.
реакция сети на падение 123.123.101.101Результат реакции сети показывает, что нагрузку на себя возьмет нода 123.123.100.100, но обратите внимание, что объем трафика не одинаков. К примеру, трафика с правой верхней ноды 123.123.110.110 в левую часть схемы через 123.123.100.100 будет больше, чем в обратном направлении с 123.10.10.10 через все тот же 123.123.100.100. Объясняется это все тем же несимметрично назначенной метрикой в левой части схемы на линке 123.10.10.10 — 123.30.30.30.
### Карта зарезервированности Stub сетей
При анализе Link-State DB учитываюся и сети (stub), которые анонсированы в OSPF/IS-IS домен. Какую полезную информацию можно получить из полученных данных? Если мы видим, что устройство 123.14.14.14 анонсирует сеть 10.0.0.0/24 и в тоже время другое устройство — 123.15.15.15 также включает её в свои анонсы, то мы можем сделать вывод, что оба эти устройства находятся в HSRP паре и данная сеть защищена на случай выхода из строя одного из устройств. Если проверить таким же образом каждую сеть, то можно построить карту с использованием градиента красного цвета там, где больше всего сетей без резервирования, и с зеленым цветом, где зарезервированных сетей больше.
Heatmap зарезервированных сетейНа рисунке показаны все сети устройства 123.10.10.10, а также то, что сеть 10.99.0.0/21 и 99.99.99.0/24 настроена только на нем, т.е. без резервирования. Стоит отметить, что здесь могут быть исключения. К примеру, стековый свич представлен в OSPF/IS-IS домене как одно устройство с одним RID, но по факту он может обеспечить резервирование при выходе из строя одного из его юнитов, если имеет минимум два кабельных подключения в разные юниты.
### Отчеты о сети
Для быстрого анализа настроек OSPF/IS-IS удобнее использовать отчеты, которые представляют собой набор стандартных проверок:
1. наличие соединений с асимметрично настроенной метрикой
2. наличие асимметричных путей
3. проверка, что резервный путь не проходит через устройства другого региона
4. резервирование сетей (stub)
Выводы с некоторых отчетов уже приводились в статье выше, приведем пример отчета по линками с асимметричной метрикой.
Отчет о линках с асиметричной метрикой Все линки с асимметричной метрикой помечаются красным.
### API
Для того, чтобы загрузить граф, не обязательно это делать через сохранение вывода OSPF/IS-IS LSDB в файл. Возможно воспользоваться любимым NetDevOps инструментом наподобие Ansible, netmiko, nornir и проч., сохранить через них вывод и сформировать POST запрос в Topolograph. Ответ будет содержать следующие данные:
* Разницу с ранее загруженными слепками сети: новые и старые L3 устройства, новые и старые связности (edge)
* ссылка на запрос списка всех сетей
* статус некоторых отчетов
Пример загрузки слепка OSPF домена сети представлен ниже.
POST запрос на загрузку LSDBИз вывода POST запроса видно, что по сравнению с ранее загруженным слепком OSPF домена, пропали 4 связности между устройствами. Старых, как и новых L3 устройств в сети не появилось. Однако появилась 1 новая сеть и 1 сеть теперь уже не анонсируется устройством 123.10.10.10. Из прочей статистики указано общее число нод — 13 и общее число сетей - 39. Таким образом можно мониторить основные характеристики OSPF/IS-IS домена сети. Для собственной проверки можно делать слепок каждый раз до и после работ на сети. Если после работ изменений не выявлено, то можно уверенно утверждать, что работы проведены успешно (если конечно работы не предполагали каких-либо изменений настроек на сети).
### Мониторинг изменений в OSPF домене из единой точки на сети в режиме Online
Имея возможность получать diff сети, можно задаться целью собирать слепки настолько часто, чтобы мы могли детектировать аварийные случаи. Но тогда нужно определиться насколько часто подключаться и сохранять их, чтобы с одной стороны не нагрузить устройство, а с другой — отловить начало и конец аварии (на тот случай, если падение связности между устройствами было кратковременным). Но гораздо эффективней и рациональней предоставить возможность сервису читать актуальные служебные сообщения OSPF (LSA) в режиме реального времени и таким образом логировать изменения на сети. Такая задача покрывается в другом, но схожем, open-source проектe [Ospfwatcher](https://github.com/Vadims06/ospfwatcher), целью которого является мониторинг изменений в OSPF топологии и экспорт данных в [ELK](https://www.elastic.co/what-is/elk-stack) (Elasticsearch, Logstash и Kibana).
На данный момент имеет следующую архитектуру:
* Linux хост с docker, с которого устанавливается GRE туннель до любого активного L3 устройства в сети
* Quagga для установления OSPF соседства через GRE туннель и дебаг OSPF LSA сообщений в docker volume
* Watcher модуль, который читает OSPF debug сообщения и переводить их в структурированный вид
* Logstash, который делает экспорт логов в стек Elastic-Logstash-Kibana
Компоненты ospfwatcher также описаны в едином конфигурационном [файле](https://github.com/Vadims06/ospfwatcher/blob/master/docker-compose.yml) для запуска их через `docker compose`.
Архитектруа OspfwatcherКак результат работы сервиса, мы имеем историческую справку обо всех изменениях на сети.
На [рисунке](https://github.com/Vadims06/ospfwatcher/blob/c491207c76be709f401a5d2ab5652383ee77867b/docs/cost-changes-raw-logs.png) выше представлена выборка логов по изменению OSPF метрики на сети в Elastic-e, а именно:
* какое устройство обнаружило изменение,
* какая была старая метрика и какая — новая.
Как это использоватьПриходя утром в офис ~~Подключившись по удаленке через VPN~~, можно просмотреть, что было c OSPF за ночь. Или когда поступают жалобы в виде "сеть начала тормозить, когда как 5 минут назад все работало хорошо" можно проверить перестраивался ли OSPF, если нет, то следовать по привычным шагам далее - смотреть мониторинг, дашборды, уточнять детали. Если же граф перестраивался, то это даст подсказку где и что произошло.
### Заключение
Этой статьей я хотел суммировать подходы к исследованию настроек OSPF/IS-IS сети с помощью доступных инструментов, с целью привнесения некоторой аналитики в legacy сети, которые по умолчанию этот сервис не предоставляют. Попробуйте применить озвученные подходы анализа к вашей сети, сделайте отчеты, будут ли у вас несимметричные пути?) Возможно, у кого серые IP адреса на Router ID и кто может показать свою топологий - также welcome, вместе посмотрим какой дизайн сети применяется чаще всего. | https://habr.com/ru/post/680048/ | null | ru | null |
# WAL in PostgreSQL: 4. Setup and Tuning
So, we got acquainted with the structure of the [buffer cache](https://habr.com/ru/company/postgrespro/blog/491730/) and in this context concluded that if all the RAM contents got lost due to failure, the [write-ahead log (WAL)](https://habr.com/ru/company/postgrespro/blog/494246/) was required to recover. The size of the necessary WAL files and the recovery time are limited thanks to the [checkpoint](https://habr.com/ru/company/postgrespro/blog/494464/) performed from time to time.
In the previous articles we already reviewed quite a few important settings that anyway relate to WAL. In this article (being the last in this series) we will discuss problems of WAL setup that are unaddressed yet: WAL levels and their purpose, as well as the reliability and performance of write-ahead logging.
WAL levels
==========
The main WAL task is to ensure recovery after a failure. But once we have to maintain the log anyway, we can also adapt it to other tasks by adding some more information to it. There are several logging levels. The *wal\_level* parameter specifies the level, and each next level includes everything that gets into WAL of the preceding level plus something new.
Minimal
-------
The minimum possible level is set by the value of *wal\_level* = *minimal* and ensures only recovery after a failure. To save space, the operations related to bulk data processing (such as CREATE TABLE AS SELECT or CREATE INDEX) are not WAL-logged. Instead, the data needed are immediately written to disk, and a new object is added to the system catalog and becomes visible at the transaction commit. If a failure occurs while the operation is performed, the data that are already written remain invisible and do not violate the consistency rules. And if a failure occurs after completion of the operation, everything needed is already on disk and does not need logging.
Let's take a look. First we'll set the necessary level (to this end, we will also need to change another parameter — *max\_wal\_senders*).
```
=> ALTER SYSTEM SET wal_level = minimal;
=> ALTER SYSTEM SET max_wal_senders = 0;
```
```
student$ sudo pg_ctlcluster 11 main restart
```
Note that the change of the level requires restarting the server.
Let's remember the current WAL location:
```
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/353927BC
(1 row)
```
Now let's perform creation of a table (CREATE TABLE AS SELECT) and remember the WAL location again. The amount of data retrieved by the SELECT operator does not matter at all in this case, so one row is enough.
```
=> CREATE TABLE wallevel AS
SELECT 1 AS n;
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/353A7DFC
(1 row)
```
Let's look at WAL records using the familiar `pg_waldump` utility.
```
postgres$ /usr/lib/postgresql/11/bin/pg_waldump -p /var/lib/postgresql/11/main/pg_wal -s 0/353927BC -e 0/353A7DFC
```
Certainly, some details can differ from one launch to another, but in this case we get the following. The record of the `Heap2` manager relates to vacuuming, here it is in-page vacuum of a table from the system catalog (system objects are easily distinguished with a naked eye by a small number in `rel`):
```
rmgr: Heap2 len (rec/tot): 59/ 7587, tx: 0, lsn: 0/353927BC, prev 0/35392788, desc: CLEAN remxid 101126, blkref #0: rel 1663/16386/1247 blk 8 FPW
```
The record of getting the next OID for the table to be created follows:
```
rmgr: XLOG len (rec/tot): 30/ 30, tx: 0, lsn: 0/35394574, prev 0/353927BC, desc: NEXTOID 82295
```
And this is pure creation of the table:
```
rmgr: Storage len (rec/tot): 42/ 42, tx: 0, lsn: 0/35394594, prev 0/35394574, desc: CREATE base/16386/74103
```
But the insert of data into the table is not WAL-logged. Multiple records follow on row inserts into different tables and indexes — this way PostgreSQL writes the information on the created table to the system catalog (provided in a shorthand form):
```
rmgr: Heap len (rec/tot): 203/ 203, tx: 101127, lsn: 0/353945C0, prev 0/35394594, desc: INSERT off 71, blkref #0: rel 1663/16386/1247 blk 8
rmgr: Btree len (rec/tot): 53/ 685, tx: 101127, lsn: 0/3539468C, prev 0/353945C0, desc: INSERT_LEAF off 37, blkref #0: rel 1663/16386/2703 blk 2 FPW
...
rmgr: Btree len (rec/tot): 53/ 2393, tx: 101127, lsn: 0/353A747C, prev 0/353A6788, desc: INSERT_LEAF off 10, blkref #0: rel 1664/0/1233 blk 1 FPW
```
And finally the transaction commit:
```
rmgr: Transaction len (rec/tot): 34/ 34, tx: 101127, lsn: 0/353A7DD8, prev 0/353A747C, desc: COMMIT 2019-07-23 18:59:34.923124 MSK
```
Replica
-------
When we restore a PostgreSQL instance from backup, we start with some state of the file system and gradually bring the data to the target point of the recovery by playing back the archived WAL records. The number of such records can be pretty large (for example, records for several days), that is, the recovery period will span many checkpoints rather than one. So, it is clear that the minimum logging level is insufficient — if an operation is not logged, we will be unaware of whether we need to redo it. To support restoring from backup, *all* the operations must be WAL-logged.
The same is true for the replication: everything that is not logged will not be sent to the replica and will not be replayed. And a wish to run queries on a replica complicates the situation even more.
First, we need information on exclusive advisory locks that occur on the main server since they can conflict the queries on the replica. Such locks are WAL-logged and then the **startup** process applies them on the replica.
Second, we need to create [data snapshots](https://habr.com/ru/company/postgrespro/blog/479512/), and to do this, as we remember, information on the transactions being executed is needed. In the case of a replica, not only local transactions are meant, but also transactions on the main server. The only way to provide this information is to WAL-log it from time to time (this happens once every 15 seconds).
The level of WAL that ensures both restoring from backup and a possibility of physical replication is set by the value of *wal\_level* = *replica*. (Before version 9.6, two separate levels were available — *archive* and *hot\_standby* — but later they were combined.)
It's this level that is used by default starting with PostgreSQL 10 (while earlier it was *minimal*). So let's just restore the parameters to their default values:
```
=> ALTER SYSTEM RESET wal_level;
=> ALTER SYSTEM RESET max_wal_senders;
```
```
student$ sudo pg_ctlcluster 11 main restart
```
Deleting the table and redoing exactly the same sequence of steps as last time:
```
=> DROP TABLE wallevel;
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/353AF21C
(1 row)
```
```
=> CREATE TABLE wallevel AS
SELECT 1 AS n;
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/353BE51C
(1 row)
```
Now let's check WAL records.
```
postgres$ /usr/lib/postgresql/11/bin/pg_waldump -p /var/lib/postgresql/11/main/pg_wal -s 0/353AF21C -e 0/353BE51C
```
Vacuuming, getting the OID, creation of the table and registration in the system catalog — same as before so far:
```
rmgr: Heap2 len (rec/tot): 58/ 58, tx: 0, lsn: 0/353AF21C, prev 0/353AF044, desc: CLEAN remxid 101128, blkref #0: rel 1663/16386/1247 blk 8
rmgr: XLOG len (rec/tot): 30/ 30, tx: 0, lsn: 0/353AF258, prev 0/353AF21C, desc: NEXTOID 82298
rmgr: Storage len (rec/tot): 42/ 42, tx: 0, lsn: 0/353AF278, prev 0/353AF258, desc: CREATE base/16386/74106
rmgr: Heap len (rec/tot): 203/ 203, tx: 101129, lsn: 0/353AF2A4, prev 0/353AF278, desc: INSERT off 73, blkref #0: rel 1663/16386/1247 blk 8
rmgr: Btree len (rec/tot): 53/ 717, tx: 101129, lsn: 0/353AF370, prev 0/353AF2A4, …
rmgr: Btree len (rec/tot): 53/ 2413, tx: 101129, lsn: 0/353BD954, prev 0/353BCC44, desc: INSERT_LEAF off 10, blkref #0: rel 1664/0/1233 blk 1 FPW
```
And this is something new. The record of the exclusive lock, related to the `Standby` manager — here it is the lock on the transaction ID (we will discuss why it is needed in the next series of articles):
```
rmgr: Standby len (rec/tot): 42/ 42, tx: 101129, lsn: 0/353BE2D8, prev 0/353BD954, desc: LOCK xid 101129 db 16386 rel 74106
```
And this is the record of row inserts in our table (compare the file number `rel` with the one in the CREATE record):
```
rmgr: Heap len (rec/tot): 59/ 59, tx: 101129, lsn: 0/353BE304, prev 0/353BE2D8, desc: INSERT+INIT off 1, blkref #0: rel 1663/16386/74106 blk 0
```
This is the commit record:
```
rmgr: Transaction len (rec/tot): 421/ 421, tx: 101129, lsn: 0/353BE340, prev 0/353BE304, desc: COMMIT 2019-07-23 18:59:37.870333 MSK; inval msgs: catcache 74 catcache 73 catcache 74 catcache 73 catcache 50 catcache 49 catcache 7 catcache 6 catcache 7 catcache 6 catcache 7 catcache 6 catcache 7 catcache 6 catcache 7 catcache 6 catcache 7 catcache 6 catcache 7 catcache 6 snapshot 2608 relcache 74106 snapshot 1214
```
And there is one more record, which occurs from time to time and is not tied to the completed transaction, relates to the `Standby` manager and informs of the transactions being executed at this point in time:
```
rmgr: Standby len (rec/tot): 50/ 50, tx: 0, lsn: 0/353BE4E8, prev 0/353BE340, desc: RUNNING_XACTS nextXid 101130 latestCompletedXid 101129 oldestRunningXid 101130
```
Logical
-------
And finally, the last level is specified by the value of *wal\_level* = *logical* and provides for logical decoding and logical replication. It must be turned on for the publishing server.
From the perspective of WAL records, this level is virtually the same as *replica*: records are added that relate to replication origins, as well as arbitrary logical records that applications can add to WAL. But logical decoding mainly depends on the information on the transactions being executed since it is needed to create the data snapshot to track changes to the system catalog.
We will not go into details of backup and replication now since this is a topic for a separate series of articles.
Reliability of writing
======================
It's clear that a logging technique must be reliable and ensure recovery whatever the circumstances (certainly, not related to corruption of the data storage media). Many things affect reliability, of which we will discuss caching, corruption of data and atomicity of writing.
Caching
-------
Multiple caches stand in the way of data to a nonvolatile storage (such as a hard disk drive platter).
If a program (any, but PostgreSQL in this case) asks the operating system (OS) to write something on disk, the OS transfers the data to its RAM cache. Writing actually happens asynchronously, depending on the settings of I/O scheduler of the OS.
When the OS decides to write the data, they get into the cache of the storage (hard disk). Electronics of the storage can also postpone writing, for example, by grouping data that are more efficient to be written together. And if a RAID controller is used, one more caching level is added between the OS and disk.
So, without taking special measures, it is absolutely unclear when the data is actually saved in a reliable manner. And usually it makes no difference, but there are critical areas where PostgreSQL must be sure that the data are written with due reliability. This is, primarily, logging (if a WAL record did not reach disk, it will be lost along with the rest of the RAM contents) and a checkpoint (we must be sure that dirty pages are really written to disk). But there are other situations, such as performing unlogged operations at the level of *minimal* and so on.
The OS provides capabilities to ensure immediate writing of the data to nonvolatile memory. There are a few options, but they reduce to the two main: either after a write, the synchronization call is performed (`fsync`, `fdatasync`) or after opening a file (or writing to it) a special flag is set to indicate a need for synchronization or even for a direct write bypassing the OS cache.
As for WAL, the `pg_test_fsync` utility allows us to choose a method that best suits a particular OS and a particular file system, and this method is specified in the *wal\_sync\_method* parameter. Normal files are synchronized using `fsync`.
A subtle point is that to choose the method, we need to take into account hardware characteristics. For example: if a controller employing a battery-backup unit (BBU) is used, there is no reason why we should avoid using the cache of the controller since the BBU enables saving the data in case of power outage.
> The documentation provides a [lot of context](https://postgrespro.com/docs/postgresql/11/wal-reliability) on this.
>
>
In any case, synchronization is expensive and performed at most as often as absolutely necessary (we will get back to this a bit later, when we discuss the performance).
In general, you can turn off the synchronization (the *fsync* parameter is responsible for this), but in this case, you have to forget about the reliability of storage. By turning *fsync* off you agree that the data can be irreversibly lost at any time. Probably, the only reasonable use case for this parameter is a temporary increase of the performance when the data can be easily restored from a different source (like at the initial migration).
Data corruption
---------------
Hardware is imperfect and the data can be corrupted in the storage when transmitted over interface cables, and so on. Some of such errors are handled at the hardware level, but the others are not.
For quick detection of an issue, checksums are provided in WAL records.
Data pages can also be protected by checksums. Earlier this could be done only at the cluster initialization, but in PostgreSQL 12 it is possible to turn the checksums on and off by means of the `pg_checksums` utility (but only when the server is shut down rather than «on the fly» so far).
In a production environment, checksums must be obligatory turned on regardless of the overhead costs of computing and verifying them. This reduces the probability of not detecting the corruption duly.
> It reduces, but not eliminates the probability.
>
> First, checksums are verified only when the page is accessed; therefore, the corruption may escape detection until the moment when it gets into all backups. It's for this reason that [pg\_probackup](https://postgrespro.com/docs/postgrespro/11/app-pgprobackup) verifies the checksums of all the cluster pages during the data backup.
>
> Second, a page filled with zeros is regarded as correct, so if the file system mistakenly «nullifies» a file, this can escape detection.
>
> Third, checksums protect only the main fork of the data. The other forks and the rest of files (for instance, transaction statuses XACT) are not protected at all.
>
> Alas.
>
>
Let's see how it works. First we make sure that checksums are turned on (note that in a package installed on Debian-like systems this is not the case by default):
```
=> SHOW data_checksums;
```
```
data_checksums
----------------
on
(1 row)
```
The *data\_checksums* parameter is read-only.
This is the file where our table is located:
```
=> SELECT pg_relation_filepath('wallevel');
```
```
pg_relation_filepath
----------------------
base/16386/24890
(1 row)
```
Let's shut down the server and change a few bytes on the zero page, for example: erase LSN of the last WAL record from the header.
```
student$ sudo pg_ctlcluster 11 main stop
```
```
postgres$ dd if=/dev/zero of=/var/lib/postgresql/11/main/base/16386/24890 oflag=dsync conv=notrunc bs=1 count=8
```
```
8+0 records in
8+0 records out
8 bytes copied, 0,0083022 s, 1,0 kB/s
```
In general, it was not needed to shut down the server. It is sufficient that the page is flushed to disk and evicted from the cache (otherwise, the server would continue working with the page in the cache). But this scenario is more complicated to reproduce.
Now we start the server and try to read the table.
```
student$ sudo pg_ctlcluster 11 main start
```
```
=> SELECT * FROM wallevel;
```
```
WARNING: page verification failed, calculated checksum 23222 but expected 50884
ERROR: invalid page in block 0 of relation base/16386/24890
```
But what shall we do if it is impossible to restore the data from backup? The *ignore\_checksum\_failure* parameter enables trying to read the table, of course, with a risk of getting corrupted data.
```
=> SET ignore_checksum_failure = on;
=> SELECT * FROM wallevel;
```
```
WARNING: page verification failed, calculated checksum 23222 but expected 50884
n
---
1
(1 row)
```
Of course, everything is fine in this case since we hurt only the header rather than pure data.
And there is one more point to note. When checksums are turned on, hint bits are WAL-logged (we [discussed](https://habr.com/ru/company/postgrespro/blog/477648/) them earlier) since a change to any, even inessential, bit results in a change to the checksum. When checksums are turned off, the *wal\_log\_hints* parameter is responsible for WAL-logging hint bits.
Changes to hint bits are always logged as *FPI (full page image)*, which pretty much increases the WAL size. In this case, it makes sense to use the *wal\_compression* parameter to turn on compression of FPIs (this parameter was added in version 9.5). We will look at specific figures a bit later.
Atomicity of writing
--------------------
And finally, there is an issue with the atomicity of writing. A database page occupies not less than 8 KB (it may be 16 or 32 KB), and at a low level, a write is done in blocks, which usually have smaller sizes (usually 512 bytes or 4 KB). Therefore, in case of a power outage, a data page can be written partially. It's clear that during a recovery, it makes no sense to apply usual WAL records to such a page.
To prevent this, PostgreSQL enables WAL-logging a *full page image* at the first change of the page since the beginning of a checkpoint cycle (the same image is also logged when hint bits change). The *full\_page\_writes* parameter controls this, and it is turned on by default.
If a recovery process comes across an FPI in WAL, it writes the image to disk unconditionally (without LSN checking): the FPI is more trustworthy since it is protected by a checksum, like each WAL record. And it is this reliably correct image, which normal WAL records are applied to.
Although in PostgreSQL, an FPI does not include free space (we [discussed](https://habr.com/ru/company/postgrespro/blog/469087/) the block structure earlier), FPIs considerably increase the amount of WAL records generated. As already mentioned, the situation can be improved by compression of FPIs (using the *wal\_compression* parameter).
To get an insight into changing the WAL size, let's conduct a simple experiment using the `pgbench` utility. Performing the initialization:
```
student$ pgbench -i test
```
```
dropping old tables...
creating tables...
generating data...
100000 of 100000 tuples (100%) done (elapsed 0.15 s, remaining 0.00 s)
vacuuming...
creating primary keys...
done.
```
The *full\_page\_writes* parameter is turned on:
```
=> SHOW full_page_writes;
```
```
full_page_writes
------------------
on
(1 row)
```
Let's perform a checkpoint and immediately run a test for 30 seconds.
```
=> CHECKPOINT;
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/38E04A08
(1 row)
```
```
student$ pgbench -T 30 test
```
```
starting vacuum...end.
transaction type: TPC-B (sort of)
scaling factor: 1
query mode: simple
number of clients: 1
number of threads: 1
duration: 30 s
number of transactions actually processed: 26851
latency average = 1.117 ms
tps = 895.006720 (including connections establishing)
tps = 895.095229 (excluding connections establishing)
```
```
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/3A69C478
(1 row)
```
Getting the size of WAL records:
```
=> SELECT pg_size_pretty('0/3A69C478'::pg_lsn - '0/38E04A08'::pg_lsn);
```
```
pg_size_pretty
----------------
25 MB
(1 row)
```
Now let's turn off the *full\_page\_writes* parameter:
```
=> ALTER SYSTEM SET full_page_writes = off;
=> SELECT pg_reload_conf();
```
And we repeat the experiment.
```
=> CHECKPOINT;
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/3A69C530
(1 row)
```
```
student$ pgbench -T 30 test
```
```
starting vacuum...end.
transaction type: TPC-B (sort of)
scaling factor: 1
query mode: simple
number of clients: 1
number of threads: 1
duration: 30 s
number of transactions actually processed: 27234
latency average = 1.102 ms
tps = 907.783080 (including connections establishing)
tps = 907.895326 (excluding connections establishing)
```
```
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/3BE87658
(1 row)
```
Getting the size of WAL records:
```
=> SELECT pg_size_pretty('0/3BE87658'::pg_lsn - '0/3A69C530'::pg_lsn);
```
```
pg_size_pretty
----------------
24 MB
(1 row)
```
Yes, the size decreased, but not so much as we could expect.
The thing is that the cluster was initialized with the checksums on data pages and therefore, FPIs have to be WAL-logged anyway when hint bits change. These data (in the situation above) make up about half of the whole amount, which you can make sure of by looking at the statistics:
```
postgres$ /usr/lib/postgresql/11/bin/pg_waldump --stats -p /var/lib/postgresql/11/main/pg_wal -s 0/3A69C530 -e 0/3BE87658
```
```
Type N (%) Record size (%) FPI size (%)
---- - --- ----------- --- -------- ---
XLOG 1721 ( 1,03) 84329 ( 0,77) 13916104 (100,00)
Transaction 27235 ( 16,32) 926070 ( 8,46) 0 ( 0,00)
Storage 1 ( 0,00) 42 ( 0,00) 0 ( 0,00)
CLOG 1 ( 0,00) 30 ( 0,00) 0 ( 0,00)
Standby 4 ( 0,00) 240 ( 0,00) 0 ( 0,00)
Heap2 27522 ( 16,49) 1726352 ( 15,76) 0 ( 0,00)
Heap 109691 ( 65,71) 8169121 ( 74,59) 0 ( 0,00)
Btree 756 ( 0,45) 45380 ( 0,41) 0 ( 0,00)
-------- -------- --------
Total 166931 10951564 [44,04%] 13916104 [55,96%]
```
Zero rows are removed to make the table more compact. Pay attention to the summary row (Total) and compare the size of full images (FPI size) with he size of normal records (Record size).
The *full\_page\_writes* parameter can be turned off only if the file system and hardware themselves ensure the automicity of writes. But, as we can see, there isn't much sense in it (provided checksums are turned on).
Now let's see how compression can help.
```
=> ALTER SYSTEM SET full_page_writes = on;
=> ALTER SYSTEM SET wal_compression = on;
=> SELECT pg_reload_conf();
```
Repeating the same experiment.
```
=> CHECKPOINT;
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/3BE87710
(1 row)
```
```
student$ pgbench -T 30 test
```
```
starting vacuum...end.
transaction type: TPC-B (sort of)
scaling factor: 1
query mode: simple
number of clients: 1
number of threads: 1
duration: 30 s
number of transactions actually processed: 26833
latency average = 1.118 ms
tps = 894.405027 (including connections establishing)
tps = 894.516845 (excluding connections establishing)
```
```
=> SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/3CBD3EA8
(1 row)
```
Getting the size of WAL records:
```
=> SELECT pg_size_pretty('0/3CBD3EA8'::pg_lsn - '0/3BE87710'::pg_lsn);
```
```
pg_size_pretty
----------------
13 MB
(1 row)
```
Conclusion: if there are many FPIs (due to checksums or *full\_page\_writes*, that is, almost always), most likely it makes sense to use compression although it loads the processor.
Performance
===========
During regular work of a server, WAL files are continuously written one by one. Because of no random access, even HDD disks do the job fine. But this kind of load is pretty much different from the one when data files are accessed.
So, it is usually beneficial to store WAL on a separate physical disk (or disk array) mounted to the file system of the server. Instead of the `$PGDATA/pg_wal` directory, a symbolic link to the appropriate directory must be created.
> There are a couple of situations where WAL files need to be not only written but read. The first one is a clear case of recovery after a failure. The second one is less trivial. It occurs if stream replication is used and a replica is late to receive WAL records while they are still in the OS buffers of the main server. In this case, the `walsender` process has to read the necessary data from disk. We will discuss this in more detail when we reach replication.
>
>
WAL is written in either of the two modes:
* Synchronous — at a transaction commit, the work cannot be continued until all WAL records of this transaction get on disk.
* Asynchronous — a transaction completes immediately, and WAL is written in the background.
The *synchronous\_commit* parameter, turned on by default, sets the synchronous mode.
Because synchronization is connected with the actual (that is, slow) input/output, it is beneficial to do it as infrequently as possible. To this end, a backend process that completes a transaction and writes WAL makes a short pause, defined by the *commit\_delay* parameter. But this happens only if the system has not less than *commit\_siblings* active transactions. This behavior relies on the expectation that during the waiting time some transactions will be completed and it will be possible to synchronize them in one go. This is similar to how you hold the doors of an elevator so that someone has time to jump into the car.
By default, *commit\_siblings* = 5 and *commit\_delay* = 0, so actually there is no wait. It makes sense to change the value of *commit\_delay* only for systems that execute a great number of OLTP transactions.
Then the process flushes part of WAL up to the LSN needed (or a little more if during the waiting time new records were added). After that the transaction is considered completed.
Synchronous writing ensures durability (the letter D in the ACID acronym): if a transaction is committed, all its WAL records are already on disk and won't be lost. But a drawback is that synchronous writing increases the response time (the COMMIT command does not return control until the end of the synchronization) and reduces the system performance.
You can make writing asynchronous by setting *synchronous\_commit* = `off` (or `local`).
When writing is asynchronous, WAL records are flushed by the **wal writer** process, which alternates work and waits (the waiting time is specified by the *wal\_writer\_delay* parameter with the default value of 200 ms).
When the process wakes up after a wait, it checks whether completely filled WAL pages appeared since last time. If they did appear, the process ignores the current page, not filled to the end, and writes only completely filled pages. (However, not all at once: writing stops when it reaches the end of the cache and proceeds from the beginning of the cache next time.)
But if none of the pages are filled, the process writes the current WAL page (not filled to the end) — otherwise, what did it wake up for?
This algorithm aims to avoid synchronization of the same page several times wherever possible, which is critical for a large stream of updates.
Asynchronous writing is more efficient than the synchronous since commits of the changes do not wait for writes of WAL pages. But the reliability decreases: committed data can be lost in case of failure if less than 3 × *wal\_writer\_delay* units of time elapsed between the commit and failure (with the default settings, this is a little longer than half a second).
Not an easy choice between efficiency and reliability is up to the system administrator.
Note that: unlike turning off synchronization (*fsync* = `off`), asynchronous mode does not make recovery impossible. In case of failure, the system will restore the consistent state, but maybe, some of the last transactions will not be present there.
You can set the *synchronous\_commit* parameter for separate transactions. This enables increasing the performance by sacrificing the reliability only of some transactions. Say, financial transactions must be committed synchronously, while chat messages can be compromised.
Actually both modes work together. Even with a synchronous commit, WAL records of a long transaction will be written asynchronously in order to free WAL buffers. And if during a flush of a page from the buffer cache it appears that the corresponding WAL record is not on disk yet, it will be immediately flushed in the synchronous mode.
To get an insight into the gains of an asynchronous commit, let's try to repeat the `pgbench` test in this mode.
```
=> ALTER SYSTEM SET synchronous_commit = off;
=> SELECT pg_reload_conf();
```
```
student$ pgbench -T 30 test
```
```
starting vacuum...end.
transaction type: TPC-B (sort of)
scaling factor: 1
query mode: simple
number of clients: 1
number of threads: 1
duration: 30 s
number of transactions actually processed: 45439
latency average = 0.660 ms
tps = 1514.561710 (including connections establishing)
tps = 1514.710558 (excluding connections establishing)
```
With synchronous commits, we got approximately 900 transactions per second (tps) and 1500 tps with asynchronous commits. It goes without saying that in a real-life system under the actual load, the proportion will be different, but it is clear that for short transactions the effect can be pretty considerable.
Here the series of articles on WAL logging comes to an end. If anything critical is unaddressed, I would appreciate if you provide comments. Thank you all!
And next, amazing adventures are awaiting us in the world of locks, but that's another story. | https://habr.com/ru/post/496150/ | null | en | null |
# Основы работы с базой данных RIPE
*Данная статья задумывалась как отправная точка, которая поможет новичкам быстро вникнуть в суть работы с БД RIPE, чтобы в голове сложилась целостная картина и понимание, для чего в ней используются те или иные объекты. Отмечу, что данная статья дает только общее представление о работе с данной системой, не описывая детальные шаги, но тем не менее я надеюсь, что после прочтения вам будет легче разобраться в вопросе.*
Рано или поздно большинство сетевых инженеров сталкиваются с необходимостью взаимодействия с базой данных RIPE. Например, если вы устроились на работу в компанию, предоставляющую доступ в интернет, или организацию, которая владеет собственной автономной системой, то вам с 99%-ной вероятностью потребуется периодически добавлять/удалять и поддерживать актуальной какую-то информацию в БД RIPE. Даже просматривая вакансии при поиске работы, иногда можно наткнуться на требование «Умение работать с RIPE».
Также в ходе своей работы, решении каких-то задач или устранении неполадок, вам может потребоваться, например, следующее: узнать контактные данные технических специалистов, администрирующих блоки определенных IP-адресов, уточнить политику маршрутизации, которая применяется в соседней с вами автономной системе, или направить жалобу о неправомерном использовании IP-адресов, принадлежащих какой-то организации и т. д. Когда сталкиваешься с этими задачами впервые, можно немного растеряться. Так что умение работать с БД RIPE и понимание того, как найти в ней необходимую информацию – это полезный и нужный навык.
В ходе данной статьи я попробую ответить на вопросы: что из себя представляет БД RIPE? Какие функции она выполняет? Какие основные объекты используются на практике?
Найти более подробную информацию вы всегда можете в [официальной документации](https://www.ripe.net/manage-ips-and-asns/db/support/documentation/ripe-database-documentation). В конце статьи также представлена ссылка на замечательный бесплатный курс от RIPE NCC, который включает в себя в том числе интересные интерактивные задачи, которые помогут получить практический опыт.
Начнем с определений:
1. IRR — Internet Routing Registry. Это глобальная распределенная база данных маршрутных политик. Задумывалась такая база как инструмент, с помощью которого операторы связи смогут делиться своими маршрутными политиками и информацией о том, какие сети и кому они анонсируют. В совокупности это должно способствовать большей стабильности работы сети Интернет, помогать инженерам при устранении неполадок, связанных с глобальной маршрутизацией. Также эта база может являться источником данных для различных программ, которые помогают автоматически генерировать конфигурацию оборудования на основании доступной там информации. IRR использует так называемый язык спецификации маршрутных политик (RPSL) для описания хранимых в ней данных. БД RIPE в том числе исполняет и функции IRR.
2. RPSL — Routing Policy Specification Language. Это язык, с помощью которого описываются маршрутные политики. Этот язык объектно-ориентированный, но к программированию он не имеет никакого отношения. По сути, он описывает классы объектов, а конкретные объекты в своих атрибутах содержат уже конкретную информацию. Например, есть класс aut-num, он описывает автономную систему: ее номер, какой организации принадлежит, к кому можно обратиться в случае проблем связности с этой автономной системой и т. д. Объекты, в свою очередь, являются кирпичиками, из которых состоит БД RIPE.
Подробнее про RPSL можно почитать тут:
<https://www.rfcreader.com/#rfc2622>
<https://www.rfcreader.com/#rfc2650>
**Функции БД RIPE**
***Поддержание актуальной контактной информации***
Интернет состоит из огромного количество связанных между собой сетей, автономных систем и людей, поддерживающих его работоспособность. Иногда вам может потребоваться узнать, кому принадлежит та или иная автономная система или блок IP-адресов, и как связаться с теми, кто за них отвечает. Вы не можете держать в своей записной книжке все эти контакты. БД RIPE – именно то место, где данную информацию можно оперативно найти.
***Учет интернет-ресурсов***
Под интернет-ресурсами здесь понимаются блоки IP-адресов и номера автономных систем. RIPE NCC, являясь одним из RIR, занимается распределением интернет-ресурсов и их учетом для Европы, Ближнего Востока и Центральной Азии. Информация о выделенных номерах AS, распределенных блоках IP-адресов и т. д. – все это учитывается и отображается в БД RIPE.
***Публикация маршрутных политик***
Как говорилось ранее, БД RIPE выполняет в том числе и функции IRR. Здесь, компании, владеющие своими автономными системами и блоками IP-адресов, могут публиковать свои маршрутные политики, тем самым делясь с остальными участниками информацией об их глобальной политике маршрутизации с внешним миром.
***Обеспечение работы механизма DNS reverse lookup***
БД RIPE играет ключевую роль в работоспособности DNS reverse lookup. Мы вернемся к этому вопросу позже.
**Способы взаимодействия с БД RIPE**
Необходимость взаимодействия с БД RIPE у вас может быть по следующим причинам: вы хотите найти какую-то информацию или вы хотите добавить/изменить/удалить какую-то информацию в ней.
Чтобы получить информацию из БД RIPE, можно воспользоваться сервисом whois прямо на [сайте RIPE](https://www.ripe.net/), либо одноименной утилитой, которая присутствует почти во всех дистрибутивах Linux.
Существует 4 способа добавить, изменить или удалить информацию:
1. Webupdates. Это самый простой и интуитивный способ работы с объектами. Вы просто заходите на сайт [RIPE](https://www.ripe.net/), авторизуетесь и с помощью веб-формы выполняете необходимые вам действия с объектами (при условии, что вы авторизованы это делать). Сам процесс выглядит так:
Шаг 1. Заходим в панель управления ресурсами, нажимаем «Create an Object», выбираем тип создаваемого объекта и нажимаем Create.
Шаг 2. В следующем окне заполняем обязательные поля и нажимаем Submit:
Если вы корректно заполнили все обязательные поля для создаваемого объекта, то все пройдет гладко, в противном случае вы увидите сообщение о том, где вы допустили ошибку.
2. По электронной почте.
Вы отправляете письмо на специальный почтовый адрес [auto-dbm@ripe.net](mailto:auto-dbm@ripe.net), в теле письма полностью описываете атрибуты и значения объекта, который вы хотите добавить, изменить или удалить. Сейчас этот способ применяется редко, куда проще воспользоваться другими методами.
3. Syncupdates.
Этот способ позволяет работать сразу с несколькими объектами одновременно. Его можно использовать как в ручном режиме, так и с собственными скриптами. Подробно данный способ описан в официальной документации.
4. RESTful API.
Также работать с объектами в БД RIPE можно с помощью RESTful API. Данный способ удобно использовать для автоматизации каких-то действий с помощью скриптов.
[Подробное описание API можно посмотреть тут.](https://github.com/RIPE-NCC/whois/wiki/WHOIS-REST-API)
Например, мы используем API БД RIPE следующим образом:
У нас есть IPAM система, в которой мы ведем учет всех наших IP-адресов. Когда нам необходимо выделить новую подсеть для клиента, то мы запускаем скрипт, который через API вытаскивает из IPAM первую свободную подсеть необходимого размера, далее через скрипт мы заполняем краткое описание назначения данной подсети. Затем скрипт с помощью API IPAM добавляет данную подсеть в базу IPAM, а с помощью API RIPE создает объект inetnum(6) в базе RIPE. Таким образом, нам не нужно самим заходить в IPAM, искать там свободную подсеть, затем заходить на сайт RIPE и создавать там новый объект вручную.
**Общие свойства всех объектов**
Как говорилось ранее, БД RIPE состоит из объектов. Каждый объект представлен двумя колонками: атрибуты (слева) и фактические значения (справа). Атрибуты всегда заканчиваются двоеточием «:».
Пример объекта, описывающего вымышленную организацию «Sandbox Inc.»:
Объекты имеют обязательные и опциональные атрибуты. Обязательные атрибуты должны присутствовать в каждом объекте соответствующего класса, например, атрибут «org-name:» в объекте «organisation» из примера выше. Некоторые атрибуты могут повторяться.
Для того, чтобы узнать, какие атрибуты объекта обязательные, какие опциональные, какие можно использовать повторно, а какие нет, можно воспользоваться запросом whois -t *object\_type*:
Здесь видно, что атрибут «phone:» является обязательным для объектов типа «role», а атрибут «e-mail:» – опциональным и может повторяться.
Когда вы создаете объект с помощью webupdates, то обязательные атрибуты сразу же отображаются в веб-форме, вам их нужно просто заполнить. Если же вы будете использовать какой-то скрипт для обновления через API, то уже сами должны позаботиться о том, чтобы не забыть указать обязательные атрибуты и их значения. Для этого удобно использовать шаблоны. Например, так может выглядеть шаблон Jinja2, описывающий объект inetnum в формате:
**JSON**
```
{
{
"objects": {
"object": [
{
"source": {
"id": "ripe"
},
"attributes": {
"attribute": [
{
"name": "inetnum",
"value": "{{ inetnum }}"
},
{
"name": "netname",
"value": "{{ netname }}"
},
{
"name": "country",
"value": "RU"
},
{
"name": "admin-c",
"value": "LXDC"
},
{
"name": "tech-c",
"value": "LXDC"
},
{
"name": "status",
"value": "ASSIGNED PA"
},
{
"name": "mnt-by",
"value": "LINXDC-NOC"
},
{
"name": "source",
"value": "RIPE"
}
]
}
}
]
}
}
```
Если вы о чем-то забудете, то при попытке добавить объект в БД RIPE вам вернется код ошибки с описанием причины, по которой операция не может быть выполнена.
Также некоторые атрибуты объекта являются ключами. По ключам осуществляется поиск объектов в БД RIPE. Существует 3 типа ключей:
1. Primary – уникальный ID объекта, однозначно определяет его в БД.
2. Lookup – ключи, по которым объект можно найти в БД.
3. Inverse Lookup – ключи, которые ссылаются на какой-то другой объект. Данный тип ключей используется, когда вы, например, хотите найти все объекты «route», которые зарождаются в какой-то AS. Для этого в запросе whois используется ключ -i. Пример:
Данный запрос находит все объекты класса «route», которые зарождаются в AS48399.
Найти объекты можно только по атрибутам, которые являются ключами, причем в параметрах поиска нужно указать точное значение атрибута. Например, атрибут «aut-num:» объекта «aut-num» является primary ключом. Если вы хотите найти объект «aut-num», который создан для AS48399, то вам нужно указать в запросе именно «as48399», варианты «48399» и «as 48399» не дадут должного результата:
**Назначение объектов**
Объекты по их назначению можно условно разделить на 5 групп:
1. Контактная информация: person, role, organization.
2. Интернет-ресурсы: inetnum, inet6num, aut-num.
3. Маршрутизация, политика маршрутизации: route, route6, as-set, aut-num.
4. Reverse DNS: domain.
5. Безопасность объектов: maintainer.
Далее пройдемся по всем этим объектам, чтобы понять их назначение.
***Группа «Контакты»***
*Объект «person»*
Служит для описания контактной информации конкретного человека, который так или иначе связан с какими-то интернет ресурсами. Другие объекты, например «inetnum», могут ссылаться на объект person в своих атрибутах «admin-c» или «tech-c». Таким образом вы можете узнать контактную информацию человека или группы, которые отвечают за те или иные ресурсы.
В примере выше представлен объект inetnum, который содержит информацию о том, что блок IPv4 адресов 80.12.176.0/22 был выделен организации Sandbox и что в случае возникновения каких-то технических вопросов, связанных с данным блоком адресов, вы можете обращаться к персоне Jean Blue.
Был забавный случай, когда у моего бывшего коллеги раздался неожиданный звонок и человек на том конце трубки, не выбирая выражений, угрожал ему физической расправой. Выяснилось, что ему нагрубил какой-то школьник в онлайн-игре и скинул ему свой IP, который он узнал по запросу «узнать мой IP адрес». Разумеется, школьник сидел за NAT. Наш хакер, недолго думая, вбил другой запрос «узнать кому принадлежит IP» и увидел контактную информацию моего коллеги, которая содержится в RIPE. Пришлось объяснять местному «Кевину Митнику», что это немного не так работает :)
*Объект «role»*
Похож на объект «person», но описывает уже контактную информацию какой-то группы, которая отвечает за определенную роль в организации. Такой группой может быть NOC. Объект «role» – это своего рода контейнер для объектов «person». Например, в организации работают 3 сетевых инженера, вы создаете группу NOC и в атрибутах «tech-c:» указываете ссылки на соответствующие объекты person.
Но также стоит отметить, что атрибуты «admin-c:» и «tech-c:» являются для «role» опциональными, поэтому данный объект может быть самодостаточным, т. е. не ссылаться на объекты «person».
Еще одной важной особенностью объекта «role» является наличие атрибута «abuse-mailbox:». В нем указываются контакты, по котором можно обращаться по вопросам злоупотребления вашими ресурсами. Например, если с принадлежащих вам IP-адресов рассылается спам, то вам скорее всего напишут именно по адресу электронной почты, указанному в данном атрибуте.
С практической точки зрения лучше использовать именно объект «role» вместо «person», особенно, если у вас много сотрудников работают с данными в БД RIPE. Почему? Дело в том, что если вы пытаетесь удалить какой-то объект, но при этом есть объекты, которые на него все еще ссылаются, то вам придется убрать все ссылки на удаляемый объект. А теперь представьте, что у вас 1000 объектов «inetnum», ссылающихся на объект «person», принадлежащий вашему коллеге, который собрался увольняться и больше не отвечает за данные ресурсы. Вам придется во всех 1000 объектах удалить ссылки на него. Кроме того, например, объект «organization» может ссылаться только на объект «role» в своем атрибуте «abuse-c:».
*Объект «organization»*
Во-первых, этот объект, как и объекты «person» и «role», содержит контактную информацию, но уже об организации, которая владеет интернет-ресурсами, например: юридический адрес, телефон и т.д.
Во-вторых, это своего рода контейнер, который связывает все ресурсы организации. Такие объекты, как «inet(6)num» и «aut-num», обязаны иметь атрибут «org:», который указывает на то, какой организации выделены данные ресурсы.
***Группа интернет-ресурсов***
*Объект «aut-num»*
Данный объект создается в базе после того, как RIPE выделит какой-то организации определенный номер AS. Он показывает, кому принадлежит AS, и контактную информацию, по которой вы можете взаимодействовать с теми, кто за данную AS отвечает.
В этом объекте вы можете публиковать свою маршрутную политику.
Для этого используются атрибуты «import:» и «export:», в которых вы указываете, от кого и какие маршруты вы принимаете и кому и какие маршруты анонсируете. Также операторы обычно описывают политику BGP community именно в этом объекте. Для наглядного примера попробуйте поискать в БД RIPE номера AS крупных операторов, например, as8359.
Чтобы лучше понять, как описывается маршрутная политика, рассмотрим следующий пример:
Допустим, что вы являетесь небольшим провайдером, у вас есть 2 аплинка и 3 клиента.
Аплинкам вы анонсируете свои сети и сети ваших клиентов, от аплинков принимаете full view.
Клиентам вы анонсируете full view, а принимаете только префиксы, которые им принадлежат.
Описание маршрутной политики при этом может выглядеть так:
Стоит отметить, что политика может описывать не только то, какие префиксы вы анонсируете или принимаете, но и более сложные сценарии. Например, вы указываете, что на какой-то префикс вы вешаете local preference 200. С помощью набора инструментов IRRToolSet вы можете автоматически создавать конфигурацию маршрутизаторов на основе информации, описанной в объекте «aut-num». Подробнее тут:
<https://github.com/irrtoolset/irrtoolset>
*Объекты «inetnum» и «inet6num»*
Являются одними из самых важных объектов в БД RIPE. Данные объекты содержат информацию о том, кому и как были распределены блоки IP-адресов. Когда RIPE выделяет вам какой-то блок iP-адресов, то в RIPE NCC создается объект «inetnum», указывающий, что этот блок выделен именно вам.
Когда вы далее выделяете из данного блока какой-то кусок под ваши нужды, например, из выделенной вам подсети /22 одну подсеть /24 вы используете под NAT, то вы также создаете объект «inetnum» и даете описание в атрибуте «netname:» – что-то вроде «NAT for users».
Важным атрибутом этих объектов является атрибут «status:». Основные статусы:
ALLOCATED-PA – RIPE NCC выделила блок IPv4 для какой-то организации.
ALLOCATED-BY-RIR – RIPE NCC выделила блок IPv6 для какой-то организации.
ASSIGNED-PA – организация выделила блок IPv4 для каких-то нужд.
ASSIGNED – организация выделила блок IPv6 для каких-то нужд.
***Группа политика маршрутизации***
*Объект «route(6)»*
Это также одни из самых важных объектов в БД RIPE, они связывают AS и зарождающиеся в ней префиксы.
Если вы анонсируете какой-то префикс в Интернет, то вам необходимо создать объект «route» для этого префикса.
Почему важно это делать? Многие провайдеры автоматизируют процесс генерации фильтров BGP, которые вешают на анонсы от своих пиров. Реализуется это, например, с помощью утилиты bgpq3, которая обращается в RIPE и автоматически на основании объектов «route» генерирует соответствующий кусок конфига для создания фильтров. Все те префиксы, которые не описаны в объектах «route», не попадут в конфигурацию, поэтому может возникнуть ситуация, когда из-за этого ваши сети не будут доступны извне. Вам придется обращаться в поддержку вашего аплинка, чтобы он разрешил на своем оборудовании принятие от вас данного префикса или же создать объект route для нового префикса и дождаться следующего запуска скрипта на стороне вашего провайдера.
*Объект «as-set»*
Это очень полезный объект, он помогает упростить процесс обновления маршрутных политик, которые описываются в объекте «aut-num». Объект «as-set» позволяет вам группировать различные AS в один объект. Вернемся к примеру:
Для аплинков у нас описана политика, что мы анонсируем им префиксы от AS500, AS1, AS2, AS3.
При каждом обновлении данной политики вам придется менять информацию для всех аплинков.
Но вы можете поступить иначе: создать объект «as-set» и в его атрибутах «members:» описать номера AS, префиксы которых вы анонсируете, тогда такая политика будет выглядеть так:
Все, что вам нужно будет делать, когда ваша политика меняется, это удалять или добавлять AS из объекта «as-set». Кроме того, атрибут members может ссылаться на другие as-set.
«As-set» часто используется для генерации фильтров. Скажем, клиент может вас попросить настроить фильтры в соответствии с их «as-set», тогда вы опять можете воспользоваться утилитой bgpq3, но указывать уже не номер AS в качестве аргумента, а «as-set». Например:
*Объект «domain»*
Как уже отмечалось ранее, БД RIPE играет ключевую роль в работе reverse DNS lookup.
В противоположность прямому DNS запросу, когда по доменному имени находится соответствующий ему IP-адрес (A запись), обратный запрос, наоборот, ищет доменное имя, которое соответствует IP-адресу (PTR запись). Зачем нужно отображать IP-адреса в доменные имена? В основном это используется как дополнительная защита от спама в электронной почте, также это помогает при устранении неполадок с помощью traceroute, т. к. если для IP-адреса существует PTR запись, то вместо IP в выводе traceroute вы будете видеть более информативные доменные имена.
Объект «domain» указывает DNS серверам RIPE на то, какой сервер отвечает за ту или иную обратную зону. Визуально это можно представить так:
Когда вы получаете какой-то блок IPv4 или IPv6 адресов от RIPE, то вы можете создавать объекты «domain». Например, вы получили блок IPv4 адресов 192.168.0.0/22. Тогда для данного блока вы можете создать объекты «domain», которые будут указывать на ваши DNS сервера, которые являются авторитативными для данных обратных зон. Важно отметить, что объект «domain» может быть создан только для /16 и /24 ipv4 подсетей, поэтому, если у вас есть блок /22, вам придется создать 4 объекта domain для 4х /24 подсетей и, соответственно, 4 обратные зоны на вашем DNS сервере.
***Безопасность объектов***
*Объект «maintainer»*
Теперь, когда мы разобрались с основными объектами, поговорим про безопасность. БД RIPE – это публичная база данных, поэтому очень важно запретить делать что-либо с вашими объектами всем неавторизованным пользователям. Краеугольным камнем в безопасности БД RIPE является объект «maintainer». Это своего рода замок, который вы вешаете на каждый объект, и открыть его может только тот, кто имеет от него ключи. Существует 3 типа таких ключей:
1. Single Sign On (SSO). Самый простой способ, вам просто нужно добавить в объекте «maintainer» атрибут «auth:» с указанием почты сотрудника, с помощью которой он авторизуется на сайте RIPE.
2. MD5 enrypted password.
3. PGP key.
Каждый объект в БД RIPE имеет атрибут «mnt-by:», который ссылается на объект «maintainer». Соответственно, если у вас есть доступ к данному «maintainer», вы можете работать со всеми объектами, которые им защищены.
**Заключение**
Данную статью я готовил на основе материала из официального курса от RIPE, который доступен по адресу <https://academy.ripe.net>. Если вы хотите лучше разобраться в вопросе и попрактиковаться на реальных примерах, то советую его пройти. Курс интерактивный, интересный и бесплатный.
**Полезные запросы whois:**
*whois -t object\_type* – посмотреть шаблон объекта.
*whois -T route -i origin ASxxxxx* – узнать все маршруты, которые происходят из автономной системы.
*whois -i mnt-by maintainer\_name* – узнать все объекты, которые защищены объектом «maintainer\_name».
*whois -M subnet* – узнать, на какие более мелкие подсети поделена подсеть «*subnet».*
*whois -L subnet* – узнать, из какой более крупной подсети образована подсеть «*subnet».*
**Полезные ссылки:**
1. <https://www.ripe.net/manage-ips-and-asns/db/support/documentation/ripe-database-documentation>
2. <https://www.ripe.net/manage-ips-and-asns/db/support/the-ripe-database-business-rules>
3. <http://www.irr.net/docs/list.html> | https://habr.com/ru/post/526508/ | null | ru | null |
# Пишем игру для Android c помощью AndEngine. Часть 3
Всем привет!
Вот и долгоданное продолжение цикла статей о том как создать для андроид ~~не очень~~ простую игру с помощью [AndEngine](http://www.andengine.org/).
Уже ознакомились с предыдущими статьями?
[Часть 1](http://habrahabr.ru/blogs/android_development/120716/)
[Часть 2](http://habrahabr.ru/blogs/android_development/120863/)
Тогда продолжим.
Сегодня мы займемся картой игровых объектов. Что она из себя представляет? Двумерный массив игровых объектов размерами 13х7. Размер немного странный но при размерах клеток 64х64 он начинет казаться вполне логичным.
Шаг 1. Задаем необходимые констаны и поля.
> `public class GameObjectsMap {
>
> public static final int HEIGHT = 7;
>
> public static final int WIDTH = 13;
>
> public static final float CELL\_SIZE\_X = 64f;
>
> public static final float CELL\_SIZE\_Y = 64f;
>
>
>
> public static final int LASER\_LAYER = 0;
>
> public static final int GAME\_OBJECTS\_LAYER = LASER\_LAYER + 1;
>
>
>
> private GameObject[][] mMap = new GameObject[WIDTH][HEIGHT];
>
> private Textures mTextures;
>
> GameObjectsMap(final Textures textures) {
>
> mTextures = textures;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Шаг 2. Добавление объектов.
Для большего удобства нам необходим метод для добавления объектов на поле:
> `public void add(Type type, final int posH, final int posW, final int angle) {
>
> GameObject object = null;
>
> switch (type) {
>
> case lasergun:
>
> object = new LaserGun(posH, posW, angle, mTextures
>
> .getLaserGun());
>
> break;
>
> case mirror:
>
> break;
>
> case target:
>
> break;
>
> default:
>
> break;
>
> }
>
> mMap[posH][posW] = object;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Шаг 3. Отображение объектов.
Enum Type внимательный читатель мог увидеть в предыдущем посте в описании класса GameObject. В метод add мы передаем тип объекта, его позицию и угол поворота, после чего он появляется в нашем массиве, но все еще не отображается. Для отображения игровых объектов нам потребуется следующий метод:
> `public void addToScene(Scene scene) {
>
> for (int i = 0; i < mMap.length; i++) {
>
> for (int j = 0; j < mMap[i].length; j++) {
>
> GameObject o = mMap[i][j];
>
> if (o != null) {
>
> o.attachTo(scene);
>
> }
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Довольно просто. Ну и на всякий случай:
> `public void clear() {
>
> for (int i = 0; i < mMap.length; i++) {
>
> Arrays.fill(mMap[i], null);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь мы можем для добавления объектов на сцену использовать простую и понятную конструкцию типа:
mGameObjectsMap.add(Type.lasergun, 0, 0, 3);
Шаг 4. Обработка прикосновений.
Все таки игру делаем и без взаимодействия с пользователем нам никак нельзя. К сожалению для класса Entity нет стандартных обработчиков, поэтому будем действовать по старинке.
scene.setOnSceneTouchListener(mGameObjectsController);
Где mGameObjectsController реализует интерфейс IOnSceneTouchListener. На самом деле мало чем отличается от обычного OnTouchListener. И в моем случае он выглядит примерно так:
> `public boolean onSceneTouchEvent(final Scene pScene, TouchEvent pSceneTouchEvent) {
>
> if (pSceneTouchEvent.isActionDown()) {
>
> float x = pSceneTouchEvent.getX();
>
> float y = pSceneTouchEvent.getY();
>
> int cellNumX = (int) ((x - x % GameObjectsMap.CELL\_SIZE\_X)
>
> / GameObjectsMap.CELL\_SIZE\_X);
>
> int cellNumY = (int) ((y - y % GameObjectsMap.CELL\_SIZE\_X)
>
> / GameObjectsMap.CELL\_SIZE\_X);
>
> DynamicGameObject object = (DynamicGameObject)mMap.getMap()[cellNumX][cellNumY];
>
> if (object != null) {
>
> //Делаем что угодно с нашим объектом
>
> }
>
> }
>
> return false;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Да, согласен, можно посчитать позицию клетки по другому, но этот вариант работает и он мне нравится.
На сегодня это все. Некоторые мои проекты вы можете найти [здесь](http://bit.ly/j0oz7D). Вопросы, пожелания и конструктивная критика как всегда приветствуются.
P.S. Исходный код все [там](http://sourceforge.net/projects/llogic/) же.
P.P.S. [Продолжение.](http://habrahabr.ru/blogs/android_development/123516/) | https://habr.com/ru/post/123367/ | null | ru | null |
# Пишем приложение для удаленного управления плеером MPV из RetroOrangePi
Многие пользователи медиацентра KODI, входящего в состав RetroOrangePi, наверняка заметили, что там используется внешний плеер MPV, который, в отличии от штатного, имеет поддержку аппаратного декодирования. Это позволяет проигрывать контент 1080P без лагов, однако есть и большая проблема — единственный способ управлять плеером это клавиатура. Более того — у плеера нет даже минимального GUI, так что какой продолжительности фильм вы смотрите, и сколько еще осталось до конца — увы, не узнать.
Я, признаюсь, очень ленивый человек, и таскать за собой еще и клавиатуру, с учетом того, что сам KODI управляется с телефона — очень не удобно. Погуглив пару минут, я с удивлением узнал, что не существует готовых решений для удаленного управления MPV с смартфона. Ну что делать — придется написать самому. Кстати, как оказалось, в центре Витебска купить недорогую беспроводную клавиатуру за 1 час обеденного перерыва — тот еще квест.
MPV поддерживает несколько языков для написания скриптов, один из них Lua. На Гитхабе я нашел проект [mpv-network-commands](https://github.com/iamevn/mpv-network-commands), написанный на Lua и позволяющий управлять минимум функций MPV, при помощи команд, передаваемых посредством UDP. Убедившись, что он работает, я во время обеденного перерыва написал простейшее приложение, которое реализовывало максимально примитивный функционал — по сути, оно позволяло поставить на паузу, запустить воспроизведение с паузы и закрыть плеер.
Выглядело оно примерно так.
Чтобы иметь возможность перематывать видео, а так же видеть прогресс-бар, пришлось модифицировать исходный скрипт, добавив следующую функцию:
```
function send_name()
local title =mp.get_property("media-title");
local length = math.floor(mp.get_property("length"));
local pos=math.floor(mp.get_property("time-pos"));
conn_up:sendto(title.."$"..length.."$"..pos, "192.168.100.168", 756);
end
```
Самое смешное — это то, что код, обрабатывающий входящие данные со стороны телефона, получился куда более громоздким:
**И это еще без кода таймера**
```
thread {
// this thread receives incoming massages from MPV and updates views accordingly to received info
try {
chnl.socket().bind(InetSocketAddress(756))
chnl.configureBlocking(false)
var timerStarted: Boolean = false
var timer = Timer()
while (true) {
var buf = ByteBuffer.allocate(1024)
buf.clear()
var last_pos = ""
if (!timerStarted) {
timer = Timer()
timer.schedule(myTimerTask(textView5, textView6, textView4, seekBar3), 2000, 1000)
//this timer will clear views, if no info received in last 2 seconds
timerStarted = true
}
if (chnl.isOpen) {
if (chnl.receive(buf) != null) {
if (timerStarted) {
timer.cancel()
timerStarted = false
}
var data_length = buf.position()
buf.flip()
var str = String(buf.array(), 0, data_length, UTF_8)
Log.d("received data", str)
val arr = str.split("$")
if (arr.size >= 3) {
media_length = arr[1].toInt()
runOnUiThread {
if (textView4.text != arr[0]) textView4.text = arr[0]
if (last_pos != arr[1]) {
last_pos = arr[1]
textView6.text = convertSecsToFullTime(last_pos)
}
if (!blockview) {
textView5.text = convertSecsToFullTime(arr[2])
seekBar3.max = arr[1].toInt()
seekBar3.progress = arr[2].toInt()
}
}
}
}
}
}
} catch (e: Exception) {
runOnUiThread {
Toast.makeText(this, e.message, Toast.LENGTH_SHORT).show()
}
Log.d("In MPVremote", e.message.toString())
}
}
```
В результате получилось вот это:
Исходные коды, а также apk, лежат на [Гитхабе](https://github.com/uBiWca/MPVremote).
Сразу предупреждаю — ~~могут быть~~ точно есть баги.
Основной недостаток — требуется фиксированный IP для телефона в вашей локальной сети, в которой работает OrangePi. Он необходим, что бы скрипт знал, куда ему отправлять инфу о воспроизводимом файле. Самый простой способ — в настройках DHCP сервера вашего роутера указать выдавать один и тот же IP устройствам с МАК-адресом телефона.
Также нет никаких элементов безопасности — любой пользователь в вашей сети сможет поставить видео на паузу или закрыть плеер, зная IP медиацентра. Правда, узнать что воспроизводится и воспроизводится ли вообще — нет.
Кстати, использование обмена данными через UDP безо всяких подтверждений порождает побочный эффект — поскольку прием входящих данных от плеера крутится в отдельном потоке, то вы можете ставить/снимать паузу и закрывать плеер, даже если не указали серверному скрипту правильный IP вашего телефона. Главное, что бы вы знали IP вашего медиацентра.
**Установка**
Перейдите в Desktop RetroOrangePi. Сначала надо установить Lua и LuaSocket.
```
sudo apt-get install lua5.1 luasocket
```
Затем перейдите в директорию /home/pi/.config/mpv/ и создайте там директорию lua.
В lua скопируйте server.lua.
Откройте server.lua тем же nano и в строке
```
conn_up:sendto(title.."$"..length.."$"..pos, "192.168.100.168", 756);
```
замените IP адрес на адрес вашего телефона.
Сохраните и перезагрузите OrangePi.
Установите приложение на телефон. Собранный apk лежит на Гитхабе. Запустите его, перейдите в Settings. Задайте там IP вашего медиацентра и порт 755. Нажмите Save.
Всё, можно пользоваться. | https://habr.com/ru/post/423765/ | null | ru | null |
# Ущербно-ориентированное программирование
Ущербно-ориентированное программирование — это набор подходов, поощряющий повторное использование кода и гарантирующий долгосрочное использование производимого программистами кода в боевых системах. Количество строк кода является повсеместно применяемым показателем значимости приложения, а количество строк, которые программист пишет за рабочий день — полезная метрика, применяемая при планировании проектов и распределении ресурсов. Ущербно-ориентированное программирование — это один из наиболее эффективных способов получить наиболее объемный исходник в кратчайшие сроки.
> ***[Ущербный](http://ru.wiktionary.org/wiki/%D1%83%D1%89%D0%B5%D1%80%D0%B1%D0%BD%D1%8B%D0%B9)** — имеющий изъян, неполноценный. Вредный, недостаточный.*
>
>
Наследование
------------
Наследование — это способ получить возможности старого кода в новом коде. Программист *наследуется* от существующей функции или блока кода, копируя этот кусок к себе и внося правки. Унаследованный код, как правило, *конкретизируется* под новые нужды с помощью возможностей, которые не поддерживал старый код. В таком смысле, старый код остается нетронутым, но новый *наследуется* от него.
Программы, в которых используется наследование, можно определить по большому числу практически одинаковых фрагментов кода, которые все же содержат небольшие различия. Другим признаком наследования можно считать статические поля — переменные и блоки кода, которые нигде напрямую не используются, но служат связующим звеном между новым кодом и старым.
Пример наследования в виде псевдокода:
```
function getCustName(custID)
{
custRec = readFromDB("customer", custID);
fullname = custRec[1] + ' ' + custRec[2];
return fullname;
}
function getCustEmail(custID)
{
custRec = readFromDB("customer", custID);
fullname = custRec[1] + ' ' + custRec[2];
/***************
* 4/15/96 git : адрес email хранится
* во втором поле для факса
***************/
return custRec[17];
}
```
Функция `getCustEmail` была *унаследована* от функции `getCustName`, когда в приложении появилась поддержка email-адресов. Наследование кода подобным образом позволяет избежать случайного введения в программу новых багов.
*Полиморфизм типов* — один из типов наследования. В нем при наследовании кода заменяются типы исходных переменных.
Модульность
-----------
Модульная программа разделяется на несколько файлов, у которых общая шапка с комментариями. В модуль обычно включается:
* Копирайт
* Отказ от ответственности
* От трех до пяти строк со звездочками
* История изменений
* Описание того, что модуль изначально должен был делать
* Еще три — пяти строк со звездочками
* Большой блок с пробелами и пустыми строками, окруженный звездочками или другими символами, в котором перечислены названия всех функций, имя или инициалы автора, а также дата написания
* Код
Размер модулей обычно стараются держать в разумных пределах, чтобы снизить *связность* и улучшить *мощность*. Если модуль становится слишком крупным — его можно поделить на несколько частей, копируя в каждую копирайт, отказ от ответственности и прочее. Комментарии всегда можно наследовать без опасений, поэтому лучше всего перенести в отпочковавшийся модуль *все* исходные комментарии.
Компоненты и библиотеки
-----------------------
В ущербно-ориентированном программировании повсеместно используются плагины и компоненты — куски кода, найденные в интернете или книгах. Гугление позволяет смекалистому программисту сэкономить уйму времени благодаря тому, что уже есть написанные заранее компоненты практически для чего угодно. Самые лучшие среди них — это черные ящики: программисту не нужно знать или думать о том, как компонент работает. Множество крупных приложений написаны с применением наследования из других приложений и компонентов, найденных в сети.
Инкапсуляция
------------
Суть инкапсуляции заключается в отделении данных от кода. Иногда этот подход также называется *сокрытием данных*, но данные на самом деле не скрываются — они размещаются в дополнительном слое кода. Например, когда в коде повсюду запросы к базе данных — это плохая практика. Ущербно-ориентированный подход предполагает написать обертки для этих функций, тем самым *инкапсулировав* базу данных. В методе `getCustName`, представленном выше, обращение к базе данных идет не напрямую, а через такую специальную обертку, считывающую одну запись. Оба этих метода (а также еще множество аналогичных им) «знают», где в записи о клиенте есть необходимые им данные. Способ считывания записи из базы `инкапсулирован` в каком-нибудь другом модуле.
В некоторых языках программирования поля можно помечать модификаторами `private`, `public` или `protected`. Это не имеет ничего общего с ущербно-ориентированным подходом. Автор модуля никак не может знать, какие внутренние переменные из его модуля потребуются для реализации требуемого функционала в будущем! Поэтому все поля следует делать публичными, а переменные — глобальными, и пусть внешний код сам решает, что трогать, а что нет.
Полиморфизм
-----------
Во время изучения ущербно-ориентированного подхода концепция полиморфизма вызывает проблемы у многих программистов. Однако идея проста и реализуется очень легко. Полиморфный код — это код, у которого формат или содержание выходных данных варьируется в зависимости от входных.
Например, функции выше можно переписать в одну полиморфную функцию, используя наследование и полиморфизм:
```
function getCustData(custId, what)
{
if (what == 'name') {
custRec = readFromDB("customer", custId);
fullname = custRec[1] + ' ' + custRec[2];
return fullname;
} else if (what == 'email') {
custRec = readFromDB("customer", custId);
fullname = custRec[1] + ' ' + custRec[2];
/***************
* 4/15/96 git : адрес email хранится
* во втором поле для факса
***************/
return custRec[17];
}
/* ... и так далее. */
}
```
Полиморфизм также связан с *недетерминированными конечными автоматами Тьюринга*, которые вы можете помнить из курса информатики.
"Является" против "содержит"
----------------------------
В этом заключается тонкость хорошего ущербно-ориентированного дизайна. Программисты-новички нередко злоупотребляют наследованием (модель «является»), в то время как с приходом опыта становится понятно, что во многих местах отношение «содержит» более уместно. В примере выше, информация о каждом клиенте *содержит* имя, в то время как custRec *является* записью в базе данных.
Виртуальные классы и функции
----------------------------
Виртуальный класс или функция — это код, который понадобится в программе в будущем, однако пока еще не написан. Как правило, это реализуется посредством базового класса, на котором будет основан финальный код.
```
function calcSalesTax(price, isTaxable, state)
{
/****************************************
*
* TO DO:
*
* получать тариф для пользователя
* из какой-нибудь таблицы, когда ее сделают
*
*
****************************************/
/** 02/07/99 git -- пока возьмем такой тариф **/
return price * (7.25 / 100.0);
}
```
*Хрупкий базовый класс* — это класс или модуль, существующий в проекте долгое время, любые изменения в котором ломают все приложение целиком.
Перегрузка
----------
Перегрузка — это подход, когда один модуль или блок кода выполняет больше одной задачи. Например, функция, которая возвращает имя пользователя, его email и государственный налог на добавленную стоимость. Перегруженные функции позволяют сэкономить на *диспетчеризации методов*, которая зачастую является причиной медленно работающего кода, написанного с использованием других подходов.
Документация
------------
Авторитеты утверждают, что код нужно писать так, чтобы его было легко читать. Отсюда следует вывод, что документацию следует писать наименее читаемым образом. Ее следует вести для каждого нового модуля и актуализировать по мере введения изменений в боевой код — ну, или хотя бы когда будет особо нечем заняться.
Отличное время заняться документацией — это когда кто-либо подает заявление об увольнении. за две недели, которые сотруднику полагается отработать, было бы неплохо написать документацию по всему разработанному им коду.
Забивание кода комментариями, объявляющими механизмы его работы, отвлекает внимание и замедляет компиляцию. Поэтому программисты, которые следуют «лучшим практикам» ущербно-ориентированного программирования хранят документацию в системе учета документооборота — чтобы программисты не могли ее случайно затереть.
Управление версиями
-------------------
Это, конечно, не то чтобы практика программирования, но последователи ущербно-ориентированного подхода ее применяют. Хранение предыдущих версий и истории изменений под рукой важно, даже если над проектом работает один человек. Опытные ущербно-ориентированные программисты придерживаются следующих правил:
* Всегда добавляйте ваши инициалы и дату последнего изменения в заголовок файла
* Если вы трогаете файл и понимаете, что изменения будет сложно откатить, сохраните копию с расширением `.bak`.
* Храните несколько копий кода, приписывая к имени файла ваши инициалы и дату изменения. Например: `custdata_git20040321.bak`.
* Всегда храните бэкапы в той же папке, что и оригинальные файлы, чтобы историю изменений было легче и удобнее отследить.
Заключение
----------
Вы наверняка заметите, что многие предприятия следуют некоторым (или даже всем) практикам ущербно-ориентированного программирования. Новомодные течения типа гибких или экстремальных методологий приходят и уходят, но ущербно-ориентированное программирование прошло испытание временем. Менеджеры всегда в курсе ущербно-ориентированного подхода и ожидают, что вы сможете работать с проектами, написанными в таком стиле.
*От переводчика: хоть статья и 2007 года, но актуальности не потеряла. Спасибо [vovochkin](https://habrahabr.ru/users/vovochkin/) за ссылку в статье "[Как разрабатывать неподдерживаемое ПО](http://habrahabr.ru/post/203628/)".* | https://habr.com/ru/post/203646/ | null | ru | null |
# Логгирование приложения на C# в базу данных FireBird Embedded с помощью NLog 2.0
Приступая к своему первому десктопному приложению на С#, я задался вопросом ведения логов. Изучив предложения по данной теме, за хорошие отзывы и отсутствие платы за использование, мой выбор пал на NLog 2.0. После чтения документации на сайте, а также местных статьей, я легко настроил вывод отладочной информации в текстовый файл. Но пытливый ум на месте не стоит, и так как в моем приложении используется база данных FireBird Embedded, то я решил настроить логгирование в нее. Вот тут я и получил пазл длиной в 5 часов. Информации по настройке NLog для FireBird (Embedded или нет не играет большой роли) практически нет, а та которая есть, относится с более ранним версиям NLog и уже потеряла актуальность. Засучив рукава и запасшись кефиром, я принялся преодолевать это препятствие, чему и посвящена данная статья.
Хочу отметить, что статья не затрагивает подключение провайдера FireBird .Net к проекту, а так же начальную установку NLog.
Настройка NLog заключается в правильной конфигурации файла NLog.config, который представляет собой XML-файл. На первых парах я столкнулся с проблемой, что после включения системы логгирования проект просто перестал запускаться, заваливаясь на инициализации главной формы приложения. Виной этому оказался плохо сконфигурированный мной NLog. Чтобы упростить себе задачу и сэкономить нервы, необходимо добавить две строки в конфигурационный файл:
`throwExceptions="true"
internalLogFile="file.txt"`
При следующем запуске приложения, в папке с исполняемым файлом будет создан file.txt, который содержит довольно подробный лог самой системы NLog и позволит отловить ошибки конфигурации.
Настройка «приемника» логов заключается в тег «target». Самым сложным было получить 3 вещи:
1) Имя провайдера СУБД с его токеном
2) Строку подключения к БД
3) Запрос к БД и его параметры
Первый пункт удалось преодолеть с помощью гугла. Но со вторым и третьим пунктом было сложнее. Строку подключения я получил из моего приложения, которое, на основании других мануалов уже могло подключаться к базе FireBird. Запрос и его параметры я разобрал с помощью не совсем научного метода «тыка». Чтобы не томить, сразу приведу работающий конфиг «приемника»:
``> <target
>
> xsi:type="Database"
>
> name="db"
>
> dbProvider="FirebirdSql.Data.FirebirdClient.FbConnection, FirebirdSql.Data.FirebirdClient, Version=2.6.5.0, Culture=neutral, PublicKeyToken=3750abcc3150b00c"
>
> useTransactions="true"
>
> connectionString="server type=Embedded;initial catalog=FYT.FDB;character set=WIN1251;dialect=3;client library=fbembed.dll;user id=SYSDBA;password=masterkey"
>
> keepConnection="true"
>
> commandText="INSERT INTO logs (DT, LOG\_TEXT, LEVEL\_ID, CLASS, STACK\_TRACE) values (@DT, @LOG\_TEXT, @LEVEL\_ID, @CLASS, @STACK\_TRACE);">
>
> <parameter layout="${longdate}" name="@DT" />
>
> <parameter layout="${level}" name="@LEVEL" />
>
> <parameter layout="${message}" name="@LOG\_TEXT" />
>
> <parameter layout="${logger}" name="@CLASS" />
>
> <parameter layout="${stacktrace}" name="@STACK\_TRACE" />
>
> target>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**dbProvider** – это имя провайдера FireBird .NET, которое соответствует его текущей официальной версии 2.6.5. Для будущих версий нужно будет только поменять циферки, Токен (PublicKeyToken=3750abcc3150b00c) должен остаться тот же.
**connectionString** – строка подключения. По большому счету, когда она сформирована, то понять и поменять в ней что-то под себя не составит никакого труда. В данном примере подключение настроено на сервер FireBird Embedded, базу FYT.FDB, которая лежит в каталоге с исполняемым файлом. Для FireBird Classic или SuperServer нужно только поменять “server type” и “client library”.
**commandText** – запрос на вставку данных в базу. Параметры, которые передаются логгером, отмечаются «собакой», т.е. @. Ниже, атрибуты в тегах «parameter» показывают NLog то, чем нужно подменять каждый параметр в запросе. Список всех доступных параметров замены (layout) можно найти на сайте NLog.
В заключение, приведу полный листинг конфигурационного файла NLog.config:
``> </fontxml version="1.0" encoding="utf-8" ?>
>
> <nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
>
> xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
>
> throwExceptions="true"
>
> internalLogFile="file.txt">
>
>
>
> <targets>
>
> <target
>
> xsi:type="Database"
>
> name="db"
>
> dbProvider="FirebirdSql.Data.FirebirdClient.FbConnection, FirebirdSql.Data.FirebirdClient, Version=2.6.5.0, Culture=neutral, PublicKeyToken=3750abcc3150b00c"
>
> useTransactions="true"
>
> connectionString="server type=Embedded;initial catalog=FYT.FDB;character set=WIN1251;dialect=3;client library=fbembed.dll;user id=SYSDBA;password=masterkey"
>
> keepConnection="true"
>
> commandText="INSERT INTO logs (DT, LOG\_TEXT, LEVEL\_ID, CLASS, STACK\_TRACE) values (@DT, @LOG\_TEXT, @LEVEL\_ID, @CLASS, @STACK\_TRACE);">
>
> <parameter layout="${longdate}" name="@DT" />
>
> <parameter layout="${level}" name="@LEVEL" />
>
> <parameter layout="${message}" name="@LOG\_TEXT" />
>
> <parameter layout="${logger}" name="@CLASS" />
>
> <parameter layout="${stacktrace}" name="@STACK\_TRACE" />
>
> target>
>
> targets>
>
>
>
> <rules>
>
> <logger name="\*" minlevel="Debug" writeTo="db" final="true"/>
>
> rules>
>
> nlog>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Спасибо за внимание! Надеюсь, моя статья поможет вам не тратить 5 часов на настройку системы ведения логов в БД FireBird!`` | https://habr.com/ru/post/133763/ | null | ru | null |
# Избавляемся от «vk.com/away.php» или переход по ссылкам здорового человека
Переходя по ссылкам, размещенным во Вконтакте, можно заметить, что как и в остальных социальных сетях, сначала происходит переход на «безопасную» ссылку, после чего социальная сеть решает: нужно ли пускать пользователя дальше или нет. Большинство внимательных людей замечали пол-секундное появление «vk.com/away.php» в адресной строке браузера, но, конечно, не придавали этому значения.
Предыстория
-----------
Однажды, некий программист, доделав очередной проект, осознал, что одержим желанием о нём всем рассказать. Проект размещался на сервере с уникальным IP, но без доменного имени. Поэтому на скорую руку был сделал красивый поддомен третьего уровня в домене .ddns.net, который в итоге использовался в качестве ссылки.
Вернувшись через некоторое время к посту, программист обнаружил, что вместо сайта открывается заглушка вк, осведомляющая о переходе на небезопасный сайт:
Казалось бы, умные пользователи сами вправе решать, на какой сайт им переходить, а на какой нет, однако Вконтакте думает иначе и не предоставляет никакой возможности без костылей перейти по ссылке.
Что не так
----------
У такой реализации есть несколько весомых недостатков:
* **Отсутствие возможности открыть подозрительный сайт.** Как говорилось выше, у пользователя нет возможности преодолеть заглушку. Единственный способ открыть ссылку — скопировать ее и вставить в адресную строку.
* **Замедляет переход по ссылке.** Скорость перенаправления зависит от пинга. Соответственно при большом пинге, могут пропасть драгоценные секунды жизни, что, как мы знаем, не допустимо.
* **Мониторинг переходов.** Такой метод облегчает сбор информации о действиях пользователей, чем конечно же и пользуется Вк, добавляя к безопасной ссылке id поста с которого был сделан переход.
Освобождаем Джанго
------------------
Оптимальным решением всех выше перечисленных проблем может стать расширение для браузера. По очевидным причинам выбор падает на Chrome. На хабре есть отличная [статья](https://habr.com/ru/post/198652/) статья посвященная написанию расширений для Сhrome.
Для создания такого расширения нам понадобится создать в отдельной папке два файла: json-Manifest и JavaScript-файл для мониторинга текущего url адреса.
#### Создаем Manifest файл
Главное что нам нужно — дать расширению разрешение на работу с вкладками и назначить исполняемый скрипт:
```
{
"manifest_version": 2,
"name": "Run Away From vk.com/away",
"version": "1.0",
"background": {
"scripts": ["background.js"]
},
"permissions": ["tabs"],
"browser_action": {
"default_title": "Run Away From vk.com/away"
}
}
```
#### Создаем js файл
Здесь всё просто: в событие, вызываемое при создании новой вкладки, добавляем проверку на url адрес, если он начинается на «[vk.com/away.php](https://vk.com/away.php)», то заменяем его на правильный, который находится в GET-запросе:
```
chrome.tabs.onCreated.addListener( function (tabId, changeInfo, tab) {
chrome.tabs.query({'active': true, 'lastFocusedWindow': true}, function (tabs) {
var url = tabs[0].url;
if (url.substr(0,23) == "https://vk.com/away.php"){
var last = url.indexOf("&", 0)
if(last == -1)last = 1000;
var url = decodeURIComponent(url.substr(27, last-27));
chrome.tabs.update({url: url});
}
});
});
```
#### Собираем расширение
Убедившись что оба файла лежат в одной папке, открываем Chrome, выбираем вкладку расширения и нажимаем «Загрузить распакованное расширение». В открывшемся окне выбираем папку написанного расширенная и нажимаем собрать. Готово! Теперь все ссылки вида vk.com/away заменяются на исходные.
Вместо заключения
------------------
Конечно, такой тип заглушек спас много людей от миллионов мошеннических сайтов, однако, я считаю, что люди сами в праве решать, переходить им на небезопасную ссылку или нет.
Для удобства я разместил проект на [github](https://github.com/M2000h/RunAwayFrom-vk.com.away). | https://habr.com/ru/post/453904/ | null | ru | null |
# Kali Linux: виды проверок информационных систем
→ Часть 1. [Kali Linux: политика безопасности, защита компьютеров и сетевых служб](https://habrahabr.ru/company/ruvds/blog/338338/)
→ Часть 2. [Kali Linux: фильтрация трафика с помощью netfilter](https://habrahabr.ru/company/ruvds/blog/338480/)
→ Часть 3. [Kali Linux: мониторинг и логирование](https://habrahabr.ru/company/ruvds/blog/338668/)
→ Часть 4. [Kali Linux: упражнения по защите и мониторингу системы](https://habrahabr.ru/company/ruvds/blog/338668/)
→ Часть 5. [Kali Linux: оценка защищённости систем](https://habrahabr.ru/company/ruvds/blog/339312/)
Продолжаем публикацию перевода 11-й главы книги «[Kali Linux Revealed](https://kali.training/introduction/kali-linux-revealed-book/)». Сегодня хотим познакомить вас с разделом 11.2, который посвящён видам мероприятий, направленных на оценку защищённости информационных систем.
[](https://habrahabr.ru/company/ruvds/blog/339636/)
11.2. Виды мероприятий по оценке защищённости информационных систем
-------------------------------------------------------------------
После того, как ваша ОС готова к работе, пришло время точно определить то, какое именно исследование вы собираетесь провести. В целом, можно выделить четыре вида подобных исследований:
* Оценка уязвимости систем;
* Оценка систем на соответствие стандартам безопасности;
* Традиционное тестирование на проникновение в систему;
* Исследование приложений.
Конкретное задание на исследование системы может включать в себя различные элементы каждого вида. Мы полагаем, что стоит рассказать о них подробнее и раскрыть их связь с Kali Linux и с рабочим окружением.
Прежде чем переходить к описанию конкретных видов мероприятий по оценке защищённости систем, расскажем о том, чем уязвимости отличаются от эксплойтов.
Уязвимость можно определить как дефект информационной системы, воспользовавшись которым можно нарушить её конфиденциальность, целостность или доступность. Существуют различные виды уязвимостей, с которыми можно столкнуться. Вот некоторые из них:
* Уязвимость к [включению файлов](https://en.wikipedia.org/wiki/File_inclusion_vulnerability). Этот класс уязвимостей позволяет злоумышленнику включать локальные или удалённые файлы в процесс выполняемых программой вычислений. Например, у веб-приложения может быть функция «Сообщение дня», которая читает содержимое некоего файла и включает его в веб-страницу для того, чтобы показать пользователям. Если при разработке подобной функции были допущены ошибки, она может позволить злоумышленнику модифицировать выполняемый им запрос к сайту таким образом, чтобы веб-приложение, вместо полезного файла, подключило к странице файл, подготовленный атакующим.
* Возможность SQL-инъекции. Атака уязвимого приложения методом [SQL-инъекции](https://en.wikipedia.org/wiki/SQL_injection) представляет собой ситуацию, когда атакующий обходит подсистемы проверки данных, вводимых пользователями. Это позволяет ему вводить собственные SQL-команды, которые будет выполнять атакованная система. Подобное может привести к проблемам в области безопасности.
* Возможность [переполнения буфера](https://en.wikipedia.org/wiki/Buffer_overflow). Это уязвимость, которая позволяет атакующему обойти подсистемы контроля ввода и записать данные в область памяти, которая соседствует с памятью, выделенной для некоего буфера. В некоторых случаях области памяти рядом с буфером могут быть чрезвычайно важны для обеспечения работоспособности атакуемой программы. При правильной манипуляции данными, хранящимися в этих областях, можно получить контроль над выполнением кода приложения.
* Подверженность системы [состоянию гонки](https://en.wikipedia.org/wiki/Race_condition). Это уязвимость, эксплуатация которой основана на использовании временных зависимостей в программах. В некоторых случаях рабочий процесс приложения зависит от выполнения неких действий в определённой последовательности. Если изменить эту последовательность событий, программу можно сделать уязвимой.
Эксплойт, с другой стороны, это программа, которая, если её применить, может воспользоваться конкретной уязвимостью, хотя и не все уязвимости можно эксплуатировать таким образом. Так как эксплойт должен изменить выполняющийся процесс, принуждая его к выполнению непредусмотренных действий, создание эксплойтов может оказаться сложной задачей. Более того, в современных вычислительных платформах имеется целый ряд технологий противодействия эксплойтам, усложняющих их разработку. Среди таких технологий — предотвращение выполнения данных ([Data Execution Prevention](https://en.wikipedia.org/wiki/Executable_space_protection#Windows), DEP) и рандомизация размещения адресного пространства ([Address Space Layout Randomization](https://en.wikipedia.org/wiki/Address_space_layout_randomization), ASLR). Однако, если для некоей уязвимости не удаётся обнаружить общедоступный эксплойт, это ещё не значит, что подобного эксплойта не существует, а также то, что его нельзя создать. Например, многие организации продают специально разработанные эксплойты, которые не попадают в общий доступ. Поэтому все уязвимости следует рассматривать как потенциально подверженные эксплуатации.
Теперь поговорим о различных видах мероприятий по оценке защищённости систем.
11.2.1. Оценка уязвимости систем
--------------------------------
Напомним, что уязвимостью считается дефект информационной системы, который может быть каким-то образом использован для нарушения её конфиденциальности, целостности или доступности. При проведении оценки уязвимости систем вашей целью является создание перечня уязвимостей, обнаруженных в целевом окружении. Понятие «целевое окружение» очень важно при оценке защищённости систем. Вы не должны пересекать оговоренные с клиентом границы. Это означает — проводить работы в пределах целевой сети и не отклоняться от целей исследования. Выход за пределы исследуемого окружения, границы которого согласованы с клиентом, может привести к нарушению работы служб клиента, к потере его доверия, или к судебному иску против вас и вашего работодателя.
Исследование уязвимостей систем, благодаря его простоте, часто выполняется на регулярной основе в достаточно зрелых окружениях. Делается это в рамках демонстрации уровня их защищённости или их соответствия неким стандартам безопасности.
В большинстве случаев автоматические инструменты, вроде тех, что можно найти в группах [Vulnerability Analysis](http://tools.kali.org/category/vulnerability-analysis) и [Web Applications](http://tools.kali.org/category/web-applications) на сайте Kali Tools, или в соответствующих разделах меню Applications (Приложения) на рабочем столе Kali, используются для обнаружения работающих в целевом окружении компьютеров, для идентификации служб, прослушивающих некие порты и их анализа. Делается это для сбора как можно большего количества информации о системе. В эту информацию входят сведения об аппаратных платформах и ПО серверов, версиях операционных систем и приложений, и другие сведения.
Затем собранную информацию проверяют на известные сигнатуры уязвимостей. Эти сигнатуры состоят из комбинаций фрагментов данных, которые позволяют распознать известные проблемы в области безопасности. Здесь используется как можно больше сведений, так как чем больше их будет — тем точнее окажется идентификация уязвимости. Существует множество показателей, представляющих интерес при анализе уязвимостей систем. Среди них можно отметить следующие:
* Версия операционной системы. Нередко бывает так, что некое приложение уязвимо в одной версии ОС, но в другой данной уязвимости нет. Именно поэтому сканер попытается определить, как можно точнее, на какой версии операционной системы работает целевое приложение.
* Уровень патча ОС. Часто выходят патчи для операционных систем, при установке которых версия ОС не меняется, хотя при этом известные уязвимости либо исчезают, либо начинают вести себя не так, как раньше.
* Архитектура процессора. Существует множество приложений, доступных для разных процессорных архитектур, таких, как Intel x86 и Intel x64, для различных версий ARM, для UltraSPARC, и так далее. В некоторых случаях уязвимость существует только на конкретной архитектуре, поэтому знание архитектуры процессора может сыграть важную роль при формировании точной сигнатуры уязвимости.
* Версия программного обеспечения. Версия целевого программного обеспечения — один из основных показателей, который нужно получить для идентификации уязвимости.
После сбора информации эти, и многие другие показатели, будут использованы для формирования сигнатур уязвимостей. Вполне ожидаемо то, что чем больше фрагментов данных совпадут с сигнатурой, тем увереннее можно говорить об обнаруженной уязвимости.
Занимаясь сопоставлением собранных данных с сигнатурами, можно получить разные результаты:
* Положительный результат. Сигнатура соответствует профилю уязвимости, уязвимость в системе обнаружена. Получив подобный результат, нужно заняться источником проблемы и исправить уязвимость, так как это — именно то, чем может воспользоваться злоумышленник для того, чтобы навредить исследуемой организации.
* Ложноположительный результат. В ходе анализа удалось обнаружить совпадение с сигнатурой уязвимости. Однако, то, что найдено, уязвимостью не является. Подобные результаты обычно считают «информационным шумом», они усложняют работу. Для того, чтобы чётко разделить истинные и мнимые уязвимости, требуется более глубокий анализ ситуации.
* Отрицательный результат. После сканирования системы совпадений с известными сигнатурами уязвимостей обнаружить не удалось, следовательно, уязвимости в системе нет. Это идеальный сценарий, доказывающий отсутствие известных уязвимостей в целевой системе.
* Ложноотрицательный результат. Совпадения с сигнатурами найти не удалось, но уязвимость в системе имеется. В получении ложноположительных результатов нет ничего хорошего, но вот ложноотрицательный результат — это гораздо хуже. В подобной ситуации у исследователя нет признаков наличия уязвимости, так как сканер её не находит, но, на самом деле, проблема существует.
Несложно понять, что для обеспечения надёжных результатов сканирования системы чрезвычайно важна точность сигнатур. Чем больше данных удаётся собрать — тем выше качество результатов автоматического сканирования, основанного на сигнатурах. Именно поэтому весьма популярно сканирование с предварительной аутентификацией в системе.
При таком подходе сканирующее ПО использует предоставленные специалисту данные для аутентификации в целевой системе. Это даёт возможности по анализу данных, недоступные в других условиях. Например, при обычном сканировании реально получить лишь информацию о системе, которую можно извлечь из анализа служб, которые доступны извне, и из анализа предоставленного ими функционала. Иногда и такое сканирование позволяет собрать немало данных. Но эти сведения не идут ни в какое сравнение с тем, что можно узнать о системе, войдя в неё и и тщательно проанализировав всё установленное ПО, применённые патчи, исполняющиеся процессы, и так далее. Сбор столь обширных данных о системе полезен для нахождения уязвимостей, которые, в противном случае, могли бы остаться необнаруженными.
Хорошо проведённое исследование уязвимостей даёт отчёт о потенциальных проблемах и показатели, которые можно использовать для анализа изменения ситуации во времени. Это — довольно простое исследование, но даже учитывая это, многие организации регулярно проводят автоматическое сканирование уязвимостей. Делается это обычно в часы минимальной нагрузки на системы, так как сканирование может потребовать немалых сетевых и серверных ресурсов и помешать обычной работе организации.
Как уже было сказано, в ходе сканирования систем на наличие уязвимостей необходимо проверить множество различных фрагментов данных для того, чтобы получить точные результаты. Все эти проверки могут создать нагрузку на целевую систему и на сеть. К сожалению, сложно заранее узнать то, сколько ресурсов будет потреблено, так как это зависит от количества запущенных служб и типов проверок, которые будут связаны с этими службами. Сканирование потребляет системные ресурсы, поэтому, при использовании соответствующих инструментов, важно представлять себе то, какую нагрузку они могут создавать на исследуемые системы и сети.
> ### ▍Многопоточное сканирование
>
>
>
> Большинство сканеров уязвимостей поддерживают настройку количества потоков, выделяемых на выполнение задачи сканирования. Речь идёт о том, сколько проверок будет выполняться одновременно. Увеличение числа потоков сканирования приводит к росту нагрузки на компьютер исследователя, на сеть, на целевые системы. Заманчиво ускорить сканирование за счёт увеличения числа потоков, но важно помнить о том, что это может привести к существенному росту нагрузки на системы.
Когда проверка завершена, обнаруженные уязвимости обычно связывают со стандартными идентификаторами, такими, как [номера CVE](https://cve.mitre.org/), [EDB-ID](https://www.exploit-db.com/about/), или коды классификации уязвимостей, принятые у поставщиков инструментов сканирования. Эта информация, вместе со сведениями об оценке уязвимостей по методике [CVSS](https://www.first.org/cvss), используется для определения уровня риска. Все эти сведения, с учётом ложноположительных и ложноотрицательных сообщений об уязвимостей, дают общее представление об уязвимостях, которые нужно учитывать, анализируя результаты сканирования.
Так как автоматизированные средства используют для выявления уязвимостей базы данных сигнатур, малейшее отклонение от известной сигнатуры может изменить результат, и, соответственно, обоснованность сообщений об обнаруженных уязвимостях.
Ложноположительные результаты указывают на то, чего нет, а ложноотрицательные, наоборот, скрывают существующие проблемы. Поэтому качество и возможности автоматических сканеров уязвимости напрямую зависят от применяемых ими баз данных сигнатур. Как правило, поставщики подобного ПО предлагают разные версии своих программ. Одни их них — бесплатные, снабжённые урезанными базами данных, предназначены для домашних пользователей. Другие — достаточно дорогие, с полноценными базами, обычно ориентированы на корпоративный сектор.
Ещё одна проблема, которая часто возникает при сканировании на наличие уязвимостей, заключается в пригодности к использованию предложенных рейтингов риска. Эти рейтинги определяют на универсальной основе, принимая во внимание множество различных факторов, таких, как уровень привилегий, тип программного обеспечения, возможность реализации уязвимости до или после аутентификации. Подобные рейтинги нельзя использовать бездумно, так как их ценность зависит от особенностей исследуемой системы. Качественно оценить уровень риска можно только пользуясь теми рейтингами, которые основаны на анализе подробной информации о системе и обнаруженных в ней уязвимостях.
Не существует единого общепринятого соглашения о рейтингах рисков, однако, можно порекомендовать взять за основу оценки рисков в исследуемой среде стандарт [NIST SP 800-30](http://csrc.nist.gov/publications/PubsSPs.html#800-30). NIST SP определяет реальный риск обнаруженной уязвимости как комбинацию возможности осуществления угрозы и уровня воздействия на организацию при осуществлении угрозы.
### ▍11.2.1.1. Возможность осуществления угрозы
В соответствии с NIST, возможность осуществления угрозы основана на вероятности того, что источник угрозы, потенциальный противник, способен к эксплуатации конкретной уязвимости. При этом возможности осуществления угрозы присваивается один из возможных рейтингов: низкий, средний или высокий.
* Высокий уровень. Потенциальный противник высококвалифицирован и мотивирован, меры, принятые для защиты от использования уязвимости, недостаточны.
* Средний уровень. Потенциальный противник мотивирован и квалифицирован, но меры по защите от использования уязвимости могут препятствовать его успеху.
* Низкий уровень. Потенциальный противник неквалифицирован или испытывает недостаток мотивации, при этом приняты меры для защиты от использования уязвимости, которые частично или абсолютно эффективны.
### ▍11.2.1.2. Уровень воздействия на организацию при осуществлении угрозы
Уровень воздействия на организацию при осуществлении угрозы определяют, оценивая размер ущерба, который может причинить использование анализируемой уязвимости.
* Высокий уровень. Использование уязвимости может привести к существенным финансовым потерям, может серьёзно повредить миссии или репутации организации, может закончится серьёзным материальным ущербом или человеческими жертвами.
* Средний уровень. Использование уязвимости может привести к финансовым потерям, повредить миссии или репутации компании, или, в случае с человеческими ресурсами компании, привести к травмам.
* Низкий уровень. Использование уязвимости может привести к некоторым финансовым потерям или воздействию на миссию или репутацию компании.
### ▍11.2.1.3. Определение уровня риска
Как только выяснены возможность осуществления угрозы и уровень её воздействия на организацию, можно оценить уровень риска (низкий, средний, или высокий), который выражается в виде функции от двух найденных показателей. Показатель уровня риска позволяет сформировать план действий для тех, кто ответственен за защиту и поддержку анализируемой системы.
* Высокий уровень. Имеется серьёзная потребность в принятии дополнительных мер для защиты от уязвимости. В некоторых случаях можно позволить, чтобы система продолжала работать, но нужно подготовить план по её защите, который должен быть реализован как можно скорее.
* Средний уровень. Есть потребность в принятии дополнительных мер для защиты от уязвимости. План по реализации необходимых мер по защите должен быть выполнен в пределах разумного периода времени.
* Низкий уровень. Владелец системы определит самостоятельно, реализовывать ли дополнительные меры по защите от уязвимости, либо принять обнаруженный риск и оставить систему неизменной.
### ▍11.2.1.4. Итоговые мероприятия
Показатель риска обнаруженной уязвимости формирует множество факторов, поэтому рейтинги, полученные из систем автоматического сканирования следует рассматривать лишь как отправную точку в определении реального риска.
По результатам оценки уязвимостей составляют отчёты. Такие отчёты, созданные со знанием дела и профессионально проанализированные, закладывают базу для других исследований, таких, как оценка систем на соответствие стандартам безопасности. Важно извлечь из результатов оценки уязвимостей всё, что можно.
Kali — это отличная платформа для проведения оценки уязвимостей, ОС для этого не нуждается в особой настройке. В разделах меню Applications (Приложения) можно найти множество инструментов для анализа уязвимостей. В частности, речь идёт о разделах Information Gathering (Сбор информации), Vulnerability Analysis (Анализ уязвимостей), и Web Application Analysis (Анализе веб-приложения). Узнать подробности об использовании Kali Linux для анализа уязвимостей можно на сайте [Kali Linux Tools](http://tools.kali.org/tools-listing), на сайте [официальной документации Kali Linux](http://docs.kali.org/), и ознакомившись с бесплатным курсом [Metasploit Unleashed](https://www.offensive-security.com/metasploit-unleashed/).
11.2.2. Оценка систем на соответствие стандартам безопасности
-------------------------------------------------------------
Следующий по сложности вид исследований — это оценка систем на соответствие стандартам безопасности. Подобные испытания систем распространены сильнее всего, так как они основаны на проверке требований, предписываемых государственными и индустриальными стандартами, распространяющимися на организации.
Существует множество специализированных стандартов безопасности, однако, чаще всего встречается Payment Card Industry Data Security Standard ([PCI DSS](https://www.pcisecuritystandards.org/documents/Penetration_Testing_Guidance_March_2015.pdf)). Этот стандарт разработан компаниями, выпускающими платёжные карты. Ему должны соответствовать организации, обрабатывающие карточные платежи. Если говорить о других распространённых стандартах, можно отметить такие, как Defense Information Systems Agency Security Technical Implementation Guides ([DISA STIG](http://iase.disa.mil/stigs/Pages/index.aspx)), Federal Risk and Authorization Management Program ([FedRAMP](https://www.fedramp.gov/about-us/about/)), Federal Information Security Management Act ([FISMA](http://csrc.nist.gov/groups/SMA/fisma/)), и другие.
Корпоративный клиент может заказать подобное исследование или обратиться за результатами ранее проведённого исследования по разным причинам. В частности, инициатива может исходить от самого клиента, либо он может быть вынужден проводить обязательную проверку. В любом случае, такие исследования называют «оценкой систем на соответствие стандартам безопасности», или «исследованиями на соответствие стандартам безопасности», или «проверками на соответствие стандартам безопасности».
Оценка системы на соответствие стандартам обычно начинается с анализа уязвимостей. В случае с процедурой [проведения аудита](https://www.pcisecuritystandards.org/documents/PCIDSS_QRGv3_2.pdf) на соответствие стандарту PCI, оценка уязвимостей, если она проведена соответствующим образом, может удовлетворить нескольким основным требованиям стандарта. Среди них — требование 2: «Не использовать пароли и другие системные параметры, заданные производителем по умолчанию». Анализ системы на соответствие этому требованию можно провести с помощью инструментов из категории меню Password Attack (Взлом паролей). Далее, это требование 11: «Регулярно выполнять тестирование систем и процессов обеспечения безопасности». Соответствующую проверку можно провести с помощью инструментов из категории Database Assessment (Исследование баз данных). Некоторые требования нельзя проверить с помощью обычных инструментов сканирования на уязвимости. Среди них — требование 9: «Ограничить физический доступ к данным держателей карт», и 12: « Разработать и поддерживать политику информационной безопасности для всего персонала организации». Для проверки таких требований нужны дополнительные усилия.
На первый взгляд может показаться не вполне понятным, как использовать Kali Linux для выполнения некоторых проверок. Однако, Kali отлично подходит для решения подобных задач, причём, не только из-за богатого набора стандартных инструментов, но и потому, что она основана на Debian, что открывает возможность установки множества дополнительных приложений. Искать программы, реализующие необходимый функционал, можно в менеджере пакетов, используя ключевые слова, взятые из используемого стандарта информационной безопасности. Подобный поиск, почти наверняка, завершится выдачей нескольких заслуживающих внимания результатов. В настоящее время многие организации используют Kali Linux как платформу именно для оценки систем на соответствие стандартам безопасности.
11.2.3. Традиционное тестирование на проникновение в систему
------------------------------------------------------------
В последнее время стало сложно подобрать подходящее определение для «традиционного теста на проникновение». Дело в том, что подобные тесты используются в различных сферах деятельности, как результат, все описывают их по-своему. Путаницы добавляет и то, что «тестированием на проникновение» всё чаще стали называть описанную выше оценку систем на соответствие стандартам безопасности, или даже обычную оценку уязвимостей. В подобных случаях исследование не выходит за рамки неких минимальных требований.
В этом разделе мы не будем касаться споров об особенностях различных видов испытаний систем. Здесь мы расскажем об исследованиях, которые не ограничены некими «минимальными требованиями». Это — исследования, которые задуманы так, чтобы после их проведения можно было бы по-настоящему улучшить общую безопасность организации.
В противоположность видам исследований, которые мы обсудили ранее, традиционные тесты на проникновение не часто начинаются с определения области исследования. Вместо этого для них устанавливают определённые цели. Например: «смоделировать последствия компрометации внутреннего пользователя», или: «выяснить, что случилось бы, если бы организация попала под целенаправленную атаку, выполняемую внешним злоумышленником». Ключевой отличительной чертой подобных исследований является то, что в ходе их выполнения не только находят и оценивают уязвимости, но ещё и используют найденные проблемы для раскрытия наихудших вариантов развития событий.
В ходе тестирования на проникновение не полагаются исключительно на инструменты сканирования систем на уязвимости. Работа продолжается путём исследования находок, путём использования эксплойтов или испытаний для исключения ложноположительных результатов, делается всё возможное для того, чтобы обнаружить скрытые уязвимости, или то, что мы называем ложноотрицательными результатами.
Подобное исследование часто включает в себя эксплуатацию обнаруженных уязвимостей, оценку уровня доступа, который предоставляют эксплойты, и использование этого повышенного уровня доступа как отправной точки для дополнительных атак на целевую систему.
Здесь требуется критический анализ целевого окружения, ручной поиск уязвимостей, креативность, способность к нестандартному мышлению. Всё это — подходы к обнаружению дополнительных уязвимостей, которые требуют других инструментов, способных найти уязвимости там, где заканчиваются возможности самых мощных автоматических сканеров. Нередко, после завершения этого шага, весь процесс начинают снова и снова для того, чтобы обеспечить полное и качественное выполнение работы.
Несмотря на сложность и многоплановость традиционного тестирования на проникновение, ход такого исследования можно упорядочить, разбив на несколько шагов. Стоит отметить, что Kali упрощает подбор ПО для каждого из таких шагов. Итак, вот пошаговый план тестирования на проникновение с комментариями об используемых инструментах:
* Сбор информации. На данной фазе усилия пентестера направлены на то, чтобы узнать как можно больше о целевом окружении. Обычно эта деятельность неинвазивна и выглядит как обычная активность пользователей. Эти действия составляют основу для остальных этапов исследования и таким образом они должны привести к сбору как можно более полных данных о системе. Раздел Information Gathering (Сбор информации) меню Applications (Приложения) Kali Linux содержит в себе десятки инструментов, направленных на то, чтобы раскрыть как можно больше информации об исследуемой системе.
* Обнаружение уязвимостей. Этот шаг часто называют «активным сбором информации». Специалист, пытаясь идентифицировать потенциальные уязвимости в целевом окружении, ещё не атакует систему, но уже ведёт себя не так, как обычный пользователь. Именно здесь часто имеет место вышеописанное сканирование систем на уязвимости. На данном шаге исследования будут полезны программы из разделов Vulnerability Analysis (Анализ уязвимостей), Web Application Analysis (Анализ веб-приложений), Database Assessment (Исследование баз данных), и Reverse Engineering (Реверс-инжиниринг).
* Эксплуатация уязвимостей. Имея список обнаруженных потенциальных уязвимостей, на данном шаге исследования специалист пытается воспользоваться ими для того, чтобы найти точку опоры в целевой среде. В этом деле полезны инструменты, которые можно найти в категориях Web Application Analysis (Анализ веб-приложений), Database Assessment (Исследование баз данных), Password Attacks (Взлом паролей), и Exploitation Tools (Средства эксплуатации уязвимостей).
* Проникновение в системы и незаметное извлечение данных. После того, как исследователю удалось закрепиться в системе, нужно двигаться дальше. Как правило, на данном этапе ищут способ повышения привилегий до уровня, соответствующего тому, который необходим для достижения целевых систем, ранее недоступных, и скрытного извлечения их них секретной информации. На этом шаге можно обратиться к таким разделам меню приложений, как Password Attacks (Взлом паролей), Exploitation Tools (Средства эксплуатации уязвимостей), Sniffing & Spoofing (Сниффинг и спуфинг), и Post Exploitation (Действия после эксплуатации уязвимости).
* Подготовка отчётов. После завершения активной фазы исследования, нужно задокументировать произведённые действия и подготовить отчёт. Обычно этот шаг не отличается такой же технической сложностью, как предыдущие. Однако, благодаря качественным отчётам клиент может получить полную отдачу от проделанной работы, поэтому не стоит недооценивать важность этого этапа исследования. Соответствующие инструменты можно найти в разделе Reporting Tools (Средства подготовки отчётов) меню Applications (Приложения).
В большинстве случаев тесты на проникновение будут устроены совершенно по-разному, так как каждая организация будет подвергаться разным угрозам и иметь различные ресурсы, которые требуется защищать. Kali Linux даёт универсальную базу для решения подобных задач, именно здесь можно воспользоваться множеством возможностей по настройке Kali. Многие организации, которые выполняют такие исследования, поддерживают настроенные под свои нужды версии Kali LInux для внутреннего использования. Это позволяет им ускорить развёртывание систем перед новым исследованием.
Среди часто встречающихся дополнительных настроек Kali Linux можно отметить следующие:
* Предустановка лицензированных коммерческих пакетов. Например, имеется пакет, вроде платного сканера уязвимостей, который планируется использовать в ходе многих сеансов тестирования на проникновение. Для того, чтобы избежать необходимости устанавливать этот пакет на каждой развернутой копии Kali, можно интегрировать его в систему. Как результат, этот пакет окажется установленным при каждом развёртывании Kali.
* Предварительно настроенная виртуальная частная сеть с обратным соединением. Это очень удобная функция для устройств, которые преднамеренно оставляют подключёнными внутри исследуемой сети. Такие устройства позволяют проводить «удалённые внутренние» исследования. Устройство с функцией обратного соединения подключается к компьютеру пентестера, создавая туннель, который можно использовать для подключения к внутренним системам. Дистрибутив [Kali Linux ISO of Doom](https://www.offensive-security.com/kali-linux/kali-rolling-iso-of-doom/) — это пример как раз такой специальной настройки системы.
* Предустановленные инструменты и программы собственной разработки. Многие организации имеют наборы инструментов собственной разработки, необходимые в ходе сеансов тестирования на проникновение, поэтому их предварительная установка при формировании специального [образа системы](http://docs.kali.org/development/live-build-a-custom-kali-iso) позволяет экономить время.
* Предварительная настройка конфигурации ОС, в том числе — настройка отображение имён хостов на IP-адреса, обоев рабочего стола, настройки прокси-серверов, и так далее. Многие пользователи Kali предпочитают [особые настройки](https://www.offensive-security.com/kali-linux/kali-linux-recipes/) системы. Если вы собираетесь регулярно переустанавливать систему, сохранение подобных настроек может иметь смысл.
11.2.4. Исследование приложений
-------------------------------
Большинство мероприятий по оценке защищённости систем отличаются достаточно большими масштабами. Особенностью же исследований приложений является тот факт, что изучению подвергается конкретная программа. Подобные исследования становятся всё более распространёнными из-за сложности жизненно важных приложений, используемых компаниями. Многие из таких приложений созданы собственными силами этих компаний. Если нужно, исследование приложений может сопутствовать другим видам исследований. Среди видов приложений, которые могут быть исследованы на предмет безопасности, можно отметить следующие:
* Веб-приложения. Эти приложения часто являются целями злоумышленников, так как они, обычно обладая значительной поверхностью атаки, доступны из интернета. Стандартные тесты нередко позволяют обнаружить базовые проблемы веб-приложений. Однако, более детальное исследование, хотя и может занимать немало времени, позволяет найти скрытые дефекты приложений. Для проведения подобных испытаний можно воспользоваться метапакетом `kali-linux-web`, который содержит множество полезных инструментов.
* Настольные приложения, распространяемые в виде исполняемых файлов. Серверные приложения — это не единственная цель злоумышленников. Настольные приложения также подвержены атакам. В прошедшие годы многие настольные программы, такие, как средства для чтения PDF-файлов, или видео-приложения, использующие интернет-ресурсы, подвергались множествам атак, что привело к их совершенствованию. Однако, всё ещё существует множество настольных приложений, в которых, при правильном подходе, можно найти массу уязвимостей.
* Мобильные приложения. С ростом популярности мобильных устройств, мобильные приложения становятся постоянными предметами исследований безопасности. Эти приложения очень быстро развиваются и меняются, поэтому в данной сфере методология исследований пока не достигла достаточной зрелости, что ведёт к регулярному, практически еженедельному, появлению новых методик. Инструменты, относящиеся к изучению мобильных приложений, можно найти в разделе меню приложений Kali Linux Reverse Engineering (Реверс-инжиниринг).
Исследование приложений можно проводить самыми разными способами. Например, для идентификации потенциальных проблем можно воспользоваться автоматическим средством, предназначенным для тестирования конкретного приложения. Подобные автоматические средства, основываясь на особенностях работы приложений, пытаются найти в них неизвестные слабости, вместо того, чтобы полагаться на набор заранее заданных сигнатур. Инструменты для анализа программ должны учитывать особенности их поведения. Вот, например, популярный сканер уязвимости веб-приложений [Burp Suite](https://portswigger.net/burp/). В ходе исследования приложения он находит поля для ввода данных, после чего выполняет различные атаки методом SQL-инъекций, наблюдая в это время за приложением для того, чтобы выявить атаки, которые оказались успешными.
Существуют и более сложные сценарии исследования приложений. Такие исследования могут быть выполнены в интерактивном режиме. При их проведении используют модели чёрного и белого ящиков.
* Исследование методом чёрного ящика. Инструмент (или исследователь) взаимодействует с приложением, не обладая специальными знаниями о нём, или особым доступом к нему, превышающим возможности обычного пользователя. Например, в случае с веб-приложением, исследователь может иметь только доступ к функциям и возможностям, открытым пользователю, который не авторизован в системе. Любая используемая учётная запись будет такой же, которую обычный пользователь может зарегистрировать самостоятельно. Это не даст атакующему возможности анализировать функционал, который доступен только привилегированным пользователям, учётные записи которых необходимо создавать администратору.
* Исследование методом белого ящика. Инструмент (или исследователь) часто имеет полный доступ к исходному коду приложения, административный доступ к платформе, на которой оно выполняется, и так далее. Это гарантирует выполнение полного и тщательного анализа всех возможностей приложения, независимо от того, где именно находится изучаемая функциональность. Минус такого исследования заключается в том, что оно не является имитацией реальных действий злоумышленника.
Конечно, между белым и чёрным есть и оттенки серого. Обычно то, как именно будет осуществляться работа с приложением, определяется целями исследования. Если цель заключается в том, чтобы узнать, что может произойти с приложением, которое окажется предметом целенаправленной внешней атаки, вероятно, лучше всего подойдёт тестирование методом чёрного ящика. Если цель заключается в идентификации и устранении как можно большего количества проблем с безопасностью за сравнительно короткое время, исследование методом белого ящика может оказаться более эффективным.
В других случаях может быть применён гибридный подход, когда исследователь не обладает полным доступом к исходному коду приложения для платформы, на которой оно выполняется, но выданная ему учётная запись подготовлена администратором и даёт доступ к как можно большим возможностям приложения.
Kali — это идеальная платформа для всех подходов к исследованию приложений. После установки стандартного дистрибутива здесь можно найти множество сканеров, рассчитанных на конкретные приложения. Тут есть и инструменты для более продвинутых исследований. Среди них — редакторы исходного кода и скриптовые окружения. В деле исследования приложений вам могут оказаться полезными материалы из разделов [Web Application](http://tools.kali.org/category/web-applications) и [Reverse Engineering](http://tools.kali.org/category/reverse-engineering) сайта Kali Tools.
Итоги
-----
В этом материале мы рассказали о различных видах мероприятий по оценке защищённости информационных систем. Здесь же можно найти ссылки на инструменты, полезные при проведении подобных исследований. В следующий раз поговорим о методике формализации исследований и о типах атак.
Уважаемые читатели! Если вы проводили исследования по оценке защищённости систем или заказывали подобные исследования в специализированных организациях — просим поделиться опытом. | https://habr.com/ru/post/339636/ | null | ru | null |
# Black [O]lives Matter: раса, криминал и огонь на поражение в США. Часть 2
В [первой части статьи](https://habr.com/ru/post/517776/) я описал предпосылки для исследования, его цели, допущения, исходные данные и инструменты. Сейчас можно без дальнейших разглагольствований сказать гагаринское...
Поехали!
--------
Импортируем библиотеки и определяем путь к директории со всеми файлами:
```
import pandas as pd, numpy as np
# путь к папке с исходными файлами
ROOT_FOLDER = r'c:\_PROG_\Projects\us_crimes'
```
Гибель от рук закона
--------------------
Начнем с анализа данных по жертвам полиции. Давайте подгрузим файл из CSV в DataFrame:
```
# Файл с БД Fatal Encounters (FENC)
FENC_FILE = ROOT_FOLDER + '\\fatal_enc_db.csv'
# грузим в DataFrame
df_fenc = pd.read_csv(FENC_FILE, sep=';', header=0, usecols=["Date (Year)", "Subject's race with imputations", "Cause of death", "Intentional Use of Force (Developing)", "Location of death (state)"])
```
Заметьте сразу, что мы не грузим все поля из БД, а только необходимые нам для анализа: год, расовая принадлежность (с учетом экспертной оценки), причина смерти (здесь пока не используется, но может понадобиться в дальнейшем), признак намеренного применения силы и штат, в котором имело место событие.
Здесь надо пояснить, что такое "экспертная оценка" расовой принадлежности. Дело в том, что официальные источники, откуда FENC собирает данные, не всегда указывают расу жертвы, отсюда получаются пропуски в данных. Для компенсации этих пропусков сообщество привлекает экспертов, оценивающих расу жертвы по другим данным (с определенной погрешностью). Более подробно на эту тему можете почитать на самом [сайте Fatal Encounters](https://fatalencounters.org/) или загрузив [исходный Excel файл](https://docs.google.com/spreadsheets/d/1dKmaV_JiWcG8XBoRgP8b4e9Eopkpgt7FL7nyspvzAsE/edit#gid=0) (во втором листе).
Переименуем столбцы для удобства и очистим строки с пропущенными данными:
```
df_fenc.columns = ['Race', 'State', 'Cause', 'UOF', 'Year']
df_fenc.dropna(inplace=True)
```
Теперь нам надо унифицировать наименования расовой принадлежности для того, чтобы в дальнейшем сопоставлять эти данные с данными по преступлениям и численности населения. Классификация рас в этих источниках немного разная. БД FENC, в частности, выделяет латиноамериканцев (Hispanic/Latino), азиатов и уроженцев тихоокеанских территорий (Asian/Pacific Islander) и среднеазиатов (Middle Eastern). Нас же интересуют только белые и черные. Поэтому сделаем укрупнение:
```
df_fenc = df_fenc.replace({'Race': {'European-American/White': 'White', 'African-American/Black': 'Black',
'Hispanic/Latino': 'White', 'Native American/Alaskan': 'American Indian',
'Asian/Pacific Islander': 'Asian', 'Middle Eastern': 'Asian',
'NA': 'Unknown', 'Race unspecified': 'Unknown'}}, value=None)
```
Оставляем только данные по белым (теперь с учетом латино) и черным:
```
df_fenc = df_fenc.loc[df_fenc['Race'].isin(['White', 'Black'])]
```
Зачем нам поле "UOF" (намеренное использование силы)? Для исследования мы хотим оставить только случаи, когда полиция (или иные правоохранительные органы) намеренно применяли силу против человека. Мы опускаем случаи, когда человек совершил самоубийство (например, в результате осады полицией) или погиб в результате ДТП, преследуемый полицейскими. Это допущение сделано по двум причинам: 1) обстоятельства гибели по косвенным причинам часто не позволяют провести прямую причинно-следственную связь между действиями правоохранительных органов и смертью (пример: полицейский держит на мушке человека, который затем умирает от сердечного приступа; другой пример: при задержании преступник пускает себе пулю в лоб); 2) при рассмотрении действий властей расценивается именно применение силы; так, например, будущая официальная БД по применению силы (которую я упомянул в предыдущей статье) будет содержать именно данные, отражающая намеренное применение смертельной силы против граждан. Итак, оставляем только эти данные:
```
df_fenc = df_fenc.loc[df_fenc['UOF'].isin(['Deadly force', 'Intentional use of force'])]
```
Для удобства добавим полные названия штатов. Для этого я приготовил [отдельный CSV](https://yadi.sk/d/Fb5NOSiLiVXwDA), который мы и подгрузим в наш датасет:
```
df_state_names = pd.read_csv(ROOT_FOLDER + '\\us_states.csv', sep=';', header=0)
df_fenc = df_fenc.merge(df_state_names, how='inner', left_on='State', right_on='state_abbr')
```
Отобразим начальные строки командой `df_fenc.head()`, чтобы получить представление о датасете:
| | Race | State | Cause | UOF | Year | state\_name | state\_abbr |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | Black | GA | Gunshot | Deadly force | 2000 | Georgia | GA |
| 1 | Black | GA | Gunshot | Deadly force | 2000 | Georgia | GA |
| 2 | Black | GA | Gunshot | Deadly force | 2000 | Georgia | GA |
| 3 | Black | GA | Gunshot | Deadly force | 2000 | Georgia | GA |
| 4 | Black | GA | Gunshot | Deadly force | 2000 | Georgia | GA |
Нам не нужно разбирать отдельные случаи гибели, давайте агрегируем данные по годам и расовой принадлежности:
```
# группируем по году и расе
ds_fenc_agg = df_fenc.groupby(['Year', 'Race']).count()['Cause']
df_fenc_agg = ds_fenc_agg.unstack(level=1)
# конвертируем численные данные в UINT16 для экономии
df_fenc_agg = df_fenc_agg.astype('uint16')
```
В итоге получили таблицу с 2 столбцами: White (количество белых жертв) и Black (количество черных жертв), индексированную по годам (с 2000 по 2020). Давайте взглянем на эти данные в виде графика:
```
# белые и черные жертвы полицейских по годам (кол-во гибелей)
plt = df_fenc_agg.plot(xticks=df_fenc_agg.index, color=['olive', 'g'])
plt.set_xticklabels(df_fenc_agg.index, rotation='vertical')
plt.set_xlabel('')
plt.set_ylabel('Кол-во жертв от рук полиции')
plt
```
**Промежуточный вывод:**
> В количественном (абсолютном) выражении белых жертв больше, чем черных.
>
>
Разница между этими данными составляет в среднем 2.4 раза. Напрашивается справедливое заключение о том, что это связано с разницей в численности белых и черных. Что же, давайте посмотрим теперь на удельные показатели.
Подгрузим данные по численности населения (по расам):
```
# файл CSV с данными по населению (1991 - 2018)
POP_FILE = ROOT_FOLDER + '\\us_pop_1991-2018.csv'
df_pop = pd.read_csv(POP_FILE, index_col=0, dtype='int64')
```
Добавим эти данные в наш датасет:
```
# выбираем только данные по числ-ти белых и черных за 2000 - 2018 гг.
df_pop = df_pop.loc[2000:2018, ['White_pop', 'Black_pop']]
# объединяем датафреймы, выкидываем строки с пропусками
df_fenc_agg = df_fenc_agg.join(df_pop)
df_fenc_agg.dropna(inplace=True)
# конвертируем данные по численности в целочисленный тип
df_fenc_agg = df_fenc_agg.astype({'White_pop': 'uint32', 'Black_pop': 'uint32'})
```
ОК. Осталось создать 2 столбца с удельными значениями, разделив количество жертв на численность и умножив на миллион (*количество жертв на 1 млн. человек*):
```
df_fenc_agg['White_promln'] = df_fenc_agg['White'] * 1e6 / df_fenc_agg['White_pop']
df_fenc_agg['Black_promln'] = df_fenc_agg['Black'] * 1e6 / df_fenc_agg['Black_pop']
```
Смотрим, что получилось:
| | Black | White | White\_pop | Black\_pop | White\_promln | Black\_promln |
| --- | --- | --- | --- | --- | --- | --- |
| Year | | | | | | |
| 2000 | 148 | 291 | 218756353 | 35410436 | 1.330247 | 4.179559 |
| 2001 | 158 | 353 | 219843871 | 35758783 | 1.605685 | 4.418495 |
| 2002 | 161 | 363 | 220931389 | 36107130 | 1.643044 | 4.458953 |
| 2003 | 179 | 388 | 222018906 | 36455476 | 1.747599 | 4.910099 |
| 2004 | 157 | 435 | 223106424 | 36803823 | 1.949742 | 4.265861 |
| 2005 | 181 | 452 | 224193942 | 37152170 | 2.016112 | 4.871855 |
| 2006 | 212 | 460 | 225281460 | 37500517 | 2.041890 | 5.653255 |
| 2007 | 219 | 449 | 226368978 | 37848864 | 1.983487 | 5.786171 |
| 2008 | 213 | 442 | 227456495 | 38197211 | 1.943229 | 5.576323 |
| 2009 | 249 | 478 | 228544013 | 38545558 | 2.091501 | 6.459888 |
| 2010 | 219 | 506 | 229397472 | 38874625 | 2.205778 | 5.633495 |
| 2011 | 290 | 577 | 230838975 | 39189528 | 2.499578 | 7.399936 |
| 2012 | 302 | 632 | 231992377 | 39623138 | 2.724227 | 7.621809 |
| 2013 | 310 | 693 | 232969901 | 39919371 | 2.974633 | 7.765653 |
| 2014 | 264 | 704 | 233963128 | 40379066 | 3.009021 | 6.538041 |
| 2015 | 272 | 729 | 234940100 | 40695277 | 3.102919 | 6.683822 |
| 2016 | 269 | 723 | 234644039 | 40893369 | 3.081263 | 6.578084 |
| 2017 | 265 | 743 | 235507457 | 41393491 | 3.154889 | 6.401973 |
| 2018 | 265 | 775 | 236173020 | 41617764 | 3.281493 | 6.367473 |
Последние 2 столбца - наши удельные показатели на миллион человек по каждой из двух рас. Пора посмотреть на графике:
```
plt = df_fenc_agg.loc[:, ['White_promln', 'Black_promln']].plot(xticks=df_fenc_agg.index, color=['g', 'olive'])
plt.set_xticklabels(df_fenc_agg.index, rotation='vertical')
plt.set_xlabel('')
plt.set_ylabel('Кол-во жертв от рук полиции\nна 1 млн представителей расы')
plt
```
Также выведем основную статистику по этим данным:
```
df_fenc_agg.loc[:, ['White_promln', 'Black_promln']].describe()
```
| | White\_promln | Black\_promln |
| --- | --- | --- |
| count *(количество)* | 19.000000 | 19.000000 |
| mean *(среднее арифм.)* | **2.336123** | **5.872145** |
| std *(станд. отклонение)* | **0.615133** | **1.133677** |
| min *(мин. значение)* | 1.330247 | 4.179559 |
| 25% | 1.946485 | 4.890977 |
| 50% | 2.091501 | 5.786171 |
| 75% | 2.991827 | 6.558062 |
| max *(макс. значение)* | 3.281493 | 7.765653 |
**Промежуточные выводы:**
> 1. В среднем от рук полиции погибает 5.9 на 1 млн. черных и 2.3 на 1 млн. белых (черных в 2.6 раз больше).
>
> 2. Разброс (отклонение) в данных по черным жертвам в 1.8 раз выше, чем в данных по белым жертвам. (На графике видно, что кривая по белым жертвам гораздо более плавная, без резких скачков.)
>
> 3. Максимальное количество жертв среди черных - в 2013 г. (7.7 на миллион); максимальное количество жертв среди белых - в 2018 г. (3.3 на миллион).
>
> 4. Жертвы среди белых монотонно растут (в среднем на 0.1 - 0.2 в год), в то время как жертвы среди черных вернулись на уровень 2009 г. после пика в 2011 - 2013 гг.
>
>
Итак, на **первый поставленный вопрос** мы ответили:
***- Можно ли сказать, что полицейские убивают черных чаще, чем белых?***
**- Да, это верный вывод. От рук закона черных гибнет в среднем в 2.6 раз больше, чем белых.**
Держа в голове эти промежуточные выводы, идем дальше - посмотрим данные по преступлениям, чтобы понять, как они соотносятся с расовой принадлежностью и жертвами от рук стражей закона.
Данные по преступлениям
-----------------------
Загружаем наш CSV по преступлениям:
```
CRIMES_FILE = ROOT_FOLDER + '\\culprits_victims.csv'
df_crimes = pd.read_csv(CRIMES_FILE, sep=';', header=0, index_col=0, usecols=['Year', 'Offense', 'Offender/Victim', 'White', 'White pro capita', 'Black', 'Black pro capita'])
```
Здесь опять-таки используем только необходимые столбцы: год, вид преступления, классификатор и данные по количеству преступлений, совершенных черными и белыми (абсолютные - "White", "Black" и удельные на человека - "White pro capita", "Black pro capita").
Взглянем на данные (`df\_crimes.head()`):
| | Offense | Offender/Victim | Black | White | Black pro capita | White pro capita |
| --- | --- | --- | --- | --- | --- | --- |
| Year | | | | | | |
| 1991 | All Offenses | Offender | 490 | 598 | 1.518188e-05 | 2.861673e-06 |
| 1991 | All Offenses | Offender | 4 | 4 | 1.239337e-07 | 1.914160e-08 |
| 1991 | All Offenses | Offender | 508 | 122 | 1.573958e-05 | 5.838195e-07 |
| 1991 | All Offenses | Offender | 155 | 176 | 4.802432e-06 | 8.422314e-07 |
| 1991 | All Offenses | Offender | 13 | 19 | 4.027846e-07 | 9.092270e-08 |
Нам пока не нужны данные по жертвам преступлений. Убираем лишние данные и столбцы:
```
# оставляем только преступников (убираем жертв)
df_crimes1 = df_crimes.loc[df_crimes['Offender/Victim'] == 'Offender']
# берем исследуемый период (2000-2018) и удаляем лишние столбцы
df_crimes1 = df_crimes1.loc[2000:2018, ['Offense', 'White', 'White pro capita', 'Black', 'Black pro capita']]
```
Получили такой датасет (1295 строк \* 5 столбцов):
| | Offense | White | White pro capita | Black | Black pro capita |
| --- | --- | --- | --- | --- | --- |
| Year | | | | | |
| 2000 | All Offenses | 679 | 0.000003 | 651 | 0.000018 |
| 2000 | All Offenses | 11458 | 0.000052 | 30199 | 0.000853 |
| 2000 | All Offenses | 4439 | 0.000020 | 3188 | 0.000090 |
| 2000 | All Offenses | 10481 | 0.000048 | 5153 | 0.000146 |
| 2000 | All Offenses | 746 | 0.000003 | 63 | 0.000002 |
| ... | ... | ... | ... | ... | ... |
| 2018 | Larceny Theft Offenses | 1961 | 0.000008 | 1669 | 0.000040 |
| 2018 | Larceny Theft Offenses | 48616 | 0.000206 | 30048 | 0.000722 |
| 2018 | Drugs Narcotic Offenses | 555974 | 0.002354 | 223398 | 0.005368 |
| 2018 | Drugs Narcotic Offenses | 305052 | 0.001292 | 63785 | 0.001533 |
| 2018 | Weapon Law Violation | 70034 | 0.000297 | 58353 | 0.001402 |
Теперь нам надо превратить удельные показатели на 1 человека в удельные на 1 миллион (так как именно эти данные используются во всем исследовании). Для этого просто умножаем на миллион соответствующие столбцы:
```
df_crimes1['White_promln'] = df_crimes1['White pro capita'] * 1e6
df_crimes1['Black_promln'] = df_crimes1['Black pro capita'] * 1e6
```
Чтобы увидеть целую картину, как соотносится количество преступлений между белыми и черными по видам преступлений (в абсолютном выражении), просуммируем годовые наблюдения:
```
df_crimes_agg = df_crimes1.groupby(['Offense']).sum().loc[:, ['White', 'Black']]
```
| | White | Black |
| --- | --- | --- |
| Offense | | |
| All Offenses | 44594795 | 22323144 |
| Assault Offenses | 12475830 | 7462272 |
| Drugs Narcotic Offenses | 9624596 | 3453140 |
| Larceny Theft Offenses | 9563917 | 4202235 |
| Murder And Nonnegligent Manslaughter | 28913 | 39617 |
| Sex Offenses | 833088 | 319366 |
| Weapon Law Violation | 829485 | 678861 |
Или в виде графика:
```
plt = df_crimes_agg.plot.barh(color=['g', 'olive'])
plt.set_ylabel('Вид преступления')
plt.set_xlabel('Кол-во совершенных преступлений (за 2000 - 2018 гг)')
```
Итак, видим, что:
* В количественном отношении нападения, наркотики, воровство и "все преступления" сильно превалируют над преступлениями, связанными с убийством, оружием и сексом
* В абсолютных значениях белые совершают больше преступлений, чем черные (ровно в 2 раза для категории "все преступления")
Опять понимаем, что без информации о численности никакие выводы о "криминальности" рас не сделаешь. Соответственно, посмотрим на удельные показатели:
```
df_crimes_agg1 = df_crimes1.groupby(['Offense']).sum().loc[:, ['White_promln', 'Black_promln']]
```
| | White\_promln | Black\_promln |
| --- | --- | --- |
| Offense | | |
| All Offenses | 194522.307758 | 574905.952459 |
| Assault Offenses | 54513.398833 | 192454.602875 |
| Drugs Narcotic Offenses | 41845.758869 | 88575.523095 |
| Larceny Theft Offenses | 41697.303725 | 108189.184125 |
| Murder And Nonnegligent Manslaughter | 125.943007 | 1016.403706 |
| Sex Offenses | 3633.777035 | 8225.144985 |
| Weapon Law Violation | 3612.671402 | 17389.163849 |
И на графике:
```
plt = df_crimes_agg1.plot.barh(color=['g', 'olive'])
plt.set_ylabel('Вид преступления')
plt.set_xlabel('Кол-во совершенных преступлений на 1 млн представителей расы (за 2000 - 2018 гг)')
```
Здесь уже совсем иная картина. По всем видам преступлений (из анализируемых) черные совершают больше, чем белые. По категории "все преступления" эта разница составляет почти 3 раза.
Давайте теперь оставим только категорию "все преступления" (All Offenses) как наиболее представительную, только удельные показатели по преступлениям (на миллион человек) и сгруппируем данные по годам (так как в исходных данных на каждый год может быть несколько записей - по количеству служб, предоставивших данные).
```
# оставляем только 'All Offenses' = все преступления
df_crimes1 = df_crimes1.loc[df_crimes1['Offense'] == 'All Offenses']
# чтобы использовать другую выборку, можем, например, оставить нападения и убийства:
#df_crimes1 = df_crimes1.loc[df_crimes1['Offense'].str.contains('Assault|Murder')]
# убираем абсолютные значения и агрегируем по годам
df_crimes1 = df_crimes1.groupby(level=0).sum().loc[:, ['White_promln', 'Black_promln']]
```
Полученный датасет:
| | White\_promln | Black\_promln |
| --- | --- | --- |
| Year | | |
| 2000 | 6115.058976 | 17697.409882 |
| 2001 | 6829.701429 | 20431.707645 |
| 2002 | 7282.333249 | 20972.838329 |
| 2003 | 7857.691182 | 22218.966500 |
| 2004 | 8826.576863 | 26308.815799 |
| 2005 | 9713.826255 | 30616.569637 |
| 2006 | 10252.894313 | 33189.382429 |
| 2007 | 10566.527362 | 34100.495064 |
| 2008 | 10580.520024 | 34052.276749 |
| 2009 | 10889.263592 | 33954.651792 |
| 2010 | 10977.017218 | 33884.236826 |
| 2011 | 11035.346176 | 32946.454471 |
| 2012 | 11562.836825 | 33150.706035 |
| 2013 | 11211.113491 | 32207.571607 |
| 2014 | 11227.354594 | 31517.346141 |
| 2015 | 11564.786088 | 31764.865490 |
| 2016 | 12193.026562 | 33186.064958 |
| 2017 | 12656.261666 | 34900.390499 |
| 2018 | 13180.171893 | 37805.202605 |
Посмотрим на графике:
```
plt = df_crimes1.plot(xticks=df_crimes1.index, color=['g', 'olive'])
plt.set_xticklabels(df_fenc_agg.index, rotation='vertical')
plt.set_xlabel('')
plt.set_ylabel('Кол-во совершенных преступлений\nна 1 млн представителей расы')
plt
```
**Промежуточные выводы:**
> 1. Белые совершают в 2 раза больше преступлений, чем черные, в абсолютном выражении, но в 3 раза меньше в относительном выражении (на миллион представителей своей расы).
>
> 2. Преступность среди белых относительно монотонно растет на протяжении всего периода (выросла в 2 раза за 18 лет). Преступность среди черных также растет, но скачкообразно: с 2001 по 2006 г. резкий рост, с 2007 по 2016 она даже убывала, с 2017 года опять резкий рост. За весь период преступность среди черных выросла также в 2 раза (аналогично белым).
>
> 3. Если не принимать во внимание спад среди черной преступности в 2007-2016 гг., преступность среди черных растет более быстрыми темпами, чем среди белых.
>
>
Итак, мы ответили на **второй вопрос**:
**-** ***Представители какой расы статистически чаще совершают преступления?***
**- Черные статистически совершают преступления в 3 раза чаще белых.**
Криминальность и гибель от рук полиции
--------------------------------------
Теперь мы подошли к самому важному: необходимо ответить на третий поставленный вопрос, а именно "*Можно ли сказать, что полиция стреляет насмерть пропорционально количеству совершаемых преступлений?*"
То есть надо как-то проследить корреляцию между двумя нашими наборами данных - данных по жертвам полиции и данных по преступлениям.
Начнем с того, что объединим эти два датасета в один:
```
# объединяем датасеты
df_uof_crimes = df_fenc_agg.join(df_crimes1, lsuffix='_uof', rsuffix='_cr')
# удаляем лишние столбцы (абс. показатели по жертвам)
df_uof_crimes = df_uof_crimes.loc[:, 'White_pop':'Black_promln_cr']
```
Что получили?
| | White\_pop | Black\_pop | White\_promln\_uof | Black\_promln\_uof | White\_promln\_cr | Black\_promln\_cr |
| --- | --- | --- | --- | --- | --- | --- |
| Year | | | | | | |
| 2000 | 218756353 | 35410436 | 1.330247 | 4.179559 | 6115.058976 | 17697.409882 |
| 2001 | 219843871 | 35758783 | 1.605685 | 4.418495 | 6829.701429 | 20431.707645 |
| 2002 | 220931389 | 36107130 | 1.643044 | 4.458953 | 7282.333249 | 20972.838329 |
| 2003 | 222018906 | 36455476 | 1.747599 | 4.910099 | 7857.691182 | 22218.966500 |
| 2004 | 223106424 | 36803823 | 1.949742 | 4.265861 | 8826.576863 | 26308.815799 |
| 2005 | 224193942 | 37152170 | 2.016112 | 4.871855 | 9713.826255 | 30616.569637 |
| 2006 | 225281460 | 37500517 | 2.041890 | 5.653255 | 10252.894313 | 33189.382429 |
| 2007 | 226368978 | 37848864 | 1.983487 | 5.786171 | 10566.527362 | 34100.495064 |
| 2008 | 227456495 | 38197211 | 1.943229 | 5.576323 | 10580.520024 | 34052.276749 |
| 2009 | 228544013 | 38545558 | 2.091501 | 6.459888 | 10889.263592 | 33954.651792 |
| 2010 | 229397472 | 38874625 | 2.205778 | 5.633495 | 10977.017218 | 33884.236826 |
| 2011 | 230838975 | 39189528 | 2.499578 | 7.399936 | 11035.346176 | 32946.454471 |
| 2012 | 231992377 | 39623138 | 2.724227 | 7.621809 | 11562.836825 | 33150.706035 |
| 2013 | 232969901 | 39919371 | 2.974633 | 7.765653 | 11211.113491 | 32207.571607 |
| 2014 | 233963128 | 40379066 | 3.009021 | 6.538041 | 11227.354594 | 31517.346141 |
| 2015 | 234940100 | 40695277 | 3.102919 | 6.683822 | 11564.786088 | 31764.865490 |
| 2016 | 234644039 | 40893369 | 3.081263 | 6.578084 | 12193.026562 | 33186.064958 |
| 2017 | 235507457 | 41393491 | 3.154889 | 6.401973 | 12656.261666 | 34900.390499 |
| 2018 | 236173020 | 41617764 | 3.281493 | 6.367473 | 13180.171893 | 37805.202605 |
Давайте вспомним, что хранится в каждом поле:
1. **White\_pop** - численность белых
2. **Black\_pop** - численность черных
3. **White promln\_uof** - количество жертв полиции среди белых (на 1 млн)
4. **Black promln\_uof** - количество жертв полиции среди черных (на 1 млн)
5. **White promln\_cr** - количество преступлений, совершенных белыми (на 1 млн)
6. **Black promln\_cr** - количество преступлений, совершенных черными (на 1 млн)
Наверное, можно было бы не полениться и дать этим столбцам русские названия... Но я надеюсь, читатели меня простят :)
Взглянем, как соотносятся графики преступлений и жертв полиции для каждой расы. Начнем с белых - в шахматном порядке :)
```
plt = df_uof_crimes['White_promln_cr'].plot(xticks=df_uof_crimes.index, legend=True)
plt.set_ylabel('Кол-во преступлений среди белых на 1 млн чел.')
plt2 = df_uof_crimes['White_promln_uof'].plot(xticks=df_uof_crimes.index, legend=True, secondary_y=True, style='g')
plt2.set_ylabel('Кол-во жертв среди белых на 1 млн чел.', rotation=90)
plt2.set_xlabel('')
plt.set_xlabel('')
plt.set_xticklabels(df_uof_crimes.index, rotation='vertical')
plt
```
То же самое на диаграмме рассеяния:
Отметим мимоходом, что определенная корреляция есть. ОК, теперь то же для черных:
```
plt = df_uof_crimes['Black_promln_cr'].plot(xticks=df_uof_crimes.index, legend=True)
plt.set_ylabel('Кол-во преступлений среди черных на 1 млн чел.')
plt2 = df_uof_crimes['Black_promln_uof'].plot(xticks=df_uof_crimes.index, legend=True, secondary_y=True, style='g')
plt2.set_ylabel('Кол-во жертв среди черных на 1 млн чел.', rotation=90)
plt2.set_xlabel('')
plt.set_xlabel('')
plt.set_xticklabels(df_uof_crimes.index, rotation='vertical')
plt
```
И скаттерплот:
Здесь все намного хуже: тренды явно "пляшут", хотя общая тенденция все равно прослеживается: пропорция здесь явно прямая, хотя и нелинейная.
Давайте воспользуемся методами матстатистики для определения величины этих корреляций, построив корреляционную матрицу на основе [коэффициента Пирсона](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%80%D1%80%D0%B5%D0%BB%D1%8F%D1%86%D0%B8%D1%8F):
```
df_corr = df_uof_crimes.loc[:, ['White_promln_cr', 'White_promln_uof', 'Black_promln_cr', 'Black_promln_uof']].corr(method='pearson')
df_corr.style.background_gradient(cmap='PuBu')
```
Получаем такую картинку:
| | White\_promln\_cr | White\_promln\_uof | Black\_promln\_cr | Black\_promln\_uof |
| --- | --- | --- | --- | --- |
| White\_promln\_cr | 1.000000 | 0.885470 | 0.949909 | 0.802529 |
| White\_promln\_uof | **0.885470** | 1.000000 | 0.710052 | 0.795486 |
| Black\_promln\_cr | 0.949909 | 0.710052 | 1.000000 | 0.722170 |
| Black\_promln\_uof | 0.802529 | 0.795486 | **0.722170** | 1.000000 |
Коэффициенты корреляции для обеих рас выделены жирным: для белых = **0.885**, для черных = **0.722**. Таким образом, положительная корреляция между гибелью от полиции и преступностью прослеживается и для белых, и для черных, но для белых она гораздо выше (статистически значима), в то время как для черных она близка к статистической незначимости. Последний результат, конечно, связан с большей неоднородностью данных как по жертвам полиции, так и по преступлениям среди черных.
Напоследок для этой статьи попробуем выяснить, какова вероятность белых и черных преступников быть застреленным полицией. Прямых способом это выяснить у нас нет (нет данных по тому, кто из погибших от рук полиции был зарегистрирован как преступник, а кто как невинная жертва). Поэтому пойдем простым путем: разделим удельное количество жертв полиции на удельное количество преступлений по каждой расовой группе (и умножим на 100, чтобы выразить в %):
```
# агрегированные значения (по годам)
df_uof_crimes_agg = df_uof_crimes.loc[:, ['White_promln_cr', 'White_promln_uof', 'Black_promln_cr', 'Black_promln_uof']].agg(['mean', 'sum', 'min', 'max'])
# "вероятность" преступника быть застреленным
df_uof_crimes_agg['White_uof_cr'] = df_uof_crimes_agg['White_promln_uof'] * 100. / df_uof_crimes_agg['White_promln_cr']
df_uof_crimes_agg['Black_uof_cr'] = df_uof_crimes_agg['Black_promln_uof'] * 100. / df_uof_crimes_agg['Black_promln_cr']
```
Получаем такие данные:
| | White\_promln\_cr | White\_promln\_uof | Black\_promln\_cr | Black\_promln\_uof | White\_uof\_cr | Black\_uof\_cr |
| --- | --- | --- | --- | --- | --- | --- |
| mean | 10238.016198 | 2.336123 | 30258.208024 | 5.872145 | **0.022818** | **0.019407** |
| sum | 194522.307758 | 44.386338 | 574905.952459 | 111.570747 | 0.022818 | 0.019407 |
| min | 6115.058976 | 1.330247 | 17697.409882 | 4.179559 | 0.021754 | 0.023617 |
| max | 13180.171893 | 3.281493 | 37805.202605 | 7.765653 | 0.024897 | 0.020541 |
Отобразим полученные значения в виде столбчатой диаграммы:
```
plt = df_uof_crimes_agg.loc['mean', ['White_uof_cr', 'Black_uof_cr']].plot.bar(color=['g', 'olive'])
plt.set_ylabel('Отношение кол-ва жертв к кол-ву преступлений')
plt.set_xticklabels(['Белые', 'Черные'], rotation=0)
```
На диаграмме видно, что вероятность белого преступника быть застреленным несколько выше, чем черного преступника. Конечно, этот анализ весьма условный, но все же дает какое-то представление.
**Промежуточные выводы:**
> 1. Гибель от рук полиции *связана* с криминальностью (количеством совершаемых преступлений). При этом эта корреляция неоднородна по расам: для белых она близка к идеальной, для черных далека от идеальной.
>
> 2. При рассмотрении совмещенных диаграмм гибели от полиции и преступности видно, что фатальные встречи с полицией растут "в ответ" на рост преступности, с лагом в несколько лет (особенно видно по данным среди черных). Это согласуется с логическим предположением о том, что власти "отвечают" на преступность (больше преступлений -> больше безнаказанности -> больше стычек с представителями закона -> больше смертельных исходов).
>
> 3. Белые преступники немного чаще встречают смерть от рук полиции, чем черные. Однако эта разница почти несущественна.
>
>
Итак, ответ на **третий вопрос**:
**-** ***Можно ли сказать, что полиция стреляет насмерть пропорционально количеству совершаемых преступлений?***
**- Да, такая корреляция наблюдается, хотя она неоднородна по расам: для белых почти идеальная, для черных - почти неидеальная.**
**В** [**следующей части статьи**](https://habr.com/ru/post/518202/) **посмотрим на географическое распределение анализируемых данных по штатам США.**
> [Ссылка на английскую версию статьи](https://habr.com/ru/post/519484/) (по просьбам трудящихся).
>
> | https://habr.com/ru/post/517782/ | null | ru | null |
# Конвертер аудио / видео файлов FFmpeg
1 Введение
Каждый пользователь хотя бы раз использовал компьютер для просмотра фильмов или прослушивания музыки. Большинство из Вас знает о существовании различных форматов как аудио-, так и видеоинформации. Каждый формат предназначен для своей цели.
Так MP4 удобен для воспроизведения на мобильных устройствах за счет высокой степени сжатия. Файлы формата MKV имеют огромные размеры, но вместе с тем высококачественное видео и звук. Формат AVI даже не самостоятельный формат, а оболочка для упаковки медиаданных других форматов. Строго говоря, MKV — это тоже контейнер, основанный на двоичном аналоге языка XML [[1]](http://ru.wikipedia.org/wiki/Matroska). Это позволяет расширять формат без утери совместимости со старыми программами.
Список можно продолжать долго. Часто возникает необходимость перевести, например, фильм из одного формата в другой. Например это может понадобится для просмотра видео на мобильном телефоне или DVD-плеере, которые не поддерживают воспроизведение исходного формата.
В этом случае Вам пригодится простой, но вместе с тем необычайно мощный инструмент — конвертер FFmpeg.
1.1 Общая характеристика
Описание в данном разделе составлено по материалам Wikipedia [[2]](http://ru.wikipedia.org/wiki/Ffmpeg) и страниц помощи MAN операционной системы Ubuntu 10.04 LTS.
Итак, FFmpeg — это набор библиотек с открытым исходным кодом. Проект создал Фабрис Беллар. Так как исходный код открыт, программа может быть скомпилирована (создана) под любую операционную систему. Утилита FFmpeg — это интерфейс для этих библиотек. Она работает из командной строки. Многим современным пользователям это может показаться не удобным, однако командная строка позволяет не отнимать ресурсы системы на отображение графических элементов, чем ускоряет работу программы.
FFmpeg — это целая система. В ее состав входят кодеки, сервер для потокового вещания, утилита для конвертирования видео файлов и даже простейший проигрыватель. Нас сейчас будут интересовать в основном возможности этой системы по преобразованию файлов.
FFmpeg поддерживает большинство распространенных форматов. Так как разработка системы не прекращена до сих пор, сложно будет привести полный их список. Конечно же, FLV, AVI, MP4 входят в их число. За все время мне не удалось обнаружить ни одного формата, который бы не поддерживался в FFmpeg.
Кроме возможностей по конвертации файлов в разные форматы FFmpeg может конвертировать видео формат в аудио дорожку, «захватить» потоковое видео или устроить широковещательную трансляцию. Возможности просто огромны. Кроме того интерфейс командной строки был разработан интуитивно понятным. Так, например, большинство форматов распознается по указанным расширениям входного и выходного файлов.
FFmpeg имеет широкие возможности обработки аудио- и видео данных. Так, например, можно изменить частоту дискретизации для аудио формата, звуковой дорожки фильма, обрезать или масштабировать кадры.
FFmpeg можно использовать для потокового преобразователя видео или аудио. Можно и дальше перечислять достоинства системы, но давайте лучше перейдем к ее изучению и попутно с ними познакомимся.
1.2 Первые шаги
Любая дорога начинается с первого шага. Так давайте же начнем. Сразу оговорюсь: я предполагаю, что утилита FFmpeg уже установлена в Вашей системе. Если это не так, Вам придется позаботиться об этом самостоятельно. Дело в том, что установка для разных операционных систем сильно отличается. Чтобы статья была универсальной и не содержала лишнего объема, здесь содержится только описание процесса использования.
Итак, предположим мы имеет видео файл film.mkv. Этот формат обеспечивает очень высокое качество изображения, но требователен к ресурсам системы. Кроме того, мобильные устройства его, чаще всего, не поддерживают. Существует формат MP4. Он очень хорошо «сжимает» видео данные и поддерживается большинством устройств с низкими системными требованиями. Чтобы перевести наш файл в этот формат нужно перейти в каталог с файлом film.mkv и дать команду:
`ffmpeg -i film.mkv film.mp4`
В том же каталоге появится файл film.mp4. Просто, правда? Большая часть настроек установлена «по умолчанию». Форматы файлов определены автоматически. Но делать так не советую и вот почему: современные видео данные имеют очень хорошее качество. Оно зависит от многих параметров, но, на мой взгляд, определяющими являются три: битрейт, частота кадров и кодек.
Битрейт — это количество информации в битах, которое необходимо обработать в секунду той программе, которая будет показывать Ваш фильм или воспроизводить Ваш звук. По умолчанию битрейт устанавливается равным 200 kb/s. Даже если на звуковую дорожку приходится 64 kb/s, а частота кадров — 15 fps (15 кадров в секунду), значит на один кадр приходится примерно 9 kb или около килобайта. Даже с современными технологиями сжатия видео не о каком качестве не может быть и речи.
От битрейта, как Вы понимаете, напрямую зависит размер конечного файла. В каждом конкретном случае битрейт подбирается индивидуально и общих рекомендаций здесь дать нельзя. Чтобы задать максимальный битрейт, команду нужно дополнить следующим образом:
`ffmpeg -i film.mkv -b 1200k film.mp4`
Теперь максимальный битрейт в 6 раз больше, чем установленный «по умолчанию» и качество изображения очень заметно повысится.
Частота кадров — это количество кадров, которое проходит на экране за секунду. Стандартная телевизионная частота — 24 fps, т. е. за одну секунду воспроизводится 24 кадра. Каждый кадр — это по сути картинка. Стандартная частота для цифрового видео — 15-16 fps. Таким образом, можно увеличить битрейт, но выиграть в размере файла за счет снижения частоты кадров. Для человеческого глаза это будет почти не заметно, а размер видео уменьшится примерно в полтора раза.
Чтобы установить частоту кадров, предыдущую команду нужно дополнить следующим образом:
`ffmpeg -i film.mkv -b 1200k -r 16 film.mp4`
После выполнения команды в каталоге появится файл film.mp4, максимальный битрейт которого равен 1200 kb/s, а частота кадров — 16 fps.
Преобразование к меньшей частоте происходит путем изъятия «лишних» кадров. Преобразование к большей частоте, надо полагать — путем дублирования соседних кадров. Как Вы понимаете, на качество такое преобразование не влияет, а вот на размер — очень даже.
И еще одна базовая операция: изменение размера кадра. Такое изменение возможно путем масштабирования или обрезки каждого кадра. Здесь я рассмотрю только масштабирование.
Ситуация: наш фильм имеет размер кадра 640 × 480. Ваш мобильный телефон воспроизводит только формат MP4 и имеет размер экрана 320 × 240. Для того, чтобы изменить размер каждого кадра фильма, предыдущую команду нужно изменить следующим образом:
`ffmpeg -i film.mkv -b 1200k -r 16 -s 320x200 film.mp4`
В каталоге появится файл film.mp4 с максимальным битрейтом 1200 kb/s, частотой кадров 16 fps и размером кадров 320 × 240 точек. Увеличивать размер кадров не стоит по тем же причинам, что и их частоту.
Таким образом можно установить любой размер кадра, даже не кратный исходному (это приведет к деформации изображения, но возможно). Большинство же фильмов и роликов имею стандартные размеры. Например, 320 × 240, 640 × 480, 1024 × 768, 1600 × 1200 и так далее. Для большинства из них (возможно и для всех) существуют буквенные обозначения. Так предыдущая команда может быть записана в виде:
`ffmpeg -i film.mkv -b 1200k -r 16 -s qvga film.mp4`
Результат совершенно аналогичный. Запомнить форматы (во всяком случае, основные) довольно просто. Например, 640 × 480 — это, как Вам известно, VGA; 320 × 240 — это QVGA (то есть, четверть VGA). Почему четверть? Мысленно проведите на поле VGA две линии, делящие их по вертикали и горизонтали пополам. Получится четыре прямоугольника, размерами 320 × 240. Вот поэтому четверть VGA. Буквенные обозначения приведены ниже. Список форматов не полон, но остальные размеры кадра просто сумасшедшие и редко встречаются. Вы можете узнать о них из справочной страницы FFmpeg, хотя вряд ли они Вам когда-нибудь понадобятся.
`sqcif - 128 × 96
qqvga - 60 × 120
uxvga - 1600 × 1200
qcif - 176 × 144
qvga - 320 × 240
qxga - 2048 × 1536
cif - 352 × 288
vga - 640 × 480
sxga - 1280 × 1024
4cif - 704 × 576
svga - 800 × 600
qsxga - 2560 × 2048
16cif - 1408 × 1152
xvga - 1024 × 768
hsxga - 5120 × 4096`
Как вы думаете, что произойдет, если дать системе команду:
`ffmpeg -i film.mkv film.mp3`
Совершенно верно: произойдет копирование звуковой дорожки в файл film.mp3. Вот так просто можно отделить видео от звука.
Часто возникает необходимость преобразовать видео файл к формату, пригодному для записи на стандартный носитель (например, диск DVD). Такие носители имеют специальную структуру и некоторые ограничения. Просто записать файл на диск не достаточно. Чтобы учесть все это нам пришлось бы сообщать FFmpeg массу параметров, многие из которых ни Вы ни я даже не знаем. К счастью авторы программы позаботились об этом. Достаточно указать один параметр, а остальные выставляются автоматически. Так для подготовки к записи файла film.mkv на DVD-диск нужно дать команду:
`ffmpeg -i film.mkv -target dvd film.mpg`
Как всегда в каталоге появляется конечный файл, готовый для записи на диск. Список распространенных форматов (их имя нужно подставить в команду вместо dvd) можно узнать на справочной странице программы. Наиболее распространенными из них являются `vcd, svcd, dvd, dv, dv50, pal- vcd, ntsc-svcd`. Эти обозначения можно непосредственно подставлять в поле `-target` последней команды. Если Ваша операционная система не чувствительна к расширению (у Вас Linux, например), расширение файла не имеет значения.
Можно задать формат выходного файла не зависимо от расширения. Для этого нужно дать команду:
`ffmpeg -f mp4 -i film.mkv -b 1200k -r 16 -s qvga film`
В каталоге появится файл film без расширения, однако имеющий формат MP4. Названия форматов совпадают с расширениями для файлов этих форматов.
В статье упоминались кодеки и форматы файлов. Можно узнать, какие из них доступны именно вам. Для это нужно дать команды:
`ffmpeg -codecs
ffmpeg -formats`
Первая команда выведет список доступных кодеков, вторая — список доступных форматов (включая аудио).
Вот и все. Базовый курс работы с программой FFmpeg Вы успешно прошли. Теперь Вы сможете выполнить большинство задач по конвертированию файлов и тех, с которыми сталкиваеся среднестатистический пользователь. Если у Вас возникли вопросы, задавайте их по адресу mailto:mna-norn@mail.ru с темой «FFmpeg». Письма с не знакомых адресов без этой темы буду удалять, не читая. На этом статья окончена. Спасибо за внимание. | https://habr.com/ru/post/119834/ | null | ru | null |
# Обнаружение пересекающихся сообществ в Instagram для определения интересов пользователей
Сколько может рассказать о человеке профиль в соцсети? Фотографии, посты, комментарии, подписки – непаханное поле для анализа. Сегодня поговорим о том, как мы определяем интересы пользователей на основе их подписок в сети Instagram.
 [*Источник*](http://memesmix.net/meme/ge4c6o)
Очевидный подход – разложить подписки человека по категориям. Допустим, среди подписок пользователя Ивана мы обнаружили двух автоблогеров и три аккаунта со смешными картинками, остальные профили не тематические (будем считать, что это друзья, родственники, коллеги и т. д.). Отсюда делаем вывод: Иван веселый человек, увлекается автомобилями. Профит. Все, что нам нужно – это соответствие “блогер + тематика контента”, но здесь не все так просто.
Кто такой блогер? Блогер в Instagram ничем не отличается от обычного аккаунта (и вообще, это что-то вроде состояния души). В идеале нас интересуют тематические аккаунты с большой долей живой аудитории, при этом не хотелось бы просто отсекать по числу подписчиков, можем что-то упустить.
Где взять хорошую таксономию? Если придумывать категории самостоятельно, то обязательно что-нибудь интересное затеряется в “разном”, а когда все будет готово, окажется, что категории слишком широкие. Мы же хотим получить естественное разбиение, а поэтому будем блогеров кластеризовать.
Может ли один блогер относиться к нескольким категориям? Еще как! Очень часто он одновременно и швец, и жнец, и на дуде игрец (а еще тревел, лайфстайл, жена и мама).
Итак, нам нужен датасет с очень большим числом блогеров и алгоритм кластеризации с пересекающимися кластерами на выходе.
###### С чего все началось
К нам обращаются клиенты, которые хотят разместить свою рекламу у лидеров мнений в Instagram наиболее эффективно. Иногда есть список блогеров, и тогда мы решаем задачу оптимизации – охватить больше людей за меньшие деньги, а иногда списка нет и релевантных блогеров надо найти. На этот раз искали профили врачей-офтальмологов.
Мы использовали подход, похожий на рекомендательную систему:
1. Выбираем 3-7 подходящих профилей руками (“ядро сообщества”)
2. С помощью пересечения подписчиков определяем людей, которые интересуются темой (“увлеченные”)
3. Ищем в подписках “увлеченных” людей новых врачей
4. В случае необходимости повторяем шаги 1-3 (добавляя новых врачей к “ядру” или меняя его)
Теперь подробнее на примере.
Шаг 1. С помощью поиска в Instagram отобрали 6 аккаунтов врачей-офтальмологов из разных регионов России:
Список довольно случайный, но нам было достаточно того, что блог действительно соответствует тематике и подписчиков не меньше, чем 1000 человек.
Шаг 2. После пересечения всех подписчиков смотрим на распределение.
| Number of mutual followings | Number of accounts |
| --- | --- |
| 6 | 2 |
| 5 | 3 |
| 4 | 24 |
| 3 | 102 |
| 2 | 693 |
| 1 | 30025 |
Ура! Пересечения есть.
Более того, есть два человека, которые подписаны на все шесть профилей! Итак, теперь нужно определить, кого считаем “увлеченными” офтальмологией. Мы решили, что берем всех, начиная с трех подписок. Как говорится, 1 раз — случайность, 2 раза — совпадение, 3 — уже закономерность. Таким образом, нашли 131 (2+3+24+102) “увлеченного” пользователя.
Шаг 3. Загружаем подписки “увлеченных” людей и опять всячески агрегируем.
Получили внушительный список аккаунтов, из которых теперь будем отбирать новых офтальмологов. Правый столбец показывает, сколько из 131 человека, которые отобраны на втором шаге, подписаны на профиль. В топе оказались профили из нашей изначальной шестерки, что неудивительно. Если мы сейчас подберем порог и скажем: “Все профили со значением count больше десяти – новые врачи”, то мы рискуем отнести популярные аккаунты вроде Ольги Бузовой к врачам-офтальмологам и в то же время потерять меленькие, но релевантные профили, поэтому добавим еще одним столбцом количество подписчиков и рассчитаем долю увлеченных пользователей среди подписчиков.
Для удобства доля умножена на 100 (так что share – это по факту процент). В итоге с условием count >= 6 и share >= 0.05 получили 166 новых врачей-офтальмологов. Класс!
Шаг 4. 172 аккаунта стали новым “ядром” сообщества, это помогло найти ещё примерно 500 новых офтальмологов, но результат уже смещался в зарубежные аккаунты.
###### Похожие аккаунты в рекомендациях Instagram
Это все, конечно, интересно, и теперь мы умеем неплохо находить похожие друг на друга аккаунты, но мы все еще мечтаем получить разбивку всех инстаблогеров по категориям. И тут в голову пришла идея посмотреть на готовые рекомендации инстаграма.
Дело в том, что у тематических аккаунтов есть рекомендации, а у обычных людей – нет. Вот и ответ на вопрос, кого считать блогерами и минус одна головная боль. Ура!
В рекомендациях у одного блогера до 80 похожих профилей. У нас был список из 1000 российских блогов, начали с него. Взяли похожих, потом похожих похожих, потом … ну вы поняли:)
План был в том, что когда-нибудь этот процесс закончится, так как маленькие профили с парой сотен подписчиков в рекомендации не попадут, но фактически остановились мы, когда закончилось терпение. Всегда можно продолжить собирать датасет, но пока не пригодилось, с большой вероятностью почти всех российских блогеров мы охватили, и ладно.
Теперь у нас есть граф с 3 428 453 вершинами (блогеры) и 96 967 974 ребрами (похожесть двух блогеров между собой).
 *Так выглядит наш граф на очень маленьком сэмпле*
Кстати, оказалось, мы не первые решили использовать [такой подход.](https://lab.alexkuk.ru/insta/)
Судя по всему, рекомендации в Instagram формируются, исходя из того, на кого еще подписаны подписчики этого профиля, поэтому у врача из Брянска в рекомендациях будут популярные брянские аккаунты и другие врачи. Это похоже на наш поиск офтальмологов, но теперь мы можем учитывать все сообщества, к которым одновременно принадлежит блогер. Плюс, скорость обработки увеличивается в разы, потому что нет необходимости анализировать всех подписчиков блогера, достаточно взять всего 80 рекомендованных аккаунтов.
###### Выбор и описание алгоритма
Отлично! Данные подготовили, теперь надо выбрать инструмент и алгоритм, который справится с таким большим графом, желательно за адекватное время. Напомню, что на выходе мы хотим получить набор сообществ, где один блогер может принадлежать нескольким из них.
Мы остановили свой выбор на библиотеке Stanford Network Analysis Platform (SNAP)
> Stanford Network Analysis Platform (SNAP) is a general purpose network analysis and graph mining library. It is written in C++ and easily scales to massive networks with hundreds of millions of nodes, and billions of edges. It efficiently manipulates large graphs, calculates structural properties, generates regular and random graphs, and supports attributes on nodes and edges.
Наше внимание привлек алгоритм AGMfit (AGM – Affilated Graph Model), а использовали в итоге BIGCLAM (Cluster Affiliation Model for Big Networks). Отличаются они лишь тем, что в первом случае задача оптимизации решается комбинаторно, что делает его менее масштабируемым, а второй как раз позволяет подавать на вход графы вроде нашего.
Основная и довольно интуитивная мысль: чем больше у двух узлов общих сообществ, тем больше вероятность связи между этими двумя узлами. В основе обоих алгоритмов лежит Affilated Graph Model, так что остановимся на ней подробнее:
Предположим, у нас есть двудольный граф, в котором круглые вершины – это сообщества ( и ), а квадратные – пользователи соцсети, и каждый человек () относится к разным сообществам с определенными весами ( и ). Чем больше вес, тем больше вероятность того, что участник связан (знаком) с другими членами сообщества.
Пример: коллеги, которые учились в одном университете подписаны друг на друга в Instagram. Оба они являются выпускниками одного ВУЗа (сообщество 1) и работают в одной компании (сообщество 2), мы не знаем, что послужило причиной “дружбы” в сети и когда они познакомились. Пусть один только что окончил универ и устроился на работу, а второй выпустился пять лет назад и все это время работает в компании, тогда вес принадлежности первого к сообществу 1 будет больше, а к сообществу 2 – меньше и наоборот.
Для каждого общего сообщества пары человек мы получаем независимый шанс быть знакомыми:
Таким образом, чем больше общих сообществ, тем больше шансов знать друг друга:
Если посчитать вероятность связи между каждой парой пользователей, то на выходе получим граф, где вершины – это люди, а ребра между ними – это факт знакомства или подписка друг на друга.
Таким образом, от представления слева мы перешли к картинке справа.
Теперь поймем, как эта модель используется в обнаружении сообществ.
У нас есть граф похожих друг на друга блогеров и наша цель обнаружить  сообществ с помощью модели описанной выше, путем подбора наиболее подходящей матрицы весов  (ее размерность  узлов на  сообществ) так, чтобы полученный на выходе граф был похож на наш исходный. Делается это с помощью максимизации функции правдоподобия
А еще все это дело можно представить в виде неотрицательного матричного разложения, что как раз дает плюс в масштабируемости алгоритма BIGCLAM по сравнению с AGMfit.
Подробнее можно почитать [здесь](http://snap.stanford.edu/agm/) и [здесь](http://infolab.stanford.edu/~crucis/pubs/paper-nmfagm.pdf).
###### Подбор числа сообществ и запуск
В BIGCLAM можно задать как точное число сообществ, так и интервал. Алгоритм выбирает 20% пар узлов на тест, а на 80% происходит подгонка модели с разным числом сообществ.
Сформировали входной файлик со списком ребер и запускаем:
```
./bigclam -o:bloggers -i:query_graph_all.edgelist -c:-1 -nc:20 -mc:50000 -xc:200000 -nt:10
```
Параметры позволяют задавать количество попыток, минимальное и максимальное число сообществ (или точное, если необходимо), количество тредов для параллелизации и префикс выходных файлов. В нашем случае мы задали интервал от 50 до 200 тысяч сообществ с 20 попытками на 10 тредах. Все это великолепие считалось пять дней на 2 Intel® Xeon® Gold 6150 CPU @ 2.70GHz. На выходе получили два файла один для Gephi, второй текстовый, в котором каждая строка – это сообщество.
На самом деле, мы запускали алгоритм дважды и первый раз уперлись в верхнюю границу в 50 тысяч сообществ, результат был неплохой, но часто попадались смешанные сообщества. В этот раз мы опять попали в максимальное значение в 200 тысяч сообществ, но они были гораздо более качественные, на этом и остановились. Вероятно, можно было получить результат еще лучше, но двести тысяч сообществ без названий и так пугали наше воображение.
 *Красивая картинка*
Что же теперь со всем этим делать?
С одной стороны, полученные сообщества помогают нам быстро искать узкие группы блогеров (как тогда с офтальмологами). Если есть парочка блогеров для примера, то берем все сообщества, в которые они входят, отбрасываем ненужные и все. Можно использовать поиск по названиям, вот, например, одно из сообществ про декор и дизайн интерьера:
С другой стороны, для определения интересов пользователей все эти сообщества надо как-то осмысленно назвать. А может быть, все и не нужно.
###### CRank
К сожалению, не все полученные сообщества одинаково хороши, и для обнаружения наиболее интересных решили попробовать использовать метод приоритезации CRank из той же библиотеки SNAP. Он призван автоматически на основе структуры графа сопоставить каждому сообществу ранг: чем больше значение, тем лучше сообщество.
На вход программе подаем найденные ранее сообщества, для каждого из них вычисляются метрики приоритизации (4 штуки), затем эти метрики агрегируются, и мы получаем оценку.
Подробнее можно почитать [тут](http://snap.stanford.edu/crank/).
Запуск
```
./crank -i:bloggers_cmtyvv.txt -c:query_graph_all.edgelist -o:bloggers_prioritization.txt
```
Во время запуска столкнулись с проблемой совместимости с Ubuntu 18.04, [здесь](https://github.com/snap-stanford/snap/issues/146) предлагают решение.
Так как наш файл с полученными сообществами bloggers\_cmtyvv.txt и список ребер query\_graph\_all.edgelist изначально содержали никнеймы (типа string), пришлось их захэшировать, чтобы было int, иначе crank ругается.
Посмотрим, как это работает на примере:
Выберем несколько сообществ, где встречаются профили, содержащие в названии строку “lokomotiv”, по задумке это должны быть сообщества футбольных болельщиков клуба “Локомотив”, посмотрим, что же на самом деле. Красным цветом обозначены участники сообщества, под каждой картинкой соответствующий score.
 *Сообщество 1, score 0.4*
 *Сообщество 2, score 0.41*
 *Сообщество 3, score 0.34*
 *Сообщество 4, score 0.13*
Затем, просмотрев все профили из этого подграфа, выделяем тех, кто действительно относится к искомому сообществу, получилось вот так:
Получается, что первые два сообщества на самом деле содержат то, что нам нужно, практически без ошибок (за исключением профиля сборной РФ по футболу teamrussia), третье сообщество хорошее, но покрывает меньше аккаунтов, чем первые два, поэтому и score поменьше, а четвертое сообщество хоть и состоит из аккаунтов на околофутбольную тему (здесь и футболисты других клубов, и их жены, и менеджеры), но мимо, нам не подходит.
Можно сделать вывод, что CRank работает весьма неплохо.
###### Ручная разметка для раскраски и результаты
Для решения задачи раскраски пользователей по интересам, мы также анализируем тексты постов и нам хотелось посмотреть, где лучше/интереснее результат (в текстах или в подписках) и вообще есть ли совпадения. Для небольшой выборки людей пришлось самостоятельно разметить около 800 сообществ. Результатом мы остались более чем довольны и решили, что этот подход стоит развивать. Метод обнаружения сообществ позволяет находить очень узкие и необычные категории интересов, например, подписка на профили крыс (в смысле маленьких сереньких грызунов) и прочие удивительные вещи, можно узнать, каким именно видом спорта предположительно увлекается человек, а не запихивать всё в категорию “экстрим” и т д
Размечать все 200 тысяч сообществ мы, вероятно, не будем, но, может быть, поиграемся с результатами CRank и оставим только сообщества с высоким скором, а может, будем размечать по мере необходимости. Такие дела :)
Спасибо!
*Статья написана совместно с моим руководителем Артёмом Королёвым ([korolevart](https://habr.com/ru/users/korolevart/)) R&D Dentsu Aegis Network Russia*
 *[Источник](https://me.me/i/when-people-ask-why-your-instagram-is-private-memes-forme-18992481)* | https://habr.com/ru/post/470634/ | null | ru | null |
# Пишем аудио-разведчик своими руками
Было бы здорово иногда иметь под рукой программку, которая в наше отсутствие умеет записывать звук со встроенного микрофона нашего ноутбука и передавать его по сети на другой наш комьютер. А тот, в свою очередь, этот звук умел бы воспроизводить в режиме реального времени. Давай попробуем самостоятельно написать такую программу, тем более что это, как оказывается, не так уж и сложно.
Содержание:
* Описание
* Алгоритм записи и воспроизведения звука
* Устанавливаем необходимые библиотеки
* Пишем сервер: запись звука
+ Шаг 1. Получаем удобный интерфейс для работы с аудио-подсистемой
+ Шаг 2. Создаём буфер и привязываем его к аудио устройству
+ Шаг 3. Читаем аудио поток из звукового буфера
+ Представление звуковых данных
+ Шаг 4. Закрываем аудио буфер и звуковую подсистему
* Билдим сервер
* Пишем клиент
* Сетевое взаимодействие
+ Сервер
+ Клиент
* Проверяем, что получилось
* Доработать напильником
* Итоги
### Описание
Что мы в итоге хотим получить и какой алгоритм работы реализовать:
* Сервер, который запускается на той машине, пространство вокруг которой мы хотим прослушивать. Он тихо ждёт, пока к нему не подключится клиент. Затем он открывает устройство записи звука, настроенное по умолчанию в системе, и начинает передавать аудио поток на машину клиента. При отключении клиента от сервера, звуковое устройство закрывается, чтобы не тратить ресурсы зря.
* Клиент, который подключается к серверу и начинает принимать аудио поток и воспроизводить его в режиме реального времени. Для того, чтобы клиент мог правильно (в нужном формате) открыть устройство воспроизведения звука, он получает нужную мета информацию от сервера в Hello сообщении.
Единственное, что нужно иметь в виду - это то, что не все устройства поддерживают одинаковые конфигурации звука. В теории, может оказаться так, что сервер открыл устройство в каком-то формате, а звуковое устройство на машине клиента просто напросто не поддерживает такой формат. В таком случае нужно использовать алгоритмы конвертации звукового потока, но эта информация не входит в данную статью.
Какие аудио-подсистемы будет поддерживать наша программа:
* ALSA (Linux)
* CoreAudio (macOS)
* DirectSound (Windows)
* OSS (FreeBSD)
* PulseAudio (Linux)
* WASAPI (Windows)
Сервер и клиент будут кросс-платформенными и поддерживать Windows, Linux, FreeBSD и macOS. И само собой разумеется, что например сервер может работать на Windows, а клиентом к нему будет программа под Linux, или как угодно иначе.
Какие пакеты для Линукса понадобятся (на примере Fedora):
* libalsa-devel (для ALSA)
* libpulse-devel (для PulseAudio)
Для остальных ОС дополнительно ничего устанавливать не надо.
### Алгоритм записи и воспроизведения звука
Прежде чем мы приступим к кодингу, я кратко расскажу в чём принцип работы со звуковой подсистемой.
Первым шагом нужно выбрать звуковое устройство. В системе может быть зарегистрировано несколько устройств. Они делятся на 2 типа: устройства записи и воспроизведения. В самом простом варианте на любом ноутбуке будет одно устройство для записи - встроенный микрофон, и одно для воспроизведения - встроенные колонки, они же будут являться устройствами по умолчанию. Любая программа может определить через звуковое API количество таких устройств, их свойства, в т.ч. иногда и список всех поддерживаемых этим устройством форматы звука. Однако в случае, когда нам нужно всего лишь использовать устройство по умолчанию, то мы можем пропустить этот шаг.
Далее, нужно открыть выбранное устройство для записи или воспроизведения, задав нужную конфигурацию. При этом происходит создание и привязка аудио буфера к этому устройству. Важнейшими характеристиками здесь является формат звука, а именно: ширина одного аудио сэмпла (как правило, 16 или 24 bit), частота сэмплов (например, 44100 или 48000 Hz) и количество каналов. Всегда нужно быть готовым к тому, что аудио-подсистема вернёт код ошибки, если устройство, которое мы пытаемся открыть, не поддерживает заданный формат. В таком случае нам нужно скорректировать нашу конфигурацию и попробовать снова. Бывает и так, что устройство в данный момент занято другим системным процессом. Так запросто может случиться, например, на Линуксе, если мы попытаемся открыть устройство напрямую через ALSA, в то время как оно же используется системным PulseAudio процессом.
Ещё одним важным параметром при открытии устройства является размер внутреннего аудио буфера. Чем меньше этот буфер, тем меньше задержка (latency), которая очень важна для некоторых приложений. Следует только помнить, что малый размер буфера увеличивает нагрузку на CPU, да и к тому же у каждого устройства есть свои внутренние ограничения на этот параметр. Как правило, размер буфера в 250мс или 500мс является достаточным для большинства приложений.
После того, как мы открыли устройство, мы можем начать работать с аудио потоком. Само собой, если это устройство звукозаписи, то мы читаем данные из него; если это устройство воспроизведения - мы пишем данные в него. Звуковой буфер - это как правило обычный кольцевой буфер, где запись и чтение бегут непрерывно по кругу.
Но здесь есть одна проблема: центральный процессор вечно хочет бежать вперёд, а звуковое устройство с данными работает равномерно. И здесь важно вовремя остановиться и ждать некоторое время, чтобы данные в кольцевом буфере не испортить. В режиме звукозаписи, если мы вычитали все имеющиеся данные, то мы должны ожидать, пока не будет доступен следующий кусок. А в режиме воспроизведения если буфер устройства заполнен на 100%, то мы должны ожидать, пока в нём не появится пустота.
В режиме воспроизведения есть ещё одна особенность - после того, как все имеющиеся данные успешно добавлены в звуковой буфер устройства, не правильно сразу закрывать используемое устройство, а нужно дождаться, пока оно не доиграет все имеющиеся данные. Для этого в буфер добавляется тишина нужной длины, и только теперь после одного оборота кольцевого буфера можно будет устройство закрывать.
Ну что же, слишком много теории - это скучно, поэтому давай приступим к практике.
### Устанавливаем необходимые библиотеки
Скачиваем или клонируем с Гитхаба репозитории с библиотеками, которые нам понадобятся:
```
git clone https://github.com/stsaz/ffbase
git clone https://github.com/stsaz/ffaudio
git clone https://github.com/stsaz/ffos
```
Зачем они нужны:
* ffbase - здесь хранится набор вспомогательных функций и базовых алгоритмов для C, без этого программировать на C очень уж не удобно
* ffaudio - библиотека для работы со звуком
* ffos - это чтобы нам удобно было писать кросс-платформенный код
### Пишем сервер: запись звука
#### Шаг 1. Получаем удобный интерфейс для работы с аудио-подсистемой.
Т.к. мы используем кросс-платформенную библиотеку ffaudio, то нам здесь вообще не нужно думать ни о каких различиях между разными API. Мы пишем код один раз, и он работает одинаково в любой конфигурации. Для начала подключаем хэдер со всеми необходимыми интерфейсами и enum-ами:
```
#include
```
Затем берём интерфейс звуковой подсистемы. Как именно он настраивается я объясню ниже в разделе "Билдим сервер".
```
const ffaudio_interface *audio = ffaudio_default_interface();
```
Далее мы везде работаем с этим интерфейсом, он позволяет делать всё, о чём мы говорили выше. Но самое первое - инициализируем аудио подсистему с конфигурацией по умолчанию:
```
ffaudio_init_conf aiconf = {};
audio->init(&aiconf);
```
Для WASAPI эта функция инициализирует систему COM-объектов через `CoInitializeEx()`. Для PulseAudio она подключается к PA серверу и создаёт отдельный поток для обработки событий. А для ALSA, DirectSound, OSS и CoreAudio на самом деле нет необходимости в этой функции.
#### Шаг 2. Создаём буфер и привязываем его к аудио устройству.
```
ffaudio_buf *abuf = audio->alloc();
ffaudio_conf aconf = {};
aconf.format = FFAUDIO_F_INT16;
aconf.sample_rate = 48000;
aconf.channels = 2;
int r = audio->open(abuf, &aconf, FFAUDIO_CAPTURE);
if (r == FFAUDIO_EFORMAT)
r = audio->open(abuf, &aconf, FFAUDIO_CAPTURE);
```
Вначале создаём объект аудио буфера через `ffaudio_interface::alloc()`. Можно иметь множество таких объектов одновременно, по-разному их настроить, привязать к разным звуковым устройствам. Единственное, что нужно помнить - не всегда можно привязать несколько буферов к одному и тому же устройству. Например, в ALSA и в WASAPI (в эксклюзивном режиме) сделать это точно не удастся.
Затем устанавливаем конфигурацию (структура `ffaudio_conf`) звукового буфера, где задаём формат 16bit, 48000Hz, стерео. В этой же структуре мы могли бы задать и идентификатор желаемого устройства, и желаемый размер буфера в миллисекундах, но можно и не задавать эти параметры - оставить всё по умолчанию.
Далее мы вызываем `ffaudio_interface::open()`, передавая ей на вход наш буфер, конфигурацию и флажки. Обрати внимание, что мы используем флаг `FFAUDIO_CAPTURE` - мы хотим открыть устройство звукозаписи. Внутри этой функции исполняется наиболее сложная логика по подготовке и настройке звукового устройства: каждое звуковое API требует знания некоторых нюансов, из-за чего, например для WASAPI, необходимо по меньшей мере 300 строк кода, чтобы все эти нюансы учесть (ты можешь разобраться в деталях, открыв код библиотеки ffaudio).
Функция `open()` возвращает код ошибки `FFAUDIO_EFORMAT`, в случае если не удалось открыть устройство в заданном нами формате. При этом она же сама находит наиболее близкий формат звука, которое звуковое устройство поддерживает, и обновляет объект конфигурации для нас. Теперь мы можем либо ещё раз скорректировать аудио формат, либо просто ещё раз вызвать эту функцию (что мы в нашем коде и делаем). Всегда необходимо проверять результаты всех вызовов на ошибки, и в случае чего прервать исполнение нашей программы и записать сообщение пользователю о том, что пошло не так. Для этого можно получить от аудио подсистемы более подробное описание ошибки через вызов `ffaudio_interface::error()`, передав ей наш объект аудио буфера:
```
const char *error = audio->error(abuf);
```
#### Шаг 3. Читаем аудио поток из звукового буфера
```
const void *buffer;
int r = audio->read(abuf, &buffer);
```
Функция `ffaudio_interface::read()` возвращает нам указатель на внутренний буфер, где находятся аудио сэмплы в interleaved формате, а также количество байт в этом буфере, которое мы можем безопасно прочитать.
#### Представление звуковых данных
Interleaved формат - это когда в одной непрерывной области памяти друг за другом идут значения сэмплов для каждого канала. Для стерео потока 16bit схематически это выглядит вот так:
```
short[0][L]
short[0][R]
short[1][L]
short[1][R]
...
```
где индексы 0 и 1 - порядковый номер сэмпла, а L и R - левый и правый каналы.
Иными словами, для разбора на сэмплы аудио потока 16bit/stereo нам нужно привести `void *buffer` к типу `short *` и умножать индекс нужного сэмпла на количество каналов (т.е. 2). Например возьмём значения сэмпла №9 для обоих каналов:
```
short *samples = (short*)buffer;
short sample_9_left = samples[9*2];
short sample_9_right = samples[9*2 + 1];
```
16-битные знаковые значения, которые мы здесь получили - это уровень звукового сигнала, где 0 - тишина. Но громкость звука обычно измеряют в значениях dB. Вот как мы можем к ним привести наши данные:
```
short sample = ...;
double gain = (double)sample * (1 / 32768.0);
double db = log10(gain) * 20;
```
Т.е. мы вначале конвертируем integer значение во float - получаем gain, в котором 0.0 - тишина, а +/-1.0 - максимально громкий сигнал. Затем, используя формулу `gain = 10 ^ (db / 20)`, переводим gain в dB. Если нужно перевести обратно, то можно использовать такой код:
```
#include // SSE2 функции. Есть на любом AMD64 процессоре.
double db = ...;
double gain = pow(10, db / 20);
double d = gain \* 32768.0;
short sample;
if (d < -32768.0)
sample = -0x8000;
else if (d > 32768.0 - 1)
sample = 0x7fff;
else
sample = \_mm\_cvtsd\_si32(\_mm\_load\_sd(&d));
```
Несмотря на то что в нашей программе не нужно разбирать поток на сэмплы, знание этого всё равно очень важно. Иначе получится, что мы работаем с какими-то данными, и даже не знаем что именно это за данные и как они устроены - это не путь настоящего хакера.
#### Шаг 4. Закрываем аудио буфер и звуковую подсистему
Каждый буфер, который мы создали через `ffaudio_interface::alloc()` мы должны закрыть с помощью `ffaudio_interface::free()`.
```
audio->free(abuf);
```
То же самое и со всей звуковой подсистемой: каждый вызов `ffaudio_interface::init()` должен в конце сопровождаться вызовом `ffaudio_interface::uninit()`, когда подсистема нам больше не нужна.
```
audio->uninit();
```
### Билдим сервер
Помнишь как в самом начале мы чудесным образом получили указатель на интерфейс аудио подсистемы?
```
const ffaudio_interface *audio = ffaudio_default_interface();
```
Однако чудес на самом деле не бывает, поэтому придётся чуточку разобраться в том, как правильно конфигурить сборку бинарника, использующего ffaudio. На самом деле эта функция лишь возвращает указатель на один из поддерживаемых интерфейсов звуковой подсистемы: ffalsa, ffpulse, ffwasapi, ffdsound, ffcoreaudio, ffoss. Кстати, мы можем использовать любой из этих интерфейсов напрямую и вообще не вызывать `ffaudio_default_interface()`.
Но в любом случае мы должны собрать как минимум по одному бинарю для каждой ОС и использовать поддерживаемую аудио подсистему. Для этого можно просто передать имя необходимой нам звуковой подсистемы на этапе сборки. И тогда `ffaudio_default_interface()` нам вернёт тот интерфейс, с которым мы этот бинарник и собирали. Я предлагаю сделать это следующим образом:
* Придумать некий параметр и передавать его на этапе сборки (например `make FFAUDIO_API=wasapi` для компиляции Windows бинарника с WASAPI)
* Далее, внутри Makefile'а устанавливаем параметр `FFAUDIO_INTERFACE_DEFAULT_PTR` Си препроцессору, например так:
```
CFLAGS += -DFFAUDIO_INTERFACE_DEFAULT_PTR="&ff$(FFAUDIO_API)"
```
* Далее, нам необходимо указать необходимые зависимости для Си линкера, например:
```
ifeq "$(FFAUDIO_API)" "alsa"
LINKFLAGS += -lasound
else ifeq "$(FFAUDIO_API)" "pulse"
LINKFLAGS += -lpulse
else ifeq "$(FFAUDIO_API)" "wasapi"
LINKFLAGS += -lole32
else ifeq "$(FFAUDIO_API)" "dsound"
LINKFLAGS += -ldsound -ldxguid
else ifeq "$(FFAUDIO_API)" "coreaudio"
LINKFLAGS += -framework CoreFoundation -framework CoreAudio
else ifeq "$(FFAUDIO_API)" "oss"
LINKFLAGS += -lm
endif
```
Минус предложенного мною решения лишь в том, что не получится вкомпилить функциональность ALSA+PulseAudio или WASAPI+DirectSound внутрь одного бинаря. Но это несложно исправить при необходимости: программно решить, какую подсистему мы хотим загружать, и взять нужный ffaudio интерфейс.
### Пишем клиент
Подготовка к воспроизведению звука в основном выглядит так же, как и для звукозаписи. Точно так же получаем интерфейс ffaudio, затем инициализируем звуковую подсистему, затем создаём звуковой буфер и привязываем его к устройству. Разница лишь в том, что в вызове `ffaudio_interface::open()` теперь нам надо передать флажок `FFAUDIO_PLAYBACK`. Всё, у нас уже готов поток для воспроизведения.
```
ffaudio_buf *abuf = audio->alloc();
ffaudio_conf aconf = {};
aconf.format = FFAUDIO_F_INT16;
aconf.sample_rate = 48000;
aconf.channels = 2;
int r = audio->open(abuf, &aconf, FFAUDIO_PLAYBACK);
```
Чтобы записать кусок звуковых данных в устройство воспроизведения вызываем `ffaudio_interface::write()`, передаём указатель на interleaved буфер и его размер в байтах. На выходе принимаем количество байт, которые ей удалось записать. Важно помнить, что это значение может быть меньше, чем мы передавали, поэтому тут нужен цикл. Но и не забываем про то, что функция может и ошибку вернуть.
```
char *samples = ...;
int length = ...;
while (length != 0) {
int r = audio->write(abuf, samples, length);
samples += r;
length -= r;
}
```
### Сетевое взаимодействие
Записывать звук мы научились, воспроизводить - тоже. Но нужно теперь записанный звук передать по сети клиенту, а клиент должен эти данные получить и отправить в звуковое устройство. Для этого мы будем использовать кросс-платформенную библиотеку ffos. Заморачиваться с асинхронными сокет операциями мы не будем, а напишем самый простой код.
#### Сервер
Итак, наш сервер будет ждать подключения клиента, посылать ему мета информацию в Hello сообщении, а затем посылать ему аудио поток, прочитанный из аудио устройства.
```
// инициализируем сокеты на Windows
// и блокируем SIGPIPE сигнал на Linux
ffsock_init(FFSOCK_INIT_SIGPIPE | FFSOCK_INIT_WSA);
// создаём слушающий сокет IPv4+TCP
ffsock lsk = ffsock_create_tcp(AF_INET, 0);
// привязываемся к 0.0.0.0:64000
ffsockaddr a = {};
ffsockaddr_set_ipv4(&a, NULL, 64000);
ffsock_bind(lsk, &a);
// начинаем слушать
ffsock_listen(lsk, SOMAXCONN);
// ждём, пока не присоединится клиент
ffsockaddr peer = {};
ffsock csk = ffsock_accept(lsk, &peer, 0);
```
При этом никогда не забываем проверять вызовы на ошибки. После того как клиент соединился, посылаем ему Hello сообщение, в котором передаём мета информацию об аудио потоке. Hello сообщение может быть следующего вида:
```
struct hello {
char version;
char opcode;
char format;
char sample_rate[4];
char channels;
};
```
Здесь первые 2 филда - версия протокола и код операции. А затем идёт описание формата аудио. Мы используем везде тип `char` для того, чтобы Си компилятор не упаковывал нашу структуру по своим правилам. Итак, формируем сообщение и посылаем клиенту следующим образом:
```
struct hello msg = { ... };
int r = ffsock_send(csk, &msg, sizeof(msg), 0);
```
Функция возвращает количество байт, которое было передано (а точнее, скопировано в системный буфер) по факту.
Затем просто в цикле считываем данные из звукового устройства и пересылаем их, как есть, клиенту.
```
for (;;) {
const void *data;
int length = audio->read(abuf, &data);
const char *d = data;
while (length != 0) {
int r = ffsock_send(csk, d, length, 0);
d += r;
length -= r;
}
}
```
Наконец, закрываем сокеты при завершении программы:
```
ffsock_close(csk);
ffsock_close(lsk);
```
Само собой, нужно учесть, что в случае ошибки взимодействия с клиентом, не нужно завершать весь сервер - нужно просто закрыть клиентский сокет и ждать следующего соединения. Иначе, наш сервер какой-то одноразовый получится.
#### Клиент
Наш клиент соединяется с сервером, получает от него мета информацию, открывает звуковое устройство с нужными параметрами и начинает передавать в него всё, что он получает от сервера.
```
// инициализируем сокеты на Windows
// и блокируем SIGPIPE сигнал на Linux
ffsock_init(FFSOCK_INIT_SIGPIPE | FFSOCK_INIT_WSA);
// создаём сокет IPv4+TCP
ffsock sk = ffsock_create_tcp(AF_INET, 0);
// соединяемся c 127.0.0.1:64000
ffsockaddr a = {};
char ip[] = {127,0,0,1};
ffsockaddr_set_ipv4(&a, ip, 64000);
ffsock_connect(sk, &a);
```
Читаем из сокета и воспроизводим:
```
for (;;) {
char buf[64*1024];
int length = ffsock_recv(sk, buf, 64*1024, 0);
char *d = buf;
while (data.len != 0) {
int r = audio->write(abuf, d, length);
d += r;
length -= r;
}
}
```
В целом у нас тут больше ничего особо интересного нет.
### Проверяем, что получилось
Полные исходники программы доступны здесь: <https://github.com/stsaz/audiospy>. Скомпилим бинари для Линукса с PulseAudio и проверим на localhost'е.
Запускаем сервер на TCP порту 64000:
```
./audiospy_sv 64000
```
Затем запускаем клиент:
```
./audiospy_cl 127.0.0.1 64000
```
Теперь мы можем сказать что-нибудь в микрофон, сервер запишет это и перешлёт клиенту (т.е. нам же самим). А клиент это воспроизведёт через колонки. Ура, работает!
### Доработать напильником
Есть несколько очевидных вещей, которые делают нашу программу неполноценной:
* Сервер умеет работать только с одним клиентом. Вообще нормальные сетевые приложения должны быть асинхронные с использованием kernel queue, например epoll или I/O Completion Ports.
* Нет сжатия аудио данных, из-за чего возникают большие требования к скорости соединения. Можно заиспользовать какую-нибудь библиотеку сжатия аудио, например Vorbis или Opus.
* Нет возможности конвертации звука, из-за чего клиент может не смочь открыть аудио поток в том формате, который используется сервером. Для этого нужны алгоритмы конвертации, в т.ч. sample rate convertor типа libsoxr.
### Итоги
Мы научились работать со звуковыми подсистемами, записывать и воспроизводить аудио потоки. Ещё мы поняли как устроены аудио сэмплы, и как их переводить в значения dB при необходимости. Ну и в итоге у нас есть полноценное приложение, которое можно использовать на своей аппаратуре в случае необходимости. Надеюсь, что это было тебе чем-то полезно.
По причине того, что я красиво рисовать не умею, использовал картинки отсюда (спасибо художникам!):
* [How to implement circular buffer video recording in C#](http://www.camera-sdk.com/p_54-how-to-implement-circular-buffer-video-recording-in-c-onvif.html).
* [The organisation of stereo data in interleaved stereo files](https://www.researchgate.net/figure/The-organisation-of-stereo-data-in-interleaved-stereo-files_fig17_326019555). | https://habr.com/ru/post/660861/ | null | ru | null |
# Mikrotik, Telegram и не только…
Здравствуйте, друзья!
Сегодня я хочу рассказать вам, как открыл для себя новый язык программирования, среду исполнения, а ещё готовый фронт-энд. И всё это без кучи фреймворков и тысяч библиотек, чистое, непаханое поле…
Однако, давайте по порядку.
Список языков программирования обширен и уже устоялся, по ним много информации и всевозможных курсов. Среды разработки выросли и обзавелись множеством полезных функций, это радует.
Но мне всегда хочется чего-то нового. Долго искать не пришлось, всё уже давно было под рукой. Это **Микротик.** Вместе с его **RouterOS**. Как оказалось тут есть практически всё, что нужно и для разработки, и для исполнения кода.
А фронтом стал **Телеграм с его bot API**. Тут можно создать приятный интерфейс и сделать взаимодействие с ботом, очень похожим на работу с обычной программой. Телеграм мультиплатформенный и с отличным бэк-эндом. Ему бы побольше элементов управления в API и цены б ему не было. Хотя, я уверен он будет развиваться.
Начать стоит с Микротика. Точнее, давайте рассмотрим его скриптовый язык. Он совсем не сложный и на первый взгляд не годится для серьёзной разработки. Но если копнуть глубже, то он раскрывается, хоть и содержит ряд ограничений.
Из самых досадных то, что из числовых имеем только целочисленный тип данных **num**. Пять разделим на два, получим два. В остальном вполне можно есть.
Я писал на нескольких популярных языках и там много различных структур данных: деревья, списки, мапы. Тут в явном виде ничего этого нет. Из структур есть только массив, правда реализована поддержка многомерных ассоциативных массивов, что позволяет создавать из него нужные структуры.
Рассмотрим наглядно. Обычный одномерный массив – это индексированный список. Элементы можно вставлять в любое место списка.
Одномерный ассоциативный, где элемент key=value, это тоже список, но сортированный по key.
Двумерный – это HashMap. Он же, но ассоциативный – сортированный **map**.
Из **многомерного** можно сделать сортированное дерево. Не сортированное тоже можно.
В одном массиве отлично живут и индексированные и именованные элементы. Первые доступны по индексу, вторые по ключу. Так каждый массив может содержать служебную информацию о себе. Например в индексированных элементах хранить имя и размер.
А массив в памяти, т.е. развернутый в глобальную переменную, это доступная для записи и чтения, оперативная память, содержимое которой можно сохранять на диск, если надо. Причем на глобальные переменные ограничений по размеру нет, в отличие от локальных. Ограничивается только оперативной памятью.
Элементом массива может быть даже код. И его можно выполнить, передав туда параметры, не разворачивая в скрипт или функцию, ещё и в отдельном потоке.
Кому нужны пруфы, прошу под кат.В этом коде объявляются две глобальные переменные и инициализируется массив, элементом которого является код.
```
:global queryID []
:global answerText []
:global answer ({
"warning"=":global queryID; :global answerText; :log warning \"fQueryID=\$queryID fAnswerText=\$answerText\"; :delay 3; :log warning \"after delay\"";
})
```
А тут мы инициализируем переменные, получаем код из массива и запускаем его на выполнение.
```
:global queryID 345554
:global answerText "Hello"
:global answer
:local exeText ($answer->"warning")
[[:parse $exeText]]
:log info "$exeText"
```
Чтобы передать параметры, нужно чтобы переменные были глобальными.
В данном случае код запускается командой **:parse**. Это значит, что сначала выполнится код из массива, а затем то, что идет после него (:log info "$exeText")
Команда **:execute работает по-другому.** Она запускает выполнение кода в отдельном потоке.
Да, многопоточность тоже доступна. Зависит от того, как вызывать код. Есть несколько способов. Из скрипта можем вызвать функцию, развернутую в глобальной переменной, выполнить код из [**:parse**](https://habr.com/ru/post/650795/), или вызвать другой скрипт. В этом случае код, который идет ниже места вызова, будет ждать пока отработает его товарищ и только потом продолжит выполняться, если первый чего-нибудь не выкинет.
Всё меняется, если вызывать код командой **:execute**. Товарищ в этом случае работает сам по себе и ждать его не надо, правда значение не вернет тут же. Всё что ниже такого вызова продолжит выполняться, а результат работы, вызванный выше код, может сохранить в массив или файл.
Под катом подробнее. Тот же пример, что выше под катом, только с использованием **:execute**
```
:global queryID []
:global answerText []
:global answer ({
"warning"=":log warning \"fQueryID=\$queryID fAnswerText=\$answerText\"; :delay 3; :log warning \"after delay\"";
})
```
```
:global queryID 345554
:global answerText "Hello"
:global answer
:local exeText ($answer->"warning")
:execute script=$exeText file=123.txt
:log info "$exeText"
```
Теперь код из массива выполнится в отдельном потоке, всё, что после вызова, продолжит выполнение.
Обратите внимание на отсутствие объявления глобальных переменных в коде из массива. В случае с **:execute** объявлять их там не надо.
Код можно запускать как службу. К примеру, в цикле мониторить появление элементов в глобальном массиве и выполнять действия в зависимости от этого. Или проверять наличие сообщений на сервере Телеграм.
Благодаря стараниям уважаемого автора Хабра, Александра [@Chupakabra303](https://habr.com/ru/users/Chupakabra303/), Микротик теперь понимает JSON. Автор создал набор библиотек, который парсит JSON объекты в многомерный ассоциативный массив и с ним уже можно работать всеми доступными методами.
Ещё функции… Развернутые в глобальном окружении, они постоянно доступны в памяти. В любой момент можем вызвать их из кода или консоли, передав туда параметры, как именованные, так и по индексу. Об этом подробнее можно почитать у местных уважаемых авторов, [здесь](https://habr.com/ru/post/650795/) и [здесь](https://habr.com/ru/post/646663/).
Есть проверка синтаксиса. Можно вывести в консоль содержимое скрипта командой **[/system script print from=script]** и в месте, где есть ошибка шрифт станет монохромным. Если ошибок нет, то будет разноцветным, как новогодняя ёлка.
Отладка реализуется выводом в лог или консоль значения любой переменной. Что ещё нужно?
Ах, да. Нужна нормальная среда разработки. Таких много. Для себя выбрал редактор [**Atom**](https://atom.io/) от команды GitHub. У него есть много плагинов, в том числе [**RouterOS plugin**](https://github.com/ofstudio/atom-language-routeros-script). Плюс нативная поддержка контроля версий **Git**. Работать вполне комфортно.
Всё это в совокупности позволяет создать на базе **RouterOS** полноценный бэк-энд для мобильных приложений. Для Телеграм вообще подходит идеально.
Многие правильно подметят, а как же базы данных? Где данные хранить, запросы куда отправлять?
Это тоже решаемо. Есть СУБД как SQL, так и noSQL, которые поддерживают HTTP(S) API и JSON. Для управления временными рядами есть **InfluxData**, которая из коробки работает с https и JSON. Она подходит для мониторинга параметров самого устройства, а также для сбора всевозможных метрик с фронта. Дружит с [Grafana](https://grafana.com/), есть дашборды и всё красиво.
А можно использовать массивы. И даже создать СУБД на их основе, с запросами и прочим. Когда будет время займусь этим плотнее.
И все это не только для управления параметрами маршрутизатора. Ничего не мешает обрабатывать данные других сервисов с JSON сериализацией и возвращать результат. Если развернуть RouterOS в виртуальной среде, то можно оперировать ресурсами. Захостить её в облаке не проблема.
Пока это только теория. А как на практике? Покажу на примере Телеграм бота, который разработан с использованием почти всех, описанных выше, возможностей. Здесь кода не будет. Скорее демонстрация работы связки Микротик плюс Телеграм. Архитектура приложения, интерфейс, bot API и немного о безопасности.
Так выглядит главное окно бота.Начнем с архитектуры. Мне понравилась статья одного из авторов Хабра "[Создание архитектуры программы или как проектировать табуретку](https://habr.com/ru/post/276593/)".
Приведу небольшую выдержку из нее.
Начнем с архитектуры. Мне понравилась статья одного из авторов Хабра "[Создание архитектуры программы или как проектировать табуретку](https://habr.com/ru/post/276593/)".
Приведу небольшую выдержку из нее.
> *Не смотря на разнообразие критериев, все же главной при разработке больших систем считается задача снижения сложности. А для снижения сложности ничего, кроме деления на части, пока не придумано. Иногда это называют принципом «разделяй и властвуй» (divide et impera), но по сути речь идет об****иерархической декомпозиции****. Сложная система должна строится из небольшого количества более простых подсистем, каждая из которых, в свою очередь, строится из частей меньшего размера, и т.д., до тех пор, пока самые небольшие части не будут достаточно просты для непосредственного понимания и создания.*
>
>
С этим трудно не согласиться. Монолитный код замучаешься читать, об отладке и поддержке вообще молчу. **Поэтому - модульность.** В RouterOS реализуется с помощью функций. В боте их условно можно разделить на несколько типов.
Библиотечные. Часто используются другими модулями и реализуют работу с API Телеграм например. Отвечают за отправку сообщений или построение кнопок и клавиатур.
Функции создания пользовательских интерфейсов. Они "рисуют окна" исходя из назначения и переданных параметров.
Функции обработчики. Эти содержат логику и обрабатывают команды, полученные от клиента. Для каждого модуля свой обработчик.
И функции диспетчеры, которые определяют какому модулю предназначена команда и передают ему управление. Таких в программе три. Первый обрабатывает Callbackи - это нажатие на кнопку, второй текстовые команды и третий команды модуля Терминала.
Код, который отслеживает наличие сообщений, работает как служба. Никаких шедулеров, он постоянно в работе. В бесконечном цикле мониторит сервер Телеграм, получает сообщения и, в зависимости от типа, передаёт их функции диспетчеру, предварительно проверив права пользователя на работу с системой в целом.
Процессор такой подход совсем не нагружает, зато повышает скорость обработки сообщений.
Конечно все паттерны тут не реализуешь, но...
> *В этом случае программа из «спагетти-кода» превращается в конструктор, состоящий из набора модулей/подпрограмм, взаимодействующих друг с другом по хорошо определенным и простым правилам, что собственно и позволяет контролировать ее сложность, а также дает возможность получить все те преимущества, которые обычно соотносятся с понятием хорошая архитектура:*
>
> ***Масштабируемость*** *(Scalability) - возможность расширять систему и увеличивать ее производительность, за счет добавления новых модулей.*
>
> ***Ремонтопригодность*** *(Maintainability) - изменение одного модуля не требует изменения других модулей*
>
> ***Заменимость модулей*** *(Swappability) - модуль легко заменить на другой*
>
> ***Возможность тестирования*** *(Unit Testing) - модуль можно отсоединить от всех остальных и протестировать / починить*
>
> ***Переиспользование*** *(Reusability) - модуль может быть переиспользован в других программах и другом окружении*
>
> ***Сопровождаемость*** *(Maintenance) разбитую на модули программу легче понимать и сопровождать*
>
>
Теперь про интерфейс. Я видел много Телеграм-ботов и большинство из них не заботятся о чистоте пользовательского пространства. Каждое новое действие там - это новое сообщение, что для работы совсем не удобно. Такое ощущение, что их разработчики просто ленятся сделать красиво. А ведь в Телеграм есть функции для редактирования messageй. Можно отдельно редактировать и сам текст и клавиатуру под ним. Конечно не все этим грешат но, повторюсь, большинство не заморачивается.
Чтобы не дублировать код в модулях, были написаны библиотечные функции для работы с bot API. Их я [выложил](https://forummikrotik.ru/viewtopic.php?f=14&t=13853) на русскоязычном форуме Микротик, кому надо можете пользоваться. Там есть всё, чтобы создать и отправить сообщение с текстом, фото, клавиатурой и т.д. Для редактирования и удаления тоже есть.
Настройки самого бота хранятся в массиве и считываются оттуда по необходимости.
Безопасность обеспечивается управлением пользовательскими разрешениями. Они тоже хранятся в массиве. Проверяются в функции обработчике перед выполнением команды.
Базовая версия бота опубликована на моем [Телеграм канале](https://t.me/mikRobot_RU). Написана так, что позволяет использовать его, как основу для разработки и подключения своих модулей. Используя эти наработки, любой из вас может самостоятельно дописывать нужный функционал.
Резюмируя можно сказать, что **RouterOS**, на мой взгляд, является неплохой средой разработки и исполнения. Конечно со своими тараканами, но их не так много. Я уверен, что рано или поздно её "распробуют" и другие разработчики приложений.
Как оказалось Микротик подходит для разработки Телеграм ботов, вообще не связанных с управлением самим устройством**.** Чтобы подтвердить этот тезис, я начал работу над новым проектом. Это будет сервис, связанный с геопозиционированием. Тут будет задействован и **inline** режим. Сейчас о подробностях говорить рано, но прототип уже есть, он работает и пока непреодолимых препятствий я не вижу.
Конечно много чего ещё хочется написать, но тогда статья слишком распухнет. И так занял много вашего времени.
Спасибо, что дочитали до конца. Сильно не пинайте, публикую в первый раз. Пожелания и предложения приветствуются. | https://habr.com/ru/post/686252/ | null | ru | null |
# Автоматическое разблокирование корневого LUKS-контейнера после горячей перезагрузки
Зачем вообще люди шифруют диски своих персональных компьютеров, а иногда — и серверов? Понятное дело, чтобы никто не украл с диска фотографии их любимых домашних котиков! Вот только незадача: зашифрованный диск требует при каждой загрузке ввести с клавиатуры ключевую фразу, а она длинная и скучная. Убрать бы ее, чтобы хотя бы иногда не приходилось ее набирать. Да так, чтобы смысл от шифрования не потерялся.
**Котейка для привлечения внимания**
Ну, совсем убрать ее не получится. Можно вместо нее сделать ключевой файл на флешке, и он тоже будет работать. А без флешки (и без второго компьютера в сети) можно? Если повезло с BIOS, почти можно! Под катом будет руководство, как настроить шифрование диска через LUKS вот с такими свойствами:
1. Ключевая фраза или ключевой файл нигде не хранится в открытом виде (или в виде, эквивалентном открытому) при выключенном компьютере.
2. При первом включении компьютера требуется ввести ключевую фразу.
3. При последующих перезагрузках (до выключения) ключевую фразу вводить не требуется.
Инструкции проверены на CentOS 7.6, Ubuntu 19.04 и openSUSE Leap 15.1 в виртуальных машинах и на реальном железе (десктопы, ноутбуки и два сервера). Они должны работать и на других дистрибутивах, в которых есть работоспособная версия Dracut.
И да, по-хорошему, это должно было бы попасть в хаб "ненормальное системное администрирование", но такого хаба нет.
Я предлагаю задействовать отдельный слот LUKS-контейнера и хранить ключ от него… в оперативной памяти!
**Что еще за слот?**
LUKS-контейнер реализует многоуровневое шифрование. Полезные данные на диске зашифрованы симметричным шифром, как правило `aes-xts-plain64`. Ключ от этого симметричного шифра (мастер-ключ) генерируется на этапе создания контейнера как случайная последовательность байт. Мастер-ключ хранится в зашифрованном виде, в общем случае — в нескольких копиях (слотах). По умолчанию, активен только один из восьми слотов. Каждый активный слот имеет отдельную ключевую фразу (или отдельный ключевой файл), с помощью которой можно расшифровать мастер-ключ. С точки зрения пользователя, получается, что разблокировать диск можно с помощью любой из нескольких различных ключевых фраз (или ключевых файлов). В нашем случае, с помощью ключевой фразы (слот 0) или с помощью участка памяти, используемого как ключевой файл (слот 6).
BIOS на большинстве материнских плат при перезагрузке не чистит память, или можно настроить, чтобы не чистил (известные исключения: "Intel Corporation S1200SP/S1200SP, BIOS S1200SP.86B.03.01.0042.013020190050 01/30/2019", "HP EliteBook 735 G6"). Поэтому там можно хранить ключ. При выключении питания содержимое оперативной памяти само через некоторое время стирается, вместе с незащищенной копией ключа.
Итак, поехали.
### Шаг первый: установить систему на зашифрованный с помощью LUKS диск
При этом раздел диска (например, `/dev/sda1`), монтируемый в `/boot`, должен остаться незашифрованным, а другой раздел, на котором будет все остальное (например, `/dev/sda2`) нужно зашифровать. Файловая система на зашифрованном разделе может быть любой, можно еще использовать LVM, чтобы в одном контейнере были и корневая файловая система, и том для swap'а, и все остальное — кроме `/boot`. Это соответствует разбиению диска по умолчанию в CentOS 7 и в Debian при выборе опции шифрования. SUSE делает все по-другому (шифрует `/boot`) и поэтому требует ручного разбиения диска.
В итоге должно получиться примерно следующее:
```
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 10G 0 disk
├─sda1 8:1 0 1G 0 part /boot
└─sda2 8:2 0 9G 0 part
└─luks-d07a97d7-3258-408c-a17c-e2fb56701c69 253:0 0 9G 0 crypt
├─centos_centos--encrypt2-root 253:1 0 8G 0 lvm /
└─centos_centos--encrypt2-swap 253:2 0 1G 0 lvm [SWAP]
```
В случае использования UEFI будет еще раздел EFI System Partition.
> Для пользователей Debian и Ubuntu: необходимо заменить пакет `initramfs-tools` на `dracut`.
>
>
> ```
> # apt install --no-install-recommends dracut
> ```
>
>
>
>
> В `initramfs-tools` реализована некорректная в нашем случае логика, применяемая к зашифрованным разделам с ключевым файлом. Такие разделы либо игнорируются полностью, либо содержимое ключевого файла копируется в initramfs (т.е. в итоге на диск) в открытом виде, что нам не надо.
### Шаг второй: создать ключевой файл, который будет использоваться для автоматического разблокирования диска после горячей перезагрузки
Нам достаточно 128 случайных бит, т.е. 16 байт. Файл будет храниться на зашифрованном диске, поэтому никто, не знающий ключа шифрования и не имеющий root-доступа к загруженной системе, его не прочитает.
```
# touch -m 0600 /root/key
# head -c16 /dev/urandom > /root/key
```
В ключевом файле достаточно по-настоящему случайных бит, чтобы медленный алгоритм PBKDF, делающий из потенциально слабой ключевой фразы трудноподбираемый ключ шифрования, стал не очень нужен. Поэтому при добавлении ключа можно уменьшить количество итераций:
```
# cryptsetup luksAddKey --key-slot=6 --iter-time=1 /dev/sda2 /root/key
Enter any existing passphrase:
```
Как видно, ключевой файл хранится на зашифрованном диске и поэтому не представляет никакой угрозы для безопасности, если компьютер выключен.
### Шаг третий: выделить место в физической памяти для хранения ключа
В Linux есть по меньшей мере три разных драйвера, позволяющих обращаться к физической памяти по известному адресу. Это `linux/drivers/char/mem.c`, отвечающий в том числе за устройство `/dev/mem`, а также модули `phram` (эмулирует MTD-чип, дает устройство `/dev/mtd0`) и `nd_e820` (применяется при работе с NVDIMM, дает `/dev/pmem0`). У них у всех есть свои неприятные особенности:
* `/dev/mem` недоступен для записи при использовании Secure Boot, если дистрибутив применил [набор патчей LOCKDOWN](https://lwn.net/Articles/784674/) от Matthew Garrett (а этот набор патчей является обязательным, если дистрибутив собирается поддерживать Secure Boot с загрузчиком, подписанным Microsoft);
* `phram` недоступен в CentOS и Fedora — мейнтейнер просто не включил соответствующую опцию при сборке ядра;
* `nd_e820` требует зарезервировать не менее 128 мегабайт памяти — так работает NVDIMM. Но это единственный вариант, работающий в CentOS с Secure Boot.
Поскольку идеального варианта нет, далее рассматриваются все три.
> При использовании любого из способов нужна предельная аккуратность, чтобы случайно не затронуть устройства или диапазоны памяти, отличные от нужного. В особенности это касается компьютеров, в которых уже есть MTD-чипы или NVDIMM-модули. А именно, `/dev/mtd0` или `/dev/pmem0` может оказаться не тем устройством, которое соответствует зарезервированному для хранения ключа участку памяти. Также может сбиться нумерация существующих устройств, на которую полагаются конфигурационные файлы и скрипты. Соответственно, все сервисы, полагающиеся на существующие устройства `/dev/mtd*` и `/dev/pmem*`, рекомендуется временно отключить.
Резервирование физической памяти в Linux осуществляется путем передачи ядру опции `memmap`. Нас интересуют два вида этой опции:
* `memmap=4K$0x10000000` резервирует (т.е. помечает как reserved, чтобы ядро само не использовало) 4 килобайта памяти, начиная с физического адреса 0x10000000;
* `memmap=128M!0x10000000` помечает 128 мегабайт физической памяти, начиная с адреса 0x10000000, как NVDIMM (очевидно, фальшивый, но нам и такой сгодится).
Вариант с `$` подходит для использования с `/dev/mem` и `phram`, вариант с `!` — для `nd_e820`. При использовании `$` начальный адрес зарезервированной области памяти должен быть кратным `0x1000` (т.е. 4 килобайтам), при использовании `!` — кратным `0x8000000` (т.е. 128 мегабайтам).
Важно: знак доллара (`$`) в конфигурационных файлах GRUB является спецсимволом и подлежит экранированию. Причем двойному: один раз — при генерации `grub.cfg` из `/etc/default/grub`, второй раз — при интерпретации получившегося конфигурационного файла на этапе загрузки. Т.е. в `/etc/default/grub` в итоге должна появиться такая строка:
```
GRUB_CMDLINE_LINUX="memmap=4K\\\$0x10000000 ... остальные опции..."
```
Без двойного экранирования знака `$` система просто не загрузится, так как будет думать, что у нее всего 4 килобайта памяти. С восклицательным знаком таких сложностей нет:
```
GRUB_CMDLINE_LINUX="memmap=128M!0x10000000 ... остальные опции..."
```
Карта физической памяти (а она нужна, чтобы выяснить, какие адреса резервировать) доступна пользователю `root` в псевдофайле `/proc/iomem`:
```
# cat /proc/iomem
...
000f0000-000fffff : reserved
000f0000-000fffff : System ROM
00100000-7ffddfff : System RAM
2b000000-350fffff : Crash kernel
73a00000-7417c25e : Kernel code
7417c25f-747661ff : Kernel data
74945000-74c50fff : Kernel bss
7ffde000-7fffffff : reserved
80000000-febfffff : PCI Bus 0000:00
fd000000-fdffffff : 0000:00:02.0
...
```
Оперативная память отмечена как "System RAM", нам достаточно зарезервировать одну ее страницу для хранения ключа. Угадать, какую часть памяти BIOS при перезагрузке не трогает, заранее надежно не получится. Разве что если есть еще один компьютер с точно такой же версией BIOS и с такой же конфигурацией памяти, на котором данное руководство уже пройдено. Поэтому в общем случае придется действовать методом проб и ошибок. Как правило, BIOS при перезагрузке изменяет данные только в начале и в конце каждого диапазона памяти. Обычно достаточно отступить на 128 мегабайт (`0x8000000`) от краев. Для виртуальных машин KVM с 1 GB памяти и более, предложенные варианты (`memmap=4K$0x10000000` и `memmap=128M!0x10000000`) работают.
При использовании модуля `phram` нужен еще один параметр командной строки ядра, который, собственно, и указывает модулю, какой кусок физической памяти использовать — наш, зарезервированный. Параметр называется `phram.phram` и содержит три части: название (произвольное до 63 символов, будет видно в `sysfs`), начальный адрес и длину. Начальный адрес и длина должны быть такими же, как и в `memmap`, но суффиксы `K` и `M` не поддерживаются.
```
GRUB_CMDLINE_LINUX="memmap=4K\\\$0x10000000 phram.phram=savedkey,0x10000000,4096 ..."
```
После редактирования `/etc/default/grub` необходимо перегенерировать настоящий конфигурационный файл, который читает GRUB при загрузке. Правильная команда для этого зависит от дистрибутива.
```
# grub2-mkconfig -o /boot/grub2/grub.cfg # CentOS (Legacy BIOS)
# grub2-mkconfig -o /boot/efi/EFI/centos/grub.cfg # CentOS (UEFI)
# update-grub # Debian, Ubuntu
# update-bootloader --reinit # SUSE
```
После обновления конфигурации GRUB компьютер надо бы перезагрузить, но мы сделаем это позже, когда обновим initramfs.
### Шаг четвертый: настроить LUKS на чтение ключа из памяти
Настройки шифрования дисков хранятся в файле `/etc/crypttab`. Каждая его строка состоит из четырех полей:
* устройство, которое должно получиться при разблокировке,
* зашифрованное устройство,
* откуда брать ключевой файл (`none` означает ввод ключевой фразы с клавиатуры),
* необязательное поле для опций.
Если ключевой файл существует, но не подходит, то Dracut спрашивает ключевую фразу. Что, собственно, и потребуется при первой загрузке.
Пример файла `/etc/crypttab` из свежеустановленного дистрибутива:
```
# cat /etc/crypttab # до редактирования
luks-d07....69 UUID=d07....69 none
```
Ключевым файлом в нашем случае будет кусок физической памяти. Т.е. `/dev/mem`, `/dev/mtd0` или `/dev/pmem0`, в зависимости от выбранной технологии доступа к памяти. Опции нужны для того, чтобы указать, какой кусок файла является ключом.
```
# cat /etc/crypttab # после редактирования
# При использовании /dev/mem:
luks-d07....69 UUID=d07....69 /dev/mem keyfile-offset=0x10000000,keyfile-size=16
# При использовании phram:
luks-d07....69 UUID=d07....69 /dev/mtd0 keyfile-size=16
# При использовании nd_e820:
luks-d07....69 UUID=d07....69 /dev/pmem0 keyfile-size=16
```
Вот только просто так это работать не будет.
Дело в том, как systemd определяет, когда можно разблокировать устройство. А именно, он берет устройство из третьей колонки и ждет, когда соответствующий ему device unit станет активным. Вроде логично: не имеет смысла пытаться разблокировать LUKS-контейнер, пока не появилось устройство с ключевым файлом. Но device unit — это не то же самое, что само устройство. Systemd по умолчанию создает device unit'ы только для устройств ядра, относящихся к подсистемам поблочных устройств и сетевых интерфейсов. Устройства `/dev/mem` и `/dev/mtd0` являются посимвольными, поэтому по умолчанию не отслеживаются и никогда не будут признаны готовыми.
Придется подсказать systemd, что он должен их отслеживать, путем создания правил udev в файле `/etc/udev/rules.d/99-mem.rules`:
```
# /dev/mem
KERNEL=="mem", TAG+="systemd"
# /dev/mtd*
KERNEL=="mtd*", TAG+="systemd"
# Устройства /dev/pmem* являются поблочными и отслеживаются по умолчанию
```
### Шаг пятый: перегенерировать initramfs
> Напоминаю: в статье рассматриваются только дистрибутивы, использующие Dracut. В том числе те, где он не используется по умолчанию, но доступен и работоспособен.
Перегенерировать initramfs нужно, чтобы обновить там файл `/etc/crypttab`. А еще — чтобы включить туда дополнительные модули ядра и правила udev. Иначе не создастся устройство `/dev/mtd0` или `/dev/pmem0`. За включение и загрузку дополнительных модулей ядра отвечает параметр конфигурации Dracut `force_drivers`, за дополнительные файлы — `install_items`. Создаем файл `/etc/dracut.conf.d/mem.conf` с таким содержимым (пробелы после открывающей кавычки и перед закрывающей обязательны, это разделители):
```
# Вся инструкция работает только при генерации initramfs, специфичной для хоста
hostonly="yes"
# При использовании /dev/mem:
install_items+=" /etc/udev/rules.d/99-mem.rules "
# При использовании phram:
install_items+=" /etc/udev/rules.d/99-mem.rules "
force_drivers+=" phram "
# При использовании nd_e820:
force_drivers+=" nd_e820 nd_pmem "
```
Собственно перегенерация initramfs:
```
# dracut -f
```
> Пользователям Debian и Ubuntu мейнтейнер подложил грабли: результирующий файл называется неправильно. Необходимо его переименовать, чтобы он назывался так же, как прописано в конфигурации GRUB:
>
>
> ```
> # mv /boot/initramfs-5.0.0-19-generic.img /boot/initrd.img-5.0.0-19-generic
> ```
>
>
>
>
> При установке новых ядер автоматическое создание initramfs через Dracut осуществляется корректно, баг затрагивает только ручной запуск `dracut -f`.
### Шаг шестой: перезагрузить компьютер
Перезагрузка нужна, чтобы подействовали изменения в конфигурации GRUB и Dracut.
```
# reboot
```
На данном этапе ключа в памяти нет, поэтому понадобится ввести ключевую фразу.
После перезагрузки необходимо проверить, правильно ли сработало резервирование памяти. Как минимум, в псевдофайле `/proc/iomem` нужный участок памяти должен быть помечен как "reserved" (при использовании `/dev/mem` или `phram`) или как "Persistent Memory (legacy)".
Еще при использовании `phram` или `nd_e820` необходимо убедиться, что устройство `/dev/mtd0` или `/dev/pmem0` действительно ссылается на зарезервированный ранее участок памяти, а не на что-то другое.
```
# cat /sys/class/mtd/mtd0/name # ожидаемый результат: "savedkey"
# cat /sys/block/pmem0/device/resource # должно вывести начальный адрес
```
Если это не так, то надо найти, какое именно из устройств `/dev/mtd*` или `/dev/pmem*` "наше", а затем исправить /etc/crypttab, перегенерировать initramfs и перепроверить результат после еще одной перезагрузки.
### Шаг седьмой: настроить копирование ключевого файла в память
Ключевой файл будет копироваться в память перед перезагрузкой. Один из способов запустить какую-либо команду на этапе завершения работы системы — это прописать ее в директиве `ExecStop` в systemd-сервисе. Чтобы systemd понял, что это не демон и не ругался на отсутствие директивы `ExecStart`, нужно указать тип сервиса как `oneshot` и еще подсказать, что сервис считается запущенным, даже если с ним не связан никакой работающий процесс. Итого, вот файл `/etc/systemd/system/savekey.service`. Надо оставить только один из приведенных вариантов директивы `ExecStop`.
```
[Unit]
Description=Saving LUKS key into RAM
Documentation=https://habr.com/ru/post/457396/
[Service]
Type=oneshot
RemainAfterExit=true
# Если используется /dev/mem:
ExecStop=/bin/sh -c 'dd if=/root/key of=/dev/mem bs=1 seek=$((0x10000000))'
# Если используется /dev/mtd0:
ExecStop=/bin/dd if=/root/key of=/dev/mtd0
# Если используется /dev/pmem0:
ExecStop=/bin/dd if=/root/key of=/dev/pmem0
[Install]
WantedBy=default.target
```
Конструкция с `/bin/sh` нужна, так как `dd` не понимает шестнадцатеричную запись.
Активируем сервис, проверяем:
```
# systemctl enable savekey
# systemctl start savekey
# reboot
```
При последующей перезагрузке вводить ключевую фразу от диска не придется. А если придется, то это, как правило, означает, что адрес начала зарезервированной области памяти выбран неправильно. Ничего страшного — поправить и перегенерировать несколько файлов и перезагрузить компьютер два раза.
При использовании `phram` или `nd_e820` править придется только конфигурацию GRUB. При использовании `/dev/mem` начальный адрес упоминается еще и в `/etc/crypttab` (поэтому придется перегенерировать initramfs) и в systemd-сервисе.
Но это еще не все.
### Вопросы безопасности
Любое обсуждение вопросов безопасности основывается на модели угроз. Т.е. на целях и средствах атакующего. Я в курсе, что некоторые примеры ниже надуманные.
Ситуации с физическим доступом к выключенному компьютеру ничем не отличаются от таковых без настроенного хранения ключа в памяти. Есть те же виды атак, нацеленных на получение ключевой фразы, в том числе [Evil Maid](https://habr.com/ru/post/259781/), и те же [средства защиты](https://habr.com/ru/post/308032/). На них не останавливаемся, так как здесь нет ничего нового.
Более интересны ситуации, когда компьютер включен.
**Ситуация 1**. Атакующий не имеет физического доступа к компьютеру, не знает ключевую фразу, но имеет root-доступ через ssh. Цель — ключ для расшифровки диска. Например, для доступа к старым посекторным бекапам образа диска виртуальной машины.
Собственно, ключ на блюдечке — в файле `/root/key`. Вопрос в том, как это соотносится с тем, что было до выполнения этой инструкции. Ответ: для luks1, угроза не является новой. Существует команда `dmsetup table --target crypt --showkeys`, которая показывает мастер-ключ, т.е. тоже данные, позволяющие получить доступ к старым бекапам. Для luks2, понижение безопасности в этом сценарии действительно имеет место: ключи dm-crypt хранятся в связке ключей на уровне ядра, и посмотреть на них из userspace невозможно.
**Ситуация 2**. Атакующий может пользоваться клавиатурой и смотреть на экран, но не готов открыть корпус. Например, воспользовался утекшим паролем от IPMI или перехватил noVNC-сессию в облаке. Ключевую фразу не знает, никакие другие пароли тоже не знает. Цель — root-доступ.
Пожалуйста: перезагрузка через `Ctrl-Alt-Del`, добавление опции ядра `init=/bin/sh` через GRUB, готово. Ключевая фраза не понадобилась, так как ключ был успешно прочитан из памяти. Чтобы от такого защититься, надо бы запретить GRUB'у грузить то, чего нет в меню. К сожалению, эта функциональность реализована в разных дистрибутивах по-разному.
В CentOS, начиная с версии 7.2, есть команда `grub2-setpassword`, которая собственно и защищает GRUB паролем. В других дистрибутивах могут быть свои утилиты для той же задачи. Если их нет, то можно напрямую отредактировать файлы в каталоге `/etc/grub.d` и перегенерировать `grub.cfg`.
В файле `/etc/grub.d/10_linux` изменить переменную CLASS, добавить в конец опцию `--unrestricted`, если ее там не было:
```
CLASS="--class gnu-linux --class gnu --class os --unrestricted"
```
В файле `/etc/grub.d/40_custom` добавить строки, задающие имя пользователя и пароль, которые нужны для редактирования командной строки ядра:
```
set superusers="root"
password_pbkdf2 root grub.pbkdf2....... # взять из вывода grub2-mkpasswd-pbkdf2
```
Или, если такую функциональность надо отключить вовсе, вот такую строку:
```
set superusers=""
```
**Ситуация 3**. Атакующий имеет доступ к включенному компьютеру, позволяющий загрузиться с недоверенного носителя. Это может быть физический доступ без открывания корпуса или доступ через IPMI. Цель — root-доступ.
Он может загрузить свой GRUB с флешки или CD-ROM и добавить `init=/bin/sh` к параметрам вашего ядра, как в предыдущем примере. Соответственно, загрузку с каких попало носителей надо бы запретить в BIOS. И еще защитить изменение настроек BIOS паролем.
**Ситуация 4**. Атакующий имеет физический доступ к включенному компьютеру, в том числе может открыть корпус. Цель — узнать ключ или получить root-доступ.
В общем-то это проигрышная ситуация в любом случае. Атаку на модули памяти путем их охлаждения ([Cold boot attack](https://ru.wikipedia.org/wiki/Cold_boot_attack)) никто не отменял. Также теоретически (не проверял) можно воспользоваться тем, что современные SATA-диски поддерживают горячее переподключение. При перезагрузке компьютера отключить диск, поменять `grub.cfg` на предмет `init=/bin/sh`, подключить обратно, дать системе перезагрузиться. Получится (если я правильно понимаю) root-доступ.
Примерно то же самое может провернуть недобросовестный сотрудник облачного хостинга путем изготовления снапшота виртуальной машины с последующей его модификацией.
### Прочие вопросы
**Хранить ключ в памяти при перезагрузке — это издевательство. Use-after-free в чистом виде. Более чистое решение — использовать kexec и складывать ключ в динамически генерируемый initramfs. Это еще и защищает от замены параметров ядра**. Да, это так, если kexec работает. Современные дистрибутивы сделали настройку kexec [слишком сложной](https://patrakov.blogspot.com/2019/06/kexec-on-modern-distributions.html).
**В датацентрах и тем более в облаке питание никогда не пропадает. Получается, ключевая фраза больше не нужна?** Действительно, *если* вы в этом так уверены, ее можно удалить. Получится работающий сервер, ключа от диска которого никто не знает¹ и поэтому не выдаст, но систему на котором можно штатными средствами обновлять. А при необходимости — быстро уничтожить все данные легко запоминаемой командой `sudo poweroff`.
¹Если не посмотрел в `/root/key` — но там все равно не набираемая с клавиатуры абракадабра, которую к тому же можно менять по cronу.
**Зачем все это надо? Есть IPMI, где я могу ввести пароль от диска**. На старых серверах IPMI работает только через старые версии Java. Не хотелось бы лезть туда для каждой перезагрузки.
**Зачем все это надо? Я умею разблокировать диск [через SSH](https://github.com/dracut-crypt-ssh/dracut-crypt-ssh)**. Прекрасно! Одно другому не мешает. Но что, если надо выдать права на `sudo reboot` пользователю, который не заслуживает знания ключевой фразы?
На самом деле я поставил себе задачку об удаленной перезагрузке с зашифрованным диском, когда понадобилось так перезагрузить с работы находящийся дома ноутбук. Решение с разблокированием через SSH работает из коробки только при проводном подключении, а у ноутбука только беспроводная сеть. В итоге тогда я ноутбук не перезагрузил, а когда вернулся к этому случаю, получилось интересное упражнение. | https://habr.com/ru/post/457396/ | null | ru | null |
# Rust 1.59.0: встроенный ассемблер, деструктурирующее присваивание, отключение инкрементальной компиляции
Команда Rust публикует новую версию языка — 1.59.0. Rust — это язык программирования, позволяющий каждому создавать надёжное и эффективное программное обеспечение.
---
[политическое сообщение удалено из-за правил Хабра]
---
Если у вас есть предыдущая версия Rust, установленная через `rustup`, то для обновления до версии 1.59.0 вам достаточно выполнить команду:
```
rustup update stable
```
Если у вас ещё нет `rustup`, то можете установить его со [страницы](https://www.rust-lang.org/install.html) на нашем веб-сайте, а также ознакомиться с [подробным описанием выпуска 1.59.0](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1590-2022-02-24) на GitHub.
Что стабилизировано в 1.59.0
----------------------------
### Встроенный ассемблер
Язык Rust теперь поддерживает встроенный ассемблер, что позволяет создавать приложения, которым требуется самый низкоуровневый контроль над их выполнением или доступ к специализированным машинным инструкциям.
Например, при компиляции под x86-64 вы теперь можете написать:
```
use std::arch::asm;
// Умножить x на 6 с помощью сдвигов и сложений
let mut x: u64 = 4;
unsafe {
asm!(
"mov {tmp}, {x}",
"shl {tmp}, 1",
"shl {x}, 2",
"add {x}, {tmp}",
x = inout(reg) x,
tmp = out(reg) _,
);
}
assert_eq!(x, 4 * 6);
```
Синтаксис форматирования строки, используемый для именования регистров в макросах `asm!` и `global_asm!`, используется в обычном [форматировании строк](https://doc.rust-lang.org/stable/std/fmt/) Rust, поэтому он должен быть знакомым Rust-программистам.
Язык ассемблера и инструкции, доступные для встроенного ассемблера, различаются в зависимости от целевой архитектуры. Сегодня стабильный компилятор Rust поддерживает встроенную сборку на следующих архитектурах:
* x86 и x86-64
* ARM
* AArch64
* RISC-V
Вы можете увидеть больше примеров встроенного ассемблера в [Rust By Example](https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html), а более подробную документацию найти в [справочнике](https://doc.rust-lang.org/nightly/reference/inline-assembly.html).
### Деструктурирующее присваивание
Теперь вы можете использовать кортежи, срезы и структурные паттерны с левой стороны от присваивания.
```
let (a, b, c, d, e);
(a, b) = (1, 2);
[c, .., d, _] = [1, 2, 3, 4, 5];
Struct { e, .. } = Struct { e: 5, f: 3 };
assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
```
Это делает присваивания более согласованными с привязками `let`, которые уже давно поддерживают это. Обратите внимание, что деструктурирующее присваивание не разрешено в таких операторах, как `+=`.
#### Значения по умолчанию для константных обобщений и чередования
Для обобщённых типов теперь можно задать значения по умолчанию для их константных обобщений. Например, теперь вы можете написать следующее:
```
struct ArrayStorage {
arr: [T; N],
}
impl ArrayStorage {
fn new(a: T, b: T) -> ArrayStorage {
ArrayStorage {
arr: [a, b],
}
}
}
```
Ранее параметры типа требовалось писать до всех константных параметров. Это ограничение было ослаблено, и теперь вы можете чередовать их.
```
fn cartesian_product<
T, const N: usize,
U, const M: usize,
V, F
>(a: [T; N], b: [U; M]) -> [[V; N]; M]
where
F: FnMut(&T, &U) -> V
{
// ...
}
```
### Предупреждения о будущей несовместимости
Иногда ошибки в компиляторе Rust заставляют его принимать код, который не должен был приниматься. Примером этого было [заимствование полей упакованной структуры](https://github.com/rust-lang/rust/issues/46043), разрешённое в безопасном коде.
Хотя это случается очень редко, такое поведение может быть весьма разрушительным – когда в крейте, используемом вашим проектом, есть код, который больше не будет разрешён. Вы этого можете даже не заметить, пока ваш проект необъяснимым образом не перестанет собираться!
Cargo теперь показывает вам предупреждения, когда зависимость будет отклонена будущей версией Rust. После запуска `cargo build` или `cargo check` вы сможете увидеть:
```
warning: the following packages contain code that will be rejected by a future version of Rust: old_dep v0.1.0
note: to see what the problems were, use the option `--future-incompat-report`, or run `cargo report future-incompatibilities --id 1`
```
Вы можете запустить команду `cargo report`, упомянутую в предупреждении, чтобы увидеть полный отчёт о коде, который будет отклонён. Это даёт вам время обновить вашу зависимость, прежде чем она сломает всю сборку.
### Создание урезанных бинарных файлов
Часто вырезание информации, например отладочной, из поставляемых вами бинарных файлов, уменьшает их размер.
Это можно сделать вручную в любой момент после создания бинарного файла, но теперь cargo и rustc поддерживают урезание на этапе линковки. Для включения данной функциональности добавьте в `Cargo.toml` следующее:
```
[profile.release]
strip = "debuginfo"
```
Это приведёт к вырезанию отладочной информации из релизных сборок. Вы также можете поставить `"symbols"` или просто `true` чтобы вырезать всю информацию о символах, которая возможна.
Стандартная библиотека обычно поставляется с отладочными символами и отладочной информацией, так что бинарные файлы Rust, собираемые без отладочной информации, по умолчанию включают в себя информацию об отладке стандартной библиотеки. Использование опции `strip` позволяет вам удалить эту дополнительную информацию, чтобы создать более компактные бинарные файлы.
Для большей информации смотрите [документацию Cargo](https://doc.rust-lang.org/beta/cargo/reference/profiles.html#strip).
### Инкрементальная компиляция отключена по умолчанию
Версия 1.59.0 по умолчанию отключает инкрементный режим (если его явно не запросить через переменную среды `RUSTC_FORCE_INCREMENTAL=1`). Это смягчает последствия известной ошибки [#94124](https://github.com/rust-lang/rust/issues/94124), которая может вызывать ошибки десериализации (и панику) во время компиляции с включённой инкрементной компиляцией.
Специальное исправление для [#94124](https://github.com/rust-lang/rust/issues/94124) появилось и в настоящее время находится в бета-версии 1.60, которая будет выпущена через шесть недель. В настоящее время мы не знаем о других проблемах, которые побудили бы принять решение об отключении инкрементной компиляции в стабильной версии 1.60, и если они не возникнут, вполне вероятно, что в стабильной версии 1.60 снова будет включена инкрементная компиляция. Инкрементная компиляция остаётся включённой по умолчанию в бета-версии и ночных каналах.
Как всегда, мы призываем пользователей тестировать ночные и бета-каналы и сообщать о найденных проблемах: особенно в отношении дополнительных ошибок. Это лучший способ быть уверенным, что команда Rust сможет оценить, есть ли поломка и какое количество пользователей она затрагивает.
### Стабилизированные API
Стабилизированы следующие методы и реализации трейтов:
* `std::thread::available_parallelism`
* `Result::copied`
* `Result::cloned`
* `arch::asm!`
* `arch::global_asm!`
* `ops::ControlFlow::is_break`
* `ops::ControlFlow::is_continue`
* `TryFrom для u8`
* `char::TryFromCharError` реализующие `Clone`, `Debug`, `Display`, `PartialEq`, `Copy`, `Eq`, `Error`
* `iter::zip`
* `NonZeroU8::is_power_of_two`
* `NonZeroU16::is_power_of_two`
* `NonZeroU32::is_power_of_two`
* `NonZeroU64::is_power_of_two`
* `NonZeroU128::is_power_of_two`
* `DoubleEndedIterator для ToLowercase`
* `DoubleEndedIterator для ToUppercase`
* `TryFrom<&mut [T]> for [T; N]`
* `UnwindSafe для Once`
* `RefUnwindSafe для Once`
* [armv8 neon intrinsics для aarch64](https://github.com/rust-lang/stdarch/pull/1266)
Следующие ранее стабилизированные API стали `const`:
* `mem::MaybeUninit::as_ptr`
* `mem::MaybeUninit::assume_init`
* `mem::MaybeUninit::assume_init_ref`
* `ffi::CStr::from_bytes_with_nul_unchecked`
### Прочие изменения
В [синтаксис](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1590-2022-02-24), [пакетный менеджер Cargo](https://github.com/rust-lang/cargo/blob/master/CHANGELOG.md#cargo-159-2022-02-24) и [анализатор Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-159) также внесены некоторые изменения.
### Участники 1.59.0
Множество людей объединились для создания Rust 1.59.0. Мы не смогли бы сделать это без всех вас. [Спасибо!](https://thanks.rust-lang.org/rust/1.59.0/)
### От переводчиков
С любыми вопросами по языку Rust вам смогут помочь в [русскоязычном Телеграм-чате](https://t.me/rustlang_ru) или же в аналогичном [чате для новичковых вопросов](https://t.me/rust_beginners_ru). Если у вас есть вопросы по переводам или хотите помогать с ними, то обращайтесь в [чат переводчиков](https://t.me/rustlang_ru_translations). Также можете поддержать нас на [OpenCollective](https://opencollective.com/rust-lang-ru).
Над публикацией данного перевода работали [@belanchuk](/users/belanchuk), [@TelegaOvoshey](/users/TelegaOvoshey), [@funkill](/users/funkill), [@ozkriff](/users/ozkriff) и [@MaybeWaffle](/users/maybewaffle). | https://habr.com/ru/post/653565/ | null | ru | null |
# Основы Ansible, без которых ваши плейбуки — комок слипшихся макарон
Я делаю много ревью для чужого кода на Ансибл и много пишу сам. В ходе анализа ошибок (как чужих, так и своих), а так же некоторого количества собеседований, я понял основную ошибку, которую допускают пользователи Ансибла — они лезут в сложное, не освоив базового.
Для исправления этой вселенской несправедливости я решил написать введение в Ансибл для тех, кто его уже знает. Предупреждаю, это не пересказ манов, это лонгрид в котором много букв и нет картинок.
Ожидаемый уровень читателя — уже написано несколько тысяч строк ямла, уже что-то в продакшене, но "как-то всё криво".
Названия
========
Главная ошибка пользователя Ansible — это не знать как что называется. Если вы не знаете названий, вы не можете понимать то, что написано в документации. Живой пример: на собеседовании, человек, вроде бы заявлявший, что он много писал на Ансибле, не смог ответить на вопрос "из каких элементов состоит playbook'а?". А когда я подсказал, что "ожидался ответ, что playbook состоит из play", то последовал убийственный комментарий "мы этого не используем". Люди пишут на Ансибле за деньги и не используют play. *На самом деле используют, но не знают, что это такое.*
Так что начнём с простого: как что называется. Может быть вы это знаете, а может и нет, потому что не обратили внимания, когда читали документацию.
ansible-playbook исполняет playbook. Playbook — это файл с расширением yml/yaml, внутри которого что-то такое:
```
---
- hosts: group1
roles:
- role1
- hosts: group2,group3
tasks:
- debug:
```
Мы уже поняли, что весь этот файл — плейбука. Мы можем показать где тут роли (roles), где таски (tasks). Но где тут play? И чем отличается play от role или playbook?
В документации это всё есть. И это пропускают. Начинающие — потому что там слишком много и всё сразу не запомнишь. Опытные — потому что "тривиальные вещи". Если вы опытный — перечитывайте эти страницы хотя бы раз в полгода, и ваш код станет классом лучше.
Итак, запоминайте: Playbook — это список, состоящий из play и `import_playbook`.
Вот это — одна play:
```
- hosts: group1
roles:
- role1
```
и вот это тоже ещё одна play:
```
- hosts: group2,group3
tasks:
- debug:
```
Что же такое play? Зачем она?
Play — это ключевой элемент для playbook, потому что play и только play связывает список ролей и/или тасок с списком хостов, на которых их надо выполнять. В глубоких недрах документации можно найти упоминание про `delegate_to`, локальные lookup-плагины, network-cli-специфичные настройки, jump-хосты и т.д. Они позволяют слегка поменять место исполнения тасок. Но, забудьте про это. У каждой из этих хитрых опций есть очень специальные применения, и они точно не являются универсальными. А мы говорим про базовые вещи, которые должны знать и использовать все.
Если вы хотите "что-то" исполнить "где-то" — вы пишете play. Не роль. Не роль с модулями и делегейтами. Вы берёте и пишете play. В которой, в поле hosts вы перечисляете где исполнять, а в roles/tasks — что исполнять.
Просто же, да? А как может быть иначе?
Одним из характерных моментов, когда у людей возникает желание сделать это не через play, это "роль, которая всё настраивает". Хочется иметь роль, которая настраивает и сервера первого типа, и сервера второго типа.
Архетипичным примером является мониторинг. Хочется иметь роль monitoring, которая настроит мониторинг. Роль monitoring назначается на хосты мониторинга (в соотв. play). Но, выясняется, что для мониторинга нам надо поставить пакеты на хосты, которые мы мониторим. Почему бы не использовать delegate? А ещё надо настроить iptables. delegate? А ещё надо написать/поправить конфиг для СУБД, чтобы мониторинг пускала. delegate! А если креатив попёр, то можно сделать делегацию `include_role` во вложенном цикле по хитрому фильтру на список групп, а внутри `include_role` можно ещё делать `delegate_to` снова. И понеслось...
Благое пожелание — иметь одну-единственную роль monitoring, которая "всё делает" — ведёт нас в кромешный ад из которого чаще всего один выход: всё переписать с нуля.
Где тут случилась ошибка? В тот момент, когда вы обнаружили, что для выполнения задачи "x" на хосте X вам надо пойти на хост Y и сделать там "y", вы должны были выполнить простое упражнение: пойти и написать play, которая на хосте Y делает y. Не дописывать что-то в "x", а написать с нуля. Пусть даже с захардкоженными переменными.
Вроде бы, в абзацах выше всё сказано правильно. Но это же не ваш случай! Потому что вы хотите написать переиспользуемый код, который DRY и похож на библиотеку, и нужно искать метод как это сделать.
Вот тут вот притаилась ещё одна грубая ошибка. Ошибка, которая превратила множество проектов из терпимо написанных (можно лучше, но всё работает и легко дописать) в совершенный ужас, в котором даже автор не может разобраться. Оно работает, но упаси боже что-то поменять.
Эта ошибка звучит так: ~~роль — это библиотечная функция~~. Эта аналогия сгубила столько хороших начинаний, что просто грустно смотреть. Роль — не библиотечная функция. Она не может делать вычисления и она не может принимать решения уровня play. Напомните мне, какие решения принимает play?
Спасибо, вы правы. Play принимает решение (точнее, содержит в себе информацию) о том, какие таски и роли на каких хостах выполнять.
Если вы делегируете это решение на роль, да ещё и с вычислениями, вы обрекаете себя (и того, кто ваш код будет пытаться разобрать) на жалкое существование. Роль не решает где ей выполняться. Это решение принимает play. Роль делает то, что ей сказали, там, где ей сказали.
Почему заниматься программированием на Ансибле опасно и чем COBOL лучше Ансибла мы поговорим в главе про переменные и jinja. Пока что скажем одно — каждое ваше вычисление оставляет за собой нестираемый след из изменения глобальных переменных, и вы ничего с этим не можете сделать. Как только два "следа" пересеклись — всё пропало.
Замечание для въедливых: роль, безусловно, может влиять на control flow. Есть `delegate_to` и у него есть разумные применения. Есть `meta: end host/play`. Но! Помните, мы учим основы? Забыли про `delegate_to`. Мы говорим про самый простой и самый красивый код на Ансибл. Который легко читать, легко писать, легко отлаживать, легко тестировать и легко дописывать. Так что, ещё раз:
**play и только play решает на каких хостах что исполняется.**
В этом разделе мы разобрались с противостоянием play и role. Теперь поговорим про отношения tasks vs role.
Таски и Роли
============
Рассмотрим play:
```
- hosts: somegroup
pre_tasks:
- some_tasks1:
roles:
- role1
- role2
post_tasks:
- some_task2:
- some_task3:
```
Допустим, вам надо сделать foo. И выглядит это как `foo: name=foobar state=present`. Куда это писать? в pre? post? Создавать role?
… И куда делись tasks?
Мы снова начинаем с азов — устройство play. Если вы плаваете в этом вопросе, вы не можете использовать play как основу для всего остального, и ваш результат получается "шатким".
Устройство play: директива hosts, настройки самой play и секции pre\_tasks, tasks, roles, post\_tasks. Остальные параметры для play нам сейчас не важны.
Порядок их секций с тасками и ролями: `pre_tasks`, `roles`, `tasks`, `post_tasks`. Поскольку семантически порядок исполнения между `tasks` и `roles` не понятен, то best practices говорит, что мы добавляем секцию `tasks`, только если нет `roles`. Если есть `roles`, то все прилагающиеся таски помещаются в секции `pre_tasks`/`post_tasks`.
Остаётся только то, что семантически всё понятно: сначала `pre_tasks`, потом `roles`, потом `post_tasks`.
Но мы всё ещё не ответили на вопрос: а куда вызов модуля `foo` писать? Надо ли нам под каждый модуль писать целую роль? Или лучше иметь толстую роль подо всё? А если не роль, то куда писать — в pre или в post?
Если на на эти вопросы нет аргументированного ответа, то это признак отсутствия интуиции, то есть те самые "шаткие основы". Давайте разбираться. Сначала контрольный вопрос: Если у play есть `pre_tasks` и `post_tasks` (и нет ни tasks, ни roles), то может ли что-то сломаться, если я первую таску из `post_tasks` перенесу в конец `pre_tasks`?
Разумеется, формулировка вопроса намекает, что сломается. Но что именно?
… Хэндлеры. Чтение основ открывает важный факт: все хэндлеры flush'атся автоматом после каждой секции. Т.е. выполняются все таски из `pre_tasks`, потом все хэндлеры, которые были notify. Потом выполняются все роли и все хэндлеры, которые были notify в ролях. Потом `post_tasks` и их хэндлеры.
Таким образом, если вы таску перетащите из `post_tasks` в `pre_tasks`, то, потенциально, вы выполните её до выполнения handler'а. например, если в `pre_tasks` устанавливается и конфигурируется веб-сервер, а в `post_tasks` в него что-то засылается, то перенос этой таски в секцию `pre_tasks` приведёт к тому, что в момент "засылания" сервер будет ещё не запущен и всё сломается.
А теперь давайте ещё раз подумаем, а зачем нам `pre_tasks` и `post_tasks`? Например, для того, чтобы выполнить всё нужное (включая хэндлеры) до выполнения роли. А `post_tasks` позволит нам работать с результатами выполнения ролей (включая хэндлеры).
Въедливый знаток Ansible скажет нам, что есть `meta: flush_handlers`, но зачем нам flush\_handlers, если мы можем положиться на порядок исполнения секций в play? Более того, использование meta: flush\_handlers может нам доставить неожиданного с повторяющимися хэндлерами, сделать нам странные варнинги в случае использования `when` у `block` и т.д. Чем лучше вы знаете ансибл, тем больше нюансов вы сможете назвать для "хитрого" решения. А простое решение — использование натурального разделения между pre/roles/post — не вызывает нюансов.
И, возвращаемся, к нашему 'foo'. Куда его поместить? В pre, post или в roles? Очевидно, это зависит от того, нужны ли нам результаты работы хэндлера для foo. Если их нет, то foo не нужно класть ни в pre, ни в post — эти секции имеют специальный смысл — выполнение тасок до и после основного массива кода.
Теперь ответ на вопрос "роль или таска" сводится к тому, что уже есть в play — если там есть tasks, то надо дописать в tasks. Если есть roles — надо делать роль (пусть и из одной task). Напоминаю, tasks и roles одновременно не используются.
Понимание основ Ансибла даёт обоснованные ответы на, казалось бы, вопросы вкусовщины.
Таски и роли (часть вторая)
===========================
Теперь обсудим ситуацию, когда вы только начинаете писать плейбуку. Вам надо сделать foo, bar и baz. Это три таски, одна роль или три роли? Обобщая вопрос: в какой момент надо начинать писать роли? В чём смысл писать роли, когда можно писать таски?… А что такое роль?
Одна из грубейших ошибок (я про это уже говорил) — считать, что роль — это как функция в библиотеке у программы. Как выглядит обобщённое описание функции? Она принимает аргументы на вход, взаимодействует с side causes, делает side effects, возвращает значение.
Теперь, внимание. Что из этого можно сделать в роли? Вызвать side effects — всегда пожалуйста, это и есть суть всего Ансибла — делать сайд-эффекты. Иметь side causes? Элементарно. А вот с "передать значение и вернуть его" — вот тут-то и нет. Во-первых, вы не можете передать значение в роль. Вы можете выставить глобальную переменную со сроком жизни размером в play в секции vars для роли. Вы можете выставить глобальную переменную со сроком жизни в play внутри роли. Или даже со сроком жизни плейбуки (`set_fact`/`register`). Но вы не можете иметь "локальные переменные". Вы не можете "принимать значение" и "возвращать его".
Из этого вытекает главное: нельзя на ansible написать что-то и не вызвать сайд-эффекты. Изменение глобальных переменных — это всегда side effect для функции. В Rust, например, изменение глобальной переменной — это `unsafe`. А в Ансибл — единственный метод повлиять на значения для роли. Обратите внимание на используемые слова: не "передать значение в роль", а "изменить значения, которые использует роль". Между ролями нет изоляции. Между тасками и ролями нет изоляции.
Итого: **роль — это не функция**.
Что же хорошего есть в роли? Во-первых, у роли есть default values (`/default/main.yaml`), во-вторых у роли есть дополнительные каталоги для складывания файлов.
Чем же хороши default values? Тем, что в ~~пирамиде Маслоу~~ довольно извращённой таблице приоритетов переменных у Ансибла, role defaults — самые неприоритетные (за вычетом параметров командной строки ансибла). Это означает, что если вам надо предоставить значения по-умолчанию и не переживать что они перебъют значения из инвентори или групповых переменных, то дефолты роли — это единственное правильное место для вас. (Я немного вру — есть ещё `|d(your_default_here)`, но если говорить про стационарные места — то только дефолты ролей).
Что ещё хорошего в ролях? Тем, что у них есть свои каталоги. Это каталоги для переменных, как постоянных (т.е. вычисляемых для роли), так и для динамических (есть такой то ли паттерн, то ли анти-паттерн — `include_vars` вместе с `{{ ansible_distribution }}-{{ ansible_distribution_major_version }}.yml`.). Это каталоги для `files/`, `templates/`. Ещё, оно позволяет иметь роли свои модули и плагины (`library/`). Но, в сравнении с тасками у playbook'и (у которой тоже всё это может быть), польза тут только в том, что файлы свалены не в одну кучу, а несколько раздельных кучек.
Ещё одна деталь: можно пытаться делать роли, которые будут доступны для переиспользования (через galaxy). После появления коллекций распространение ролей можно считать почти забытым.
Таким образом, роли обладают двумя важными особенностями: у них есть дефолты (уникальная особенность) и они позволяют структурировать код.
Возвращаясь к исходному вопросу: когда делать таски а когда роли? Таски в плейбуке чаще всего используются либо как "клей" до/после ролей, либо как самостоятельный строительный элемент (тогда в коде не должно быть ролей). Груда нормальных тасок в перемешку с ролями — это однозначная неряшливость. Следует придерживаться конкретного стиля — либо таски, либо роли. Роли дают разделение сущностей и дефолты, таски позволяют прочитать код быстрее. Обычно в роли выносят более "стационарный" (важный и сложный) код, а в стиле тасок пишут вспомогательные скрипты.
Существует возможность делать import\_role как таску, но если вы такое пишете, то будьте готовы к объяснительной для собственного чувства прекрасного, зачем вы это хотите делать.
Въедливый читатель может сказать, что роли могут импортировать роли, у ролей может быть зависимость через galaxy.yml, а ещё есть страшный и ужасный `include_role` — напоминаю, мы повышаем навыки в базовом Ансибле, а не в фигурной гимнастике.
Хэндлеры и таски
================
Давайте обсудим ещё одну очевидную вещь: хэндлеры. Умение их правильно использовать — это почти искусство. В чём разница между хэндлером и таской?
Так как мы вспоминаем основы, то вот пример:
```
- hosts: group1
tasks:
- foo:
notify: handler1
handlers:
- name: handler1
bar:
```
У роли handler'ы лежат в rolename/handlers/main.yaml. Handler'ы шарятся между всеми участниками play: pre/post\_tasks могут дёргать handler'ы роли, а роль может дёргать handler'ы из плей. Однако, "кросс-ролевые" вызовы handler'ов вызывают куда больший wtf, чем повтор тривиального handler'а. (Ещё один элемент best practices — стараться не делать повторов имён handler'ов).
Основное различие в том, что таска выполняется (идемпотентно) всегда (плюс/минус теги и `when`), а хэндлер — по изменению состояния (notify срабатывает только если был changed). Чем это чревато? Например, тем, что при повторном запуске, если не было changed, то не будет и handler. А почему может быть так, что нам нужно выполнить handler когда не было changed у порождающей таски? Например, потому что что-то сломалось и changed был, а до хэндлера выполнение не дошло. Например, потому что сеть временно лежала. Конфиг поменялся, сервис не перезапущен. При следующем запуске конфиг уже не меняется, и сервис остаётся со старой версией конфига.
Ситуация с конфигом не решаемая (точнее, можно самим себе изобрести специальный протокол перезапуска с файловыми флагами и т.д., но это уже не 'basic ansible' ни в каком виде). Зато есть другая частая история: мы поставили приложение, записали его `.service`-файл, и теперь хотим его `daemon_reload` и `state=started`. И натуральное место для этого, кажется, хэндлер. Но если сделать его не хэндлером а таской в конце тасклиста или роли, то он будет идемпотентно выполняться каждый раз. Даже если плейбука сломалась на середине. Это совершенно не решает проблемы restarted (нельзя делать таску с атрибутом restarted, т.к. теряется идемпотентность), но однозначно стоит делать state=started, общая стабильность плейбуки возрастает, т.к. уменьшается количество связей и динамического состояния.
Ещё одно положительное свойство handler'а состоит в том, что он не засоряет вывод. Не было изменений — нет лишних skipped или ok в выводе — легче читать. Оно же является и отрицательным свойством — если опечатку в линейно исполняемой task'е вы найдёте на первый же прогон, то handler'ы будут выполнены только при changed, т.е. при некоторых условиях — очень редко. Например, первый раз в жизни спустя пять лет. И, разумеется, там будет опечатка в имени и всё сломается. А второй раз их не запустить — changed-то нет.
Отдельно надо говорить про доступность переменных. Например, если вы notify для таски с циклом, то что будет в переменных? Можно аналитическим путём догадаться, но не всегда это тривиально, особенно, если переменные приходят из разных мест.
… Так что handler'ы куда менее полезны и куда более проблемны, чем кажется. Если можно что-то красиво (без выкрутас) написать без хэндлеров лучше делать без них. Если красиво не получается — лучше с ними.
Въедливый читатель справедливо отмечает, что мы не обсудили `listen`, что handler может вызывать notify для другого handler'а, что handler может включать в себя import\_tasks (который может делать include\_role c with\_items), что система хэндлеров в Ансибле тьюринг-полная, что хэндлеры из include\_role прелюбопытнейшим образом пересекаются с хэндлерами из плей и т.д. — всё это явно не "основы").
Хотя есть один определённый WTF, который на самом деле фича, и о котором надо помнить. Если у вас таска выполняется с `delegate_to` и у неё есть notify, то соответствующий хэндлер выполняется без `delegate_to`, т.е. на хосте, на котором назначена play. (Хотя у хэндлера, разумеется, может быть `delegate_to` тоже).
Отдельно я хочу сказать пару слов про reusable roles. До появления коллекций была идея, что можно сделать универсальные роли, которые можно `ansible-galaxy install` и поехал. Работает на всех ОС всех вариантов во всех ситуациях. Так вот, моё мнение: это не работает. Любая роль с массовым `include_vars`, поддержкой 100500 случаев обречена на бездны corner case багов. Их можно затыкать массированным тестированием, но как с любым тестированием, либо у вас декартово произведение входных значений и тотальная функция, либо у вас "покрыты отдельные сценарии". Моё мнение — куда лучше, если роль линейная (цикломатическая сложность 1).
Чем меньше if'ов (явных или декларативных — в форме `when` или форме `include_vars` по набору переменных), тем лучше роль. Иногда приходится делать ветвления, но, повторю, чем их меньше, тем лучше. Так что вроде бы хорошая роль с galaxy (работает же!) с кучей `when` может быть менее предпочтительна, чем "своя" роль из пяти тасок. Момент, когда роль с galaxy лучше — когда вы что-то начинаете писать. Момент, когда она становится хуже — когда что-то ломается, и у вас есть подозрение, что это из-за "роли с galaxy". Вы её открываете, а там пять инклюдов, восемь таск-листов и стопка `when`'ов… И в этом надо разобраться. Вместо 5 тасок линейным списком, в котором и ломаться-то нечему.
В следующих частях
==================
* [Немного про инвентори](https://habr.com/en/post/509938/)
* групповые переменные, host\_group\_vars plugin, hostvars. Как из спагетти связать Гордиев узел. Scope и precedence переменных, модель памяти Ansible. "Так где же всё-таки хранить имя пользователя для базы данных?".
* `jinja: {{ jinja }}` — nosql notype nosense мягкий пластилин. Оно всюду, даже там, где вы его не ожидаете. Немного про `!!unsafe` и вкусный yaml. | https://habr.com/ru/post/508762/ | null | ru | null |
# Openwrt сниффер витой пары
Всем доброго времени суток, моя не большая история началась с того как мы с другом спорили о стандартах 10BASE-T и 100BASE-T о полных и халф-дуплексах в итоге решил на примере готового устройства показать ему что слушать с пар можно.
Прочитав [статью](https://habr.com/ru/post/90678/) взял свой старенький TP-Link mr3240 v1.2 на котором была дефолтная прошивка. немного танцев с бубном и вот на нем уже полноценный снифер с Openwrt на борту, 8Ah батарейка, Wireguard и флешечка для хранения дампов в случае чего.
Установку openwrt описывать не буду т.к мануалов и так куча.
Начнем наверно с установки tcpdump и подготовки самого WRT: логинимся в роутер по SSH, дефолт root без пароля, далее:
```
opkg update && opkg install tcpdump
```
**img**
далее немного настроек в Switch openwrt переходим 192.168.1.1
Network -> Switch
будем слушать порт wan и 4 порт, при этом появится интерфейс влана eth0.3, если оставить настройки дефолтными то на 4 порту мы будем слышать только широковещательные сообщения т.к процессор не будет обрабатывать все адресованные не ему сообщения, в случае со статьей вдохновившей меня мы слушали только одну пару либо RX либо TX в моём случае мы слушаем обе на интерфейсах eth1 и eth0.3
Суть в том, чтобы подключить пары Rx и Tx на пары Rx пары каждого интерфейса:
**img**
Для этого я собрал такой топорный кабель:
**Кабель**
Теперь вопрос о том, как же удобно слушать просто запустить tcpdump и хранить всё на роутере не вариант от слова совсем, только в редких случаях конечно где объем не трафика не большой.
Поэтому решено использовать pipe через ssh plink для windows подходит прям идеально и смотреть всё в wireshark.
Нашел на просторах интернета простой скриптик, в котором нужно указать интерфейс и так далее:
```
@REM ----------------------------------------------------
@REM remotecap.cmd
@REM Example command for captruing eremote network packet
@REM using wireshark and tcpdump.
@REM First written by j2doll. September 10th 2016.
@REM https://github.com/j2doll/wireshark-remote-command-win
@REM http://j2doll.tistory.com
@REM ----------------------------------------------------
@REM install putty and wireshark on your windows pc.
@SET PLINK_PATH="C:\Program Files\PuTTY\plink.exe"
@SET WIRESHARK_PATH="C:\Program Files\Wireshark\Wireshark.exe"
@SET REMOTE_SERVER=192.168.1.1
@SET REMOTE_ACCOUNT=root
@SET REMOTE_PASSWORD=
@SET REMOTE_INTERFACE=eth0.3
@REM execute command
%PLINK_PATH% -batch -ssh -pw %REMOTE_PASSWORD% %REMOTE_ACCOUNT%@%REMOTE_SERVER% "tcpdump -s0 -U -w - -i %REMOTE_INTERFACE%" | %WIRESHARK_PATH% -i - -k
```
Конечно, можно было бы и доделать это всё есть скриптик на питоне, который объединяет два pipe в один и видно было бы удобно, но для моих целей это было вовсе не нужно.
Дальше вставляем кабель между девайсами и дополнительные пары в wan и 4 порт роутера запускаем две версии скрипта в одной REMOTE\_INTERFACE=eth0.3 во второй REMOTE\_INTERFACE=eth1.
Пара желтых кабелей была для снифера в них я использовал только зеленую пару как и описывал выше, накручена она на оранжевую пару цветной к цветному, полосатый к полосатому второй кабель так же к зеленой паре.
Я использовал в качестве жертв ноутбук и map lite, синий и серый кабеля как раз для них спаяны они на прямую то есть как должно быть цвет к цвету.
**Чутка картиночек**
Дальше всё это запитал от аккума добавил wwan подкрутил wireguard и снифить можно из дома, естественно, если есть куда подкинуть wwan в месте, где мы слушаем.
На этом всё.
З.Ы. если сделать мост между интерфейсами то можно слушать оба интерфейса вместе то есть в шарке будет видно сразу и RX и TX)) | https://habr.com/ru/post/512468/ | null | ru | null |
# Универсальный бот для игры Flood-It
*Рисунок 1. Игровое поле.*
Однажды, попалась мне на глаза одна [статейка](http://habrahabr.ru/blogs/gdev/129117/). Сразу же после прочтения заголовка, в голове появились десятки идей подобного рода, среди которых была та самая — идея создания универсального бота для этой игры.
На тот момент особого опыта в автоматизации игр я не имел, но желание было превыше всего. Поэтому, достав тетрадь, я начал обдумывать сей процесс…
#### Анализ
Анализировать я начал с конца, представив, что у меня на руках уже есть работающая программа, нажимающая нужные кнопки в нужной последовательности. Чтобы она умела это делать, ей нужно знать координаты этих кнопок, не будет же она тыкать в любое место на экране, в надежде на то, что хоть раз попадёт? Далее, нужно предоставить последовательность, по которой бот будет нажимать кнопки, не будет же он тыкать любые кнопки, верно? Чтобы предоставить необходимую последовательность нажатий, нужно выбрать наиболее оптимальный алгоритм выбора цветов для заливки, а как это сделать не имея данных о состоянии поля? Правильно, никак! Поэтому нужно получить данные о цветах ячеек в игровом поле. Отлично, но возникает вопрос, а где же само игровое поле? Ответ «где-то на экране» не принимается, поэтому нужно будет найти и его. Вот теперь вроде всё, распишем план наших дальнейших действий:
* распознать игровое поле и его параметры;
* получить данные о цветах ячеек в игре;
* найти оптимальную последовательность вариантов заливки;
* отыскать положение кнопок заливки по каждому цвету;
* автоматизировать процесс игры.
#### Распознавание игрового поля и его параметров
Первым делом нужно было как-то узнать положение игрового поля на экране. Но сначала не помешало бы получить снимок экрана. Для этого мне понадобился класс java.awt.Robot, с его методом: BufferedImage createScreenCapture(Rectangle screenRect).
А что же дальше? А дальше было множество попыток заставить программу находить положение игрового поля, десятки тысяч обращений к методу getRGB класса BufferedImage, попытки узнать позицию игрового поля по шаблону и т.д. Все эти результаты были безуспешны. То что работало для одной игры, не работало для другой. И вот однажды, в голову ко мне влетел такой вот план:
* бинаризировать изображение;
* при необходимости инвертировать его, чтобы значимые точки были белыми, а фон чёрным;
* подсчитать количество вхождений белых точек по горизонтали и по вертикали;
* отсеять ненужные вхождения;
* найти самую длинную последовательность ненулевых значений. Позиция, с которой начинается эта длинная последовательность будет точкой начала игрового поля, а длина этой последовательности — размером в пикселях.
Получив снимок экрана, неплохо было бы перевести его в ARGB-массив:
```
int[] pixels = new int[w * h];
image.getRGB(0, 0, w, h, pixels, 0, w);
```
Работать с цветным изображением сложно, поэтому нужно бинаризировать его, то есть сделать монохромным, чтобы в нашем распоряжении были лишь черный и белый цвета. Здесь всё просто: берём очередной цвет и смотрим на его яркость, если она ниже пороговой, значит этот цвет будет чёрным, если выше — белым. В программной реализации это выглядит так:
```
int red = (color >> 16) & 0xff;
int green = (color >> 8) & 0xff;
int blue = color & 0xff;
int mean = (qr + qg + qb) / 3;
if (mean > thresholdValue) color = 0xFFFFFFFF;
else color = 0xFF000000;
```
Сначала нужно получить яркость текущего цвета, а она берётся либо как среднее сумм RGB компонент, либо по формуле: brightness = 0.3 \* red + 0.59 \* green + 0.11 \* blue. Коэффициенты взяты не просто так, они означают восприятие человеческим глазом той или иной компоненты цвета.
Теперь нужно подобрать пороговое значение (thresholdValue), 191 вполне подошло — на всех сайтах с игрой, где был светлый фон, бинаризация выдавала такое изображение:
*Рисунок 2. Монохромное изображение.*
А на сайтах с тёмным фоном, значение 64 давало подобную картинку, но инверсную. К слову, 191 я выбрал не просто так, а по закону 255-64.
Легко заметить, что на таком изображении игровое поле найти гораздо проще, чем если бы мы искали на цветном. Остаётся только узнать, светлый или тёмный у нас фон, чтобы по этим данным применить порог 64 или (255-64) и инвертировать изображение при надобности. В коде у меня это выглядит так:
```
private boolean[] threshold(int[] pixels, int value) {
boolean inverse = isBackgroundLight(MAX_COLOR_POINTS);
if (inverse) value = 255 - value;
boolean[] bw = new boolean[pixels.length];
for (int i = 0; i < pixels.length; i++) {
int brightness = getBrightness(pixels[i]);
bw[i] = (brightNess >= value) ^ inverse;
}
return bw;
}
```
isBackgroundLight принимает число точек, которые необходимы для того, чтобы понять, что фон светлый или тёмный. Получаем MAX\_COLOR\_POINTS из цветного изображения и находим среднюю яркость. Если она больше 128, значит фон светлый, если меньше — тёмный.
Далее, в полученном монохромном изображении, нам нужно подсчитать количество белых точек по горизонтали и по вертикали. Делается это двумя проходами по изображению. В итоге получаем два массива со значениями вида: 1440, 1440, 410, 23, 119, 838… Отфильтруем значения меньше среднего, и получаем массив: 1, 1, 0, 0, 0, 1… И наконец, нужно определить самую длинную последовательность вот таких единичек, которые не разорваны нулём. Это тоже довольно тривиальная задача.
В конце концов мы получаем 4 значения: положение игрового поля по горизонтали, по вертикали, ширину и высоту игрового поля. Так как оно квадратное, то два последних значения должны совпадать. Чтобы узнать размер каждой ячейки, нужно поделить размер игрового поля на его размерность. Размерность задаётся пользователем, ведь поле бывает не только 14x14, а и 10x10, 20x20 и т.д.
#### Получение данных о цветах ячеек
Теперь, когда мы определили параметры игрового поля, можно считывать цвета ячеек:
```
int[][] table = new int[boardSize][boardSize];
int offset = cellSize / 2;
for (int i = 0; i < boardSize; i++) {
for (int j = 0; j < boardSize; j++) {
table[i][j] = detectImage.getRGB(j*cellSize + offset, i*cellSize + offset);
}
}
```
Во избежание ошибок, цвета будем брать строго по центру ячейки.
Далее, чтобы проще было работать с данными, нужно перевести эти цвета в идентификаторы: 0, 1, 2, 3… Но простым if (color == 0xFF46B1E2) это не сделать, так как палитра различается в разных версиях игр. Например в одной есть оранжевый цвет, а в другой, вместо него используется сиреневый… Но ничего страшного, пойдём обходным путём — будем запоминать цвета для каждого индекса:
```
private byte[][] colorsToIds(int[][] tableColor) {
int size = tableColor.length;
byte[][] out = new byte[size][size];
int colorsReaded = 1; // сколько цветов распознано
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
int color = tableColor[i][j];
for (byte k = 0; k < colorsReaded; k++) {
// Добавляем цвет в палитру
if (colors[k] == -1) {
colors[k] = color;
colorsReaded++;
if (colorsReaded > MAX_COLORS) colorsReaded = MAX_COLORS;
}
// Если цвет уже в палитре, то присваиваем ему ID
if (color == colors[k]) {
out[i][j] = k;
break;
}
}
}
}
return out;
}
```
MAX\_COLORS здесь равен 6, так как в играх Flood-It именно столько цветов в палитре. Но если вдруг кому-то вздумается сделать игру с десятью различными цветами в палитре, программа сможет распознать и их.
Теперь можно проверить работоспособность этого куска кода. Скормив программе изображение игрового поля на рисунке 1, результат не заставил себя долго ждать:
0 1 2 2 3 3 0 0 1 4 2 3 5 3
2 4 1 1 5 4 5 0 2 4 5 3 4 4
3 1 1 5 2 1 3 5 5 2 1 0 4 2
0 3 1 0 5 4 4 1 4 1 4 5 3 5
4 5 0 4 4 4 3 2 0 3 1 0 0 5
0 4 3 4 1 1 2 2 3 2 4 3 1 2
3 2 0 0 5 2 1 5 3 0 2 1 4 4
3 3 5 3 1 5 3 0 3 5 2 4 1 1
3 3 3 3 0 5 0 3 5 0 1 4 2 4
4 2 3 0 2 1 0 3 1 3 2 5 2 3
5 5 1 4 2 3 5 4 1 2 5 0 4 0
5 2 0 2 2 3 2 5 4 1 1 5 0 5
1 0 0 5 5 5 4 1 2 2 3 2 2 0
3 2 2 3 4 3 0 3 2 2 4 3 5 5
#### Поиск оптимальной последовательности вариантов заливки
Как я ни пытался, но придумать алгоритм лучше чем у автора [статьи](http://habrahabr.ru/blogs/gdev/129117/) у меня не получилось. Поэтому я взял его алгоритм и переписал на более универсальный лад. Думаю он возражать не будет.
```
private byte getNextFillColor(byte[][] table) {
// Количество вариантов заливок
int fillSize = (int) Math.pow(MAX_COLORS, FILL_STEPS);
int[] fillRate = new int[fillSize];
// Заполняем значениями степени заливки
int[] fillPow = new int[FILL_STEPS];
for (int i = 0; i < FILL_STEPS; i++) {
fillPow[i] = (int) Math.pow(MAX_COLORS, i);
}
// Заливаем FILL_STEPS раз MAX_COLORS вариантов
for (int i = 0; i < fillSize; i++) {
byte[][] iteration = copyTable(table);
for (int j = 0; j < FILL_STEPS; j++) {
byte fillColor = (byte) (i / fillPow[j] % MAX_COLORS);
fillTable(iteration, fillColor);
}
// Подсчитываем число залитых ячеек
fillRate[i] = getFillCount(iteration);
}
// Теперь ищем максимально залитый участок из FILL_STEPS итераций заливки
int maxArea = fillRate[0];
int maxColor = 0;
for (int i = 1; i < fillSize; i++) {
if (fillRate[i] > maxArea) {
maxColor = i;
maxArea = fillRate[i];
}
}
// Получаем цвет с наибольшей площадью дальнейшей заливки
byte colorID = (byte) (maxColor % MAX_COLORS);
fillTable(table, colorID);
return colorID;
}
```
Теперь мы не ограничены четырьмя просчетами вперёд и шестью цветами в палитре, поэтому можно менять значения по своему усмотрению.
Составим на основе этой функции, функцию получения полной выигрышной последовательности:
```
ArrayList seq = new ArrayList();
while(!gameCompleted(copyTable)) {
seq.add(getNextFillColor(copyTable));
}
```
gameCompleted проверяет, залиты ли все ячейки каким-нибудь одним цветом, и если да, значит игра завершена.
Запустив приложение, дадим ему на съедение наш рисунок 1, в результате чего получим:
1 2 1 3 0 5 4 0 3 1 0 5 3 1 4 1 5 2 4 0 5
Но такой вид результата не слишком удобен для нас.
#### Поиск положения кнопок заливки
Итак, в нашем распоряжении есть последовательность идентификаторов для заливки, палитра с цветами ячеек, координаты поля и его размер. Остались кнопки. Взглянув на игровые поля можно заметить, что кнопки зачастую находятся левее от игрового поля, причём на одном уровне с ним. Этим мы ограничиваться, конечно же не будем. Вдруг где-то есть игра с кнопками сверху или справа? Далее, цвета кнопок близки к цветам ячеек, но не всегда равны им. Это значит, что простым сравнением точек изображения с палитрой мы ограничиваться не будем. Что ж, соберём всё в кучу и составим алгоритм поиска кнопок:
* выделяем одну из четырёх частей изображения окна: слева от игрового поля, сверху, справа и, наконец, снизу;
* для каждого цвета из палитры ищем близкий к ней цвет на изображении. По нахождению, запоминаем позицию этой точки;
* если точки найдены для всех цветов из палитры, то всё отлично, с заданием справились. Иначе, переходим к первому шагу и выбираем следующую часть изображения;
* если были просмотрены все части изображения, но кнопки так и не нашли, значит их просто нет! В этом случае просто выдадим результат в более человеческом виде.
*Рисунок 3. Разбивка изображения на части.*
Всё вышеописанное в коде выглядит так:
```
public Point[] getButtons(int[] colors) {
Point[] out = new Point[colors.length];
// Размер игрового поля в пикселах
int size = boardSize * cellSize;
// Размеры частей изображения, на которых будем искать кнопки
Rectangle[] partsOfImage = new Rectangle[] {
new Rectangle(0, board.y, board.x, size), // слева от поля
new Rectangle(0, 0, w, board.y), // сверху от поля
new Rectangle(board.x+size, board.y,
w-board.x-size, size), // справа от поля
new Rectangle(0, board.y+size,
w, h-board.y-size) // снизу от поля
};
for (int i = 0; i < partsOfImage.length; i++) {
Rectangle rect = partsOfImage[i];
BufferedImage part = image.getSubimage(rect.x, rect.y, rect.width, rect.height);
// Вырезаем часть изображения, в котором будем искать
boolean found = true;
for (int j = 0; j < colors.length; j++) {
if (colors[i] == -1) continue;
Point pt = findButton(part, colors[j]);
if (pt != null) {
// Учитываем смещения относительно частей картинок
pt.translate(rect.x, rect.y);
out[j] = pt;
} else {
found = false;
break;
}
}
if (found) return out;
}
// Не удалось найти все точки
return null;
}
```
findButton просто перебирает все точки изображения, пока не встретит похожий на заданный ему цвет. Чтобы найти такой цвет, нужно посчитать разность по модулю каждой его RGB компоненты и сравнить с некоторым числом — чувствительностью:
```
private boolean isEquals(int color1, int color2, int tolerance) {
if (tolerance < 2) return color1 == color2;
int r1 = (color1 >> 16) & 0xff;
int g1 = (color1 >> 8) & 0xff;
int b1 = color1 & 0xff;
int r2 = (color2 >> 16) & 0xff;
int g2 = (color2 >> 8) & 0xff;
int b2 = color2 & 0xff;
return (Math.abs(r1 - r2) <= tolerance) &&
(Math.abs(g1 - g2) <= tolerance) &&
(Math.abs(b1 - b2) <= tolerance);
}
```
#### Автоматизация игрового процесса
Итак, когда все кнопки будут найдены и будет дана нужная последовательность их нажатий, можно приступать к «автокликанью». Для того, чтобы программа сама переводила курсор в нужное место и нажимала левую кнопку мыши, служит всё тот же класс java.awt.Robot. Функция выглядит так:
```
public void clickPoint(Point click) {
robot.mouseMove(click.x, click.y);
robot.mousePress(InputEvent.BUTTON1_MASK);
robot.delay(CLICK_DELAY);
robot.mouseRelease(InputEvent.BUTTON1_MASK);
}
```
Поясню: сначала переводим курсор в нужную позицию экрана, затем нажимаем левую кнопку мыши, ждём несколько долей секунд, чтобы браузер смог успеть обработать нажатие, и затем отпускаем кнопку. Всё просто. А имея последовательность индексов для нажатий и координаты каждой кнопки, можно написать автоматический кликер:
```
public void autoClick(Point[] buttons, byte[] result) {
for (int i = 0; i < result.length; i++) {
clickPoint(buttons[result[i]]);
}
}
```
Всё, осталось теперь обработать ситуацию, когда кнопок нет на экране. В этом случае просто создадим изображение, нарисуем на нём все цвета (именно цвета, а не идентицикаторы 0, 1, 2...) по порядку и выведем на экран.
```
public BufferedImage sequenceToImage(byte[] ids, int[] palette) {
final int size = 20; // размер каждой ячейки
// Разбивать будем по 10 клеток на строку
final int CELLS_IN_ROW = 10;
int width = CELLS_IN_ROW * size;
if (width == 0) width = size;
int rows = ids.length / CELLS_IN_ROW;
BufferedImage out = new BufferedImage(width, (rows*size)+size, BufferedImage.TYPE_INT_RGB);
Graphics G = out.getGraphics();
for (int i = 0; i < ids.length; i++) {
G.setColor(new Color(palette[ids[i]]));
G.fillRect(i % CELLS_IN_ROW * size,
i / CELLS_IN_ROW * size,
size, size);
}
G.dispose();
return out;
}
```
#### Заключение
Вот что получилось всё с тем же рисунком 1:
*Рисунок 4. Результат.*
Спасибо за внимание, буду рад любым советам и идеям по этой тематике.
Исходники доступны на github: [Flood-It-Bot](https://github.com/aNNiMON/Flood-It-Bot) | https://habr.com/ru/post/136380/ | null | ru | null |
# Переводим студентов на удаленку за 1 день
Еще 16 марта мы сидели в уютном оупенспейсе, а уже на следующий день весь офис переехал на удаленку, домой. На хабре достаточно подобных историй. Но специфика нашей ситуации заключается не в переводе сотрудников, а переводе клиентов. Это более трех тысяч студентов, которые пришли учиться на дневном, но в одначасье оказались на заочном.
#### Что было сделано
Учебным отделом для преподавателей были разработаны методические рекомендации по ведению лекций online. Например, такие как:
**Длительность занятий**Если у вас в расписании запланировано было офлайн-занятие длительностью 4 ак.часа, то вы можете сохранить эту длительность для онлайн, однако ввести более длинный перерыв (30-40 минут), чтобы студенты успели отдохнуть.
Если у вас в расписании запланировано было офлайн-занятие длительностью 8 ак.часов (полный день в выходные), то мы рекомендуем разделить занятие на две части (и вести занятия не три, например, раза в неделю, а четыре).
Если у вас большая группа, то мы рекомендуем ее разделить и провести более короткие занятия, но с большой интенсивностью и плотностью взаимодействия внутри группы.
**Фокусировка внимания**Теоретические занятия в онлайне максимально похожи на офлайн, но– однако стоит учесть, что фокус внимания в онлайне еще короче, чем в офлайне. Поэтому мы рекомендуем проводить лекции с интерактивным форматом: например, 15-20 минут теоретического материала, после которого следует дискуссия, вовлекающая в обсуждение всех студентов.
Интерактивные занятия лучше всего проводить в малых группах (10-12 человек). Если у вас большая группа (30+ человек), то лучше «разбить» группу на две части и провести, например, первые 2 ак.часа с первой половиной и вторые 2 ак.часа – с другой.
Огромная работа легла на сотрудников первой и второй линии поддержки. В одночасье на поддержке оказались тысячи личных устройств пользователей, на которых надо помочь установить необходимый софт, выдать лицензии на специфическое ПО и еще, внезапно, Zoom не работает в Крыму (кто успел туда уехать), Опера c встроенным VPN`ом помогают.
В качестве основной платформы был выбран Zoom.
Изначально остро встал вопрос с планированием занятий, созданием конференций и информированием всех студентов и проеподавателей.
*Вот так выглядело расписание Zoom лекций первые несколько дней. В котором все конференции создавались вручную*
*А так, когда оно снова стало вестись в 1с*
Спасибо моему коллеге, что он оперативно раскурил API Zoom`а и прикрутил автоматическое создание конференции в соответствии с расписанием. А так же автоинформирование об этом.
А тут [ссылка](https://infostart.ru/public/1219405/) на труды Сергея, как с помощью Zoom API можно создавать конференции.
Я в свою очередь хочу поделиться опытом по интергации платформы в Android приложение.
В нашем юзер-кейсе это оказалось очень удобно, т.к. конференции создаются на сервере и их идентификаторы передаются в расписание на телефоне.
*Интерфейс расписания интегрированного с Zoom*
**Теперь посмотрим как это работает.**
*[Исходный код](https://github.com/donyab/ZoomExample)*
1. Импортируем две библиотеки из [SDK](https://github.com/zoom/zoom-sdk-android/archive/master.zip): commonlib и mobilertc. Это, наверно, самый печальный этап, т.к. ваше приложение становится тяжелее на 80 мегабайт.
2. Имплементируем InitAuthSDKCallback, MeetingServiceListener в нашу активити или фрагмент. Для работы зума нужен минимальный API 21 (В документации на сайте указан minSdkVersion 16, но ее не очень оперативно обновляют, лучше ориентироваться на примеры в семплах идущих с SDK).
При создании фрагмента инициализируем SDK
**Инициализация Zoom SDK**
```
private View view;
private ZoomSDK mZoomSDK;
@Override
public View onCreateView(
LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
view = inflater.inflate(R.layout.fragment_first, container, false);
mZoomSDK = ZoomSDK.getInstance();
if (mZoomSDK.isLoggedIn()) {
getActivity().onBackPressed();
return null;
}
InitAuthSDKHelper.getInstance().initSDK(getContext(), this);
if (mZoomSDK.isInitialized()) {
ZoomSDK.getInstance().getMeetingService().addListener(this);
ZoomSDK.getInstance().getMeetingSettingsHelper().enable720p(true);
}
return view;
}
```
Для этого созаем класс InitAuthSDKHelper и вызываем функцию:
**initSDK**
```
public void initSDK(Context context, InitAuthSDKCallback callback) {
if (!mZoomSDK.isInitialized()) {
mInitAuthSDKCallback = callback;
ZoomSDKInitParams initParams = new ZoomSDKInitParams();
// initParams.jwtToken = SDK_JWTTOKEN;
initParams.appKey = SDK_KEY;
initParams.appSecret = SDK_SECRET;
initParams.enableLog = true;
initParams.logSize = 50;
initParams.domain = WEB_DOMAIN;
initParams.videoRawDataMemoryMode = ZoomSDKRawDataMemoryMode.ZoomSDKRawDataMemoryModeStack;
mZoomSDK.initialize(context, this, initParams);
}
}
```
Тут обратим внимание на следующие параметры:
**appKey и appSecret** — это идентификатор и секретный ключ вашего приложения, которое вы создаете на сайте зума (занимает примерно 1 минуту), зарегитрировавшись как разработчик.
На практике настоятельно не рекомендуется использовать их для идентификации.
Вместо них следует использовать параметр **jwtToken**, как это сделать написано [тут](https://marketplace.zoom.us/docs/guides/auth/jwt).
**Подключение к конференции**
```
private AutoCompleteTextView idMeeting;
private AutoCompleteTextView idDisplayName;
private void onClickJoin() {
if(!mZoomSDK.isInitialized())
{
Toast.makeText(getContext(),"ZoomSDK has not been initialized
successfully",Toast.LENGTH_SHORT).show();
InitAuthSDKHelper.getInstance().initSDK(getContext(), this);
return;
}
if (ZoomSDK.getInstance().getMeetingSettingsHelper().isCustomizedMeetingUIEnabled()) {
ZoomSDK.getInstance().getSmsService().enableZoomAuthRealNameMeetingUIShown(false);
} else {
ZoomSDK.getInstance().getSmsService().enableZoomAuthRealNameMeetingUIShown(true);
}
String number = idMeeting.getText().toString();
String name = idDisplayName.getText().toString();
JoinMeetingParams params = new JoinMeetingParams();
params.meetingNo = number;
params.displayName = name;
ZoomSDK.getInstance().getMeetingService().joinMeetingWithParams(getContext(), params);
}
```
*В данной реализации используется родной интерфейс. Но поддерживается возможность его кастомизации.*
#### Выводы
1. Процесс обучения (за исключением тех случаев, когда требуются мастерские и спец. оборудование) можно перевести в online.
2. Важен целенаправленный и систематический подход, чтобы исключить зоопарк инструментов коммуникации, которые каждый тьютор будет использовать.
3. Если у вас на бэкенде учебный процесс был до этого налажен, то внедрение конференций в мобильное приложение не займет много времени. | https://habr.com/ru/post/495820/ | null | ru | null |
# Миграция схемы данных без головной боли: идемпотентность и конвергентность для DDL-скриптов
Язык SQL и реляционные базы с нами уже более сорока лет. За это время стандарт SQL прошёл через множество ревизий, и, судя по всему, процесс развития на этом не останавливается. Реляционные базы в качестве хранилищ данных десятилетиями царствовали безраздельно, царствуют и поныне, и лишь только в последнее время их немного теснят альтернативные подходы.
SQL практически всемогущ, если вопрос касается извлечения данных. (Не все знают, но одним SQL-запросом [можно](https://thedailywtf.com/articles/Stupid-Coding-Tricks-The-TSQL-Madlebrot) графически построить [множество Мандельброта](https://en.wikipedia.org/wiki/Mandelbrot_set)). Но одна проблема продолжает быть в нём концептуально не решена: проблема миграции схем данных.
Я думаю, на разных этапах своей карьеры в IT мы все сталкивались с тем, как это бывает тяжело: контролировать структуру рабочей базы данных и выполнять её обновления по мере разворачивания новых версий софта. Баги, возвращающиеся после того, как их вроде уже исправили, ошибки «поле отсутствует в таблице», жалобы «я исправил хранимку, а вы затёрли!» — знакомо ли вам это всё?
Острота этой проблемы особенно ясна по контрасту с тем, насколько кардинально решена задача контроля версий исходного кода: системы типа Git или Subversion позволяют вам держать под контролем совместную работу многих разработчиков, не терять ни одного изменения, «записывать все ходы» и собирать результаты труда команды воедино. Но эта благостная картина заканчивается там, где заканчивается область применимости систем контроля версий. Если мы говорим о структуре схемы данных, то до сих пор применение систем контроля версий для их разработки — весьма ограничено.
Так легко и соблазнительно бывает внести изменения структуры прямо на базе! Если такие изменения оказываются не задокументированы, то в будущем наступает необходимость развивать систему и приближается катастрофа. Но и осознав необходимость документировать каждый шаг по изменению структуры БД, мы приходим к тому, что делать это — очень неудобно, а язык DDL определения схемы данных нам в этом никак не помогает. Например, добавление поля в таблицу требует команды ALTER TABLE ADD. Выполнить это выражение имеет смысл ровно один раз и ровно тот самый момент, когда в таблице поле ещё отсутствует, а необходимость в нём – уже есть. Выполнение этого скрипта в другие моменты приведёт либо к ошибке выполнения самого скрипта, либо, что хуже, к неправильному состоянию структуры базы данных.
Как же агрегировать все изменения, производимые разработчиками, в единый результат и как проконтролировать его выполнение?
### Подход №1: накопление change-скриптов
Практическое решение этой задачи вручную, без использования каких-либо дополнительных инструментов, заключается в создании в кодовой базе проекта папки с пронумерованными скриптами модификации структуры базы данных, в накапливании их в этой папке и во введении строжайшей дисциплины среди участников проекта разработки. Должен быть формализован процесс записи изменений в очередном скрипт-файле и процесс «накатки» изменений на базы данных.
Более продвинутым и удобным способом решения является использование систем типа [Liquibase](http://www.liquibase.org/). Liquibase берёт на себя контроль номера последнего выполненного изменения структуры данных и обеспечивает прогон скриптов модификации структуры в линейном порядке, один и только один раз. Это уже очень много, и использование Liquibase однозначно ликвидирует хаос, царящий при разработке и обновлении схемы данных.
Но тем не менее, использование Liquibase и других инструментов, основанных на накоплении change-скриптов, не делает задачу модификации схемы данных столь же легкой и техничной, как легка и технична модификация программного исходного кода вашего приложения.
Во-первых, change-скрипты *накапливаются*. Достаточно долго идущий проект тянет за собой большой «хвост» из этих скриптов, большинство из которых утрачивают свою актуальность, т. к. содержат в себе изменения, выполненные очень давно. Сохранение всего «хвоста» бывает бессмысленно, т. к. изменение в одном месте лога может отменять результат изменения в другом месте: допустим, в ходе развития системы мы попробовали какой-то вариант и отказались от него, но два изменения уже навсегда остаются change-log-е. Глядя на разросшийся лог, становится невозможно понять наше текущее представление о структуре базы. А если мы хотим воспроизвести структуру базы данных «с нуля» на, допустим, совершенно новом проекте, нам придётся в процессе выполнения скрипта повторять весь её путь эволюционного развития!
Во-вторых, при таком подходе сохраняется колоссальная разница между сложностью модификации структуры БД через changeset-ы и простотой модификации исходного кода программы.
Допустим, у вас есть код, описывающий класс в вашем любимом языке программирования, и вам в процессе улучшения системы понадобилось один метод в класс добавить, а другой – удалить. Что вы делаете? Берёте и меняете исходный код класса, а затем коммитите его на систему контроля версий, не так ли? Не вынуждены же вы создавать change set с командами вида:
`alter class drop method foo;
alter class add method bar(…) {
…
}`
Почему мы должны это делать для структуры схемы данных?
Причина, конечно, в том, что в базе данных лежат ещё и данные, с которыми надо что-то делать при изменении структуры. Об этой проблеме мы ещё поговорим, но сначала давайте взглянем на другой возможный подход к решению нашей задачи.
### Подход №2: идемпотентный DDL-скрипт
Проблемы, схожие с теми, что возникают при миграции схемы базы данных, давно возникали при конфигурировании серверов.
Как автоматизировать установку нужного софта на сервер и обеспечить обновление конфигураций? Мы можем написать shell-скрипт, который, будучи выполнен на пустой виртуальной машине, всё на ней установит и сконфигурирует. Это аналог скрипта создания структуры БД (CREATE TABLE…-скрипта), но его проблема в том, что он может быть выполнен только один раз и только на пустой машине. Если машина уже развёрнута и работает, а по новой спецификации для работы системы нам нужна, например, другая версия Java, как тут постуить — дописывать change скрипт, сносящий старую версию и устанавливающий новую версию Java? Ну а если нам нужно будет воспроизвести конфигурацию на пустой машине — нам что же, проходить через все шаги, которые мы прошли исторически?
Главный, ключевой вопрос, который при этом возникает: можно ли править инфраструктуру/схему данных так же легко, как мы правим исходный код – прямым изменением её описания и записи в контроль версий?
Ответом на эти вопросы для задачи конфигурирования серверов явилось появление принципа [Infastructure as Code (IaC)](https://en.wikipedia.org/wiki/Infrastructure_as_Code) и целого класса систем, известных как configuration management-системы: Ansible, Chef, Puppet и т. д. В основе всех систем этого вида стоят два главных принципа: идемпотентность (idempotence) и конвергентность (сходимость, convergence). Оба этих термина позаимствованы из математики. Если отбросить ненужный формализм, применительно к нашей проблематике термины эти обозначают следующее:
1. Идемпотентный и конвергентный скрипт описывает **не действия**, которые надо произвести над объектом, **а состояние**, в которое нужно привести объект.
2. Идемпотентность означает, что если такой скрипт выполнен успешно и объект уже находится в нужном состоянии, то повторное выполнение скрипта ничего не изменит и ни к чему не приведёт. Например, если мы говорим о скрипте configuration management системы, декларирующем установку необходимых пакетов, то, если эти пакеты уже установлены, при повторном запуске скрипт просто не выполнит никаких операций.
3. Конвергентность означает, что если скрипт не был выполнен или завершился неуспешно, при его повторном выполнении система будет стремиться к желаемому состоянию. Например, если установка одного из пакетов завершилась с ошибкой, т. к. в момент скачивания пакета пропала сеть, то повторный запуск скрипта приведёт к тому, что пропущенный пакет доустановится (а те, что установились в прошлый раз, останутся на своём месте).
Данные принципы являются общими и применимы не только к программной конфигурации машин. Например, система Terraform позволяет вам в виде кода специфицировать необходимый набор виртуальных серверов и их аппаратную конфигурацию и контролировать ваш парк виртуальных машин в облаке.
Я думаю, сказанного уже достаточно для того, чтобы понять, каким образом эти принципы могут помочь для контроля схемы данных. Предположим, что наша база данных поддерживает ключевое слово “CONVERGE” и у нас имеется такой скрипт:
`CONVERGE TABLE OrderHeader(
id VARCHAR(30) NOT NULL,
date DATETIME DEFAULT GETDATE(),
customer_id VARCHAR(30),
customer_name VARCHAR(100),
CONSTRAINT Pk_OrderHeader PRIMARY KEY (id)
);`
Ключевое слово CONVERGE должно интерпретироваться как «приведи таблицу к желаемой структуре». То есть: если таблицы нет — создай, если таблица есть, посмотри, какие в ней поля, с какими типами, какие индексы, какие внешние ключи, какие default-значения и т. п. и не надо ли что-то изменить в этой таблице, чтобы привести её к нужному виду.
Если бы базы данных могли поддерживать такое ключевое слово, т. е. если бы была возможность писать для баз данных идемпотентные и конвергентные DDL-скрипты — необходимости в написании этой статьи не возникло бы. Все мы просто держали бы в системе контроля версий “CONVERGE TABLE”-скрипты, описывающие желаемую на текущий момент схему данных, и работали бы с ними точно так же, как работаем с исходным кодом: нужно новое поле в таблице — добавили, нужен другой состав полей в индексе — отредактировали. (Я слышу ваш вопрос: а как же быть с миграцией данных — но терпение, я к этому перейду уже скоро.)
К сожалению, в мире реляционных БД движения к поддержке настоящей идемпотентности DDL пока не происходит. Всё, что до сих пор было сделано в базах данных по направлению к идемпотентности DDL-кода – это поддержка конструкции CREATE IF NOT EXISTS, но это, скажем прямо – довольно слабая попытка. Скрипт CREATE TABLE IF NOT EXISTS, конечно, внешне поведёт себя как идемпотентный (не выдаст ошибку, если таблица уже создана), но не как конвергентный (не будет модифицировать структуру уже созданной таблицы).
Приходится уповать на внешние инструменты. Идемпотентный и конвергентный DDL доступен, например, в системе [Celesta](https://habrahabr.ru/post/335966/). Чтобы для разработчиков и для инструментов разработки (например, визуального редактора ER-диаграмм) выглядеть как обычный DDL-скрипт, в Celesta применяется ключевое слово CREATE, хотя в Celesta оно обладает смыслом именно гипотетического CONVERGE. При каждом старте, Celesta сравнивает актуальную структуру базы данных, к которой она присоединена, с желаемой структурой, описанной в виде DDL-скрипта CelestaSQL, и при необходимости выполняет *минимально необходимую* серию CREATE/ALTER/DROP-команд. На сегодня поддерживаются четыре типа баз данных: PostgreSQL, Oracle, MS SQL Server и H2 (последняя, в основном, для нужд организации модульного тестирования).
Идемпотентный скрипт, задающий структуру БД, нельзя просто взять и линейно выполнить. Как известно, одни объекты в базе данных зависят от других объектов — например, таблицы ссылаются друг на друга через внешние ключи, представления и индексы зависят от таблиц и т. д. Поэтому, прежде чем выполнять серию создания / перестроения объектов, их необходимо ранжировать в порядке зависимости друг от друга: говоря формально, выполнить топологическую сортировку графа зависимостей, и далее обрабатывать объекты, начиная с тех, от которых не зависит ничего. Часто бывает необходимо сбросить внешние ключи, чтобы затем восстановить их после модификации соединяемых ими таблиц. Эта задача решена в Celesta, и это позволяет без проблем выполнять апгрейд для абсолютного большинства случаев.
### Миграция данных
Так как же быть с трансформацией данных, ведь простого ALTER не всегда достаточно? Что делать, если мы, допустим, захотим добавить в непустую таблицу NOT NULL-поле и не снабдим его DEFAULT-значением? Ведь если такое поле не заполнить предварительно данными, то база данных не даст выполнить ALTER TABLE ADD-скрипт. А если мы хотим добавить Foreign Key, но не все данные в таблице удовлетворяют ограничению? А если, допустим, логика приложения изменилась и требуется перенести данные из одного столбца в другой?
Всё это вопросы совершенно корректные, но для начала заметим, что для большинства изменений, которые вы производите в базе данных в процессе развития вашего приложения, никакой миграции не требуется и простого ALTER-скрипта достаточно. Вам не надо мигрировать данные, если вы просто добавляете новую таблицу или новую колонку в таблицу (NULLABLE или с DEFAULT-значением). Вам не надо мигрировать данные, если вы добавляете или перестраиваете индекс. Не нужно ничего мигрировать, если изменяется запрос для view. Практика применения системы Celesta показывает, что *подавляющее* большинство производимых разработчиками изменений относится именно к такому типу.
Если же миграция данных действительно необходима, то, да: придётся написать и выполнить одноразовый миграционный скрипт. Вот только сохранять этот скрипт «на века» не нужно и история с его отладкой и применением гораздо проще, чем в системах, построенных на change log.
Рассмотрим случай добавления внешнего ключа на непустую таблицу, не все записи которой удовлетворяют такому ключу. В процессе обновления Celesta попробует создать такой ключ при помощи команды ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY. Если ей это удаётся – отлично, если нет – система останавливается и Celesta сообщает, что апдейт такого-то объекта она выполнить полностью не сумела по такой-то причине, с таким-то сообщением БД.
Для changelog-систем нет ничего хуже changeset-а, выполнившегося наполовину и зафиксированного в промежуточном состоянии: в такой ситуации система находится «посередине» между двумя ревизиями и ситуацию можно разрулить лишь вручную. Отсутствие поддержки откатываемых DDL-транзакций во многих базах вносит дополнительные трудности.
Для «конвергентных» систем, в отличие от «changelog»-систем, апдейты, не выполненные до конца, не являются проблемой, т. к. для генерации ALTER-команд система сравнивает текущее *фактическое* состояние базы с желаемым, и изменения, не выполненные при одной попытке, она будет пытаться доделать в другой.
Столкнувшись с ситуацией, когда апдейт не может быть выполнен автоматически (ситуация, повторюсь, довольно редкая), вы можете сделать одноразовый скрипт. Допустим, наполняющий таблицу-справочник нужными данными и тем самым создающий для Celesta условия автоматического выполнения апдейта. Этот скрипт можно отладить на свежей копии production-базы, затем выполнить на production базе, затем произвести Celesta-апдейт.
После всего этого **ваш скрипт можно просто выкинуть**, потому что больше он вам не понадобится никогда! Ведь ваши рабочие базы уже находятся в нужном вам состоянии по структуре, а если вы задумаете делать новую базу «с нуля», то тогда вам не надо заставлять базу проходить весь тот путь, который вы прошли, дорабатывая её структуру в процессе разработки.
Возможно, такой подход покажется кому-то менее надёжным, чем использование changelog-систем, которые заставляют вас думать о необходимых шагах по миграции данных при каждом изменении структуры и о встраивании таких шагов в changeset. Но если подумать, то становится понятно, что надёжность changelog-систем в этом плане – мнимая. Как известно, не бывает программ без потенциальных ошибок, это правило относится и к скриптам модификации данных. Тот факт, что на имеющемся у вас наборе данных скрипт модификации change set-а был отлажен и показал корректную работу, на самом деле не гарантирует со 100% уверенностью, что он выполнится без ошибок на любых данных. В случае с применением идемпотентного DDL мы по крайней мере не объявляем скрипт модификации данных не подлежащим изменению, защищённым контрольной суммой атрибутом ревизии. В случае, если ошибка всё же произойдёт, мы всегда можем повторять попытки апдейта до тех пор, пока не сведём систему к желаемой структуре. Ваши данные не будут потеряны, т. к. Celesta никогда автоматически не выполняет drop столбцов и таблиц, содержащих данные, оставляя эту операцию на выполнение вручную.
### \* \* \*
~~К сожалению, область применения CelestaSQL ограничена использованием его в паре с [системой Celesta](https://habrahabr.ru/post/335966/) для создания кода бизнес-логики,~~ (уже нет — см. update!) поэтому именно для вашего проекта на сегодня, пожалуй, я бы порекомендовал Liquibase. Однако Celesta — проект открытый и одно из возможных направлений его развития – создание инструмента миграции структуры БД общего назначения.
Хотя лично я бы предпочёл, чтобы разработчики БД когда-нибудь реализовали реальную поддержку идемпотентности и конвергентности DDL.
UPD: С начала 2018 года CelestaSQL можно применять для идемпотентного обновления произвольной базы данных при помощи системы [2bass](https://github.com/CourseOrchestra/2bass). | https://habr.com/ru/post/337816/ | null | ru | null |
# Имитируем иридисценцию: шейдер CD-ROM
Этот туториал посвящён **иридисценции**. В этом туториале мы исследуем саму природу света, чтобы понять и воссоздать поведение материала, создающего цветные отражения. Туториал предназначен для разработчиков игр на Unity, однако описанные в нём техники можно запросто реализовать на других языках, в том числе в Unreal и на WebGL.
Туториал будет состоять из следующих частей:
* Часть 1. Природа света
* Часть 2. Усовершенствуем радугу — 1
* Часть 3. Усовершенствуем радугу — 2
* Часть 4. Разбираемся с дифракционной решёткой
* Часть 5. Математика дифракционной решётки
* Часть 6. Шейдер CD-ROM: дифракционная решётка — 1
* Часть 7. Шейдер CD-ROM: дифракционная решётка — 2
#### Введение
**Иридисценция** — это оптическое явление, при котором объекты изменяют цвета при изменении угла освещения или угла обзора. Именно благодаря этому эффекту пузыри обладают такой широкой палитрой цветов.
Иридисценция также проявляется в луже пролитого бензина, на поверхности CD-ROM и даже на свежем мясе. Многие насекомые и животные используют иридисценцию для создания цветов без наличия соответствующих пигментов.
Так происходит потому, что иридисценция возникает вследствие взаимодействия света и микроскопических структур, которые находятся на поверхностях всех этих объектов. И дорожки CD-ROM, и чешуйки наружного скелета насекомого (см. изображения ниже) имеют тот же порядок величины длины волн света, с которым они взаимодействуют. На самом деле, иридисценция стала первым явлением, которое позволило раскрыть истинную волновую природу света. Мы не сможем объяснить и воспроизвести иридисценцию, не поняв сначала, что же такое свет, как он работает и как воспринимается глазом человека.
#### Природа света
Как и многие субатомные частицы, свет одновременно проявляет свойства частиц и волн. Довольно часто свет моделируют как первые или вторые. Для большинства применений свет можно рассматривать как созданный из триллионов отдельных частиц, называемых **фотонами**. Например, большинство шейдеров считает, что фотоны ведут себя как крошечные бильярдные шары и отражаются от объектов по тем углом, под которым столкнулись с ним (см. схему ниже).
Но свет также можно смоделировать как волну. Физики знакомы с этой концепцией, однако разработчикам она известна не всегда. Так давайте же потратим немного времени на то, чтобы понять, что означает для света существование в виде волны.
Всем нам известны океанские волны. Каждая точка на поверхности океана имеет высоту. Чем выше она от среднего значения, тем выше волна. Если потревожить поверхность воды, волны начинают распространяться по океану, пока их энергия не рассеется.
Свет — это волна, но вместо того, чтобы измерять его как высоту на поверхности воды, он задаётся как энергия, которой обладает **электромагнитное поле** в нужной точке. В соответствии с этой моделью, свет — это возмущение электромагнитного поля, распространяющееся через пространство. Мы можем представить лампочку, или создающую волну, или испускающую в окружающее пространство множества фотонов.
Величина переносимой фотоном **энергии** определяет цвет света. Фотоны с низкой энергией воспринимаются как красный цвет; фотоны с высокой энергией воспринимаются как фиолетовый. Волны обладают свойством, аналогичным энергии частицы: **длиной волны**. Для интуитивного понимания можно сказать, что это расстояние между двумя пиками волны.
Свет всегда движется с одной скоростью (приблизительно 299 792 458 метров в секунду), то есть электромагнитные волны распространяются с одинаковой скоростью. Хотя их скорость постоянна, длина волн может быть разной. Фотоны с высокой энергией — это волны с короткой длиной. Именно длина волны света в конце концов определяет его цвет.
Как вы видите на схеме выше, глаз человека может воспринимать фотоны с длиной волны в интервале примерно от 700 нанометров до 400 нанометров. Нанометр — это миллиардная часть метра.
**Насколько мал нанометр?**
Когда пытаешься разобраться с наименьшими масштабами, в которых работает Природа, сложно представить обсуждаемые размеры. Средний человек имеет рост примерно 1,6 метра. Толщина человеческого волоса примерно 50 **микрометров** (50 мкм). Микрометр — это миллионная часть метра (1 мкм = 0,000001 метра =  метра). **Нанометр** — это одна тысячная микрометра (1 нм = 0,000000001 метра =  метра). То есть длина волны видимого света равна примерно одной сотой толщины человеческого волоса.
##### Что дальше?
После этого краткого введения в оставшейся части туториала мы сосредоточимся на понимании иридисценции и её реализации в Unity.
* **Усовершенствуем радугу.** Как сказано выше, разные длины волн света воспринимаются человеческим глазом как разные цвета. В следующих двух частях мы разберёмся с тем, как связать эти длины волн с цветами RGB. Этот шаг необходим для воссоздания иридисцентных отражений с высокой степенью точности. В этих частях я также представлю новый подход, который будет и физически точным, и эффективным с точки зрения вычислений.
* **Дифракционная решётка.** В частях 4 и 5 этого туториала мы рассмотрим **дифракционную решётку**. Это техническое название одного из эффектов, заставляющих материалы демонстрировать иридисцентные отражения. Несмотря на свою «техничность», выведенное уравнение, управляющее этим оптическим явлением, будет очень простым. Если вас не интересует математика дифракционной решётки, то можете пропустить часть 5.
* **Шейдер CD-ROM.** Ядро этого туториала — реализация шейдера CD-ROM. В нём для реализации дифракционной решётки в Unity будут использоваться знания, собранные в предыдущих частях. Он является расширением стандартного поверхностного шейдера (Standard Surface shader) Unity 5; что делает этот эффект и физически правильнмы, и фотореалистичным. Приложив небольшие усилия, вы сможете изменить его так, чтобы он соответствовал другим типам иридисцентных отражений, основанных на дифракционной решётке.
#### Подведём итог
С этой части мы начали туториал по иридисценции. В оставшейся части статьи мы исследуем способы симуляции и реализации иридисцентных отражений на различных материалах, от пузырей до CD-ROMs, и от разлитого бензина до насекомых.
Часть 2. Усовершенствуем радугу — 1.
------------------------------------
Наше путешествие в мир фотореализма требует от нас понимания не только того, как работает свет, но и как мы воспринимаем цвета. Сколько цветов есть в радуге? Почему розовый в них не входит? Вот только некоторые из вопросов, которые мы рассмотрим в этой части.
#### Введение
В этой части мы познакомимся в наиболее популярными техниками, используемыми в компьютерной графике для воссоздания цветов радуги. Хотя это может казаться бесполезным занятием, на самом деле оно имеет очень практическое применение. Каждый цвет радуги соответствует определённой длине волны света. Такое соответствие позволит нам симулировать физически достоверные отражения.
В следующей части, «Усовершенствуем радугу — 2», мы введём новый подход, который очень хорошо оптимизирован для шейдеров и при этом создаёт наилучшие на данный момент результаты (см. ниже).
Сравнение WebGL-версий всех рассмотренных в этом туториале техник можно посмотреть в [Shadertoy](https://www.shadertoy.com/view/ls2Bz1).
#### Восприятие цветов
**Сетчатка** — это часть глаза, распознающая свет. В ней есть **клетки-колбочки**, способные передавать сигналы в мозг при распознавании определённых длин волн света. Свет — это волна в электромагнитном поле, поэтому колбочки работают по тем же принципам, которые позволяют нам распознавать радиоволны. *Де-факто* колбочки являются крошечными антеннами. Если вы изучали электронику, то должны знать, что длина антенны связана с улавливаемой ею длиной волны. Именно поэтому в глазе человека есть три разных типа колбочек: короткие, средние и длинные. Каждый тип специализируется в распознавании определённого интервала длин волн.
На графике выше показано, насколько каждый тип колбочек реагирует на разные длины волн. Когда один из этих типов колбочек активируется, мозг интерпретирует его сигнал как цвет. Несмотря на то, что такое часто говорят, короткие, средние и длинные колбочки не соответствуют определённым цветам. Если точнее, каждый тип по-разному реагирует на разные цветовые диапазоны.
Неверно будет считать, что короткие, средние и длинные колбочки распознают синий, зелёный и красный цвета. Несмотря на это, во многих учебниках (и даже в шейдерах!) принимается такое допущение для создания относительно приемлемой аппроксимации этого довольно сложного явления.
#### Спектральный цвет
Если мы хотим воссоздать физические явления, которые делают возможной иридисценцию, то нам нужно переосмыслить способ хранения и обработки цветов в компьютере. Когда мы создаём в Unity (или любом другом игровом движке) источник света, то можем задавать его цвет как смешение трёх основных компонентов: красного, зелёного и синего. Хотя сочетанием красного, зелёного и синего цветов действительно можно создать все видимые цвета, на самом фундаментальном уровне свет работает иначе.
Источник света можно смоделировать как постоянный поток фотонов. Фотоны, несущие разные величины энергии, воспринимаются нашим глазом как разные цвета. Однако «белого фотона» не существует. Это сумма множества фотонов, каждый из которых имеет разную длину волны, что придаёт свету белый цвет.
Чтобы двигаться дальше, нам нужно поговорить о самих «стоительных блоках» света. Когда мы говорим о «длинах волн», то стоит думать о конкретных цветах радуги. В этой части мы покажем различные подходы, реализующие данную связь. В результате мы хотим получить функцию, которая для заданного цвета возвращает воспринимаемый цвет:
```
fixed3 spectralColor (float wavelength);
```
В оставшейся части поста мы будем выражать длины волн в нанометрах (миллиардных частях метра). Глаз человека может воспринимать свет в диапазоне от 400 нм до 700 нм. Длины волн за пределами этого диапазона существуют, но не воспринимаются как цвета.
**Почему оптимального решения не существует?**
На этот вопрос лучше всех ответил [Эрл Ф. Глинн](http://www.efg2.com/Lab/ScienceAndEngineering/Spectra.htm):
> «Не существует уникального соответствия между длиной волны и значениями RGB. Цвет — это удивительное сочетание физики и человеческого восприятия».
Поиск *окончательно верного* соответствия длин волн и цветов неизбежно обречён на провал. Природа света объективна, а наше восприятие — нет. Колбочки, воспринимающие определённые длины волн видимого спектра, имеют значительные вариации у разных людей. Даже если предположить, что все колбочки работают одинаково и постоянно для всех людей, их распределение и количество в сетчатке в основном случайны. Никакие две сетчатки не одинаковы, даже у одного человека.
Наконец, восприятие цвета зависит от того, как эти входные данные воспринимает мозг. Благодаря этому возникают различные оптические иллюзии и нейроадаптации, которые делают восприятие цветов уникальным и истинно личностным опытом.
#### Спектральная карта
На рисунке ниже показано, как глаз человека воспринимает волны длиной от 400 нанометров (синие) до 700 нанометров (красные).
Легко увидеть, что распределение цветов в видимом спектре очень нелинейно. Если мы нанесём на график для каждой длины волны соответствующие компоненты R, G и B воспринимаемого цвета, то в результате получим нечто подобное:
Не существует простой функции, которая может полностью описать эту кривую. Простейшим и наименее затратным подходом реализации будет использование этой текстуры в шейдере как средства привязки длин волн к цветам.
Первое, что нужно сделать — обеспечить шейдеру доступ к новой текстуре. Мы можем сделать это, добавив в блок `Properties` нового шейдера свойство текстуры.
```
// Свойства
Properties
{
...
_SpectralTex("Spectral Map (RGB)",2D) = "white" {}
...
}
// Код шейдера
SubShader
{
...
CGPROGRAM
...
sampler2D _SpectralTex;
...
ENDCG
...
}
```
Наша функция `spectralColor` просто преобразует длины волн в интервале [400,700] в UV-координаты в интервале [0,1]:
```
fixed3 spectral_tex (float wavelength)
{
// длина волны: [400, 700]
// u: [0, 1]
fixed u = (wavelength -400.0) / 300.0;
return tex2D(_SpectralTex, fixed2(u, 0.5));
}
```
В нашем конкретном случае нам не нужно принудительно ограничивать длины волн интервалом [400, 700]. Если спектральная текстура импортируется с **Repeat: Clamp**, все значения за пределами этого интервала будут автоматически иметь чёрный цвет.
**Сэмплирование текстур в цикле**
Ниже мы увидим, что для воспроизведения эффектов иридисценции нам нужно сэмплировать несколько цветов из радуги. В некоторых устройствах шейдер может не поддерживать сэмплирование текстуры в цикле. Это самая важная причина того, что использование текстуры может быть не самым хорошим подходом, особенно на мобильных платформах.
#### Цветовая схема JET
Сэмплирование текстуры может показаться хорошей идеей. Однако оно может значительно замедлить шейдер. Мы увидим, насколько это критично, в части про иридисценцию на CD-ROM, где каждому пикселю потребуются несколько сэмплов текстуры.
Существует несколько функций, аппроксимирующих распределения цветов светового спектра. Вероятно, одной из самых простых является цветовая схема JET. Эта цветовая схема по умолчанию используется в MATLAB, и изначально она была выведена Национальным центром суперкомпьютерных приложений для лучшей визуализации симуляций струй жидкости в астрофизике.
Цветовая схема JET является сочетанием трёх разных кривых: синей, зелёной и красной. Это чётко видно при разбиении цвета:
Мы с лёгкостью можем самостоятельно реализовать цветовую схему JET, написав уравениня линий, составляющих представленную выше схему.
```
// Цветовая схема MATLAB Jet
fixed3 spectral_jet(float w)
{
// w: [400, 700]
// x: [0, 1]
fixed x = saturate((w - 400.0)/300.0);
fixed3 c;
if (x < 0.25)
c = fixed3(0.0, 4.0 * x, 1.0);
else if (x < 0.5)
c = fixed3(0.0, 1.0, 1.0 + 4.0 * (0.25 - x));
else if (x < 0.75)
c = fixed3(4.0 * (x - 0.5), 1.0, 0.0);
else
c = fixed3(1.0, 1.0 + 4.0 * (0.75 - x), 0.0);
// Ограничиваем компоненты цвета интервалом [0,1]
return saturate(c);
}
```
Значения R, G и B получившегося цвета ограничены интервалом [0,1] с помощью функции Cg `saturate`. Если для камеры выбран режим HDR ([High Dynamic Range Rendering](https://docs.unity3d.com/Manual/HDR.html)), это необходимо, чтобы избежать наличия цветов с компонентами больше единицы.
Стоит заметить, что если вы хотите строго придерживаться цветовой схемы JET, то значения за пределами видимого диапазона не будут чёрными.
#### Цветовая схема Брутона
Ещё одним подходом к преобразованию длин волн в видимые цвета является схема, предложенная Дэном Брутоном в статье "[Approximate RGB values for Visible Wavelengths](http://www.physics.sfasu.edu/astro/color/spectra.html)". Аналогично тому, что происходит в цветовой схеме JET, Брутон начинает с аппроксимированного распределения воспринимаемых цветов.
Однако его подход лучше аппроксимирует активность длинных колбочек, что приводит к более сильному оттенку фиолетового в нижней части видимого спектра:
Такой подход преобразуется в следующий код:
```
// Дэн Брутон
fixed3 spectral_bruton (float w)
{
fixed3 c;
if (w >= 380 && w < 440)
c = fixed3
(
-(w - 440.) / (440. - 380.),
0.0,
1.0
);
else if (w >= 440 && w < 490)
c = fixed3
(
0.0,
(w - 440.) / (490. - 440.),
1.0
);
else if (w >= 490 && w < 510)
c = fixed3
( 0.0,
1.0,
-(w - 510.) / (510. - 490.)
);
else if (w >= 510 && w < 580)
c = fixed3
(
(w - 510.) / (580. - 510.),
1.0,
0.0
);
else if (w >= 580 && w < 645)
c = fixed3
(
1.0,
-(w - 645.) / (645. - 580.),
0.0
);
else if (w >= 645 && w <= 780)
c = fixed3
( 1.0,
0.0,
0.0
);
else
c = fixed3
( 0.0,
0.0,
0.0
);
return saturate(c);
}
```
#### Цветовая схема Bump
Цветовые схемы JET и Брутона используют прерывные функции. Поэтому в них создаются довольно резкие цветовые вариации. Более того, за пределами видимого диапазона они не становятся чёрным цветом. В книге «GPU Gems» эта проблема решается заменой резких линий предыдущих цветовых схем на гораздо более плавные *изгибы (bumps)*. Каждый изгиб является обычной параболой вида . А конкретнее
Автор схемы Рандима Фернандо использует для всех компонентов цвета параболы, расположенные следующим образом:
Мы можем написать следующий код:
```
// GPU Gems
inline fixed3 bump3 (fixed3 x)
{
float3 y = 1 - x * x;
y = max(y, 0);
return y;
}
fixed3 spectral_gems (float w)
{
// w: [400, 700]
// x: [0, 1]
fixed x = saturate((w - 400.0)/300.0);
return bump3
( fixed3
(
4 * (x - 0.75), // Red
4 * (x - 0.5), // Green
4 * (x - 0.25) // Blue
)
);
}
```
Дополнительное преимущество этой цветовой схемы заключается в том, что в ней не используются сэмплы текстур и ветвление, что делает её одним из лучших решений, если вы предпочитаете скорость, а не качество. В конце этого туториала я покажу пересмотренную версию этой цветовой схемы, которая обеспечивает бОльшую скорость, при этом сохраняя высокую чёткость цветов.
#### Цветовая схема Spektre
Одной из самых точных цветовых схем является схема, созданная пользователем Stack Overflow [Spektre](https://stackoverflow.com/users/2521214/spektre). Он объясняет свою методологию в посте [RGB values of visible spectrum](https://stackoverflow.com/questions/3407942/rgb-values-of-visible-spectrum), где он сэмплирует синий, зелёный и красный компоненты вещественных данных из солнечного спектра. После чего он заполняет отдельные интервалы простыми функциями. Результат показан на следующей схеме:
Что даёт нам:
А вот как выглядит код:
```
// Spektre
fixed3 spectral_spektre (float l)
{
float r=0.0,g=0.0,b=0.0;
if ((l>=400.0)&&(l<410.0)) { float t=(l-400.0)/(410.0-400.0); r= +(0.33*t)-(0.20*t*t); }
else if ((l>=410.0)&&(l<475.0)) { float t=(l-410.0)/(475.0-410.0); r=0.14 -(0.13*t*t); }
else if ((l>=545.0)&&(l<595.0)) { float t=(l-545.0)/(595.0-545.0); r= +(1.98*t)-( t*t); }
else if ((l>=595.0)&&(l<650.0)) { float t=(l-595.0)/(650.0-595.0); r=0.98+(0.06*t)-(0.40*t*t); }
else if ((l>=650.0)&&(l<700.0)) { float t=(l-650.0)/(700.0-650.0); r=0.65-(0.84*t)+(0.20*t*t); }
if ((l>=415.0)&&(l<475.0)) { float t=(l-415.0)/(475.0-415.0); g= +(0.80*t*t); }
else if ((l>=475.0)&&(l<590.0)) { float t=(l-475.0)/(590.0-475.0); g=0.8 +(0.76*t)-(0.80*t*t); }
else if ((l>=585.0)&&(l<639.0)) { float t=(l-585.0)/(639.0-585.0); g=0.82-(0.80*t) ; }
if ((l>=400.0)&&(l<475.0)) { float t=(l-400.0)/(475.0-400.0); b= +(2.20*t)-(1.50*t*t); }
else if ((l>=475.0)&&(l<560.0)) { float t=(l-475.0)/(560.0-475.0); b=0.7 -( t)+(0.30*t*t); }
return fixed3(r,g,b);
}
```
#### Заключение
В этой части мы рассмотрели некоторые самые распространённые техники для генерирования в шейдере похожих на радугу паттернов. В следующей части я познакомлю вас с новым подходом к решению этой задачи.
| | |
| --- | --- |
| **Название** | **Градиент** |
| JET | |
| Bruton | |
| GPU Gems | |
| Spektre | |
| Zucconi | |
| Zucconi6 | |
| Видимый спектр | |
Часть 3. Усовершенствуем радугу — 2.
------------------------------------
#### Введение
В предыдущей части мы проанализировали четыре различных способа преобразования длин волн видимого диапазона электромагнитного спектра (400-700 нанометров) в соответствующие им цвета.
В трёх из этих решений (JET, Bruton и Spektre) активно используются конструкции *if*. Для C# это стандартная практика, однако в шейдере ветвление является плохим подходом. Единственным подходом, в котором не используется ветвление, является рассмотренный в книге GPU Gems. Однако он не обеспечивает оптимальную аппроксимацию цветов видимого спектра.
| | |
| --- | --- |
| **Название** | **Градиент** |
| GPU Gems | |
| Видимый спектр | |
В этой части я расскажу про оптимизированную версию цветовой схемы, описанной в книге GPU Gems.
#### Цветовая схема «Bump»
Исходная цветовая схема, изложенная в книге GPU Gems, для воссоздания распределения компонентов R, G и B цветов радуги использует три параболы (называемые автором *bumps*).
Каждый bump описывается следующим уравнением:
Каждая длина волны  в диапазоне [400, 700] сопоставляется с нормализованным значением  в интервале [0,1]. Затем компоненты R, G и B видимого спектра задаются следующим образом:
Все численные значения подобраны автором экспериментально. Однако вы видите, насколько плохо они соответствуют истинному распределению цветов.
#### Оптимизация качества
В первом решении, к которому пришёл я, использовались точно такие же уравнения, что и в цветовой схеме GPU Gems. Однако я оптимизировал все численные значения, так что конечный диапазон цветов соответствует, насколько это возможно, настоящим цветам из видимого спектра.
Результат сводится к следующему решению:
И приводит к гораздо более реалистичному результату:
| | |
| --- | --- |
| **Название** | **Градиент** |
| GPU Gems | |
| Zucconi | |
| Видимый спектр | |
Как и исходное решение, новый подход не содержит ветвления. Поэтому он идеально подходит для шейдеров. Код имеет следующий вид:
```
// На основе кода из GPU Gems
// Оптимизовано Аланом Цуккони
inline fixed3 bump3y (fixed3 x, fixed3 yoffset)
{
float3 y = 1 - x * x;
y = saturate(y-yoffset);
return y;
}
fixed3 spectral_zucconi (float w)
{
// w: [400, 700]
// x: [0, 1]
fixed x = saturate((w - 400.0)/ 300.0);
const float3 cs = float3(3.54541723, 2.86670055, 2.29421995);
const float3 xs = float3(0.69548916, 0.49416934, 0.28269708);
const float3 ys = float3(0.02320775, 0.15936245, 0.53520021);
return bump3y ( cs * (x - xs), ys);
}
```
**Расскажите подробнее о своём решении!**
Чтобы найти алгоритм оптимизации, я воспользовался библиотекой Python [scikit](http://scikit-learn.org/stable/).
Вот параметры, необходимые для воссоздания моих результатов:
* Algorithm: L-BFGS-B
* Tolerance: 
* Iterations: 
* Weighted MSE:
+ 
+ 
+ 
* Fitting
+ Image: [Linear Visible Spectrum](https://commons.wikimedia.org/wiki/File:Linear_visible_spectrum.svg)
+ Wavelength range: from  to 
+ Range resized to:  pixels
* Исходное решение:
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
* Конечное решение:
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
#### Усовершенствуем радугу
Если внимательнее присмотреться к распределению цветов в видимом спектре, то мы заметим, что параболы на самом деле не могут повторить кривые цветов R, G и B. Немного лучше будет использовать шесть парабол вместо трёх. Привязав к каждому основному компоненту по два *bump*, мы получим гораздо более правильную аппроксимацию. Разница очень заметна в фиолетовой части спектра.
Разница хорошо заметна в фиолетовой и оранжевой частях спектра:
| | |
| --- | --- |
| **Название** | **Градиент** |
| Zucconi | |
| Zucconi6 | |
| Видимый спектр | |
Вот как выглядит код:
```
// На основе кода из GPU Gems
// Оптимизировано Аланом Цуккони
fixed3 spectral_zucconi6 (float w)
{
// w: [400, 700]
// x: [0, 1]
fixed x = saturate((w - 400.0)/ 300.0);
const float3 c1 = float3(3.54585104, 2.93225262, 2.41593945);
const float3 x1 = float3(0.69549072, 0.49228336, 0.27699880);
const float3 y1 = float3(0.02312639, 0.15225084, 0.52607955);
const float3 c2 = float3(3.90307140, 3.21182957, 3.96587128);
const float3 x2 = float3(0.11748627, 0.86755042, 0.66077860);
const float3 y2 = float3(0.84897130, 0.88445281, 0.73949448);
return
bump3y(c1 * (x - x1), y1) +
bump3y(c2 * (x - x2), y2) ;
}
```
Нет никаких сомнений, что `spectral_zucconi6` обеспечивает более качественную аппроксимацию цветов без использования ветвления. Если для вас важна скорость, то можно использовать упрощённую версию алгоритма — `spectral_zucconi`.
#### Подводим итог
В этой части мы рассмотрели новый подход к генерированию в шейдерах похожих на радугу паттернов.
| | |
| --- | --- |
| **Название** | **Градиент** |
| JET | |
| Bruton | |
| GPU Gems | |
| Spektre | |
| Zucconi | |
| Zucconi6 | |
| Видимый спектр | |
Часть 4. Разбираемся с дифракционной решёткой
---------------------------------------------
В первой части туториала мы познакомились с двойственной природой света, который проявляет свойства волн и частиц. В этой части мы увидим, почему оба эти два аспекта необходимы для возникновения иридисценции.
#### Отражения: свет и зеркала
В научной литературе часто упоминается **луч света** как способ указания пути, проходимого фотонами в пространстве и взаимодействия с объектами. В большинстве **моделей затенения** свет воспринимается как созданный из однородных частиц, ведущих себя как идеальные бильярдные шары. В общем случае, когда луч света сталкивается с поверхностью, он отражается от неё под тем же углом отклонения. Такие поверхности ведут себя как идеальные зеркала, полностью отражая свет.
Объекты, отрендеренные в такой технике, походят на зеркала. Более того, если свет падает с направления **L**, то наблюдатель может увидеть его только тогда, когда смотрит с направления **R**. Такой тип отражения также называется **specular**, что означает «зеркалоподобный».
В реальном мире большинство объектов отражает свет другим способом, называемым **рассеянным (diffuse)**. Когда луч света падает на рассеивающую поверхность, он более-менее равномерно рассеивается во всех направлениях. Это придаёт объектам равномерную рассеянную расцветку.
В большинстве современных движков (наподобие Unity и Unreal) эти два поведения моделируются с помощью разных наборов уравнений. В своём предыдущем туториале [Physically Based Rendering and Lighting Models](https://www.alanzucconi.com/?p=1964) я объяснял модели **отражаемости** **Ламберта** и **Блинна-Фонга**, которые используются соответственно для рассеянных и зеркальных отражений.
Несмотря на то, что они выглядят по-разному, рассеянное отражение можно объяснить через зеркальное. Никакая поверхность не является совершенно плоской. Можно смоделировать грубую поверхность как созданную из крошечных зеркал, каждое из которых полностью характеризуется зеркальной отражаемостью. Наличие таких **микрограней** приводит к рассеянию лучей во всех направлениях.
Разнонаправленность таких микрограней часто моделируется физически точными шейдерами с помощью таких свойств, как **Smoothness (гладкость)** или **Roughness (шероховатость)**. Подробнее об этом можно прочитать на странице справки Unity, объясняющей свойство [Smoothness](https://docs.unity3d.com/Manual/StandardShaderMaterialParameterSmoothness.html) стандартного шейдера движка.
**А что насчёт отражаемости?**
В этом разделе мы сказали, что рассеянное (диффузное) отражение можно полностью объяснить, рассмотрев зеркальное отражение на поверхности, состоящей из разнонаправленных микрограней. Однако это не совсем правда. Если поверхность демонстрирует только зеркальное отражение, то это означает, что при полной полировке она будет выглядеть чёрной. Хорошим контрпримером можно считать белый мрамор: никакая полировка не способна сделать его чёрным. Даже если нам удастся достичь идеально гладкой поверхности, белый мрамор всё равно будет проявлять белый диффузный компонент отражения.
И в самом деле, за этот эффект ответственно кое-что ещё. Диффузный компонент поверхности также возникает из вторичного источника: **преломления**. Свет может проникать сквозь поверхность объекта, отражаться внутри него и выходить под другим углом (см. рисунок выше). Это значит, что какой-то процент всего падающего света будет повторно излучаться поверхностью материала в любой произвольной точке и под любым углом. Такое поведение часто называют **подповерхностным рассеянием (subsurface scattering)** и вычисления для его симуляции часто бывают очень затратны.
Подробнее об этих эффектах (и их симуляции) можно прочитать в статье [Basic Theory of Physically Based Rendering](https://www.marmoset.co/posts/basic-theory-of-physically-based-rendering/) компании Marmoset.
#### Свет как волна
Очень удобно моделировать лучи света так, как будто они состоят из частиц. Однако это не позволит нам воссоздать поведение, которое демонстрирует множество материалов, в том числе и иридисценцию. Некоторые явления можно полностью понять только в том случае, если принять тот факт, что свет в определённых условиях ведёт себя как волна.
Большинство шейдеров работает со светом как с частицами. Результатом этого огромного упрощения становится то, что подвергается **аддитивной композиции**. Если два луча достигают наблюдателя, то их яркость просто складывается. Чем больше лучей испускает поверхность, тем она ярче.
В реальном мире это не так. Если два луча света достигают наблюдателя, то конечный цвет зависит от того, как их волны взаимодействуют друг с другом. В представленной ниже анимации показано, как две простые синусоидальные волны могут **усиливать** или **гасить** друг друга в зависимости от их **фазы**.
**Анимация**
Когда две волны **совпадают по фазе**, то их пики и впадины идеально совпадают: в этом случае конечная волна усиливается. В противоположном случае они могут в буквальном смысле уничтожить друг друга. Это значит, что если два луча света падают на наблюдателя в правильной конфигурации, то он не получит никакого света.
Взаимодействие волн может казаться странным принципом. Однако все мы испытывали его в повседневной жизни. Популяризатор науки Дерек Мюллер хорошо объясняет это в своём видео [The Original Double Slit Experiment](https://www.youtube.com/watch?v=Iuv6hY6zsd0), где он демонстрирует **усиливающую** и **гасящую интерференцию** волн воды.
Но как это связано со светом и иридисценцией? Причиной иридисценции является взаимодействие волн света разной длины. Некоторые материалы могут отражать фотоны только в нужном направлении, усиливая определённые цвета и уничтожая другие. В результате такого взаимодействия мы можем наблюдать радугу.
#### Дифракция
В первом разделе этой части мы изучили один из видов взаимодействия света и материи: отражение. Отражение возникает, когда свет моделируется как частица. Однако если обращаться с ним как с волной, то возникает новое множество поведений. Одно из них называется **дифракцией**. Если весь падающий свет достигает поверхности под одним углом, то это называется **плоской волной**. Например, *направленные источники освещения* в Unity создают плоские волны. Когда плоская волна проходит через щель, она преломляется, как показано в следующей анимации:
**Анимация**
Если свет проходит через две разные щели, то генерируются два новых фронта волн. И как мы говорили выше, эти новые световые волны могут взаимодействовать друг с другом. В анимации ниже показано, как ведёт себя свет при наличии двух таких щелей. Можно увидеть, что они на самом деле взаимодействуют, как усиливая, так и гася лучи.
**Анимация**
Теперь у нас все необходимые основы, чтобы обсудить причины возникновения иридисценции.
##### Дифракционная решётка
Когда плоская волна проходит через щель или отражается в неровность, она преломляется, создавая новый сферический фронт волны. Это значит, что свет рассеивается во всех направлениях, аналогично тому, как это происходит при рассеянном отражении. Если поверхность материала неравномерна, то получившиеся плоские волны рассеиваются случайным обраом и на микроскопическом уровне не возникает паттерна интерференции.
Однако некоторые материалы обладают паттернами поверхностей, повторяющимися в масштабах, сравнимых с длиной волны падающего света. Когда такое происходит, повторяемость паттерна приводит к повторяющемуся и неслучайному взаимодействию фронтов дифрагированных волн. Получившееся взаимодействие создаёт повторяющийся паттерн интерференции, который можно увидеть на макроскопическом уровне.
Вышеупомянутый эффект называется **дифракционной решёткой**. Некоторые длины волн значительно усиливаются, другие же уничтожаются. Поскольку разные длины волн соответствуют разным цветам, дифракционная решётка приводит к тому, что отражения некоторых цветов становятся более явными.
Этот механизм обеспечивает возникновение иридисценции на поверхностях с повторяющимся паттерном. Они часто встречаются в природе: внешние скелеты насекомых и перья птиц содержат микроскопические чешуйки, выровненные в повторяющиеся паттерны. На представленном ниже рисунке вы видите увеличенное изображение павлиньего пера.
#### Подводим итог
В следующей части туториала я покажу, как можно математически смоделировать конкретный вид иридисценции. После вывода уравнений их легко реализовать в шейдере.
Часть 5. Математика дифракционной решётки.
------------------------------------------
#### Введение
В предыдущей части мы объяснили, почему в некоторых материалах возникает иридисценция. Теперь у нас есть всё необходимое, чтобы начать моделировать это явление математически. Давайте начнём с того, что представим материал, в котором есть неоднородности, повторяющиеся через известные расстояния . В целях вывода уравнений обозначим угол между падающими лучами света и нормалью поверхности как . Давайте также представим, что наблюдатель расположен таким образом, что он получает все отражённые лучи с углом . Каждая неоднородность рассеивает свет во всех направлениях, поэтому всегда будут присутсвовать лучи света, падающие на наблюдателя, вне зависимости от .
Поскольку неоднородности повторяются регулярно с шагом  нанометров, то сам паттерн рассеяния повторяется каждые  нанометров. Значит, что существует *хотя бы один* луч света, приходящий к наблюдателю от каждой щели.
#### Вывод уравнений
Два луча света, изображённые на схеме выше, прежде чем достигнуть наблюдателя, проходят разное расстояние. Если они начинают двигаться, совпадая по фазе, то достигнув наблюдателя, могут и не совпадать Чтобы понять, как эти два луча взаимодействуют (усиливая или гася друг друга), нам нужно вычислить, насколько не совпадают они по фазе, когда достигают наблюдателя.
Эти два луча точно будут совпадать по фазе, пока первый не упадёт на поверхность. Второй луч проходит дополнительное расстояние  (выделено зелёным), после чего тоже падает на поверхность. Воспользовавшись простой тригонометрией, можно показать, что длина зелёного отрезка  равна .
С помощью похожей конструкции мы можем вычислить дополнительное расстояние , которое проходит первый луч, пока второй не столкнётся с поверхностью. В этом случае мы видим, что .
Эти два отрезка  критически важны для определения того, совпадают ли два луча по фазе, когда их принимает наблюдатель. Их разность измеряет разность длин этих двух лучей. Если она равна нулю, то мы точно знаем, что два луча совпадают по фазе, потому что они в сущности прошли одинаковое расстояние.
Однако два луча могут совпадать по фазе не только в этом случае. Если разность длин равна целому числу, кратному длине волны , то они по-прежнему будут совпадать по фазе. С математической точки зрения, два луча совпадают по фазе, если они удовлетворяют следующему условию:
#### Визуализация
Давайте уделим минуту, чтобы разобраться в значении этого уравнения. Если свет падает под углом , то что увидит наблюдатель, смотрящий на материал под углом ? Все длины волн , являющиеся целыми кратными , будут взаимодействовать с усилением, и сильно проявятся в конечном отражении. Поэтому именно эти цвета увидит зритель.
Этот эффект визуализируется следующей схемой, взятой из очень интересного обсуждения [A complex approach: Iridescence in cycles](https://blenderartists.org/forum/showthread.php?340095-A-complex-approach-Iridescence-in-cycles/page2):
Белый луч следует по пути, пройденному фотонами для зеркального отражения. Наблюдатель, смотрящий на материал под разными углами, увидит циклический радужный паттерн. Каждый цвет соответствует своей длине волны, а порядок определяет соответствующее целое . Как вы видите, уравнение дифракционной решётки удовлетворяется даже при отрицательных значениях , потому что величина  может быть отрицательной. С вычислительной точки зрения имеет смысл упростить пространство поиска, ограничившись только положительными значениями . Новое уравнение, которое мы будем использовать, имеет вид:
Часть 6. Шейдер CD-ROM: дифракционная решётка — 1
-------------------------------------------------
В этой части мы рассмотрим создание шейдера, воссоздающего радужные отражения, видимые на поверхности дисков CD-ROM или DVD.
#### Введение
В предыдущей части мы вывели уравнения, описывающие саму природу иридисцентных отражений, демонстрируемых некоторыми поверхностями. Иридисценция возникает в материалах, на поверхностях которых присутствует повторяющийся паттерн, размер которого сравним с длиной волны отражаемого им света.
Оптические эффекты, которые мы хотим воссоздать, в конечном итоге зависят от трёх факторов: угла между источником света и нормалью поверхности (**направление света**), углом обзора наблюдателя (**направление обзора**) и расстояния между повторяющимися зазорами.
Мы хотим, чтобы шейдер добавлял иридисцентные отражения поверх обычных эффектов, которые обычно создаёт стандартный материал. Поэтому мы расширим **функцию освещения** **стандартного поверхностного шейдера (Standard Surface shader)**. Если вы не знакомы с этой процедурой, то стоит изучить мой туториал [Physically Based Rendering and Lighting Models](https://www.alanzucconi.com/?p=1964).
#### Создание поверхностного шейдера
Первым шагом будет создание нового шейдера. Так как мы хотим расширить возможности шейдера, уже поддерживающего физически точное освещение, то начнём с **Standard Surface Shader**.
Создаваемому шейдеру CD-ROM потребуется новое свойство: расстояние , используемое в уравнении дифракционной решётки. Давайте добавим его в блок `Properties`, который должен выглядеть следующим образом:
```
Properties
{
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_Glossiness ("Smoothness", Range(0,1)) = 0.5
_Metallic ("Metallic", Range(0,1)) = 0.0
_Distance ("Grating distance", Range(0,10000)) = 1600 // nm
}
```
Так мы создадим новый ползунок в Material Inspector. Однако свойство `_Distance` по-прежнему нужно связать с переменной в разделе `CGPROGRAM`:
```
float _Distance;
```
Теперь мы готовы к работе.
#### Изменение функции освещения
Первое, что нам нужно сделать — заменить функцию освещения шейдера CD-ROM на собственную. Мы можем сделать это, изменив директиву `#pragma` здесь:
```
#pragma surface surf Standard fullforwardshadows
```
на:
```
#pragma surface surf Diffraction fullforwardshadows
```
Это заставит Unity делегировать вычисление освещения функции под названием `LightingDiffraction`. Важно понимать, что мы хотим *расширить* функционал этого поверхностного шейдера, а не *переопределить его*. Поэтому наша новая функция освещения будет начинаться с вызова стандартной функции PBR-освещения Unity:
```
#include "UnityPBSLighting.cginc"
inline fixed4 LightingDiffraction(SurfaceOutputStandard s, fixed3 viewDir, UnityGI gi)
{
// Исходный цвет
fixed4 pbr = LightingStandard(s, viewDir, gi);
// <здесь будет код дифракционной решётки>
return pbr;
}
```
Как видно из представленного выше фрагмента кода, новая функция `LightingDiffraction` просто вызывает `LightingStandard` и возвращает её значение. Если мы скомпилируем шейдер сейчас, то не увидим никакой разницы в способе рендеринга материалов.
Однако прежде чем двигаться дальше, нам нужно создать дополнительную функцию для обработки **глобального освещения (Global Illumination)**. Поскольку нам не нужно менять это поведение, наша новая функция глобального освещения будет просто прокси-функцией стандартной PBR-функции Unity:
```
void LightingDiffraction_GI(SurfaceOutputStandard s, UnityGIInput data, inout UnityGI gi)
{
LightingStandard_GI(s, data, gi);
}
```
Стоит также заметить, что поскольку мы используем непосредственно `LightingStandard` и `LightingDiffraction_GI`, то нужно включить в наш шейдер `UnityPBSLighting.cginc`.
#### Реализация дифракционной решётки
Это будет фундаментом нашего шейдера. Мы наконец готовы к реализации уравнений дифракционной решётки, выведенных в предыдущей части. В ней мы пришли к выводу, что наблюдатель видит иридисцентное отражение, которое является суммой всех длин волн , удовлетворяющих **уравнению решётки**:
где  — целое число больше .
Для каждого пикселя значения  (определяемого *направлением света*),  (определяемого *направлением обзора*) и  (*расстояние между зазорами*) известны. Неизвестными переменными являются  и . Проще всего будет перебрать в цикле значения , чтобы увидеть, какие длины волн удовлетворяют уравнению решётки.
Когда мы будем знать, какие длины волн вносят вклад в конечное иридисцентное отражение, то мы вычислим соответствующие им цвета и сложим их. В части «Усовершенствуем радугу» мы рассмотрели несколько способов преобразования длин волн видимого спектра в цвета. В этом туториале мы воспользуемся `spectral_zucconi6`, потому что он обеспечивает наилучшую аппроксимацию с наименьшими вычислительными затратами.
Давайте рассмотрим следующую возможную реализацию:
```
inline fixed4 LightingDiffraction(SurfaceOutputStandard s, fixed3 viewDir, UnityGI gi)
{
// Исходный цвет
fixed4 pbr = LightingStandard(s, viewDir, gi);
// Вычисляет цвет отражения
fixed3 color = 0;
for (int n = 1; n <= 8; n++)
{
float wavelength = abs(sin_thetaL - sin_thetaV) * d / n;
color += spectral_zucconi6(wavelength);
}
color = saturate(color);
// Прибавляет цвет отражения к цвету материала
pbr.rgb += color;
return pbr;
}
```
В этом фрагменте кода мы используем значения  до 8. Для более качественных результатов можно взять бОльшие значения, однако и этого уже достаточно, чтобы учесть значительную часть иридисцентного отражения.
Нам осталось последнее — вычислить `sin_thetaL` и `sin_thetaV`. Для этого понадобится ввести ещё одну концепцию: **касательного вектора**. В следующей части мы узнаем, как его вычислить.
Часть 7. Шейдер CD-ROM: дифракционная решётка — 2
-------------------------------------------------
#### Введение
В предыдущей части туториала мы создали первую аппроксимацию иридисцентных отражений, проявляющихся на поверхности CD-ROM. Важно помнить, что этот шейдер физически корректен. Для правильной симуляции нужного нам отражения мы должны сделать так, чтобы все дорожки CD-ROM были расположены по кругу. Так мы создадим радиальное отражение.
#### Ориентация щелей
Выведенное нами уравнение решётки имеет большое ограничение: оно предполагает, что все щели расположены в одном направлении. Это часто справедливо для наружных скелетов насекомых, но дорожки на поверхности CD-ROM расположены по кругу. Если мы реализуем решение буквально, то получим довольно неубедительное отражение (правая часть изображения).
Чтобы решить эту проблему, нам нужно учесть локальную ориентацию щелей на CD-ROM. Использование вектора нормали не поможет, потому что все щели имеют одинаковое направление нормалей, перпендикулярное поверхности диска. Локальную ориентацию щели можно определить с помощью вектора касательной (левая часть верхнего изображения).
На представленной выше схеме направление нормали  показано синим, а направление касательной  — красным. Углы источника света и наблюдателя, образуемые с направлением нормали , называются  и . Аналогичные углы относительно  — это  и . Как сказано выше, при использовании в вычислениях  и  мы получим «плоское» отражение, потому что все щели имеют одинаковую . Нам нужно найти способ, как использовать  и , потому что они правильно соответствуют локальным направлениям.
Пока нам известно, что:
Поскольку  и  перпендикулярны, то они обладают следующим свойством:
Это очень удобно ещё и потому, что Cg обеспечивает нативную реализацию скалярного произведения. Нам осталось только вычислить .
**Откуда взялся косинус?**
Все рассматриваемые здесь векторы имеют общее свойство: их длина равна 1. По этой причине их также называют **единичными векторами**. Простейшая операция, применимая к единичным векторам — это **скалярное произведение**.
Грубо говоря, скалярное произведение двух единичных векторов является мерой из сонаправленности. На самом деле оказывается, что скалярное произведение двух единичных векторов является косинусом угла между ними. Поэтому в уравнениях появляется косинус.
#### Вычисление вектора касательной
Чтобы доделать наш шейдер, мы должны вычислить вектор касательной . Обычно он указывается непосредственно в вершинах мешей. Однако с учётом того, насколько проста поверхность CD-ROM, мы можем вычислить его самостоятельно. Стоит учесть, что показанный в этом туториале подход довольно прост и будет работать только в том случае, если поверхность меша CD-ROM имеет правильную UV-развёртку.
На схеме выше показано, как вычисляются направления касательных. При этом предполагается, что поверхность диска UV-развёрнута как четырёхугольник с координатами в интервале от (0,0) до (1,1). Зная это, мы переназначаем координаты каждой точки поверхности CD-ROM в интервале от (-1,-1) до (+1,+1). Взяв за основу этот принцип, мы получаем, что новая координата точки также соответствует направлению наружу из центра (зелёная стрелка). Мы можем повернуть это направление на 90 градусов, чтобы найти вектор, являющийся касательным к концентрическим дорожкам CD-ROM (показан красным).
Эти операции необходимо выполнять в функции `surf` шейдера, потому что UV-координаты недоступны в функции освещения `LightingDiffraction`.
```
// IN.uv_MainTex: [ 0, +1]
// uv: [-1, +1]
fixed2 uv = IN.uv_MainTex * 2 -1;
fixed2 uv_orthogonal = normalize(uv);
fixed3 uv_tangent = fixed3(-uv_orthogonal.y, 0, uv_orthogonal.x);
```
Нам осталось только преобразовать вычисленную касательную из **пространства объекта** в **мировое пространство**. При преобразовании учитываются положение, поворот и масштаб объекта.
```
worldTangent = normalize( mul(unity_ObjectToWorld, float4(uv_tangent, 0)) );
```
**Как передать направление касательной в функцию освещения?**
Иридисцентное отражение вычисляется в функции освещения `LightingDiffraction`. Однако ей требуется вектор касательной worldTangent, который вычисляется в поверхностной функции `surf`. Сигнатуру функции освещения нельзя изменить, то есть её нельзя заставить получать больше параметров, чем она уже имеет.
Если вы незнакомы с шейдерами, то я подскажу: существует очень простой способ передачи дополнительных параметров. Нужно просто добавить их как переменные в тело шейдера. В нашем случае мы можем использовать общую переменную `worldTangent`, которая инициализирована функцией `surf` и используется функцией `LightingDiffraction`.
**Как переключаться между пространствами координат?**
Координаты не абсолютны. Они всегда зависят от точки отсчёта. В зависимости от нужных операций бывает более удобно хранить векторы в одном или другом пространстве координат.
В контексте шейдеров можно менять пространства координат точки, просто умножая их на особую матрицу. Матрица, позволяющая преобразовывать координаты, выраженные в пространстве объектов, в мировое пространство, называется `unity_ObjectToWorld`. Если вы пользуетесь старой версией Unity, то эта константа будет называться `_Object2World`.
#### Соединяем всё вместе
Теперь у нас есть всё необходимое для вычисления влияния цвета на иридисцентное отражение:
```
inline fixed4 LightingDiffraction(SurfaceOutputStandard s, fixed3 viewDir, UnityGI gi)
{
// Исходный цвет
fixed4 pbr = LightingStandard(s, viewDir, gi);
// --- Эффект дифракционной решётки ---
float3 L = gi.light.dir;
float3 V = viewDir;
float3 T = worldTangent;
float d = _Distance;
float cos_ThetaL = dot(L, T);
float cos_ThetaV = dot(V, T);
float u = abs(cos_ThetaL - cos_ThetaV);
if (u == 0)
return pbr;
// Цвет отражения
fixed3 color = 0;
for (int n = 1; n <= 8; n++)
{
float wavelength = u * d / n;
color += spectral_zucconi6(wavelength);
}
color = saturate(color);
// Прибавляет отражение к цвету материала
pbr.rgb += color;
return pbr;
}
```
**Как это связано с радугой?**
Переменная `wavelength`, объявленная в цикле for, содержит длины волн света, влияющие на иридисцентное отражение текущего пикселя.
Каждая длина волны в видимом диапазоне (от 400 до 700 нанометров) воспринимается человеческим мозгом как отдельный цвет. В частности, длина волны в видимом диапазоне соответствует цветам радуги.
Части «Усовершенствуем радугу» мы показали, что любую длину волны можно преобразовать в соответствующие цвета. Функция, используемая для такого проецирования, называется `spectral_zucconi6`. Она является оптимизированной версией решения, представленного в учебнике по шейдерам [GPU Gems](https://developer.nvidia.com/sites/all/modules/custom/gpugems/books/GPUGems/gpugems_ch08.html).
 | https://habr.com/ru/post/346852/ | null | ru | null |
# Автоматическое управление номером версии c помощью Azure DevOps
В этой статье я расскажу, как мы организовали последовательное автоматическое увеличение номера версии приложения при выполнении коммита в ветку main с помощью Azure DevOps Pipeline.
Мы делаем этого для того, чтобы все пользователи и разработчики могли видеть, какая именно версия продукта развернута в той или иной среде.
Задача
------
В зависимости от архитектуры приложения номер версии может храниться в разных местах. Здесь я приведу пример приложения .NET Core, где номер версии находится в теге AssemblyVersion XML-файла проекта с расширением .csproj. По умолчанию этого тега в проекте нет, инициировать его добавление можно, установив в свойствах проекта его значение, например, 1.0.0.1.
В «классических» приложениях .NET Framework номер версии хранится в файле Properties\AssemblyInfo.cs. Этот уже не XML-файл. Способ поиска и редактирования нужного тега будет несколько отличаться.
При работе с git-репозиторием мы используем trunk-подход, описанный здесь: trunkbaseddevelopment.com. В рамках этого подхода, в отличие от GitFlow, разработчики создают ветки с коротким жизненным циклом от основной ветки main. Эту методологию, в частности, продвигает и Microsoft, мы используем слегка упрощенный подход по сравнению с их Release Flow, описанным [в этой статье](https://docs.microsoft.com/en-us/azure/devops/learn/devops-at-microsoft/release-flow).
В нашем случае в ветку main код попадает в результате пул-реквестов, но без контрольной автоматической сборки. Поэтому мы запускаем CI-сборку сразу после коммита в мастер. Нам требуется, чтобы, в случае успешного завершения этой сборки, увеличивалась бы последняя цифра в номере версии приложения в AssemblyVersion. Например, было 1.3.4.15, стало 1.3.4.16.
Решение
-------
Сценарий пайплайна в общих чертах выглядит так:
1. Получить содержимое ветки main.
2. Обновить номер версии с помощью PowerShell-скрипта. Для этого на агенте необходимо создать новую ветку. Мы будем делать все изменения в этой ветке, использовать ее для сборки и потом будет объединять ее с веткой main. Эта ветка останется локальной, она не будет отправляться в серверный репозиторий. В конце процесса мы ее удалим.
3. Выполнить сборку.
4. Если сборка прошла успешно, обновить номер версии в репозитории также с помощью PowerShell-скрипта.
Стоит упомянуть несколько важных моментов.
* С момента получения содержимого ветки main и до окончания сборки в ветку main могут попасть новые коммиты. По этой причине Azure-агент получает не содержимое ветки, а конкретный коммит. После получения кода репозиторий становится со "сдвинутой головой" (HEAD detached). Именно поэтому и надо обновлять номер версии в отдельной ветке.
* Azure-агент, который будет обновлять репозиторий, должен в нем дополнительно авторизоваться. Для этого понадобится на уровне пайплайна сохранить персональный ключ доступа (PAT) одного из авторизованных пользователей. Это значение является секретным и должно соответствующим образом сохраняться. Оно будет использоваться при отправке коммита через HTTPS.
* Чтобы не "возбуждать" CI-сборку при попадании нового номера версии в main, при выполнении коммита необходимо в комментарии указать [skip ci].
Реализация
----------
Мы создаем CI-сборку, которая должна запускаться автоматически после того, как код попадает в ветку main. Поэтому скрипт пайплайна начинается с фразы:
```
trigger:
- main
```
Далее следует стандартный блок выбора агента, установки базовых переменных и обновления nuget-пакетов:
```
Pool:
vmImage: 'windows-latest'
variables:
solution: '**/*.sln'
buildPlatform: 'Any CPU'
buildConfiguration: 'Release'
steps:
- task: NuGetToolInstaller@1
- task: NuGetCommand@2
inputs:
restoreSolution: '$(solution)'
```
Теперь, когда агент получил из репозитория свежее содержимое ветки main, выполняем PoweShell-скрипт.
```
- task: PowerShell@2
displayName: 'Assembly Version Generation'
# первая часть – увеличение номера версии
# если сборка падает, новый номер версии не сохраняется в репозитории
inputs:
targetType: 'inline'
script: |
```
Детали этого скрипта могут отличаться, например, если обновить номер версии надо сразу для нескольких проектов или используется другой принцип хранения номера версии.
Опция --quiet при вызове git указывается, чтобы пайплайн не воспринимал служебные сообщения от git как сообщения об ошибках и не останавливал процесс.
```
# имя XML-файла проекта, в который будут вноситься изменения
$ProjectFile = '.\azure-devops-versioning\azure-devops-versioning.csproj'
# создаем новую ветку
git branch DevOps/test_$(Build.BuildNumber) –quiet
# переключаемся в новую ветку
git checkout DevOps/test_$(Build.BuildNumber) –quiet
# ищем строку, содержащую тег
foreach($line in Get-Content -Path $ProjectFile)
{$AssemblyVersionLine = $line | Select-String -Pattern '' -CaseSensitive
if ($AssemblyVersionLine) {break}
}
# ищем номер версии в строке через операцию -match
$AssemblyVersionLine -match ('()(.+)()$')
# получаем строку версии
$Version = $Matches[2]
# разбиваем строку на массив
$VerParts = $Version.split('.')
# получаем последнюю часть массива и увеличиваем на 1
$VerParts[3] = ([int]$VerParts[3] + 1)
# собираем обратно в строку через точку
$NewVersion = $VerParts -join '.'
# получаем новую строку с тегом и новым номером версии
$NewAssemblyVersionLine = $AssemblyVersionLine -replace $Version, $NewVersion
# заменяем старую строку с тегом на новую
(Get-Content $ProjectFile) | Foreach-Object { $\_ -replace $AssemblyVersionLine, $NewAssemblyVersionLine } | Set-Content $ProjectFile
# вводим информацию о пользователе-агенте
git config user.email "azure.agent@profinfotech.ru"
git config user.name "Azure Agent"
# индексируем измененный файл
git add $ProjectFile
# фиксируем изменения в локальном репозитории с комментарием
git commit -m "[skip ci] Pipeline Modification: AssemblyVersion = $NewVersion"
```
В этом скрипте мы создали новую локальную ветку с использованием номера билда, который в Azure DevOps является уникальным. То есть, при каждой CI-сборке на агенте будет создаваться новая локальная ветка. Мы переключились на эту новую ветку, нашли нужный файл и заменили в нем AssemblyVersion, увеличив последний номер на 1. Мы сделали коммит в локальный репозиторий и запускаем сборку с помощью стандартного блока:
```
- task: VSBuild@1
inputs:
solution: '$(solution)'
msbuildArgs: '/p:DeployOnBuild=true /p:WebPublishMethod=Package /p:PackageAsSingleFile=true /p:SkipInvalidConfigurations=true /p:DesktopBuildPackageLocation="$(build.artifactStagingDirectory)\WebApp.zip" /p:DeployIisAppPath="Default Web Site"'
platform: '$(buildPlatform)'
configuration: '$(buildConfiguration)'
```
Если сборка завершилась с ошибкой, на этом процесс закончится. На агенте останется локальная ветка с номером билда, которую можно удалить, но для нас это не критично, поэтому мы не будем здесь на этом останавливаться.
Если же сборка завершилась успешно, мы запускаем PowerShell-скрипт.
```
- task: PowerShell@2
displayName: 'Send new version to main'
# вторая часть – после успешной сборки новая версия отправляется в серверный репозиторий
inputs:
targetType: 'inline'
script: |
```
Этот скрипт переключит нас в main, получит обновление main, объединит нашу ветку с веткой main, удалит нашу ветку и сделает push в центральный репозиторий, авторизовавшись с помощью PAT-токена:
```
# переключаемся на ветку main
git checkout main –quiet
# обновляем локальную ветку main
git pull –quiet
# объединяем нашу ветку с веткой main, в комментарии указываем номер версии
git merge DevOps/test_$(Build.BuildNumber) -m "[skip ci] Pipeline Modification: AssemblyVersion = $NewVersion" –quiet
# удаляем локальную ветку
git branch -d DevOps/test_$(Build.BuildNumber)
# отправляем локальную ветку main в серверный репозиторий
# PAToken – это переменная пайплайна, содержащая значение персонального ключа
git push https://kanailov:$(PAToken)@github.com/Kanailov/azure-devops-versioning.git main –quiet
```
В приведенном примере git-репозиторий находится в GitHub. В том случае, если используется git-репозиторий, встроенный в Azure DevOps, формат HTTPS-запроса немного отличается:
```
git push https://Personal%20Access%20Token:$(PAToken)@ main --quiet
```
Ссылка
------
[Пример проекта выложен на Github](https://github.com/Kanailov/azure-devops-versioning). В репозитории находится yml-скрипт azure-pipelines.yml. | https://habr.com/ru/post/576464/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.