text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# «Как по нотам!» или Машинное обучение (Data science) на C# с помощью Accord.NET Framework
Вчера после публикации статьи [zarytskiy](https://habrahabr.ru/users/zarytskiy/) «[Какой язык программирования выбрать для работы с данными?](https://habrahabr.ru/post/337330/)» я понял, что .net в целом и C# в частности не рассматривается, как инструмент для машинного обучения и анализа данных. Не то, чтобы для этого совсем не было объективных причин, но все же надо восстановить справедливость и потратить пару минут на рассказ о фреймворке **Accord.NET.**
Итак, в [прошлой статье](https://habrahabr.ru/post/337040/) цикла, посвящённого обучению Data Science с нуля, мы с вами разбирали вопрос создания своего собственного набора данных и обучение моделей из библиотеки scikit-learn (Python) на примере задачи классификации спектров излучения ламп и дневного света.
В этот раз, чтобы набор данных не пропадал мы рассмотрим и сопоставим нашей прошлой статье маленький кусочек задачи машинного обучения, но в этот раз реализованный на C#
Милости прошу всех под кат.
Для начала надо отметить, что машинное обучение, Python и C# я знаю одинаково плохо, ну то есть почти никак, поэтому данная статья вряд ли подарит читателю, какой-то виртуозный код или особо ценную информацию. В прочем мы такую цель и не ставим, ведь правда?
Фрагменты кода и данные, как и прежде можно взять на [GitHub](https://github.com/bosonbeard/ML_light_sources_classification/tree/master/1st_spectrum_classification)
### Часть 1. Прелюдия
Вкратце напомню о чем шла речь в [прошлой статье](https://habrahabr.ru/post/337040/):
С помощью открытого проекта [Spectralworkbench](https://spectralworkbench.org/) (Public Lab), я собрал для вас небольшую коллекцию спектров дневного света, люминесцентных ламп и светодиодных ламп предположительно различных оттенков белого света и с различным качеством цветопередачи. В наборе содержалось по 30 обучающих образцов каждого класса и по 11 контрольных соответственно.
Дальше после долгих моих разглагольствований мы наконец приступили к непосредственно машинному обучению и в итоге обучили: классификаторы RandomForestClassifier и LogisticRegression, в том числе с подбором параметров, также побаловались с отображением признаков в двухмерном виде с помощью T-SNE и PCA, под конец попробовали сделать кластеризацию данных с помощью DBSCAN, ну а завершила статью моя эпичная битва с компьютером, которую я к сожалению проиграл с результатом в пару % точности предсказания.
### Часть 2. Ария
Итак, беглый поиск в Интернете говорит, о том, что [Accord.NET](http://accord-framework.net/) один из самых популярных в экосистеме .Net, видимо по тому, что в первую очередь заточен под C#, хотя есть и другие, например, [Angara](https://github.com/predictionmachines/Angara) (заточена под F#). Безусловно платформа позволяет запускать фреймворки на всех языках .Net (ну или точно подавляющем большинстве языков).
Первое, что бросается в глаза, это все же на порядок меньшая популярность фреймворка по сравнению с решениями на Python или R, как следствие полагаться придется на примеры и документацию, документация, для новичка могла бы быть и побольше разжёвана, а примеры в основном встречаются в виде уже собранных проектов, которые хорошо бы открывать в Visual Studio. После целого моря информации по машинному обучению c Питоном, это немного отталкивает, видимо именно поэтому в данном случае я ограничился только классификацией (SVM) и отображением признаков с помощью PCA.
Итак, нам понадобится MS Visual Studio (у меня была 2015) или MonoDevelop (например, для Linux).
В принципе можно воспользоваться инструкцией для [быстрого старта](https://github.com/accord-net/framework/wiki/Getting-started), а можно поверить мне на слово. Пример буду приводить для Visual Studio:
1. Создаём новое консольное приложение.
2. Добавляем ссылку на сборку System.Windows.Forms.dll, она нам пригодится для отображения графиков.
3. Добавляем пакеты NuGet: Accord, Accord.Controls, Accord.IO, Accord.MachineLearning, Accord.Statistics (часть из них итак добавиться сама, когда один потянет другие)
4. Начинаем «кодить»
Открываем Program.cs и добавляем пространства имен:
```
using System;
using System.Linq;
using Accord.Statistics.Models.Regression.Linear;
using Accord.Statistics.Analysis;
using Accord.IO;
using Accord.Math;
using System.Data;
using Accord.MachineLearning.VectorMachines.Learning;
using Accord.Math.Optimization.Losses;
using Accord.Statistics.Kernels;
using Accord.Controls;
```
Дальше для простоты все запихнем в базовый класс
```
class Program
{
static void Main(string[] args)
{
```
Итак:
Читаем данные, к сожалению удобной библиотеки, Pandas у нас нет, но есть аналоги (хоть и менее удобные на мой взгляд).
Один из минусов, это опять-таки не очевидность, я собрал пару «велосипедов» прежде чем понял, что Accord предлагает свое решение для обработки csv или xsls при желании.
```
//This is a program for demonstrating machine
//learning and classifying the spectrum of light sources using .net
//read data (If you use linux do not forget to correct the path to the files)
string trainCsvFilePath = @"data\train.csv";
string testCsvFilePath = @"data\test.csv";
DataTable trainTable = new CsvReader(trainCsvFilePath, true).ToTable();
DataTable testTable = new CsvReader(testCsvFilePath, true).ToTable();
// Convert the DataTable to input and output vectors (train and test)
int[] trainOutputs = trainTable.Columns["label"].ToArray();
trainTable.Columns.Remove("label");
double[][] trainInputs = trainTable.ToJagged();
int[] testOutputs = testTable.Columns["label"].ToArray();
testTable.Columns.Remove("label");
double[][] testInputs = testTable.ToJagged();
```
Собственно, обучаем модель классификатора, если вам уже впиталась в душу терминология scikit-learn, то по началу будет не привычно. Но в принципе все должно быть понятно в teacher запихиваем класс модели, потом обучаем ее на данных, потом вызываем предсказание меток (напомню: 0 – светодиод, 1 – лампа, — 2 дневной свет)
```
// training model SVM classifier
var teacher = new MulticlassSupportVectorLearning()
{
// Configure the learning algorithm to use SMO to train the
// underlying SVMs in each of the binary class subproblems.
Learner = (param) => new SequentialMinimalOptimization()
{
// Estimate a suitable guess for the Gaussian kernel's parameters.
// This estimate can serve as a starting point for a grid search.
UseKernelEstimation = true
}
};
// Learn a machine
var machine = teacher.Learn(trainInputs, trainOutputs);
// Obtain class predictions for each sample
int[] predicted = machine.Decide(testInputs);
```
Дальше распечатаем данные (результат будет, чуть позже на картинке)
```
// print result
int i = 0;
Console.WriteLine("results - (predict ,real labels)");
foreach (int pred in predicted)
{
Console.Write("({0},{1} )", pred, testOutputs[i]);
i++;
}
//calculate the accuracy
double error = new ZeroOneLoss(testOutputs).Loss(predicted);
Console.WriteLine("\n accuracy: {0}", 1 - error);
```
Ну и финальный аккорд — трансформируем данные с помощью PCA и выведем диаграмму рассеяния
```
// consider the decrease in the dimension of features using PCA
var pca = new PrincipalComponentAnalysis()
{
Method = PrincipalComponentMethod.Center,
Whiten = true
};
pca.NumberOfOutputs = 2;
MultivariateLinearRegression transform = pca.Learn(trainInputs);
double[][] outputPCA = pca.Transform(trainInputs);
// print it on the scatter plot
ScatterplotBox.Show(outputPCA, trainOutputs).Hold();
Console.ReadLine();
```
Ну вот, что получилось в итоге:
Давайте сравним с тем что поучилось в прошлой статье для
Логистической регрессии с подобранными параметрами
(предсказание, факт):
[(0, 0), (0, 0), (0, 0), (2, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (2, 0), (1, 1), (1, 1), (1, 1), (1, 1), (2, 1), (2, 1), (1, 1), (1, 1), (1, 1), (1, 1), (2, 1), (2, 2), (2, 2), (2, 2), (0, 2), (2, 2), (2, 2), (2, 2), (2, 2), (2, 2), (2, 2), (2, 2)]
accuracy on test data: 0.81818
как видите результат сопоставим.
Посмотрим на график PCA.
Ну в принципе похоже, но немного отличается, разработчики на своем сайте утверждают, что «все в порядке так и должно быть, все равно все скорей всего правильно, просто таковы особенности алгоритмов» (ну близко к тексту).
UPD: Спасибо [AirLight](https://habrahabr.ru/users/airlight/)
Как выяснилось, графики если их правильно наложить и вовсе совпадают практически полностью думаю, как раз остальное особенности работы и реализации алгоритма, а может все дело в масштабе, не возьмусь точно утверждать
### Часть 3. Финал.
Давайте подведем итоги. Понятно, что опыта у меня мало, чтобы судить объективно, так что буду субъективен.
1. По началу после Python, возврат к .Net и этому фреймворку «вымораживал» жутко. К динамической типизации и удобным манипуляциям с данными быстро привыкаешь. Также раздражали другие названия моделей и то, что их чертовски много и для всего реализован свой класс (ну что поделать такова парадигма C#)
2. Качать проекты целиком не хотелось, а примеры к описанию классов «куцые» в итоге разбор даже того, что я вам сюда выложил, отнял у меня больше времени, чем бы хотелось, с мульти-классовой классификацией я так толком и не разобрался, в scikit-learn, оно как-то намного лучше из коробки выходит.
3. С другой стороны — модель показала такую же точность и даже не пришлось перебирать параметры, думаю и cлучайный лес тоже бы сошелся, если бы я не поленился разобраться с его реализациями.
4. Где это применять? Ну по всей видимости, во-первых, в приложениях, базирующихся на Windows Forms – технологии безусловно почетной и заслуживающей уважения, но уже давно устаревшей и MS не развиваемой, с другой стороны я не пробовал, но вполне возможно, что Аккорд подцепится к универсальным приложениям Windows и тогда с его помощью можно будет решать задачи машинного обучения и анализа данных в малых устройствах под управлением Windows IoT.
5. Если кого интересует кроссплатформенность, то да — она есть! Не поленился поставил себе на вторую систему (Mint) MonoDevelop и проверил, проект собирается и запускается, а значит и под MacOS должно тоже пойти.
Учитывая большое количество фанатов C# и их оптимистичные комментарии на сайте проекта, думаю у данного фреймворка, как и в целом у применения C# в области науки о данных есть право на жизнь, пусть и какую-то слегка маргинальную.
Ну всё, на этом все обещания, которые я дал в статье [«Паровозик, который смог!» или «Специализация Машинное обучение и анализ данных», глазами новичка в Data Science»](https://habrahabr.ru/post/335214/) — выполнены, так что могу ненадолго уйти на покой с чистой совестью.
Всем успехов и хороших выходных! | https://habr.com/ru/post/337438/ | null | ru | null |
# Кроссбраузерная одноцветная полупрозрачность
В этой статье я рассмотрю метод создания блоков с одноцветным полупрозрачным фоном.
Например, таких:
Сразу оговорюсь, что я не буду использовать opacity и абсолютное позиционирование, чтобы разместить контент поверх полупрозрачного блока.
Итак, нам нужно сделать блок с однотонным полупрозрачным фоном. Для этого можно использовать свойство opacity, но все знают, что оно применяется не только к самому элементу, но и к его детям. Можно, конечно, схитрить и применить opacity к элементу-подложке, а сам контент разместить в другом блоке, и, затем, переместить этот блок на элемент-подложку с помощью абсолютного позиционирования. Но у этого метода есть существенные недостатки, во-первых, необходимо точно знать размеры блока, а, во-вторых, добавляются лишние несемантические элементы.
Всех этих недостатков можно избежать, если вместо opacity использовать однопиксельную картинку нужного цвета с заданной прозрачностью. Но, в таком случае, будет происходить лишний http-запрос, что нежелательно.
В CSS3 появилась возможность задавать цвет фона элементу при помощи [RGBA](http://www.w3.org/TR/css3-color/#rgba-color) это, по сути, тот же RGB но с возможностью указать значение прозрачности.
> `.opacity {
>
> background: rgba(0, 0, 0, 0.5);
>
> }`
[пример (RGBA)](http://markup.xtreemhost.com/opacity/rgba.html)
Но, к сожалению, задание цвета фона через RGBA поддерживается только в новых версиях Safari (Chrome тоже) и Firefox. Для старых версий Safari, Firefox а также для Opera и IE8 (Ура!), чтобы избавиться от лишнего http-запроса, можно использовать [Data:URI](http://ru.wikipedia.org/wiki/Data:_URI):
> `.opacity {
>
> background:url(data:image/png;base64,iVBORw0KGg...);
>
> }`
>
>
[пример (Data:URI)](http://markup.xtreemhost.com/opacity/data_uri.html)
Где, `iVBORw0KG...` это наша однопиксельная полупрозрачная картинка, закодированная base64. Такое представление файла получить достаточно просто. Можно, например, использовать [Data: URI image encoder](http://www.scalora.org/projects/uriencoder/).
Объединив вместе эти два способа получим:
> `.opacity {
>
> background:url(data:image/png;base64,iVBORw0KGg...);
>
> background:rgba(0, 0, 0, 0.5);
>
> }`
>
>
[пример (RGBA + Data:URI)](http://markup.xtreemhost.com/opacity/rgba_data_uri.html)
Этот пример уже работает для FF 1.5+, Opera 7.2+, Safari 2+, Chrome, Konqueror, IE 8.
Но что делать с IE 7 и IE 6? Здесь нам поможет фильтр Alpha и один маленький трюк. Дело в том, что если к элементу применить фильтр Alpha и потом дать всем потомкам этого элемента position: relative;, то они чудесным образом становятся полностью непрозрачными:
> `.opacity {
>
> zoom:1; /\* hasLayout чтобы фильтр применился \*/
>
> background:#000;
>
> filter:alpha(opacity=50);
>
> }
>
>
>
> .opacity \* {
>
> position:relative;
>
> }`
[пример (IE 6 и 7)](http://markup.xtreemhost.com/opacity/ie.html)
Итак, совмещая все вместе получим:
> `DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
>
> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="ru">
>
> <head>
>
> <title>Opacity Blocktitle>
>
> <meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
>
> <style type="text/css">
>
> \* {
>
> margin:0;
>
> padding:0;
>
> }
>
>
>
> html {
>
> font-size:100.01%;
>
> }
>
>
>
> body {
>
> font:.8em Arial, Helvetica, sans-serif;
>
> color:#fff;
>
> background:url(bg\_pattern.jpg);
>
> }
>
>
>
> a {
>
> color:#fff;
>
> }
>
>
>
> h1 {
>
> font-weight:normal;
>
> margin:0 0 .5em;
>
> }
>
>
>
> p {
>
> margin:0 0 .5em;
>
> }
>
>
>
> .opacity {
>
> margin:40px;
>
> padding:20px;
>
> background:url(data:image/png;base64,iVBORw0KG...);
>
> background:rgba(0, 0, 0, 0.5);
>
> }
>
> style>
>
>
>
> head>
>
> <body>
>
> <div class="opacity">
>
> <h1>Привет!h1>
>
> <p>Это полупрозрачный блок.p>
>
> div>
>
> body>
>
> html>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
[конечный результат](http://markup.xtreemhost.com/opacity/opacity_final.html)
Пример протестирован и корректно работает в IE 6+, FF 1.5+, Opera 7.2+, Safari 2+, Chrome, Konqueror 4.1. Из недостатков, не работает в IE < 6. | https://habr.com/ru/post/50996/ | null | ru | null |
# Определяем ключевые товары с помощью линейной регрессии
Ритейл, все-таки, штука интересная. Особенно, если разрабатываешь сервис для его аналитики. Каждый поход в магазин превращается в мини-исследование. Идешь себе вдоль полок и думаешь:
“С чем лучше сосиски коррелируются с кетчупом или мариноваными огурцами? А черт, ладно, беру и то, и то!”
“Hoegaarden почти раскупили, а ведь до вечера пятницы еще целых полдня. Эх, че ж так плохо спрос то спрогнозировали? ”
Интересно, а что применяют управляющие для прогнозирования продаж?
А иногда приходишь с этим вопросом к ритейлерам, а тебе в ответ люди говорят «Нууууу, обычно как-то так ...» и начинают делать широкие жесты руками. Да вот, приблизительно, такие, как на картинке.
Так вот, мы в [Datawiz.io](http://datawiz.io/ru/), решительно не согласны с таким подходом.
В предыдущей статье о [корреляции в ритейле](http://habrahabr.ru/company/datawiz/blog/264217/) мы рассмотрели возможности определения влияния продаж категорий товаров на другие, и на общий оборот магазина.
Но возможно ли более точно найти ключевые товары? Какова значимость продаж определенных категорий товаров и как именно они влияют на оборот магазина?
Помогут линейные модели. Построим простое уравнение которое опишет структуру продаж магазина и которое легко смоделировать.
Использовать будем все те же исходные данные по двум магазинам: Гастроном и Универсам:
* объем продаж товаров определенной категории;
* количество упоминаний в чеках товаров определенной категории.
Составляем таблицы:
ряды — недели;
колонки — категории;
ячейки -количество проданных товаров или упоминаний в чеках.
Применяем:
```
feature_selection <- function(df){
drops <- c('Непродовольственные.товары','Фрукты','Непродовольственные.товары')
df <- df[,!names(df) %in% drops]
control <- rfeControl(functions=rfFuncs, method="cv", number=10)
results <- rfe(df[1:ncol(df)-1],
df$sum,
sizes=c(1:ncol(df)-1),
rfeControl=control)
return(results)
}
results <- feature_selection(df=Gastronom_df)
predictors(results)
plot(results, type=c("g", "o"))
output
```
Получаем список товарных категорий по Гастроному:
1. Хлеб и хлебобулочные изделия
2. Снеки
3. Молоко и молочная продукция
4. Кофе, какао, чай
5. Бакалея
6. Колбасные изделия
7. Консервация
8. Кондитерские изделия
9. Безалкогольные напитки
10. Мясо
11. Диабетическое питание
12. Табачные изделия
13. Сопутствующие продовольственные товары
14. Заморозка
15. Растительное масло
Определяем нужное количество фичей для анализа объема продаж **Гастронома**.
Мы можем определить наиболее эффективное количество фичей для построения модели. Как видим, оптимальным является использование 9, но удобным для нас будет использовать топ-6.
```
create formula
Gastronom_formula <- sum~
Хлеб и хлебобулочные изделия+
Снеки+
Молоко и молочная продукция+
Кофе, какао, чай+
Бакалея+
Колбасные изделия
```
Используем линейную регрессию:
```
Gastronom_lm <- linear_models(Gastronom_formula,Gastronom_df)
coefplot(Gastronom_lm, intercept=FALSE, outerCI=1.96, lwdOuter=1.5)
```
В модели представлены коэффициенты значения, чем коэффициент выше 0, тем более он влияет на результат.
```
cv.lm(df=Gastronom_df, Gastronom_lm, m=10) #run cross validation test
> sqrt(1629697) #mse
[1] 1277 #square root from mse
Print coefficients
>Gastronom_lm$coefficients
(Intercept) 5.53e+02
Хлеб и хлебобулочные изделия 3.20e+00
Снеки 4.60e+00
Молоко и молочная продукция 1.18e+00
Кофе, какао, чай 9.34e-03
Бакалея 1.23e+00
Колбасные изделия 3.58e+00
```
Используя данные Гастронома получаем такую формулу:
**Оборот +- 1277 = 5530 + 3.2 \*Хлеб и хлебобулочные изделия + 4.6 \*Снеки +1.18 \*Молоко и молочная продукция +0.0934\* Кофе, какао, чай + 1.23 \*Бакалея +3.58\* Колбасные изделия**
Проанализировав ее, видим, что категория “Кофе, какао, чай” имеет слишком слабое влияние на результат, а значит мы можем ее исключить без потери точности.
Получаем:
**Оборот +- 1277 = 5530 + 3.2 \*Хлеб и хлебобулочные изделия + 4.6 \*Снеки +1.18 \*Молоко и молочная продукция + 1.23 \*Бакалея +3.58\* Колбасные изделия**
Итак, теперь мы видим товары каких категорий значительно влияют на оборот выбранного магазина. Любые колебания их продаж значительно отразятся на конечном результате.
Если же мы хотим рассмотреть влияние категорий товаров не на оборот, а на количество чеков, мы используем другие данные о количестве упоминаний товаров в чеках.
Определяем нужное количество фичей для анализа количества чеков **Гастронома**
1. Хлеб и хлебобулочные изделия
2. Снеки
3. Бакалея
4. Молоко и молочная продукция
5. Кондитерские изделия
6. Колбасные изделия
7. Кофе, какао, чай
8. Консервация
9. Табачные изделия
10. Безалкогольные напитки
11. Мясо
12. Сопутствующие продовольственные товары
13. Диабетическое питание
14. Алкоголь
Используем 6 переменных.
```
Gastronom_formula <- sum~
Хлеб и хлебобулочные изделия+
Снеки+
Бакалея+
Молоко и молочная продукция+
Кондитерские изделия+
Колбасные изделия
```
```
> sqrt(1033597)
[1] 1017
> Gastronom_lm$coefficients
(Intercept) 840.105
Хлеб и хлебобулочные изделия 3.792
Снеки 3.283
Бакалея 0.741
Молоко и молочная продукция 0.924
Кондитерские изделия 0.142
Колбасные изделия 2.358
```
Получаем такое уравнение
**receipt\_qty+-1017 = 840 + 3.79 \*Хлеб и хлебобулочные изделия + 3.29 \*Снеки + 0.7\*Бакалея + 0.92 \*Молоко и молочная продукция +0.14\*Кондитерские изделия +2.358 \*Колбасные изделия**
Сравним 2 уравнения Оборота и Количества упоминаний в чеках по Гастроному
**Оборот +- 1277 = 5530 + 3.2 \*Хлеб и хлебобулочные изделия + 4.6 \*Снеки +1.18 \*Молоко и молочная продукция + 1.23 \*Бакалея +3.58\* Колбасные изделия**
и
**receipt\_qty+-1017 = 840 + 3.79 \*Хлеб и хлебобулочные изделия + 3.29 \*Снеки + 0.7\*Бакалея + 0.92 \*Молоко и молочная продукция +0.14\*Кондитерские изделия +2.358 \*Колбасные изделия**
Коэффициенты в первом уравнении значительно выше, чем во втором, это значит, что увеличение продаж данных категорий товаров больше повлияет на оборот магазина, чем на количество чеков. Но в тоже время на количество чеков может повлиять увеличение продаж Кондитерских изделий, хотя и с небольшим коэффициентом. Полученные данные можно и нужно активно использовать.
В это же время ситуация в другом магазине может значительно отличатся.
Проанализируем результаты **Универсама**
Выбираем товары для анализа оборота по Универсаму.
1. Диабетическое питание
2. Хлеб и хлебобулочные изделия
3. Консервация
4. Молоко и молочная продукция
5. Кофе, какао, чай
6. Бакалея
7. Колбасные изделия
8. Сопутствующие продовольственные товары
9. Пирожные и торты
10. Товары для животных
11. Яйца
12. Заморозка
13. Безалкогольные напитки
14. Табачные изделия
15. Товары без НДС
16. Кондитерские изделия
17. Алкоголь
18. Растительное масло
19. Снеки
20. Рыба и морепродукты
21. Мясо
Используем 3 фичи.
```
universam_formula = sum ~
Диабетическое питание+
Хлеб и хлебобулочные изделия +
Консервация+
```
```
> sqrt(9591095)
[1] 3097
> universam_lm$coefficients
(Intercept) -1612.10
Диабетическое питание 27.77
Хлеб и хлебобулочные изделия 5.24
Консервация 1.44
```
**Оборот +- 3097 = -1612.10 + 27.77 \*Диабетическое питание + 5.24 \*Хлеб и хлебобулочные изделия + 1.44 \*Консервация**
Интересный выбор товаров, что он значит рассмотрим ниже.
Данные по количеству упоминаний товаров в чеках в **Универсаме**
1. Хлеб и хлебобулочные изделия
2. Молоко и молочная продукция
3. Диабетическое питание
4. Кондитерские изделия
5. Колбасные изделия
6. Консервация
7. Кофе, какао, чай
8. Бакалея
9. Яйца
10. Пирожные и торты
11. Сопутствующие продовольственные товары
12. Заморозка
13. Снеки
14. Табачные изделия
15. Безалкогольные напитки
16. Растительное масло
17. Алкоголь
18. Товары без НДС
19. Товары для животных
20. Мясо
21. Рыба и морепродукты
```
universam_formula = sum ~
Хлеб и хлебобулочные изделия+
Молоко и молочная продукция+
Диабетическое питание+
Кондитерские изделия+
Колбасные изделия
```
```
> sqrt(3382240)
[1] 1839
> universam_lm$coefficients
(Intercept) 270.43
Хлеб и хлебобулочные изделия 2.24
Молоко и молочная продукция 1.37
Диабетическое питание 14.81
Кондитерские изделия 1.21
Колбасные изделия 1.31
```
Eсли мы взглянем на ситуацию по Универсаму, то увидим ситуацию явно отличную от Гастронома.
**Оборот +- 3097 = -1612.10 + 27.77 \*Диабетическое питание + 5.24 \*Хлеб и хлебобулочные изделия + 1.44 \*Консервация**
и
**Receipt\_qty+-1839 = 270.43 + 2.24 \*Хлеб и хлебобулочные изделия + 1.37 \*Молоко и молочная продукция + 14.81\*Диабетическое питание + 1.21\*Кондитерские изделия + 1.31 \*Колбасные изделия**
Всего 3 категории товаров влияют на оборот магазина, и Диабетическое питание особенно, практически в 5 раз больше чем Хлеб и хлебобулочные изделия. Как такое могло получится? Нам тоже стало интересно. Мы копнули глубже, заглянув в список товаров входящих в Универсаме в эту категорию. Оказалось все очень просто Универсам в категорию Диабетического питания включил всю линейку детского питания, что, естественно, значительно повысило продажи именно этой категории.
А вот на количество чеков по Универсаму влияет уже 5 категорий товаров. Но, например, Консервация влияет на оборот магазина, но не отражается на количестве чеков. Кондитерка и Колбасы влияют на количество чеков, но слабее на общий оборот магазина.
В чем, собственно, суть? Все использованные в статье примеры достаточно просты, но практическое их применение дает большой простор для анализа, прогноза продаж, планирования работы ритейлера, организации акций,… Не обязательно только одного или двух магазинов, но и торговой сети в целом.
Так давайте подходить к процессу прогнозирования в ритейле не только творчески, но и аналитически. С уважением, [Datawiz.io](http://datawiz.io/ru/). | https://habr.com/ru/post/264333/ | null | ru | null |
# Контроль диапазонов целых чисел в FindBugs
[FindBugs](http://findbugs.sourceforge.net/) — это статический анализатор кода для Java с открытым исходным кодом (под [LGPL](http://www.gnu.org/licenses/lgpl.html)). Он содержит множество детекторов, которые определяют те или иные проблемы в коде. С недавних пор я являюсь участником проекта и пишу для него новые детекторы. Об одном из них я и расскажу в этой статье. Также мы посмотрим примеры багов, найденных в реальных проектах.
### Устройство FindBugs
FindBugs анализирует не исходники, а байт-код. У этого метода есть некоторые недостатки. Нельзя написать детектор, который основан только на неправильном форматировании кода (например, возможно пропущенное else в else if, как [V646 в PVS-Studio](http://www.viva64.com/ru/d/0265/)). Нельзя детектировать некоторые ситуации, в которых генерируется одинаковый байт-код. Например, хорошо бы детектировать такой странный код (на который выдаёт предупреждение IDEA и та же [PVS-Studio](http://www.viva64.com/ru/d/0228/)):
```
while(a < 5) {
a++;
return;
}
```
Но если мы заменим while на if, компиляторы сгенерируют точно такой же байт-код, поэтому FindBugs не может увидеть разницы. Важно помнить про это, когда вы используете или планируете расширять FindBugs.
Для работы с байт-кодом используется в основном [Byte Code Engineering Library (6.0-SNAPSHOT)](http://commons.apache.org/proper/commons-bcel/) от Apache и иногда [ASM 5.0.2](http://asm.ow2.org/). Видимо, такой расклад случился по историческим причинам: когда проект FindBugs начинался, BCEL была единственным подходящим вариантом, но сейчас она, к сожалению, почти не развивается. По сути сами авторы FindBugs дорабатывают её, чтобы можно было анализировать новые версии class-файлов.
Основная часть работы FindBugs выполняется в детекторах, которые и занимаются выдачей предупреждений. Бывают также специальные детекторы, которые собирают какую-нибудь информацию о коде (например, строят граф вызовов) и сохраняют её для дальнейшего использования другими детекторами. FindBugs работает в два прохода: на первом проходе работают в основном эти специальные детекторы и они анализируют не только классы самого проекта, но и классы используемых библиотек. Также есть фабрики анализов, которые строят определённый анализ класса или метода по требованию того или иного детектора (например, анализ потока null и non-null значений внутри метода).
### Задача
Мне захотелось отлавливать логические ошибки вроде таких:
```
int test(int x) {
if( x > 10 && x > 5 ) {
return 1;
}
return 0;
}
```
Здесь очевидно второе условие бесполезно, потому что если x больше 10, то он хоть как больше 5. Приведённый пример очень простой, хотя и такие ошибки встречаются в реальном коде. В целом задача состоит в том, чтобы найти условия на целые числа, которые для любого возможного значения числа всегда истинны или всегда ложны.
### Граф потока управления
В теории компиляции есть такая штука — [граф потока управления](http://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D1%84_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F) (control flow graph, CFG). Это похоже на старую добрую блок-схему, построенную по программному коду: вершины графа — это базовые блоки, код в которых выполняется линейно без всяких переходов, а рёбра — возможные направления перехода. Граф потока управления может быть довольно большим даже для простого метода, потому что большинство инструкций может сгенерировать исключение, для которого добавляется ребро. Граф потока управления для каждого метода уже строится в FindBugs, поэтому им можно пользоваться. Вот как бы выглядел такой граф для метода, приведённого выше:
Для нашей задачи сперва надо выбрать все параметры и локальные переменные, которые могут участвовать в анализе. Пока я ограничился только теми, которые никогда не меняются (возможно, в будущем ограничение будет ослаблено). То есть нас интересуют параметры, которые ни разу не присваивают, и переменные, которые присваивают ровно один раз. Такой список легко составить, просто пробежавшись по инструкциям метода в поисках инструкций записи в локальную переменную. Для каждой переменной мы изначально устанавливаем допустимый диапазон значений. Например, для типа int это будет [Integer.MIN\_VALUE..Integer.MAX\_VALUE].
Далее мы перебираем те узлы CFG, которые содержат условие. Если это сравнение интересующей нас переменной с константой, то мы разбиваем соответствующий интервал согласно условию. Например, для условия x > 5 мы получим [Integer.MIN\_VALUE..5] + [6..Integer.MAX\_VALUE], а для x != 0 получим три интервала: [Integer.MIN\_VALUE..-1] + {0} + [1..Integer.MAX\_VALUE]. Также для каждого такого условия сохраняется интервал, который условию удовлетворяет.
Затем для каждой интересующей нас переменной мы пробегаемся по всем интервалам области определения и для каждого интервала гуляем по графу потока, начиная от входного узла. При этом если мы попадаем в условный узел, связанный с данной переменной, то идём только по одному ребру в зависимости от того, выполняется ли условие на данном интервале, и помечаем, по какому мы прошли. Для всех прочих узлов мы проходим всевозможные исходящие рёбра. Наша маленький метод разбивает область определения x на три интервала, для которых обход графа будет выглядеть так:
Заметьте, что в первых двух случаях получилось одно и то же. В конце остаётся лишь найти рёбра, которых мы ни разу не достигли и сформировать по ним сообщение об ошибке. Если конечная вершина этого ребра также оказалась не достигнута, это означает, что у нас не просто бесполезное условие, но и имеется код, который никогда не будет выполнен. В этом случае я повышаю приоритет сообщения об ошибке. Для вышеприведённого примера имеется недостижимое ребро, но достижимы все вершины:
А вот простой метод, в котором появляется недостижимая вершина (тело оператора if):
```
int test(int x) {
if( x > 10 && x < 5 ) {
return 1;
}
return 0;
}
```
CFG будет выглядеть так:
### finally
Всё это классно работало, пока я не столкнулся с finally. Компиляторы дублируют finally-блоки в байт-коде, из-за чего появляются недостижимые условия, которых не было в исходнике. Скажем, такой простой пример:
```
int test(int x) {
try {
if( x > 0 ) return -1;
return 0;
}
finally {
if( x <= 0 ) log.info("x <= 0!");
}
}
```
Код вполне нормальный, но в процессе компиляции он превращается во что-то такое (без учёта возможных исключений):
```
int test(int x) {
if( x > 0 ) {
if( x <= 0 ) log.info("x <= 0!");
return -1;
}
if( x <= 0 ) log.info("x <= 0!");
return 0;
}
```
В результате наш новый детектор жалуется, что в первом случае x <= 0 всегда ложно и есть мёртвый код, а во втором, что x <= 0 всегда истинно. Готового решения для разбора таких ситуаций в FindBugs не было. Только при null-анализе делаются некоторые предположения на основе таблицы номеров строк. Мне это показалось ненадёжным (тем более этой таблицы может и не быть), и я написал отдельный анализатор, который с небольшой долей эвристики находит в байт-коде дублирующие finally-блоки и может для заданного ребра CFG выдать все его дубликаты. Собственно, в процессе этой работы и родилась мысль написать [шуточную статью](http://habrahabr.ru/post/245333/). Теперь я выдаю ошибку, только если во всех дубликатах ребро не было достигнуто.
### Найденные ошибки
Теперь самая весёлая часть. Я обычно для тестов анализирую пачку проектов с открытыми исходниками, поэтому примеры будут из разных проектов.
#### Ошибки из-за диапазона значений типа
Это побочный эффект анализа, про который я сразу не подумал: иногда условие бесполезно не потому, что выше было противоречащее ему условие, а потому, что тип переменной ограничен. Я сделал для него отдельное сообщение. Вот пример, про который я даже не буду говорить, из какого он проекта. Этот метод с небольшими вариациями бездумно скопирован в десяток проектов, где используется XML:
```
public final static boolean isNameStartChar(char ch) {
return (ch > bA && ch < aZ) || (ch > ba && ch < az) ||
(ch == ':') || (ch == '_') || (ch > 0xBF && ch < 0xD7) ||
(ch > 0xD7 && ch < 0xF7) || (ch > 0xF7 && ch < 0x300) ||
(ch > 0x36F && ch < 0x37E) || (ch > 0x37E && ch < 0x2000) ||
(ch > 0x200B && ch < 0x200E) || (ch > 0x206F && ch < 0x2190) ||
(ch > 0x2BFF && ch < 0x2FF0) || (ch > 0x3000 && ch < 0xD800) ||
(ch > 0xF900 && ch < 0xFDD0) || (ch > 0xFDEF && ch < 0xFFFE) ||
(ch > 0x0FFFF && ch < 0xF0000); // ch > 0xFFFF всегда истинно
}
```
Последняя пара условий бессмысленна: значение переменной типа char не может быть больше 0xFFFF. Если авторы планировали поддерживать такие символы, надо анализировать суррогатные пары UTF-16, анализом одного char тут не обойдёшься.
Вот более конкретное — [Utility#encodeRun](http://grepcode.com/file/repo1.maven.org/maven2/com.ibm.icu/icu4j/54.1.1/com/ibm/icu/impl/Utility.java#Utility.encodeRun%28java.lang.Appendable%2Cshort%2Cint%29) из проекта IBM ICU:
```
private static final char ESCAPE = '\uA5A5';
private static final void encodeRun(T buffer, short value, int length) {
try {
if (length < 4) {
for (int j=0; j
```
ESCAPE при преобразовании в int равно 0xA5A5 (42405) и никак не может равняться переменной типа short, которая принимает значения от -32768 до 32767.
Часть таких ошибок уже ловилась FindBugs (например, сравнение byte с числами больше 127), сейчас ловится больше. Но в целом это неинтересно, за таким вообще и IDE могла бы следить без проблем.
#### Использован && вместо ||
Одна из частых грубых ошибок. Обычно встречается в проверке входных параметров, которая не всегда должным образом покрыта юнит-тестами. Вот, например, в [SegmentArrayWithData#setElementAt](http://grepcode.com/file/repository.grepcode.com/java/ext/com.jetbrains/intellij-idea/13.0.0/com/intellij/openapi/editor/ex/util/SegmentArrayWithData.java#SegmentArrayWithData.setElementAt%28int%2Cint%2Cint%2Cint%29) в IntelliJ IDEA:
```
public void setElementAt(int i, int startOffset, int endOffset, int data) {
if (data < 0 && data > Short.MAX_VALUE) throw new IndexOutOfBoundsException("data out of short range" + data);
...
}
```
Здесь data > Short.MAX\_VALUE бессмысленно, потому что не может быть число одновременно меньше 0 и больше 32767. В результате формируется мёртвый код: исключение никогда не будет выкинуто. Подобная бага была найдена в различных проектах, но меня удивило увидеть это в IDEA: у них самих встроенный серьёзный статический анализатор, который наверняка должен ловить такое. Возможно, проглядели.
#### Использован || вместо &&
Такое встречается существенно реже. Вот снова из ICU — [ULocale#parseAcceptLanguage](http://grepcode.com/file/repo1.maven.org/maven2/com.ibm.icu/icu4j/54.1.1/com/ibm/icu/util/ULocale.java#2266):
```
case 8: // before q value fraction part
if ('0' <= c || c <= '9') { // c <= '9' всегда истинно
...
} else {
// invalid
state = -1;
}
break;
```
Условие c <= '9' бессмысленно: если оказалось, что c < '0', то оно уж точно <= '9'. В результате весь if бесполезен, ветка else никогда не выполнится.
#### Одно и то же условие в двух ветках
Пример из Eclipse Mylyn — [DefaultXmlStreamWriter#printEscaped](http://grepcode.com/file/repo1.maven.org/maven2/org.fusesource.wikitext/wikitext-core/1.4/org/eclipse/mylyn/wikitext/core/util/DefaultXmlStreamWriter.java#432):
```
private static void printEscaped(PrintWriter writer, int ch, boolean attribute) throws IOException {
String ref = getEntityRef(ch, attribute);
if (ref != null) {
writer.write('&');
writer.write(ref);
writer.write(';');
} else if (ch == '\r' || ch == 0x0085 || ch == 0x2028) {
printHex(writer, ch);
} else if ((ch >= ' ' && ch != 160 && isUtf8Printable((char) ch) && XML11Char.isXML11ValidLiteral(ch))
|| ch == '\t' || ch == '\n' || ch == '\r') { // ch == '\r' всегда ложно
writer.write((char) ch);
} else {
printHex(writer, ch);
}
}
```
Здесь условие ch == '\r' имеется в двух ветках else if. Сработает, конечно, только первое. Мёртвого кода нет, но неясно, что имел в виду автор.
#### Взаимоисключающие параграфы
Вот довольно свежий код из того же Mylyn — [EscapeBlock#canStart](http://git.eclipse.org/c/mylyn/org.eclipse.mylyn.docs.git/tree/org.eclipse.mylyn.wikitext.mediawiki.core/src/org/eclipse/mylyn/internal/wikitext/mediawiki/core/block/EscapeBlock.java?h=fffa125338b17798157eae5cedbea4ba4f3ad35e#n58):
```
public boolean canStart(String line, int lineOffset) {
if (lineOffset == 0) {
Matcher matcher = START_PATTERN.matcher(line);
if (lineOffset > 0) { // lineOffset > 0 всегда ложно
matcher.region(lineOffset, line.length());
}
if (matcher.matches()) {
return true;
}
}
return false;
}
```
Если уж lineOffset равен 0, то он никак не может быть больше 0.
#### Забыли, что было раньше?
Пример из проекта Jmol — [GromacsReader#readAtoms](https://sourceforge.net/p/jmol/code/20161/tree/trunk/Jmol/src/org/jmol/adapter/readers/more/GromacsReader.java#l67)
```
for (int i = 0; i < modelAtomCount; ++i) {
rd();
int len = line.length();
if (len != 44 && len != 68) {
Logger.warn("line cannot be read for GROMACS atom data: " + line);
continue;
}
...
if (len < 69) // len < 69 всегда истинно
continue;
float vx = parseFloatRange(line, 44, 52) * 10;
float vy = parseFloatRange(line, 52, 60) * 10;
...
}
```
В начале цикла проверяется длина прочитанной из файла строки. Если она не равна 44 или 68, выдаём предупреждение и переходим к следующей итерации цикла. Ближе к концу итерации ещё одна проверка на len: теперь уже if (len < 69). Досюда могли дойти только два значения len: 44 или 68. Оба они меньше 69, поэтому условие всегда сработает и последние 6 строчек цикла никогда не выполнятся.
#### Запутались в операторах сравнения
Снова ICU — [CollationParsedRuleBuilder#isJamo](http://grepcode.com/file/repo1.maven.org/maven2/com.ibm.icu/icu4j/52.1/com/ibm/icu/text/CollationParsedRuleBuilder.java#CollationParsedRuleBuilder.isJamo%28char%29):
```
private static final boolean isJamo(char ch) {
return (ch >= 0x1100 && ch <= 0x1112) || (ch >= 0x1175 && ch <= 0x1161) // ch <= 0x1161 всегда ложно
|| (ch >= 0x11A8 && ch <= 0x11C2);
}
```
Средняя пара условий находит числа в диапазоне от 0x1175 до 0x1161. Разумеется, таких чисел быть не может, так как 0x1161 меньше, чем 0x1175. Здесь мы выдаём предупреждение, что условие ch <= 0x1161 бесполезно. Мёртвый код не образуется, но тут определённо какая-то ошибка.
#### Переполнение при вычислениях
Вот [Andrey2008](https://habrahabr.ru/users/andrey2008/) постоянно спрашивают, может ли он показать весёлые баги из кода PVS-Studio, найденные PVS-Studio, а он отвечает, что все баги обычно исправляются сразу, так как используется инкрементальная проверка, и они даже в репозиторий не попадают. В целом это справедливо и для FindBugs: Eclipse-проект в FindBugs настроен на инкрементальную проверку, так что трудно найти что-то серьёзное в FindBugs, проверяя его им же самим. Но всё меняется, когда разрабатываешь новый детектор. Тогда он действительно может найти очень вкусную багу в старом коде, что и случилось. Посмотрите метод [DumbMethods#checkForCompatibleLongComparison](https://code.google.com/p/findbugs/source/browse/findbugs/src/java/edu/umd/cs/findbugs/detect/DumbMethods.java?r=2e9bc86b391531536a8ef29ad767fab87039f40c#1207)
```
private void checkForCompatibleLongComparison(OpcodeStack.Item left, OpcodeStack.Item right) {
if (left.getSpecialKind() == Item.RESULT_OF_I2L && right.getConstant() != null) {
long value = ((Number) right.getConstant()).longValue();
if ( (value > Integer.MAX_VALUE || value < Integer.MIN_VALUE)) {
int priority = Priorities.HIGH_PRIORITY;
if (value == Integer.MAX_VALUE+1 || value == Integer.MIN_VALUE -1) { // оба условия всегда ложны
priority = Priorities.NORMAL_PRIORITY;
}
...
}
```
Данный код (написанный, кстати, более четырёх лет назад) выполняется в случае, если в анализируемом исходнике число типа int сравнивается с числом типа long, которое не влезает в диапазон int. Такое сравнение бессмысленно, поэтому здесь генерируется предупреждение INT\_BAD\_COMPARISON\_WITH\_INT\_VALUE. Предполагалось установить приоритет пониже, если сравнение выполняется с числом, которое на границе диапазона целых чисел (Integer.MAX\_VALUE+1 или Integer.MIN\_VALUE-1). Дело однако в том, что эти выражения сами вычисляются в целых числах и возникает переполнение: вместо Integer.MAX\_VALUE+1 мы получаем Integer.MIN\_VALUE, а вместо Integer.MIN\_VALUE-1 получаем Integer.MAX\_VALUE. Причём это вычисление выполняет компилятор, и в байткод попадает уже результирующее число. Здесь-то мой новый детектор и блеснул: из вышестоящего условия следует, что ни Integer.MIN\_VALUE, ни Integer.MAX\_VALUE не может быть в value в данной точке. В результате условие никогда не выполнится, и приоритет никогда не будет понижен. Конечно, следовало написать
```
if (value == Integer.MAX_VALUE+1L || value == Integer.MIN_VALUE-1L)
```
Понятно, почему этот баг оставался незамеченным годами: пользователи могли и не догадываться о намерении авторов понизить приоритет в данном случае, а тесты в FindBugs обычно проверяют, есть ли определённое предупреждение на определённом коде или нет, но не проверяют его приоритет.
#### Перестраховка
Довольно много сообщений выдаётся о перестраховочных условиях вроде таких:
```
if( x > 0 ) { ... } else if( x <= 0 ) { ... }
```
Второе условие очевидно не нужно, хотя кто-то может поспорить, что оно дополнительно документирует код. Всё же я считаю, что если пояснение нужно, его лучше написать в комментарии. Во всяком случае, ранее FindBugs уже ругался на такой код:
```
if( obj == null ) { ... } else if( obj != null ) { ... }
```
Поэтому я считаю, что не нарушил общей концепции.
Ещё встречается такой код:
```
if( x > 0 ) {
... // много строчек
if( x > 0 ) {
... // ещё код
}
...
}
```
Обычно тут ошибки нет, но выглядит так, будто автор уже сам не помнит, в какой он ветке кода. Возможно, это признак того, что метод сильно сложный.
### Заключение
Желающие испытать новый детектор могут выкачать код из нашего [репозитория](https://code.google.com/p/findbugs/) и скомпилировать ant'ом. Если кому-то лень компилировать, я сделал неофициальные сборки из текущего кода — [findbugs.jar](http://biorainbow.com/~lan/fb-unofficial/findbugs.jar) и [Eclipse update site](http://biorainbow.com/~lan/fb-unofficial/eclipse-daily/) (к сожалению, официальный Eclipse daily site не работает). Новые предупреждения называются UC\_USELESS\_CONDITION и UC\_USELESS\_CONDITION\_TYPE (категория Dodgy code).
Если кому интересна реализация, большая часть кода в классе [ValueRangeAnalysisFactory](https://code.google.com/p/findbugs/source/browse/findbugs/src/java/edu/umd/cs/findbugs/classfile/engine/bcel/ValueRangeAnalysisFactory.java), сам детектор — [RedundantConditions](https://code.google.com/p/findbugs/source/browse/findbugs/src/java/edu/umd/cs/findbugs/detect/RedundantConditions.java), а поиск дублирующихся finally-блоков — [FinallyDuplicatesInfoFactory](https://code.google.com/p/findbugs/source/browse/findbugs/src/java/edu/umd/cs/findbugs/classfile/engine/bcel/FinallyDuplicatesInfoFactory.java). Код ещё неокончательный, но вполне рабочий. Могут быть ложные сработки в assert'ах, с этим будем бороться.
Ошибки есть в любой программе, а статический анализ — это хорошо. | https://habr.com/ru/post/240121/ | null | ru | null |
# Yii 2.0.7
Вышла версия 2.0.7 PHP фреймворка Yii. Как установить или обновиться описано на странице <http://www.yiiframework.com/download/>.
Данная версия содержит [более сотни улучшений и исправлений](https://github.com/yiisoft/yii2/blob/2.0.7/framework/CHANGELOG.md), уточнения документации и её переводы.
Для обновления может понадобится выполнить дополнительные действия, описанные в [UPGRADE.md](https://github.com/yiisoft/yii2/blob/2.0.7/framework/UPGRADE.md).
Спасибо нашему [замечательному сообществу](https://github.com/yiisoft/yii2/graphs/contributors), которое дало нам множество пулл-реквестов и обсуждений. Без вас этого релиза не было бы. Спасибо!
За процессом разработки Yii можно следить, поставив звёздочку или нажав на watch [на странице проекта на GitHub](https://github.com/yiisoft/yii2). Также у нас есть [Twitter](https://twitter.com/yiiframework) и [группа в Facebook](https://www.facebook.com/groups/yiitalk/).
Ну а теперь рассмотрим самые интересные улучшения и исправления этого релиза.
Валидатор IP
------------
Новый валидатор может проверять IP на чёткое соответствие, диапазоны и маски. Он может использоваться как отдельный валидатор, так и как часть метода `rules()` модели:
```
public function rules()
{
return [
['address', 'ip', 'ranges' => [
'192.168.10.128'
'!192.168.10.0/24',
'any' // все остальные адреса
]],
];
}
```
Подробнее возможности валидатора описаны [в руководстве](http://www.yiiframework.com/doc-2.0/guide-tutorial-core-validators.html#ip), [комментариях к классу](http://www.yiiframework.com/doc-2.0/yii-validators-ipvalidator.html) и
[тестах](https://github.com/yiisoft/yii2/blob/2.0.7/tests/framework/validators/IpValidatorTest.php).
i18n
----
Форматтер обзавёлся новым методом `asDuration()`, который позволяет получить читабельную строку из интервала времени, представленного [объектом DateInterval](http://php.net/manual/ru/class.dateinterval.php), количеством секунд или [строкой ISO8601](https://ru.wikipedia.org/wiki/ISO_8601):
```
echo Yii::$app->formatter->asDuration(131);
// выведет "2 minutes, 11 seconds"
```
Теперь через `yii\i18n\Formatter::$calendar` можно выбрать, по какому календарю форматировать даты. Например, вот так можно использовать Персидский календарь:
```
Yii::$app->formatter->locale = 'fa_IR@calendar=persian';
Yii::$app->formatter->calendar = \IntlDateFormatter::TRADITIONAL;
Yii::$app->formatter->timeZone = 'UTC';
$value = 1451606400; // Fri, 01 Jan 2016 00:00:00 (UTC)
echo Yii::$app->formatter->asDate($value, 'php:Y');
// выведет "۱۳۹۴"
```
Подробное описание можно найти в [документации к классу](http://www.yiiframework.com/doc-2.0/yii-i18n-formatter.html#$calendar-detail).
Кроме того, транслитерация вне контекста URL теперь доступна как [`Inflector::transliterate()`](http://www.yiiframework.com/doc-2.0/yii-helpers-baseinflector.html#transliterate()-detail), что полезно для генерации ключевых слов и других метаданных при разработке под такие языки, как вьетнамский.
Базы данных
-----------
Помимо исправлений в релиз были включены и несколько интересных улучшений. В `Query::groupBy()` и `Query::orderBy()` теперь можно использовать `yii\db\Expression`:
```
$expression = new Expression('SUBSTR(name, 2)');
$users = (new \yii\db\Query)
->from('user')
->orderBy($expression)
->limit(10)
->all();
```
Для SQLite стало возможным использование псевдонимов в DSN:
```
'db' => [
'dsn' => 'sqlite:@app/db/database.sqlite3',
]
```
Для JOIN с связанными записями в Active Record появился упрощённый способ именовать таблицы. Синтаксис, доступный ранее в `join()`, теперь можно использовать и в `joinWith()`:
```
// join-им с заказами и сортируем результат по orders.id
$query->joinWith(['orders o'])->orderBy('o.id');
```
Улучшения в новом синтаксисе миграций
-------------------------------------
Новый синтаксис миграций, введённый в 2.0.6, получил несколько улучшений. Во-первых, это поддержка `unsigned`:
```
'createdBy' => $this->integer(10)->unsigned(),
```
Во-вторых, теперь можно использовать выражения в качестве значений по умолчанию:
```
$this->integer()->defaultExpression('CURRENT_TIMESTAMP');
```
Консольный генератор миграций
-----------------------------
Команда `./yii migrate/create` стала умнее. На основе имени создаваемой миграции и параметров она научилась генерировать код самой миграции:
```
./yii migrate/create create_post --fields=title:string,body:text
```
сгенерирует:
```
class m150811_220037_create_post extends Migration
{
public function up()
{
$this->createTable('post', [
'id' => $this->primaryKey(),
'title' => $this->string(),
'body' => $this->text()
]);
}
public function down()
{
$this->dropTable('post');
}
}
```
Синтаксис подробно описан [в руководстве](http://www.yiiframework.com/doc-2.0/guide-db-migrations.html#generating-migrations). Надеемся, нововведение сбережёт ваше время.
Расширение интерфейса RBAC
--------------------------
В интерфейс RBAC было добавлен метод [`getUserIdsByRole()`](http://www.yiiframework.com/doc-2.0/yii-rbac-managerinterface.html#getUserIdsByRole()-detail). Он наверняка будет полезен при разработке админки для ролей и разрешений.
Обработка и вывод ошибок
------------------------
* Добавлена поддержка кодов ошибок PHP 5.5 при обработке JSON. Это позволяет точно определить причину, по которой кодирование в JSON не удалось.
* `VarDumper::dump()` научился работать с магическим методом PHP `__debugInfo()`.
* Обработчик ошибок из соображений безопасности больше не показывает `$_ENV` и `$_SERVER` на странице ошибок. Отображаемые данные настраиваются через [`yii\web\ErrorHandler::$displayVars`](http://www.yiiframework.com/doc-2.0/yii-web-errorhandler.html#$displayVars-detail).
* `yii\helpers\VarDumper::export()` научился работать с циклическими ссылками, что делает логирование и отладочную панель более надёжными. | https://habr.com/ru/post/277201/ | null | ru | null |
# Что нового в CakePHP 3.0.0?
Здравствуйте, уважаемые читатели. В данной статье хотелось бы написать о новой версии [CakePHP](http://www.cakephp.org/) и возродить интерес к этому замечательному PHP фреймворку. Последняя заметка в блоге о CakePHP датирована почти годом назад и многие могли подумать, что фреймворк прекратил своё существование, однако это не так. Он очень активно развивается и весьма популярен в западных странах и его используют такие компании, как [BMW и Hyundai](http://www.cakedc.com/cakephp-development#who-uses-cakephp).
Текущая стабильная версия CakePHP – 2.5.5. Давайте кратко посмотрим, какие возможности предоставляет этот фреймворк сейчас, а затем подробно остановимся на новинках, которые появятся в 3.0.0.
#### Почему стоит использовать CakePHP?
CakePHP позволяет создавать веб приложения проще, быстрее и писать меньше кода. Нет никаких сложных XML или YAML файлов. Просто сконфигурируйте соединение с базой данных и начинайте разработку. Вместо раздумывания над тем, где, что и как лучше разместить, положитесь на продуманные конвенции CakePHP, которые помогут вам в разработке приложения. Вещи, которые нужны практически в каждом проекте уже внедрены. Поддержка мультиязычности, доступ к базам данных, кэширование, валидация, аутентификация и многое другое уже встроено в ядро фреймворка. Вот краткий список возможностей CakePHP 2.5.5:
* Совместимость с версиями PHP 5.2.8 и выше
* Встроенная ORM для взаимодействия с базой данных
* Скаффолдинг — построение каркаса приложения по структуре базы данных
* Генерация кода из командной строки
* MVC архитектура
* Диспетчер запросов, гибкие URL и маршрутизация
* Встроенная валидация
* Быстрая и гибкая шаблонизация с синтаксисом PHP и помощниками
* Помощники Видов для AJAX, JavaScript, HTML форм и др.
* Email, cookie, security, session, и request компоненты
* Гибкий ACL
* Нормализация данных
* Гибкое кэширование
* Поддержка локализации
* Работает из любой директории сайта и практически не требует конфигурации Apache
* Отличная документация и активное сообщество CakePHP
* Фреймворк выпускается под лицензией MIT, что идеально подходит для его использования в коммерческих проектах
В январе 2014 года увидело свет первое превью CakePHP 3.0.0. В настоящее время активно продолжается разработка и совсем недавно вышел CakePHP 3.0.0-beta, что означает, что релиз уже не за горами. А пока давайте посмотрим, что нового появляется в третьей версии.
#### Что нового в CakePHP 3.0.0-beta?
##### Изменения в структуре каталогов и в именовании
* Одинаковая структура каталогов для приложений и плагинов. Это даст возможность при работе с плагинами чувствовать себя так, как будто вы работаете в небольшом модульном приложении.
* src/Config теперь /config
* src/bootstrap.php теперь /config/bootstrap.php
* log-файлы теперь на верхнем уровне директории по умолчанию
* шаблоны Bake теперь должны лежат в src/Template/Bake
* Плагины, которые используют вендорные префиксы (например AcmeCorp/Users) больше не переименовываются. Вместо использования Users.User вы теперь должны использовать AcmeCorp/Users.User. Также, вендорные префиксы будут использованы как имя папки в папке плагина, таким образом плагин будет установлен в plugins/AcmeCorp/User
* Файлы исключений были перемещены в соответствующие им пространства имен
##### Улучшения ORM
* Добавлена поддержка Microsoft SQL Server
* Пустые ассоциации в BelongsTo и HasOne больше не создают пустую сущность. Вместо этого, свойством ассоциации будет null
* Параметры для всех различных операций ORM теперь согласованы
* Вы можете указать белый список полей, когда сортируемые данные отсутствуют в запросе и есть в сущностях
* Теперь легче реализовать собственные типы столбцов с помощью метода \_initializeSchema для таблиц
* Query::newExpr() теперь позволяет SQL выражения
* Условия с обнуляемыми значениями теперь легче создавать.`'field IS' => $val` сгенерирует правильный SQL, когда $val не равен NULL.
* Условия с ключевым словом IN стали лучше работать с пустыми данными
* Добавлен Query::autoFields(). Это контролирует, были ли автоматически выбраны поля для основной таблицы
* Способность передать опции искателя отдельным искателям из paginator, используя ключ FinderOptions
* Теперь возможно получить отдельную колонку значений из базы данных, используя Schema\Table::defaultValue()
* Добавлен accessibleFields как опциональный ключ для newEntity() и patchEntity(). Это позволит более тонко осуществлять контроль для масового назначения
* TranslateBehavior автоматически находит переводы, основанные на текущей локали приложения
* Добавлен метод Table::findOrCreate()
* Возможность переопределять тип join для ассоциаций, используя contain()
* Миграции теперь являются официальным плагином CakePHP. Он оборачивает отличную библиотеку Phinx в оболочку CakePHP, чтобы избежать повторения конфигурационных строк и добавить некоторые особенности CakePHP
##### Важные изменения
* Разделение фреймворка на отдельные компоненты для самостоятельного использования: коллекции, валидация, утилиты, события, ядро
* Класс маршрутизатора переписан и добавлены новые методы, позволяющие файлам роутинга больше соответствовать принципу DRY, чем раньше. Маршруты по умолчанию, предоставляемые CakePHP, были удалены. Их место занял маленький набор маршрутов, предоставляемый, чтобы помочь на стадии прототипа разработки приложений
* Слияние тем и плагинов. Теперь вы можете использовать любой плагин в качестве темы. Это делает упаковку и распространение тем таким же легким, как и плагинов и позволяет использовать помощники и ячейки
* Появились [View Cells](http://book.cakephp.org/3.0/en/views/cells.html) — это маленькие классы, которые по функциональности похожи на контроллеры, но могут использоваться непосредственно во view, чтобы получить данные из любого источника и отобразить определенный шаблон
* Создание объектов View было упрощено, они теперь больше не зависят от контроллеров
* Переработаны фильтры диспетчера — фильтры теперь регистрируются как экземпляры объекта, а не через конфигурационные данные, что добавляло вложенную зависимость
* Новый объект сессии. В CakePHP 3.0, вы можете получить доступ к сессии с помощью объекта запроса `$this->request->session()`
* Раньше CookieComponent мог работать только в одном пространстве имен. Переработанный CookieComponent отделяет конфигурацию пространства имен cookie от обработки данных cookie
* Новый класс [Time](http://book.cakephp.org/3.0/en/core-utility-libraries/time.html) — теперь класс Time может делать все то же самое, что и библиотеки Carbon и DateTime
* CakePHP 3.0 дает разработчикам больше инструментов для создания и рендеринга нескольких видов сообщений простым образом. Для этого были созданы отдельный компонент и помощник FlashHelper и FlashComponent
* CacheHelper был удален из CakePHP. Команда разработчиков рекомендует функции этого помощника выполнять на отдельном сервере, например Varnish.
* Класс L10n был удален. Построенная на ext/intl и Aura/Intl новая подсистема локализации предлагает более мощный синтаксис замены и сохраняет обратную совместимость форматтера, основанного на sprintf()
* Добавлен метод Validator::notEmpty()
* Request::isMobile теперь использует внешнюю библиотеку, чтобы соответствовать увеличивающемуся количеству мобильных устройств
* Bcrypt в паролях по умолчанию
* Новый интерфейс логирования. Теперь все движки логирования реализуют Psr\Log\LoggerInterfaceinterface
* Появился новый IntegrationTestCase класс для тестирования всех аспектов HTTP запроса в вашем приложении
* Появился DebugKit – это панель инструментов для приложения, которая собирает полезную статистику о вашем коде, такую как время и память, выполненные запросы, лог-сообщения и переменные представления
* Улучшения консоли
* Улучшена производительность за счет ускорения в процессе загрузки и генерации некоторых частей помощников шаблонов
* Новый шаблон пекарни
#### Плагины
С каждым днем начинает появляться всё больше плагинов для версии 3.0. Вот только самые интересные из них:
* [TwigView](https://github.com/WyriHaximus/TwigView) — шаблонизатор Twig
* [Imagine](https://github.com/burzum/cakephp-imagine-plugin/tree/3.0) — плагин для работы с изображениями
* [Geo](https://github.com/dereuromark/cakephp-geo) — содержит библиотеки утилит и поведения для работы с гео данными
* [Blame](https://github.com/ceeram/blame) — регистрирует идентификатор пользователя, который модифицирует строку в базе данных
* [CakePdf](https://github.com/FriendsOfCake/CakePdf/tree/3.0) — генерирует PDF файлы, используя различные движки
* [Authenticate](https://github.com/FriendsOfCake/Authenticate/tree/cake3) — адаптеры авторизации и аутентификации
* [TinyAuth](https://github.com/dereuromark/cakephp-tinyauth) — легковесная система авторизации
* [TwitterBootstrap](https://github.com/gourmet/twitter_bootstrap) — плагин для генерации интерфейсов бутстрапа
* [Whoops](https://github.com/gourmet/whoops) — альтернативный рендерер исключений с удобным интерфейсом для отладки
* [Assetic](https://github.com/gourmet/assetic) — минифицирует и обрабатывает (pre-process) CSS и Javascript
Вы можете [скачать](https://github.com/cakephp/cakephp/releases/download/3.0.0-beta2/cakephp-3-0-0-beta2.zip) релиз 3.0.0-beta или просто использовать `composer create-project -s dev cakephp/app`, чтобы попробовать CakePHP 3.0 уже сейчас.
#### Полезные ссылки
[CakePHP](http://www.cakephp.org/) — Официальная страница фреймворка
[CookBook](http://book.cakephp.org/) — Официальная документация
[API](http://api.cakephp.org/) — Описание классов CakePHP
[GitHub](https://github.com/cakephp/cakephp) – Исходный код для всех релизов
[Plugins](http://plugins.cakephp.org/) — Репозиторий плагинов фреймворка
[Пекарня](http://bakery.cakephp.org/) — Советы, руководства и статьи
[Community Center](http://community.cakephp.org/) — Список официальных страниц и каналов сообщества
В данной статье очень кратко описан полный список изменений. Если читателям эта тема будет интересна, то в следующих статьях вы сможете прочитать подробно о самых значимых изменениях и способах миграции с версии 2.x. | https://habr.com/ru/post/239905/ | null | ru | null |
# Правильный анонс к тексту или закрываем незакрытые теги
После добавления статьи и вывода списка статей на главной странице своего самописного блога возник вопрос об анонсе. Если обрезать определенное количество символов, то обрезаются и хтмл теги добавляемые текстовым редактором. От такого «анонсирования» верстка ползет по швам. И, ясное дело, меня не устраивает. После неслабого наряга в этой связи решение было найдено. Вот он метод для создания правильного анонса.
```
function anons($html = '')
{
$html = trim($html);
$anons_tag = "";
preg_match('/^(.*)' . $anons_tag . '/SUsi',$html,$res);
if(!empty($res[1])) $html = $res[1];
#put all opened tags into an array
preg_match_all("##iU",$html,$result);
$openedtags = array_unique($result[1]);
#put all closed tags into an array
preg_match_all("##iU",$html,$result);
$closedtags = array_unique($result[1]);
$len_opened = count($openedtags);
# all tags are closed
if(count($closedtags) == $len_opened){
return $html;
}
$openedtags = array_reverse($openedtags);
# close tags
for($i=0;$i < $len_opened;$i++) {
if (!in_array($openedtags[$i],$closedtags)){
$html .= '';
} else {
unset($closedtags[array_search($openedtags[$i],$closedtags)]);
}
}
return $html;
}
```
Переменная $anons\_tag хранит в себе текст тега анонса. Он может быть любым. Его вы вставляете в конце анонса. | https://habr.com/ru/post/145196/ | null | ru | null |
# Изучаю Scala: Часть 2 — Todo лист с возможностью загрузки картинок
Привет, Хабр! Следующий этап изучения нового языка это старый добрый todo list c картинками. Чтобы научится работе с базой данных и файловой системой. Работе со стримами. За подробностями добро пожаловать под кат.
Содержание
----------
* [Изучаю Scala: Часть 1 — Игра змейка](https://habr.com/ru/post/503560/)
* Изучаю Scala: Часть 2 — Todo лист с возможностью загрузки картинок
Ссылки
------
[Исходники](https://gitlab.com/VictorWinbringer/scalatodoapi)
[Образы docker image](https://gitlab.com/VictorWinbringer/scalatodoapi/container_registry/)
API
---
Описание апи в swagger и эндпойнты я сделал с помощью [Tapir](https://github.com/softwaremill/tapir). Он позволяет своим DSL описать API которое мы хотим реализовать.
```
//Пытаемся выполнить IO и если случается ошибка то бросаем http код 500
def withStatus[A](f: IO[A]): IO[Either[(StatusCode, String), A]] =
f.attempt.map(x => x match {
case Right(value) => Right(value)
case Left(value) => Left(StatusCode.InternalServerError, value.getMessage)
})
//Описываем что все наши эндпоинты буду начинаться с api/v1 и возвращать в случае ошибки http код и текст ошибки
val baseEndpoint = endpoint
.in("api" / "v1")
.errorOut(statusCode.and(stringBody))
//Описываем что все эндпоинты для изображений будут по адресу api/v1/images
//и иметь тег Imgage.
//По тегам идет группировка в Swagger. Например на КДПВ эндпойнты собраны в две группы
//Images и Todos
private val baseImageEndpoint = baseEndpoint
.in("images")
.tag("Images")
private val download = baseImageEndpoint
.summary("Скачать картинку")
.description("Скачивает картинку по ее идентификатору")
//Эндпоинт будет реагировать на GET запрос
.get
// Эндпоинт будет брать переменную id из пути т.е для lacalhost:8080/api/v1/images/2 он передаст в id = 2
.in(path[Long]("id"))
//Запрос будет возвращать в ответе хедер ContentLengsh
.out(header[Long](HeaderNames.ContentLength))
//Запрос будет возвращать в ответ бинарный файл
.out(streamBody[Stream[IO, Byte]](schemaFor[File], CodecFormat.OctetStream()))
//Логика обработки запроса. Тут мы просто вызываем метод нашего сервиса
.serverLogic(x => withStatus(imagesService.download(x)))
```
на основе коллекции таких эндпойнтов создаются роуты, а на основе них документация Swagger
```
endpoints = todosController.endpoints ::: imagesController.endpoints
routes = endpoints.toRoutes;
docs = endpoints.toOpenAPI("The Scala Todo List", "0.0.1")
yml: String = docs.toYaml
appRoutes = routes <+> new SwaggerHttp4s(yml, "swagger").routes[IO]
```
Server
------
В качестве сервера Tapir поддерживает несколько бекендов. Я использовал [http4s](https://github.com/http4s/http4s)
```
httpApp = Router(
"/" -> appRoutes
).orNotFound
blazeServer <- BlazeServerBuilder[IO](serverEc)
.bindHttp(settings.host.port, settings.host.host)
.withHttpApp(httpApp)
.resource
```
Работа с файлами и стримы
-------------------------
Для работы с файлами я использовал стримы из [fs2](https://github.com/functional-streams-for-scala/fs2)
```
import fs2.{Stream, io}
def get(path: Path): Stream[IO, Byte] =
io.file.readAll[IO](path, blocker, 4096)
```
Работа с базой данных
---------------------
Для работы с БД я использовал [doobie](https://github.com/tpolecat/doobie) и он мне чертовски понравился потому что напомнил старый добрый Dapper ORM. Позволяет маппить DTO и выполнять SQL запросы.
```
def add(image: Image): IO[Long] = sql"""
INSERT INTO images (hash, file_path)
VALUES (${image.hash}, ${image.filePath})""".update
//Запрос будет возвращать созданный id новой записи в БД
.withUniqueGeneratedKeys[Long]("id")
.transact(xa)
```
Для миграций подключил [Flyway](https://flywaydb.org/getstarted/)
```
val flyway = Flyway
.configure()
.dataSource(settings.db.url, settings.db.user, settings.db.password)
.load()
flyway.migrate()
```
```
CREATE TABLE IF NOT EXISTS IMAGES (
id SERIAL PRIMARY KEY,
hash VARCHAR NOT NULL UNIQUE,
file_path VARCHAR NOT NULL UNIQUE
);
CREATE TABLE IF NOT EXISTS TODOS (
id SERIAL PRIMARY KEY,
name VARCHAR NOT NULL UNIQUE,
image_id BIGINT REFERENCES images,
created TIMESTAMP
);
```
Сборка и упаковка в образ Docker
--------------------------------
Я захотел собрать все в один единственный файл как например делает это Go или .NET Core с нужными настройками поэтому использовал [sbt-native-packager](https://github.com/sbt/sbt-native-packager) и плагин к нему [sbt-assembly](https://github.com/sbt/sbt-assembly). Собранный файл можно запустить с помощью команды
```
java -jar <имя файла>
```
Потом сделал DockerFile для запуска этого образа в контейнере
```
FROM hseeberger/scala-sbt:11.0.2-oraclelinux7_1.3.12_2.13.3 AS base
COPY . /root
WORKDIR /root
RUN sbt universal:packageZipTarball
RUN sbt test
FROM openjdk:15-alpine as final
COPY --from=base /root/target/scala-2.13/scala-todo-api.jar /root
WORKDIR /root
EXPOSE 8080
ENTRYPOINT ["java","-jar","scala-todo-api.jar"]
```
Собранный образ автоматом отправляется в [Registry](https://gitlab.com/VictorWinbringer/scalatodoapi/container_registry) гитлаба через его встроенный CI/CD
Настройки
---------
Настройки сервера загружаю с помощью библиотеки [PureConfig](https://github.com/pureconfig/pureconfig) и потом так как я использую Docker дополняю их из переменных окружения. Файл application.conf:
```
db {
//Два раза повторяем переменную потому что если в переменной окружения TODO_API_DB_URL будет пусто то будет использован первый вариант иначе его перезапишет переменная окружения.
url = "jdbc:postgresql://localhost:5432/todos_db"
url = ${?TODO_API_DB_URL}
user = "postgres"
user = ${?TODO_API_DB_USER}
password = "postgres"
password = ${?TODO_API_DB_PASSWORD}
}
host {
port = 8080
port = ${?TODO_API_HOSTING_PORT}
host = "0.0.0.0"
host = ${?TODO_API_HOSTING_HOST}
}
```
```
val config = ConfigSource.default.load[AppSettings]
```
Запуск
------
Запустить это все можно вот таким docker-compose файлом
```
version: '3.4'
services:
scala.todo.api:
image: registry.gitlab.com/victorwinbringer/scalatodoapi:latest
ports:
- "8001:8080"
environment:
- TODO_API_DB_URL=jdbc:postgresql://pgdb:5432/postgres
pgdb:
image: postgres
environment:
POSTGRES_PASSWORD: postgres
POSTGRES_USER: postgres
ports:
- "8002:5432"
volumes:
- todo-pgdb:/var/lib/postgresql/data
volumes:
todo-pgdb:
external: false
``` | https://habr.com/ru/post/508560/ | null | ru | null |
# Автоматическая проверка орфографии, модель Noisy Channel
 Доброго времени суток. На днях у меня возникла задача по реализации алгоритма пост-обработки результатов оптического распознавания текста. Для решения этой проблемы не плохо подошла одна из моделей для проверки орфографии в тексте, хотя конечно слегка модифицированная под контекст задачи. Этот пост будет посвящен [модели Noisy Channel](http://en.wikipedia.org/wiki/Noisy_channel_model), которая позволяет осуществлять автоматическую проверку орфографии, мы изучим математическую модель, напишем на c# немного кода, обучим модель [на базе Питера Норвига](http://norvig.com/ngrams/), и под конец протестируем то что у нас получится.
#### Математическая модель — 1
Для начала постановка задачи. Итак вы хотите написать некоторое слово **w** состоящее из **m** букв, но каким то неведомым вам способом на бумаге выходит слово **x** состоящее из **n** букв. Кстати вы как раз и есть тот самый *noisy channel*, канал передачи информации с шумами, который исказил правильное слово **w** (из вселенной правильных слов) до не правильного **x** (множества всех написанных слов).
Мы хотим найти такое слово, которое вы наиболее вероятно подразумевали при написании слова **x**. Запишем эту мысль математически, модель по своей идее похожа на модель [наивного байесовского классификатора](http://habrahabr.ru/post/184574/), хотя даже проще:
* **V** — список всех слов естественного языка.
Далее используя теорему Байеса развернем причину и следствие, полную вероятность **x** мы можем убрать из знаменателя, т.к. он при *argmax* не зависит от **w**:
* **P(w)** — априорная вероятность слова **w** в языке; этот член представляет из себя статистическую модель естественного языка (*language model*), мы будем использовать [модель](http://en.wikipedia.org/wiki/Language_model) [unigram](http://en.wikipedia.org/wiki/N-gram), хотя конечно вы в праве использовать и более сложные модели; так же заметим, что значение этого члена легко вычисляется из базы слов языка;
* **P(x | w)** — вероятность того, что правильное слово **w** было ошибочно написано как **x**, этот член называется *channel model*; в принципе обладая достаточно большой базой, которая содержит все способы ошибиться при написании каждого слова языка, то вычисление этого члена не вызвало бы трудностей, но к сожалению такой большой базы нет, но есть похожие базы меньшего размера, так что придется как то выкручиваться (например [здесь](http://norvig.com/ngrams/) находится база из 333333 слов английского языка, и только для 7481 есть слова с ошибками).
#### Вычисление значения вероятности **P(x | w)**
Тут к нам на помощь приходит [расстояние Дамерау-Левенштейна](http://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) — это мера между двумя последовательностями символов, определяемая как минимальное количество операций вставки, удаления, замены и перестановки соседних символов для приведения строки *source* к строке *target*. Мы же далее будем использовать [расстояние Левенштейна](http://en.wikipedia.org/wiki/Levenshtein_distance), которое отличается тем, что не поддерживает операцию перестановки соседних символов, так будет проще. [Оба эти алгоритма с примерами хорошо описаны в тут](http://habrahabr.ru/post/114997/), так что я повторяться не буду, а сразу приведу код:
**Расстояние Левенштейна**
```
public static int LevenshteinDistance(string s, string t)
{
int[,] d = new int[s.Length + 1, t.Length + 1];
for (int i = 0; i < s.Length + 1; i++)
{
d[i, 0] = i;
}
for (int j = 1; j < t.Length + 1; j++)
{
d[0, j] = j;
}
for (int i = 1; i <= s.Length; i++)
{
for (int j = 1; j <= t.Length; j++)
{
d[i, j] = (new int[]
{
d[i - 1, j] + 1, // del
d[i, j - 1] + 1, // ins
d[i - 1, j - 1] + (s[i - 1] == t[j - 1] ? 0 : 1) // sub
}).Min();
}
}
return d[s.Length, t.Length];
}
```
Эта функция сообщает нам сколько операций удаления, вставки и замены нужно произвести для приведения одного слова к другому, но нам этого не достаточно, а хотелось бы получить так же список этих самых операций, назовем это backtrace алгоритма. Нам необходим модифицировать приведенный код таким образом, что бы при вычислении матрицы расстояний **d**, так же записывалась матрица операций *b*. Рассмотрим пример для слов **ca** и **abc**:
| | |
| --- | --- |
| **d** | **b** (0 — удаление из *source*, слева; 1 — вставка из *target* в *source*; 2 — замена символа в *source* на символ из *target*) |
| | |
Как вы помните, значение ячейки **(i,j)** в матрице расстояний **d** вычисляется следующим образом:
```
d[i, j] = (new int[]
{
d[i - 1, j] + 1, // del - 0
d[i, j - 1] + 1, // ins - 1
d[i - 1, j - 1] + (s[i - 1] == t[j - 1] ? 0 : 1) // sub - 2
}).Min();
```
Нам остается в ячейку **(i,j)** матрицы операций **b** записывать индекс операции (0 для удаления, 1 для вставки и 2 для замены), соответственно этот кусок кода преобразуется следующим образом:
```
IList vals = new List()
{
d[i - 1, j] + 1, // del
d[i, j - 1] + 1, // ins
d[i - 1, j - 1] + (s[i - 1] == t[j - 1] ? 0 : 1) // sub
};
d[i, j] = vals.Min();
int idx = vals.IndexOf(d[i, j]);
b[i, j] = idx;
```
Как только обе матрицы заполнены, не составит труда вычислить backtrace (стрелочки на картинках выше). Это путь из правой нижней ячейки матрицы операций, по пути наименьшей стоимости матрицы расстояний. Опишем алгоритм:
1. обозначим правую нижнюю ячейку как текущую
2. делаем одно из следующих действий
* если удаление, то записываем удаленный символ, и сдвигаем текущую ячейку вверх (красная стрелка)
* если вставка, то записываем вставленный символ и сдвигаем текущую ячейку влево (красная стрелка)
* если замена, а так же заменяемые символы **не** равны, то записываем заменяемые символы и сдвигаем текущую ячейку налево и вверх (красная стрелка)
* если замена, но заменяемые символы равны, то только сдвигаем текущую ячейку налево и вверх (синяя стрелка)
3. если количество записанных операций не равно расстоянию Левенштейна, то на пункт назад, иначе стоп
В итоге получим следующую функцию, вычисляющую расстояние Левенштейна, а так же backtrace:
**Расстояние Левенштейна с backtrace'ом**
```
//del - 0, ins - 1, sub - 2
public static Tuple>> LevenshteinDistanceWithBacktrace(string s, string t)
{
int[,] d = new int[s.Length + 1, t.Length + 1];
int[,] b = new int[s.Length + 1, t.Length + 1];
for (int i = 0; i < s.Length + 1; i++)
{
d[i, 0] = i;
}
for (int j = 1; j < t.Length + 1; j++)
{
d[0, j] = j;
b[0, j] = 1;
}
for (int i = 1; i <= s.Length; i++)
{
for (int j = 1; j <= t.Length; j++)
{
IList vals = new List()
{
d[i - 1, j] + 1, // del
d[i, j - 1] + 1, // ins
d[i - 1, j - 1] + (s[i - 1] == t[j - 1] ? 0 : 1) // sub
};
d[i, j] = vals.Min();
int idx = vals.IndexOf(d[i, j]);
b[i, j] = idx;
}
}
List> bt = new List>();
int x = s.Length;
int y = t.Length;
while (bt.Count != d[s.Length, t.Length])
{
switch (b[x, y])
{
case 0:
x--;
bt.Add(new Tuple(0, s[x].ToString()));
break;
case 1:
y--;
bt.Add(new Tuple(1, t[y].ToString()));
break;
case 2:
x--;
y--;
if (s[x] != t[y])
{
bt.Add(new Tuple(2, s[x] + "" + t[y]));
}
break;
}
}
bt.Reverse();
return new Tuple>>(d[s.Length, t.Length], bt);
}
```
Эта функция возвращает кортеж, в первом элементе которого записано расстояние Левенштейна, а во втором список пар , строка состоит из одного символа для операций удаления и вставки, и из двух символов для операции замены (подразумевается замена первого символа на второй).
PS: внимательный читатель заметит, что из правой нижней ячейки часто существует несколько способов движения по пути наименьшей стоимости, это один из способов увеличить выборку, но мы его для простоты так же опустим.
#### Математическая модель — 2
Теперь опишем полученный выше результат на языке формул. Для двух слов **x** и **w** мы можем вычислить список операций необходимых для приведений первого слова ко второму, обозначим список операции буквой **f**, тогда вероятность написать слово **x** как **w** будет равна вероятности произвести весь список ошибок **f** при условии, что мы писали именно **x**, а подразумевали **w**:
Вот тут начинаются упрощения, похожие на те что были в [наивном байесовском классификаторе](http://habrahabr.ru/post/184574/):
* порядок следования операций ошибки не имеет значения
* ошибка не будет зависеть от того какое слово мы написали и от того что подразумевали
Теперь для того что бы вычислить вероятности ошибок (независимо от того в каких словах они были сделаны) достаточно иметь на руках любую базу слов с их ошибочным написанием. Запишем финальную формулу, во избежание работы с числами близкими к нулю, будем работать в log space:
Итак, что же мы имеем? Если у нас на руках есть достаточный набор текстов мы можем вычислить априорные вероятности слов в языке; так же имея на руках базу слов с их ошибочным написанием, мы можем вычислить вероятности ошибок, этих двух баз достаточно что бы реализовать модель.
#### Размытие вероятностей ошибок
При пробеге по все базе слов при *argmax*, мы ни разу не наткнемся на слова с нулевой вероятностью. Но вот при вычислении операций редактирования для приведения слова **x** к слову **w** могут возникнуть такие операции, которые не встречались в нашей базе ошибок. В этом случае нам поможет [additive smoothing или размытие по Лапласу](http://en.wikipedia.org/wiki/Additive_smoothing) (оно так же использовалось в [наивном байесовском классификаторе](http://habrahabr.ru/post/184574/)). Напомню формулу, в контексте текущей задачи. Если некоторая операция коррекции **f** встречается в базе **n** раз, при том что всего ошибок в базе **m**, а типов коррекции **t** (например для замены, не то сколько раз встречается замена "*a* на *b*", а сколько всего уникальных пар "\* на \*"), то размытая вероятность выглядит следующим образом, где **k** — коэффициент размытия:
Тогда вероятность операции которая ни разу не встречалась в обучающей базе (**n = 0**) будет равна:
#### Скорость
Возникает естественный вопрос, а как быть со скоростью работы алгоритма, ведь нам придется пробегать по всей базе слов, а это сотни тысяч вызовов функции вычисления расстояния Левенштейна с backtrace'ом, а так же вычислять для всех слов вероятности ошибки (сумма чисел, если хранить в базе предвычисленные логарифмы). Тут приходит на помощь следующий статистический факт:
* 80% всех печатных ошибок находятся в пределах 1 операции редактирования, т.е. расстояния Левенштейна равным единице
* почти все печатные ошибки находятся в пределах 2 операций редактирования
Ну а далее вы можете придумывать различные алгоритмические трюки. Я использовал очевидный и очень простой способ ускорить работу алгоритма. Очевидно, что если мне требуются только слова не более чем в t операций редактирования от текущего слова, то их длина отличается от текущего не более чем на t. При инициализации класса, я создаю хэш-таблицу, в которой ключами является длины слов, а значениями — множества слов этой длины, это позволяет значительно сокращать пространство поиска.
#### Код
Приведу код класса NoisyChannel который у меня получился:
**NoisyChannel**
```
public class NoisyChannel
{
#region vars
private string[] _words = null;
private double[] _wLogPriors = null;
private IDictionary> \_wordLengthDictionary = null; //length of word - word indices
private IDictionary> \_mistakeLogProbs = null;
private double \_lf = 1d;
private IDictionary \_mNorms = null;
#endregion
#region ctor
public NoisyChannel(string[] words, long[] wordFrequency,
IDictionary> mistakeFrequency,
int mistakeProbSmoothing = 1)
{
\_words = words;
\_wLogPriors = new double[\_words.Length];
\_wordLengthDictionary = new SortedDictionary>();
double wNorm = wordFrequency.Sum();
for (int i = 0; i < \_words.Length; i++)
{
\_wLogPriors[i] = Math.Log((wordFrequency[i] + 0d)/wNorm);
int wl = \_words[i].Length;
if (!\_wordLengthDictionary.ContainsKey(wl))
{
\_wordLengthDictionary.Add(wl, new List());
}
\_wordLengthDictionary[wl].Add(i);
}
\_lf = mistakeProbSmoothing;
\_mistakeLogProbs = new Dictionary>();
\_mNorms = new Dictionary();
foreach (int mType in mistakeFrequency.Keys)
{
int mNorm = mistakeFrequency[mType].Sum(m => m.Value);
\_mNorms.Add(mType, mNorm);
int mUnique = mistakeFrequency[mType].Count;
\_mistakeLogProbs.Add(mType, new Dictionary());
foreach (string m in mistakeFrequency[mType].Keys)
{
\_mistakeLogProbs[mType].Add(m,
Math.Log((mistakeFrequency[mType][m] + \_lf)/
(mNorm + \_lf\*mUnique))
);
}
}
}
#endregion
#region correction
public IDictionary GetCandidates(string s, int maxEditDistance = 2)
{
IDictionary candidates = new Dictionary();
IList dists = new List();
for (int i = s.Length - maxEditDistance; i <= s.Length + maxEditDistance; i++)
{
if (i >= 0)
{
dists.Add(i);
}
}
foreach (int dist in dists)
{
foreach (int tIdx in \_wordLengthDictionary[dist])
{
string t = \_words[tIdx];
Tuple>> d = LevenshteinDistanceWithBacktrace(s, t);
if (d.Item1 > maxEditDistance)
{
continue;
}
double p = \_wLogPriors[tIdx];
foreach (Tuple m in d.Item2)
{
if (!\_mistakeLogProbs[m.Item1].ContainsKey(m.Item2))
{
p += \_lf/(\_mNorms[m.Item1] + \_lf\*\_mistakeLogProbs[m.Item1].Count);
}
else
{
p += \_mistakeLogProbs[m.Item1][m.Item2];
}
}
candidates.Add(\_words[tIdx], p);
}
}
candidates = candidates.OrderByDescending(c => c.Value).ToDictionary(c => c.Key, c => c.Value);
return candidates;
}
#endregion
#region static helper
//del - 0, ins - 1, sub - 2
public static Tuple>> LevenshteinDistanceWithBacktrace(string s, string t)
{
int[,] d = new int[s.Length + 1, t.Length + 1];
int[,] b = new int[s.Length + 1, t.Length + 1];
for (int i = 0; i < s.Length + 1; i++)
{
d[i, 0] = i;
}
for (int j = 1; j < t.Length + 1; j++)
{
d[0, j] = j;
b[0, j] = 1;
}
for (int i = 1; i <= s.Length; i++)
{
for (int j = 1; j <= t.Length; j++)
{
IList vals = new List()
{
d[i - 1, j] + 1, // del
d[i, j - 1] + 1, // ins
d[i - 1, j - 1] + (s[i - 1] == t[j - 1] ? 0 : 1) // sub
};
d[i, j] = vals.Min();
int idx = vals.IndexOf(d[i, j]);
b[i, j] = idx;
}
}
List> bt = new List>();
int x = s.Length;
int y = t.Length;
while (bt.Count != d[s.Length, t.Length])
{
switch (b[x, y])
{
case 0:
x--;
bt.Add(new Tuple(0, s[x].ToString()));
break;
case 1:
y--;
bt.Add(new Tuple(1, t[y].ToString()));
break;
case 2:
x--;
y--;
if (s[x] != t[y])
{
bt.Add(new Tuple(2, s[x] + "" + t[y]));
}
break;
}
}
bt.Reverse();
return new Tuple>>(d[s.Length, t.Length], bt);
}
public static int LevenshteinDistance(string s, string t)
{
int[,] d = new int[s.Length + 1, t.Length + 1];
for (int i = 0; i < s.Length + 1; i++)
{
d[i, 0] = i;
}
for (int j = 1; j < t.Length + 1; j++)
{
d[0, j] = j;
}
for (int i = 1; i <= s.Length; i++)
{
for (int j = 1; j <= t.Length; j++)
{
d[i, j] = (new int[]
{
d[i - 1, j] + 1, // del
d[i, j - 1] + 1, // ins
d[i - 1, j - 1] + (s[i - 1] == t[j - 1] ? 0 : 1) // sub
}).Min();
}
}
return d[s.Length, t.Length];
}
#endregion
}
```
Инициализируется класс следующими параметрами:
* *string[] words* — список слов языка;
* *long[] wordFrequency* — частота слов;
* *IDictionary> mistakeFrequency*
* *int mistakeProbSmoothing = 1* — коэффициент размытия частоты ошибок
#### Тестирование
Для тестирования используем [базу Питера Норвига](http://norvig.com/ngrams/), в которой содержится 333333 слов с частотами, а также 7481 слово с ошибочными написаниями. Следующий код используется для вычисления значений необходимых для ининциализации класса NoisyChannel:
**чтение базы**
```
string[] words = null;
long[] wordFrequency = null;
#region read priors
if (!File.Exists("../../../Data/words.bin") || !File.Exists("../../../Data/wordFrequency.bin"))
{
IDictionary wf = new Dictionary();
Console.Write("Reading data:");
using (StreamReader sr = new StreamReader("../../../Data/count\_1w.txt"))
{
string line = sr.ReadLine();
while (line != null)
{
string[] parts = line.Split('\t');
wf.Add(parts[0].Trim(), Convert.ToInt64(parts[1]));
line = sr.ReadLine();
Console.Write(".");
}
sr.Close();
}
Console.WriteLine("Done!");
words = wf.Keys.ToArray();
wordFrequency = wf.Values.ToArray();
using (FileStream fs = File.Create("../../../Data/words.bin"))
{
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fs, words);
fs.Flush();
fs.Close();
}
using (FileStream fs = File.Create("../../../Data/wordFrequency.bin"))
{
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fs, wordFrequency);
fs.Flush();
fs.Close();
}
}
else
{
using (FileStream fs = File.OpenRead("../../../Data/words.bin"))
{
BinaryFormatter bf = new BinaryFormatter();
words = bf.Deserialize(fs) as string[];
fs.Close();
}
using (FileStream fs = File.OpenRead("../../../Data/wordFrequency.bin"))
{
BinaryFormatter bf = new BinaryFormatter();
wordFrequency = bf.Deserialize(fs) as long[];
fs.Close();
}
}
#endregion
//del - 0, ins - 1, sub - 2
IDictionary> mistakeFrequency = new Dictionary>();
#region read mistakes
IDictionary> misspelledWords = new SortedDictionary>();
using (StreamReader sr = new StreamReader("../../../Data/spell-errors.txt"))
{
string line = sr.ReadLine();
while (line != null)
{
string[] parts = line.Split(':');
string wt = parts[0].Trim();
misspelledWords.Add(wt, parts[1].Split(',').Select(w => w.Trim()).ToList());
line = sr.ReadLine();
}
sr.Close();
}
mistakeFrequency.Add(0, new Dictionary());
mistakeFrequency.Add(1, new Dictionary());
mistakeFrequency.Add(2, new Dictionary());
foreach (string s in misspelledWords.Keys)
{
foreach (string t in misspelledWords[s])
{
var d = NoisyChannel.LevenshteinDistanceWithBacktrace(s, t);
foreach (Tuple ml in d.Item2)
{
if (!mistakeFrequency[ml.Item1].ContainsKey(ml.Item2))
{
mistakeFrequency[ml.Item1].Add(ml.Item2, 0);
}
mistakeFrequency[ml.Item1][ml.Item2]++;
}
}
}
#endregion
```
Следующий код инициализирует модель и выполняет поиск правильных слов для слова "**he;;o**" (конечно подразумевается **hello**, точка-с-запятой находятся справа от l и легко было ошибиться при печати, в базе в списке ошибочных написания слова **hello** нет слова **he;;o**) на расстоянии не более 2, с засечением времени:
```
NoisyChannel nc = new NoisyChannel(words, wordFrequency, mistakeFrequency, 1);
Stopwatch timer = new Stopwatch();
timer.Start();
IDictionary c = nc.GetCandidates("he;;o", 2);
timer.Stop();
TimeSpan ts = timer.Elapsed;
Console.WriteLine(ts.ToString());
```
У меня такое вычисление занимает в среднем чуть менее 1 секунды, хотя конечно процесс оптимизации не исчерпывается приведенными способами, а наоборот, только начинается с них. Взглянем на варианты замены и их вероятности:
#### Ссылки
* [курс Natural Language Processing на курсере](https://class.coursera.org/nlp/class)
* [Natural Language Corpus Data: Beautiful Data](http://norvig.com/ngrams/)
* [годное описание алгоритмов Левенштейна и Домерау-Левенштейна](http://habrahabr.ru/post/114997/)
[Архив с кодом можно слить от сюда](https://drive.google.com/file/d/0B4bl7YMqDnVicEhydkJRS0RVNEk/edit?usp=sharing). | https://habr.com/ru/post/202908/ | null | ru | null |
# Унификация и поиск с возвратом на C#
Эта статья является ответом на статью [«Задача Эйнштейна на Прологе»](http://habrahabr.ru/post/122142/). В ней автор пишет, что Пролог очень хорошо подходит для решения этой задачи и что суммарное количество строк почти совпадает с условиями задачи. Здесь я хочу показать, что на C# количество строк кода может быть примерно тем же. Я просто скопирую решение на Прологе и немного изменю синтаксис. Сначала приведу итоговый результат, а потом распишу функции. Вот что получилось:
```
public static IEnumerable Einstein(object houses)
{
return
/\* 0. Всего 5 домов \*/
YP.unify(houses, List(\_, \_, \_, \_, \_))
/\* 1. Норвежец живёт в первом доме. \*/
.And(Nth1(1, houses, List("norwegian", \_, \_, \_, \_)))
/\* 2. Англичанин живёт в красном доме. \*/
.And(Member(List("englishman", \_, \_, \_, "red"), houses))
/\* 3. Зелёный дом находится слева от белого, рядом с ним. \*/
.And(Nextto(List(\_, \_, \_, \_, "green"), List(\_, \_, \_, \_, "white"), houses))
/\* 4. Датчанин пьёт чай. \*/
.And(Member(List("dane", \_, \_, "tea", \_), houses))
/\* 5. Тот, кто курит Marlboro, живёт рядом с тем, кто выращивает кошек. \*/
.And(Neighbors(List(\_, \_, "marlboro", \_, \_), List(\_, "cat", \_, \_, \_), houses))
/\* 6. Тот, кто живёт в жёлтом доме, курит Dunhill. \*/
.And(Member(List(\_, \_, "dunhill", \_, "yellow"), houses))
/\* 7. Немец курит Rothmans. \*/
.And(Member(List("german", \_, "rothmans", \_, \_), houses))
/\* 8. Тот, кто живёт в центре, пьёт молоко. \*/
.And(Nth1(3, houses, List(\_, \_, \_, "milk", \_)))
/\* 9. Сосед того, кто курит Marlboro, пьёт воду. \*/
.And(Neighbors(List(\_, \_, "marlboro", \_, \_), List(\_, \_, \_, "water", \_), houses))
/\* 10. Тот, кто курит Pall Mall, выращивает птиц. \*/
.And(Member(List(\_, "bird", "pallmall", \_, \_), houses))
/\* 11. Швед выращивает собак. \*/
.And(Member(List("swede", "dog", \_, \_, \_), houses))
/\* 12. Норвежец живёт рядом с синим домом. \*/
.And(Neighbors(List("norwegian", \_, \_, \_, \_), List(\_, \_, \_, \_, "blue"), houses))
/\* 13. Тот, кто выращивает лошадей, живёт в синем доме. \*/
.And(Member(List(\_, "horse", \_, \_, "blue"), houses))
/\* 14. Тот, кто курит Winfield, пьет пиво. \*/
.And(Member(List(\_, \_, "winfield", "beer", \_), houses))
/\* 15. В зелёном доме пьют кофе. \*/
.And(Member(List(\_, \_, \_, "coffee", "green"), houses));
}
```
И сам запрос решения:
```
var houses = new Variable();
var owner = new Variable();
Einstein(houses)
// У кого рыба?
.And(Member(List(owner, "fish", _, _, _), houses))
// Выводим владельца рыбы.
.And(WriteLine(() => owner))
// Выводим полное решение.
.And(WriteLine(() => houses))
.Count();
```
Результат работы программы:
> german
>
> ((norwegian, cat, dunhill, water, yellow), (dane, horse, marlboro, tea, blue), (englishman, bird, pallmall, milk, red), (german, fish, rothmans, coffee, green), (swede, dog, winfield, beer, white))
>
>
Количество строк кода примерно тоже, что и в решении на Прологе.
Что же происходит под капотом? В данном решении я воспользовался библиотекой [YieldProlog](http://yieldprolog.sourceforge.net/), которая позволяет производить унификацию параметров и поиск с возвратом. Здесь не происходит какой-либо промежуточной компиляции Пролог программы. Это честное решение на C#.
Унификация параметров происходит с помощью функции YP.unify(arg1, arg2). Это основная функция, можно сказать, ядро всего решения. Реализация достаточно простая, но лучше, чем про нее написано в документации, я все равно не напишу. А сама документация небольшая. Поэтому отсылаю к ней.
Первой строкой решения как раз и происходит связывание переменной houses со списком несвязанных переменных. Для задания списков будем использовать функтор с пятью аргументами, так как в нашей задаче все списки состоят только из пяти элементов. Вот код метода List:
```
public static object List(params object[] list)
{
return Functor.make("", list);
}
```
Здесь Functor – это класс из библиотеки YieldProlog.
Теперь вместо длинной записи Functor.make(new [] {new Variable(), new Variable(), …}) я могу использовать более короткую List(new Variable(), new Variable(), …). А чтобы создание списка выглядело более элегантно добавил свойство:
```
public static Variable _ { get { return new Variable(); } }
```
Тогда список не унифицированных переменных будет записываться так: List(\_, \_, …).
Далее опишу предикаты member(Elem, List), nth1(N, List, Elem), nextto(X, Y, List) и neighbors(X, Y, List). Я специально не стал использовать списки вида [head | tail], а использую обычные массивы, так как у меня нет задачи повторить описание данных предикатов аналогично их описанию на Прологе.
member(Elem, List) будет выглядеть так:
```
public static IEnumerable Member(object elem, object list)
{
foreach (var e in YP.getFunctorArgs(list))
foreach (var l1 in YP.unify(elem, e))
yield return false;
}
```
Здесь все очень просто. В цикле перебираем элементы списка и каждый элемент унифицируем с элементом списка.
Конструкция:
```
foreach (var l1 in YP.unify(elem, e))
yield return false;
```
служит для унификации двух переменных.
nth1(N, List, Elem) превратится в:
```
public static IEnumerable Nth1(object n, object list, object elem)
{
int i = 0;
foreach (var e in YP.getFunctorArgs(list))
{
i++;
foreach (var l1 in YP.unify(elem, e))
foreach (var l2 in YP.unify(i, n))
yield return false;
}
}
```
Здесь мы так же перебираем каждый элемент списка и для каждого элемента проводим его унификацию с параметром elem. Если же параметр у нас уже связан с каким-то значением и это значением совпадает со значением какого-то элемента списка, то проводим унификацию номера этого элемента в списке с параметром n.
nextto(X, Y, List) запишем так:
```
public static IEnumerable Nextto(object x, object y, object list)
{
var nativeList = YP.getFunctorArgs(list);
var e1 = nativeList.FirstOrDefault();
foreach (var e2 in nativeList.Skip(1))
{
foreach(var l1 in YP.unify(x, e1))
foreach(var l2 in YP.unify(y, e2))
yield return false;
e1 = e2;
}
}
```
Перебираем уже не по одному элементу, а по два и проводим унификацию двух соседних элементов списка с параметрами x и y.
neighbors(X, Y, List) реализуем точно так же как в решении на Прологе:
```
public static IEnumerable Neighbors(object x, object y, object list)
{
foreach (var l1 in Nextto(x, y, list))
yield return false;
foreach (var l1 in Nextto(y, x, list))
yield return false;
}
```
Использование итераторов — очень важная часть решения. Они как раз и позволяют делать поиск с возвратом. Если унификация двух переменных успешна, происходит следующий шаг итерации и переход к вложенному циклу, если такой есть. Если унификация не успешна, происходит прерывание данного цикла и переход к следующей итерации внешнего цикла.
В решении данной задачи идут подряд 15 предикатов. В YieldProlog для этого придется записать 15 вложенных циклов:
```
foreach (var l1 in Pred1(...))
foreach (var l2 in Pred2(...))
…
foreach (var l15 in Pred15(...))
yield return false;
```
Это неудобно и некрасиво. Поэтому добавим вспомогательный метод And, который выстраивает цепочки предикатов:
```
public static IEnumerable And(this IEnumerable source, IEnumerable inner)
{
foreach (bool l1 in source)
foreach (bool l2 in inner)
yield return false;
}
```
Это всё. Можно вызывать функцию Einstein:
```
var houses = new Variable();
Einstein(houses);
```
И, ничего не происходит. А все потому, что мы просто построили итератор с помощью yield, но не создали цикл итерации. Можно его создать явно:
```
foreach (var l1 in Einstein(houses))
Console.WriteLine(houses);
```
А можно просто вызвать метод Count, который пройдет по итератору и подсчитает количество итераций.
Кроме того, до того, как запустить наш итератор, мы можем к нашему решению добавлять новые условия:
```
Einstein(houses)
// У кого рыба?
.And(Member(List(owner, "fish", _, _, _), houses))
// Выводим владельца рыбы.
.And(WriteLine(() => owner))
// Выводим полное решение.
.And(WriteLine(() => houses))
.Count();
```
Вспомогательная функция WriteLine:
```
public static IEnumerable WriteLine(Func s)
{
Console.WriteLine(s());
yield return false;
}
```
#### Вместо резюме
Данная статья возникла с вопроса, каким образом в C# можно было бы легко описывать логические задачи. И здесь я привел один из способов. У меня не было цели получить оптимальное решение по производительность или объему памяти. Существуют библиотеки, которые позволяют писать программы на Прологе, компилировать их и подключать в виде библиотек к своему проекту. Мне же захотелось получить решение встроенными средствами C#. Поискав по интернету, нашел библиотеку YieldProlog, которая и решает эту задачу. То есть, я могу описывать логические задачи на привычном мне языке, используя привычный синтаксис. При этом описываю задачу аналогично описанию на Прологе. Да еще и есть возможность использовать типы и возможности C#. Да еще и с возможностью оптимизировать решение по мере необходимости.
Если кому-то интересно, то время работы программы на моем стареньком ноутбуке AMD Turion 1.8ГГц выполняется за 0.1 сек. | https://habr.com/ru/post/248847/ | null | ru | null |
# Топ 10 ошибок в проектах Java за 2020 год
Новый год неумолимо приближается — а, значит, настало время подводить итоги. Продолжая традицию, мы прошлись по нашим статьям о проверках Java-проектов из мира open-source за этот год и составили рейтинг 10 самых интересных ошибок.
За уходящий год мы (Java-команда PVS-Studio) разобрали в наших статьях ошибки из пяти open-source проектов и совсем немного рассказали про нашу внутреннюю кухню:
* [АНБ, Ghidra и единороги](https://www.viva64.com/ru/b/0738/)
* [Под капотом PVS-Studio для Java: разработка диагностик](https://www.viva64.com/ru/b/0752/)
* [Проверка кода XMage и почему недоступны специальные редкие карточки для коллекции Dragon's Maze](https://www.viva64.com/ru/b/0758/)
* [Проверка WildFly — сервера JavaEE приложений](https://www.viva64.com/ru/b/0763/)
* [Единороги на страже вашей безопасности: исследуем код Bouncy Castle](https://www.viva64.com/ru/b/0775/)
* [Big/Bug Data: анализируем исходный код Apache Flink](https://www.viva64.com/ru/b/0781/)
Предлагаем читателю сначала ознакомиться с этими статьями и составить свой личный рейтинг, чтобы потом сравнить его с нашим и сказать, что мы неправы :).
Десятое место: "Обманчивое равенство"
-------------------------------------
Источник: [Big/Bug Data: анализируем исходный код Apache Flink](https://www.viva64.com/ru/b/0781/)
[V6001](https://www.viva64.com/ru/w/v6001/) There are identical sub-expressions 'processedData' to the left and to the right of the '==' operator. CheckpointStatistics.java(229)
```
@Override
public boolean equals(Object o)
{
....
CheckpointStatistics that = (CheckpointStatistics) o;
return id == that.id &&
savepoint == that.savepoint &&
triggerTimestamp == that.triggerTimestamp &&
latestAckTimestamp == that.latestAckTimestamp &&
stateSize == that.stateSize &&
duration == that.duration &&
alignmentBuffered == that.alignmentBuffered &&
processedData == processedData && // <=
persistedData == that.persistedData &&
numSubtasks == that.numSubtasks &&
numAckSubtasks == that.numAckSubtasks &&
status == that.status &&
Objects.equals(checkpointType, that.checkpointType) &&
Objects.equals(
checkpointStatisticsPerTask,
that.checkpointStatisticsPerTask);
}
```
Простая и очень обидная ошибка из-за невнимательности: поле *processedData* сравнивается с самим собой. Из-за этой ошибки сравнение объектов типа *CheckpointStatistics* иногда будет выдавать ложноположительный результат. Но основная опасность этой опечатки состоит в том, что *equals* крайне активно используется в коллекциях, и некорректная реализация этого метода может привести к очень странному поведению, на отладку которого уйдёт огромное количество времени.
Хочу заметить, что ошибаться в функциях сравнения для разработчиков привычное дело. Мой коллега даже написал большую статью "[Зло живет в функциях сравнения](https://www.viva64.com/ru/b/0509/)" с множеством примеров и объяснений.
Девятое место: "Недостижимый код"
---------------------------------
Источник: [Единороги на страже вашей безопасности: исследуем код Bouncy Castle](https://www.viva64.com/ru/b/0775/).
[V6019](https://www.viva64.com/ru/w/v6019/) Unreachable code detected. It is possible that an error is present. XMSSTest.java(170)
```
public void testSignSHA256CompleteEvenHeight2() {
....
int height = 10;
....
for (int i = 0; i < (1 << height); i++) {
byte[] signature = xmss.sign(new byte[1024]);
switch (i) {
case 0x005b:
assertEquals(signatures[0], Hex.toHexString(signature));
break;
case 0x0822:
assertEquals(signatures[1], Hex.toHexString(signature));
break;
....
}
}
}
```
Ветвь *switch* для значения *i == 0x0822(2082)* оказалась недостижимой. Как же так получилось?
Если обратить внимание на условие цикла *1 << height*, где *height* всегда равен 10*,* то всё сразу встанет на свои места. Согласно условию цикла, счётчик *i* в цикле *for* не может быть больше, чем 1024 (1 << 10). Естественно, выполнение рассматриваемой ветви *switch* никогда не произойдет.
Восьмое место: "Проаннотированный метод"
----------------------------------------
Источник: [Под капотом PVS-Studio для Java: разработка диагностик](https://www.viva64.com/ru/b/0752/).
[V6009](https://www.viva64.com/ru/w/v6009/) Collection is empty. The call of the 'clear' function is senseless. MetricRepositoryRule.java(90)
```
protected void after()
{
this.metricsById.clear();
this.metricsById.clear();
}
```
Часть наших диагностик сильно полагается на механизм аннотирования методов. Аннотации предоставляют дополнительную информацию анализатору об используемых методах, например:
* Чистый ли это метод,
* Какие накладываются ограничения на аргументы,
* Возвращаемый результат,
* … и всякое прочее.
Некоторые аннотации анализатор выводит сам из исходного кода, некоторые мы проставляем вручную (например, для методов стандартной библиотеки). История этой ошибки началась с того, что мы не в полной мере проаннотировали метод Map#clear. После того, как мы это заметили и исправили, на наших тестовых проектах повылезали новые срабатывания, среди которых был и наш интересный случай.
На первый взгляд, повторная очистка словаря – не ошибка. И мы бы даже решили, что это случайно продублированная строка, если бы не обратили внимание на поля класса:
```
private final Map metricsByKey = new HashMap<>();
private final Map metricsById = new HashMap<>();
```
У класса есть два поля с похожими именами *metricsById* и *metricsByKey*. Это и наталкивает на мысль, что автор кода хотел очистить оба словаря, но… этого не произошло. Таким образом, два словаря, которые хранят связанные данные, будут рассинхронизированы после вызова *after*.
Седьмое место: "Ожидание / реальность"
--------------------------------------
Источник: [Проверка WildFly — сервера JavaEE приложений](https://www.viva64.com/ru/b/0763/).
[V6058](https://www.viva64.com/ru/w/v6058/) The 'equals' function compares objects of incompatible types: String, ModelNode. JaxrsIntegrationProcessor.java(563)
```
// Send value to RESTEasy only if it's not null, empty string, or the
// default value.
private boolean isTransmittable(AttributeDefinition attribute,
ModelNode modelNode) {
if (modelNode == null || ModelType
.UNDEFINED.equals(modelNode.getType())) {
return false;
}
String value = modelNode.asString();
if ("".equals(value.trim())) {
return false;
}
return !value.equals(attribute.getDefaultValue()); // <=
}
```
Обратив внимание на предшествующий методу комментарий, можно ожидать, что метод вернет *true,* если:
* *modelNode* не *null,*
* строковое представление *modelNode* не пустое,
* *modelNode* – не значение по умолчанию.
Несмотря на авторский комментарий и корректную, на первый взгляд, логику, поведение метода будет отличаться. Причиной этому служит проверка *modelNode* на равенство со значением по умолчанию в последней строчке метода.
Строковое представление *modelNode* сравнивается с объектом типа *ModelNode*, и, как можно догадаться, такое сравнение всегда будет возвращать отрицательный результат из-за несовместимости типов.
Последствия ошибки: непредвиденное разрешение к отправке значения *modelNode,* когда оно равно значению по умолчанию (*attribute.getDefaultValue()*).
Шестое место: "Копипаст-ориентированное программирование"
---------------------------------------------------------
Источник: [Проверка кода XMage и почему недоступны специальные редкие карточки для коллекции Dragon's Maze](https://www.viva64.com/ru/b/0758/).
[V6072](https://www.viva64.com/ru/w/v6072/) Two similar code fragments were found. Perhaps, this is a typo and 'playerB' variable should be used instead of 'playerA'. SubTypeChangingEffectsTest.java(162), SubTypeChangingEffectsTest.java(158), SubTypeChangingEffectsTest.java(156), SubTypeChangingEffectsTest.java(160)
```
@Test
public void testArcaneAdaptationGiveType() {
addCard(Zone.HAND, playerA, "Arcane Adaptation", 1);
addCard(Zone.BATTLEFIELD, playerA, "Island", 3);
addCard(Zone.HAND, playerA, "Silvercoat Lion");
addCard(Zone.BATTLEFIELD, playerA, "Silvercoat Lion");
addCard(Zone.GRAVEYARD, playerA, "Silvercoat Lion"); // <=
addCard(Zone.HAND, playerB, "Silvercoat Lion");
addCard(Zone.BATTLEFIELD, playerB, "Silvercoat Lion");
addCard(Zone.GRAVEYARD, playerA, "Silvercoat Lion"); // <=
....
for (Card card : playerB.getGraveyard().getCards(currentGame)) {
if (card.isCreature()) {
Assert.assertEquals(card.getName() + " should not have ORC type",
false, card.getSubtype(currentGame).contains(SubType.ORC));
Assert.assertEquals(card.getName() + " should have CAT type",
true, card.getSubtype(currentGame).contains(SubType.CAT));
}
}
}
```
В этом году, как и в прошлом ([Топ 10 ошибок за 2019](https://www.viva64.com/ru/b/0699/)), классная copy-paste ошибка от диагностического правила V6072 заслуживает место в десятке.
Характер ошибки заключается в том, что когда разработчику нужно сделать схожие действия для различных переменных, то он копирует добросовестно написанный ранее код и изменяет название переменной. Но делает это уже не совсем добросовестно и забывает доизменить переменные.
В данном фрагменте кода так и произошло. Автор теста имитировал игру между игроками, раскидывая между ними одинаковые карты по игровым зонам, но из-за copy-paste игроку *playerA* дважды досталась одна и та же карта. Из-за этого игровая зона *Zone.GRAVEYARD* игрока *playerB* осталась без тестирования. Подробное описание ошибки можно почитать в самой статье.
Пятое место: "Ненормальное распределение"
-----------------------------------------
Источник: [Big/Bug Data: анализируем исходный код Apache Flink](https://www.viva64.com/ru/b/0781/)
[V6048](https://www.viva64.com/ru/w/v6048/) This expression can be simplified. Operand 'index' in the operation equals 0. CollectionUtil.java(76)
```
public static
Collection> partition(Collection elements, int numBuckets)
{
Map> buckets = new HashMap<>(numBuckets);
int initialCapacity = elements.size() / numBuckets;
int index = 0;
for (T element : elements)
{
int bucket = index % numBuckets; // <=
buckets.computeIfAbsent(bucket,
key -> new ArrayList<>(initialCapacity))
.add(element);
}
return buckets.values();
}
```
Ошибка была обнаружена в утилитном методе *partition*, который разбивает переданную коллекцию *elements* на *numBuckets* коллекций. Суть ошибки в том, что индекс коллекции *bucket*, в которую хотят поместить каждый рассматриваемый элемент, имеет константное значение (0). Причиной этому служит то, что разработчик забыл инкрементировать переменную *index* на каждой итерации цикла.
Вследствие чего метод *partition* будет всегда возвращать коллекцию *elements*, обернутую в другую коллекцию. А это – вряд ли задуманное поведение.
Четвертое место: "Бомба замедленного действия"
----------------------------------------------
Источник: [АНБ, Ghidra и единороги](https://www.viva64.com/ru/b/0738/).
[V6008](https://www.viva64.com/ru/w/v6008/) Null dereference of 'selectedNode' in function 'setViewPanel'. OptionsPanel.java(266)
```
private void processSelection(OptionsTreeNode selectedNode) {
if (selectedNode == null) {
setViewPanel(defaultPanel, selectedNode); // <=
return;
}
....
}
private void setViewPanel(JComponent component, OptionsTreeNode selectedNode) {
....
setHelpLocation(component, selectedNode);
....
}
private void setHelpLocation(JComponent component, OptionsTreeNode node) {
Options options = node.getOptions();
....
}
```
В приведенном фрагменте кода явно напортачили. Если вы проследите за *selectedNode* из *processSelection()*, когда *selectedNode == null*, то сразу же обнаружите, что при таком исходе нас ждет неминуемый *NullPointerException*. О чем и предупреждает нас анализатор.
Но, изучив немного код, автор статьи пришел к выводу, что выполнение программы никогда не встретится с *NullPointerException,* так как *processSelection*() вызывается всего в двух местах, перед вызовом которых *selectedNode* явно проверяется на *null.*
Несмотря на это, такой код – бомба замедленного действия, поскольку другой разработчик может увидеть, что метод явно обрабатывает случай *selectedNode == null*, и решить, что это валидное значение, что потом выльется в падение приложения.
Третье место: "Всегда false"
----------------------------
Источник: [Проверка кода XMage и почему недоступны специальные редкие карточки для коллекции Dragon's Maze](https://www.viva64.com/ru/b/0758/).
[V6007](https://www.viva64.com/ru/w/v6007/) Expression 'filter.getMessage().toLowerCase(Locale.ENGLISH).startsWith("Each ")' is always false. SetPowerToughnessAllEffect.java(107)
```
@Override
public String getText(Mode mode) {
StringBuilder sb = new StringBuilder();
....
if (filter.getMessage().toLowerCase(Locale.ENGLISH).startsWith("Each ")) {
sb.append(" has base power and toughness ");
} else {
sb.append(" have base power and toughness ");
}
....
return sb.toString();
}
```
Кто же сравнивает строку, приведенную в нижний регистр, со строкой, которая начинается с заглавной буквы? Отсюда и всегда ложный результат проверки сообщения.
Результат дефекта не критический, но тоже неприятный: где-то будет фигурировать неграмотно составленный текст.
Второе место: "2-в-1"
---------------------
Источник: [АНБ, Ghidra и единороги](https://www.viva64.com/ru/b/0738/).
[V6007](https://www.viva64.com/ru/w/v6007/) Expression 'index >= 0' is always true. ExternalNamesTableModel.java(105)
[V6019](https://www.viva64.com/ru/w/v6019/) Unreachable code detected. It is possible that an error is present. ExternalNamesTableModel.java(109)
```
public void setValueAt(Object aValue, int row, int column) {
....
int index = indexOf(newName);
if (index >= 0) { // <=
Window window = tool.getActiveWindow();
Msg.showInfo(getClass(), window, "Duplicate Name",
"Name already exists: " + newName);
return;
}
ExternalPath path = paths.get(row); // <=
....
}
private int indexOf(String name) {
for (int i = 0; i < paths.size(); i++) {
ExternalPath path = paths.get(i);
if (path.getName().equals(name)) {
return i;
}
}
return 0;
}
```
Метод *indexOf* всегда возвращает неотрицательное число. А всё из-за того, что автор метода в случае отсутствия искомого *newName* по ошибке возвращает 0, а не -1. Такая ошибка приводит к тому, что поток выполнения программы всегда будет заходить в then-ветку условного оператора *if (index >= 0)*, в котором будет выдавать сообщение о существующем *newName* и успешно выходить из метода, даже тогда, когда в реальности *newName* не был найден.
Но и это ещё не всё. Так как then-ветка условного оператора прекращает выполнение метода, то до кода после условного оператора дело так и не дойдет.
Об этом и предупреждает нас анализатор.
Первое место: "А то ли мы проверили?"
-------------------------------------
Источник: [Под капотом PVS-Studio для Java: разработка диагностик](https://www.viva64.com/ru/b/0752/).
[V6080](https://www.viva64.com/ru/w/v6080/) Consider checking for misprints. It's possible that an assigned variable should be checked in the next condition. Menu.java(40)
```
public class Menu
{
private Map> menus = new HashMap>();
public void putMenuItem(String menu, String item)
{
List items = menus.get(menu);
if (item == null) // <=
{
items = new ArrayList();
menus.put(menu, items);
}
items.add(item);
}
....
}
```
По задумке автора предполагалось создать коллекцию по ключу *menu*, если таковой ещё не было. Но проверка не той переменной разрушила всю задумку, прорубив лазеечку для *NullPointerException.* Метод выбросит исключение, когда в словаре ключ *menu* будет отсутствовать, и значение *item*, которое хотели добавить, не будет *null*.
Заключение
----------
Проверки open-source проектов с помощью PVS-Studio из года в год доказывают, что такой рубеж защиты, как статический анализ кода, должен обязательно присутствовать в разработке. Каким бы вы мастером своего дела ни были, ошибки обязательно найдут лазеечку в ваш проект, и причин этому множество: устали, завал на работе или вовсе отвлеклись на котиков. А если вы работаете в команде, то количество возможностей попасть ошибкам в код вырастает пропорционально количеству коллег.
Если вам понравился наш обзор, то не ждите следующего конца года. Статьи о проверках начнутся сразу же с первого месяца 2021, а если вам не терпится – смелее [скачивайте](https://www.viva64.com/ru/pvs-studio-download/) анализатор и самостоятельно проверяйте open-source проекты.
[](https://habr.com/en/company/pvs-studio/blog/535376/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Maxim Stefanov. [Top-10 Bugs in Java Projects in 2020](https://habr.com/en/company/pvs-studio/blog/535376/). | https://habr.com/ru/post/535380/ | null | ru | null |
# Маршрутизация в Mac OS при VPN подключении
Появилась как-то задача подключатся по VPN к рабочей сети, чтобы иметь доступ к внутренним ресурсам.
Средствами Мака это можно сделать создав VPN подключение и 2 варианта:
1. поставить галочку «Слать весь трафик через VPN подключение»
2. статически прописать статически route add -net 192.168.10.0/24 192.168.44.1, где 192.168.10.0/24 — сеть в которой находятся компьютеры на работе, 192.168.44.1 VPN шлюз к которому я подключаюсб.
Итак после каждого подключения нужно делать вторую манипуляцию, так как общий доступ в интернет ограничен и скорость не ахты. Или задача состоит в том чтобы ходить на сайты (например youtube) через более быстрый канал VPN…
Итак задачу я решил следующим образом:
создал скрипт: `touch /etc/ppp/ip-up`
дал ему прав на исполнение: `chmod +x /etc/ppp/ip-up`
создал файл для логов: `touch /tmp/ppp.log`
Содержимое скрипта:
`#!/bin/sh
VPNWORK="192.168.44.1"; #обьявляем переменную (например по названию VPN подключения)
if [ $IPREMOTE = $VPNWORK ] #проверяем, если совпадает добавляем маршрут
then
/sbin/route -n add -net 192.168.10.0/24 $IPREMOTE > /tmp/ppp.log 2>&1
fi`
Таким образом после подключения к сети добавляется маршрут, и нет необходимости добавлять его вручную, так-же при отключении от VPN он удаляется сам.
При необходимости добавлять DNS сервер можно дописать текст между then и fi:
`echo "nameserver 4.2.2.1" > /etc/resolv.conf`
Вместо 4.2.2.1 укажите свой основной DNS и второй записью рабочий.
Но при этом после отключения нам надо вернуть предыдущий DNS конфиг на место, для этого создаем: `touch /etc/ppp/ip-down && chmod +x /etc/ppp/ip-down`
Перед началом работы делаем бекап:
`cp /etc/resolv.conf /etc/resolv.conf_original`
и добавляем в скрипт /etc/ppp/ip-down:
`#!/bin/sh
cat /etc/resolv.conf_original > /etc/resolv.conf`
Собственно всё. При каждом подключении VPN прописывается маршрут, работаете сколько надо, после отключения удаляется, при этом у вас не будет загвоздок с DNS. | https://habr.com/ru/post/88946/ | null | ru | null |
# Simulating Return Type Inference in C#
Мне по-настоящему нравится больше чего-либо в разработке ПО делать фреймворки, позволяющие другим разработчикам создавать что-то крутое. Иногда, в погоне за идеальным кодом, мне на ум приходят странные идеи, при реализации которых C# может дойти до предела своих возможностей.
Не так давно произошёл подобный случай, когда мы вместе с коллегой искали способ избежать передачи большого количества типовых параметров в тех местах, где компилятор должен был по идее их вывести. Однако, C# так устроен, что способен выводить типы в обобщённых вызовах только из передаваемых параметров метода.
В этой статье покажу небольшой трюк, который позволит симулировать вывод типов для возвращаемых значений, и немного примеров, где это может быть полезно.
---
Вывод типов
-----------
Вывод типов это способность компилятора автоматически распознавать тип выражения без его явного указания. Эта особенность работает через анализ контекста, в котором вычисляется выражение, учитывая ограничения, накладываемые окружающим потоком данных в программе.
Способность автоматически распознавать тип позволяет программистам на этом языке писать лаконичный код, пользуясь всеми преимуществами статической типизации. Поэтому, большинство популярных языков имеют в той или иной форме вывод типов.
C# относится к их числу. Простейший пример, демонстрирующий это, ключевое слово `var`:
```
var x = 5; // int
var y = "foo"; // string
var z = 2 + 1.0; // double
var g = Guid.NewGuid(); // Guid
```
При использовании ключевого слова var в рамках объявления, совмещённого с присваиванием, не требуется указывать тип переменной. Компилятор способен определить его самостоятельно на основе выражения справа.
В том же духе, C# позволяет инициализировать массив без нужды в явном указании типа:
```
var array = new[] {"Hello", "world"}; // string[]
```
Здесь компилятор видит, что инициализируется массив с двумя строковыми элементами, из чего он может спокойно сделать вывод о том, что результирующий тип переменной `string[]`. В некоторых особых случаях, он даже может вывести тип, основываясь на наиболее общем типе среди элементов:
```
var array = new[] {1, 2, 3.0}; // double[]
```
Всё же, самый интересный аспект вывода типов в C# это, конечно, обобщённые методы. При вызове такого метода можно пренебречь типовыми аргументами, поскольку они могут быть выведены из значений, передаваемых в параметры метода.
Например, можно определить обобщённый метод `List.Create`, который создаёт список из последовательности элементов:
```
public static class List
{
public static List Create(params T[] items) => new List(items);
}
```
Который можно использовать следующим образом:
```
var list = List.Create(1, 3, 5); // List
```
В примере выше можно было бы написать явно `List.Create(...)`, но в этом не было необходимости. Компилятор на основе параметров, переданных в метод, самостоятельно определил тип, от которого также зависит возвращаемое значение.
Достаточно интересно, что все примеры выше основаны на одной форме вывода типов, которая работает за счёт анализа ограничений, наложенных другими выражениями, тип которых уже известен. Другими словами, исследуется *входящий* поток данных и формируются выводы об *исходящем*.
Однако, также существуют сценарии, где мы хотим иметь вывод типов в обратном направлении. Посмотрим, где это может быть полезно.
Тип Option
----------
Если раньше вам приходилось писать код в функциональном стиле, то, скорее всего, вы очень близко знакомы с типом `Option`. Это контейнер, содержащий значение вместе с фактом его наличия и позволяющий выполнять операции над ним без необходимости в наблюдении за состоянием.
В C# такой тип обычно определяют двумя полями - значением некого типа и флагом, указывающим на наличие этого значения. Это можно представить следующим образом:
```
public readonly struct Option
{
private readonly T \_value;
private readonly bool \_hasValue;
private Option(T value, bool hasValue)
{
\_value = value;
\_hasValue = hasValue;
}
public Option(T value)
: this(value, true)
{
}
public TOut Match(Func some, Func none) =>
\_hasValue ? some(\_value) : none();
public void Match(Action some, Action none)
{
if (\_hasValue)
some(\_value);
else
none();
}
public Option Select(Func map) =>
\_hasValue ? new Option(map(\_value)) : new Option();
public Option Bind(Func> bind) =>
\_hasValue ? bind(\_value) : new Option();
}
```
Этот API достаточно прост. Реализация выше скрывает значение от его потребителей, оставляя на поверхности только метод `Match(...)`, который обрабатывает оба возможных состояния контейнера. Есть дополнительные методы `Select(...)` и `Bind(...)`, которые используются для безопасных превращений значения вне зависимости от того, есть оно или нет.
Также, в этом примере, `Option` объявлен как `readonly struct`. Учитывая, что в дальнейшем объекты этого типа будут либо возвращаться из методов, либо использоваться в локальных областях видимости, решение о таком объявлении было принято из соображений производительности.
Чтобы сделать использование типа удобнее, можно предоставить фабричные методы, которые помогут гибче создавать инстансы `Option`:
```
public static class Option
{
public static Option Some(T value) => new Option(value);
public static Option None() => new Option();
}
```
Пример использования:
```
public static Option Parse(string number)
{
return int.TryParse(number, out var value)
? Option.Some(value)
: Option.None();
}
```
Видно, что в случае вызова `Option.Some(...)` можно опустить типовой параметр, потому что компилятор может его вывести на основе типа `value`, который является `int`. С другой стороны, такой же подход не работает с методом `Option.None(...)`, потому что у него нет никаких параметров. В результате, нужно указывать тип вручную.
Несмотря на то, что типовой параметр для `Option.None(...)`, кажется очевидным из контекста, компилятор не способен его вывести. Потому что, как говорилось ранее, вывод типов в C# работает только за счёт анализа входящего потока данных, но никак не наоборот.
Конечно, в идеале, хотелось бы, чтобы компилятор сам выяснил тип `T` в `Option.None(..)`, основываясь на *возвращаемом* типе выражения, который оно *должно* иметь согласно сигнатуре метода. Иначе, хотелось бы получить тип `T`, как ветвь тернарного оператора, исходя из типа `value`.
К несчастью, ни тот, ни другой сценарий невозможны в C#, потому что тогда системе типов пришлось бы работать с анализом исходящего потока данных, что она не умеет. Однако, можно ей помочь.
Можно симулировать *return type inference*, заставив `Option.None` вернуть специальное значение не обобщённого типа, которое могло быть приведено к `Option`. Приблизительно так это могло бы выглядеть:
```
public readonly struct Option
{
private readonly T \_value;
private readonly bool \_hasValue;
private Option(T value, bool hasValue)
{
\_value = value;
\_hasValue = hasValue;
}
public Option(T value)
: this(value, true)
{
}
// ...
public static implicit operator Option(NoneOption none) => new Option();
}
public readonly struct NoneOption
{
}
public static class Option
{
public static Option Some(T value) => new Option(value);
public static NoneOption None { get; } = new NoneOption();
}
```
Как вы можете видеть, `Option.None` возвращает пустышку типа `NoneOption`, которая моделирует пустой контейнер, соответственно, и не важно какого типа. Тип `NoneOption` не обобщённый, поэтому можно типовые параметры опустить и превратить `Option.None` в свойство.
Также, в `Option` теперь есть неявное преобразование из `NoneOption`. Хоть операторы и не могут быть обобщёнными в C#, они всё ещё могут использовать типовые параметры, объявленные в типе, содержащем оператор. Это позволяет определить преобразования ко всем возможным вариациям `Option`.
Всё это позволяет использовать `Option.None` так, как планировалось изначально. С точки зрения разработчика выглядит так, будто в языке появился return type inference:
```
public static Option Parse(string number)
{
return int.TryParse(number, out var value)
? Option.Some(value)
: Option.None;
}
```
Тип Result
----------
Те же схемы, применённые к Option, можно натянуть на тип `Result`. Этот тип выполняет тоже назначение, за исключением того, что предоставляет целое значение для обработки негативных сценариев.
Таким образом можно было бы его реализовать:
```
public readonly struct Result
{
private readonly TOk \_ok;
private readonly TError \_error;
private readonly bool \_isError;
private Result(TOk ok, TError error, bool isError)
{
\_ok = ok;
\_error = error;
\_isError = isError;
}
public Result(TOk ok)
: this(ok, default, false)
{
}
public Result(TError error)
: this(default, error, true)
{
}
// ...
}
public static class Result
{
public static Result Ok(TOk ok) =>
new Result(ok);
public static Result Error(TError error) =>
new Result(error);
}
```
А вот так использовать:
```
public static Result Parse(string input)
{
return int.TryParse(input, out var value)
? Result.Ok(value)
: Result.Error("Invalid value");
}
```
Здесь ситуация с выводом типов и вовсе внушает ужас. Ни `Result.Ok(...)`, ни `Result.Error(...)` не имеют достаточно аргументов, чтобы вывести типовые параметры. Поэтому, мы вынуждены явно их указывать в обоих случаях.
Необходимость явно писать эти типы влечёт за собой визуальный шум, дублирование кода и в целом плохие практики разработки. Попробуем исправить это, используя те же методики, что и раньше:
```
public readonly struct Result
{
private readonly TOk \_ok;
private readonly TError \_error;
private readonly bool \_isError;
private Result(TOk ok, TError error, bool isError)
{
\_ok = ok;
\_error = error;
\_isError = isError;
}
public Result(TOk ok)
: this(ok, default, false)
{
}
public Result(TError error)
: this(default, error, true)
{
}
public static implicit operator Result(DelayedResult ok) =>
new Result(ok.Value);
public static implicit operator Result(DelayedResult error) =>
new Result(error.Value);
}
public readonly struct DelayedResult
{
public T Value { get; }
public DelayedResult(T value)
{
Value = value;
}
}
public static class Result
{
public static DelayedResult Ok(TOk ok) =>
new DelayedResult(ok);
public static DelayedResult Error(TError error) =>
new DelayedResult(error);
}
```
Похожим образом определили тип `DelayedResult`, моделирующий инициализацию `Result`. Опять же, используется неявное приведение типов для перехода от отложенной инициализации к желаемому контейнеру.
Всё сделанное позволяет переписать код следующим образом:
```
public static Result Parse(string input)
{
return int.TryParse(input, out var value)
? (Result) Result.Ok(value)
: Result.Error("Invalid value");
}
```
Чуть лучше, но не идеально. Проблема в том, что тернарный оператор в C# не приводит ветви к "общему знаменателю". Из-за этого приходится явно кастить к `Result` ветвь "истины". ***(до C# 9)***
Однако, такого поведения можно избежать если использовать классическое условное выражение:
```
public static Result Parse(string input)
{
if (int.TryParse(input, out var value))
return Result.Ok(value);
return Result.Error("Invalid value");
}
```
Такая конфигурация более удовлетворительна. Можно полностью опустить типовые параметры, не изменяя сигнатуры и пользуясь типобезопасностью. И снова создаётся иллюзия того, что эти параметры выводятся на основе ожидаемого возвращаемого типа.
При этом, вы могли заметить баг в текущей реализации. Если `TOk` и `TError` будут одинаковыми, то возникнет неоднозначность: какой именно вариант `DelayedResult` использовать.
Представим, в качестве примера, такой сценарий с использованием нашего типа:
```
public interface ITranslationService
{
Task IsLanguageSupportedAsync(string language);
Task TranslateAsync(string text, string targetLanguage);
}
public class Translator
{
private readonly ITranslationService \_translationService;
public Translator(ITranslationService translationService)
{
\_translationService = translationService;
}
public async Task> TranslateAsync(string text, string language)
{
if (!await \_translationService.IsLanguageSupportedAsync(language))
return Result.Error($"Language {language} is not supported");
var translated = await \_translationService.TranslateAsync(text, language);
return Result.Ok(translated);
}
}
```
Здесь `Result.Error(...)` и `Result.Ok(...)` оба возвращают DelayedResult. Так что компилятор затрудняется выяснить, что с этим делать:
```
Cannot convert expression type 'DelayedResult' to return type 'Result'
```
К счастью, исправить это просто - надо только каждое состояние представить отдельным типом:
```
public readonly struct Result
{
private readonly TOk \_ok;
private readonly TError \_error;
private readonly bool \_isError;
private Result(TOk ok, TError error, bool isError)
{
\_ok = ok;
\_error = error;
\_isError = isError;
}
public Result(TOk ok)
: this(ok, default, false)
{
}
public Result(TError error)
: this(default, error, true)
{
}
public static implicit operator Result(DelayedOk ok) =>
new Result(ok.Value);
public static implicit operator Result(DelayedError error) =>
new Result(error.Value);
}
public readonly struct DelayedOk
{
public T Value { get; }
public DelayedOk(T value)
{
Value = value;
}
}
public readonly struct DelayedError
{
public T Value { get; }
public DelayedError(T value)
{
Value = value;
}
}
public static class Result
{
public static DelayedOk Ok(TOk ok) =>
new DelayedOk(ok);
public static DelayedError Error(TError error) =>
new DelayedError(error);
}
```
Вернувшись к коду, написанному ранее, увидим, что он работает, как того и требовалось:
```
public class Translator
{
private readonly ITranslationService _translationService;
public Translator(ITranslationService translationService)
{
_translationService = translationService;
}
public async Task> TranslateAsync(string text, string language)
{
if (!await \_translationService.IsLanguageSupportedAsync(language))
return Result.Error($"Language {language} is not supported");
var translated = await \_translationService.TranslateAsync(text, language);
return Result.Ok(translated);
}
}
```
Вывод
-----
Хоть у вывода типов в C# и есть ограничения, язык можно заставить их немного отодвинуть с помощью неявного преобразования типов. Используя простой трюк, показанный в статье, можно симулировать return type inference, попутно открывая потенциально интересные архитектурные возможности.
---
Ещё я веду telegram канал [StepOne](https://t.me/steponeit), где оставляю небольшие заметки про разработку и мир IT. | https://habr.com/ru/post/673448/ | null | ru | null |
# Продолжаем парсить RSS теперь уже kinozal'a используя grep, wget/curl
В моем [предыдущем посте](http://labinskiy.habrahabr.ru/blog/87042/) про автоматизацию загрузок новых эпизодов с **RSS** ленты [LostFilm](http://www.lostfilm.tv/)'а хабраюзер [AmoN](https://habrahabr.ru/users/amon/) поднял правильный [вопрос](http://labinskiy.habrahabr.ru/blog/87042/#comment_2604898) о невозможности описанным мною способом загрузки раздач, прямых ссылок на torrent файл которых в **RSS** ленте не содержится. В качестве примера был приведен трекер [кинозал.тв](http://kinozal.tv/). Именно решению этого вопроса посвящен сей пост ;)
##### Вместо введения
Перескажу вкратце суть прошлого поста. Многие популярные torrent клиенты позволяют в своих настройках задать папки слежения, анализируя которые на появление новых файлов, автоматически начинают закачки. Написанный ранее shell скрипт периодически просматривает RSS ленту трекера, выбирает интересующие нас раздачи, и загружает их torrent файлы в папку слежения.
##### Что в имени тебе моем?
В основе выборки и фильтрации RSS ленты прошлого способа лежал анализ регулярным выражением ссылки на torrent файл. К примеру, даже мельком взглянув на ссылку вида `http://www.lostfilm.tv/download.php/2035/Lost.s06e07.rus.PROPER.LostFilm.TV.torrent`
сразу же видно что это за сериал, сезон и эпизод. Однако, как верно заметил [AmoN](https://habrahabr.ru/users/amon/), далеко не во всех трекерах RSS ленты содержат прямые ссылки на torrent файлы что несколько затрудняет нашу задачу по автоматизации загрузок. Именно эта особенность и стала причиной сего поста :)
##### Нусс, приступим
Для начала, я внимательно взглянул на формат подопытной RSS ленты. И вот что увидел:
`The 3 Great Tenors - VA / Classic / 2002 / MP3 / 320 kbps
Раздел: Музыка - Буржуйская
http://kinozal.tv/details.php?id=546381`
а именно: ссылка не только не содержит в себе имени раздачи, но и не является прямой ссылкой на torrent файл. Ну что ж, значит для того, чтобы получить сам torrent файл нужно последовать по ссылке, и на загруженной странице уже взять прямую ссылку на файл.
##### Вырабатываем план
Немного поразмыслив, я выдумал следующий алгоритм:
1. читаем RSS ленту `http://kinozal.tv/rss.xml` и `grep`'ом выбираем интересующие нас раздачи по описанию:
`curl -s http://kinozal.tv/rss.xml | grep -iA 2 'MP3'`
где "`-s`" — указание «вести себя тихо»,
"`-i`" — регистронезависимый поиск,
"`-A 2`" — указывает grep'у вместе с найденной строкой выводить еще и две следующих за ней (именно в них и содержится интересующая нас ссылка)
2. среди выбранных раздач с помощью `grep`'а оставляем только ссылки:
`grep -ioe 'http.*[0-9]'`
3. открываем цикл по всем найденным ссылкам:
`for i in ... ; do ... ; done`
где на месте списка, используя «волшебные» кавычки ``...`` подставляем два результат наших предыдущих изысканий:
`for i in `curl -s http://kinozal.tv/rss.xml | grep -iA 2 'MP3' | grep -ioe 'http.*[0-9]'`; do ... ; done`
4. в цикле, мы для каждой из ссылок загружаем страничку и, опять же, `grep`'ом вытаскиваем из нее ссылку на torrent файл:
`curl -sb "uid=***; pass=***; countrys=ua" $i | grep -m 1 -ioe 'download.*\.torrent'`
где, "`-b "uid=***; pass=***; countrys=ua"`" — опция для задания передаваемых cookies со сведениями об авторизации,
"`-m 1`" — оставляет только первую из двух прямых ссылок на torrent файл (да, на страничках описания раздач кинозала ссылка на один и тот же файл встречается дважды)
**Обращаю внимание** на то, что ни пароль ни uid **не не передаются в открытом виде**! Их значения можно увидеть открыв окошко просмотра cookies в вашем браузере или же, к примеру, воспользоваться [плагином](https://addons.mozilla.org/ru/firefox/addon/66579) для [FireFox](http://www.firefox.com/).
5. загружаем torrent файлы `wget`'ом:
`wget -nc -qi - -B "http://kinozal.tv/" -P ~/.config/watch_dir --header "Cookie: uid=***; pass=***; countrys=ua"`
где из опций отмечу "`-B "http://kinozal.tv/"`" — задание префикса/домена для загрузки относительных ссылок (а именно таковыми они и являются на страницах описаний раздач кинофильма),
и "`--header "Cookie: uid=***; pass=***; countrys=ua"`" — задание заголовка для **GET** запроса (в этот раз я захотел передать cookies именно таких способом а не через файл:) )
6. переход на начало цикла
##### И что же мы имеем
А в итоге у нас получается вот такая вот "*простенькая*" команда:
`for i in `curl -s http://kinozal.tv/rss.xml | grep -iA 2 'mp3' | grep -ioe 'http.*[0-9]'`; do curl -sb "uid=***; pass=***; countrys=ua" $i | grep -m 1 -ioe 'download.*\.torrent' | wget -nc -qi - -B "http://kinozal.tv/" -P ~/.config/watch_dir --header "Cookie: uid=***; pass=***; countrys=ua"; done`
И для полного счастья, эту команду стоит прописать в `cron`:
`*/15 * * * * наша команда > /dev/null 2>&1`
##### За сим все, разрешите откланяться :)
**UPD**. В комментариях к моему предыдущему [посту](http://habrahabr.ru/blogs/p2p/87042/) из этой серии было сделано несколько интересных предложений по оптимизации нагрузки на сервер:
[habrahabr.ru/blogs/p2p/87042/#comment\_2609116](http://habrahabr.ru/blogs/p2p/87042/#comment_2609116) (проверка на существования файлов)
[habrahabr.ru/blogs/p2p/87042/#comment\_2609714](http://habrahabr.ru/blogs/p2p/87042/#comment_2609714) (использование Last-Modified и ETag)
**UPD2**. По [совету](http://habrahabr.ru/blogs/p2p/87166/#comment_2612586) [apatrushev](https://habrahabr.ru/users/apatrushev/) заменил "`head -1`" на опцию `grep` "`-m 1`". | https://habr.com/ru/post/87166/ | null | ru | null |
# Полнотекстовый поиск на App Engine уже сейчас
Все конечно с нетерпением ждут, когда в [App Engine](http://appengine.google.com) появится полнотекстовый поиск, но пока его нет даже в [roadmap](http://code.google.com/appengine/docs/roadmap.html). Тем не менее, для GAE/Java полнотекстовый поиск можно прикрутить самостоятельно уже сейчас.
Вы удивитесь, но это [Lucene](http://lucene.apache.org/). Нет-нет, не спешите разочарованно уходить, вздыхая «ну это ж сколько возиться надо». Подружить Lucene с App Engine datastore дело, наверное, не пяти минут, но если вы используете JDO, то за вас это уже сделали разработчики [compass-project](http://compass-project.org/) в разрабатываемом compass 2.3 (сейчас в стадии бета-версии).
Compass умеет превращать ваши JDO объекты в проиндексированные документы и возвращать их в качестве результатов поиска. Код простейшего JDO объекта с индексированием и поиском, и комментарии к интересным местам в нём смотрите ниже. Чтобы это скомпилировалось и заработало, нужно добавить в `war/WEB-INF/lib` несколько библиотек: `lucene-core, commons-logging и compass-2.3.0-beta1`. Они все живут в дистрибутиве ночного билда Compass'а, который закопан глубоко в дебри их continuous build системы. На момент написания, последний успешный билд живёт тут: <http://build.compass-project.org/download/CMPTRK-NIGHTLY/artifacts/build-786/Release>. Признаюсь что я не проверял работоспособность конкретно этого билда.
> `@PersistenceCapable(identityType = IdentityType.APPLICATION)
>
> @Searchable // [1]
>
> public class GreetingServiceUser {
>
> @PrimaryKey
>
> @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
>
> @SearchableId
>
> private Long id; // [2]
>
>
>
> @Persistent
>
> private String name;
>
>
>
> public GreetingServiceUser(String name) {
>
> this.name = name;
>
> }
>
>
>
> @SearchableProperty // [3]
>
> public String getName() {
>
> return name;
>
> }
>
>
>
> private static final PersistenceManagerFactory factory =
>
> JDOHelper.getPersistenceManagerFactory("transactions-optional");
>
> private static Compass compass;
>
> private static CompassGps compassGps;
>
>
>
> static {
>
> // [4]
>
> compass = new CompassConfiguration()
>
> .setConnection("gae://index")
>
> // [5]
>
> .setSetting(CompassEnvironment.ExecutorManager.EXECUTOR\_MANAGER\_TYPE,
>
> "disabled")
>
> .addScan("compass\_test")
>
> .buildCompass();
>
> compassGps = new SingleCompassGps(compass);
>
> Jdo2GpsDevice jdo2GpsDevice = new Jdo2GpsDevice("appengine", factory);
>
> // [6]
>
> jdo2GpsDevice.setMirrorDataChanges(false);
>
> compassGps.addGpsDevice(jdo2GpsDevice);
>
> // [7]
>
> // if (compass.getSearchEngineIndexManager().isLocked()) {
>
> // compass.getSearchEngineIndexManager().releaseLocks();
>
> // }
>
> compassGps.start();
>
> }
>
>
>
> public void save() {
>
> PersistenceManager pm = factory.getPersistenceManager();
>
> CompassIndexSession indexSession = null;
>
> try {
>
> pm.makePersistent(this);
>
>
>
> // [8]
>
> // compass.getSearchEngineIndexManager().releaseLocks();
>
>
>
> // [9]
>
> indexSession = compass.openIndexSession();
>
> indexSession.save(this);
>
> indexSession.commit();
>
> }
>
> catch (Throwable e) {
>
> e.printStackTrace();
>
> }
>
> finally {
>
> pm.close();
>
> if (indexSession != null) {
>
> indexSession.close();
>
> }
>
> }
>
> }
>
>
>
> public static List search(String query) {
>
> CompassSearchSession searchSession = compass.openSearchSession();
>
>
>
> CompassHits hits = searchSession.find(query);
>
> List results =
>
> new ArrayList(hits.getLength());
>
> PersistenceManager pm = factory.getPersistenceManager();
>
> try {
>
> for (int i=0; i
> // [10]
>
> results.add(pm.getObjectById(
>
> GreetingServiceUser.class,
>
> Long.valueOf(hits.resource(i).getId())));
>
> }
>
> }
>
> catch (JDOObjectNotFoundException e) {
>
> e.printStackTrace();
>
> }
>
> finally {
>
> pm.close();
>
> }
>
> return results;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**[1]** Аннотациями отмечаются JDO классы, подлежащие индексированию…
**[2]**… свойства, идентифицирующие документы,…
**[3]**… и наконец свойства, значения которых будут проиндексированы.
**[4]** При конструировании экземпляра `Compass` вы указываете, какие пакеты надо просканировать в поисках таких аннотаций
**[5]** Это тонкость, специфичная для App Engine. Compass вообще работает в несколько потоков, но на App Engine потоки создавать нельзя, поэтому нужно потоки запретить.
**[6]** Это тоже небольшой хак актуальный для App Engine. Compass вообще-то умеет актуализировать индекс автоматически, когда что-нибудь меняется в интересных ему персистентных данных. Но при работе на App Engine он может не уложиться в отведённые 30 секунд. Вызов `setMirrorDataChanges(false)` отключит автоматическое обновление и обновлять индекс нужно будет вручную. Это не больно, и в качестве компенсации это можно делать, например, в отдельной задаче в task queue.
**[7, 8]** Поддержка App Engine ещё сыровата, и иногда Compass, кажется, забывает снимать блокировки индекса. В причинах и правильном способе исправления я пока не разбирался, но явная просьба отпустить блокировки помогает. Надо, конечно, понимать что это может быть не очень безопасно. Если кто найдёт время проблему отловить и победить, дайте знать.
**[9]** Собственно так объект индексируется вручную.
**[10]** Результатом поиска является коллекция `CompassHits`. Из неё теоретически можно извлечь найденные объекты (`GreetingServiceUser` в нашем случае) методом `data(int)`, но у меня они получались с незаполненными значениями. Поэтому я пользуюсь объектом Resource, который соответствует документу, извлекаю из него id документа и ищу соответствующий JDO объект средствами JDO/AppEngine. | https://habr.com/ru/post/90223/ | null | ru | null |
# HTML 5: Microdata
HTML 5 продолжает удивлять нас своими возможностями. Вот еще одна.
Одной из функций, которые мы добавили в HTML5 является возможность включить аннотации, чтобы люди могли получить данные простым и определенным способом. Это означает, что если ваш сайт хочет сделать информацию доступной, вам не нужно будет надеяться на посторонние несовершенные механизмы получения данных.
Допустим, вы работаете с трекером инцедентов типа [Bugzilla](http://www.bugzilla.org/), и вам нужны дополнительные инструменты для получения информации об инцедентах из базы данных.
Сейчас, Bugzilla создает XML-файл на каждую ошибку, а это означает, что для страницы с ошибкой формируется два параллельных формата данных. Вместо того, чтобы осуществлять такое разделение, вы можете использовать microdata — новые атрибуты HTML5. Таким образом, при отслеживании изменений интерфейса от версии к версии, основные данные об ошибках отображены на этой же HTML-странице.
Разметка выглядит сейчас так:
> `<body>
>
> <h1>Issue 12941: Too many pies in the pie factoryh1>
>
> <dl>
>
> <dt>Reporterdt>
>
> <dd>ian@hixie.chdd>
>
> <dt>Prioritydt>
>
> <dd>AAAdd>
>
> ...`
Для пояснения работы с microdata, мы создаем некоторые атрибуты, а затем присваиваем каждому полю с этими атрибутами значение. Это атрибуты в «reverse-DNS» форме; если существует ошибка на «example.net», то атрибуты будут «net.example.bug», «net.example.number», и так далее. Таким образом, мы получаем:
> `<body item="net.example.bug">
>
> <h1>Issue <span itemprop="net.example.number">12941span>:
>
> <span itemprop="net.example.title">Too many pies in the pie factoryspan>h1>
>
> <dl>
>
> <dt>Reporterdt>
>
> <dd itemprop="net.example.reporter">ian@hixie.chdd>
>
> <dt>Prioritydt>
>
> <dd itemprop="net.example.priority">AAAdd>
>
> ...`
Атрибут *item* = «net.example.bug» указывает: «это ошибка». Различные атрибуты *itemprop* формируют пару имя/значение для ошибки. Фрагмент выше является результатом следующего дерева данных:
> `net.example.bug:
>
> net.example.number = "12941"
>
> net.example.title = "Too many pies in the pie factory"
>
> net.example.reporter = "ian@hixie.ch"
>
> net.example.priority = "AAA"`
Теперь в случае кардинального изменения страницы, теже данные об ошибках однозначно доступны:
> `<body>
>
> <h1>Example.Net Bugs Databaseh1>
>
> <section item="net.example.bug">
>
> <h1 itemprop="net.example.title">Too many pies in the pie factoryspan>h1>
>
> <p>#<span itemprop="net.example.number">12941span>; reported
>
> by <span itemprop="net.example.reporter">ian@hixie.chspan>.p>
>
> <p>PRIORITY: <strong itemprop="net.example.priority">AAAstrong>.p>
>
> ...`
На этом заканчивается краткое введение в microdata! Некоторые будущие статьи опишут несколько аспектов microdata, что я не обсуждал здесь:
• Как описывать URL, дату и время, скрытые данные с использованием microdata.
• Как один элемент сделать внутри другого.
• Как описывать объект более чем одного типа или о том, как дать единое значение для нескольких атрибутов.
• Как определять заранее словари.
• Как добавлять описание вне *item* = "", используя *subject* = "".
##### Дополнительно:
[Microdata Extractor for HTML 5](http://james.html5.org/microdata/)
[Microdata Specification](http://www.whatwg.org/specs/web-apps/current-work/multipage/microdata.html#top-level-microdata-items)
\* This source code was highlighted with [Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).
Особая благодарность [XaocCPS](https://habrahabr.ru/users/xaoccps/) за некоторую корректировку перевода. | https://habr.com/ru/post/66043/ | null | ru | null |
# Стратегии в Moxy (Часть 2)
В [части 1](https://habrahabr.ru/company/redmadrobot/blog/325816/) мы разобрались, для чего нужны стратегии в [Moxy](https://github.com/Arello-Mobile/Moxy) и в каких случаях уместно применять каждую из них. В этой статье мы рассмотрим механизм работы стратегий изнутри, поймем, в каких случаях нам могут понадобиться кастомные стратегии, и попробуем создать свою собственную.
Зачем нужны кастомные стратегии
-------------------------------
Зачем вообще [Moxy](https://github.com/Arello-Mobile/Moxy) поддерживает создание
пользовательских стратегий? При проектировании библиотеки мы (I) старались учесть все возможные случаи, и встроенные стратегии практически на сто процентов их покрывают. Однако в некоторых случаях может потребоваться больше власти над ситуацией, и мы не хотели вас ограничивать. Рассмотрим один из таких случаев.
Презентер отвечает за выбор бизнес-ланча, который состоит из бургера и напитка.
Команды в зависимости от функции у нас делятся на следующие типы:
* кастомизируют бургер (добавить/удалить сыр, выбрать ржаную/пшеничную булку и т.д.);
* кастомизируют напиток (выбрать количество ложек сахара, добавить/удалить лимон и т.д);
* оповещают о том, что заказ отправлен.
Итак, мы хотим уметь отдельно управлять очередями команд для бургера и для напитка. Стратегий по умолчанию для этого не хватит, дополнительно нам нужны бургерные и напиточные! Давайте их изобретем, но для начала разберемся, как вообще устроен механизм применения команд и на что влияют стратегии.
Механика работы команд Moxy
---------------------------
Начнем издалека: в конструкторе презентера создается **ViewState**, все команды проксируются через него. *ViewState* содержит очередь команд — [ViewCommands](https://github.com/Arello-Mobile/Moxy/blob/master/moxy/src/main/java/com/arellomobile/mvp/viewstate/ViewCommands.java) (класс, который отвечает за список команд и стратегий) и список **View**. В списке View может содержаться как несколько View, если вы используете презентер типа **Global** или **Weak**, так и ни одного (в ситуации, когда у вас фрагмент ушел в бэк стэк).
**Global и Weak презентеры**Между нами говоря, не стройте на их основе архитектуру, так как они залезают не в свою зону ответственности. Шарить данные между экранами лучше при помощи общих сущностей типа интеракторов в чистой архитектуре. О чистой архитектуре есть неплохая [статья](https://habrahabr.ru/company/mobileup/blog/335382/)
Для начала разберемся, что же представляет собой стратегия:
**StateStrategy**
```
public interface StateStrategy {
void beforeApply(
List> currentState,
ViewCommand incomingCommand);
void afterApply(
List> currentState,
ViewCommand incomingCommand);
}
```
Это интерфейс с двумя методами: **beforeApply** и **afterApply**. Каждый метод на вход принимает новую команду и текущий список команд, который и будет меняться (или останется без изменений) в теле метода. У каждой команды мы можем получить тэг (это строка, которую можно указать в аннотации [StateStrategyType](https://github.com/Arello-Mobile/Moxy/blob/master/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/StateStrategyType.java)) и тип стратегии (см. листинг ниже). Как именно менять список решаем, опираясь **только** на эту информацию.
**ViewCommand**
```
public abstract class ViewCommand {
private final String mTag;
private final Class extends StateStrategy mStateStrategyType;
protected ViewCommand(
String tag,
Class extends StateStrategy stateStrategyType) {
mTag = tag;
mStateStrategyType = stateStrategyType;
}
public abstract void apply(View view);
public String getTag() {
return mTag;
}
public Class extends StateStrategy getStrategyType() {
return mStateStrategyType;
}
}
```
Давайте поймем, когда у нас будут вызываться данные методы. Итак, у нас есть интерфейс **SimpleBurgerView**, который умеет только добавлять немного сыра(II).
```
interface SimpleBurgerView : BaseView {
@StateStrategyType(value = AddToEndSingleStrategy::class, tag = "Cheese")
fun toggleCheese(enable: Boolean)
}
```
Рассмотрим, что происходит при вызове метода **toggleCheese** у сгенерированного класса **LaunchView$$State** (см. листинг):
**LaunchView$$State**
```
@Override
public void toggleCheese( boolean p0_32355860) {
ToggleCheeseCommand toggleCheeseCommand = new ToggleCheeseCommand(p0_32355860);
mViewCommands.beforeApply(toggleCheeseCommand);
if (mViews == null || mViews.isEmpty()) {
return;
}
for(com.redmadrobot.app.presentation.launch.LaunchView view : mViews) {
view.toggleCheese(p0_32355860);
}
mViewCommands.afterApply(toggleCheeseCommand);
}
```
1) Создается команда ToggleCheeseCommand (см. листинг ниже)
**ToggleCheeseCommand**
```
public class ToggleCheeseCommand extends ViewCommand {
public final boolean enable;
ToggleCheeseCommand( boolean enable) {
super("toggleCheese", com.arellomobile.mvp.viewstate.strategy.AddToEndStrategy.class);
this.enable = enable;
}
@Override
public void apply(com.redmadrobot.app.presentation.launch.SomeView mvpView) {
mvpView.toggleCheese(enable);
}
}
```
2) Вызывается метод **beforeApply** для класса **ViewCommands** для данной команды. В нем мы получаем стратегию и вызываем ее метод **beforeApply**. (см. листинг ниже)
**ViewCommands.beforeApply**
```
public void beforeApply(ViewCommand viewCommand) {
StateStrategy stateStrategy = getStateStrategy(viewCommand);
stateStrategy.beforeApply(mState, viewCommand);
}
```
Ура! Теперь мы знаем, когда выполняется метод **beforeApply** у стратегии: **сразу же** после соответствующего вызова метода у ViewState и **только тогда**. Продолжаем погружение!
В случае если у нас есть View:
3) Им поочередно проксируется метод toggleCheese.
4) Вызывается метод afterApply для класса ViewCommands для данной комнады. В нем мы получаем стратегию и вызываем ее метод afterApply.
Однако **afterApply** вызывается **не только** в этом случае. Он также будет вызван в случае аттача новой View. Давайте рассмотрим этот случай. При аттаче View вызывается метод **attachView(View view)**
Метод **attachView(View view)** вызывается из метода **onAttach()** класса [MvpDelegate](https://github.com/Arello-Mobile/Moxy/blob/master/moxy/src/main/java/com/arellomobile/mvp/MvpDelegate.java). Тот в свою очередь вызывается довольно часто: из методов **onStart()** и **onResume()**. Тем не менее библиотека гарантирует, что **afterApply** вызовется один раз для приаттаченой вью (см. листинг ниже).
**MvpViewState.attachView**
```
public void attachView(View view) {
if (view == null) {
throw new IllegalArgumentException("Mvp view must be not null");
}
boolean isViewAdded = mViews.add(view);
if (!isViewAdded) {
return;
}
mInRestoreState.add(view);
Set> currentState = mViewStates.get(view);
currentState = currentState == null ? Collections.>emptySet() : currentState;
restoreState(view, currentState);
mViewStates.remove(view);
mInRestoreState.remove(view);
}
```
1) Вью добавляется в список.
2) Если ее в этом списке не было, вью переводится в состояние **StateRestoring**
**Зачем нужно состояние StateRestoring**.
Это даёт возможность активити/вью/фрагменту понять, что состояние восстанавливается. У презентера есть метод **isInRestoreState()**. Этот механизм необходим для того, чтобы не выполнять некоторые действия дважды (например, старт анимации для перевода вью в нужное состояние). Это единственный метод **presenter**, который возвращает не **void**. Данный метод принадлежит **presenter**, т.к. **view** и **mvpDelegate** могут иметь несколько презентеров и помещение их в эти классы привело бы к коллизиям.
3) Далее происходит восстановление состояния
Стоит отметить, что метод **afterApply** может вызываться несколько раз. Обратите на это внимание, когда будете писать свои кастомные стратегии.
Мы познакомились с тем, как работают стратегии, пришло время закрепить навыки на практике.
Создаем кастомную стратегию
---------------------------
**Схема работы**
Итак, для начала давайте поймем, какую именно стратегию мы хотим получить. Договоримся об обозначениях.
Данная схема похожа на схему из первой части, однако в ней есть важное отличие -— появилось обозначение тэга. Отсутствие тэга у команды обозначает, что мы его не указывали и он принял значение по умолчанию — null
Мы хотим реализовать следующую стратегию:
При вызове презентером команды (2) со стратегией AddToEndSingleTagStrategy:
* Команда (2) добавляется в конец очереди ViewState.
* В случае, если в очереди уже находилась любая другая команда с аналогичным тэгом, она удаляется из очереди.
* Команда (2) применяется ко View, если оно находится в активном состоянии.
При пересоздании View:
* Ко View последовательно применяются команды из очереди ViewState
**Реализация**
1) Реализуем интерфейс StateStrategy. Для этого переопределяем методы beforeApply и afterApply
2) Реализация метода beforeApply будет очень похожа на реализацию аналогичного метода в классе [AddToEndSingleStrategy](https://github.com/Arello-Mobile/Moxy/blob/master/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/AddToEndSingleStrategy.java).
Мы хотим удалить из очереди **абсолютно все** команды с данным тегом, т.е. удаляться будут даже команды с другой стратегией, но аналогичным тегом.
Поэтому мы вместо строчки **entry.class == incomingCommand.class** будем использовать **entry.tag == incomingCommand.tag**
**Комментарий для не Kotlin пользователей**В Kotlin == равносильно .equals в Java
Также нам необходимо убрать строку **break**, так как в отличие от [AddToEndSingleStrategy](https://github.com/Arello-Mobile/Moxy/blob/master/moxy/src/main/java/com/arellomobile/mvp/viewstate/strategy/AddToEndSingleStrategy.java) у нас в очереди могут появиться несколько команд для удаления.
3) Реализацию метода **afterApply** оставим пустой, так как у нас нет необходимости менять очередь после применения команды.
Итак, что у нас получилось:
```
class AddToEndSingleTagStrategy() : StateStrategy {
override fun beforeApply(
currentState: MutableList>,
incomingCommand: ViewCommand) {
val iterator = currentState.iterator()
while (iterator.hasNext()) {
val entry = iterator.next()
if (entry.tag == incomingCommand.tag) {
iterator.remove()
}
}
currentState.add(incomingCommand)
}
override fun afterApply(
currentState: MutableList>,
incomingCommand: ViewCommand) {
//Just do nothing
}
}
```
Вот и все, осталось проиллюстрировать, как мы будем использовать стратегию (см. листинг ниже).
```
interface LaunchView : MvpView {
@StateStrategyType(AddToEndSingleStrategy::class, tag = BURGER_TAG)
fun setBreadType(breadType: BreadType)
@StateStrategyType(AddToEndSingleStrategy::class, tag = BURGER_TAG)
fun toggleCheese(enable: Boolean)
@StateStrategyType(AddToEndSingleTagStrategy::class, tag = BURGER_TAG)
fun clearBurger(breadType: BreadType, cheeseSelected: Boolean)
//Другие функции
companion object {
const val BURGER_TAG = "BURGER"
}
}
```
Полный пример кода можно посмотреть в репозитории [Moxy](https://github.com/Arello-Mobile/Moxy/tree/master/sample-custom-strategy). Напоминаю, что это сэмпл и решения в нем приведены сугубо для иллюстрации функционала фреймворка
Предназначение..
----------------
Для чего еще можно использовать кастомные стратегии:
1) склеивать предыдущие команды в одну;
2) менять порядок выполнения команд, если команды не коммутативны (a•b != b•a);
3) выкидывать все команды, которые **не** содержат текущий tag;
4) ..
Если вы часто используете команды, а их нет в списке дефолтных — пишите, обсудим их добавление.
Обсудить Moxy можно в [чате сообщества](https://t.me/moxy_ru)
Ждем замечаний и предложений по статье и библиотеке ;)
---
(I) здесь и далее "мы" — авторы Moxy: [Xanderblinov](https://habrahabr.ru/users/xanderblinov/), [senneco](https://habrahabr.ru/users/senneco/) и все ребята из сообщества, которые помогали советами, замечаниями и пулреквестами. Полный список контрибьютеров можно посмотреть [здесь](https://github.com/Arello-Mobile/Moxy/graphs/contributors)
(II) Код в листингах написан на Kotlin | https://habr.com/ru/post/341108/ | null | ru | null |
# Управление правами доступа в Expressjs при помощи CASL
В современных приложениях, которые поддерживают аутентификацию, мы часто хотим изменить то, что видимо для пользователя, в зависимости от его роли. Например, гостевой пользователь может видеть статью, но только зарегистрированный пользователь или администратор видит кнопку для удаления этой статьи.
Управление этой видимостью может стать полным кошмаром с увеличением количества ролей. Вероятно, вы уже писали или видели код вроде этого:
```
if (user.role === ADMIN || user.auth && post.author === user.id) {
res.send(post)
} else {
res.status(403).send({ message: 'You are not allowed to do this!' })
}
```
Такой код распространяется по приложению и обычно становится большой проблемой, когда заказчик изменяет требования или просит добавить дополнительные роли. В конце концов вам нужно пройти все такие if-s и добавить дополнительные проверки.
В этой статье я покажу альтернативный способ реализации управления разрешениями в [Expressjs API](https://expressjs.com/) с помощью библиотеки, которая называется [CASL](https://github.com/stalniy/casl). Она намного упрощает управление правами доступа и позволяет переписать предыдущий пример на что-то вроде этого:
```
if (req.ability.can('read', post)) {
res.send(post)
} else {
res.status(403).send({ message: 'You are not allowed to do this!' })
}
```
**Впервые слышете о CASL?** Рекомендую прочесть [Что такое CASL?](http://freaksidea.com/show-133-chto-takoe-casl-ili-kak-vnedrit-proverku-prav-dostupa-v-vashe-prilozhenie)
**Примечание:** эта статья изначально была опубликована [на Medium](https://medium.com/netscape/authorization-with-casl-in-express-app-d94eb2e2b73b)
Демо-приложение
---------------
В качестве тестового приложения я сделал достаточно простой [REST API для блога](https://github.com/stalniy/casl-express-example). Приложение состоит из 3 сущностей (`User`, `Post` и `Comment`) и 4 модулей (по одному модулю для каждой сущности и еще один — для проверки авторизации). Все модули можно найти в папке `src/modules`.
Приложение использует [mongoose](http://mongoosejs.com/) модели, аутентификацию [passportjs](http://www.passportjs.org/) и авторизацию (или проверку прав доступа) на базе CASL. При помощи API, пользователь может:
* читать все статьи и комментарии
* создавать пользователя (т.е., регистрироваться)
* управлять собственными статьями (создавать, редактировать, удалять), если авторизован
* обновлять персональную информацию, если авторизован
* управлять собственными комментариями, если авторизован
Чтобы установить это приложение, просто склонируйте его из [github](https://github.com/stalniy/casl-express-example) и запустите `npm install` и `npm start`. Также нужно запустить MongoDB сервер, приложение подключается к `mongodb://localhost:27017/blog`. После того, как все будет готово, можно немного поиграться, а чтобы было веселее, заимпортите базовые данные с папки `db/`:
```
mongorestore ./db
```
В качестве альтернативы, Вы можете следовать инструкциям в [README файле проекта](https://github.com/stalniy/casl-express-example) или использовать мою [Postman коллекцию](https://www.getpostman.com/collections/a39c622e1c9401e32c51).
В чем фишка?
------------
Во-первых, большим плюсом CASL является, то что он позволяет определить права доступа в одном месте, для всех пользователей! Во-вторых, CASL концентрирует внимание не на том кем является пользователь, а на том что он может делать, т.е. на его возможностях. Это позволяет распределять эти возможности разным ролям или группам пользователей без лишних усилий. Это значит, что мы можем прописать права доступа для авторизированных и не авторизированных пользователей:
```
const { AbilityBuilder, Ability } = require('casl')
function defineAbilitiesFor(user) {
const { rules, can } = AbilityBuilder.extract()
can('read', ['Post', 'Comment'])
can('create', 'User')
if (user) {
can(['update', 'delete', 'create'], ['Post', 'Comment'], { author: user._id })
can(['read', 'update'], 'User', { _id: user._id })
}
return new Ability(rules)
}
const ANONYMOUS_ABILITY = defineAbilitiesFor(null)
module.exports = function createAbilities(req, res, next) {
req.ability = req.user.email ? defineAbilitiesFor(req.user) : ANONYMOUS_ABILITY
next()
}
```
Давайте теперь разберем код написанный выше. В функции `defineAbilitiesFor(user)` создается экземпляр `AbilityBuilder`-a, его метод extract разбивает этот объект на 2 простые функции `can` и `cannot` и массив `rules` (в данном коде `cannot` не используется). Далее при помощи вызовов функции `can` мы определяем, что пользователь может делать: первым аргументом передает действие (или массив действий), вторым аргументом — тип объекта над которым проводится действие (или массив типов) и третьим необязательным аргументом можно передать объект условий. Объект условий используется при проверке прав доступа на экземпляре класса, т.е. он проверяет равняется ли свойство `author` объекта `post` и `user._id`, если равны, то вернется `true`, в противном случае `false`. Для большей наглядности приведу пример:
```
// Post is a mongoose model
const post = await Post.findOne()
const user = await User.findOne()
const ability = defineAbilitiesFor(user)
console.log(ability.can('update', post)) // если post.author === user._id, то вернется true
```
Далее при помощи `if (user)` мы определяем права доступа для авторизованного пользователя (если пользователь не авторизован, то мы не знаем кто он и не имеем объекта с информацией о пользователе). В конце возвращаем экземпляр класса `Ability`, с помощь которого мы и будем проверять права доступа.
Далее создаем константу `ANONYMOUS_ABILITY`, она является инстансом `Ability` класса для не авторизованных пользователей. В конце, экспортируем express middleware, которое отвечает за создание `Ability` экземпляра для конкретного пользователя.
Тестируем API
-------------
Давайте протестируем, что у нас получилось используя [Postman](https://www.getpostman.com/). Для начала нужно получить accessToken, для этого отправьте запрос:
```
POST /session
{
"session": {
"email": "casl@medium.com",
"password": "password"
}
}
```
В ответ получите что-то вроде этого:
```
{ "accessToken": "...." }
```
Этот токен нужно вставить в `Authorization header` и отправлять со всеми последующими запросами.
Теперь давайте попробуем обновить статью
```
PATCH http://localhost:3030/posts/597649a88679237e6f411ae6
{
"post": {
"title": "[UPDATED] my post title"
}
}
200 Ok
{
"post": {
"_id": "597649a88679237e6f411ae6",
"updatedAt": "2017-07-24T19:53:09.693Z",
"createdAt": "2017-07-24T19:25:28.766Z",
"title": "[UPDATED] my post title",
"text": "very long and interesting text",
"author": "597648b99d24c87e51aecec3",
"__v": 0
}
}
```
Все хорошо работает. А что если обновим чужую статью?
```
PATCH http://localhost:3030/posts/59761ba80203fb638e9bd85c
{
"post": {
"title": "[EVIL ACTION] my post title"
}
}
403
{
"status": "forbidden",
"message": "Cannot execute \"update\" on \"Post\""
}
```
Получили ошибку! Как и ожидалось :)
А теперь давайте представим, что для авторов нашего блога мы хотим создать страницу, где они смогут видеть все посты которые они могут обновлять. С точки зрения конкретной логики это несложно, просто нужно выбрать все статьи в которых author равняется `user._id`. Но мы ведь уже прописали такую логику при помощи CASL, было бы очень удобно получить все такие статьи из базы без написания лишних запросов, да и если права поменяются, то придется менять и запрос — лишняя работа :).
К счастью, CASL имеет дополнительный npm пакет — [@casl/mongoose](https://github.com/stalniy/casl/tree/master/packages/casl-mongoose). Этот пакет позволяет запрашивать записи из MongoDB в соответствии с определенными правами доступа! Для mongoose этот пакет предоставляет плагин, который добавляет метод `accessibleBy(ability, action)` в модельку. С помощью этого метода мы и будем запрашивать записи из базы (больше об этом читайте [в документации CASL](https://stalniy.github.io/casl/abilities/database/integration/2017/07/22/database-integration.html) и [README файле пакета](https://github.com/stalniy/casl/tree/master/packages/casl-mongoose)).
Это именно, то как реализован `handler` для `/posts` (я также добавил возможность указывать, для какого действия нужно проверять права доступа):
```
Post.accessibleBy(req.ability, req.query.action)
```
Так вот, для того чтобы решить задачу описанную ранее, достаточно добавить параметр `action=update`:
```
GET http://localhost:3030/posts?action=update
200 Ok
{
"posts": [
{
"_id": "597649a88679237e6f411ae6",
"updatedAt": "2017-07-24T19:53:09.693Z",
"createdAt": "2017-07-24T19:25:28.766Z",
"title": "[UPDATED] my post title",
"text": "very long and interesting text",
"author": "597648b99d24c87e51aecec3",
"__v": 0
}
]
}
```
В заключение
------------
Благодаря CASL у нас есть действительно хороший способ управления правами доступа. Я более чем уверен, что конструкция типа
```
if (ability.can('read', post)) ...
```
намного понятнее и проще чем
```
if (user.role === ADMIN || user.auth && todo.author === user.id) ...
```
При помощи CASL мы можем быть более четкими в отношении того, что делает наш код. Кроме того, такие проверки, безусловно, будут использоваться в другом месте нашего приложения, и именно здесь CASL поможет избежать дублирования кода.
Я надеюсь, Вам было на столько же интересно читать о CASL, на сколько мне было интересно его создавать. [CASL имеет довольно хорошую документацию](https://stalniy.github.io/casl/), Вы наверняка найдете там много полезной информации, но не стесняйтесь задавать вопросы если что в [gitter чате](https://gitter.im/stalniy-casl/casl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) и добавить звездочку на [гитхабе](https://github.com/stalniy/casl) ;) | https://habr.com/ru/post/414951/ | null | ru | null |
# WarCraft III / Dota кратко о создании чита
Добрый день. Прошлая заметка о [принципе создания чита](http://habrahabr.ru/post/143178/), заинтересовала многих. Руководствуясь этим я предположил, что кому-то может оказаться интересным другой способ создания подобных программ. Перед тем как начать скажу: «Все ниже описанное Вы, если решите применить на деле, используете на свой страх и риск. Все описанное здесь приводится, **исключительно**, для общего развития».
Для примера будем использовать стандартную «рыбу» для подобных программ/трейнеров. Весь принцип работы заключается в нахождении нужных нам адресов/смещений в память программы и изменении их значений на свои.
И так, для начала нам понадобятся:
[ArtMoney](http://www.artmoney.ru/)/[TSearch](http://warcraftall.ucoz.ua/load/0-0-0-2-20) — для поиска значений.
[ollydbg](http://www.ollydbg.de/) — дебагер для поиска адресов.
Посмотреть ролик:
Разъясняю:
1) Первоначально находим адрес в памяти игры, по которому хранится флаг отвечающий за условие показывать/скрыть юнита.
2) Далее, в дебагере, находим этот адрес и ставим точку остановки на его вызов. Переходим туда откуда это произошло. Создаем микро сбой. Копируем значения (выделенные красным) — это и есть то, что мы должны записывать в память программы при активации чита — **6F3A1563 66:B9 0F00.**
66:B9 0F00 это и есть наши волшебные байты, запишем их как **0x66 0xB9 0x0F 0x00**. И запишем в **6F3A1563** со смещением на единицу.
Находим дескриптор окна и устанавливаем привилегии для нашего маркера.
```
LPSTR gameWindowTitle = "Warcraft III";
HWND hWnd=::FindWindow(NULL, gameWindowTitle);
if (hWnd != NULL)
{
HANDLE currentProccess = GetCurrentProcess();
HANDLE token;
BOOL retValue = OpenProcessToken(currentProccess, 40, &token);
LUID luid;
LPSTR debugPrivilege = "SeDebugPrivilege";
retValue = LookupPrivilegeValue(NULL, debugPrivilege, &luid);
TOKEN_PRIVILEGES newState, preState;
DWORD returnLength;
newState.PrivilegeCount = 1;
newState.Privileges[0].Luid = luid;
newState.Privileges[0].Attributes = 2;
retValue = AdjustTokenPrivileges(token, FALSE, &newState, 28, &preState, &returnLength);
DWORD PID;
DWORD TID = ::GetWindowThreadProcessId(hWnd, &PID);
openedProccess = OpenProcess(
PROCESS_ALL_ACCESS |
PROCESS_TERMINATE |
PROCESS_VM_OPERATION |
PROCESS_VM_READ|
PROCESS_VM_WRITE,
FALSE,
PID);
...
}
```
Далее можно модифицировать память
```
DWORD data = 0x66;
WriteProcessMemory(openedProccess, (LPVOID)(6F3A1563), &data, 1, 0);
data = 0xB9;
WriteProcessMemory(openedProccess, (LPVOID)(6F3A1564), &data, 1, 0);
data = 0x0F;
WriteProcessMemory(openedProccess, (LPVOID)(6F3A1565), &data, 1, 0);
data = 0x00;
WriteProcessMemory(openedProccess, (LPVOID)(6F3A1566), &data, 1, 0);
```
Для удобства можно передать адреса относительно библиотеки **Game.dll**, что может увеличить срок жизни нашей программы без пересборки — если в игре будут обновлены другие библиотеки. Для этого нужно знать ее адрес
```
DWORD GetModuleBase(HANDLE hProc, LPSTR sModuleName)
{
HMODULE hMods[8];
DWORD cbNeeded;
unsigned int i;
if(EnumProcessModules(hProc, hMods, sizeof(hMods), &cbNeeded))
{
for ( i = 0; i < (cbNeeded / sizeof(HMODULE)); i++ )
{
TCHAR szModName[MAX_PATH];
if ( GetModuleBaseName(hProc, hMods[i], szModName,
sizeof(szModName) / sizeof(TCHAR)))
{
if(strstr(szModName, sModuleName))
{
return (DWORD)hMods[i];
}
_tprintf( TEXT("\t%s (0x%08X)\n"), szModName, hMods[i] );
}
}
}
return 0x00;
}
bool WriteData(DWORD address, DWORD data)
{
return WriteProcessMemory(openedProccess, (LPVOID)(gameOffset + address), &data, 1, 0);
}
...
LPSTR gameLibraryName = "Game.dll";
gameOffset = GetModuleBase(openedProccess, gameLibraryName);
...
```
Вот в принципе и все. | https://habr.com/ru/post/144453/ | null | ru | null |
# Хочешь вкусного пива, Arduino в помощь
Данная публикация навеяна другой. Она называется [«Контроллер для домашней пивоварни Mega Brewery. Part I»](http://habrahabr.ru/post/122886/) и опубликована за авторством [megadenis](http://habrahabr.ru/users/megadenis/).
С чего все началось?
--------------------
Я студент технического ВУЗа. Однажды, сидя в кафе с другом, который тогда учился в медицинском университете, решили открыть бар. Было много идей, которые, в принципе, заслуживали некоторого внимания. Например, танц-пол, который изменяет угол наклона в зависимости от стиля музыки… Но, наряду со всем многообразием идей, так же была еще одна —
… а не сварить ли нам свое пиво?
--------------------------------
Через пару недель я сварил пиво, взяв ингредиенты с пивзавода, на котором работал друг отца. Но многие технологические процессы были нарушены, поэтому вместо пива вышло что-то с не очень приятным запахом.
Через несколько лет решил повторить процесс, немного автоматизировав его с помощью Arduino UNO. И вот, что получилось.
Начну с того, что должна делать вся установка.
* Проверять себя — все ли работает, все ли подключено;
* Чистить себя;
* Подготавливаться к процессу пивоварения;
* Варить пиво в полуавтоматическом режиме;
* Варить пиво в ручном режиме;
* Варить пиво в автоматическом режиме (как стиральная машина стирает белье).
Первый пункт в данный момент не реализован. Пока даже мыслей нет, как реализовать.
Второй — тоже не реализован, но в ближайшее время доделаю, только дождусь, когда доставят насосы с ebay.
Третий пункт — достаточно простой.
Подготовка к процессу пивоварения
---------------------------------
Сообщение от системы о том, что необходимо залить воду в чан -> программа ждет нажатия клавиши ОК — > программа посылает arduino команду на включение [твердотельного реле](http://www.ebay.com/itm/Output-24V-380V-25A-SSR-25-DA-Solid-State-Relay-For-PID-Temperature-Controller/390915738600?_trksid=p2047675.c100005.m1851&_trkparms=aid%3D222007%26algo%3DSIC.MBE%26ao%3D1%26asc%3D26943%26meid%3Dcf9da8c81bed41d99c314d5d59fe9277%26pid%3D100005%26prg%3D11184%26rk%3D1%26rkt%3D6%26sd%3D310702225734&rt=nc) -> твердотельное реле включает однокиловатный тенн в чане, доводит до температуры 37 градусов, отсылает программе команду, что все готово для варки. Поддерживает температуру 37 градусов.
Хочется, чтобы была проверка на наличие воды, но датчик еще ждет своего отправления от «китайских братьев».
Варка пива в полуавтоматическом режиме
---------------------------------------
В принципе, несложная процедура:
— Нажимаем в управляющей программе кнопку «Прогрев», остальные управляющие кнопки не активны;
— После прогрева программа выводить сообщение «Все готово, можно варить»;
— Засыпаем ингредиенты, выбираем программу для варки — кнопка «Варка пива» становится активной;
— Нажимаем кнопку «Варка пива», процесс пошел;
— Далее система периодически будет оповещать информационными сообщениями, что делать и когда.
Нужно следовать инструкциям.
Варка пива в ручном режиме
---------------------------
Данный процесс позволяет задавать параметры варки, изменять их в цикле варки. До него еще не дошел.
Варка в автоматическом режиме
------------------------------
Это мечта. В данный момент нет компонентов для реализации. Не хватает насосов, датчиков уровня воды. Не знаю, как мерить плотность сусла, сколько алкоголя в молодом пиве и еще много чего. Но я не отчаиваюсь и буду автоматизировать постепенно, пока варка пива не будет выглядеть так:
Закинул ингредиенты в соответствующие лотки, нажал кнопку и… через полтора месяца получил готовое пиво.
Это вкратце о процессе, а теперь перейдем к техническое стороне.
Техническая сторона процесса
----------------------------
Как сказано выше за управляющий микроконтроллер выступает arduino UNO. К нему подключены 2 реле, 2
[цифровых термометра DS18B20](http://www.ebay.com/itm/170821333658?_trksid=p2060778.m2749.l2649&ssPageName=STRK%3AMEBIDX%3AIT.).
Arduino общается с основной программой через com порт. Т.к. у меня нет шильда реального времени к arduino, пришлось таймеры брать из visual c#. Опыта написания программ у нет, так что, если вдруг у кого есть идеи, критика — почту за честь. Критикуйте, дербаньте, так сказать, что вдруг не нравится.
**Вот текст программы на arduino**
```
#include
OneWire ds(8); // датчики температуры сидят на 8 пине
int reley1 = 13;
int reley2 = 12;
int reley3 = 11;
int reley4 = 10;
int reley5 = 7; //включение тен
int reley6 = 6; // тен на заторном чане
float temp1;
float temp2;
void setup(void) {
Serial.begin(9600);
pinMode(reley1,OUTPUT);
pinMode(reley2,OUTPUT);
pinMode(reley3,OUTPUT);
pinMode(reley4,OUTPUT);
pinMode(reley5,OUTPUT);
pinMode(reley6,OUTPUT);
digitalWrite(reley1,LOW);
digitalWrite(reley2,LOW);
digitalWrite(reley3,LOW);
digitalWrite(reley4,LOW);
digitalWrite(reley5,LOW);
digitalWrite(reley6,LOW);
}
void loop(void) {
if (Serial.available()) {
switch (Serial.read()){
case 'i':
infuz();
break;
case 'p':
progrev();
break;
case 'a':
avariya();
break;
case 'v':
varka();
break;
case 't':
temperature();
break;
}
}
}
void varka() {
digitalWrite(reley6, HIGH);
while(Serial.read()!='m') {
temperature();
if (temp1 >= 52.00)
digitalWrite(reley6,LOW);
else
digitalWrite(reley6,HIGH);
}
while(Serial.read()!='n') {
//digitalWrite(reley6,HIGH);
temperature();
if(temp1>= 62.00)
digitalWrite(reley6,LOW);
else
digitalWrite(reley6,HIGH);
}
while(Serial.read()!='b') {
//digitalWrite(reley6,HIGH);
temperature();
if(temp1 >= 75.00)
digitalWrite(reley6,LOW);
else
digitalWrite(reley6,HIGH);
}
digitalWrite(reley6,LOW);
while(Serial.read()!='c')
delay(1000);
while(Serial.read()!='x') {
digitalWrite(reley5,HIGH);
temperature();
}
digitalWrite(reley5,LOW);
}
void infuz() {
//temperature();
//Serial.available();
while (Serial.read()!='s'){ //выключение цикла инфузионной варки
if (temp<=69.50)
digitalWrite(reley5,HIGH);
else
digitalWrite(reley5,LOW);
}
digitalWrite(reley5,LOW);
}
void progrev() {
while (temp1 <=36.00)
temperature();
digitalWrite(reley6,HIGH);
digitalWrite(reley6,LOW);
//while (temperature() >40.0)
//delay(1000);
Serial.println('s');
}
void avariya(){
digitalWrite(reley1,LOW);
digitalWrite(reley2,LOW);
digitalWrite(reley3,LOW);
digitalWrite(reley4,LOW);
digitalWrite(reley5,LOW);
}
void temperature() {
byte i;
byte present = 0;
byte data[12];
byte addr[8];
byte zator[8] = {40, 23, 218, 43, 6, 0, 0, 22}; // адрес температурного датчика в заторе
byte varilka[8] = {40, 255, 240, 115, 59, 4, 0, 234}; //адрес температурного датчика в варильном чане
float celsius;
// float temp;
boolean gde;
if ( !ds.search(addr)) {
//Serial.println("No more addresses.");
//Serial.println();
ds.reset\_search();
delay(250);
// return;
}
if (OneWire::crc8(addr, 7) != addr[7]) {
Serial.println("CRC is not valid!");
// return;
}
ds.reset();
ds.select(addr);
ds.write(0x44, 1); // start conversion, with parasite power on at the end
delay(840); // maybe 750ms is enough, maybe not
// we might do a ds.depower() here, but the reset will take care of it.
present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad
for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
}
int16\_t raw = (data[1] << 8) | data[0];
byte cfg = (data[4] & 0x60);
if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms
else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
celsius = (float)raw / 16.0;
for(i = 0; i<8; i++) {
if (addr[i] == zator[i])
gde = true;
else {
gde = false;
break;
}
}
if (gde) {
Serial.print("t2 "); //temperatura варочника
temp2 = celsius;
Serial.print(temp2);
Serial.println();
}
else
{
Serial.print("t1 "); //температура затора
temp2 = celsius;
Serial.print(temp1);
}
}
```
Все бы хорошо, но почему-то третий датчик показывает постоянно 85 градусов. Пока не могу сказать, почему. А нужен он для дальнейшей автоматизации — поддержание температуры в холодильнике.
Вкратце опишу, что делает программа.
Программа разделена на подпрограммы, каждая из которых активируется, если на com порту появляется определенный символ. Например, если в порт попадает буква «p», то включается режим «Прогрев». Или же, если «a» — то вызывается подпрограмма avariya() и все отключается. При вызове подпрограммы temperature() данные записываются в глобальные переменные temp1, temp2. Оттуда и попадают в нужные подпрограммы.
В будущем появятся подпрограммы для варки различных сортов и даже самогона.
Теперь, что касается основной программы управления.
Основная программа управления
-----------------------------
Она написана на visual studio c#.
Исходный код программы:
**Исходный код программы**
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
// String portnumber;
SerialPort Port1 = new SerialPort("COM5", 9600);
int s=0;
public Form1()
{
InitializeComponent();
}
/*private const int CP_NOCLOSE_BUTTON = 0x200;
protected override CreateParams CreateParams
{
get
{
CreateParams myCp = base.CreateParams;
myCp.ClassStyle = myCp.ClassStyle | CP_NOCLOSE_BUTTON;
return myCp;
}
}*/
private void Form1_Load(object sender, EventArgs e)
{
label2.Text = Port1.PortName;
Port1.Open();
}
//Проверка оборудования
private void button1_Click(object sender, EventArgs e)
{
if (Port1.IsOpen == false)
{
try
{
//программу можно доработать информация из podrugomu.com/node/987
Port1.PortName = label2.Text;
Port1.Open();
Port1.Write("Check");
//SerialPort Port2 = new SerialPort("COM4", 9600);
//Port2.Open();
//label3.Text = Convert.ToString(Port2.ReadByte()); //проверка показаний порта
MessageBox.Show("Процес проверки оборудования запущен", "Инфорамационное сообщение");
richTextBox1.Text = richTextBox1.Text + "\n" + "Запуск процесса проверки оборудования"+" "+DateTime.Now.ToString("HH:mm");
button1.Enabled = false;
button2.Enabled = false;
button3.Enabled = false;
if (Port1.ReadByte() == 1000)
{
richTextBox1.Text = richTextBox1.Text + "\n" + "Окончание процесса проверки оборудования"+" "+DateTime.Now.ToString("HH:mm");
button1.Enabled = true;
button2.Enabled = true;
button3.Enabled = true;
Port1.Close();
MessageBox.Show("Конец Цикла проверки оборудования" +" "+ DateTime.Now.ToString("HH:mm"));
richTextBox1.SaveFile("CheckLOG.rtf");
}
}
catch
{
richTextBox1.Text = richTextBox1.Text + "\n" + "Ошибка процесса проверки оборудования" +" "+ DateTime.Now.ToString("HH:mm");
MessageBox.Show("Неверно выбран порт устройства. Процесс проверки не может быть запущен", "Warninig");
richTextBox1.SaveFile("log/Check_"+DateTime.Now.ToString("ddMMyyyy")+".rtf");
}
}
}
// Чистка оборудования
private void button3_Click(object sender, EventArgs e)
{
if (Port1.IsOpen == false)
{
try
{
//программу можно доработать информация из podrugomu.com/node/987
MessageBox.Show("Вы точно налили дезинфектор", "WARNING", MessageBoxButtons.OK, MessageBoxIcon.Warning);
Port1.PortName = label2.Text;
Port1.Open();
Port1.Write("Clean");
MessageBox.Show("Процес чистки оборудования запущен", "Инфорамационное сообщение");
button1.Enabled = false;
button2.Enabled = false;
button3.Enabled = false;
if (Port1.ReadByte() == 1000)
{
button1.Enabled = true;
button2.Enabled = true;
button3.Enabled = true;
Port1.Close();
MessageBox.Show("Конец Цикла чистки оборудования");
}
}
catch
{
MessageBox.Show("Неверно выбран порт устройства. Процесс чистки не может быть запущен", "Warninig");
}
}
}
private void contextMenuStrip1_Opening(object sender, CancelEventArgs e)
{
}
private void cOM1ToolStripMenuItem_Click(object sender, EventArgs e)
{
SerialPort Port1 = new SerialPort("COM1", 9600);
// MessageBox.Show("Выбран порт COM1");
label1.Visible = true;
label2.Text = "COM1";
}
private void label2_Click(object sender, EventArgs e)
{
}
private void cOM2ToolStripMenuItem_Click(object sender, EventArgs e)
{
SerialPort Port1 = new SerialPort("COM2", 9600);
// MessageBox.Show("Выбран порт COM2");
label1.Visible = true;
label2.Text = "COM2";
}
private void cOM3ToolStripMenuItem_Click(object sender, EventArgs e)
{
SerialPort Port1 = new SerialPort("COM3", 9600);
// MessageBox.Show("Выбран порт COM3");
label1.Visible = true;
label2.Text = "COM3";
}
private void cOM4ToolStripMenuItem_Click(object sender, EventArgs e)
{
SerialPort Port1 = new SerialPort("COM4", 9600);
// MessageBox.Show("Выбран порт COM4");
label1.Visible = true;
label2.Text = "COM4";
}
private void cOM5ToolStripMenuItem_Click(object sender, EventArgs e)
{
SerialPort Port1 = new SerialPort("COM5", 9600);
// MessageBox.Show("Выбран порт COM5");
label1.Visible = true;
label2.Text = "COM5";
}
private void cOM6ToolStripMenuItem_Click(object sender, EventArgs e)
{
SerialPort Port1 = new SerialPort("COM6", 9600);
// MessageBox.Show("Выбран порт COM6");
label1.Visible = true;
label2.Text = "COM6";
}
private void cOM7ToolStripMenuItem_Click(object sender, EventArgs e)
{
SerialPort Port1 = new SerialPort("COM7", 9600);
// MessageBox.Show("Выбран порт COM7");
label1.Visible = true;
label2.Text = "COM5";
}
private void программаВаркиToolStripMenuItem_Click(object sender, EventArgs e)
{
}
// Варка пива
private void button2_Click(object sender, EventArgs e)
{
// if (Port1.IsOpen == false)
//{
// try
//{
//программу можно доработать информация из podrugomu.com/node/987
//Port1.PortName = label2.Text;
//Port1.Open();
switch (label3.Text)
{
case "Выбрано инфузионное затирание":
MessageBox.Show("Процесс инфузионного затирания Запущен", "Инфорамационное сообщение");
Port1.WriteLine("i");
timer1.Start();
break;
case "Выбрана варка Cooper":
MessageBox.Show("Процесс затирания Cooper запущен", "Инфорамационное сообщение");
Port1.WriteLine("v");
timer3.Start();
break;
}
button1.Enabled = false;
button2.Enabled = false;
button3.Enabled = false;
// button5.Enabled = false;
// richTextBox1.Text = Port1.ReadLine()+"\n";
/* if (Port1.ReadLine() == "e\r") {
button1.Enabled = true;
button2.Enabled = true;
button3.Enabled = true;
button5.Enabled = true; */
//Port1.Close();
// MessageBox.Show("Конец Цикла варки пива");
// }
// }
// catch
//{
// MessageBox.Show("Неверно выбран порт устройства. Процесс варки не может быть запущен", "Warninig");
//}
// }
}
private void button5_Click(object sender, EventArgs e)
{
Port1.Write("p");
button1.Enabled = false;
button2.Enabled = false;
button3.Enabled = false;
timer2.Start();
richTextBox1.Text = richTextBox1.Text + "\n" + "Запуск подогрева воды в заторном чане до 37 градусов" + " " + DateTime.Now.ToString("HH:mm");
/* Port1.Open();
//Port1.Open();
//richTextBox1.Text = richTextBox1.Text + "\n" + Port1.ReadLine();
Port1.WriteLine("o");
Port1.Close(); */
}
private void выходToolStripMenuItem_Click(object sender, EventArgs e)
{
Close();
}
private void button4_Click(object sender, EventArgs e)
{
}
private void инфузионноеЗатираниеToolStripMenuItem_Click(object sender, EventArgs e)
{
label3.Text = "Выбрано инфузионное затирание";
}
private void timer1_Tick(object sender, EventArgs e)
{
textBox1.Text = Convert.ToString(Convert.ToInt32(s / 60));
textBox2.Text = Convert.ToString(Convert.ToInt32((s)));
s++;
label5.Text = Port1.ReadLine();
if (s==4200){ //70 минут это 4200 секунд
timer1.Stop();
//timer2.Start();
//Port1.Open();
Port1.WriteLine("s");
// Port1.Close();
MessageBox.Show("инфузионное затирание окончено необходимо отфильтровать сусло");
button1.Enabled = true;
button2.Enabled = true;
button3.Enabled = true;
button5.Enabled = true;
textBox1.Text = "";
textBox2.Text = "";
}
//Port1.Close();
}
private void label4_Click(object sender, EventArgs e)
{
}
private void timer2_Tick(object sender, EventArgs e)
{
label5.Text = Port1.ReadLine();
if (Port1.ReadLine() == "s\r")
{
timer2.Stop();
MessageBox.Show("Вода имеет температуру 37 градусов. Можно засыпать солод и включать режим затирания");
richTextBox1.Text = richTextBox1.Text + "\n" + "Окончание процесса подготовки заторного чана. Т=37 градусов" + " " + DateTime.Now.ToString("HH:mm");
button2.Enabled = true;
}
}
private void аварийноеОтключениеToolStripMenuItem_Click(object sender, EventArgs e)
{
Port1.WriteLine("a");
MessageBox.Show("Пользователь аварийно отключил всю систему");
}
private void заторногоКотлаToolStripMenuItem_Click(object sender, EventArgs e)
{
Port1.WriteLine("k");
MessageBox.Show("Включен режим кипячения заторного чана. Ждите 60 минут");
richTextBox1.Text = richTextBox1.Text + "\n" + "Включен режим кипячения заторного чана. Ждите 60 минут" + " " + DateTime.Now.ToString("HH:mm");
}
private void timer3_Tick(object sender, EventArgs e)
{
string s1 = "";
Port1.ReadLine();
if (s1.Substring(0, 2) == "t1")
label5.Text = s1.Substring(4, 5);
if (s1.Substring(0, 2) == "t2")
label9.Text = s1.Substring(4, 5);
s++;
if (s == 900)
{
Port1.WriteLine("m");
MessageBox.Show("Этап затирания при 62 градусах");
richTextBox1.Text = richTextBox1.Text + "\n" + "Этап затирания при 62 градусах" + " " + DateTime.Now.ToString("HH:mm");
}
if(s== 2250)
{
Port1.WriteLine("n");
MessageBox.Show("Этап затирания при 78 градусах");
richTextBox1.Text = richTextBox1.Text + "\n" + "Этап затирания при 78 градусах" + " " + DateTime.Now.ToString("HH:mm");
}
if (s ==2700)
{
Port1.WriteLine("b");
MessageBox.Show("Этап затирания закончен, можно сливать сусло");
richTextBox1.Text = richTextBox1.Text + "\n" + "Этап затирания окончен. Можно сливать сусло" + " " + DateTime.Now.ToString("HH:mm");
}
}
private void обычнаяToolStripMenuItem_Click(object sender, EventArgs e)
{
label3.Text = "Выбрана варка Cooper";
}
}
}
```
Программа общается с arduino через com порт. Единственное, никак не могу победить, чтобы при опрашивании com порта программа не подвисала на момент выполнения подпрограммы. После окончания подпрограммы программа отвисает, но пока это не критично и даже некий плюс. Защита от дурака — чтобы не нажать ничего во время определенной процедуры.
Итого, программа умеет
----------------------
— готовить оборудование к варке;
— варить;
— писать простенький лог работы (очень полезно при дальнейшем анализе варки);
— выбирать порт для подключение к управляющему контроллеру(arduino UNO);
кипятить варочник и заторный чаны.
Когда придут помпы и солинойдные клапаны, буду автоматизировать дальше. А пока каждое воскресение буду добавлять по одной программе варки. В сумме будет 5 программ. Так же ждет своей очереди реализация ручного режима.
Как говорится,
to be continued...
------------------
UPD:
----
Вот несколько фотографий пивоварни
Это варочный котел. Таких у меня два. С боку установлен датчик температуры DS18B20 в герметичной оправе.
Долго не мог понять, почему периодически arduino виснет, пока не осенило, что нужно все заземлить, наче пробивает на корпус, далее на корпус датчика и на arduino.
Медная трубка внутри — это для фильтрования сусла. Можно сделать красивее, но лучше использовать фальшдно. К сожалению китайские собрать не торопятся высылать его.
Пока рано говорить о результате, вот что получилось
Общий вид чана выглядит вот так.
Использовал обычные коннекторы
для подключения датчиков температуры, подключающиеся к двойной розетке. Удобнее мыть оборудование. Отключил, понес в ванную. Помыл, подключил и все работает.
Все пенилось по графику, лишнего не вытекало. А самых ближайших планах — слить на дображивание партию пива, сварить еще одну. Рецепт, в принципе можно посмотреть в коде в подпрограмме varka() у arduino.
Наконец-то пришли соленойдные клапаны. Процесс автоматизации продолжается. | https://habr.com/ru/post/241463/ | null | ru | null |
# Портирование MIPSfpga на другие платы и интеграция периферии в систему. Часть 2
MIPSfpga микропроцессор MIPS32 microAptiv описаный на языке Verilog для образовательных целей фирмы Imagination, который имеет кэш-память и блок управления памятью. Код процессора доступен пользователю ([инструкция по скачиванию](http://www.silicon-russia.com/2015/12/11/mipsfpga-download-instructions/)) и может использоваться для моделирования и реализации процессора на FPGA плате.
Данная статья является продолжением статьи о том [как портировать MIPSfpga-plus на другие платы](https://habrahabr.ru/post/329808/), и в ней будет описано как интегрировать периферию в систему MIPSfpga-plus на примере 16 кнопочной клавиатуры Digillent Pmod KYPD:
Подключение клавиатуры к процессору позволит пользователю общаться с ним. В общем 16 кнопочные клавиатуры бывают в различных представлениях, но реализация и принцип работы у них одинаковый. Поэтому, по даному примеру можно интегрировать и схожие клавиатуры.
Интеграция встроенного в плату АЦП, а так же подключения дисплея от Nokia 5100 описана в следующей части моего tutorial:
[Портирование MIPSfpga на другие платы и интеграция периферии в систему. Часть 3](https://habrahabr.ru/post/329854/)
Так же о том как начать работать с MIPSfpga написано в [статье](https://habrahabr.ru/post/275215/).
Архитектура MIPS является одной из первых архитектур компьютеров с сокращенным набором команд (RISC). Она появилась в результате исследований в Стэнфордском университете в 1981 году и революционно увеличила эффективность компьютерных архитектур. Коммерческое применение архитектуры MIPS началось в 1984 году фирмой 2 MIPSfpga: Начало работы Imagination Technologies v1.3, 1 марта, 2016 MIPS Computer Systems, которая в 2013 году была приобретена компанией Imagination Technologies.
Процессоры MIPS использовались в высокопроизводительных рабочих станциях Silicon Graphics, которые производились в 1980 и 1990 годах. Первым коммерчески успешным продуктом был процессор MIPS R3000, который имел пятистадийный конвейер. За ним последовал R4000, в котором были добавлены 64-разрядные команды, суперскалярный R8000, процессор с внеочередным выполнением команд R10000 и множество других высокопроизводительных ядер.
Со временем архитектура MIPS эволюционировала для применений в недорогих изделиях с малым энергопотреблением, таких как бытовые электронные устройства, сетевое оборудование, микроконтроллеры. Семейство M4K базируется на классической 32-разрядной архитектуре с пятистадийным конвейером. В семействе M14K добавлен набор 16-разрядных инструкций microMIPS, что позволяет уменьшить размер программ для встраиваемых приложений, в которых очень важна стоимость. В семействе microAptiv набор инструкций M14K расширен дополнительными инструкциями цифровой обработки сигналов. Ядро M14K существует в двух вариантах: микроконтроллерном (UC) и микропроцессорном (UP). Микропроцессорный вариант содержит кэш-память и поддерживает виртуальную память, что обеспечивает возможность запуска операционной системы, такой как Linux или Android. Возможно, вы знакомы с популярной линейкой микроконтроллеров PIC32 фирмы Microchip, которая основана на архитектуре M4K.
Процессор использует интерфейс памяти для связи с периферийными устройствами. То есть, это означает что данные записываются и считываются с подключенной периферии так же, как и с блока памяти RAM. Интеграция периферии в процессор осуществляется подключением к шине AHB-Lite ([подробная документация](https://github.com/zhelnio/memos/blob/master/public/02_mips_uart/doc/D2_MicroAptiv_UP_AHB_Lite_Interface_MD01082.pdf)). Подробней попробуем разобраться в процессе подключения.
Для начала нужно иметь понятие как будут проходить сигналы по шине AHB-Lite:
Видно, что процесс считывания данных с периферии осуществляется по сигналу HRDATA, передача данных производится по HWRITE с активным высоким уровнем на сигнале разрешения записи, выбор GPIO осуществляется выбором адреса на HADDR.
1. Подключение клавиатуры Digilent Pmod KYPD
--------------------------------------------
Первым датчиком который был подключён это 16 кнопочный pmod KYPD ([даташит](https://reference.digilentinc.com/_media/reference/pmod/pmodkypd/pmodkypd_rm.pdf)).
В моем случае для подключения клавиатуры был использован интерфейс Pmod, но можно использовать любые другие пины вашей платы, но тогда в файле с ограничениями \*.xdc нужно будет их прописать. К каким пинам подключать клавиатуру описано ниже в таблице.
Распиновка и сигналы клавиатуры описаны в таблице:
| Пин | Сигнал | Назначение | Пин | Сигнал | Назначение |
| --- | --- | --- | --- | --- | --- |
| 1 | Col4 | 4 колонка | 7 | ROW4 | 4 ряд |
| 2 | Col3 | 3 колонка | 8 | ROW3 | 3 ряд |
| 3 | Col2 | 2 колонка | 9 | ROW2 | 2 ряд |
| 4 | Col1 | 1 колонка | 10 | ROW1 | 1 ряд |
| 5 | GND | контакт земли | 11 | GND | контакт земли |
| 6 | GND | контакт питания | 12 | VCC | контакт питания |
Схема подключения клавиатуры очень простая:
Следующим шагом для интеграции клавиатуры к шине AHB-lite будет написание модуля на Verilog.
Клавиатура использует 4 ряда и столбца для создания массива з 16 тактовых кнопок.
На схеме показано что ряды подтянуты к питанию сопротивлениями в R=10к, это значит что путем приведения в действие линии столбцов на низкий логический уровень подается тактовый сигнал с определенной частотой. В момент когда активный сигнал на входе совпадёт с колонкой (col) на которой нажата кнопка на выходе рядка появится низкий уровень. Для реализации такого процесса нужно написать дешифратор (пример реализации модуля так же описан в данной [статье](https://habrahabr.ru/post/323360/)).
Сам модуль имеет вид:
```
module kypd_decoder(
input i_clk,
input i_rst_n,
input [3:0] i_row,
output reg [3:0] o_col,
output reg [3:0] o_number
);
reg [19:0] counter;
reg [3:0] col;
reg [3:0] row;
// row col
parameter ZERO = 8'b11100111,
ONE = 8'b01110111,
TWO = 8'b01111011,
THREE = 8'b01111101,
FOUR = 8'b10110111,
FIVE = 8'b10111011,
SIX = 8'b10111101,
SEVEN = 8'b11010111,
EIGHT = 8'b11011011,
NINE = 8'b11011101,
A = 8'b01111110,
B = 8'b10111110,
C = 8'b11011110,
D = 8'b11101110,
E = 8'b11101101,
F = 8'b11101011;
always @(posedge i_clk or negedge i_rst_n)
if (i_rst_n == 0)
counter <= 20'b0;
else
counter <= counter + 1'b1;
always @(posedge i_clk or negedge i_rst_n)
if (i_rst_n == 1'b0) begin
o_col <= 4'b1110;
col <= 4'b1110;
row <= 4'b1111;
end else if (!counter) begin
o_col <= {o_col [0], o_col [3:1]};
col <= o_col;
row <= i_row;
end
always @(posedge i_clk or negedge i_rst_n)
if (i_rst_n == 0)
o_number <= 4'b0;
else
case ({row, col})
ZERO: o_number <= 4'h0;
ONE: o_number <= 4'h1;
TWO: o_number <= 4'h2;
THREE: o_number <= 4'h3;
FOUR: o_number <= 4'h4;
FIVE: o_number <= 4'h5;
SIX: o_number <= 4'h6;
SEVEN: o_number <= 4'h7;
EIGHT: o_number <= 4'h8;
NINE: o_number <= 4'h9;
A: o_number <= 4'hA;
B: o_number <= 4'hB;
C: o_number <= 4'hC;
D: o_number <= 4'hD;
E: o_number <= 4'hE;
F: o_number <= 4'hF;
endcase
endmodule
```
Схема модуля в Vivado будет иметь вид:
Если кратко, то добавить модуль дешифратора в проект Vivado нужно так: Add Sources → Add or create design sources → Next → Create File → (написать имя файла) → Ok → Ok → Yes. Создан пустой Verilog файл, после создания файла, нужно его найти в иерархии системы MIPSfpga-plus, написать код дешифратора и сохранить. Более подробное описание как добавить модуль в проект и просто как работать с Vivado описано в предыдущей моей статье:
[Портирование MIPSfpga на другие платы и интеграция периферии в систему. Часть 1](https://habrahabr.ru/post/329808/)
Теперь приступим к подключению входов и выходов к шине AHB-Lite и физическим выходам нашей платы.
Иерархия mipsfpga\_ahb имеет вид:
Для начала в директории Verilog Header mfp\_ahb\_lite\_matrix\_config.vh пропишем с помощью директивы `define название периферии которую будем подключать. Для этого найдем строку с идентификатором добавления в систему датчика освещённости (подробнее о датчике описано в предыдущей статье):
Строку нужно закомментировать, это позволит выключить все строки которые связаны с кодом подключения датчика освещённости к шине AHB-Lite:
```
//`define MFP_DEMO_LIGHT_SENSOR
```
Пропишем и расскоментируем строку для нащей периферии:
```
`define MFP_PMOD_KYPD
```
Откроем «mfp\_system» найдем строки подключения екземпляра датчика освещенности:
```
`ifdef MFP_DEMO_LIGHT_SENSOR
```
И рядом добавим екземпляр своего модуля дешифратора:
```
`ifdef MFP_PMOD_KYPD
kypd_decoder kypd_decoder
(
.i_clk ( SI_ClkIn ),
.i_rst_n ( KEY_0 ),
.o_col ( KYPD_DATA [3:0] ),
.i_row ( KYPD_DATA [7:4] ),
.o_number ( KYPD_OUT )
);
`endif
```
Сигналы модуля дешифратора нужно подключить к екземпляру шины mfp\_ahb\_lite\_matrix\_with\_loader (где прописывать нужные строчки можно смотреть по примеру интеграции датчика освещённости с помощью поиска по модулю MFP\_DEMO\_LIGHT\_SENSOR):
```
`ifdef MFP_PMOD_KYPD
.KYPD_OUT ( KYPD_OUT ),
`endif
```
Для соединения экземпляров модуля дешифратора и шины добавим сигнал типа wire:
```
`ifdef MFP_PMOD_KYPD
wire [3:0] KYPD_OUT;
`endif
```
После подключения нашего модуля дешифратора к шине перейдём в «mfp\_ahb\_lite\_matrix\_with\_loader» который находится по иерархии ниже модуля «mfp\_system» и добавим порт ввода/вывода:
```
`ifdef MFP_PMOD_KYPD
input [3:0] KYPD_OUT,
`endif
```
Так же добавим эти сигналы в екземпляр «mfp\_ahb\_lite\_matrix»:
```
`ifdef MFP_PMOD_KYPD
.KYPD_OUT ( KYPD_OUT ),
`endif
```
Те же действия проделаем в «mfp\_ahb\_lite\_matrix» который находится по иерархии ниже модуля «mfp\_ahb\_lite\_matrix\_with\_loader» и добавим порт ввода/вывода:
```
`ifdef MFP_PMOD_KYPD
input [3:0] KYPD_OUT,
`endif
```
Так же добавим эти сигналы в екземпляр «mfp\_ahb\_gpio\_slave»:
```
`ifdef MFP_PMOD_KYPD
.KYPD_OUT ( KYPD_OUT ),
`endif
```
Перейдем в модуль «mfp\_ahb\_gpio\_slave», это именно тот блок (GPIO) в который мы так рвались, добавим порт ввода/вывода:
```
`ifdef MFP_PMOD_KYPD
input [3:0] KYPD_OUT,
`endif
```
Теперь следует изменить модуль «mfp\_ahb\_gpio\_slave» так, чтобы он обнаруживал адрес ввода/вывода с отображением в память (которые мы ещё определим) и записывал данные (HWDATA) в соответствующий обнаруженному адресу регистр:
```
`ifdef MFP_PMOD_KYPD
`MFP_PMOD_KYPD_IONUM : HRDATA <= { 28'b0, KYPD_OUT };
`endif
```
Чтобы указать адрес по которому мы будем обращаться, откроем заголовочный файл «mfp\_ahb\_lite\_matrix\_config.vh» и добавим:
```
`ifdef MFP_PMOD_KYPD
`define MFP_PMOD_KYPD_ADDR 32'h1f800018
`endif
```
Модуль GPIO использует младшие биты адреса, чтобы определить, с каким периферийным устройством следует осуществлять операцию чтения или записи информации.
```
`ifdef MFP_PMOD_KYPD
`define MFP_PMOD_KYPD_IONUM 4'h6
`endif
```
Вернемся назад по иерархии в модуль «mfp\_system» и добавим порты ввода/вывода:
```
`ifdef MFP_PMOD_KYPD
inout [7:0] KYPD_DATA,
input KEY_0,
`endif
```
Стоит заметить что это уже не совсем те порты которые мы подключали к шине. Перейдем в топ модуль оболочку (у меня «cmoda7») и добавим в екземпляр «mfp\_system» строчки:
```
`ifdef MFP_PMOD_KYPD
.KYPD_DATA ( JA ),
.KEY_0 ( ~ i_btn1 ),
`endif
```
Таким образом мы добавили к JA[7:0] выводам модуль нашего декодера и соединили декодер с процессором по шине AHB-Lite.
В нашем случае порты ввода/вывода JA в модуле оболочке и в файле ограничений (у меня «cmoda7.xdc») добавлять не потребуется так как они уже использовались для датчика освещённости. Но в других случаях такие действия потребуются, потому для понимания я просто покажу эти строки:
```
module cmoda7
(
...
...
...
inout [ 7:0] JA
);
```
**cmoda7.xdc**
```
## Pmod Header JA
set_property -dict {PACKAGE_PIN G17 IOSTANDARD LVCMOS33} [get_ports {JA[0]}]
set_property -dict {PACKAGE_PIN G19 IOSTANDARD LVCMOS33} [get_ports {JA[1]}]
set_property -dict {PACKAGE_PIN N18 IOSTANDARD LVCMOS33} [get_ports {JA[2]}]
set_property -dict {PACKAGE_PIN L18 IOSTANDARD LVCMOS33} [get_ports {JA[3]}]
set_property -dict {PACKAGE_PIN H17 IOSTANDARD LVCMOS33} [get_ports {JA[4]}]
set_property -dict {PACKAGE_PIN H19 IOSTANDARD LVCMOS33} [get_ports {JA[5]}]
set_property -dict {PACKAGE_PIN J19 IOSTANDARD LVCMOS33} [get_ports {JA[6]}]
set_property -dict {PACKAGE_PIN K18 IOSTANDARD LVCMOS33} [get_ports {JA[7]}]
```
И если мы вспомним в «mfp\_ahb\_lite\_matrix\_config.vh» мы закомментировали строку:
```
//`define MFP_DEMO_LIGHT_SENSOR
```
тем самым при синтезе системы весь код прописаный между
```
`ifdef MFP_DEMO_LIGHT_SENSOR
...
`endif
```
будет игнорироваться, и конфликтов использования портов не будет.
Мы можем посмотреть схему созданой системы MIPSfpga-plus со встроенным дешифратором для нашей клавиатуры, для этого откройте во вкладке RTL Analysys → Open Elaborated Design → Schematic. Здесь отображается вся схема системы, чтобы проверить правильность подключёного модуля дешифратора желательно пройтись по RTL Netlist и проверить все контакты.
Теперь можно сгенерировать bitstream файл (.bit) и загрузить в FPGA.
Напишем простую программу для взаимодействия клавиатуры и процессора.
Для загрузки кода в систему нужно перейти в папку скачаного mipsfpga plus → github → mipsfpga-plus → programs → 01\_pmod\_kypd откроем «mfp\_memory\_mapped\_registers.h»
```
#define MFP_PMOD_KYPD_ADDR 0xBF800018
и
#define MFP_PMOD_KYPD (* (volatile unsigned *) MFP_PMOD_KYPD_ADDR )
```
далее откроем main.c и напишем пару строк для демонстрации:
```
#include "mfp_memory_mapped_registers.h"
int main ()
{
int n = 0;
for (;;)
{
MFP_7_SEGMENT_HEX = MFP_PMOD_KYPD;
}
return 0;
}
```
После в папке находим скрипт который компилирует код:
```
02_compile_and_link
```
Генерируем motorola\_s\_record файл:
```
08_generate_motorola_s_record_file
```
Проверяем к какому СОМ порту подключен USB UART преобразователь:
```
11_check_which_com_port_is_used
```
Изменяем файл 12\_upload\_to\_the\_board\_using\_uart:
```
set a=7
mode com%a% baud=115200 parity=n data=8 stop=1 to=off xon=off odsr=off octs=off dtr=off rts=off idsr=off type program.rec >\.\COM%a%
```
где а – номер СОМ порта, к которому подключен USB UART преобразователь. И загружаем программу:
```
12_upload_to_the_board_using_uart
```
Результат:
В следующей части расскажу как добавить в MIPSfpga встроеный в cmoda7 АПЦ, и LCD дисплей от Nokia 5100.
[Портирование MIPSfpga на другие платы и интеграция периферии в систему. Часть 3](https://habrahabr.ru/post/329854/) | https://habr.com/ru/post/329852/ | null | ru | null |
# Простота и cложность примитивов или как определить ненужный препроцессинг для нейронной сети
Это третья статья по анализу и изучению эллипсов, треугольников и других геометрических фигур.
Предыдущие статьи вызвали у читателей несколько очень интересных вопросов, в частности о сложности или простоте тех или иных обучающих последовательностей. Вопросы на самом деле очень интересные, например насколько треугольник сложнее для обучения, чем четырехугольник или другой многоугольник?
Попробуем сравнить, и для сравнения у нас есть отличная, проверенная поколениями студентов, идея — чем короче шпаргалка, тем легче экзамен.
Статья эта тоже есть просто результат любопытства и праздного интереса, ничего из нее в практике не встречается и для практических задач тут есть пара отличных идей, но нет почти ничего для копипастинга. Это небольшое исследование сложности обучающих последовательностей — рассуждения автора и код изложены, можно все проверить/дополнить/изменить самим.
Итак, попробуем выяснить, какая геометрическая фигура сложнее или проще для сегментации, какой курс лекций для ИИ понятней и лучше усваивается.
Геометрических фигур много разных, но мы будем сравнивать только треугольники, четырехугольники и пятиконечные звезды. Мы применим простой метод построения трейн последовательности — мы разделим 128х128 одноцветной картинки на четыре части и случайным образом будем помещать в эти четверти эллипс и, например, треугольник. Будем детектить треугольник того же цвета, что и эллипс. Т.е. задача состоит в том, что бы обучить сеть отличать, например четырехугольный полигон от эллипса, окрашенного в тот же цвет. Вот примеры картинок, которые будем изучать
Мы не будем детектить на одной картинке треугольник и четырехугольник, мы будем детектить их отдельно, в разных трейн, на фоне помехи в виде эллипса.
Возьмем для исследования классическую U-net и три вида обучающих последовательностей с треугольниками, четырехугольниками и звездами.
Итак, дано:
* три обучающие последовательности пар картинка/маска;
* сеть. Обыкновенная U-net, которая широко используются для сегментации.
Идея для проверки:
* определим, какая из обучающих последовательностей «сложнее» для обучения;
* как влияют на обучение некоторые приемы предобработки.
Начнем, выберем 10 000 пар картинок четырехугольников с эллипсами и масок и рассмотрим их внимательно. Нам интересно, насколько короткой получится шпаргалка и от чего её длина зависит.
**Загружаем библиотеки, определяем размеры массива картинок**
```
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import math
from tqdm import tqdm
from skimage.draw import ellipse, polygon
from keras import Model
from keras.optimizers import Adam
from keras.layers import Input,Conv2D,Conv2DTranspose,MaxPooling2D,concatenate
from keras.layers import BatchNormalization,Activation,Add,Dropout
from keras.losses import binary_crossentropy
from keras import backend as K
import tensorflow as tf
import keras as keras
w_size = 128
train_num = 10000
radius_min = 10
radius_max = 20
```
**определяем функции потерь и точности**
```
def dice_coef(y_true, y_pred):
y_true_f = K.flatten(y_true)
y_pred = K.cast(y_pred, 'float32')
y_pred_f = K.cast(K.greater(K.flatten(y_pred), 0.5), 'float32')
intersection = y_true_f * y_pred_f
score = 2. * K.sum(intersection) / (K.sum(y_true_f) + K.sum(y_pred_f))
return score
def dice_loss(y_true, y_pred):
smooth = 1.
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = y_true_f * y_pred_f
score = (2. * K.sum(intersection) + smooth) / (K.sum(y_true_f) +
K.sum(y_pred_f) + smooth)
return 1. - score
def bce_dice_loss(y_true, y_pred):
return binary_crossentropy(y_true, y_pred) + dice_loss(y_true, y_pred)
def get_iou_vector(A, B):
# Numpy version
batch_size = A.shape[0]
metric = 0.0
for batch in range(batch_size):
t, p = A[batch], B[batch]
true = np.sum(t)
pred = np.sum(p)
# deal with empty mask first
if true == 0:
metric += (pred == 0)
continue
# non empty mask case. Union is never empty
# hence it is safe to divide by its number of pixels
intersection = np.sum(t * p)
union = true + pred - intersection
iou = intersection / union
# iou metrric is a stepwise approximation of the real iou over 0.5
iou = np.floor(max(0, (iou - 0.45)*20)) / 10
metric += iou
# teake the average over all images in batch
metric /= batch_size
return metric
def my_iou_metric(label, pred):
# Tensorflow version
return tf.py_func(get_iou_vector, [label, pred > 0.5], tf.float64)
from keras.utils.generic_utils import get_custom_objects
get_custom_objects().update({'bce_dice_loss': bce_dice_loss })
get_custom_objects().update({'dice_loss': dice_loss })
get_custom_objects().update({'dice_coef': dice_coef })
get_custom_objects().update({'my_iou_metric': my_iou_metric })
```
Мы будем использовать метрику из [первой статьи](https://habr.com/company/ods/blog/431512/). Напомню читателям, что будем предсказывать маску пикселя — это «фон» или «четырехугольник» и оценивать истинность или ложность предсказания. Т.е. возможны следующие четыре варианта — мы правильно предсказали, что пиксель это фон, правильно предсказали, что пиксель это четырехугольник или ошиблись в предсказании «фон» или «четырехугольник». И так по всем картинкам и всем пикселям оцениваем количество всех четырех вариантов и подсчитываем результат — это и будет результат работы сети. И чем меньше ошибочных предсказаний и больше истинных, то тем точнее полученный результат и лучше работа сети.
Мы исследуем сеть как «черный ящик», мы не станем смотреть, что происходит с сетью внутри, как меняются веса и как выбираются градиенты — заглянем в недра сети попозже, когда будем сравнивать сети.
**простая U-net**
```
def build_model(input_layer, start_neurons):
# 128 -> 64
conv1 = Conv2D(start_neurons * 1, (3, 3), activation="relu", padding="same")(input_layer)
conv1 = Conv2D(start_neurons * 1, (3, 3), activation="relu", padding="same")(conv1)
pool1 = MaxPooling2D((2, 2))(conv1)
pool1 = Dropout(0.25)(pool1)
# 64 -> 32
conv2 = Conv2D(start_neurons * 2, (3, 3), activation="relu", padding="same")(pool1)
conv2 = Conv2D(start_neurons * 2, (3, 3), activation="relu", padding="same")(conv2)
pool2 = MaxPooling2D((2, 2))(conv2)
pool2 = Dropout(0.5)(pool2)
# 32 -> 16
conv3 = Conv2D(start_neurons * 4, (3, 3), activation="relu", padding="same")(pool2)
conv3 = Conv2D(start_neurons * 4, (3, 3), activation="relu", padding="same")(conv3)
pool3 = MaxPooling2D((2, 2))(conv3)
pool3 = Dropout(0.5)(pool3)
# 16 -> 8
conv4 = Conv2D(start_neurons * 8, (3, 3), activation="relu", padding="same")(pool3)
conv4 = Conv2D(start_neurons * 8, (3, 3), activation="relu", padding="same")(conv4)
pool4 = MaxPooling2D((2, 2))(conv4)
pool4 = Dropout(0.5)(pool4)
# Middle
convm = Conv2D(start_neurons * 16, (3, 3), activation="relu", padding="same")(pool4)
convm = Conv2D(start_neurons * 16, (3, 3), activation="relu", padding="same")(convm)
# 8 -> 16
deconv4 = Conv2DTranspose(start_neurons * 8, (3, 3), strides=(2, 2), padding="same")(convm)
uconv4 = concatenate([deconv4, conv4])
uconv4 = Dropout(0.5)(uconv4)
uconv4 = Conv2D(start_neurons * 8, (3, 3), activation="relu", padding="same")(uconv4)
uconv4 = Conv2D(start_neurons * 8, (3, 3), activation="relu", padding="same")(uconv4)
# 16 -> 32
deconv3 = Conv2DTranspose(start_neurons * 4, (3, 3), strides=(2, 2), padding="same")(uconv4)
uconv3 = concatenate([deconv3, conv3])
uconv3 = Dropout(0.5)(uconv3)
uconv3 = Conv2D(start_neurons * 4, (3, 3), activation="relu", padding="same")(uconv3)
uconv3 = Conv2D(start_neurons * 4, (3, 3), activation="relu", padding="same")(uconv3)
# 32 -> 64
deconv2 = Conv2DTranspose(start_neurons * 2, (3, 3), strides=(2, 2), padding="same")(uconv3)
uconv2 = concatenate([deconv2, conv2])
uconv2 = Dropout(0.5)(uconv2)
uconv2 = Conv2D(start_neurons * 2, (3, 3), activation="relu", padding="same")(uconv2)
uconv2 = Conv2D(start_neurons * 2, (3, 3), activation="relu", padding="same")(uconv2)
# 64 -> 128
deconv1 = Conv2DTranspose(start_neurons * 1, (3, 3), strides=(2, 2), padding="same")(uconv2)
uconv1 = concatenate([deconv1, conv1])
uconv1 = Dropout(0.5)(uconv1)
uconv1 = Conv2D(start_neurons * 1, (3, 3), activation="relu", padding="same")(uconv1)
uconv1 = Conv2D(start_neurons * 1, (3, 3), activation="relu", padding="same")(uconv1)
uncov1 = Dropout(0.5)(uconv1)
output_layer = Conv2D(1, (1,1), padding="same", activation="sigmoid")(uconv1)
return output_layer
# model
input_layer = Input((w_size, w_size, 1))
output_layer = build_model(input_layer, 26)
model = Model(input_layer, output_layer)
model.compile(loss=bce_dice_loss, optimizer=Adam(lr=1e-4), metrics=[my_iou_metric])
model.summary()
```
Функция генерации пар картинка/маска. На черно-белой картинке 128х128 заполненной случайным шумом со случайно выбранным из двух диапазонов, или 0.0...0.75 или 0.25..1.0. Случайным образом выбираем четверть на картинке и размещаем случайно ориентированный эллипс и в другой четверти размещаем четырехугольник и одинаково раскрашиваем случайным шумом.
```
def next_pair():
img_l = (np.random.sample((w_size, w_size, 1))*
0.75).astype('float32')
img_h = (np.random.sample((w_size, w_size, 1))*
0.75 + 0.25).astype('float32')
img = np.zeros((w_size, w_size, 2), dtype='float')
i0_qua = math.trunc(np.random.sample()*4.)
i1_qua = math.trunc(np.random.sample()*4.)
while i0_qua == i1_qua:
i1_qua = math.trunc(np.random.sample()*4.)
_qua = np.int(w_size/4)
qua = np.array([[_qua,_qua],[_qua,_qua*3],[_qua*3,_qua*3],[_qua*3,_qua]])
p = np.random.sample() - 0.5
r = qua[i0_qua,0]
c = qua[i0_qua,1]
r_radius = np.random.sample()*(radius_max-radius_min) + radius_min
c_radius = np.random.sample()*(radius_max-radius_min) + radius_min
rot = np.random.sample()*360
rr, cc = ellipse(
r, c,
r_radius, c_radius,
rotation=np.deg2rad(rot),
shape=img_l.shape
)
p0 = np.rint(np.random.sample()*(radius_max-radius_min) + radius_min)
p1 = qua[i1_qua,0] - (radius_max-radius_min)
p2 = qua[i1_qua,1] - (radius_max-radius_min)
p3 = np.rint(np.random.sample()*radius_min)
p4 = np.rint(np.random.sample()*radius_min)
p5 = np.rint(np.random.sample()*radius_min)
p6 = np.rint(np.random.sample()*radius_min)
p7 = np.rint(np.random.sample()*radius_min)
p8 = np.rint(np.random.sample()*radius_min)
poly = np.array((
(p1, p2),
(p1+p3, p2+p4+p0),
(p1+p5+p0, p2+p6+p0),
(p1+p7+p0, p2+p8),
(p1, p2),
))
rr_p, cc_p = polygon(poly[:, 0], poly[:, 1], img_l.shape)
if p > 0:
img[:,:,:1] = img_l.copy()
img[rr, cc,:1] = img_h[rr, cc]
img[rr_p, cc_p,:1] = img_h[rr_p, cc_p]
else:
img[:,:,:1] = img_h.copy()
img[rr, cc,:1] = img_l[rr, cc]
img[rr_p, cc_p,:1] = img_l[rr_p, cc_p]
img[:,:,1] = 0.
img[rr_p, cc_p,1] = 1.
return img
```
Создадим обучающую последовательность пар, посмотрим случайные 10. Напомню, что картинки монохромные, градации серого.
```
_txy = [next_pair() for idx in range(train_num)]
f_imgs = np.array(_txy)[:,:,:,:1].reshape(-1,w_size ,w_size ,1)
f_msks = np.array(_txy)[:,:,:,1:].reshape(-1,w_size ,w_size ,1)
del(_txy)
# смотрим на случайные 10 с масками
fig, axes = plt.subplots(2, 10, figsize=(20, 5))
for k in range(10):
kk = np.random.randint(train_num)
axes[0,k].set_axis_off()
axes[0,k].imshow(f_imgs[kk])
axes[1,k].set_axis_off()
axes[1,k].imshow(f_msks[kk].squeeze())
```
### Первый шаг. Обучаем на минимальном стартовом множестве
Первый шаг нашего эксперимента простой, мы пробуем обучить сеть предсказывать всего 11 первых картинок.
```
batch_size = 10
val_len = 11
precision = 0.85
m0_select = np.zeros((f_imgs.shape[0]), dtype='int')
for k in range(val_len):
m0_select[k] = 1
t = tqdm()
while True:
fit = model.fit(f_imgs[m0_select>0], f_msks[m0_select>0],
batch_size=batch_size,
epochs=1,
verbose=0
)
current_accu = fit.history['my_iou_metric'][0]
current_loss = fit.history['loss'][0]
t.set_description("accuracy {0:6.4f} loss {1:6.4f} ".\
format(current_accu, current_loss))
t.update(1)
if current_accu > precision:
break
t.close()
```
`accuracy 0.8545 loss 0.0674 lenght 11 : : 793it [00:58, 14.79it/s]`
Мы выбрали из исходной последовательности первые 11 и обучили сеть на них. Сейчас не важно, заучивает сеть конкретно эти картинки или обобщает, главное, что эти 11 картинок она может распознать так, как нам нужно. В зависимости от выбранного датасета и точности, обучение сети может продолжаться долго, очень долго. Но у нас всего несколько итераций. Повторю, что нам сейчас не важно как и что заучила или выучила сеть, главное, что она достигла установленной точности предсказания.
### Теперь начнем главный эксперимент
Построим шпаргалку, будем строить такие шпаргалки раздельно для всех трех обучающих последовательностей и сравнивать их длину. Мы будем брать новые пары картинка/маска из построенной последовательности и будем пытаться предсказать их сетью обученной на уже отобранной последовательности. В начале это всего 11 пар картинка/маска и сеть обучена, возможно и не очень корректно. Если в новой паре маска по картинке предсказывается с приемлемой точностью, то эту пару выбрасываем, в ней нет новой информации для сети, она уже знает и может вычислить по этой картинке маску. Если же точность предсказания недостаточна, то эту картинку с маской добавляем в нашу последовательность и начинаем тренировать сеть до достижения приемлемого результата точности на отобранной последовательности. Т.е. эта картинка содержит новую информацию и мы её добавляем в наш обучающую последовательность и извлекаем тренировкой содержащуюся в ней информацию.
```
batch_size = 50
t_batch_size = 1024
raw_len = val_len
t = tqdm(-1)
id_train = 0
#id_select = 1
while True:
t.set_description("Accuracy {0:6.4f} loss {1:6.4f}\
selected img {2:5d} tested img {3:5d} ".
format(current_accu, current_loss, val_len, raw_len))
t.update(1)
if id_train == 1:
fit = model.fit(f_imgs[m0_select>0], f_msks[m0_select>0],
batch_size=batch_size,
epochs=1,
verbose=0
)
current_accu = fit.history['my_iou_metric'][0]
current_loss = fit.history['loss'][0]
if current_accu > precision:
id_train = 0
else:
t_pred = model.predict(
f_imgs[raw_len: min(raw_len+t_batch_size,f_imgs.shape[0])],
batch_size=batch_size
)
for kk in range(t_pred.shape[0]):
val_iou = get_iou_vector(
f_msks[raw_len+kk].reshape(1,w_size,w_size,1),
t_pred[kk].reshape(1,w_size,w_size,1) > 0.5)
if val_iou < precision*0.95:
new_img_test = 1
m0_select[raw_len+kk] = 1
val_len += 1
break
raw_len += (kk+1)
id_train = 1
if raw_len >= train_num:
break
t.close()
```
```
Accuracy 0.9338 loss 0.0266 selected img 1007 tested img 9985 : : 4291it [49:52, 1.73s/it]
```
Здесь accuracy используется в смысле «точность», а не как стандартная метрика keras и для вычисления точности используется подпрограмма «my\_iou\_metric».
А теперь сравним работу той же самой сети с теми же самыми параметрами на другой последовательности, на треугольниках
И получим совсем другой результат
```
Accuracy 0.9823 loss 0.0108 selected img 1913 tested img 9995 : : 6343it [2:11:36, 3.03s/it]
```
Сеть выбрала 1913 картинок с «новой» информацией, т.е. содержательность картинок с треугольниками получается в два раза ниже, чем с четырехугольниками!
Проверим то же самое на звездах и запустим сеть на третьей последовательности
получим
```
Accuracy 0.8985 loss 0.0478 selected img 476 tested img 9985 : : 2188it [16:13, 1.16it/s]
```
Как видим, звезды оказались наиболее информативными, всего 476 картинок в шпаргалке.
У нас появились основания судить о сложности геометрических фигур для восприятия их нейронной сетью. Самая простая это звезда, всего 476 картинок в шпаргалке, далее четырехугольник с его 1007 и самым сложным оказался треугольник — для обучения нужно 1913 картинок.
Учтите, это для нас, для людей это картинки, а для сети это курс лекций по распознаванию и курс про треугольники оказался самым сложным.
### Теперь о серьезном
На первый взгляд все эти эллипсы и треугольники кажутся баловством, куличи из песка и лего. Но вот конкретный и серьезный вопрос: если к исходной последовательности применить какую нибудь предобработку, фильтр, то как изменится сложность последовательности? Например, возьмем всё те же эллипсы и четырехугольники и применим к ним вот такую предобработку
```
from scipy.ndimage import gaussian_filter
_tmp = [gaussian_filter(idx, sigma = 1) for idx in f_imgs]
f1_imgs = np.array(_tmp)[:,:,:,:1].reshape(-1,w_size ,w_size ,1)
del(_tmp)
fig, axes = plt.subplots(2, 5, figsize=(20, 7))
for k in range(5):
kk = np.random.randint(train_num)
axes[0,k].set_axis_off()
axes[0,k].imshow(f1_imgs[kk].squeeze(), cmap="gray")
axes[1,k].set_axis_off()
axes[1,k].imshow(f_msks[kk].squeeze(), cmap="gray")
```
На первый взгляд всё то же самое, такие же эллипсы, такие же полигоны, но сеть стала работать совсем по-другому:
```
Accuracy 1.0575 loss 0.0011 selected img 7963 tested img 9999 : : 17765it [29:02:00, 12.40s/it]
```
Тут необходимо небольшое пояснение, мы не используем аугментацию, т.к. форма полигона и форма эллипса изначально выбираются случайно. Поэтому аугментаци не даст новой информации и не имеет смысла с данном случае.
Но, как видно из результата работы, простой gaussian\_filter создал сети много проблем, породил много новой, и наверно лишней, информации.
Ну и для любителей простоты в чистом виде, возьмем те же самые эллипсы с полигонами, но без какой бы то ни было случайности в цвете
результат говорит о том, что случайный цвет совсем не простая добавка.
```
Accuracy 0.9004 loss 0.0315 selected img 251 tested img 9832 : : 1000it [06:46, 1.33it/s]
```
Сеть вполне обошлась информацией, извлеченной из 251 картинки, почти в четыре раза меньше, чем из множества картинок раскрашенных шумом.
Цель статьи показать некоторый инструмент и примеры его работы на несерьезных примерах, лего в песочнице. Мы получили инструмент сравнения двух обучающих последовательностей, мы можем оценить насколько наша предобработка усложняет или упрощает обучающую последовательность, насколько тот или иной примитив в обучайющей последовательности прост для детекции.
Возможность применения этого лего примера в реальных делах очевидна, но реальные трейны и сети читателей дело самих читателей. | https://habr.com/ru/post/439122/ | null | ru | null |
# Java HotSpot JIT компилятор — устройство, мониторинг и настройка (часть 2)
В [предыдущей](https://habr.com/ru/post/536288/) статье мы рассмотрели устройство JIT компилятора и способы мониторинга его работы. В этой статье мы рассмотрим счетчики, которые JVM использует для принятия решения о необходимости компиляции кода, потоки компиляции, оптимизации, выполняемые JVM при компиляции, а также что такое деоптимизация кода.
Счетчики вызовов методов и итераций циклов
------------------------------------------
Главным фактором влияющим на решение JVM о компиляции какого-либо кода является частота его исполнения. Решение принимается на основе двух счетчиков: счетчика количества вызовов метода и счетчика количества итераций циклов в методе.
Когда JVM исполняет какой-либо метод, она проверяет значения этих двух счетчиков, и принимает решение о необходимости его компиляции. У этого типа компиляции нет официального названия, но часто его называют стандартной компиляцией.
Аналогично, после каждой итерации цикла проверяется значение счетчика цикла и принимается решение о необходимости его компиляции.
При выключенной многоуровневой компиляции стандартная компиляция управляется параметром **-XX:CompileThreshold**. Значением по умолчанию является 10000. Несмотря на то, что параметр всего один, превышение порога определяется суммой значений двух счетчиков. В настоящее время этот флаг ни на что не влияет (многоуровневая компиляция включена по умолчанию), но знать о нем полезно, ведь существует довольно много унаследованных систем.
Ранее уменьшением значения этого параметра добивались ускорения старта приложения при использовании серверного компилятора, поскольку это приводило к более ранней компиляции кода. Также уменьшение его значения могло способствовать компиляции методов, которые иначе никогда бы не скомпилировались.
Последнее утверждение довольно интересно. Ведь если программа исполняется бесконечно, не должен ли весь ее код в конце концов скомпилироваться? На самом деле не должен, поскольку значения счетчиков не только увеличиваются при каждом вызове метода или итерации цикла, но и периодически уменьшаются. Таким образом, они являются отражением текущего «нагрева» метода или цикла.
Получается, что до внедрения многоуровневой компиляции методы, выполнявшиеся довольно часто, но недостаточно часто, чтобы превысить порог, никогда бы не были скомпилированы. В настоящее время такие методы будут скомпилированы компилятором C1, хотя, возможно, их производительность была бы выше, будь они скомпилированы компилятором C2. При желании можно поиграть параметрами **-XX:Tier3InvocationThreshold** (значение по умолчанию 200) и **-XX:Tier4InvocationThreshold** (значение по умолчанию 5000), но вряд ли в этом есть большой практический смысл. Такие же параметры (**-XX:TierXBackEdgeThreshold**) существуют и для задания пороговых значений счетчиков циклов.
Потоки компиляции
-----------------
Как только JVM решает скомпилировать метод или цикл, они помещаются в очередь. Эта очередь приоритетная - чем выше значения счетчиков, тем выше приоритет. Это особенно помогает при старте приложения, когда необходимо компилировать огромное количество кода. Таким образом, более важный код будет скомпилирован раньше.
Компиляторы C1 и C2 имеют собственные очереди, каждая из которых может обрабатывается несколькими потоками. Существует специальная формула для вычисления количества потоков в зависимости от количества ядер. Некоторые значения приведены в таблице:
| | | |
| --- | --- | --- |
| **Количество ядер** | **Количество потоков C1** | **Количество потоков C2** |
| 1 | 1 | 1 |
| 2 | 1 | 1 |
| 4 | 1 | 2 |
| 8 | 1 | 2 |
| 16 | 2 | 6 |
| 32 | 3 | 7 |
| 64 | 4 | 8 |
| 128 | 4 | 10 |
Задать произвольное количество потоков можно параметром **-XX:CICompilerCount**. Это общее количество потоков компиляции, которое будет использовать JVM. При включенной многоуровневой компиляции одна треть из них (но минимум один) будут отданы компилятору C1, остальные достанутся компилятору C2. Значением по умолчанию для этого флага является сумма потоков из таблицы выше. При выключенной многоуровневой компиляции все потоки достанутся компилятору C2.
В каком случае имеет смысл менять настройки по умолчанию? Ранние версии Java 8 (до update 191) при запуске в Docker контейнере не корректно определяли количество ядер. Вместо количества ядер, выделенных контейнеру определялось количество ядер на сервере. В этом случае есть смысл задать количество потоков вручную, исходя из значений, приведенных в таблице выше.
Аналогично, при запуске приложения в одноядерной виртуальной машине может оказаться предпочтительнее иметь только один поток компиляции, чтобы избежать борьбы за процессорное время. Но надо иметь ввиду, что выгода от наличия всего одного потока проявляется только при старте и «прогреве» приложения, после этого количество методов, ожидающих компиляцию, будет не велико.
Еще один параметр, влияющий на количество потоков компиляции - это **-XX:+BackgroundCompilation**. Его значение по умолчанию - true. Он означает, что компиляция должна происходить в асинхронном режиме. Если установить его в false, каждый раз при наличии кода, который необходимо скомпилировать, JVM будет ожидать завершения компиляции, прежде чем этот код исполнить.
Оптимизации
-----------
Как мы знаем, JVM использует результаты профилирования методов в процессе компиляции. JVM хранит данные профиля в объектах, называемых method data objects (MDO). Объекты MDO используются интерпретатором и компилятором C1 для записи информации, которая затем используется для принятия решения о том, какие оптимизации возможно применить к компилируемому коду. Объекты MDO хранят информацию о вызванных методах, выбранных ветвях в операторах ветвления, наблюдаемых типах в точках вызова. Как только принято решение о компиляции, компилятор строит внутреннее представление компилируемого кода, которое затем оптимизируется. Компиляторы способны проводить широкий набор оптимизаций, включающий:
* встраивание (inlining);
* escape-анализ (escape-analysis);
* размотка (раскрутка) цикла (loop unrolling);
* мономорфная диспетчеризация (monomorphic dispatch);
* intrinsic-методы.
### Встраивание
Встраивание - это копирование вызываемого метода в место его вызова. Это позволяет устранить накладные расходы, связанные с вызовом метода, такие как:
* подготовка параметров;
* поиск по таблице виртуальных методов;
* создание и инициализация объекта Stack Frame;
* передача управления;
* опциональный возврат значения.
Встраивание является одной из оптимизаций, выполняемых JVM в первую очередь, оно включено по умолчанию. Отключить его можно флагом **-XX:-Inline**, хотя делать этого не рекомендуется. JVM принимает решение о необходимости встраивания метода на основе нескольких факторов, некоторые из которых приведены ниже.
* Размер метода. «Горячие» методы являются кандидатами для встраивания если их размер меньше 325 байт (или меньше размера заданного параметром **-XX:MaxFreqInlineSize**). Если метод вызывается не так часто, он является кандидатом для встраивания только если его размер меньше 35 байт (или меньше размера заданного параметром **-XX:MaxInlineSize**).
* Позиция метода в цепочке вызовов. Не подлежат встраиванию методы с позицией больше 9 (или значения заданного параметром **-XX:MaxInlineLevel**).
* Размер памяти, занимаемой уже скомпилированными версиями метода в code cache. Встраиванию не подлежат методы, скомпилированные на последнем уровне, версии которых занимают более 1000 байт при выключенной многоуровневой компиляции и 2000 байт при включенной (или значения заданного параметром **-XX:InlineSmallCode**).
### Escape-анализ
Escape-анализ - это техника анализа кода, которая позволяет определить пределы достижимости какого-либо объекта. Например, escape-анализ может использоваться для определения является ли объект созданный внутри метода достижимым за пределами области видимости метода. Сам по себе escape-анализ не является оптимизацией, но оптимизации могут выполняются по его результатам.
#### Предотвращение выделений памяти в куче
Создание новых объектов внутри циклов может создать нагрузку на систему выделения памяти. Создание большого числа короткоживущих объектов потребует частых сборок мусора в молодом поколении. Если частота создания объектов будет достаточно большой, короткоживущие объекты могут попасть и в старое поколение, что потребует уже «дорогостоящей» полной сборки мусора. Если JVM убедится, что объект не достижим за пределами области видимости метода, она может применить технику оптимизации, называемую скаляризация. Поля объекта станут скалярными значениями и будут храниться в регистрах процессора. Если регистров не достаточно, скалярные значения могут храниться в стеке.
#### Блокировки и escape-анализ
JVM способна использовать результаты escape-анализа для оптимизации производительности блокировок. Это относится только к блокировкам с помощью ключевого слова synchronized, блокировки из пакета java.util.concurrent таким оптимизациям не подвержены. Возможными оптимизации приведены ниже.
* Удаление блокировок с объектов недостижимых за пределами области видимости (lock elision).
* Объединение последовательных синхронизированных секций, использующих один и тот же объект синхронизации (lock coarsening). Выключить эту оптимизацию можно флагом **-XX:-EliminateLocks**.
* Определение и удаление вложенных блокировок на одном и том же объекте (nested locks). Выключить эту оптимизацию можно флагом **-XX:-EliminateNestedLocks**.
#### Ограничения escape-анализа
Поскольку регистры процессора и стек являются ресурсами довольно ограниченными, существуют ограничения и на их использование. Так, например, массивы размером более 64 элементов не участвуют в escape-анализе. Этот размер можно задавать параметром **-XX:EliminateAllocationArraySizeLimit**. Представьте код, создающий временный массив в цикле. Если массив не достижим за пределами метода, массив не должен создаваться в куче. Но если его размер больше 64 элементов, он будет создаваться именно там, даже при условии, что реально используется не весь массив.
Еще одно ограничение заключается в том, что частичный escape-анализ не поддерживается. Если объект выходит за пределы области видимости метода хотя бы по одной из веток, оптимизация по предотвращению создания объекта в куче не применима. Пример подобного кода приведен ниже.
```
for (int i = 0; i < 100_000_000; i++) {
Object mightEscape = new Object(i);
if (condition) {
result += inlineableMethod(mightEscape);
} else {
result += tooBigToInline(mightEscape);
}
}
```
Но если вам удастся локализовать создание объекта внутри ветки, в которой объект не выходит за пределы области видимости, то данная оптимизация будет применена в этой ветке.
```
if (condition) {
Object mightEscape = new Object(i);
result += inlineableMethod(mightEscape);
} else {
Object mightEscape = new Object(i);
result += tooBigToInline(mightEscape);
}
}
```
### Размотка (раскрутка) цикла
После встраивания всех возможных вызовов методов внутри цикла, JVM может оценить «стоимость» каждой его итерации, и определить возможность применения оптимизации, называемой размотка (раскрутка) цикла. Размотка цикла - это техника оптимизации компьютерных программ, состоящая в искусственном увеличении количества инструкций, исполняемых в течение одной итерации цикла. Каждая итерация цикла оказывает отрицательное влияние на работу процессора, т.к. сбрасывает конвейер инструкций. Чем короче тело цикла, тем выше «стоимость» итерации.
В результате размотки цикла такой код:
```
int i;
for ( i = 1; i < n; i++)
{
a[i] = (i % b[i]);
}
```
преобразуется в код вида:
```
int i;
for (i = 1; i < n - 3; i += 4)
{
a[i] = (i % b[i]);
a[i + 1] = ((i + 1) % b[i + 1]);
a[i + 2] = ((i + 2) % b[i + 2]);
a[i + 3] = ((i + 3) % b[i + 3]);
}
for (; i < n; i++)
{
a[i] = (i % b[i]);
}
```
JVM принимает решение о размотке цикла по нескольким критериям:
* по типу счетчика цикла, он должен быть одним из типов int, short или char;
* по значению, на которое меняется счетчик цикла каждую итерацию;
* по количеству точек выхода из цикла.
### Мономорфная диспетчеризация
Многие оптимизации, выполняемые компилятором C2 основаны на эмпирических наблюдениях. Одним из примеров является оптимизация под названием мономорфная диспетчеризация. Она основана на факте, что очень часто в точках вызова тип объекта во время выполнения остается неизменным. Это связано с особенностями объектно-ориентированного дизайна. Например, при вызове метода на объекте, наблюдаемый тип объекта при первом и последующих вызовах будет одним и тем же. Если это предположение верно, то вызов метода в этой точке можно оптимизировать. В частности, нет необходимости каждый раз выполнять поиск по таблице виртуальных методов. Достаточно один раз определить целевой тип объекта и заменить вызов виртуального метода быстрой проверкой типа и прямым вызовом метода на объекте целевого типа. Если в какой-то момент тип объекта поменяется, JVM откатит оптимизацию и будет снова выполнять вызов виртуального метода.
Большое число вызовов в типичном приложении являются мономорфными. JVM также поддерживает биморфную диспетчеризацию. Она позволяет делать быстрые вызовы методов в одной точке на объектах двух разных типов.
Вызовы, которые не являются ни мономорфными ни биморфными, называются мегаморфными. Если в точке вызова наблюдается не очень большое число типов, используя один трюк, можно немного выиграть в производительности. Достаточно «отделить» от точки вызова несколько типов, используя оператор instanceof так, чтобы в ней осталось только 2 конкретных типа. Примеры биморфного, мегаморфного и разделенного мегаморфного вызовов приведены ниже.
```
interface Shape {
int getSides();
}
class Triangle implements Shape {
public int getSides() {
return 3;
}
}
class Square implements Shape {
public int getSides() {
return 4;
}
}
class Octagon implements Shape {
public int getSides() {
return 8;
}
}
class Example {
private Random random = new Random();
private Shape triangle = new Triangle();
private Shape square = new Square();
private Shape octagon = new Octagon();
public int getSidesBimorphic() {
Shape currentShape = null;
switch (random.nextInt(2)) {
case 0:
currentShape = triangle;
break;
case 1:
currentShape = square;
break;
}
return currentShape.getSides();
}
public int getSidesMegamorphic() {
Shape currentShape = null;
switch (random.nextInt(3))
{
case 0:
currentShape = triangle;
break;
case 1:
currentShape = square;
break;
case 2:
currentShape = octagon;
break;
}
return currentShape.getSides();
}
public int getSidesPeeledMegamorphic() {
Shape currentShape = null;
switch (random.nextInt(3))
{
case 0:
currentShape = triangle;
break;
case 1:
currentShape = square;
break;
case 2:
currentShape = octagon;
break;
}
// peel one observed type from the original call site
if (currentShape instanceof Triangle) {
return ((Triangle) currentShape).getSides();
}
else {
return currentShape.getSides(); // now only bimorphic
}
}
}
```
### Intrinsic-методы
Intrinsic-методы - это оптимизированные нативные реализации методов готовые к использованию JVM. Обычно это базовые, критичные к производительности методы, использующие специфичные функции операционной системы (ОС) или архитектуры процессора. Из-за этого они являются платформо-зависимыми и некоторые из них могут поддерживаться не каждой платформой. Примеры intrinsic-методов приведены в таблице ниже.
| | |
| --- | --- |
| **Метод** | **Описание** |
| java.lang.System.arraycopy() | Быстрое копирование, используя векторную поддержку процессора. |
| java.lang.System.currentTimeMillis() | Быстрая реализация предоставляемая большинством ОС. |
| java.lang.Math.min() | Может быть выполнено без ветвления на некоторых процессорах. |
| Другие методы класса java.lang.Math | Прямая поддержка инструкций некоторыми процессорами. |
| Криптографические функции | Может использоваться аппаратная поддержка на некоторых платформах. |
Шаблоны intrinsic-методов содержатся в исходном коде OpenJDK в файлах с расширением .ad (architecture dependent). Для архитектуры x86\_64 они находятся в файле hotspot/src/cpu/x86/vm/x86\_64.ad.
Деоптимизации
-------------
Когда мы рассматривали мониторинг работы компилятора в первой части, мы упомянули, что в логе могут появиться сообщения о деоптимизации кода. Деоптимизация означает откат ранее скомпилированного кода. В результате деоптимизации производительность приложения будет временно снижена. Существует два вида деоптимизации: недействительный код (not entrant code) и зомби код (zombie code).
### Недействительный код
Код может стать недействительным в двух случаях:
* при использовании полиморфизма;
* в случае многоуровневой компиляции.
#### Полиморфизм
Рассмотрим пример:
```
Validator validator;
if (document.isOrder()) {
validator = new OrderValidator();
} else {
validator = new CommonValidator();
}
ValidationResult validationResult = validator.validate(document);
```
Выбор валидатора зависит от типа документа. Пусть для заказов у нас есть собственный валидатор. Предположим, что необходимо провалидировать большое количество заказов. Компилятор зафиксирует, что всегда используется валидатор заказов. Он встроит метод validate (если это возможно) и применит другие оптимизации. Далее, если на валидацию придет документ другого типа, предыдущее предположение окажется неверным, и сгенерированный код будет помечен как недействительный (non entrant). JVM перейдет на интерпретацию этого кода, и в будущем сгенерирует новую его версию.
#### Многоуровневая компиляция
В случае многоуровневой компиляции, когда код компилируется на новом уровне, его предыдущая версия также помечается недействительной.
### Зомби код
Если в логе компиляции появилось сообщение о зомби коде, это значит, что все объекты, использующие предыдущие оптимизации были удалены из памяти и, как следствие, из code cache был удален код, ранее помеченный недействительным.
Список литературы и ссылки
--------------------------
* Java Performance: In-Depth Advice for Tuning and Programming Java 8, 11, and Beyond, Scott Oaks. ISBN: 978-1-492-05611-9.
* Optimizing Java: Practical Techniques for Improving JVM Application Performance, Benjamin J. Evans, James Gough, and Chris Newland. ISBN: 978-1-492-02579-5.
* [Размотка цикла - википедия](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%BC%D0%BE%D1%82%D0%BA%D0%B0_%D1%86%D0%B8%D0%BA%D0%BB%D0%B0)
Статьи цикла
------------
* [Java HotSpot JIT компилятор — устройство, мониторинг и настройка (часть 1)](https://habr.com/ru/post/536288/)
* [Java HotSpot JIT компилятор — устройство, мониторинг и настройка (часть 2)](https://habr.com/ru/post/536514/) | https://habr.com/ru/post/536514/ | null | ru | null |
# Вопрос к почтеннейшей публике
`javascript:alert(0=="")`
я отказываюсь в это верить)). но хочу про это поговорить.
Почему такой результат?
upd. гранмерси, в первом комментарии объяснили. %) вопрос снят. %) | https://habr.com/ru/post/47894/ | null | ru | null |
# Потокобезопасные события в C# или Джон Скит против Джеффри Рихтера
Готовился я как-то к собеседованию по C# и среди прочего нашел вопрос примерно следующего содержания:
> «Как организовать потокобезопасный вызов события в C# с учетом того, что большое количество потоков постоянно подписываются на событие и отписываются от него?»
Вопрос вполне конкретно и чётко поставлен, поэтому я даже не сомневался в том, что ответ на него можно дать также чётко и однозначно. Но я очень сильно ошибался. Оказалось, что это крайне популярная, избитая, но до сих пор открытая тема. А еще заметил не очень приятную особенность — в русскоязычных ресурсах этому вопросу уделяется очень мало внимания (и хабр не исключение), поэтому я решил собрать всю найденную и переваренную мной информацию по данному вопросу.
До Джона Скита и Джеффри Рихтера тоже дойдем, они то, собственно, и сыграли ключевую роль в моем общем понимании проблемы работы событий в многопоточной среде.
Особо внимательный читатель сможет найти в статье два комикса в стиле xkcd.
(Осторожно, внутри две картинки примерно по 300-400 кб)
Продублирую вопрос, на который надо ответить:
> «Как организовать потокобезопасный вызов события в C# с учетом того, что большое количество потоков постоянно подписываются на событие и отписываются от него?»
У меня было предположение, что часть вопросов опирается на книгу **CLR via C#**, тем более что в моей любимой **C# 5.0 in a Nutshell** подобный вопрос вообще не рассматривался, поэтому начнем с Джеффри Рихтера (CLR via C#).
Путь Джеффри Рихтера
--------------------
Небольшая выдержка из написанного:
Долгое время рекомендованным способом вызова событий была примерно следующая конструкция:
*Вариант 1:*
```
public event Action MyLittleEvent;
...
protected virtual void OnMyLittleEvent()
{
if (MyLittleEvent != null) MyLittleEvent();
}
```
Проблема подобного подхода в том, что в методе `OnMyLittleEvent` один поток может увидеть, что наше событие `MyLittleEvent` не равно `null`, а другой поток, сразу после этой проверки, но перед вызовом события, может убрать свой делегат из списка подписчиков, и таким образом сделать из нашего события `MyLittleEvent null`, что приведет к выбросу `NullReferenceException` в месте вызова события.
Вот небольшой комикс в стиле xkcd, который наглядно иллюстрирует эту ситуацию (два потока работают параллельно, время идет сверху вниз):
**Развернуть**
В целом всё логично, у нас обычное [состояние гонки](http://en.wikipedia.org/wiki/Race_condition) (здесь и далее — race condition). И вот как эту проблему решает Рихтер (и этот вариант встречается чаще всего):
Добавим в наш метод вызова события локальную переменную, в которую будем копировать наше событие на момент «захода» в метод. Поскольку делегаты — это неизменяемые объекты (здесь и далее — immutable), у нас получится «замороженная» копия события, от которой никто уже не сможет отписаться. При отписке от события создается новый объект делегата, который заменяет объект в поле `MyLittleEvent`, в то время как у нас остается локальная ссылка на *старый* объект делегата.
*Вариант 2:*
```
protected virtual void OnMyLittleEvent()
{
Action tempAction = MyLittleEvent; // "Заморозили" наше событие для текущего метода
// На наш tempAction теперь никто не может повлиять, он никогда не станет равен null ни при каких условиях
if (tempAction != null) tempAction ();
}
```
Далее у Рихтера описывается, что JIT компилятор вполне может просто опустить создание локальной переменной ради оптимизации, и сделать из второго варианта первый, то есть пропустить «заморозку» события. В итоге рекомендуется делать копирование через `Volatile.Read(ref MyLittleEvent)`, то есть:
*Вариант 3:*
```
protected virtual void OnMyLittleEvent()
{
// Ну теперь уж точно заморозили
Action tempAction = Volatile.Read(ref MyLittleEvent);
if (tempAction != null) tempAction ();
}
```
Про `Volatile` можно долго говорить отдельно, но в общем случае это «просто позволяет избавиться от нежелательной оптимизации JIT компилятора». По этому поводу еще будут уточнения и подробности, но мы пока остановимся на общей идее текущего решения Джеффри Рихтера:
> Для обеспечения потокобезопасного вызова события нужно «заморозить» текущий список подписчиков, скопировав событие в локальную переменную, после чего, в случае если полученный список не пустой, вызвать все обработчики из «замороженного» списка. Таким образом мы избавляемся от возможного `NullReferenceException.`
>
>
Меня сразу смутило то, что *мы вызываем события у уже отписавшихся объектов/потоков*. Вряд ли кто-то отписался просто так — вполне вероятно, что кто-то сделал это во время общей «чистки» следов — вместе с закрытием потоков записи / чтения (например логгер, который по событию должен был писать данные в файл), закрытием соединений и т.п., то есть внутреннее состояние объекта-подписчика на момент вызова его обработчика может быть непригодно для дальнейшей работы.
Для примера представим, что наш подписчик реализует метод `IDisposable`, и следует конвенции, определяющей что при попытке вызвать любой метод у освобожденного (здесь и далее — disposed) объекта, он должен выбросить `ObjectDisposedException`. Также условимся, что мы отписываемся от всех событий в методе `Dispose`.
А теперь представте такой сценарий — мы вызываем у этого объекта метод `Dispose` ровно после того момента, когда другой поток «заморозил» список своих подписчиков. Поток успешно вызывает обработчик у отписавшегося объекта, а тот во время попытки обработки события объект рано или поздно понимает, что он уже был освобожден, и выбрасывает `ObjectDisposedException`. Скорее всего это исключение в самом обработчике никак не ловится, потому что вполне логично предположить: «Если наш подписчик отписался и был освобожден, то его обработчик никогда не будет вызван». Тут либо будет краш приложения, либо утечка неуправляемых ресусов, либо вызов события прервется при первом появлении `ObjectDisposedException` (если мы ловим исключение при вызове), но до нормальных «живых» обработчиков событие так и не доберется.
Вернемся к комиксу. История та же — два потока, время идет сверху вниз. Вот что происходит на самом деле:
**Развернуть**
Эта ситуация, по-моему, намного серьезней, чем возможное `NullReferenceException` при вызове события.
Что интересно, советы по реализации потокобезопасного вызова событий на стороны Наблюдаемого объекта есть, а советов по реализации потокобезопасных Обработчиков — нет.
### О чем говорит StackOverflow
На SO можно найти [подробную «статью»](http://stackoverflow.com/questions/786383/c-sharp-events-and-thread-safety) (да, вопрос этот тянет на целую небольшую статью), посвященную данному вопросу.
В целом там разделяется моя точка зрения, но вот что добавляет этот товарищ:
> Мне кажется, что вся эта шумиха с локальными переменными — ничто иное, как [Карго-культ программирование (Cargo Cult Programming)](http://en.wikipedia.org/wiki/Cargo_cult_programming). Большое количество людей решает проблему потокобезопасных событий именно таким способом, в то время как для **полноценной** потокобезопасности нужно сделать намного больше. Я могу с уверенностью сказать, что те люди, которые не добавляют в свой код подобные проверки, могут вполне обойтись без них. Этой проблемы просто не существует в однопоточном окружении, да и учитывая что в онлайн примерах с кодом редко можно встретить ключевое слово `volatile`, эта дополнительная проверка вполне может быть бессмысленной. Если нашей задачей является отслеживание `NullReferenceException`, нельзя ли обойтись вообще без проверки на `null`, присвоив пустой `delegate { }` нашему событию во время инициализации объекта класса?
>
>
Это подводит нас к еще одному варианту решения проблемы.
```
public event Action MyLittleEvent = delegate {};
```
`MyLittleEvent` никогда не будет равно `null`, и лишнюю проверку можно просто не делать. В многопоточной среде нужно только синхронизировать добавление и удаление подписчиков события, но вызывать его можно без опасения получения `NullReferenceException`:
*Вариант 4:*
```
public event Action MyLittleEvent = delegate {};
protected virtual void OnMyLittleEvent()
{
// Собственно, это все
MyLittleEvent();
}
```
Единственный минус такого подхода *по сравнению с предыдущим* — небольшой оверхед на вызов пустого события (оверхед оказался равен примерно *5 наносекунд* на вызов). Можно также подумать, что в случае большого количества разных классов с разными событиями, эти пустые «затычки» для событий будут занимать много места в оперативной памяти, но если верить Джону Скиту в [ответе на SO](http://stackoverflow.com/a/703033/2614361), начиная с версии C# 3.0 компилятор использует один и тот же объект пустого делегата для всех «затычек». *От себя добавлю, что при проверке получившегося IL кода это утверждение не подтверждается, пустые делегаты создаются по штуке на событие (проверял с помощью LINQPad и ILSpy).* В крайнем случае можно сделать общее на проект статическое поле с пустым делегатом, к которому можно обращаться из всех участков программы.
Путь Джона Скита
----------------
Раз уж мы добрались до Джона Скита, стоит отметить его реализацию потокобезопасных событий, которую он описал в **C# in Depth** в разделе **Delegates and Events** ([статья онлайн](http://csharpindepth.com/Articles/Chapter2/Events.aspx) и [перевод](http://habrahabr.ru/post/198694/) товарища [Klotos](https://habrahabr.ru/users/klotos/))
Суть в том, чтобы закрыть `add`, `remove` и локальную «заморозку» в `lock`, что позволит избавиться от возможных неопределенностей с одновременной подпиской на событие нескольких потоков:
**Немного кода**
```
SomeEventHandler someEvent;
readonly object someEventLock = new object();
public event SomeEventHandler SomeEvent
{
add
{
lock (someEventLock)
{
someEvent += value;
}
}
remove
{
lock (someEventLock)
{
someEvent -= value;
}
}
}
protected virtual void OnSomeEvent(EventArgs e)
{
SomeEventHandler handler;
lock (someEventLock)
{
handler = someEvent;
}
if (handler != null)
{
handler (this, e);
}
}
```
Несмотря на то, что этот метод считается устаревшим (внутренняя реализация событий начиная с C# 4.0 выглядит совершенно по-другому, см. список источников в конце статьи), он наглядно показывает, что нельзя просто обернуть вызов событий, подписку и отписку в `lock`, поскольку это с очень большой вероятностью может привести к взаимоблокировке (здесь и далее — deadlock). В `lock` находится только копирование в локальную переменную, сам вызов события происходит вне этой конструкции.
Но это совершенно не решает проблему вызова обработчиков у уже отписавшихся событий.
Вернемся к вопросу на SO. Дэниель, в ответ на все *наши* способы предотвращения `NullReferenceException` высказывает очень интересную мысль:
> Да, я действительно разобрался с этим советом о попытках предотвращения `NullReferenceException` любой ценой. Я говорю о том, что в нашем конкретном случае `NullReferenceException` может возникнуть только если другой поток отписывается от события. И делает он это только для того, чтобы **больше никогда не получать события**, чего мы, собственно, **не добиваемся** при использовании проверок локальных переменных. Там, где мы **скрываем** состояние гонки мы можем **открыть** его и исправить последствия. `NullReferenceException` позволяет определить момент неправильного обращения с вашим событием. В общем я утверждаю, что эта техника *копирования и проверки* — простое Карго-культ программирование, которое добавляет неразбериху и шум в ваш код, но совершенно не решает проблему многопоточных событий.
>
>
Среди прочих, на вопрос ответил и Джон Скит, и вот что он пишет.
Джон Скит против Джеффри Рихтера
--------------------------------
> JIT компилятор не имеет права оптимизировать локальную ссылку на делегат, поскольку там присутствует условие. Эту информацию «вбросили» некоторое время назад, но это неправда (я уточнял этот вопрос то ли у Джо Даффи, то ли у Ванса Мориссона). Без модификатора `volatile` просто возникает возможность, что локальная ссылка на делегат будет немного устаревшей, но в целом это все. Это не приведет к `NullReferenceException`.
>
>
>
> И да, у нас определенно возникает состояние гонки, вы правы. Но оно будет присутствовать всегда. Допустим, мы уберем проверку на `null` и просто напишем
>
>
> ```
> MyLittleEvent();
>
> ```
>
>
> А теперь представьте, что наш список подписчиков состоит из 1000 делегатов. Вполне возможно, что мы начнем вызывать событие перед тем, как один из подписчиков отпишется от него. В этом случае он все равно будет вызван, поскольку он останется в старом списке (не забывайте, что делегаты неизменяемы). **Насколько я понимаю, это совершенно неизбежно.**
>
> Использование пустого `delegate {};` избавляет нас от необходимости проверять событие на `null`, но это не спасет нас от очередного состояния гонки. Более того, этот способ не гарантирует, что мы будем использовать наиболее свежую версию события.
>
>
Теперь надо отметить, что этот ответ был написан в 2009м году, а CLR via C# 4th edition — в 2012. Так кому в итоге верить?
На самом деле я не понял, зачем Рихтер описывает случай с копированием в локальную переменную через `Volatile.Read`, поскольку дальше он *подтверждает* слова Скита:
> Хоть и рекомендуется использовать версию с `Volatile.Read` как наилучшую и технически верную, можно обойтись и *Вариантом 2*, поскольку JIT компилятор знает о том, что он может случайно натворить, оптимизируя локальную переменную `tempAction`. *Чисто теоретически*, в будущем это может измениться, поэтому рекомендуется использовать *Вариант 3*. *Но на самом деле* Microsoft вряд ли пойдет на такие изменения, поскольку это может сломать огромное количество уже готовых программ.
>
>
Всё становится совершенно запутанным — оба варианты равнозначны, но тот, что с `Volatile.Read` более равнозначен. И ни один вариант не спасет от состояния гонки при вызове отписавшихся обработчиков.
Может потокобезопасного способа вызова событий вообще не существует? Почему на предотвращение маловероятного `NullReferenceException` тратится столько сил и времени, а на предотвращение не менее вероятного вызова отписавшегося обработчика — нет? Этого я так и не понял. Но зато в процессе поиска ответов я понял много всего другого, и вот небольшой итог.
Что имеем в итоге
-----------------
* Наиболее популярный способ **не является потокобезопасным** из-за возможности превращения делегата в `null` после поверки на неравенство. Появляется опасность возникновения `NullReferenceException`
```
public event Action MyLittleEvent;
...
protected virtual void OnMyLittleEvent()
{
if (MyLittleEvent != null)
// Опасность NullReferenceException
MyLittleEvent();
}
```
* Методы Скита и Рихтера помогают избежать возникновения `NullReferenceException`, но **не являются потокобезопасными**, поскольку остается вероятность вызова уже отписавшихся обработчиков.
**Метод Скита**
```
SomeEventHandler someEvent;
readonly object someEventLock = new object();
public event SomeEventHandler SomeEvent
{
add
{
lock (someEventLock)
{
someEvent += value;
}
}
remove
{
lock (someEventLock)
{
someEvent -= value;
}
}
}
protected virtual void OnSomeEvent(EventArgs e)
{
SomeEventHandler handler;
lock (someEventLock)
{
handler = someEvent;
}
if (handler != null)
{
handler (this, e);
}
}
```
**Метод Рихтера**
```
protected virtual void OnMyLittleEvent()
{
// Ну теперь уж точно заморозили
Action tempAction = Volatile.Read(ref MyLittleEvent);
if (tempAction != null) tempAction ();
}
```
* Метод пустого `delegate {};` позволяет избавиться от `NullReferenceException` благодаря тому, что событие никогда не обращается в `null`, но **не является потокобезопасным** поскольку остается вероятность вызова уже отписавшихся обработчиков. Более того, без модификатора `volatile` у нас есть возможность получить не самую свежую версию делегата при вызове события.
* Нельзя просто обернуть добавление, удаление и вызов события в `lock`, поскольку это создаст опасность взаимоблокировки. Технически, это может спасти от вызова отписавшихся обработчиков, но мы не можем быть уверенными в том, какие действия сделал объект-подписчик перед тем, как отписаться от события, поэтому мы все еще можем напороться на «испорченный» объект (см. пример с `ObjectDisposedException`). Этот метод также **не является потокобезопасным**.
* Попытка поймать отписавшиеся делегаты после локальной «заморозки» события бессмысленна — при большом количестве подписчиков вероятность вызова отписавшихся обработчиков (после начала вызова события) даже выше, чем при локальной «заморозке».
Технически, ни один из представленных вариантов **не является потокобезопасным** способом *вызова* события. Более того, добавление метода проверки делегата с помощью локальных копий делегатов **создает ложное чувство защищенности**. Единственным способом, позволяющим полностью обезопасить себя — заставить **обработчики** событий проверять, не отписались ли они уже от конкретного события. К сожалению, в отличие от общих практик предотвращения `NullReferenceException` при вызове событий, по поводу обработчиков нет никаких предписаний. Если вы делаете отдельную библиотеку, то чаще всего вы никак не можете повлиять на её пользователей — не можете заставить клиентов предполагать, что их обработчики не будут вызваны после отписки от события.
После осознания всех этих проблем у меня остались смешанные чувства по поводу внутренней реализации делегатов в C#. С одной стороны, поскольку они являются неизменяемыми, нет шансов получить `InvalidOperationException` как в случае перебора изменяющейся коллекции через `foreach`, но с другой — нет никакой возможности проверить, отписался ли кто-то от события **во время вызова** или нет. Единственное что можно сделать со стороны держателя события — обезопаситься от `NullReferenceException` и надеяться, что подписчики ничего не испортят. В итоге на поставленный вопрос можно ответить так:
> Невозможно обеспечить потокобезопасный вызов события в многопоточном окружении, поскольку всегда остается вероятность вызова обработчиков уже отписавшихся подписчиков. Эта неопределенность противоречит определению термина «потокобезопасность», в частности пункту
> > Implementation is guaranteed to be free of race conditions when accessed by multiple threads simultaneously.
>
>
>
>
### Дополнительное чтение
Разумеется, я не мог просто скопировать / перевести всё, что нашел. Поэтому оставлю список источников, которые были прямо или косвенно использованы.
* [CLR via C# (Jeffrey Richter)](http://www.amazon.com/CLR-via-Edition-Developer-Reference/dp/0735667454)
* [Вопрос на SO, в котором Джон Скит рассказывает про неизбежность состояния гонки. Еще там есть результаты сравнительных тестов на время вызова событий](http://stackoverflow.com/questions/786383/c-sharp-events-and-thread-safety)
* [Небольшая статья, в которой четко и взвешено объясняются недостатки различных методов вызова событий (устаревшая)](http://www.codeproject.com/Articles/37474/Threadsafe-Events)
* [C# in Depth — Delegates and Events (Jon Skeet)](http://csharpindepth.com/Articles/Chapter2/Events.aspx)
* [Полезная статья с утверждением того, что обеспечение потокобезопасности — это работа обработчиков](http://blogs.msdn.com/b/ericlippert/archive/2009/04/29/events-and-races.aspx)
* [Еще один сравнительный анализ времени вызовов событий с помощью различных подходов](http://geekswithblogs.net/BlackRabbitCoder/archive/2011/12/01/c.net-fundamentals-safely-and-efficiently-raising-events.aspx)
* [Подробности о пустых делегатах](http://stackoverflow.com/questions/170907/is-there-a-downside-to-adding-an-anonymous-empty-delegate-on-event-declaration)
* [Немного о Memory Barrier и Volatile (Joe Albahari)](http://www.albahari.com/threading/part4.aspx#_The_volatile_keyword)
* [Еще немного о volatile](http://stackoverflow.com/questions/24677773/variable-freshness-guarantee-in-net-volatile-vs-volatile-read)
* [Об атомарности операций со ссылочными типами](http://stackoverflow.com/questions/2192124/reference-assignment-is-atomic-so-why-is-interlocked-exchangeref-object-object)
* [Методы расширений для псевдо-потокобезопасного вызова событий](http://stackoverflow.com/questions/3668953/raise-event-thread-safely-best-practice)
* [C# 5.0 in a Nutshell (пока любимая книга по C#, очень рекомендую)](http://shop.oreilly.com/product/0636920023951.do) | https://habr.com/ru/post/240385/ | null | ru | null |
# Cucumber и BDD. Пишем UI-автотесты на iOS
Предисловие
-----------
Привет, Хабр! В данной статье-мануале я хочу рассказать о базовых функциях такого фреймворка как Cucumber и его применение для создания UI-автотестов на мобильных iOS устройствах.
Я ставлю перед собой задачу сделать описание максимально простым и понятным для большинства читателей, вне зависимости от навыков программирования или автоматизации. В целом, информации про BDD и Cucumber в сети довольно много, поэтому, дабы избежать повторений, я не хочу сильно углубляться в общую теорию, а сосредоточусь именно на связке фреймворка и iOS.
Эта статья будет интересна, в первую очередь, тем тестировщикам, которые только начинают познавать мир автотестов. Их ждет детальная инструкция по развертыванию Cucumber, а также подробный пример написания первого теста. Опытным же пользователям, не знакомым с данным инструментом, статья даст общее представление о Cucumber и, возможно, поможет с выбором в пользу этого (ну, или наоборот - другого) тестового фреймворка.
Несколько слов о Gherkin, Cucumber и BDD
----------------------------------------
**Gherkin** представляет из себя структурированную манеру написания документации для PO, бизнес-аналитиков и тестировщиков. «Академическое» определение Gherkin говорит, что это человеко-читаемый язык для описания поведения системы, каждая строчка начинается с одного из ключевых слов (Given-When-Then-And) и описывает одно из предусловий/шагов/результатов.
**Cucumber** - это инструмент, используемый для выполнения behavior driven (BDD) сценариев, написанных на языке Gherkin.
**BDD** (behavior driven development) - методология разработки ПО, основной идеей которой является составление требований к продукту в формате понятых не-специалисту поведенческих сценариев. Пример BDD сценария:
```
Scenario: Login with PIN
Given the app is running
And I'am registered user
And I see Login screen
When I enter 4-digits PIN
Then I am logged in
```
Объединив эти три понятия, мы получаем методологию, в которой все требования к новой фиче описываются простыми, понятными для любого человека сценариями, покрывающими все возможные пути поведения пользователя. Эти сценарии в то же время являются тест кейсами.
Разворачиваем Cucumber
----------------------
На сайте Cucumber поддержка iOS находится в любопытном статусе semi-official (полу-официальный?) поэтому процесс установки и настройки фреймворка местами весьма нетривиален.
* Cucumber - это СocoaPod библиотека, поэтому начинаем с нее. Открываем терминал и устанавливаем CocoaPod
`sudo gem install cocoa pods`
* переходим в свой проект и создаем подфайл
`pod init`
* заходим в созданный подфайл. Проверяем, что в нем есть следующее:
```
source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '11.0'
use_frameworks!
inhibit_all_warnings!
def test_pods
pod 'Cucumberish'
end
target ‘НАЗВАНИЕ_ВАШЕГО_ПРОЕКТАCucumberTests’ do
test_pods
end
```
Если этой записи нет - добавляем её руками, предварительно удалив всё из файла. Обратите внимание, что в таргете фигурирует название вашего проекта
* устанавливаем XCFit
`sudo gem install xcfit`
* открываем Xcode, добавляем к проекту новый таргет, используя появившийся шаблон cucumberish bundle. В проекте появятся папка **НазваниеВашегоПроектаCucumberTests** с дефолтными файлами. Там же необходимо самостоятельно создать папку **Features**
* идем в build phases таргета CucumberTests, удаляем дубликаты **Copy Bundle Resources**, **Compile Sources** и **Link Binary With Libraries**
* закрываем Xcode, устанавливаем поды
`pod install`
* в проекте появится **.xcworkspace** файл, открываем его. Зачастую на этом шаге отваливаются стандартные файлы из папок **Screens**, **Step Definitions** и **Supporting Files**. Если это произошло - добавляем их обратно руками через Add Files to.
Почти готово, мы в шаге от завершения установки Cucumber!
* на момент написания этой статьи (осень 2020) «из коробки» фреймворк не собирается из-за нескольких ошибок в коде. Возможно, эти проблемы будут неактуальны. Через поиск в Xcode находим и правим следующие строки:
+ добавляем `@objc`перед`class func CucumberishSwiftInit()`
+ зменяем `var elementQurey` на `var elementQuery`
+ заменяем `expectedMenuCount: uInt = uInt(menuCount)!` на `expectedMenuCount: Int = Int(menuCount)!`
+ заменяем `expectedCellCount: uInt = uInt(cellCount)!` на `expectedCellCount: Int = Int(cellCount)!`
Вот теперь все. Жмем ⌘+U для запуска тестов. Если все сделано правильно, проект соберется, а в логе мы увидим сообщение «Tests successfully executed 0 from 0». Это значит, что фреймворк успешно отработал, но не запустил ни одного теста, что не удивительно, так как мы еще не написали ни одного сценария.
Фреймворк "из коробки"
----------------------
По умолчанию Cucumber имеют следующую структуру:
* папка **Features** - в ней хранятся файлы с разрешением **.feature**, они содержат в себе один или несколько BDD сценариев. Каждый сценарий, написанный на Gherkin, состоит из набора строк, последовательно выполняемых при работе теста
* <название проекта>**CucumberTests.swift** файл в корне фреймворка**.** Содержащий код, выполняемый для Given шагов, задает предусловия каждого теста. По умолчанию файл будет содержать шаг для запуска приложения. Также файл содержит ряд настроек, к примеру, управление тэгами, но о них чуть позже
* папка **Screens** - в ней хранятся .swift файлы, содержащие локаторы, по которым можно обращаться к инспектируемым элементам приложения
* папка **Step Definitions** - в ней хранятся .swiftфайлы содержащие код, выполняемый в шагах тестов
* папка **Common** - в ней хранится commonStepDefinitions.swift файл, содержащий в себе код, который может выполняться для простых проверок типовых элементов (наличие объектов на экране, нажимаемость кнопок и т.п.)
Для удобства организации шагов и сценариев в соответствующих папках фреймворка можно создавать дополнительные файлы. Все .feature файлы, помещенные в папку Features, будут подтягиваться в тестовые наборы автоматически, а файлы с шагами потребуется дополнительно вызывать в beforeStart функции `CucumberishSwiftInit()`
Что происходит при запуске теста?
---------------------------------
Фреймворк установлен, теперь мы хотим создать свой первый тест. Для того, чтобы это было проще сделать, надо понимать, что будет происходить c Xcode после того, как вы нажмете ⌘+U.
А происходить будет следующее:
* фреймворк соберет проект на выбранном девайсе/эмуляторе
* фреймворк построчно распарсит первый сценарий из первого фича-файла
* все первые Given и And строки будут рассматриваться как предусловия теста. Они могут быть как совсем простыми и состоять из единственного Given условия, так и комплексными Given-And-And-… наборами строк
Простой шаг-предусловие* фреймворк отправится в корневой swift файл за кодом, выполняемым в этих шагах. Если точнее, то для простого предусловия выше будет выполнен следующий код:
Шаг «The app is running» является первым и обязательным почти для любого сценария, так как в нем происходит запуск трестируемого приложения.
* как только будут пройдены все Given шаги и дело дойдет до первой When или Then строки, предусловия будут считаться выполненными. За кодом для выполнения последующих строк фреймворк будет обращаться в .swift файлы из папки Step Definitions
* при проходе всех шагов теста приложение будет закрыто. Далее начнет выполняться следующий по порядку сценарий из фича-файла, и так до тех пор, пока не будут выполнены все сценарии во всех фича-файлах
Пишем свой первый тест
----------------------
Итак, имея базовое представление о том, как работает фреймворк мы понимаем, что именно должно быть сделано для создания нашего первого теста:
* создаем feature файл в папке Features. В начале файла обязательно должна быть общая информация описывающая функционал по шаблону:
```
Feature:…
In order to …
As a …
I want to …
```
* пишем тестовый сценарий в feature файле, используя синтаксис Gerkin
* в корневом swift файле раскрываем Given шаги этого сценария
* в step definition файле раскрываем остальные шаги
Особенности написания Given шагов
---------------------------------
Упомянутого выше предусловия «the app is running» самого по себе почти всегда будет недостаточно. Если точка входа в тест находится не на стартовой страничке, а где-то «глубже», то удобно использовать комплексные Given-And-And-… предусловия. При помощи еще одной или нескольких строк, мы можем привести приложение к нужному для конкретного теста состоянию.
Пример выше - реальный тест с моего проекта. Далее приведу его детальный разбор, надеюсь, это поможет понять, как расписываются предусловия и тестовые шаги.
Итак, из предусловия сценария видно, что после запуска приложения я хочу взаимодействовать с ним как зарегистрированный пользователь, хочу видеть экран «My credentials», и при этом экран должен быть пустым и не содержать ни одной сущности.
Ниже приведен код для каждого из этих шагов. Контекст действий внутри шагов не столь важен для общего понимания работы фреймворка, тем не менее, я приведу и поясню код полностью для целостности картинки.
* Запускаем приложение
* если после запуска мы видим страницу регистрации, то регистрируемся, нажав на кнопку «Get started». Ждем, пока прогрузится экран для установки пинкода, задаем пин «0000», вводим его повторно для подтверждения регистрации
Если после запуска мы видим НЕ страницу регистрации, значит, регистрация была произведена в предыдущем тесте, и приложение, сохранив этот состояние, направит нас сразу на экран логина. В этом случае нам остается лишь залогиниться единожды введя пин «0000».
В конце шага также есть UIInterruptionMonitor, он необходим, чтобы обработать системный диалог с запросом на разрешение биометрического логина (faceid или отпечаток пальца) при самом первом запуске приложения.
* Проверяем, что после регистрации/логина приложение прогрузилось, и мы находимся на экране «My credentials». Простой ассерт, в котором мы ожидаем экран
* Проверяем, что на экране в табличке credentialList нет сущностей, если они остались с предыдущих тестов, удаляем их одну за одной. Для этого тапаем по первой ячейке в таблице, вызываем меню действий, тапаем по кнопке "Delete" и подтверждаем кнопкой "Delete credential". Повторяем эти действия пока первая ячейка в таблице не перестанет существовать
В результате предусловия выполнены. Мы имеем запущенное приложение, ожидающее дальнейших шагов на пустом экране «My credentials».
Несколько слов о тестовых шагах и CommonStepDefinitions
-------------------------------------------------------
Тестовые шаги описываются по абсолютно такому же принципу и мало чем отличаются от Given-шагов, разве что содержаться в других файлах.
Отдельно хочется рассказать про CommonStepDefinitions.swift. Он создается по умолчанию в папке Common и содержит в себе набор проверок, которые могут быть использованы для тестирования стандартных, типовых элементов.
Допустим, в вашем приложении есть условный объект Menu, на нем находятся две стандартные кнопки Confirm и Deny, а также текст «Please confirm». Для того, чтобы проверить отображение этого объекта, кнопок и текста, не обязательно в step definitions детализировать код для четырех разных шагов. Достаточно просто в сценарии написать эти шаги в подходящем под CommonStep формате:
```
…
And I see the "Menu" view
And I see "Confirm" button
And I see "Deny" button
And I see "Please confirm" text
…
```
При выполнении теста все эти строки будут определены как common шаги, а точнее, как один единственный шаг:
Использование common шагов позволяет здорово сократить количество кода, необходимого для простых проверок или действий. Но надо понимать, что этот метод не всегда подходит для тестирования кастомных элементов из-за сложных путей их обнаружения. В этом случае удобнее всего пользоваться обычными step definitions и обращаться к этим элементам через accessibility identifier.
Запускаем тесты
---------------
После того, как один или несколько BDD сценариев написаны и ко всем их строкам существует definition, можно запускать тестовый прогон комбинацией ⌘+U. В случае, если необходимо запустить только часть тестов, можно воспользоваться тегами, отметив ими желаемые сценарии в фича файлах (или фича файлы целиком) и перечислив теги для запуска в executeFeatures корневого .swift файла.
По умолчанию состояние приложения после каждого теста не обнуляется, так что если в конкретном сценарии подразумевается создание какого-либо объекта, сущности, записи в памяти телефона или чего-либо еще, то в последующем тесте мы этот объект увидим.
Из этого можно извлечь пользу. К примеру, на нашем проекте из общего количества автотестов в 50+ штук необходимо всего 5 тестов на регистрацию. После прохождения этих 5-и тестов состояние регистрации сохраняется и последующие 45 тестов начинаются уже с логина, минуя десяток тапов по кнопкам и пару экранов. Тем самым, мы экономим примерно 10 секунд времени от каждого теста, не выполняя одни и те же действия, уже протестированные ранее.
Обратная сторона медали - периодически требуется очищать приложение от различных сущностей в предусловиях тестов (как было показано выше на примере шага «I have no credentials»). Для этого приходится писать довольно объемные шаги, но в моем случае такой существенный выигрыш времени стоит того.
Отчет
-----
После выполнения всех тестов будет сформирован стандартный Xcode отчет. Тесты в нем группируются по фича файлам. Для любого шага можно просмотреть детализацию вплоть до вызываемых методов.
В случае падения теста тут же можно будет увидеть подробный лог и скриншоты. Этот инструмент очень удобен при написании и отладке тестов на новые фичи.
Когда начинается магия?
-----------------------
Сперва создание и поддержка cucumber тестов казались мне довольно трудоёмким занятием, фреймворк выглядел медленным и неудобным, а BDD сценарии излишне формализованными. Но после десятка внедренных тестов я полностью изменил свое мнение.
Одна из самых полезных фишек кукумбера - переиспользование отдельно взятых шагов в любом месте, где это допустимо. Максимальное дробление сценариев на мельчайшие части, так раздражавшее поначалу, спустя 3-4 спринта привели к формированию внутри фреймворка большого пула разных шагов. Все эти предусловия, действия и результаты при грамотном написании должны работать независимо друг от друга и иметь одинаковые точки входа-выхода, в этом случае их можно переиспользовать, комбинировать и на лету собирать из них новые автотесты просто написав BDD-сценарий. В моей текущей работе бывали случаи, когда создание автотестов на новый функционал просто сводилось к написанию BDD сценария из уже существующих шагов. Новый автотест без программирования? Фантастика? Так вот с cucumber это действительно возможно.
Если добавить к этому то, что при разработке по BDD методологии сценарии для вас пишет PO и пишет их точь-в-точь как вам надо, то получается совсем утопическая вселенная, где тестировщику остается только скопипастить текст из Jira в фича-файл и получить работающий автотест.
Естественно, реальность всё-таки вносит свои корректировки, и PO будет иметь отличный от тестировщика взгляд на описание фичи, чаще всего, сценарии приходится глубоко редактировать, дополняя деталями или пропущенными шагами, примерять на них стандартные техники тест дизайна. И без добавления кода в step definitions тоже никак не обойтись.
Но все же, спустя год работы с фреймворком, он кажется мне простым в освоении, легко поддерживаемым и, главное, функциональным.
Надеюсь, эта статья помогла вам узнать чуть больше о таком не самом распространенном, но очень интересном звере в мире мобильных UI-автотестов как Cucumber. Если у вас есть вопросы, жду их в комментариях, постараюсь все прочитать и на все ответить. | https://habr.com/ru/post/522544/ | null | ru | null |
# Prototype, proto и оператор new
В этой статье я кратко в примерах объясню что такое свойства \_\_proto\_\_, prototype и работу оператора new в JavaScript.
#### Свойство \_\_proto\_\_
Абсолютно любой объект в JavaScript имеет свойство \_\_proto\_\_. Это скрытое системное свойство, и не во всех реализациях языка оно доступно пользователю.
При обращении к любому свойству объекта, оно в первую очередь ищется в самом объекте:
```
var obj = {ownProperty: 1};
console.log(obj.ownProperty);// 1
```
Но если его там нет, поиск происходит в свойстве \_\_proto\_\_:
```
obj.__proto__ = {propertyOfProto: 2};
console.log(obj.propertyOfProto);// 2
```
Если его нет и там, оно ищется дальше по цепочке:
```
obj.__proto__.__proto__ = {propertyOfProtosProto: 3};
console.log(obj.propertyOfProtosProto);// 3
```
Эта цепочка называется цепочкой прототипов (prototype chain).
\_\_proto\_\_ любого значения (кроме null и undefined) ссылается на prototype соответствующего ему типу данных:
```
(0).__proto__ === Number.prototype &&
false.__proto__ === Boolean.prototype &&
"string".__proto__ === String.prototype &&
(new Date).__proto__ === Date.prototype &&
(function(){}/* new Function */).__proto__ === Function.prototype
```
Все типы данных наследуются от Object, это означает что к примеру:
```
Number.prototype.__proto__ === Object.prototype
```
И наконец, завершение цепочки:
```
Object.prototype.__proto__ === null
```
#### Свойство prototype
А чем же тогда является свойство prototype? Это обычное свойство, ничем не отличающиеся от любых других свойств. За исключением двух особенностей:
1) Функции в JavaScript имеют свойство prototype. Оно по умолчанию является объектом с единственным свойством constructor, которое ссылается на саму функцию.
2) Свойство prototype используется при создании новых объектов оператором new.
#### Оператор new
Этот оператор делает следущее:
1) Создает пустой объект:
```
var instance = {};
```
2) Устанавливает \_\_proto\_\_ этому объекту ссылкой на prototype функции-класса:
```
instance.__proto__ = FnClass.prototype;
```
3) Применяет функцию-класс к нашему новосозданному объекту:
```
constructorReturns = FnClass.apply(instance, arguments);
```
(т.е. исполняет функцию FnClass, передавая ей instance в качестве this и аргументы в виде массива arguments)
4) Возвращает экземпляр функции-класса, но если FnClass нам вернул обьект, тогда его:
```
return constructorReturns instanceof Object ? constructorReturns : instance;
```
Функцией-классом я называю функцию, к которой впоследствии ожидается применение оператора new. Такие функции принято именовать с заглавной буквы.
#### Использование \_\_proto\_\_ в ваших скриптах
Т.к. свойство \_\_proto\_\_ является скрытым, и не описано в спецификации языка, то использование его в явном виде некорректно. Так что никогда не пишите так как я выше в примерах :) Этот код только для консоли.
Однако в последней (действующей) спецификации ECMA Script 5 наконец-то появились два метода, позволяющие манипулировать свойством \_\_proto\_\_, это Object.create и Object.getPrototypeOf.
Поясню их работу в двух простых примерах:
```
//var myObj = {__proto__: {property1_OfProto: 1}}
var myObj = Object.create({property1_OfProto: 1});
```
```
//myObj.__proto__.property2_OfProto = 2
Object.getPrototypeOf(myObj).property2_OfProto = 2;
```
Если вы используете более раннюю версию JavaScript, то метод Object.create можете создать самостоятельно:
```
if(!Object.create){
Object.create = function(proto){
var Fn = function(){};
Fn.prototype = proto;
return new Fn;
}
}
```
C getPrototypeOf ситуация сложнее, его можно эмулировать только для функций, и только при условии что constructor этой функции не был изменен:
```
if(!Object.getPrototypeOf){
if( (new Object).__proto__ !== Object.prototype ){
// may return incorrect value if fn.prototype has been modified
Function.getPrototypeOf = function(fn){
if(typeof(fn)!=='function')
throw new TypeError('Function.getPrototypeOf called on non-function');
return fn.constructor.prototype;
}
}else{
Object.getPrototypeOf = function(obj){
return obj.__proto__;
}
}
}
```
А лучше, как посоветовали в комментах, используйте библиотеку [github.com/kriskowal/es5-shim](https://github.com/kriskowal/es5-shim)
#### Далее — [о классах в JavaScript...](http://habrahabr.ru/post/175029/#classes) | https://habr.com/ru/post/140810/ | null | ru | null |
# Вам больше ничего не принадлежит
##### Предисловие переводчика
После запуска Google Drive по интернету прокатилась очередная волна недовольства условиями использования сервисов Google. На самом деле проблема TOS присуща практически всему современному интернету. Мне показалась интересной статья, пусть не бесспорная и не слишком глубокая, но доступно описывающая ситуацию.
##### Вам больше ничего не принадлежит
*Не переживайте об условиях использования Google Drive, посмотрите на условия использования у **всех** сервисов. В интернете мы с вами — товары на распродаже.*
Вдумчиво ли вы читали условия использования (TOS) на сайтах вроде Google или Facebook? Или спрошу по-другому: читали ли вы условия использования на достаточном количестве сайтов? Если да, вы легко узнаете пример: после более или менее длительного предисловия, напоминающего прочистку горла, большинство условий подходят к печальному пункту:
>
> ```
> Загружая или иным образом добавляя материалы в наши Службы, вы предоставляете нам действующую во всем мире лицензию, которая позволяет нам использовать это содержание, размещать его, хранить, воспроизводить, изменять, создавать на его основе производные работы, обмениваться им, публиковать его, открыто воспроизводить, отображать, а также распространять.
> ```
>
Для большинства людей этот пункт — самый значимый. Это как раз то место, где каждая компания, с которой вы общаетесь в онлайне — Facebook, Pinterest, Microsoft или, как в вышеприведенном случае, Google — объясняет вам, прямо в ваше простоватое лицо, что загружая ваш контент, вы его **отдаете**. И хотя этот отрывок написан наиболее ясно, вас не покидает чувство, что вы стали жертвой мошенничества. Именно он “достает” вас в интернете.
Заявление о том, что пользователь продолжает как бы “владеть” контентом, но предоставляет вебсайтам практически неограниченную лицензию на его использование, стало настолько повсеместным, что практически превратилось в шаблон, в новую норму в вопросах собственности на контент. И это до ужаса ненормально! Facebook или даже Google Drive становятся вашими лицензиатами при каждой загрузке фотографии, а вы в определенной степени становитесь лицензиаром. Публикация фотки с вашего дня рождения означает вступление в сложные юридические отношения, словно при сдаче дома в аренду или заключении трудового договора. Ставки, конечно, не столь высоки, вы не ставите свою подпись и сама транзакция занимает всего доли секунды, но этим разница ограничивается.
Эти гнетущие, сбивающие с толку, по большей части невидимые отношения и определяют знакомый нам сегодня интернет.
---
Условия использования Google не только выглядят “загребущими”, они таковы на самом деле: TOS Google Drive (и вообще всех сервисов Google) предоставляет компании право делать почти все с загруженным вами контентом. И не потому, что у Google есть куча прикольных идей по публичному показу ваших фотографий, а по причине того, что закон об авторском праве был написан до появления такой штуки, как компьютер.
“Закон об авторском праве действительно странен”, — говорит Грег Ластовка, один из директоров рутгеровского Института информационной политики и права. “Эти компании делают только то, что заставляет их делать закон”.
К примеру, вы нарисовали картину. В буквальном смысле слова вы владеете бумагой и чернилами для рисования, а копирайт у вас на нечто нематериальное: структуру, форму, дизайн. Если кто-то крадет ваш рисунок, он крадет вашу собственность. Если кто-то фотографирует ваш рисунок, то он нарушает копирайт. “Когда вы говорите, что владеете фотографией”, — говорит Ластовка, — “вы на самом деле имеете в виду: “у меня есть эксклюзивное право на репродукцию моей фотографии.””
За копирайтом легко следить в мире, где передача фотографии возможна лишь публикацией или физическим копированием, поэтому закон работал хорошо. “Передавая” фотографию вашей бабушке, вы кладете либо саму фотографию, либо ее копию в конверт и посылаете по почте.
Однако, отсылка бабушке фотографии по *электронной* почте может включать в себя копирование вашей фотографии 5 или 6 раз, сначала на серверы Google, потом на другой сервер, затем на CDN провайдера, далее на сервер AOL и на компьютер бабушки. Для вас это похоже на опускание конверта в почтовый ящик, но в отношении копирайта это скоординированная юридическая пляска.
>
> ```
> 2. Распространение опубликованных Вами материалов и информации
>
> Вам принадлежат все материалы и информация, которые Вы публикуете на Facebook. Вы можете контролировать их распространение через настройки конфиденциальности и настройки приложений. Кроме того:
>
> 1. Вы предоставляете нам следующее особое разрешение, с учетом Ваших настроек конфиденциальности и приложений, на все материалы, на которые распространяются права интеллектуальной собственности, такие как фотографии и видео (далее – «материалы, на которые распространяются права интеллектуальной собственности»): Вы предоставляете нам, переуступаемую, передаваемую в порядке сублицензирования , свободную от роялти, глобальную лицензию на использование любых материалов, на которые распространяются права интеллектуальной собственности,, размещаемых Вами на Facebook или каким-либо образом связанных с Facebook (далее – «Лицензия на интеллектуальную собственность»). Действие настоящей Лицензии на интеллектуальную собственность заканчивается тогда, когда Вы удаляете опубликованные Вами материалы, на которые распространятся права интеллектуальной собственности, или свой аккаунт, за исключением случаев, когда Ваши материалы передавались другим лицам, и не были ими удалены.
>
> 2. Вы принадлежите нам.
>
> 3. Трам-па-пам. ОДИН-ОДИН11!!! Хай. Привет. Меня зовут Марк Цукерберг.
>
> 4. При публикации материалов или информации с использованием настройки «для всех», это означает, что Вы разрешаете всем, включая людей, не зарегистрированных на Facebook, получать доступ к этой информации и использовать ее, а также связывать ее с Вами (т.е. с Вашим именем и фотографией профиля).
>
> 5. Нам важны Ваши отзывы или другие предложения по усовершенствованию Facebook, однако Вы безоговорочно соглашаетесь на то, что мы можем использовать их, не принимая на себя никаких обязательств по оплате подобных предложений (так же как и Вы не несете обязательств по предоставлению предложений)
> ```
>
Сайты должны получить разрешение (лицензию) на копирование и распространение ваших материалов. Им необходимо ваше согласие на “использование” и “хостинг”, “хранение” и “копирование” только для предоставления вам обещанной функциональности. Конечно, им необязательно нужно право “изменять”, “создавать производные работы” и “публично демонстрировать”… до тех пор, пока им не надо зарабатывать деньги. А им, разумеется, надо.
---
Понятно зачем Facebook необходимо лицензировать ваш контент. Менее понятно, зачем Google такая широкая лицензия для Google Drive, ведь Google Drive намеревается быть личным хранилищем, а не публично доступной страницей. Но это неважно. В терминах закона о копирайте они скорее похожи, нежели различны.
Условия использования, дающие онлайновым компаниям достаточную свободу действий для функционирования, юридически разрешают им массу вещей. которые они пока догадываются не делать. Pinterest, внезапно продающий распечатки панелей своих пользователей, был бы ужасным пиаром и тупым бизнес-планом. Но даже продавая, они вышли бы сухими из воды. [Facebook Beacon](http://en.wikipedia.org/wiki/Facebook_Beacon) был кошмарным и глупым (замаскированный способ сказать “на 5 лет раньше, чем нужно”), но по-видимому, не был незаконным.
Чтобы не рисковать и не сужать условия использования, компании стали писать их более искусными, даже обнадеживающими. Когда Facebook купила Instagram я забеспокоился о замене его щедрого TOS, где первое предложение в разделе “Права” читается, словно выкрикнутое в мегафон:
>
> ```
> Instagram не предъявляет никаких прав на текст, файлы, изображения, фотографии, звуки, музыкальные работы, авторские работы, приложения или любое другое содержание (далее, “контент”), которое вы публикуете на сервисах или при помощи сервисов Instagram.
> ```
>
Но даже замени Facebook условия на свои, это было бы совершенно неважно. Первое предложение — не более чем обольщение. Instagram не предъявляет прав потому, что ему это не нужно, а главное потому, что это будет нелепо! Это все равно, как компания написала бы в начале TOS “Instagram не предъявляет никаких прав на тусовки в вашем доме и поедание вашей пищи”. Это же так очевидно!
“Когда [компании] говорят, что вы “владеете” чем-то”, говорит Ластовка, — “они говорят, что вы владеете этим, но даете нам неограниченную лицензию.” Следующее же предложение TOS Instagram (то самое, о лицензиях) фактически идентично фейсбуковскому и достаточное для того, чтобы рациональный человек чувствовал, будто отказывается от своей собственности при каждом логине.
И здесь происходит отчуждение. Реально ли мы владеем чем-то, если другой человек или компания могут делать с этим все, что захотят? Есть ли у вас чувство настоящего владельца чего-то, если многомиллиардная компания делает на этом деньги и не платит вам ни копейки?
Мой мозг говорит “нет”. А мой все еще активный аккаунт на Фейсбуке говорит “да”. | https://habr.com/ru/post/143111/ | null | ru | null |
# The Better Parts: доклад Дугласа Крокфорда о JavaScript и языках программирования будущего с конференции .concat() 2015
Кто знает о JS больше, чем один из его «отцов»? На [HolyJS 2017 Piter](https://holyjs-piter.ru) приедет легендарный Дуглас Крокфорд, создатель JSON и автор множества инструментов JavaScript. В преддверии его выступлений в Петербурге публикуем перевод его выступления на .concat() 2015: The Better Parts — о том как использовать существующие языки программирования более эффективно и каким будет язык программирования будущего. Хотя с момента выступления прошло более года, доклад коснулся ряда «вечных» вопросов программирования, которые, мы уверены, будут актуальны и через 3-5 лет.
Путь к совершенству
-------------------
 Этот человек — известный авиатор и писатель Антуан де Сент-Экзюпери. Большинство его помнит за то, что он является автором замечательной детской книги «Маленький принц» (хотя книга эта не совсем детская). Помимо нее он написал много других книг, и в одной из них есть удивительная фраза: «Как видно, совершенство достигается не тогда, когда уже нечего прибавить, но когда уже ничего нельзя отнять».
Это блестящая цитата. Она использовалась в разговорах о дизайне, архитектуре, притягивалась ко всему, что сочетает в себе креативность и дисциплину.
Он говорил о конструкции самолетов. Но, кажется, мысль на самом деле шире. Я думаю, что она лучшим образом подходит к компьютерной программе. Поскольку у нас особые отношения с совершенством, отсутствующие в других дисциплинах: то, что мы пишем, должно быть совершенным, или оно будет вести себя неправильно. И автор дает нам некоторое представление о том, как мы достигаем совершенства — через вычитание.
Я думаю, что это относится и к языкам программирования.
Языки программирования имеют тенденцию к постепенному усложнению. Но если мы хотим достичь совершенства, необходимо удалить оттуда некоторые вещи. В этом и заключается принцип сильных сторон. Согласно этому принципу, если функция в одних случаях полезна, а в других — опасна, при этом есть лучший вариант, всегда используйте лучший вариант.
Это удивительно противоречивое заявление. Есть множество людей, не желающих использовать лучший вариант. И происходит это из-за непонимания одной вещи: нам не платят за использование каждой функции языка. В конце проекта нет менеджера с портфелем, проверяющего: «А использовали ли вы двойное равенство»? Никто не заботится об этом. Нам платят за то, чтобы мы писали программы, которые хорошо работают и не содержат ошибок.
Когда «отсутствие ошибок» стало частью сделки? Оно всегда была ее частью. Просто мы очень редко достигаем этого. Легко забыть, что на самом деле отсутствие ошибок было первым требованием. Поэтому хороший язык программирования должен научить вас этому.
Я призываю людей изучать как можно больше языков программирования, потому что каждый из них даст вам новые идеи, которые вы сможете применить к другим языкам.
Язык, который научил меня больше всего, — это JavaScript. У меня было много времени, чтобы разобраться с ним, потому что я допустил каждую ошибку, которую только можно допустить в JavaScript. И начал с самой первой — наихудшей — я не удосужился выучить язык до того, как начал писать в нем.
В конце концов я изучил язык, а он научил меня. И продолжает меня учить. Я использовал этот язык для написания инструмента под названием JSLint, который читает программы JavaScript и подсказывает, как сделать их лучше. И JSLint научил меня еще больше. Все это изменило мою точку зрения на программирование, так что теперь моя основная цель — пытаться создавать программы, которые не содержат ошибок. И JSLint дал мне много информации о том, как это делать.
Я написал книгу о своем опыте использования JavaScript и кода JSLint — «JavaScript — сильные стороны». Возможно, вы слышали о ней. Она по-прежнему бестселлер, что редкость для книг по программному обеспечению. Большинство книг по программному обеспечению устаревают еще до выпуска, а эта по-прежнему актуальна. Все потому, что «сильные стороны» по-прежнему остаются сильными сторонами. Что хорошо, язык не изменился вообще.
Контраргументы
--------------
Теперь аргументы против использования «сильных сторон». Я бы хотел изложить их для вас:
* Первый звучит так: «**что хорошо, а что плохо — это просто вопрос мнения**». Это неправда. В рамках поддержки JSLint я получаю сообщения об ошибках от людей со всего мира. Недавно я получил письмо от одной компании, которая провела две недели, пытаясь решить некую проблему. Выяснилось, что в одном месте была случайно добавлена точка перед знаком равенства. Никто не видел ее, потому что она выглядела корректно, но результат был плохим. Поэтому они спросили меня, могу ли я модифицировать JSLint, чтобы никто больше не страдал от подобной проблемы. Почему нет? Я делаю это уже много лет. Так что если вы используете JSLint, вы никогда не потратите впустую две недели на проблему такого рода. И это не мнение, это факт.
* **Каждая функция является важным инструментом**. Это неправда. Вы можете написать лучшие программы, не используя некоторые из этих функций. И если вы можете писать более качественные программы без них, то они не так уж важны.
* **Я имею право использовать каждую функцию**. Тема разговора изменилась. Неужели мы больше не говорим о том, как лучше всего писать программы. Мы сейчас говорим о наших правах? На этом аргументация, в конечном итоге, заканчивается. «Я имею право писать дерьмо», правда? Это не важно. Важно, что мы обязаны писать очень хорошо.
* **Мне нужна свобода самовыражения** или «я художник и я самовыражаюсь, ставя точку с запятой в начале оператора, а не в конце». Соображения те же.
* **Мне нужно уменьшить количество нажатий клавиш**. Мы предполагаем, что большую часть времени печатаем. И если бы мы могли найти способ компоновки программ с помощью нескольких нажатий клавиш, это сделало бы нас намного эффективнее. Но дело обстоит с точностью до наоборот. Главный растратчик времени — не набор символов, а взгляд в бездну с возгласом: «мой бог, что я сделал, почему это не работает». Вот куда мы тратим большую часть времени. Если бы я мог предложить вам схему, согласно которой увеличение количества нажатий клавиш в 10 раз могло бы сократить ошибки вдвое, это было бы огромной победой (к сожалению, у меня нет такой схемы).
* **«Это оскорбление предполагать, что я когда-либо ошибусь, используя опасную функцию»**. «Я знаю, что можно ошибиться, но я настолько искусен, что это спасает меня. Думать иначе — оскорбление для меня, личная травма». Тут все понятно.
* «**Есть причина, почему эти функции были добавлены в язык**». Это абсолютно неверно. Существует множество причин, почему вещи попадают в язык, но большинство из них не являются вескими.
Например, JavaScript был разработан и реализован всего за 10 дней. Это удивительно. И блестящий человек, который это сделал, Брендан Айк, за эти 10 дней совершил несколько ошибок. Одна из них — оператор двойного равенства, который он заставил делать преобразование типа, прежде чем сравнивать элементы. Это вызывает ложные срабатывания, которые путают. Брендан Айк признал, что оператор был реализован неправильно. В то время многие другие языки (например, PHP) имели ту же ошибку. Брендан хотел исправить это. Поэтому, когда началась работа над стандартом, он решил, что сейчас самое время внести исправления. Он пошел к ECMA и сказал: «Такое поведение неверно, давайте сделаем правильно». Но в ECMA отказали, хотя и предложили компромисс: ввести оператор тройного равенства, который будет работать правильно. При этом двойное равенство осталось в языке для людей, которые уже начали использовать неправильную конструкцию. В итоге мы имеем оператор без веских на то оснований.
Брендан называет подобные особенности «выстрелом в ногу» (*footgun — в дословном переводе пистолет для выстрела в ногу, — прим. ред.*). И он непреднамеренно поместил их в JavaScript. Их использовать не рекомендуется.
Итак, целью языков программирования является помощь разработчикам в создании программ, не содержащих ошибок.
Раньше мы думали, что писать хорошие программы на JavaScript просто невозможно, потому что это был такой хрупкий язык. Но оказывается, что писать хорошие программы на JavaScript не только невозможно, но и не нужно. Как раз из-за своей «хрупкости» JavaScript требует большей дисциплины, чем любой другой язык программирования. И вы действительно должны ее придерживаться, чтобы писать нечто, что будет работать.
Есть две вещи, которые работают против этого. Во-первых, это фантазия о непогрешимости. В особенности молодые программисты считают, что их навыки настолько развиты, что они могут делать удивительные вещи, которые будут работать. Во-вторых, есть бесполезность безупречности, которую вы видите особенно у старых парней, которые делали годами то, что никогда не работало. Эти два очень разных взгляда приводят к одному и тому же: danger driven development. И это плохо.
Одна из вещей, усложняющих управление разработкой программного обеспечения, — это сложность планирования. Есть два времени, о которых вы должны знать. Время A — это время, необходимое для написания кода. Мы действительно плохо оцениваем его — у нас нет науки, которая ответила бы на вопрос, как оценивать время A. Но еще хуже обстоит дело с оценкой времени B — времени, необходимого на то, чтобы заставить код работать правильно.
Время B должно быть равно 0, верно? Вы пишете код — он должен работать. Но время В иногда становится больше времени А. Иногда оно бесконечно. Подобное происходит, когда у вас есть проект по разработке ПО, который заканчивается, но затем от ПО отказываются, прежде чем оно начинает работать.
Все, что вы делаете в рамках времени A, увеличивающее время B, неправильно. Вы должны пытаться сократить время B до нуля.
Новые сильные стороны ES6
-------------------------
Есть ряд дополнений к JavaScript, которые будут отправлены на ECMA General Assembly в июне этого года (*эти нововведения действительно прошли через процедуру сертификации и стали частью новой спецификации — ECMAScript 2015 Language Specification, — прим. ред.*).
Рад сообщить, что там есть некоторые новые сильные стороны. И сегодня я бы хотел поделиться ими с вами.
### Хвостовая рекурсия
Первое и лучшее — это конструкция, называемая хвостовой рекурсией. Если последнее, что делает функция, возвращает результат вызова функции (которая может быть вызовом другой функции), вместо создания обратной последовательности вызова компилятор генерирует скачок. Так что код будет работать немного быстрее, что приятно. Но что еще лучше — для некоторых моделей это значительно уменьшит потребление памяти. Таким образом, можно использовать совершенно новый класс алгоритмов.
Например, мы можем использовать стиль передачи продолжений и другие виды программирования, которые мы не могли реализовать на старом языке. Так что с этой функцией JavaScript, наконец, становится реальным функциональным языком программирования, и это здорово.
### Многоточие
Также мы получили оператор многоточия. Если мы поместим его в список параметров или аргументов, сможем иметь дело с переменным количеством аргументов, что действительно приятно.
Здесь у нас есть две версии функции curry. Первая — в соответствии с ES6:
```
function curry(func, ...first) {
return function (...second) {
return func(...first, ...second);
};
}
```
Вторая — как это реализовывалось ранее:
```
function curry(func) {
var slice = Array.prototype.slice, args = slice.call(arguments, 1);
return function () {
return func.apply(null, args.concat(slice.call(arguments, 0)));
};
}
```
Я не буду объяснять, что именно происходит во второй версии, потому что все это просто ужасно. Первая, наоборот, выглядит довольно разумно: всюду мы видим точки (здесь у вас может быть столько аргументов, сколько вы захотите). И это замечательно.
Нововведение не позволяет нам делать то, что мы не могли делать ранее. Но когда приходится иметь дело с переменным числом аргументов, такой подход намного приятнее.
### Модули
Теперь у нас появились модули. Вы можете импортировать и экспортировать значения из разных файлов; и это наконец-то имеет поддержку в языке. Раньше все это реализовывалось через глобальные переменные, и это было ужасно.
Теперь мы можем сделать это правильно. Если вам не кажется, что это здорово, попробуйте реализовать то же самое в соответствии с предыдущим стандартом. Но с ES6 мы наконец можем делать это правильно на полностью асинхронном языке, без блокировок.
### Константы
У нас появилось два новых способа определения переменных: let и const, что решает проблему области видимости блока. Оказывается, в хорошей программе вам не нужна область видимости блока. Но синтаксис JavaScript ранее выглядел так, будто область видимости блока есть (с его синтаксической конструкцией var), хотя это было не так, что смущало людей. Всякий раз из-за путанницы возникали ошибки. Let и Const позволяют этого избежать.
Опять же, новые конструкции не позволяют писать какие-либо программы, которые мы не могли написать раньше. Но теперь код не смущает Java-программистов, и это хорошо.
### Деструктуризация
У нас появилась деструктуризация, которая представляет собой еще одну синтаксическую конфетку. Она также не позволяет вам делать то, что вы не могли сделать раньше. Но для некоторых вещей новый синтаксис намного более выразителен.
Например, здесь у меня есть объект. И я хочу создать некоторые переменные, инициализировав эти переменные из свойств объекта.
```
let {that, other} = some_object;
let that = some_object.that, other = some_object.other;
```
Это очень упрощенный пример. Позже я покажу вам еще один пример того, как вы могли бы использовать это.
### WeakMaps
У нас появился WeakMap. WeakMap работает так, как должны были бы работать объекты. В объектах JavaScript ключи — это строки, что является ошибкой. Было бы лучше, если бы вместо них использовались какие-то значения. Но, тем не менее, это строки. WeakMap решает эту проблему. Здесь можно взять любое значение и использовать его в качестве ключа.
К сожалению, нам пришлось добавить эту вещь, и она значительно усложнила язык. Кроме того, мы назвали его худшим именем из когда-либо использованных в языках программирования (*weak — слабый, англ.*). Никто не захочет помещать в свою программу что-то слабое. Но работает эта конструкция действительно хорошо.
С помощью WeakMap вы можете писать программы, которые невозможно было создать на языке ранее.
### Шаблонные строки
И наконец мы нечто, что я назвал мегастроковым литералом (в языке это называется шаблонными строками, но мне не нравится это имя; но ранее их называли квази-литералами, что еще больше сбивало с толку).
Это регулярные выражения, которое соответствует нескольким строкам в ES6. Объявление этого регулярного выражения просто ужасно; я надеюсь, когда-нибудь мы сделаем что-нибудь получше. Но в ES6 у нас нет лучшей альтернативы.
Итак, у нас есть функция, которая принимает строку и преобразовывает ее в регулярное выражение, предварительно удалив все пробелы. Имея такую функцию, я могу взять любое выражение, но не писать все в кучу, а поместить в него необходимое пустое пространство, чтобы видеть элементы и то, как они соотносятся друг с другом. Результат будет тем же самым.
У этой конструкции есть один недостаток — компилятор рассматривает регулярное выражение как строку, поэтому не может выполнить проверку. Валидация не произойдет, пока мы не вызовем конструктор. Но в предыдущей версии записи из-за того, что все было смешано в кучу, серьезные ошибки также могли легко проскочить мимо компилятора. Поэтому я не думаю, что мы потеряем много в этом преобразовании.
Кстати, если вы часто работаете с регулярными выражениями, я настоятельно рекомендую инструмент под названием RegulEx. Поместите в него регулярное выражение, и он построит его диаграмму, чтобы вы точно видели, что именно происходит внутри. Я использую его каждый раз, когда я пишу регулярные выражения.
### Стрелочные функции
Еще одна новая функция, которую мы получили а ES6, это анонимные стрелочные функции. Хорошей мотивацией для их появления стало то, что некоторые люди жаловались на большой объем текста при наборе названий функций. Поэтому я добавил такую вещь. По сути это более короткое обозначение для функции. В результате я получаю функцию, которая будет принимать аргумент и возвращать объект, у которого указанное свойство имеет это значение.
Все хорошо, кроме того, что этого не работает должным образом. Если вы вызовете эту функцию, она вернет undefined вместо значения, потому что здесь присутствует ошибка. Так что это еще одна из тех маргинальных вещей, которые иногда хороши, а иногда — нет. Было бы здорово, если бы это работало все время, но это не так.
Недостатки ES6
--------------
Помимо сильных сторон, у ES6 есть и откровенно плохие элементы.
### Классы
Худшее нововведение — это классы. Класс был самой востребованной новой функцией, причем большая часть запросов поступала от Java-программистов, которые теперь должны писать на JavaScript и они действительно возмущены этим. Хочется писать на Java, но задачи и деньги есть в JavaScript, поэтому им приходится это делать. Переучиваться они не хотят, поэтому новый синтаксис упростит их жизнь.
Все бы ничего, но полагаясь на этот новый синтаксис, они никогда не поймут, как работает язык. И они никогда не поймут, как эффективно использовать этот язык, хотя будут думать, что понимают. Они так и продолжат писать, не зная, насколько они несчастны. Это ловушка.
#### Object.Create
Я пересматриваю то, что было написано в «Сильных сторонах», учитывая новые знания и необходимость отражения нововведений ES6. Когда я писал «сильные стороны», я рекомендовал вместо классов использовать object.create.
Фактически, именно мне удалось добавить object.create к языку, чтобы именно я мог его использовать. Получилось неплохо. Но как же я был удивлен, когда заметил, что прекратил использовать object.create. Я добавил его туда для себя, но даже я его не использую. И причина в том, что я прекратил использовать this.
### This
Я перестал использовать this из-за того, что в 2007 году сделал проект под названием ADSafe. В то время существовало несколько исследовательских групп, таких как fbjs в Facebook, Caja Google, Web Sandbox в Microsoft, кроме того, был мой собственный проект — ADSafe и другие. Все мы пытались выяснить, как сделать JavaScript безопасным языком, чтобы можно было добавить сторонний код в приложение и быть уверенным, что он не породит проблем с безопасностью. И в JavaScript это оказалось очень сложной задачей.
Одна из вещей, которая затрудняет ее решение — this. Если у вас есть this в методе, оно привязывается к списку событий объекта (это хорошо и необходимо). Но если вы вызываете тот же метод в качестве функции, this привязывается к глобальному объекту, что полностью нарушает нашу безопасность. Как с этим справиться?
Большинство проектов справились с этой проблемой при помощи компилятора, который переводит JavaScript в JavaScript со множеством рантайм-проверок и взаимодействий, чтобы предотвратить проблемы с безопасностью.
Мой подход в ADSafe был намного проще. Я просто сделал это незаконным, побудив отказаться от программ, где это используется. Это работает. Единственная проблема в том, что отказаться приходится от львиной доли программ, потому что все использовали this.
Однако моя гипотеза заключалась в том, что если удалить this из языка, мы все равно останемся с функциональным языком программирования, которого достаточно для написания хороших программ. Чтобы проверить ее, я начал писать также (без this) в свободном от ограничений JavaScript. И я был очень удивлен, обнаружив, что стал писать лучшие программы с меньшими усилиями, не имея this. Очень мило. Что и говорить, если наличие this в языке само по себе вызывает сложности: общаясь на английском, я не могу заранее знать, имеется в виду конструкция языка или местоимение. Это довольно сложно.
### Null / undefined
Я перестал использовать null. JavaScript имеет два минимальных значения — null и undefined. В некоторых языках считается, что у вас и одного не должно быть. JavaScript — это единственный язык, который у которого таких значений более одного. Но совершенно точно, что глупо иметь два сразу.
Некоторые фреймворки пытаются рассматривать их как взаимозаменяемые, но они таковыми не являются. В зависимости от ситуации я должен использовать только один из них. Я использовал undefined, потому что именно его использует сам язык: вы получаете undefined, если, к примеру, обращаетесь к отсутствующему свойству.
Неопределенное значение порождает целый круг проблем: совершенно неправильный тип отсутствующего объекта. Мы надеялись, что это будет исправлено в ES6, но этого не произошло. Наверное, так будет всегда. Но если вы не используете null, то не столкнетесь с этой проблемой. И я перестал использовать ошибочные значения, решив, что само их существование в JavaScript — плохая идея.
Изначально эта идея появилась из C, который использует 0 для представления no, false и другие аналогичные значения. JavaScript попытался сделать то же самое. Но это сбивает с толку.
### For
Я перестал использовать for. В ES5 мы ввели новый набор методов работы с массивами — for each, map и другие, поэтому теперь я использую эти инструменты. Если у меня есть массив и мне нужно его обработать, я использую один из этих методов. И я могу объединить их вместе удобным образом. Это действительно выразительно.
### For Each
Я не использую for each. В ES5 мы получили object .keys(object). Эта конструкция дает вам хороший массив строк. И он не включает в себя вещи из цепочки прототипов, поэтому вам не нужно фильтровать результаты. Очень приятно, что я могу взять массив и выполнить for each таким образом, это действительно выразительный способ.
Ранее я уже упоминал, что в ES6 появились правильная хвостовая рекурсия. И сейчас пора перестать использовать циклы вовсе (в частности, оператор while) — время использовать только рекурсивные функции.
Например, это рекурсивная функция. Вы вызываете эту функцию до тех пор, пока она не вернет undefined. Первая версия кода написана с использованием цикла while.
```
function repeat(func) {
while (func() !== undefined) {
}
}
```
Вторая версия написана с использованием хвостовой рекурсии.
```
function repeat(func) {
if (func() !== undefined) {
return repeat(func);
}
}
```
В ES6 эти два способа должны работать с одинаковой скоростью, потребляя ровно столько же памяти. Таким образом, у циклов перед рекурсией больше нет преимущества. Это здорово.
Язык следующего поколения
-------------------------
Я много думал о языке программирования следующего поколения. Каким он будет? Вероятно, это должен быть язык, которым мы заменим JavaScript, потому что было бы очень грустно, если бы оказалось, что JavaScript является последним языком программирования. Было невыносимо. Мы должны сделать мир лучше, по крайней мере для наших детей, не так ли?
Я думал о том, каким будет этот язык. Какие у него должны быть свойства? Какие проблемы он позволит решить? Как мы его распознаем, когда он все-таки появится?
В одной вещи я уверен: когда он, наконец, появится, мы отвергнем его. И причина этого в том, что программисты — эмоциональные и иррациональные ненормальные люди.
Мы считаем, что это не так. Мы думаем, что являемся ультра-рациональными, потому что исполняем роль послов людей в мире компьютеров, а компьютеры вполне рациональны. Соответственно, мы предполагаем, что и сами также рациональны. Многие из нас лишились социальных навыков, но выходит так, что иррациональность и эмоциональность никуда не делась. Давайте посмотрим на доказательства в поддержку этого тезиса:
* **Потребовалось поколение, чтобы признать языки высокого уровня хорошей идеей.** Когда среди множества ассемблерных языков появился Fortran, разработчики (на тот момент они все были ассемблерными программистами) отказались на него переходить. Потому что Fortran отнимал у них контроль взаимодействия с машиной, чего они не могли допустить. Переход сделал бы их жизнь намного лучше, но они отказались от него.
* **Потребовалось целое поколение, чтобы согласиться с тем, что go to был плохой идеей.** Десятилетиями мы вели эмоциональные споры о том, следует ли нам использовать go to или нет. И приводились как глубоко продуманные аргументы от очень умных людей, так и заявления в стиле: «Это мой способ самовыражения», «Мне нужна эффективность», «Умру, но не отдам». Оказалось, что все эти доводы были совершенно неправильными.
* **Потребовалось поколение, чтобы согласиться, что объекты были хорошей идеей.** В 1967 году в Норвегии появился язык, названный Simula. Насколько я могу судить, только один человек в мире — Алана Кей из Университета штата Юта (США) — признал, что этот язык содержал важные идеи. Все остальные пропустили это. Он думал, что объекты, которые появились в Simula были настолько выразительными, что он мог бы разработать язык программирования для детей. И дети могли бы писать удивительные программы, используя эту парадигму. Поэтому он начал изучать этот язык и потратил почти десять лет на разработку и совершенствование собственного. В 1980 он наконец был опубликован. И это был лучший из разработанных языков программирования в истории — С++. Алан Кей взял идеи Simula, не совсем понял их, но перевел на C.
Итак, у индустрии появился выбор: мы могли пойти вслед за Simula или за C++. Итоговое решение принимали люди, которые в корне не понимали, чем объекты были для программирования. Но они сделали выбор в пользу C ++, потому что там вам не нужно было разбираться в объектно-ориентированном программировании, чтобы начать работу с языком. И с тех пор почти во всех языках больше заимствовано от C++, нежели от Simula. И поэтому мы до сих пор ошибаемся.
* И, наконец, **потребовалось два поколения, чтобы согласиться с тем, что лямбды были хорошей идеей.** Лямбды появились в языке под названием Squeak в MIT в начале семидесятых. И индустрия вообще не обратила на это внимания. Потребовалось даже не два, а четыре поколения, чтобы наконец лямбды добрались до мейнстрима. На это потребовалось так много времени, что некоторые считали это доказательством несостоятельности идеи. Но оказалось, что функциональное программирование с лямбдами очень эффективно при работе с асинхронностью и распределенными системами, с которыми мы имеем дело сегодня. Первый язык, принявший эту идею, — JavaScript. После этого лямбды появились в Python и Ruby, и, в конечном итоге, C#. Не так давно наконец в Java. Но JavaScript был первым.
Причина, почему все происходит так долго, в том, что мы не можем изменить ум. Мы должны ждать, пока поколение уйдет на пенсию или умрет, прежде чем мы сможем получить критическую массу пользователей новой хорошей идеи и продолжать работать уже с ней.
Я помню, когда появился go to. Спор вокруг него не утихал годами, а потом вдруг стало тихо. Можем ли мы избавиться от него сейчас? Да, мы уже просто бросили его. Разве кто-нибудь страдает от отсутствия go to? Все споры оказались бессмысленным, произошел сдвиг парадигмы.
Людям действительно сложно сдвинуть эту парадигму. История с go to — это просто избавление от одной конструкции и изменение способа, структурирования программы. Оказалось, что отсутствие go to облегчает программирование.
Именно поэтому я считаю, что следующий язык программирования в первую очередь будет отклонен.
О классификации языков
----------------------
Подумайте о том, как мы классифицируем языки программирования. Я делю языки на два основных набора: системные и прикладные.
Системные языки используются для написания распределителей памяти, системных ядер, драйверов устройств — это языки очень низкого уровня. Все остальное должно быть написано на прикладных языках.
Возможно, самая большая проблема Java заключается в том, что ее создатели никак не могли решить, на какой стороне этой деления они хотели быть. И поэтому Java пытается оседлать обе задачи.
Нам нужны новые языки в обеих категориях. Например, доминирующим системным языком на сегодняшний день остается C, появившийся в шестидесятые годы. Но моя работа сосредоточена на прикладных языках — именно с ними большинство из нас и будут иметь дело.
Прикладные языки также можно разделить на две группы: классическую школу (к которой относятся почти все языки) и группу языков для прототипного программирования, которая включает JavaScript.
И я думаю, JavaScript правильно выбрал направление. Вызывая много критики, JavaScript содержит инновации.
Когда вы программируете на языке классической школы, проектируя систему, вам необходимо сделать классификацию объектов. Нужно проанализировать все объекты в вашей системе, чтобы понять, из чего они состоят, провести таксономию, выяснить, как классы будут связаны друг с другом, как и что будет реализовано. Все это довольно сложно, поскольку делается чаще всего в начале проекта, т.е. в той точке, где вы имеете минимальное понимание о том, как система должна будет работать. Поэтому неизменно вы получаете неправильную таксономию. И поэтому вы в конечном итоге получаете неправильно выделенные объекты. И с этого момента вы боретесь с ними. Все это не позволяет решить задачу правильно. Вы хотите, чтобы у вас было множественное наследование, но все это просто не работает. Более того, вы обнаруживаете, что поломка работает на новом, более высоком уровне, поскольку все, что наследуется от первого набора объектов, также неверно. В итоге вы получаете структурные проблемы по всей системе. И в конечном итоге становится так плохо, что вам приходится прибегать к реорганизации, чего делать очень не хочется, поскольку вам приходится разрывать все на части и собрать вместе заново. И вы надеетесь, что все это соберется вместе (а может и не собраться).
Все это не является обязательной частью объектно-ориентированного программирования. Это просто классы. Если вы займетесь объектно-ориентированным программированием без классов, вам не придется ничего делать. Поэтому в JavaScript, если вы просто делаете прототипы (и делаете их правильно), вам не нужно делать таксономию и выполнять рефакторинг. Это намного проще.
Я постоянно пытаюсь объяснить это Java-разработчикам. Но они так и не осознают, что таксономию делать не надо. Здесь нужен сдвиг парадигмы — они просто не могут осознать, что таксономия делает их несчастными, не могут представить другого способа.
Раньше я был сторонником прототипического наследования. Его основное преимущество заключается в сохранении памяти. В этом случае мы копируем объект, запоминая только реальное различие между оригиналом и копией, т.е. памяти выделяем меньше. И, возможно, это было самым важным фактором в 1995 году. Но не сегодня. Объем доступной памяти постоянно растет в соответствии с Законом Мура. Теперь у вас есть гигабайты оперативной памяти буквально в вашем кармане. Поэтому беспокоиться о том, сколько битов выделяется на каждый объект сегодня — просто потеря времени. Но мы по-прежнему делаем это.
Выгода, которую мы получаем от прототипов, на деле не является преимуществом. Кроме того, есть определенные расходы. К примеру, собственные свойства отличаются от унаследованных. И это различие вызывает путаницу, что является источником ошибок. Мы получаем ретроактивную наследственность, когда вы можете изменить наследуемый объект после его создания. Пользы в этом никакой, но я могу представить много способов использовать это во вред.
Все это также снижает производительность. Современные движки JavaScript работают очень быстро, делая предположения о параметрах объектов. Но они вынуждены с пессимизмом относиться к цепочкам прототипов, поскольку прототип может быть в любое время изменен. Таким образом, наличие такого уровня косвенности в языке фактически замедляет процесс.
Поэтому, хотя я и был сторонником прототипического наследования, теперь я придерживаюсь бесклассового объектно-ориентированного программирования. Я думаю, такой подход — дар JavaScript человечеству.
Позвольте объяснить, что я имею в виду. Это пример области видимости блока. Вы можете создать внутренний блок, который видит переменные внешнего блока. При этом другой блок не может видеть переменные во внутреннем блоке.
```
{
let a;
{
let b;
... a …
... b …
}
... a ...
}
```
JavaScript всегда был в состоянии так работать с функциями, поскольку функция — это просто блок, связанный с объектом. И поэтому функции имеют те же взаимоотношения.
```
function green() {
let a;
function yellow() {
let b;
... a …
... b …
}
... a ...
}
```
Множество переменных, которые видит внешняя функция, включается в множество переменных, видимых для внутренней функции (поэтому мы такие взаимоотношения называем замкнутыми — это понятие из теории множеств).
Но что делать, если внутренняя функция живет дольше, чем внешняя? В этом случае при вызове внешней функции в стеке выделяется А. Когда внешняя функция возвращает значение, А из стека удаляется. Как сделать, чтобы теперь внутренняя функция могла использовать это A?
Понадобилась пара поколений, чтобы понять, как это сделать. Это тривиально — просто не использовать стек, а выделять место в heap, имея при этом хороший сборщик мусора. Именно так мы это делаем сейчас.
С учетом всего этого вот, как я создаю объекты, в соответствии с ES6. Итак, у меня есть функция constructor:
```
function constructor(spec) {
let {member} = spec,
{other} = other_constructor(spec),
method = function () {
// member, other, method
};
return Object.freeze({
method,
other
});
}
```
Здесь я задаю спецификацию объекта. И мне это нравится гораздо больше, чем задание некого количества переменных.
Несколько лет назад я спроектировал ужасный конструктор, в котором было множество параметров, и никто не мог вспомнить, в каком порядке они шли. В какой-то момент мы осознали, что никто никогда не использует третий параметр. Но мы не могли ничего изменить, и это было ужасно. Вместо этого я создал один объект, описывающий то, что мы пытаемся сделать. Получилось более гибко — мы могли иметь значения по умолчанию, а также добавлять или удалять вещи со временем.
Но вернемся к нашему примеру. Я использую деструктуризацию, чтобы получить значения из объекта и инициализировать локальные переменные.
Далее вызываю другой конструктор. Я могу передать ту же спецификацию объекта, и это будет преобразование объекта. Затем я беру методы и помещаю их в локальные переменные. Я могу повторять вызов столько раз, сколько захочу, так что если мне необходимо множественное наследование или что-то вроде того, я могу реализовать это очень легко. Затем я создаю свои методы.
После этого я выполняю return. В ES6 у нас есть еще одна сокращенная нотация: вместо вызова метода можно просто написать method. Что приятно, это больше похоже на объявление, чем на литерал.
Далее я собираюсь его заморозить. Теперь это объект, который нельзя изменить, что правильно определяет его локальное состояние. Это лучший способ реализовать подобное на JavaScript. И я думаю, что это действительно важное свойство для объектов. В начале объектно-ориентированного программирования мы стартовали с идеи, реализованной в Pascal, согласно которой у нас есть запись, а затем мы связываем с этой записью функции, которые являются методами, действующими на элементы записи. И ранее я не мог выйти за эти рамки. Теперь же у меня теперь есть два совершенно разных набора объектов. У меня есть замороженные объекты, которые содержат только функции, и у меня есть значимые объекты, которые просто содержат данные. И я не смешиваю их. Я использую их друг с другом, чтобы защитить данные и обеспечить соблюдение дисциплины.
Единственный численный тип
--------------------------
### История одной ошибки
У меня есть еще немного времени, чтобы рассказать вам историю одной ошибки. В 2001 году я писал на Java один из первых парсеров JSON. И он содержал конструкцию this. Я создавал локальную переменную с именем index, она была int. Переменная измеряла, сколько символов было в файле или потоке, без парсинга. При обнаружении синтаксической ошибки переменная могла сообщить вам, в каком именно месте она произошла ошибка.
Напомню, я написал это в 2001 году. Я хорошо подумал, что int дает мне примерно 2 миллиарда байт — это два гигабайта. В то время это был довольно большой диск. Я не мог себе представить, что текст JSON окажется больше. Самый большой текстовый файл из тех, что я создавал, был пару килобайт.
Я думал, что все хорошо, пока в прошлом году не получил сообщение об ошибке от кого-то, у кого текст JSON был 7 Gb. И он содержал синтаксическую ошибку за пределами первых двух миллиардов символов, поэтому переменная давала в корне неверное значение. А все потому, что я выбрал int. Это оказалось ошибкой.
Я ненавижу int. У int есть ужасное свойство — он переполняется без предупреждения. Что должно произойти, если у вас есть число, которое слишком велико для помещения в int? Считается, что программа не должна вылетать. В итоге значимые биты выкидываются, а вы получаете неверные результаты. Лучше было бы бросить эксепшн, который скажет, что «что-то не так».
Альтернативный вариант — замена: когда вы попробуете получить значение, вам сообщат, что его больше здесь нет. Но существующий вариант — худшее, что можно было придумать; это путь максимизировать ошибки. Более того, эти ошибки никогда не выявляются в тестах, поскольку тесты изначально предполагают, что данные соответствуют диапазонам.
Может случиться так, что система будет работать в течение 10 или 20 лет, прежде чем ошибка будет выявлена. Я не хочу, чтобы моя система вообще когда-либо давала сбой, поэтому приглашаю вас с этим разобраться.
### DEC64
Причина всех проблем с типами данных родом из пятидесятых годов, когда компьютеры были ламповыми. Чем больше ламп, тем больше требуется энергии и косвенных затрат (например, тем быстрее выгорают лампы).
Кроме того, задействовать дополнительную память было действительно страшно. У машины могла быть только пара килобайт. К примеру, память Atari 2600 была всего 128 байтов. И поэтому не хотелось выделять 64 бита на то, что могло бы быть представлено 4 битами.
И кто-то догадался в целях экономии использовать дополнительную арифметику. Догадка была действительно великолепной. Но, спустя 50 лет, мы должны спросить себя — почему мы все еще делаем это?
Аналогичная ситуация сохраняется на других языках. Например, в Java у вас есть byte, char, short, int, long, flot, double и т.п. Каждый раз, когда вам нужно создать параметр, переменную или элемент, вы должны спросить себя, к какому типу будет относится новая структура. Значение сэкономленной при этом памяти настолько мало, что говорить о нем нет смысла. Нет никакой пользы в том, чтобы сделать правильный выбор. Фактически время, которое вы потратили на размышления, стоит бесконечно больше, чем сэкономленный ресурс. Но если вы ошибетесь, все перестанет работать, и тесты это не выявят. Это плохо.
С другой стороны, JavaScript имеет только один численный тип. Здесь вы не можете ошибиться. Единственная проблема с JavaScript заключается в том, что это неправильный тип. При его использовании 0.1 + 0.2 не равно 0.3. Это фундаментальная вещь. Проблема в двоичной плавающей запятой — это снова нечто, что имело смысл в пятидесятые годы.
В сороковые годы, когда проектировалась первая машина, речь шла о математике с целыми числами. Приходилось работать со шкалой арифметики, чтобы получить реальные значения. И это было тяжело. Но кто-то предложил использовать второе значение, связанное с каждым числом, которое сообщает, где находится десятичная точка. И это было намного проще. К сожалению, работало это очень медленно, поэтому работу с плавающей точкой перенесли на уровень аппаратного обеспечения.
В пятидесятые годы какой-то блестящий инженер пришел к мысли, что можно использовать двоичную плавающую точку вместо десятичной: вместо того, чтобы делать сдвиг на 10 при помощи деления, мы можем сделать сдвиг на один бит, что намного дешевле.
По сей день мы продолжаем это делать. И это неправильно, поскольку вызывает проблемы. Это было так же неправильно и в пятидесятые годы: бизнесмены возражали, что не могут пользоваться такими вычислениями. Вместо этого они использовали BCD (двоично-десятичный код). Таким образом языки программирования разделились. Вы могли использовать Fortran с плавающей запятой или COBOL с BCD. В конце концов, ситуация стала совсем запутанной. Java стала наследником COBOL. Но Java не была предназначена для ведения бизнес-процессов. Так что этот функционал здесь просто не используется.
Я предлагаю решение этой ужасной проблемы. Я назвал его DEC64. Это 64-битное значение, которое на самом деле очень похоже на то, что было сделано в сороковых годах.
Здесь используется 56-битный коэффициент, который является просто большим целым числом, а также отрицательный показатель. На Intel архитектуре я могу распаковать это практически бесплатно. С точки зрения научных вычислений этот формат также делает все, что нужно. Он соответствует и нуждам бизнеса. Поэтому я предлагаю его как единственный численный тип в будущих прикладных языках (у системных языков другие потребности, и поэтому они будут делать другие вещи).
Я написал реализацию DEC64 на ассемблере Intel x64 — используйте ее, если хотите опробовать тип в аппаратной реализации (dec64.com, [GitHub](https://github.com/douglascrockford/DEC64/)).
Этот тип избавит от необходимости иметь отдельный int. Кроме того, он правильно считает деньги и выполняет арифметические операции так, как нас учили это делать в средней школе.
Мое предложение сделать этот тип единственным означает, что я должен убедить всех в этом мире, что нужно делать именно так. И я догадываюсь, насколько это сложно. Но на самом деле мне не нужно убеждать всех в этом мире. Мне нужно убедить только одного человека — мужчину или женщину, который(которая) разрабатывают следующий язык программирования. Если я смогу убедить этого человека, данный тип, который хорошо работает для людей, станет единственным.
У меня есть немного опыта в сфере убеждения всего мира в том, как поступать правильно. Пример — мой любимый формат обмена данными JSON.
Это статистика Google, которая показывает относительную популярность XML (красным) и JSON (синим). Вы можете видеть, что мир неуклонно теряет интерес к XML с 2005 года, и он очень медленно растет интерес к JSON.
Стоит отметить, что на рост популярности JSON не повлияла никакая отрасль. Нет крупных корпораций, которые продают большие инструменты JSON, потому что вам не нужны большие инструменты для работы с JSON. Вот почему вам он нравится. Это просто работает.
Похоже, скоро будет пересечение. Я не могу предсказать, когда это произойдет. Но Google может. Согласно прогнозам Google Trends это произойдет в этом году (*2015 — прим. ред.*). JSON наконец станет официально более интересным, чем XML.
---
Если вам интересна оригинальная видеозапись доклада на английском, с радостью ее предоставляем:
---
На грядущем HolyJS Piter вы сможете прослушать два доклада Дугласа Крокфорда:
* [The Post JavaScript Apocalypse](https://holyjs-piter.ru/talks/keynote-the-post-javascript-apocalypse/)
* [Typing, Goto There and Back Again](https://holyjs-piter.ru/talks/typing-goto-there-and-back-again/)
Кроме них в течение двух дней вы услышите еще более 20 докладов о JavaScript: от новых фронтенд фреймворков до разбора серверного перфоманса и десктопной разработки. Будут доклады от Lea Verou, Martin Splitt, Anjana Vakil, Claudia Hernández и много кого еще. Детали смотрите [на сайте конференции](https://holyjs-piter.ru/talks/). | https://habr.com/ru/post/327320/ | null | ru | null |
# Samsung удалённо блокирует свои «серые» Smart TV в России. UPD — заявление Samsung
> Никогда и ничего фирмы Самсунг я больше в жизни не куплю!!! И буду отговаривать всех кто будет спрашивать совет в покупке техники!
*Типичный гнев анонимуса на заданную тему*
С 22 января Самсунг начала активно блокировать работу Smart TV на своих телевизорах, не предназначенных производителем для эксплуатации на территории России. Пару дней назад эта ситуация получила широкую огласку и с тех пор рунет не утихает.
Понятно желание производителя воспользоваться преимуществами российского законодательства (национальный принцип исчерпания права на товарный знак — [ст. 1487 ГК РФ](http://www.consultant.ru/document/cons_doc_LAW_64629/d385de69e4ce009809fb698159d15e2abc56ba1c/)), ограничить параллельный импорт и таким образом защитить свою маржу.
`Например, одна из самых популярных моделей Q70 в размере 55" стоит около 64 000 рублей, а в официальном магазине - 100 000 рублей. Для больших диагоналей разница в цене составляет 1,5-2 раза.`
Но пикантность ситуации в том, что применённые меры ударили в первую очередь по конечным потребителям уже введённой в оборот продукции, а не по импортёрам. На форумах множество историй о том, как люди самостоятельно покупали телевизоры в Финляндии или Польше и совершенно легально ввозили их в Россию, не подозревая, что могут столкнуться с проблемами. Но вне зависимости от варианта покупки — самостоятельно за рубежом или у неофициального продавца на условной Горбушке — получили окирпиченный Smart TV.
Дополнительная сложность для конечного потребителя в том, что не всегда удаётся чётко определить какой именно телевизор предлагает продавец. Например, вот [тут](https://vc.ru/claim/105162-samsung-zablokirovala-moy-televizor) человек был уверен, что покупает «легальный» телевизор, но в результате получил блокировку. Там же можно увидеть один из типичных ответов Самсунга:
> Уважаемый Eugene, мы ознакомились с описанием вашей проблемы и сожалеем о сложностях, с которыми вы столкнулись.
>
>
>
> Подобная информация на экранах ТВ указывает на то, что данный ТВ был изготовлен для другого региона и может не соответствовать техническим требованиям региона фактического нахождения. Что исключает возможность производителя гарантировать доступность всех функций в стране проживания пользователя (фактического использования устройства).
>
> Информация о том, что доступность функций зависит от региона поставки указана в инструкции пользователя.
>
>
>
> Мы рекомендуем покупать продукцию только у официальных ритейлеров в регионе, чтобы иметь возможность пользоваться всеми функциями изделия и также поддержкой производителя.
>
> Для того, чтобы убедиться в этом, просим вас связаться с нашей сервисной службой по бесплатному номеру 8-800-555-55-55.
Конечно чувствуется некоторое противоречие между обтекаемой фразой «исключает возможность производителя гарантировать доступность всех функций в стране проживания пользователя» и фактическим преднамеренным принудительным дистанционным отключением функций.
На форумах с переменным успехом ищут варианты обхода блокировок. Основной вариант — перенастройка региона и активация через VPN европейского смарт хаба. Но в этом случае будут доступны приложения и сервисы выбранного европейского региона, зачастую без ivi, okko, Яндекса и Матч ТВ. Другой вариант решения проблемы более экстремальный — замена системной платы ТВ на аналог от официальной модели. Стоит такая процедура не менее $140.
Что дальше? Некоторые пользователи рассказали, что уже обратились в Роспотребнадзор с просьбой проверить законность действий компании Самсунг. Другие даже успели оформить петицию на change.org. Форумы заполнены радостными дистрибуторами «легальных» телевизоров и на удивление радостными пользователями «легальных» телевизоров, которые активно клеймят «нищебродов», которые «сами виноваты». При этом люди справедливо замечают, что дальше стоит ждать проблем с прочей «нелегальной» умной техникой Самсунг, что ставит под вопрос целесообразность дальнейшей приверженности этому бренду.
С другой стороны в случае с телевизорами потеряна только функциональность Smart TV, а сам экран продолжает исправно показывать картинку с внешних источников. Разница в цене с «легальным» телевизором такова, что некоторые на эти деньги покупают Xbox/Play Station, Nvidia shield или более бюджетные варианты — Apple TV, Xiaomi Mi Box и прочие умные коробочки.
Теперь ход за конкурентами. Если Sony и LG не последуют примеру своего основного конкурента, то можно предположить, что любовь потребителей сместится в их сторону не смотря на приятные технические характеристики экранов Самсунга.
UPD. Самсунг выпустила официальное заявление. Бла-бла-бла мы хотим денег, а вы — держитесь. [news.samsung.com/ru/officialstatement2](https://news.samsung.com/ru/officialstatement2)
> В связи с появлением информации о проблемах пользователей, связанных с блокировкой на территории России некоторых функций телевизоров, компания Samsung Electronics сообщает.
>
>
>
> Блокировка затронула функции устройств, которые были произведены для использования на территории других государств или регионов.
>
>
>
> Заблокированные функции не могли быть доступны на таких устройствах без проведения манипуляций по изменению установленных заводских настроек (например, разблокировкой или перепрошивкой).
>
>
>
> Такие устройства не сертифицированы для использования в российском регионе, что исключает возможность производителя гарантировать корректную их работу, доступность всех функций, а также своевременное и качественное сервисное обслуживание в соответствии с глобальными корпоративными стандартами компании Samsung Electronics. Кроме того, часть сервисов, реализуемых через заблокированную платформу, могут иметь лицензионные ограничения по территории использования.
>
>
>
> Информация о том, что доступность функций зависит от региона поставки указана в инструкции пользователя.
>
>
>
> В соответствии с законодательством РФ устройства должны иметь сертификаты EAC (сертификат соответствия техническому регламенту Eвразийского Экономического Союза) и быть маркированы знаком EAC на этикетке корпуса и коробки. Сертификат EAC должен иметься в наличии у продавца.
>
>
>
> Мы рекомендуем пользователям при покупке телевизоров проверять наличие такого сертификата в месте продажи, а также удостовериться, что модель, указанная в сертификате EAC, полностью совпадает с моделью, указанной на устройстве.
>
>
>
> Все телевизоры, сертифицированные для продажи на территории России, в полном наименовании модели оканчиваются на латинские буквы RU.
>
>
>
> Компания Samsung рекомендует покупать продукцию только в официальных каналах продаж (например, в магазинах фирменной розницы Samsung или на сайте фирменного интернет-магазина), чтобы иметь возможность пользоваться всеми функциями изделия и также поддержкой производителя.
>
>
>
> По всем вопросам идентификации устройств мы рекомендуем обращаться в службу поддержки Samsung Electronics по телефонам: 8-800-555-55-55 (бесплатно с городских и мобильных телефонов местных сотовых операторов по России).
>
>
>
> Кроме того, дополнительную информацию по вопросам технической поддержки можно найти на сайте Samsung в соответствующем разделе: [www.samsung.com/ru/support/category/tv-audio-video](https://www.samsung.com/ru/support/category/tv-audio-video/) | https://habr.com/ru/post/487290/ | null | ru | null |
# AWS: IAM роли для серверов
Привет! 
Я хочу рассказать о фиче IAM ролей для серверов в AWS. Роль — это совокупность прав доступа, которые можно применить к серверу. Можем рассмотреть на определённом примере — дать доступ серверу к S3, не забивая никаких ключей вручную.
Приступим к примеру.
#### 1. Создадим роль с нужными правами
Идём в консоль IAM и там создаём роль S3.
Далее выбираем Amazon EC2
Далее Amazon S3 Full Access
Далее-далее-далее.
#### Запустим сервер.
Запустим обычный сервер с Amazon Linux (на нём сразу установлены все нужные тулзы). В Advanced Details выбираем роль, которую только что создали:
И стартуем сервер.
#### 3. Тестируем.
Зайдя по ssh на сервер мы можем достать ключи доступа, обратившись по адресу
[http://169.254.169.254/latest/meta-data/iam/security-credentials/S3](http://ec2-54-234-43-218.compute-1.amazonaws.com)
Ответ в формате JSON можно распарсить и вытащить из него нужные данные:
```
{
"Code" : "Success",
"LastUpdated" : "2012-11-29T16:23:50Z",
"Type" : "AWS-HMAC",
"AccessKeyId" : "ASIAI6G6HHSLUCRSUCQA",
"SecretAccessKey" : "15WdeWs2H182T+j3ZKkK+JBOssFqWdxdVpsHHgBm",
"Token" : "AQoDYXdzEDIagAL1yc69LLX+jH3tyDdf1rSk++Y1+4TrpYo4VUhHzcdFh3M9aWzUx1JCrWVoOr1Ghnkd3ALgUPBPtFrviuanVOSoXZBbuF0CKl3iVVLTJpEmOMStAAs0myrezYnUNVwIxIawSczxQkKIAuHDszV2mDFBBQ8RbKYu7wHAh+lQvUmfppyIcZ2kCHy/DtGuB9pYXxiNbTnFEN15LtOCojHdVicJSW4s5ynDd36GjsYYcAGmtDGNZXkUI/AS/ljgOtK1+7o9xN+M2RKJj7niL/iRv0LjWuTyTD9Z/D+p9k4KeLCiujKLTIt7g2VDiKqOg0r1OwI76Uh4q0MokEVH+PGuiccNILyY3oUF",
"Expiration" : "2012-11-29T22:38:49Z"
}
```
Далее дело техники. Мы можем проводить все операции с сервисами, к которым имеем доступ. | https://habr.com/ru/post/160755/ | null | ru | null |
# Мои грабли: из грязи в князи
Предыстория
-----------
Я работаю фронтенд разработчиком уже на протяжение одного года. На моём первом проекте был «вражеский» бэкенд. Бывает так, что это не составляет больших проблем, когда налажена коммуникация.
Но в нашем случае было не так.
Мы разрабатывали код, который опирался на то, что бэкенд отправляет нам определённые данные, определённой структуры и определённого формата. В то время как бэкенд считал нормальным изменять содержимое ответов – без предупреждения. В итоге у нас тратились часы на то, чтобы определить почему определённая часть сайта перестала работать.
Мы осознали, что нам необходимо проверять то, что возвращает бэкенд, прежде чем полагаться на данные, которые он нам прислал. Мы создали таску на исследования вопроса валидации данных со стороны фронтенда.
Это исследование было поручено мне.
Примерно составил список того, что хочу, чтобы было в том инструменте, который хотел бы использовать для валидации данных.
Самыми важными пунктами отбора были следующие пункты:
* декларативное описание(схема) валидации, которая трансформируется в функцию-валидатор, которая возвращает true/false (валидно, не валидно)
* низкий порог входа;
* схожесть валидируемых данных с описанием валидации;
* легкость интеграции кастомных валидаций;
* легкость интеграции кастомных сообщений об ошибках.
Как результат, нашел множество библиотек валидации, рассмотрев ТОП-5(ajv,joi, roi…). Все они очень хороши. Но мне показалось, что ради решения 5% сложных случаев – они обрекали 95% самых частых случаев быть довольно многословными и громоздкими.
Поэтому подумал: почему бы самому не разработать что-то, что меня бы устроило.
Четыре месяца спустя, вышла седьмая версия моей библиотеки валидации [quartet](https://www.npmjs.com/package/quartet).
Это была стабильная версия, полностью оттестированная, 11к скачиваний на npm. Мы использовали её на трёх проектах в кампании на протяжение трёх месяцев.
Эти три месяца сыграли очень полезную роль. [quartet](https://www.npmjs.com/package/quartet) продемонстрировал все свои преимущества. Проблем с данными от бэкенда не осталось. Каждый раз, когда они меняли ответ – у нас это сразу же кидало ошибку. Время нахождение причин багов сократилось разительно. Багов с данными практически не осталось.
Но также были выявлены и недостатки.
Поэтому принял решение проанализировать их и выпустить новую версию с исправлениями всех ошибок, которые были допущены во время разработки.
Об этих архитектурных ошибках и их решениях расскажу далее.
Архитектурные грабли
--------------------
### «Строко»-типизированный язык схемы
Приведу пример старого варианта схемы, для объекта персоны.
```
const personSchema = {
name: 'string',
age: 'number',
linkedin: ['string', 'null']
}
```
Эта схема валидирует объект с тремя свойствами: имя – должно быть строкой, возраст – должен быть числом, ссылка на акканут в LinkedIn – должен либо быть null (если аккаунта нет) либо строкой(если аккаунт есть).
Эта схема отвечает моим требованиям по читаемости, схожестью с валидируемыми данными и думаю порог входа к обучению написанию таких схем – не высок. Более того, такую схему можно легко написать имея определение типа на typescript:
```
type Person = {
name: string
age: number
linkedin: string | null
}
```
(Как видим – изменения скорее косметические)
Когда принимал решение, что должно использоваться для наиболее частых вариантов валидаций(например используемых выше). Выбрал использование – строк, как-бы имён валидаторов.
Но проблема строк в том, что они недоступны для компилятора или анализатора ошибок. Строка ‘number’ для них не сильно отличается от ‘numder’.
### Решение
В новой версии [quartet](https://www.npmjs.com/package/quartet) 8.0.0. Решил убрать из квартета – использование строк как наименований валидаторов внутри схемы.
Схема выглядит теперь так:
```
const personSchema = {
name: v.string
age: v.number,
linkedin: [v.string, null]
}
```
Такое изменение имеет два больших преимуществ:
* компиляторы или анализаторы ошибок – смогут обнаружить то, что имя метода написано с ошибкой.
* Строки – больше не используются как элемент схемы. Это значит, что для них можно выделить новую функционал в библиотеке, который будет описан ниже.
### Поддержка TypeScript
В общем-то первые семь версий разрабатывались на чистом Javаscript. При переходе на проект с Typescript возникла необходимость как-то приспособить библиотеку для него. Поэтому были написаны декларации типов для библиотеки.
Но в этом был минус – при добавлении функционала, или при изменении каких-то элементов библиотеки всегда было легко забыть обновить объявления типов.
Также были просто незначительные неудобства такого рода:
```
const checkPerson = v(personSchema) // (0)
// ...
const person: any = await axios.get('https://myapi.com/person/42')
if (!checkPerson(person)) {// (1)
throw new TypeError('Invalid person response')
}
console.log(person.name) // (2)
```
Когда мы создали валидатор объекта на строке (0). Мы хотели бы, чтобы после проверки реального ответа с бэкенда на строке (1) и обработки ошибки. На строке (2) чтобы `person` имела тип Person. Но так не происходило. К сожалению такая проверка – не была type guard’ом.
### Решение
Принял решение переписать всю библиотеку [quartet](https://www.npmjs.com/package/quartet) на Typescript, чтобы проверкой соответствия библиотеки типам – занимался компилятор. Попутно добавим к функции, которая возвращает скомпилированный валидатор – параметр типа, который бы определял type guard’ом какого типа является этот валидатор.
Пример выглядит так:
```
const checkPerson = v(personSchema) // (0)
// ...
const person: any = await axios.get('https://myapi.com/person/42')
if (!checkPerson(person)) {// (1)
throw new TypeError('Invalid person response')
}
console.log(person.name) // (2)
```
Теперь на строке (2) `person` имеет тип `Person`.
### Читаемость
Также было два случая, где код плохо читался: проверка на соответствие определённому множеству значений(проверка enum’ов) и проверка остальных свойств объекта.
a) Проверка enum’ов
Изначально была идея, на мой взгляд хорошая. Продемонстрируем её добавлением поля «пол» к нашему объекту.
Старый вариант схемы выглядел так:
```
const personSchema = {
name: 'string',
age: 'number',
linkedin: ['null', 'string'],
sex: v.enum('male', 'female')
}
```
Вариант очень читаемый. Но как обычно бывает, всё пошло немного не по плану.
Имея при себе объявленный enum в программе, например такой:
```
enum Sex {
Male = 'male',
Female = 'female'
}
```
Естественно хочется использовать его внутри схемы. Чтобы при изменении какого-то из значений (Например ‘male’ -> ‘m’, ‘female’ -> ‘f’) изменилась и схема валидации.
Поэтому почти всегда валидация enum’ов записывалась так:
```
const personSchema = {
name: 'string',
age: 'number',
linkedin: ['null', 'string'],
sex: v.enum(...Object.values(Sex))
}
```
Что выглядит довольно громоздко.
b) Валидация остаточных свойств объекта
Предположим к нашему объекту мы прибавим ещё такую характеристику – у него могут быть дополнительные поля, но все они должны быть ссылками на соцсети – значит должны быть равны либо `null` либо быть строкой.
Старая схема выглядела бы так:
```
const personSchema = {
name: 'string',
age: 'number',
linkedin: ['null', 'string'],
sex: v.enum(...Object.values(Sex)),
...v.rest(['null', 'string']) // Rest props are string | null
}
```
Данная запись выделяла остальные свойства – от уже перечисленных. Использования spread-оператора – скорее путает человека, который хочет понять эту схему.
### Решение
Так как было описано выше – строки перестали быть частью схем валидации. Схемой валидации остались только три вида значений Javascript. Объект – для описания схемы валидации объекта. Массив для описания – нескольких вариантов валидности. Функция(сгенерированная библиотекой или кастомная) – для всех остальных вариантов валидации.
Данное положение позволило добавить функционал, который позволил в разы увеличить читаемость схемы.
В самом деле, что если мы хотим сравнить значение со строкой ‘male’. Неужели нам нужно знать что-то ещё кроме самого значения и строки ‘male’.
Поэтому было принято решение – добавить значения примитивных типов – как элемент схемы. Стало быть там, где вы встречаете примитивное значение в схеме, это значит, что это то валидное значение, которое должен проверить валидатор созданный по данной схеме. Лучше приведу пример:
Если нам нужно проверить число на равенство 42-ум. То мы запишем это так:
```
const check42 = v(42)
check42(42) // => true
check42(41) // => false
check42(43) // => false
check42('42') // => false
```
Посмотрим как это отразится на схеме person(без учёта дополнительных свойств):
```
const personSchema = {
name: v.string,
age: v.number,
linkedin: [null, v.string], // null is primitive value
sex: ['male', 'female'] // 'male', 'female' are primitive values
}
```
С использованием заранее определённых еnum’ов мы можем переписать так:
```
const personSchema = {
name: v.string,
age: v.number,
linkedin: [null, v.string],
sex: Object.values(Sex) // same as ['male', 'female']
}
```
В данном случае убралась лишняя церемониальность в виде использования метода enum и использования spread-оператора для вставки валидных значений из объекта как параметров в этот метод.
Что считается примитивным значением: числа, строки, символы, `true`, `false`, `null` и `undefined`.
То есть если нам нужно сравнить значение с ними – мы просто используем сами эти значения. И библиотека валидации – создаст валидатор, который строго сравнит значение с указанными в схеме.
Для валидации остаточных свойств было выбрано использовать особое свойство для всех остальных полей объекта:
```
const personSchema = {
name: v.string,
age: v.number,
linkedin: [null, v.string],
sex: Object.values(Sex),
[v.rest]: [null, v.string]
}
```
Таким образом схема выглядит более читаемой. И более похожей на объявления из Typescript.
### Связанность валидатора с функцией, которая создала его
В старых версиях объяснения ошибок – не были частью валидатора. Они складывались в массив внутри функции `v`.
Раньше, чтобы получить объяснения ошибок валидации необходимо было иметь при себе валидатор(чтобы провести проверку) и функцию v(чтобы получить объяснения невалидности). Всё это выглядело следующим образом:
a) Мы добавляем объяснения в схему
```
const checkPerson = v({
name: v('string', 'wrong name')
age: v('number', 'wrong age'),
linkedin: v(['null', 'string'], 'wrong linkedin'),
sex: v(
v.enum(...Object.values(Sex)),
'wrong sex value'
),
...v.rest(
v(
['null', 'string'],
'wrong social networks link'
)
) // Rest props are string | null
})
```
К любому элементу схемы – можно добавить объяснение ошибки используя второй аргумент функции-компилятора v.
b) Очистить массив объяснений
Перед валидацией нужно было очищать этот глобальный массив в который записывались все объяснения во время валидации.
```
v.clearContext() // same as v.explanations = []
```
c) Провести валидацию
```
const isPersonValid = checkPerson(person)
```
Во время этой проверки, если невалидность была обнаружена, и на этапе создания схемы – ей была указано объяснение, то это объяснение помещается в глобальный массив `v.explanation`.
d) Обработка ошибки
```
if (!isPersonValid) {
throw new TypeError('Invalid person response: ' + v.explanation.join('; '))
} // ex. Throws ‘Invalid person response: wrong name; wrong age’
```
Как видим здесь есть большая проблема. Потому что если мы захотим использовать валидатор не в месте его создания. Нам необходимо будет передавать в параметры не только его, но и функцию, которая его создало. Потому что именно в ней находится массив в который будут сложены объяснения.
### Решение
Эта проблема была решена так: объяснения стали частью самой функции валидации. Что можно понять из его типа:
type Validator = (value: any, explanations?: any[]) => boolean
Теперь если вам необходимы объяснения ошибки – вы передаёте массив, в который вы хотите сложить объяснения.
Таким образом валидатор становится независимой единицей. Также добавлен метод, который может трансформировать функцию валидации в функцию, которая возвращает null, если значение валидно, и возвращает массив объяснений, если значение не валидно.
Теперь валидация с объяснениями выглядит так:
```
const checkPerson = v({
name: v(v.string, 'wrong name'),
age: v(v.number, 'wrong age'),
linkedin: v([null, v.string], 'wrong linkedin')
sex: v(Object.values(Sex), 'wrong sex')
[v.rest]: v([null, v.string], 'wrong social network')
})
// ...
const explanations = []
if (!checkPerson(person, explanation)) {
throw new TypeError('Wrong person: ' + explanations.join('; '))
}
// OR
const getExplanation = v.explain(checkPerson)
const explanations = getExplanation(person)
if (explanations) {
throw new TypeError('Wrong person: ' + explanations.join('; '))
}
```
Послесловие
-----------
Я выделил три предпосылки из-за которых пришлось всё переписывать:
* Надежда на то, что люди не ошибаются при написании строк
* Использование глобальных переменных (в данном случае массива v.explanation)
* Проверка на маленьких примерах во время разработки – не показала проблем, которые возникают при использовании в реальных больших случаях.
Но я рад, что провел анализ этих проблем, и выпущенная версия – уже используется в нашем проекте. И надеюсь она нам будет полезна не меньше чем предыдущая.
Всем спасибо за прочтение, надеюсь мой опыт будет вам полезен. | https://habr.com/ru/post/453502/ | null | ru | null |
# Spring Cloud Contract. Что такое контрактное тестирование и с чем его едят
Тестирование является неотъемлемой частью процесса разработки ПО. Согласно [пирамиде тестирования Майка Коэна](https://martinfowler.com/articles/practical-test-pyramid.html) ~~как не сказать про пирамиду тестирования~~ можно выделить следующие виды тестирования:
* модульное тестирование (60%)
* интеграционное тестирование (20%)
* приемочное тестирование (15%)
* сквозное тестирование (5%)
где % — это соотношение количества тестов, *которое может различаться от проекта к проекту.*
Контрактное тестирование или **Consumer Driven Contract (CDC)** является связующим звеном между модульным и интеграционным тестированием. Тут важно отметить скорость выполнения тестов, а именно, чем выше по пирамиде находятся тесты, тем ниже скорость и выше сложность тестируемого взаимодействия или тем больше можно проверить интеграцию с другими ПО. Таким образом, при контрактном тестировании выше необходимость в поиске проблемных мест за один прогон теста.
### Итак, что же такое Consumer Driven Contract (CDC)?
Как известно, а также хорошо [описано тут,](https://habr.com/ru/post/358950/) каждый интерфейс имеет поставщика (supplier) и потребителя (consumer). Само собой, сервисы поставщика и потребителя распределены между разными командами, мы оказываемся в ситуации, когда чётко прописанный интерфейс между ними (или контракт) просто необходим. Обычно многие подходят к этой проблеме следующим образом:
1. Пишут подробное описание спецификации интерфейса - контракт
2. Реализуют сервис поставщика согласно спецификации
3. Передают спецификацию интерфейса потребителю
4. Ждут реализации от другой стороны
5. Запускают ручные системные тесты, чтобы всё проверить
6. Держат кулачки, что обе стороны будут вечно соблюдать описанный интерфейс
Сегодня многие компании заменили последние два шага на автоматизированные контрактные тесты, которые регулярно проверяют соответствие описания и реализации у поставщика и потребителя определённого контракта. Что является набором регрессионных тестов, которые обеспечивают раннее обнаружение отклонения от контракта.
Разберемся во взаимодействии на примере REST архитектуры: поставщик создает API c некоторым endpoint, а потребитель отправляет запрос к API, например, с целью получения данных или выполнения изменений в другом приложении.
Это контракт, который описывается с помощью DSL (domain-specific language). Он включает API описание в форме сценариев взаимодействия между потребителем и поставщиком. С помощью CDC выполняется тестирование клиента и API с использованием заглушек, которые собираются на основе контракта. Основной задачей CDC является сближение восприятия между командами разработчиков API и разработчиков клиента. Таким образом, участники команды потребителей пишут CDC тесты (для всех данных проекта разработки), чтобы команда поставщика смогла запустить тесты и проверить API. В итоге команда поставщика с легкостью разработает свой API, используя тесты CDC. **Результатом прогона контрактных тестов является понимание, что поставщик уверен в исправной работе API у потребителя.**
Следует обратить внимание, что команда потребителя должна регулярно осуществлять поддержку CDC-тестов при каждом изменении, и вовремя передавать всю информацию команде поставщика. Если регулярно фиксируем неудачно выполненные CDC-тесты, то следует пойти (в буквальном смысле слова, к пострадавшей стороне теста и узнать, в рамках какой задачи были изменения (что привело к падению теста), а также уточнить, к чему в перспективе приведет данное изменение – прокачиваем софт скиллы:)). Из того, что было описано выше, можно выделить следующие **тезисы для выполнения контрактного тестирования:**
1. Команда разработчиков (тестировщиков) со стороны потребителей пишет автоматизированные тесты с ожидаемыми параметрами со стороны потребителей.
2. Тесты передаются команде поставщика.
3. Команда поставщика запускает контрактные тесты и проверяет результат их выполнения. Если происходит падение тестов, то команды должны зафиксировать сбой и перепроверить документацию (согласованность разработки).
Использование CDC-тестов является важным шагом в разработке микросервисной архитектуры приложений, т.к. позволяет использовать автономные группы тестов. Т.к. в данный момент микросервисная архитектура становится широко применяемой в IT, то подход с CDC-тестированием становится популярным и, что немаловажно, достаточно эффективным из-за своей позиции в иерархии видов тестов.
### Минусы CDC
Было сказано много чего хорошего, но какие минусы есть у CDC? В целом сводятся в основном к следующим ограничениям:
1. CDC тесты не заменяют E2E тесты. По факту я склонен отнести CDC к заглушкам, которые являются моделями реальных компонентов, но не являются ими, т.е. это еще одна абстракция, которую нужно поддерживать и применять в нужных местах (сложно реализовать сложные сценарии).
2. CDC тесты не заменяют функциональные тесты API. Лично придерживаюсь золотого правила – если убрать контракт и это не вызывает ошибки или неправильную работу клиента, то значит он не нужен. Пример: Нет необходимости проверять все коды ошибок через контракт, если клиент обрабатывает их (ошибки) одинаково. Таким образом контракт то, что важно для клиента сервиса, а не наоборот.
3. CDC тесты дороже в поддержке, чем функциональные тесты.
4. Для реализации CDC-тестов нужно использовать (изучать) отдельные инструменты тестирования – Spring Cloud Contract, PACT.
### Инструменты для CDC
~~Автор попробовал 2 тула Spring Cloud Contract и PACT. Protobuf можете изучить самостоятельно. Пришел к тому, что Spring Cloud Contract ему ближе~~ Ниже в данной статье будет рассмотрен инструмент **Spring Cloud Contract** и будет приведен небольшой пример реализации контрактного теста. Если коротко об инструментах:
[Spring Cloud Contract](https://spring.io/projects/spring-cloud-contract) - Spring Cloud Contract is an umbrella project holding solutions that help users in successfully implementing the Consumer Driven Contracts approach. Currently Spring Cloud Contract consists of the Spring Cloud Contract Verifier project.
[PACT](https://docs.pact.io/) - Pact is a code-first tool for testing HTTP and message integrations using contract tests. Contract tests assert that inter-application messages conform to a shared understanding that is documented in a contract. Without contract testing, the only way to ensure that applications will work correctly together is by using expensive and brittle integration tests.
Перейдем к практике и разберем стандартный пример использования контрактного тестирования с помощью Spring Cloud Contract.
Для начала нужно описать поставщика и потребителя услуг. Подготовьте **стандартный проект с Java 1.8, maven 3.6.3, JUnit 4.12.**
Проект будет иметь следующую структуру:
### Поставщик
Добавьте зависимости org.springframework.cloud:
```
org.springframework.cloud
spring-cloud-starter-contract-verifier
2.1.1.RELEASE
test
```
Добавьте plugin:
```
org.springframework.cloud
spring-cloud-contract-maven-plugin
2.1.1.RELEASE
true
com.baeldung.spring.cloud.springcloudcontractproducer.BaseTestClass
```
Сделаем RestController для поставщика с endpoint /validate/prime-number, на вход которого будем направлять число(“number”). На выходе мы получаем два значения – если на вход подается четное число вернется "Even", наоборот - "Odd". В коде это будет выглядеть следующим образом:
```
@RestController
public class EvenOddController {
@GetMapping("/validate/prime-number")
public String isNumberPrime(@RequestParam("number") Integer number) {
return number % 2 == 0 ? "Even" : "Odd";
}
}
```
Далее необходимо создать базовый класс для загрузки Spring context.
```
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@DirtiesContext
@AutoConfigureMessageVerifier
public class BaseTestClass {
@Autowired
private EvenOddController evenOddController;
@Before
public void setup() {
StandaloneMockMvcBuilder standaloneMockMvcBuilder = MockMvcBuilders.standaloneSetup(evenOddController);
RestAssuredMockMvc.standaloneSetup(standaloneMockMvcBuilder);
}
}
```
В */src/test/resources/contracts/* добавим два контракта заглушки с расширением .groovy:
Заглушка с проверкой четного числа
```
Contract.make {
description "should return even when number input is even"
request {
method GET()
url("/validate/prime-number") {
queryParameters {
parameter("number", "2")
}
}
}
response {
body("Even")
status 200
}
}
```
Заглушка с проверкой нечетного числа
```
Contract.make {
description "should return odd when number input is odd"
request {
method GET()
url("/validate/prime-number") {
queryParameters {
parameter("number", "1")
}
}
}
response {
body("Odd")
status 200
}
}
```
***Примечание:*** при выполнении команды в инструменте сборки mvn clean install выполняется генерация тестового класса на основе контракта с именем ContractVerifierTest, который наследует (расширяет) BaseTestClass в target. Методами сгенерированного класса являются контракты .groovy с приставкой validate\_[имя контракта].
Пример:
* public void validate\_shouldReturnEvenWhenRequestParamIsEven()
* public void validate\_shouldReturnOddWhenRequestParamIsOdd()
Результатом сборки также станет добавление заглушки в локальный репозиторий Maven, чтобы наши потребители могли ее использовать.
```
public class ContractVerifierTest extends BaseTestClass {
@Test
public void validate_shouldReturnEvenWhenRequestParamIsEven() throws Exception {
// given:
MockMvcRequestSpecification request = given();
// when:
ResponseOptions response = given().spec(request)
.queryParam("number","2")
.get("/validate/prime-number");
// then:
assertThat(response.statusCode()).isEqualTo(200);
// and:
String responseBody = response.getBody().asString();
assertThat(responseBody).isEqualTo("Even");
}
@Test
public void validate_shouldReturnOddWhenRequestParamIsOdd() throws Exception {
// given:
MockMvcRequestSpecification request = given();
// when:
ResponseOptions response = given().spec(request)
.queryParam("number","1")
.get("/validate/prime-number");
// then:
assertThat(response.statusCode()).isEqualTo(200);
// and:
String responseBody = response.getBody().asString();
assertThat(responseBody).isEqualTo("Odd");
}
}
```
### Потребитель:
Потребители контрактного тестирования поддерживают контракт через заглушки, сгенерированные через http-соединение, таким образом изменение в поставщике нарушит контракт и приведет к ошибке.
Добавим зависимости в pom файл потребителя (consumer):
```
org.springframework.cloud
spring-cloud-contract-wiremock
test
org.springframework.cloud
spring-cloud-contract-stub-runner
test
com.peterwanghao.spring.cloud
spring-cloud-contract-producer
0.0.1-SNAPSHOT
test
```
Создадим RestController BasicMathController, который выполняет GET запрос для получения ответа от сгенерированной заглушки.
```
@RestController
public class BasicMathController {
@Autowired
private RestTemplate restTemplate;
@GetMapping("/calculate")
public String checkOddAndEven(@RequestParam("number") Integer number) {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.add("Content-Type", "application/json");
ResponseEntity responseEntity = restTemplate.exchange(
"http://localhost:8090/validate/prime-number?number=" + number, HttpMethod.GET,
new HttpEntity<>(httpHeaders), String.class);
return responseEntity.getBody();
}
}
```
Теперь пришло время настроить наш stub Runner, который сообщит нашему потребителю имеющихся заглушек, который находятся в локальном репозитории Maven от поставщика.
```
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@AutoConfigureMockMvc
@AutoConfigureJsonTesters
@AutoConfigureStubRunner(workOffline = true, ids = "com.peterwanghao.spring.cloud:spring-cloud-contract-producer:+:stubs:8090")
public class BasicMathControllerIntegrationTest {
@Autowired
private MockMvc mockMvc;
@Test
public void given_WhenPassEvenNumberInQueryParam_ThenReturnEven() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/calculate?number=2").contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk()).andExpect(content().string("Even"));
}
@Test
public void given_WhenPassOddNumberInQueryParam_ThenReturnOdd() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/calculate?number=1").contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk()).andExpect(content().string("Odd"));
}
}
```
Для запуска тестов выполните команду mvn clean install и проверьте результат.
Пример из кода можно найти на [github](https://www.baeldung.com/spring-cloud-contract).
Другие примеры можно посмотреть:
1. [Одно из первых знакомств с Spring Cloud Contract-Introduction](https://russianblogs.com/article/5653907198/)
2. [Практика тестирования контрактов Spring Cloud Contract](https://russianblogs.com/article/5176837142/)
3. [Spring-Cloud-Contract реальный бой](https://russianblogs.com/article/9006463610/)
4. [Playing with Spring Cloud Contract](https://blog.arima.eu/en/2020/10/29/playing-with-spring-cloud-contract.html)
5. [Pact: best practices](https://docs.pact.io/best_practices/consumer/contract_tests_not_functional_tests)
6. [Martin Fowler: Contract Test](https://martinfowler.com/bliki/ContractTest.html)
7. [InfoQ: Creating Spring Cloud Contract Testing](https://www.infoq.com/articles/contract-testing-spring-cloud-contract)
8. [Pact with JS](https://devblog.xero.com/trust-but-verify-using-pact-for-contract-testing-495a1e303a6)
9. [Protocol Buffers](https://github.com/protocolbuffers/protobuf)
10. [Spring Cloud Contract](https://cloud.spring.io/spring-cloud-contract)
11. [Spring Cloud Contract Samples](https://github.com/spring-cloud-samples/spring-cloud-contract-samples) | https://habr.com/ru/post/570544/ | null | ru | null |
# Читаем бинарные файлы iOS-приложений
На хабре есть много статей о том, как работает рантайм Swift/Objective-C, но для еще более полного понимания того, что происходит под капотом, полезно залезть на самый низкий уровень и посмотреть, как код iOS приложений укладывается в бинарные файлы. Кроме того, безусловно, под капот приходится залезать при решении реверс-инжиниринговых задач. В этой статье мы обсудим самые простые конструкции Objective-C, а о Swift и более сложных примерах поговорим в последующих статьях.
В первых двух секциях я постарался максимально подробно осветить практические подробности, чтобы читателю, желающему пройти этот тьюториал, не нужно было каждые две минуты гуглить вещи в стиле "где найти бинарный файл приложения в Xcode". Дальше все максимально информативно.
[](https://habrahabr.ru/company/solarsecurity/blog/323346/)
Мы будем изучать файлы с 64-битной архитектурой arm64. Интересующие нас объекты в бинарном файле представляют собой записанные подряд 16-, 32- и 64-битные слова и null-terminated строки, так что мне будет удобно говорить о них на С. Например, я буду говорить, что описание метода в бинарном файле выглядит так:
```
struct objc_method { // по адресу описания метода подряд лежат:
uint64 name_addr; // адрес, по которому лежит null-terminated строка, имя переменной,
uint64 type; // адрес, по которому лежит null-terminated строка, сигнатура метода,
uint64 imp_addr; // адрес реализации метода
}
```
Кроме uint64 также встречаются 32-битные параметры uint32, 16-битные uint16, и для относительных указателей используются int64 и int32.
Macho-O и Hopper
================
Бинарные файлы iOS-приложений имеют формат Mach-O. Получить представление об этом формате можно [здесь](https://habrahabr.ru/post/115558) (глава “Кратко о Mach-O”). Один из удобных способов просматривать Mach-O-файлы — это дизассемблер Hopper. Скачать триальную версию можно [здесь](https://www.hopperapp.com/download.html).
Для навигации в хоппере удобно знать пару шорткатов:
Shift+S — список секций
G — перейти по адресу
На любой адрес, встретившийся в ассемблере, можно щелкнуть два раза и перейти по нему. Кроме того, хоппер парсит много названий разных сущностей, и по ним можно производить поиск (строка поиска слева ближе к верху).
Иногда бывает полезно посмотреть на нераспарсенный бинарный код. Для этого можно выбрать Hexadimal Mode на вот таком свиче вверху:
Подготовка в Xcode
==================
Будем писать изучаемое приложение сами. Создадим для этого в Xcode Single View Application на Objective-C. Для удобства можно оставить в Build Settings только архитектуру arm64. Мы будем билдить (cmd+B) под всегда доступное устройство Generic iOS Device:
В принципе, можно билдить и под настоящее устройство, но не стоит под симулятор, потому что бинарный файл получится сильно другой (другая архитектура). Итак, пусть наше приложение называется InspectedObjc. Для компактности не будем пользоваться .h-файлами и будем все писать в .m-файлах. Создаем файл InspectedObject.m и заводим в нем класс со всякими разнообразностями (код в следующей секции).
Не забываем добавить его к цели и билдим. Видим в папке Products готовое приложение:
Далее Show in Finder и Show Package Contents на InspectedObjc.app. Ок, теперь можно скормить бинарный файл InspecteObjc хопперу.
Лезем под капот
===============
Эта часть, в некоторой мере, является объяснением кода [отсюда](https://opensource.apple.com/source/objc4/objc4-437/runtime/objc-private.h). Итак, будем изучать, как выкладывается в бинарный файл класс InspectedObject из такого InspectedObject.m:
```
#import
@protocol InspectedProtocol
- (int)instanceMethod:(NSString \*)string;
+ (NSNumber \*)classMethod:(NSNumber \*)number;
@end
@interface InspectedObject : NSObject {
int intIvar;
NSString \_\_weak \*weakStringIvar;
NSNumber \*strongNumberIvar;
}
@property(nonatomic, strong) NSString \*strongStringProperty;
@property(weak) NSNumber \*weakNumberProperty;
- (int)instanceMethod:(NSString \*)string;
+ (NSNumber \*)classMethod:(NSNumber \*)number;
@end
@implementation InspectedObject
- (int)instanceMethod:(NSString \*)string {
return intIvar;
}
+ (NSNumber \*)classMethod:(NSNumber \*)number {
return @234;
}
@end
```
Смотрим в бинарный файл. Секция objc\_classlist — это список адресов классов:
```
struct objc_classlist {
uint64 classes[num_classes];
}
```
В нашем бинарном файле num\_classes = 3. Хоппер парсит имена, и поэтому видно, что наш класс — третий:
Остальные два сгенерировались при создании Single View Application. Идентифицировать нужный класс можно и без распарсенных имен, для этого нужно достать имена самостоятельно. Как это делать, понятно из дальнейшего.
Итак, переходим к \_OBJC*CLASS*$\_InspectedObject. В хоппере он выглядит так:
что соответствует следующей структуре:
```
struct objc_class {
uint64 metaclass_addr; // адрес метакласса; здесь хранятся class methods
uint64 superclass_addr; // адрес класса родителя, в нашем случае -- NSObject
uint64 cache_addr; // в бинарных файлах это адрес __objc_empty_cache, настоящий кэш селекторов заполняется в рантайме
uint64 vtable_addr; // в бинарных файлах это 0, заполняется в рантайме
uint64 raw_data_addr; // здесь лежит объект типа raw_data (см. ниже)
}
```
[Здесь](http://www.sealiesoftware.com/blog/archive/2011/06/17/objc_explain_objc_msgSend_vtable.html) можно посмотреть, какие примерно методы лежат в таблице виртуальных функций.
Будем называть переменные экземпляра класса калькой с английского — иварами (ivar). Данные класса:
```
struct raw_data {
uint32 flags; // некоторые флаги, используемые в рантайме
uint32 instance_start; // куда, относительно начала экземпляра класса, указывают указатели на экземпляр
uint32 instance_size; // размер объекта нашего класса
uint32 reserved; // пустое поле, что-то может записываться сюда в рантайме
uint64 strong_ivar_layout_addr; // раскладка strong иваров
uint64 name_addr; // адрес имени класса
uint64 method_list_addr; // список методов
uint64 protocol_list_addr; // список протоколов
uint64 ivar_list_addr; // список иваров
uint64 weak_ivar_layout_addr; // раскладка weak иваров
uint64 properties_list_addr; // список свойств
}
```
Списки методов, протоколов, иваров и свойств состоят каждый из 64-битного хедера и последовательности некоторых одинаковых структур.
Начнем со списка методов. Он начинается 64-битным хедером:
```
struct objc_list_header {
uint32 flags; // некоторые рантайм флаги
uint32 size; // размер списка
}
```
Дальше подряд идут следующего вида структуры:
```
struct objc_method {
uint64 name;
uint64 signature; // сигнатура метода
uint64 implementation; // адрес реализации метода
}
```
Сигнатура может выглядеть, например, вот так: i24@0:8@16. Цифры тут смысловой нагрузки [не несут](http://stackoverflow.com/questions/11527385/how-are-the-digits-in-objc-method-type-encoding-calculated/11527925#11527925), а остальное расшифровывается [следующим образом](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html):
i -> int — возвращаемое значение
@ -> Objective-C объект — 1й аргумент, self
: -> селектор — 2й аргумент
@ -> Objective-C объект — 3й аргумент (1й аргумент после “:”)
Точные типы объектов Objective-C по сигнатуре восстановить нельзя.
Заметим, что в этом списке будут методы, которые мы не определяли, а именно сеттеры и геттеры свойств и метод -[InspectedObject .cxx\_destruct], использующийся в ARC (и Objective-C++).
Хедер списка протоколов состоит просто из 64-битного размера списка. Далее идут 64-битные адреса протоколов, которым удовлетворяет класс. Протокол в памяти выглядит так:
```
struct objc_protocol {
uint64 isa_addr; // адрес класса Протокол, в бинарном файле не заполнен, равен 0
uint64 name_addr; // адрес имени
uint64 protocols_addr; // адрес списка протоколов, которым удовлетворяет протокол
uint64 instance_methods_addr;
uint64 class_methods_addr;
uint64 optional_instance_methods_addr;
uint64 optional_class_methods_addr;
uint64 instance_properties_addr;
}
```
Неоткомментированные поля соответствуют спискам, устроенным аналогично спискам в raw\_data класса.
Все ивары записаны в objc\_ivar\_list, начинающийся хедером типа objc\_list\_header, и выглядят следующим образом:
```
struct objc_ivar {
uint64 offset_addr; // адрес, по которому лежит отступ ивара
uint64 name_addr; // адрес имени
uint64 type_addr; // адрес строки с типом
uint32 alignment; // минимальная память в байтах, кратная 8, в которую помещается переменная
uint32 size; // размер переменной
}
```
Стоит отметить, что в этом списке будут также синтезированные переменные (в нашем случае — NSString *\_strongStringProperty и NSNumber* \_weakNumberProperty). С помощью полей "раскладок" сильных и слабых переменных из raw\_data можно понять, на какие из членов класса объект хранит сильные ссылки и на какие — слабые. Остальные переменные будут присваиваться по значению. Раскладка — это последовательность чисел от 1 до 15, заканчивающаяся нулевым байтом. Каждое второе число — это количество последовательных (в objc\_ivar\_list) переменных одного типа и каждое второе другое число — это промежутки между блоками последовательных переменных одного типа. В нашем случае переменные идут в порядке assign-weak-strong-strong-weak. Сначала идут 2 не-strong переменные, а потом — 2 strong. Поэтому раскладка сильных переменных — 0x22. Раскладка слабых переменных — 0x1121. Хоппер парсит раскладки как строки, и поэтому показывает, например, во втором случае "\x11!". Чтобы увидеть исходную последовательность байтов, можно перейти в Hexadimal Mode.
Список свойств начинается хедером типа objc\_list\_header и состоит из таких структур:
```
struct objc_property {
uint64 name_addr; // адрес имени
uint64 attributes_addr; // адрес строки атрибутов
}
```
Опишем [устройство строки атрибутов](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtPropertyIntrospection.html). Строка начинается с “T”, за которым следует тип свойства, затем через запятую идут свойства:
R — readonly
C — copy
& — retain (strong, если используется ARC)
N — nonatomic
G — кастомный геттер
S — кастомный сеттер
D — dynamic
W — weak
P — свойство подходит для автоматической сборки мусора
t — типа в старой кодировке
Заканчивается строка атрибутов именем ивара свойства с префиксом V. Для нашего свойства
```
@property(nonatomic, strong) NSString *strongStringProperty;
```
получается строка атрибутов "T@\"NSString\",&,N,V\_strongStringProperty".
Заметим, что в списке свойств, как и в списке методов, есть некоторые, сгенерированные автоматически:
```
@property(readonly) NSUInteger hash;
@property(readonly, copy) NSString *description;
@property(readonly, copy) NSString *debug_description;
@property(readonly) id superclass; // здесь, вообще говоря, непонятный "T#"
```
Стоит заметить, что ивары для этих свойств не синтезируются.
Для полной картины осталось сказать еще о методах класса (class methods). Это обычные методы, но экземпляр в них — класс и, следовательно, хранятся они в классе класса, то есть в метаклассе. У метакласса так же есть raw\_data и список методов. Собирая все вместе, получаем следующий восстановленный интерфейс класса:
```
@interface InspectedObject : NSObject {
int intIvar;
NSString \_\_weak \*weakStringIvar;
NSNumber \*strongNumberIvar;
NSString \*\_strongStringProperty;
NSNumber \_\_weak \*\_weakNumberProperty;
}
@property(nonatomic, strong) NSString \*strongStringProperty;
@property(weak) NSNumber \*weakNumberProperty;
@property(readonly) NSUInteger hash;
@property(readonly, copy) NSString \*description;
@property(readonly, copy) NSString \*debug\_description;
@property(readonly) id superclass;
- (int)instanceMethod:(id)arg;
- (void).cxx\_destruct;
- (id)strongStringProperty;
- (id)setStrongStringProperty:(id)arg;
- (id)weakNumberProperty;
- (id)setWeakNumberProperty:(id)arg;
+ (id)classMethod:(id)arg;
@end
```
Убирая автоматически сгенерированное, получаем:
```
@interface InspectedObject : NSObject {
int intIvar;
NSString \_\_weak \*weakStringIvar;
NSNumber \*strongNumberIvar;
}
@property(nonatomic, strong) NSString \*strongStringProperty;
@property(weak) NSNumber \*weakNumberProperty;
- (int)instanceMethod:(id)arg;
+ (id)classMethod:(id)arg;
@end
```
Итого, не считая потери информации о точных типах Objective-C объектов в аргументах, интерфейс восстанавливается полностью.
В заключение хочу сделать небольшой анонс: если вам интересно проверить свой код с помощью автоматического анализатора, сейчас как раз тот момент, когда это можно сделать абсолютно бесплатно. Вот [тут](http://promo.softline.ru/solar-incode) можно прочитать про Solar inCode и получить триальный доступ на одно бесплатное сканирование. | https://habr.com/ru/post/323346/ | null | ru | null |
# Анализ коммитов и pull request'ов в Travis CI, Buddy и AppVeyor с помощью PVS-Studio
В анализаторе PVS-Studio для языков С и C++ на Linux и macOS, начиная с версии 7.04, появилась тестовая возможность проверить список указанных файлов. С помощью нового режима можно настроить анализатор для проверки коммитов и pull request'ов. В этой статье будет рассказано, как настроить проверку списка изменённых файлов GitHub-проекта в таких популярных CI (Continuous Integration) системах, как Travis CI, Buddy и AppVeyor.
Режим проверки списка файлов
----------------------------
[PVS-Studio](https://www.viva64.com/ru/pvs-studio/) — это инструмент для выявления ошибок и потенциальных уязвимостей в исходном коде программ, написанных на языках С, C++, C# и Java. Работает в 64-битных системах на Windows, Linux и macOS.
В версии PVS-Studio 7.04 для Linux и macOS появился режим проверки списка исходных файлов. Работает это для проектов, сборочная система которых позволяет сгенерировать файл [compile\_commands.json](https://clang.llvm.org/docs/JSONCompilationDatabase.html). Он нужен для того, чтобы анализатор извлёк информацию о компиляции указанных файлов. Если ваша сборочная система не поддерживает генерацию файла compile\_commands.json, вы можете попробовать сгенерировать такой файл с помощью утилиты [Bear](https://github.com/rizsotto/Bear).
Также режим проверки списка файлов можно использовать вместе с логом трассировки strace запусков компилятора (pvs-studio-analyzer trace). Для этого вам нужно будет сначала провести полную сборку проекта и отследить её, чтобы анализатор собрал полную информацию о параметрах компиляции всех проверяемых фалов.
Однако у такого варианта есть существенный недостаток — нужно будет либо производить полную трассировку сборки всего проекта при каждом запуске, что само по себе противоречит идее быстрой проверки коммита. Либо, если закешировать сам результат трассировки, последующие запуски анализатора могут оказаться неполными, если после трассировки поменяется структура зависимостей исходных файлов (например, в один из исходных файлов будет добавлен новый #include).
Поэтому мы не рекомендуем использовать режим проверки списка файлов с логом трассировки для проверки коммитов или pull request'ов. В случае, если вы можете делать при проверке коммита инкрементальную сборку, рассмотрите возможность использовать режим [инкрементального анализа](https://www.viva64.com/ru/m/0036/#ID0EWJAI).
Список исходных файлов для анализа сохраняется в текстовой файл и передаётся анализатору с помощью параметра *-S*:
```
pvs-studio-analyzer analyze ... -f build/compile_commands.json -S check-list.txt
```
В этом файле указываются относительные или абсолютные пути к файлам, причем каждый новый файл должен быть на новой строке. Допустимо указывать не только имена файлов для анализа, но и различный текст. Анализатор увидит, что это не файл, и проигнорирует строку. Это может быть полезно для комментирования, если файлы указываются вручную. Однако зачастую список файлов будет сгенерирован во время анализа в CI, например, это могут быть файлы из коммита или pull request'а.
Теперь с помощью этого режима можно быстро проверять новый код до попадания его в основную ветку разработки. Чтобы система проверки реагировала на наличие предупреждений анализатора, в утилиту *plog-converter* добавлен флаг *--indicate-warnings*:
```
plog-converter ... --indicate-warnings ... -o /path/to/report.tasks ...
```
С этим флагом конвертер вернёт ненулевой код, если в отчёте анализатора присутствуют предупреждения. По коду возврата можно заблокировать прекоммит хук, коммит или pull request, а сгенерированный отчёт анализатора вывести на экран, расшарить или отправить по почте.
*Примечание. При первом запуске анализа списка файлов будет проанализирован весь проект, т.к. анализатору необходимо сгенерировать файл зависимостей исходных файлов проекта от заголовочных файлов. Это особенность анализа C и C++ файлов. В дальнейшем файл зависимостей можно закешировать и он будет обновляться анализатором автоматически. Преимущество проверки коммитов при использовании режима проверки списка файлов перед использованием режима инкрементального анализа заключается в том, что нужно кешировать только этот файл, а не объектные файлы.*
Общие принципы анализа pull request'а
-------------------------------------
Анализ всего проекта занимает достаточно много времени, поэтому есть смысл в том, чтобы проверять только некоторую его часть. Проблема в том, что нужно отделить новые файлы от остальных файлов проекта.
Рассмотрим пример дерева коммитов с двумя ветками:
Давайте представим, что коммит *A1* содержит достаточно большое количество кода, который уже проверили. Немного ранее мы сделали ветку от коммита *A1* и изменяли какие-то файлы.
Вы, конечно, заметили, что после *A1* произошло ещё два коммита, но это были также слияния других веток, ведь мы же не коммитим в *master*. И вот настало время, когда *hotfix* готов. Поэтому появился pull request на слияние *B3* и *A3*.
Само собой, можно было бы проверить весь результат их слияния, но это было бы слишком долго и неоправданно, так как было изменено лишь несколько файлов. Поэтому эффективнее проанализировать только измененные.
Для этого получим разницу между ветками, находясь в HEAD ветки, из которой хотим слить в master:
```
git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list
```
*$MERGE\_BASE* мы будем подробно рассматривать позже. Дело в том, что далеко не каждый CI сервис дает необходимую информацию про базу для слияния, поэтому каждый раз приходится придумывать новые способы получения этих данных. Это будет подробно расписано ниже в каждом из описанных веб-сервисов.
Итак, мы получили разницу между ветками, а точнее — список имен файлов, которые были изменены. Теперь нам нужно отдать файл *.pvs-pr.list* (мы в него перенаправили вывод выше) анализатору:
```
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
-S .pvs-pr.list
```
После анализа нам нужно конвертировать файл логов (PVS-Studio.log) в удобный для восприятия формат:
```
plog-converter -t errorfile PVS-Studio.log --cerr -w
```
Эта команда выведет список ошибок в [stderr](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D1%8B%D0%B5_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B8#%D0%A1%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D1%8B%D0%B9_%D0%B2%D1%8B%D0%B2%D0%BE%D0%B4_%D0%BE%D1%88%D0%B8%D0%B1%D0%BE%D0%BA) (стандартный поток вывода сообщений об ошибках).
Только вот нам нужно не только вывести ошибки, но и сообщить нашему сервису для сборки и тестирования о наличии проблем. Для этого в конвертер был добавлен флаг *-W* (*--indicate-warnings*). При наличии хоть одного предупреждения анализатора, код возврата утилиты *plog-converter* изменится на 2, что, в свою очередь, сообщит CI сервису о наличии потенциальных ошибок в файлах pull request'а.
Travis CI
---------
Конфигурация выполнена в виде файла *.travis.yml*. Для удобства советую вынести всё в отдельный bash-скрипт с функциями, которые будут вызваны из файла *.travis.yml* (*bash имя\_скрипта.sh имя\_функции*).
Будем добавлять необходимый код в скрипт на *bash*, таким образом мы получим больший функционал. В секции *install* напишем следующее:
```
install:
- bash .travis.sh travis_install
```
Если у вас были какие-либо инструкции, то можете перенести их в скрипт, убрав дефисы.
Откроем файл *.travis.sh* и добавим установку анализатора в функцию *travis\_install()*:
```
travis_install() {
wget -q -O - https://files.viva64.com/etc/pubkey.txt \
| sudo apt-key add -
sudo wget -O /etc/apt/sources.list.d/viva64.list \
https://files.viva64.com/etc/viva64.list
sudo apt-get update -qq
sudo apt-get install -qq pvs-studio
}
```
Теперь добавим в секцию *script* запуск анализа:
```
script:
- bash .travis.sh travis_script
```
И в bash-скрипте:
```
travis_script() {
pvs-studio-analyzer credentials $PVS_USERNAME $PVS_KEY
if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
git diff --name-only origin/HEAD > .pvs-pr.list
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
-S .pvs-pr.list \
--disableLicenseExpirationCheck
else
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
--disableLicenseExpirationCheck
fi
plog-converter -t errorfile PVS-Studio.log --cerr -w
}
```
Этот код нужно запустить после сборки проекта, например, если у вас была сборка на CMake:
```
travis_script() {
CMAKE_ARGS="-DCMAKE_EXPORT_COMPILE_COMMANDS=On ${CMAKE_ARGS}"
cmake $CMAKE_ARGS CMakeLists.txt
make -j8
}
```
Получится так:
```
travis_script() {
CMAKE_ARGS="-DCMAKE_EXPORT_COMPILE_COMMANDS=On ${CMAKE_ARGS}"
cmake $CMAKE_ARGS CMakeLists.txt
make -j8
pvs-studio-analyzer credentials $PVS_USERNAME $PVS_KEY
if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
git diff --name-only origin/HEAD > .pvs-pr.list
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
-S .pvs-pr.list \
--disableLicenseExpirationCheck
else
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
--disableLicenseExpirationCheck
fi
plog-converter -t errorfile PVS-Studio.log --cerr -w
}
```
Наверное, вы уже обратили внимание на указанные переменные окружения *$TRAVIS\_PULL\_REQUEST* и *$TRAVIS\_BRANCH*. Travis CI объявляет их самостоятельно:
* *$TRAVIS\_PULL\_REQUEST* хранит номер pull request'а или *false*, если это обычная ветка;
* *$TRAVIS\_REPO\_SLUG* хранит имя репозитория проекта.
Алгоритм работы этой функции:
Travis CI реагирует на коды возврата, поэтому наличие предупреждений укажет сервису пометить коммит как содержащий ошибки.
А теперь рассмотрим подробнее эту строку кода:
```
git diff --name-only origin/HEAD > .pvs-pr.list
```
Дело в том, что Travis CI автоматически делает слияние веток во время анализа pull request:
Поэтому мы анализируем *A4*, а не *B3->A3*. Из-за этой особенности нам нужно высчитывать разницу с *А3*, которая как раз и является вершиной ветки из *origin*.
Осталась одна важная деталь — кеширование зависимостей заголовочных файлов от компилируемых единиц трансляции (\*.c, \*.cc, \*.cpp и т.д.). Эти зависимости анализатор вычисляет при первом запуске в режиме проверки списка файлов и сохраняет затем в директории .PVS-Studio. Travis CI позволяет кешировать папки, поэтому мы сохраним данные директории *.PVS-Studio/*:
```
cache:
directories:
- .PVS-Studio/
```
Этот код нужно добавить в файл *.travis.yml*. Эта директория хранит различные данные, собранные после анализа, которые существенно ускорят последующие запуски анализа списка файлов или инкрементального анализа. Если этого не сделать, то анализатор фактически каждый раз будет анализировать все файлы.
Buddy
-----
Как и Travis CI, [Buddy](https://buddy.works/) предоставляет возможность автоматизированной сборки и тестирования проектов, которые хранятся на GitHub. В отличие от Travis CI, он настраивается в веб интерфейсе (поддержка bash имеется), поэтому нет необходимости хранить файлы конфигурации в проекте.
В первую очередь нам необходимо добавить новое действие в линию сборки:
Укажем компилятор, который использовался для сборки проекта. Обратите внимание на docker контейнер, который установлен в этом действии. Например, для GCC есть специальный контейнер:
Теперь установим PVS-Studio и необходимые утилиты:
Добавим в редактор следующие строки:
```
apt-get update && apt-get -y install wget gnupg jq
wget -q -O - https://files.viva64.com/etc/pubkey.txt | apt-key add -
wget -O /etc/apt/sources.list.d/viva64.list \
https://files.viva64.com/etc/viva64.list
apt-get update && apt-get -y install pvs-studio
```
Теперь перейдем на вкладку Run (первая иконка) и в соответствующее поле редактора добавим следующий код:
```
pvs-studio-analyzer credentials $PVS_USERNAME $PVS_KEY
if [ "$BUDDY_EXECUTION_PULL_REQUEST_NO" != '' ]; then
PULL_REQUEST_ID="pulls/$BUDDY_EXECUTION_PULL_REQUEST_NO"
MERGE_BASE=`wget -qO - \
https://api.github.com/repos/${BUDDY_REPO_SLUG}/${PULL_REQUEST_ID} \
| jq -r ".base.ref"`
git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
--disableLicenseExpirationCheck \
-S .pvs-pr.list
else
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
--disableLicenseExpirationCheck
fi
plog-converter -t errorfile PVS-Studio.log --cerr -w
```
Если вы читали раздел, посвященный Travs-CI, то этот код уже вам знаком, однако, теперь появился новый этап:
Дело в том, что теперь мы анализируем не результат слияния, а HEAD ветки, из которой делается pull request:
Поэтому мы находимся в условном коммите *B3* и нам нужно получить разницу с *A3*:
```
PULL_REQUEST_ID="pulls/$BUDDY_EXECUTION_PULL_REQUEST_NO"
MERGE_BASE=`wget -qO - \
https://api.github.com/repos/${BUDDY_REPO_SLUG}/${PULL_REQUEST_ID} \
| jq -r ".base.ref"`
git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list
```
Для определения *A3* воспользуемся API GitHub:
```
https://api.github.com/repos/${USERNAME}/${REPO}/pulls/${PULL_REQUEST_ID}
```
Мы использовали следующие переменные, которые предоставляет Buddy:
* *$BUDDY\_EXECUTION\_PULL\_REQEUST\_NO* — номер pull request'а;
* *$BUDDY\_REPO\_SLUG* — сочетание имени пользователя и репозитория (например max/test).
Теперь сохраним изменения, воспользовавшись кнопкой внизу, и включим анализ pull request:
В отличии от Travis CI, нам нет необходимости указывать *.pvs-studio* для кеширования, так как Buddy автоматически кеширует все файлы для последующих запусков. Поэтому осталось последнее — сохранить логин и пароль для PVS-Studio в Buddy. После сохранения изменений мы попадем обратно в Pipeline. Нам нужно перейти к настройке переменных и добавить логин и ключ для PVS-Studio:
После этого появление нового pull request'а или коммита будет запускать проверку. Если коммит содержит ошибки, то Buddy укажет на это на странице pull request'а.
AppVeyor
--------
Настройка AppVeyor похожа на Buddy, так как всё происходит в web интерфейсе и нет нужды добавлять файл \*.yml в репозиторий проекта.
Перейдем на вкладку Settings в обзоре проекта:
Прокрутим эту страницу вниз и включим сохранение кеша для сборки pull request'ов:
Теперь перейдем на вкладку Environment, где укажем образ для сборки и необходимые переменные окружения:
Если вы прочитали предыдущие разделы, ты вы хорошо знакомы с этими двумя переменными — *PVS\_KEY* и *PVS\_USERNAME*. Если же нет, то напомню, что они необходимы для проверки лицензии анализатора PVS-Studio. В дальнейшем мы встретим их вновь в Bash скриптах.
На этой же странице внизу укажем папку для кеширования:
Если мы этого не сделаем, то будем анализировать вместо пары файлов весь проект, но вывод получим по указанным файлам. Поэтому важно ввести правильное название директории.
Теперь настало время скрипта для проверки. Откроем вкладку Tests и выберем Script:
В эту форму нужно вставить следующий код:
```
sudo apt-get update && sudo apt-get -y install jq
wget -q -O - https://files.viva64.com/etc/pubkey.txt \
| sudo apt-key add -
sudo wget -O /etc/apt/sources.list.d/viva64.list \
https://files.viva64.com/etc/viva64.list
sudo apt-get update && sudo apt-get -y install pvs-studio
pvs-studio-analyzer credentials $PVS_USERNAME $PVS_KEY
PWD=$(pwd -L)
if [ "$APPVEYOR_PULL_REQUEST_NUMBER" != '' ]; then
PULL_REQUEST_ID="pulls/$APPVEYOR_PULL_REQUEST_NUMBER"
MERGE_BASE=`wget -qO - \
https://api.github.com/repos/${APPVEYOR_REPO_NAME}/${PULL_REQUEST_ID} \
| jq -r ".base.ref"`
git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
--disableLicenseExpirationCheck \
--dump-files --dump-log pvs-dump.log \
-S .pvs-pr.list
else
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
--disableLicenseExpirationCheck
fi
plog-converter -t errorfile PVS-Studio.log --cerr -w
```
Обратим внимание на следующую часть кода:
```
PWD=$(pwd -L)
if [ "$APPVEYOR_PULL_REQUEST_NUMBER" != '' ]; then
PULL_REQUEST_ID="pulls/$APPVEYOR_PULL_REQUEST_NUMBER"
MERGE_BASE=`wget -qO - \
https://api.github.com/repos/${APPVEYOR_REPO_NAME}/${PULL_REQUEST_ID} \
| jq -r ".base.ref"`
git diff --name-only HEAD origin/$MERGE_BASE > .pvs-pr.list
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
--disableLicenseExpirationCheck \
--dump-files --dump-log pvs-dump.log \
-S .pvs-pr.list
else
pvs-studio-analyzer analyze -j8 \
-o PVS-Studio.log \
--disableLicenseExpirationCheck
fi
```
Достаточно специфичное присваивание значения команды pwd переменной, которая должна хранить это значение по умолчанию, кажется странным на первый взгляд, однако, я сейчас всё объясню.
Во время настройки анализатора в AppVeyor я столкнулся с крайне странным поведением анализатора. С одной стороны, всё работало верно, но анализ не запускался. Я потратил немало времени, чтобы заметить, что мы находимся в директории /home/appveyor/projects/testcalc/, а анализатор уверен в том, что мы находимся в /opt/appveyor/build-agent/. Тогда я понял, что переменная $PWD немного врёт. По этой причине вручную обновил её значение перед запуском анализа.
А дальше всё, как и раньше:
Теперь рассмотрим следующий фрагмент:
```
PULL_REQUEST_ID="pulls/$APPVEYOR_PULL_REQUEST_NUMBER"
MERGE_BASE=`wget -qO - \
https://api.github.com/repos/${APPVEYOR_REPO_NAME}/${PULL_REQUEST_ID} \
| jq -r ".base.ref"`
```
В нём мы получаем разницу между ветками, над которыми объявлен pull request. Для этого нам нужны следующие переменные окружения:
* $APPVEYOR\_PULL\_REQUEST\_NUMBER — номер pull request;
* $APPVEYOR\_REPO\_NAME — имя пользователя и репозиторий проекта.
Заключение
----------
Конечно, мы не рассмотрели все из возможных сервисов непрерывной интеграции, однако, все они имеют крайне схожую друг с другом специфику работы. За исключением кеширования, каждый сервис делает свой «велосипед», поэтому всегда всё по-разному.
Где-то, как в Travis-CI, пара строк кода и кеширование работает безупречно; где-то, как в AppVeyor, нужно просто указать папку в настройках; но где-то нужно создавать уникальные ключи и пытаться убедить систему дать тебе возможность перезаписать закешированный фрагмент. Поэтому, если вы хотите настроить анализ pull request'ов на сервисе непрерывной интеграции, который не был рассмотрен выше, то сперва убедитесь, что с кешированием у вас не возникнет проблем.
Спасибо за внимание. Если что-то не получается, то смело пишите нам в [поддержку](https://www.viva64.com/ru/about-feedback/). Мы подскажем и поможем.
[](https://habr.com/en/company/pvs-studio/blog/470982/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Maxim Zvyagintsev. [Analysis of commits and pull requests in Travis CI, Buddy and AppVeyor using PVS-Studio](https://habr.com/en/company/pvs-studio/blog/470982/). | https://habr.com/ru/post/470984/ | null | ru | null |
# Как я изучаю фреймворк Spring — часть 2 (помощь начинающим — дело рук самих начинающих)
Добрый день!
Я вдохновился приглашением продолжить [публикацию,](https://habr.com/post/420901) поэтому продолжаю.
В этот раз мы рассмотрим основные варианты внедрения зависимости — через конструктор и через сеттеры. Все исходники искать [здесь](https://github.com/KevinSmish/JavaSpring)
### Урок 06. Внедрение через конструктор.
Снова возьмем за основу проект из урока 2.
Добавим еще одного поэта. *src\main\java\spring\impls\Severyanin.java*
```
package spring.impls;
import spring.intarfaces.Lyricist;
public class Severyanin implements Lyricist {
@Override
public String Generate() {
return "Это было у моря, где ажурная пена,\r\n" + "Где встречается редко городской экипаж…\r\n"
+ "Королева играла — в башне замка — Шопена,\r\n" + "И, внимая Шопену, полюбил её паж. ";
}
}
```
Зарегистрируем класс в конфигурационном файле *src\main\resources\ApplicationContext.xml*
```
xml version="1.0" encoding="UTF-8"?
```
В начале двадцатого века были очень популярны литературные дуэли.
Устроим литературную дуэль между двумя поэтами. Для этого создадим сцену *src\main\java\spring\impls\ Stage.java*
```
package spring.impls;
import spring.intarfaces.Lyricist;
public class Stage {
private Lyricist lyr1;
private Lyricist lyr2;
public Stage(Lyricist lyr1, Lyricist lyr2) {
this.lyr1 = lyr1;
this.lyr2 = lyr2;
}
public void Act() {
System.out.println("Первый поэт:");
System.out.println(lyr1.Generate());
System.out.println();
System.out.println("Второй поэт:");
System.out.println(lyr2.Generate());
System.out.println();
System.out.print("В литературной дуэли победил ");
if (Math.random() < 0.1) {
System.out.println("Первый поэт.");
} else {
System.out.println("Второй поэт.");
}
}
}
```
В принципе, можно изменить *src\main\java\spring\main\ Start.java* – и все заработает:
```
package spring.main;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring.impls.Stage;
import spring.intarfaces.Lyricist;
public class Start {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
Lyricist lyr1 = context.getBean("LyricistBean2", Lyricist.class);
Lyricist lyr2 = context.getBean("LyricistBean3", Lyricist.class);
Stage myStage = new Stage(lyr1, lyr2);
myStage.Act();
((ConfigurableApplicationContext) context).close();// закрытие контекста
}
}
```
Запускаем – все работает. Поэты выдали по одному шедевру, второй, скорее всего, победил. Так и должно быть, 27 февраля 1918 года в Политехническом музее на Избрании короля поэтов Северянин победил Маяковского. Но мы дали Владимиру Владимировичу небольшой шанс. Может быть, в вашей версии победил он.
Теперь вынесем все настройки в конфигурационный файл *src\main\resources\ApplicationContext.xml*, негоже явно в стартовом файле конфигурировать бины.
```
xml version="1.0" encoding="UTF-8"?
```
Обычно бины создаются с конструктором по умолчанию без аргументов. Но в нашем случае он не подойдет. Передадим в качестве аргументов ссылки на другие создаваемые бины Маяковского и Северянина.
Осталось убрать все лишнее из класса *src\main\java\spring\main\ Start.java*
```
package spring.main;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring.impls.Stage;
public class Start {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
Stage myStage = context.getBean("StageBean", Stage.class);
myStage.Act();
((ConfigurableApplicationContext) context).close();// закрытие контекста
}
}
```
Запускаем. Все работает. Бины создаются. Северянин вновь победил.
Во всяком случае, в моей реальности.
Теперь посмотрим, каким образом можно сконфигурировать сеттеры.
### Урок 07. Внедрение через сеттеры.
Продолжим терзать предыдущий проект.
Наверное, неправильно при создании сцены создавать и поэтов.
Исправим эту оплошность и немного изменим класс сцены. Удалим конструктор и добавим сеттеры для lyr1 и lyr2 из *src\main\java\spring\impls\ Stage.java*
```
package spring.impls;
import spring.intarfaces.Lyricist;
public class Stage {
private Lyricist lyr1;
private Lyricist lyr2;
public void setLyr1(Lyricist lyr1) {
this.lyr1 = lyr1;
}
public void setLyr2(Lyricist lyr2) {
this.lyr2 = lyr2;
}
public void Act() {
System.out.println("Первый поэт:");
System.out.println(lyr1.Generate());
System.out.println();
System.out.println("Второй поэт:");
System.out.println(lyr2.Generate());
System.out.println();
System.out.print("В литературной дуэли победил ");
if (Math.random() < 0.1) {
System.out.println("Первый поэт.");
} else {
System.out.println("Второй поэт.");
}
}
}
```
Изменим конфигурационный файл *src\main\resources\ApplicationContext.xml*. Уберем аргументы конструктора и добавим значения сеттеров.
```
xml version="1.0" encoding="UTF-8"?
```
Класс старт в данном случае можно не трогать. Запускаем. Все работает. Отметим, что для сцены не запускается конструктор с двумя параметрами, зато после создания сцены устанавливаются два сеттера.
Продолжение следует… | https://habr.com/ru/post/421093/ | null | ru | null |
# Проверка
`Красный?` | https://habr.com/ru/post/10780/ | null | ru | null |
# Отправка SMS с 3G/GSM модема
Привет Хабр. В данной статье я бы хотел поделиться опытом работы с GSM модемом, а точнее опытом отправки SMS сообщений. Ниже будет описана реализация программы на Delphi для отправки SMS сообщений, а так же чтение и удаление входящих/исходящих сообщений с модема. В моём случае это был модем HUAWEI от MTS. Всех кого заинтересовал, прошу под кат.
#### **Рождение идеи**
Всё началось с того, что в одной небольшой сети магазинов возникла необходимость ежедневно информировать начальство о выручке по каждому магазину за день. В центральном офисе скапливается информация о продажах, её то и нужно донести до начальника. Ген.дир. (заказчик) — человек очень занятой, и как директору ему необходимо своевременно получать данные о выручке магазинов, интернет порой недоступен, а мобильник всегда под рукой, вот и было решено отправлять ему на телефон SMS с данными о выручке по каждому магазину, в простом и читабельном виде.
##### Пример SMS:
`08.11.2011
1.Магазин A, 123045 р.
2.Магазин B, 134520 р.
3.Магазин C, 215403 р.
...`;
Как выяснилось в последующем это ещё не всё что требуется, но об этом чуть позже.
Сначала было предложено отправлять SMS через гейт, коих сейчас великое множество. Но заказчик сразу же отверг это предложение из соображений безопасности, ибо данные о дневной выручке — вещь довольно конфиденциальная. Затем было решено отправлять SMS просто с телефона подключенного к компу по USB кабелю, а в итоге и вовсе вместо телефона был задействован USB модем который уже давненько валялся без дела.
#### **С чего начать**
С COM портом конечно работать приходилось, а вот общаться с модемом по средствам AT команд, до этого как то не доводилось. AT команд конечно довольно много, но всё оказалось гораздо проще чем я ожидал, т.к. для нашей цели потребовались всего 5 команд:
AT+CMGF — задаёт режим работы: 0-цифровой или 1-текстовый. Эта команда будет вызываться первой, от этого зависит формат последующих команд и ответов модема.
AT+CMGS — отправка сообщения, формат параметра сильно зависти от режима (т.е. от прошлой команды).
AT+CMGL — чтение сообщений с модема, в качестве параметра можно передать одно из пяти значений, стоит обратить внимание что в зависимости от режима (AT+CMGF) следует передавать цифровые или строковые значения:
AT+CMGD — удаление одного сообщения с модема, в качестве параметра передаём номер сообщения.
AT+CMGR — чтение одного сообщения с модема, так же передаём номер сообщения.
#### **Первые результаты**
После нескольких часов (проб/ошибок) выяснил, что отправить SMS сообщение с модема ненамного сложнее чем сделать это с обычного мобильного телефона. Как уже упоминалось выше, для отправки SMS следует использовать команду «AT+CMGS». И так, открыл hyperterm, подключился к модему (через COM порт), и настрочил в порт следующие команды:
```
AT+CMGF=1 [Enter]
AT+CMGS=+79261234567 [Enter]
hello habr, this is test message [Ctrl+Z]
```
##### Пример того же самого на Delphi:
```
procedure SendSMS(AComPort: integer; AMsg: String; ANumTel: String);
var
hFile: THandle;
procedure WriteStr(AStr: String); //пишет в порт переданную строку
var
LWrited: Cardinal;
begin
//Пишем в порт
WriteFile(hFile, PAnsiChar(AStr)^, Length(AStr), LWrited, nil);
end;
begin
//открываем порт
hFile := Windows.CreateFile(PChar('\\.\COM' + IntToStr(AComPort)), GENERIC_READ or GENERIC_WRITE, 0, nil, OPEN_EXISTING, 0, 0);
//если открылся
if (hFile <> INVALID_HANDLE_VALUE) then
begin
try
//устанавливаем текстовый режим
WriteStr('AT+CMGF=1' + #$D#$A);
//вводим номер в формате "+79xxxxxxxxx"
WriteStr('AT+CMGS="'+ANumTel+'"' + #$D#$A);
//вводим текст сообщения, только латиница
WriteStr(AMsg + #$D#$A#$1A);
finally
//закрываем порт
Windows.CloseHandle(hFile);
end;
end;
end;
```
Вуаля, и карманный девайс сообщил о ожидаемом событии.
Но увы положительные эмоции возникшие у меня в момент этого успеха продлились недолго, а если точнее до того момента когда было обнаружено что с русским текстом всё гораздо сложнее. Во первых для отправки сообщений на русском нужно переключить режим с текстового на цифровой (AT+CMGF=0), а во вторых само сообщение должно быть отправлено в кодировке UCS2. И если с первым проблем минимум, то со вторым пришлось повозиться.
##### Кодировка текста в UCS и обратно (опять таки на Delphi):
```
function UCSToAnsi(AStr: AnsiString): AnsiString;
function Convert(ACnvStr: AnsiString): AnsiChar;
var
j: integer;
begin
j := StrToIntDef('$'+ACnvStr, 0);
case j of
1040..1103: j := j - 848;
1105: j := 184;
end;
Result := Chr(j);
end;
var
c, i: integer;
begin
Result := '';
c := Length(AStr) div 4;
for i := 0 to c - 1 do
Result := Result + Convert(Copy(AStr, i*4+1, 4)); end;
function AnsiToUCS(AStr: AnsiString): AnsiString;
function Convert(AChar: AnsiChar): AnsiString;
var
j: integer;
begin
Result := '';
j := ord(AChar);
case j of
192..255: j := j + 848;
184: j := 1105;
end;
Result := IntToHex(j, 4)
end;
var
c, i: integer;
begin
Result := '';
c := Length(AStr);
for i := 1 to c do
Result := Result + Convert(AStr[i]);
end;
```
Не скажу что всё получилось сразу и легко, но всё же получилось. Если раньше я отправлял в модем:
```
AT+CMGF=1 [Enter]
AT+CMGS=+79261234567 [Enter]
hello habr, this is test message [Ctrl+Z]
```
то для того чтобы отправить сообщение на русском нужно будет отправить:
```
AT+CMGF=0 [Enter]
AT+CMGS=84 [Enter]
0011000B919762214365F70008C146043F04400438043204350442002004450430043
10440002C0020044D0442043E00200442043504410442043E0432043E043500200441
043E043E043104490435043D04380435 [Ctrl+Z]
```
Сначала переключение режима (в цифровой), затем отправляется длинна сообщения (84), а последняя строка содержит: номер телефона, текст сообщения и различные настройки (такие как: номер SMS-центра, сохранять ли сообщение у получателя и др.).
##### Пример на Delphi:
```
procedure SendSMSMessage(AComPort: integer; AMsg: String; ANumTel: String);
var
Lng, i: Integer;
LRead, LText, LMes, LTel, ANum: String;
hFile: THandle;
procedure WriteStr(AStr: String);
var
LWrited: Cardinal;
begin
//Пишем в порт
WriteFile(hFile, PAnsiChar(AStr)^, Length(AStr), LWrited, nil);
end;
begin
//открываем порт
hFile := Windows.CreateFile(PChar('\\.\COM' + IntToStr(AComPort)), GENERIC_READ or GENERIC_WRITE, 0, nil, OPEN_EXISTING, 0, 0);
//если открылся
if (hFile <> INVALID_HANDLE_VALUE) then
begin
ANum := ANumTel;
if (Length(ANum) mod 2) = 1 then
ANum := ANum + 'F';
for i := 1 to Length(ANum) do
if i mod 2 = 0 then
LTel := LTel + ANum[i] + ANum[i-1];
LText := AnsiToUCS(AMsg);
// Длина и номер SMS центра. 0 - означает, что будет использоваться дефолтный номер.
LMes := '00';
// SMS-SUBMIT
LMes := LMes + '11';
// Длина и номер отправителя. 0 - означает что будет использоваться дефолтный номер.
LMes := LMes + '00';
// Длина номера получателя
LMes := LMes + IntToHex(Length(ANumTel), 2);
// Тип-адреса. (91 указывает международный формат телефонного номера, 81 - местный формат).
LMes := LMes + '91';
// Телефонный номер получателя в международном формате.
LMes := LMes + LTel;
// Идентификатор протокола
LMes := LMes + '00';
// Старший полубайт означает сохранять SMS у получателя или нет (Flash SMS), Младший полубайт - кодировка(0-латиница 8-кирилица).
LMes := LMes + '08';
// Срок доставки сообщения. С1 - неделя
LMes := LMes + 'C1';
// Длина текста сообщения.
LMes := LMes + IntToHex(Trunc(Length(LText)/2),2);
LMes := LMes + LText;
Lng := Round((Length(LMes)-2)/2);
WriteStr('AT+CMGF=0' + #$D#$A);
WriteStr('AT+CMGS=' + StrToInt(Lng) + #$D#$A);
WriteStr(LMes + #$D#$A#$1A);
Windows.CloseHandle(hFile);
end;
end;
```
#### **Развитие идеи**
Сказать что я был счастлив когда на мобилу пришёл долгожданные русский текст, вместо «кракозябр», значит не сказать ничего. На следующий день дописал основную часть программы, и вроде бы всё. Сообщения с данными о выручке отправляются на телефон заказчику, вроде бы и жизнь то удалась, но не тут то было. Где то через неделю заказчик попросил доработать приложение, а именно сделать так чтобы после того как ему пришло SMS с текстом:
`08.11.2011
1.Магазин A, 123045 р.
2.Магазин B, 134520 р.
3.Магазин C, 215403 р.
...`
он бы мог в ответ на это сообщении отправить номер магазина и пришло бы новое сообщение, но уже с более детальной информацией по указанному магазину.
Ну в общем то логика простая: программа должна хранить последней отправленный «отчёт» по всем магазинам и читать входящие сообщения, как только появляется сообщение с условным текстом (например «магазин=12»), вытаскивать от туда номер магазина, смотреть в последнем отправленном сообщении что было под этим номером и отправлять детальную информацию по этому магазину (к сожалению на данный момент заказчик так и не определился с форматом и содержанием «подробного отчёта», так что в качестве примера привести нечего). Для реализации вышеупомянутой логики от модема требуется: прочитать SMS из памяти, удалить SMS из памяти (чтобы не скапливались). Для чтения сообщений использовал команды AT+CMGR и AT+CMGL (их краткое описание приводилось ранее). Чтение всех сообщений будет выглядеть как:
```
AT+CMGF=1 [Enter]
AT+CMGL="ALL" [Enter]
+CMGL: 6,"REC READ","778467",,"11/09/03,18:49:40+16"
007700770077002E006D00740073002E00720075
+CMGL: 7,"REC READ","+79261234567",,"11/10/18,18:38:00+16"
04220435044104420020043F044004380435043C043000200073006D0073002004410
43E043E043104490435043D04380439002100200421043C04410020043D043D043D04
3004340430003F0021003F00210028002D005F002D00290020 [Enter]
```
Здесь всё проще чем было раньше. Каждое сообщение состоит из 2х строк, в первой содержатся данные о сообщении (такие как: от кого, когда, номер сообщения), а во второй сам текст сообщения (опять таки в кодировке UCS, функция UCSToAnsi приводилась выше). Чтение одного сообщение осуществляется как:
```
AT+CMGF=1 [Enter]
AT+CMGR=7 [Enter]
+CMGR: "REC READ","+79261234567",,"11/10/18,18:38:00+16"
04220435044104420020043F044004380435043C043000200073006D0073002004410
43E043E043104490435043D04380439002100200421043C04410020043D043D043D04
3004340430003F0021003F00210028002D005F002D00290020 [Enter]
```
Аналогичным образом происходит и удаление сообщений. Если например в моём случае отправить команду AT+CMGD=7, то при следующем AT+CMGL=«ALL» я уже не увижу сообщение номер 7, т.к. оно будет удалено.
#### **Заключение**
И так, были разобраны основные команды для работы с SMS сообщениями через GSM модем, была рассмотрена отправка, чтение, удаление сообщений. На последок хотелось бы отметить что область применения такого использования SMS сообщений довольно широка (особенно потому что можно организовать двухстороннюю связь). Например так: пользователь отправляет SMS, модем принимает, наша программа считывает, выполняет какие то действия исходя из текста сообщения и отправляет пользователю результата. Или наоборот: на ПК происходит какое то событие, и программа отправляет пользователю сообщение об этом событии. Удачи вам в ваших экспериментах, спасибо!
Исходники тестовой проги [**тут**](http://depositfiles.com/files/0nut0c7wa). | https://habr.com/ru/post/133085/ | null | ru | null |
# Добавляем ссылки на страницы сайта в CKEDITOR 4
Доброго времени суток, %habrauser%!
Очень часто приходится писать мини CMS для разных проектов. Обосновано это, в большей степени, человеческой ленью. Поэтому в такие проекты часто добавляю очень удобный редактор CKEDITOR. И часто заказчики просят сделать удобный функционал для добавление ссылок на материалы сайта. В сети есть много описаний подобного процесса, но большинство рассчитаны на версии < 4. Недавно столкнулся с необходимостью внедрения данной функции в редактор.
Если тебе, дорогой читатель, интересно как это реализовать, милости прошу под кат.
#### Постановка задачи
Делая CMS даже малых размеров, очень часто приходится давать инструменты, позволяющие обойтись без программистов и верстальщиков, для размещения материалов на сайте. С одной стороны, можно просто вставить редактор и рассказать, каким образом обрезать ссылки из адресной строки, чтобы все работало. Но, как это часто бывает, исполнитель меняется или забывает как это делается.
Поэтому будем добавлять функционал для простого добавления ссылок на разделы/материалы CMS.
Что же мы хотим иметь в конечном итоге? Мы хотим иметь простой способ выбора материала для генерации ссылки на него. Сделаем это с помощью выпадающего списка.
#### Первый шаг
Будем считать, что мы уже загрузили архив с CKEDITOR и распаковали в папку с проектом (для удобства будем считать, что это папка Scripts). Таким образом, у наш редактор лежит по пути /Scripts/ckeditor
##### Что дальше?
А дальше мы… нет, мы не будем редактировать скрипты. Это следующий этап действий. Для начала мы должны создать данные, на основе которых, будет формироваться список материалов.
###### Немного теории
Практически во всех мануалах, посвященных данной проблеме, авторы создают скрытый input и «запихивают» в него данные. Но это не является безоговорочным способом. Мы вполне можем объявить глобальную переменную, в которую будут помещаться данные, и на ее основе инициализировать список. Я не буду особенно углубляться в такие дебри, так как это никак не связано с темой статьи, поэтому просто опишу вариант, показанный в других мануалах.
Одной из особенностей списка, передаваемого в качестве параметра является то, что он должен быть JSON объектом и представлять собой массив строковых массивов.
Таким образом конечный объект будет примерно таким:
```
[['Главная','/index.html'],['Галерея','/images.html'],['Контакты','/about.html'].....]
```
Каким образом формировать такой список решать разработчику. Ограничений нет.
Осталось только добавить на страницу контейнер, в который мы положим наш список. Давайте создадим скрытый input, который будет выглядеть примерно так:
```
```
Вот мы и подготовили данные для работы.
##### Идем дальше
Вот теперь мы полезем в скрипты. Первым делом откроем скрипт, который создает диалог выбора ссылки /Scripts/ckeditor/plugins/link/dialog/link.js
Находим слова
```
id: "linkType", type: "select"
```
(скрипт минифицирован, поэтому искать не очень удобно. я его отформатировал, для большего удобства работы)
и добавляем следующие строки
```
return {
title: b.title, minWidth: 350, minHeight: 230, contents: [{
id: "info", label: b.info, title: b.info, elements: [{
id: "linkType",
type: "select",
label: b.type,
"default": "localPage",
items: [
[b.toUrl, "url"],
[b.localPage, 'localPage'],
[b.toAnchor, "anchor"],
[b.toEmail, "email"]],
onChange: function () {
var a =
this.getDialog(), b = ["urlOptions", "localPageOptions", "anchorOptions", "emailOptions"], c = this.getValue(), d = a.definition.getContents("upload"), d = d && d.hidden; if (c == "url") { n.config.linkShowTargetTab && a.showPage("target"); d || a.showPage("upload") } else { a.hidePage("target"); d || a.hidePage("upload") } for (d = 0; d < b.length; d++) { var e = a.getContentElement("info", b[d]); if (e) { e = e.getElement().getParent().getParent(); b[d] == c + "Options" ? e.show() : e.hide() } } a.layout()
}, setup: function (a) { a.type && this.setValue(a.type) }, commit: function (a) {
a.type =
this.getValue()
}
},
//Наш тип ссылок
{
type: 'vbox',
id: 'localPageOptions',
children: [
{
type: 'select',
label: 'Страница сайта',
id: 'localPage', //Название "типа ссылки". Оно нам еще понадобится
title: 'Выберите страницу сайта, на которую хотите ссылаться',
items: eval(document.getElementById("localPageList").value), //берем данные из input'а localPageList
setup: function (data) {
if (data.localPage)
this.setValue(data.localPage);
},
commit: function (data) {
if (!data.localPage)
data.localPage = {};
data.localPage = this.getValue();
}
}]
},
//#Наш тип ссылок
```
Надеюсь, что здесь все понятно.
На данном этапе мы описали новый тип ссылки, который будет использоваться в диалоге и инициализировали его данными из нашего input'а.
Но если мы сейчас запустим редактор и посмотри список ссылок, мы не увидим созданного нами пункта.
##### Открываем новый тип ссылки в диалоге
Для того, чтобы созданный тип ссылки появился в диалоге, мы должны добавить его в список инициализации.
Ищем следующую строку кода:
```
b = ["urlOptions", "anchorOptions", "emailOptions"]
```
и добавляем в нее строку «localPageOptions», чтобы получилось так:
```
b = ["urlOptions", "localPageOptions", "anchorOptions", "emailOptions"]
```
Теперь, запустив редактор и открыв диалог ссылок мы видим… мы видим пункт «undefined».
«Вот это облом»! — подумал я, когда впервые увидел это.
Но, покопавшись немного в коде я понял, что диалог пытается найти название для нашего типа в файлах локализации. И не найдя ничего просто присваивает undefined переменной, которая должна хранить название. Решаем эту проблему добавлением всего одной строчки кода в файл/файлы(если вы используете несколько локализаций).
###### Правка локализации
Открываем файл /Scripts/ckeditor/lang/ru.js (en.js для английской локализации).
Выполняем поиск по словам:
```
"title": "Ссылка" //для русской локализации
"title": "Link" //для английской локализации
```
и через запятую добавляем строку:
```
"localPage": "Страница сайта" //для русской локализации
"localPage": "Local page" //для английской локализации
```
где localPage- название нашего типа ссылок, указанного как параметр id
#### Вместо заключения
Не тривиальная на первый взгляд задача отняла у меня 1,5-2 часа времени. Все мануалы, которые были найдены мной в сети, написаны для CKEDITOR версии 2 и 3. В четвертой версии многое изменилось и пришлось исследовать код, чтобы адаптировать под новый API. Такой опыт полезен, но иногда бывает очень нужно сделать все быстро.
Поэтому надеюсь, что мой пост оказался кому-нибудь полезным. | https://habr.com/ru/post/183868/ | null | ru | null |
# Автоэнкодеры в Keras, часть 6: VAE + GAN
### Содержание
* Часть 1: [Введение](https://habrahabr.ru/post/331382/)
* Часть 2: [*Manifold learning* и скрытые (*latent*) переменные](https://habrahabr.ru/post/331500/)
* Часть 3: [Вариационные автоэнкодеры (*VAE*)](https://habrahabr.ru/post/331552/)
* Часть 4: [*Conditional VAE*](https://habrahabr.ru/post/331664/)
* Часть 5: [*GAN* (Generative Adversarial Networks) и tensorflow](https://habrahabr.ru/post/332000/)
* **Часть 6: VAE + GAN**
В позапрошлой части мы создали ***CVAE*** автоэнкодер, декодер которого умеет генерировать цифру заданного лейбла, мы также попробовали создавать картинки цифр других лейблов в стиле заданной картинки. Получилось довольно хорошо, однако цифры генерировались смазанными.
В прошлой части мы изучили, как работают ***GAN’ы***, получив довольно четкие изображения цифр, однако пропала возможность кодирования и переноса стиля.
В этой части попробуем взять лучшее от обоих подходов путем совмещения *вариационных автоэнкодеров* (***VAE***) и *генеративных состязающихся сетей* (***GAN***).
Подход, который будет описан далее, основан на статье **[Autoencoding beyond pixels using a learned similarity metric, Larsen et al, 2016]**.
Иллюстрация из ***[1]***
#### Разберемся более подробно, почему восстановленные изображения получаются смазанные.
В части про *VAE* рассматривался процесс генерации изображений  из скрытых (*latent*) переменных .
Так как размерность скрытых переменных  значительно ниже, чем размерность объектов  (в части про *VAE* эти размерности были 2 и 784), а также всегда присутствует некоторая случайность, то одному и тому же  может соответствовать многомерное распределение , то есть . Это распределение можно представить как:
где  некоторый средний наиболее вероятный объект при заданном , а  — шум какой-то сложной природы.
Когда мы обучаем автоэнкодеры, мы сравниваем вход из выборки  и выход автоэнкодера  с помощью некоторого функционала ошибки ,
где  — энкодер и декодер.
Задавая , мы определяем шум , которым приближаем настоящий шум .
Минимизируя , мы учим автоэнкодер подстраиваться под шум , убирая его, то есть находить среднее значение в заданной метрике (во второй части это показывалось наглядно на простом искусственном примере).
Если шум , который мы определяем функционалом , не соответствует реальному шуму , то  окажется сильно смещенным от реального  (пример: если в регрессии реальный шум лаплассовский, а минимизируется разность квадратов, то предсказанное значение будет смещено в сторону выбросов).
Возвращаясь к картинкам: посмотрим, как связана попиксельная метрика, которой определен лосс в предыдущих частях, и метрика, используемая человеком. Пример и иллюстрация из ***[2]***:
На картинке выше:
(а) — оригинальное изображение цифры,
(b) — получена из (а) отрезанием куска,
(с) — цифра (а), сдвинутая на полпикселя вправо.
С точки зрения попиксельной метрики (а) намного ближе к (b), чем к (с); хотя с точки зрения человеческого восприятия (b) — даже не цифра, а вот разница между (а) и (b) практически незаметна.
Автоэнкодеры с попиксельной метрикой, таким образом, размазывали изображение, отражая тот факт, что в рамках близких :
* положение цифр слегка гуляет по картинке,
* нарисованы цифры слегка по-разному (хотя попиксельно может быть значительно далеко).
По метрике же человеческого восприятия тот факт, что цифра размылась, уже заставляет ее быть сильно непохожей на оригинал. Таким образом, если мы будем знать метрику человека или близкую к ней и оптимизировать в ней, то цифры не будут размываться, а важность того, чтобы цифра была полноценной, не как с картинки (b), резко возрастет.
Можно пытаться вручную придумывать метрику, которая будет ближе к человеческой. Но используя подход ***GAN***, можно обучить нейронную сеть самой искать хорошую метрику.
Про *GAN’ы* написано в прошлой части.
### Соединяя *VAE* и *GAN*
Генератор *GAN* выполняет функцию, аналогичную декодеру в *VAE*: оба сэмплят из априорного распределения  и переводят его в . Однако роли у них разные: декодер восстанавливает объект, закодированный энкодером, при обучении опираясь на некоторую метрику сравнения; генератор же генерирует случайный объект, который ни с чем не сравнивается, лишь бы дискриминатор не мог отличить, какому из распределений  или  он принадлежит.
Идея: добавить в *VAE* третью сеть — дискриминатор и подавать ей на вход и восстановленный объект и оригинал, а дискриминатор обучать определять, какой из них какой.
Иллюстрация из ***[1]***
Разумеется, использовать ту же самую метрику сравнения из *VAE* мы уже не можем, потому что, обучаясь в ней, декодер генерирует изображения, легко отличимые от оригинала. Не использовать метрику вообще — тоже, так как нам бы хотелось, чтобы воссозданный  был похож на оригинал, а не просто какой-то случайный из , как в чистом *GAN*.
Задумаемся, однако, вот о чем: дискриминатор, учась отличать реальный объект от сгенерированного, будет вычленять какие-то характерные черты одних и других. Эти черты объекта будут закодированы в слоях дискриминатора, и на основе их комбинации он уже будет выдавать вероятность объекта быть реальным. Например, если изображение размыто, то какой-то нейрон в дискриминаторе будет активироваться сильнее, чем если оно четкое. При этом чем глубже слой, тем более абстрактные характеристики входного объекта в нем закодированы.
Так как каждый слой дискриминатора является кодом-описанием объекта и при этом кодирует черты, позволяющие дискриминатору отличать сгенерированные объекты от реальных, то можно заменить какую-то простую метрику (например, попиксельную) на метрику над активациями нейронов в каком-то из слоев:
где  — активации на -ом слое дискриминатора, а  — энкодер и декодер.
При этом можно надеяться, что новая метрика  будет лучше.
Ниже приведена схема работы получившейся *VAE+GAN* сети, предлагаемая авторами ***[1]***.
Иллюстрация из ***[1]***
Здесь:
*  — входной объект из ,
*  — сэмплированный  из ,
*  — объект сгенерированный декодером из ,
*  — объект восстановленный из ,
* ![\mathcal L_{prior} = KL \left[ Q(Z|X)||P(Z) \right]](https://habrastorage.org/getpro/habr/post_images/9e5/0fe/123/9e50fe123a7a8f84e366f8a93cc6856c.svg) — лосс, заставляющий энкодер переводить  в нужное нам  (точно как в части 3 про *VAE*),
*  — метрика между активациями -ого слоя дискриминатора  на реальном  и восстановленным ,
*  — кросс-энтропия между реальным распределением лейблов настоящих/сгенерированных объектов, и распределением вероятности предсказываемым дискриминатором.
Как и в случае с *GAN*, мы не можем обучать все 3 части сети одновременно. Дискриминатор надо обучать отдельно, в частности, не нужно, чтобы дискриминатор пытался уменьшать , так как это схлопнет разницу активаций в 0. Поэтому обучение всех сетей надо ограничить только на релевантные им лоссы.
Схема, предлагаемая авторами:
Выше видно, на каких лоссах какие сети учатся. Особое внимание разве что стоит уделить декодеру: он, с одной стороны, пытается уменьшить расстояние между входом и выходом в метрике *l-го* слоя дискриминатора (), а с другой, пытается обмануть дискриминатор (увеличивая ). В статье авторы утверждают, что, меняя коэффициент , можно влиять на то, что важнее для сети: контент () или стиль (). Не могу, однако, сказать, что наблюдал этот эффект.
Код
---
Код во многом повторяет то, что было в прошлых частях про чистые ***VAE*** и ***GAN***.
Опять же сразу будем писать **conditional** модель.
```
from IPython.display import clear_output
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
from keras.layers import Dropout, BatchNormalization, Reshape, Flatten, RepeatVector
from keras.layers import Lambda, Dense, Input, Conv2D, MaxPool2D, UpSampling2D, concatenate
from keras.layers.advanced_activations import LeakyReLU
from keras.layers import Activation
from keras.models import Model, load_model
# Регистрация сессии в keras
from keras import backend as K
import tensorflow as tf
sess = tf.Session()
K.set_session(sess)
# Импорт датасета
from keras.datasets import mnist
from keras.utils import to_categorical
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test .astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))
y_train_cat = to_categorical(y_train).astype(np.float32)
y_test_cat = to_categorical(y_test).astype(np.float32)
# Глобальные константы
batch_size = 64
batch_shape = (batch_size, 28, 28, 1)
latent_dim = 8
num_classes = 10
dropout_rate = 0.3
gamma = 1 # Коэффициент гамма
# Итераторы тренировочных и тестовых батчей
def gen_batch(x, y):
n_batches = x.shape[0] // batch_size
while(True):
idxs = np.random.permutation(y.shape[0])
x = x[idxs]
y = y[idxs]
for i in range(n_batches):
yield x[batch_size*i: batch_size*(i+1)], y[batch_size*i: batch_size*(i+1)]
train_batches_it = gen_batch(x_train, y_train_cat)
test_batches_it = gen_batch(x_test, y_test_cat)
# Входные плейсхолдеры
x_ = tf.placeholder(tf.float32, shape=(None, 28, 28, 1), name='image')
y_ = tf.placeholder(tf.float32, shape=(None, 10), name='labels')
z_ = tf.placeholder(tf.float32, shape=(None, latent_dim), name='z')
img = Input(tensor=x_)
lbl = Input(tensor=y_)
z = Input(tensor=z_)
```
Описание моделей от *GAN* отличается почти только добавленным энкодером.
```
def add_units_to_conv2d(conv2, units):
dim1 = int(conv2.shape[1])
dim2 = int(conv2.shape[2])
dimc = int(units.shape[1])
repeat_n = dim1*dim2
units_repeat = RepeatVector(repeat_n)(lbl)
units_repeat = Reshape((dim1, dim2, dimc))(units_repeat)
return concatenate([conv2, units_repeat])
# у меня получалось, что батч-нормализация очень сильно тормозит обучение на начальных этапах (подозреваю, что из-за того, что P и P_g почти не ра)
def apply_bn_relu_and_dropout(x, bn=False, relu=True, dropout=True):
if bn:
x = BatchNormalization(momentum=0.99, scale=False)(x)
if relu:
x = LeakyReLU()(x)
if dropout:
x = Dropout(dropout_rate)(x)
return x
with tf.variable_scope('encoder'):
x = Conv2D(32, kernel_size=(3, 3), strides=(2, 2), padding='same')(img)
x = apply_bn_relu_and_dropout(x)
x = MaxPool2D((2, 2), padding='same')(x)
x = Conv2D(64, kernel_size=(3, 3), padding='same')(x)
x = apply_bn_relu_and_dropout(x)
x = Flatten()(x)
x = concatenate([x, lbl])
h = Dense(64)(x)
h = apply_bn_relu_and_dropout(h)
z_mean = Dense(latent_dim)(h)
z_log_var = Dense(latent_dim)(h)
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(batch_size, latent_dim), mean=0., stddev=1.0)
return z_mean + K.exp(K.clip(z_log_var/2, -2, 2)) * epsilon
l = Lambda(sampling, output_shape=(latent_dim,))([z_mean, z_log_var])
encoder = Model([img, lbl], [z_mean, z_log_var, l], name='Encoder')
with tf.variable_scope('decoder'):
x = concatenate([z, lbl])
x = Dense(7*7*128)(x)
x = apply_bn_relu_and_dropout(x)
x = Reshape((7, 7, 128))(x)
x = UpSampling2D(size=(2, 2))(x)
x = Conv2D(64, kernel_size=(5, 5), padding='same')(x)
x = apply_bn_relu_and_dropout(x)
x = Conv2D(32, kernel_size=(3, 3), padding='same')(x)
x = UpSampling2D(size=(2, 2))(x)
x = apply_bn_relu_and_dropout(x)
decoded = Conv2D(1, kernel_size=(5, 5), activation='sigmoid', padding='same')(x)
decoder = Model([z, lbl], decoded, name='Decoder')
with tf.variable_scope('discrim'):
x = Conv2D(128, kernel_size=(7, 7), strides=(2, 2), padding='same')(img)
x = MaxPool2D((2, 2), padding='same')(x)
x = apply_bn_relu_and_dropout(x)
x = add_units_to_conv2d(x, lbl)
x = Conv2D(64, kernel_size=(3, 3), padding='same')(x)
x = MaxPool2D((2, 2), padding='same')(x)
x = apply_bn_relu_and_dropout(x)
# l-слой на котором будем сравнивать активации
l = Conv2D(16, kernel_size=(3, 3), padding='same')(x)
x = apply_bn_relu_and_dropout(x)
h = Flatten()(x)
d = Dense(1, activation='sigmoid')(h)
discrim = Model([img, lbl], [d, l], name='Discriminator')
```
Построение графа вычислений на основе моделей:
```
z_mean, z_log_var, encoded_img = encoder([img, lbl])
decoded_img = decoder([encoded_img, lbl])
decoded_z = decoder([z, lbl])
discr_img, discr_l_img = discrim([img, lbl])
discr_dec_img, discr_l_dec_img = discrim([decoded_img, lbl])
discr_dec_z, discr_l_dec_z = discrim([decoded_z, lbl])
cvae_model = Model([img, lbl], decoder([encoded_img, lbl]), name='cvae')
cvae = cvae_model([img, lbl])
```
Определение лоссов:
Интересно, что получался слегка лучше результат, если в качестве метрики на активациях слоев брать не *MSE*, а кросс-энтропию.
```
# Базовые лоссы
L_prior = -0.5*tf.reduce_sum(1. + tf.clip_by_value(z_log_var, -2, 2) - tf.square(z_mean) - tf.exp(tf.clip_by_value(z_log_var, -2, 2)))/28/28
log_dis_img = tf.log(discr_img + 1e-10)
log_dis_dec_z = tf.log(1. - discr_dec_z + 1e-10)
log_dis_dec_img = tf.log(1. - discr_dec_img + 1e-10)
L_GAN = -1/4*tf.reduce_sum(log_dis_img + 2*log_dis_dec_z + log_dis_dec_img)/28/28
# L_dis_llike = tf.reduce_sum(tf.square(discr_l_img - discr_l_dec_img))/28/28
L_dis_llike = tf.reduce_sum(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.sigmoid(discr_l_img),
logits=discr_l_dec_img))/28/28
# Лоссы энкодера, декодера, дискриминатора
L_enc = L_dis_llike + L_prior
L_dec = gamma * L_dis_llike - L_GAN
L_dis = L_GAN
# Определение шагов оптимизатора
optimizer_enc = tf.train.RMSPropOptimizer(0.001)
optimizer_dec = tf.train.RMSPropOptimizer(0.0003)
optimizer_dis = tf.train.RMSPropOptimizer(0.001)
encoder_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "encoder")
decoder_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "decoder")
discrim_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "discrim")
step_enc = optimizer_enc.minimize(L_enc, var_list=encoder_vars)
step_dec = optimizer_dec.minimize(L_dec, var_list=decoder_vars)
step_dis = optimizer_dis.minimize(L_dis, var_list=discrim_vars)
def step(image, label, zp):
l_prior, dec_image, l_dis_llike, l_gan, _, _ = sess.run([L_prior, decoded_z, L_dis_llike, L_GAN, step_enc, step_dec],
feed_dict={z:zp, img:image, lbl:label, K.learning_phase():1})
return l_prior, dec_image, l_dis_llike, l_gan
def step_d(image, label, zp):
l_gan, _ = sess.run([L_GAN, step_dis], feed_dict={z:zp, img:image, lbl:label, K.learning_phase():1})
return l_gan
```
Функции рисования картинок после и в процессе тренировки:
**Код**
```
digit_size = 28
def plot_digits(*args, invert_colors=False):
args = [x.squeeze() for x in args]
n = min([x.shape[0] for x in args])
figure = np.zeros((digit_size * len(args), digit_size * n))
for i in range(n):
for j in range(len(args)):
figure[j * digit_size: (j + 1) * digit_size,
i * digit_size: (i + 1) * digit_size] = args[j][i].squeeze()
if invert_colors:
figure = 1-figure
plt.figure(figsize=(2*n, 2*len(args)))
plt.imshow(figure, cmap='Greys_r')
plt.grid(False)
ax = plt.gca()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
# Массивы, в которые будем сохранять результаты, для последующей визуализации
figs = [[] for x in range(num_classes)]
periods = []
save_periods = list(range(100)) + list(range(100, 1000, 10))
n = 15 # Картинка с 15x15 цифр
from scipy.stats import norm
# Так как сэмплируем из N(0, I), то сетку узлов, в которых генерируем цифры берем из обратной функции распределения
grid_x = norm.ppf(np.linspace(0.05, 0.95, n))
grid_y = norm.ppf(np.linspace(0.05, 0.95, n))
grid_y = norm.ppf(np.linspace(0.05, 0.95, n))
def draw_manifold(label, show=True):
# Рисование цифр из многообразия
figure = np.zeros((digit_size * n, digit_size * n))
input_lbl = np.zeros((1, 10))
input_lbl[0, label] = 1
for i, yi in enumerate(grid_x):
for j, xi in enumerate(grid_y):
z_sample = np.zeros((1, latent_dim))
z_sample[:, :2] = np.array([[xi, yi]])
x_decoded = sess.run(decoded_z, feed_dict={z:z_sample, lbl:input_lbl, K.learning_phase():0})
digit = x_decoded[0].squeeze()
figure[i * digit_size: (i + 1) * digit_size,
j * digit_size: (j + 1) * digit_size] = digit
if show:
# Визуализация
plt.figure(figsize=(15, 15))
plt.imshow(figure, cmap='Greys')
plt.grid(False)
ax = plt.gca()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
return figure
# Рисование распределения z
def draw_z_distr(z_predicted):
im = plt.scatter(z_predicted[:, 0], z_predicted[:, 1])
im.axes.set_xlim(-5, 5)
im.axes.set_ylim(-5, 5)
plt.show()
def on_n_period(period):
n_compare = 10
clear_output() # Не захламляем output
# Сравнение реальных и декодированных цифр
b = next(test_batches_it)
decoded = sess.run(cvae, feed_dict={img:b[0], lbl:b[1], K.learning_phase():0})
plot_digits(b[0][:n_compare], decoded[:n_compare])
# Рисование многообразия для рандомного y
draw_lbl = np.random.randint(0, num_classes)
print(draw_lbl)
for label in range(num_classes):
figs[label].append(draw_manifold(label, show=label==draw_lbl))
xs = x_test[y_test == draw_lbl]
ys = y_test_cat[y_test == draw_lbl]
z_predicted = sess.run(z_mean, feed_dict={img:xs, lbl:ys, K.learning_phase():0})
draw_z_distr(z_predicted)
periods.append(period)
```
Процесс обучения:
```
sess.run(tf.global_variables_initializer())
nb_step = 3 # Количество шагов во внутреннем цикле
batches_per_period = 3
for i in range(48000):
print('.', end='')
# Шаги обучения дискриминатора
for j in range(nb_step):
b0, b1 = next(train_batches_it)
zp = np.random.randn(batch_size, latent_dim)
l_g = step_d(b0, b1, zp)
if l_g < 1.0:
break
# Шаг обучения декодера и энкодера
for j in range(nb_step):
l_p, zx, l_d, l_g = step(b0, b1, zp)
if l_g > 0.4:
break
b0, b1 = next(train_batches_it)
zp = np.random.randn(batch_size, latent_dim)
# Периодическая визуализация результата
if not i % batches_per_period:
period = i // batches_per_period
if period in save_periods:
on_n_period(period)
print(i, l_p, l_d, l_g)
```
Функция рисования гифок:
**Код**
```
from matplotlib.animation import FuncAnimation
from matplotlib import cm
import matplotlib
def make_2d_figs_gif(figs, periods, c, fname, fig, batches_per_period):
norm = matplotlib.colors.Normalize(vmin=0, vmax=1, clip=False)
im = plt.imshow(np.zeros((28,28)), cmap='Greys', norm=norm)
plt.grid(None)
plt.title("Label: {}\nBatch: {}".format(c, 0))
def update(i):
im.set_array(figs[i])
im.axes.set_title("Label: {}\nBatch: {}".format(c, periods[i]*batches_per_period))
im.axes.get_xaxis().set_visible(False)
im.axes.get_yaxis().set_visible(False)
return im
anim = FuncAnimation(fig, update, frames=range(len(figs)), interval=100)
anim.save(fname, dpi=80, writer='ffmpeg')
for label in range(num_classes):
make_2d_figs_gif(figs[label], periods, label, "./figs6/manifold_{}.mp4".format(label), plt.figure(figsize=(10,10)), batches_per_period)
```
Так как у нас снова модель на основе автоэнкодера, мы можем применять перенос стиля:
**Код**
```
# Трансфер стиля
def style_transfer(X, lbl_in, lbl_out):
rows = X.shape[0]
if isinstance(lbl_in, int):
label = lbl_in
lbl_in = np.zeros((rows, 10))
lbl_in[:, label] = 1
if isinstance(lbl_out, int):
label = lbl_out
lbl_out = np.zeros((rows, 10))
lbl_out[:, label] = 1
# Кодирем стиль входящего изображения
zp = sess.run(z_mean, feed_dict={img:X, lbl:lbl_in, K.learning_phase():0})
# Восстанавливаем из этого стиля, заменяя лейбл
created = sess.run(decoded_z, feed_dict={z:zp, lbl:lbl_out, K.learning_phase():0})
return created
# Картинка трансфера стиля
def draw_random_style_transfer(label):
n = 10
generated = []
idxs = np.random.permutation(y_test.shape[0])
x_test_permut = x_test[idxs]
y_test_permut = y_test[idxs]
prot = x_test_permut[y_test_permut == label][:batch_size]
for i in range(num_classes):
generated.append(style_transfer(prot, label, i)[:n])
generated[label] = prot
plot_digits(*generated, invert_colors=True)
draw_random_style_transfer(7)
```
Результаты
----------
### Сравнение с простым CVAE
Сверху оригиналы цифр, снизу восстановленные.
*CVAE*, скрытая размерность — 2
*CVAE+GAN*, скрытая размерность — 2
*CVAE+GAN*, скрытая размерность — 8
Сгенерированные цифры каждого лейбла сэмплированные из :
[](https://habrastorage.org/web/d7a/468/2ef/d7a4682ef6ed41dd90bcddbeb9d1b2e4.png)[](https://habrastorage.org/web/50e/263/85e/50e26385e2e146a0a33bcc827bfade39.png)[](https://habrastorage.org/web/5ed/bc2/4f0/5edbc24f0f2b4ce2bd41ca5f21543d02.png)[](https://habrastorage.org/web/309/49b/061/30949b0613d2460f9a2fae7c19865c08.png)[](https://habrastorage.org/web/c23/ae0/c3e/c23ae0c3eaea43f29add817bc59b6201.png)[](https://habrastorage.org/web/944/78f/c98/94478fc985304338968036fbf5c90e67.png)[](https://habrastorage.org/web/26d/09c/21d/26d09c21d6a04545b7e51998e7f31aaa.png)[](https://habrastorage.org/web/d2a/d40/2aa/d2ad402aabc34b4a846ff79c0c8b6917.png)[](https://habrastorage.org/web/5d9/431/ce5/5d9431ce5815417b9a83c8a42f5db6da.png)[](https://habrastorage.org/web/6f6/47e/938/6f647e9388a84882964c77c7a8fbc6ff.png)
### Процесс обучения
**Гифки**[](https://hsto.org/web/06e/ba4/0e8/06eba40e8ae04f469521a230982a30fb.gif)[](https://habrastorage.org/web/1d3/f62/26d/1d3f6226dbcf41389913b482c8b9c212.gif)[](https://habrastorage.org/web/dab/905/67e/dab90567ed464de19822102de1526752.gif)[](https://habrastorage.org/web/71f/e07/b6a/71fe07b6a28c4c3b8c7a076e96d087f9.gif)[](https://habrastorage.org/web/b51/010/5c4/b510105c4c4a4637b4f38558b1ca1f92.gif)[](https://habrastorage.org/web/712/d61/555/712d6155577e4d39b1786da16391e8c6.gif)[](https://habrastorage.org/web/50c/f6e/ccf/50cf6eccf2aa4ac58253105f5d176041.gif)[](https://habrastorage.org/web/07c/6c3/bb0/07c6c3bb099e4ed7806a6d378b9f437d.gif)[](https://habrastorage.org/web/602/102/111/602102111a374d7aae900f2b867d49e6.gif)[](https://habrastorage.org/web/bec/5ec/330/bec5ec33020b4951adae3171af205aaf.gif)
### Трансфер стиля
За основу брались «7», из стиля которых создавались уже остальные цифры (здесь ).
Вот так было с простым *CVAE*:
А вот так стало:
Заключение
----------
На мой взгляд, получилось очень неплохо. Пройдя путь от простейших *автоэнкодеров*, мы дошли до генеративных моделей, а именно до *VAE*, *GAN*, поняли, что такое *conditional* модели, и почему важна метрика.
Мы также научились пользоваться *keras’ом* и совмещать его с голым *tensorflow*.
Всем спасибо за внимание, надеюсь было интересно!
[**Репозиторий со всеми ноутбуками**](https://github.com/urtrial/ae_vae_gan)
Полезные ссылки и литература
----------------------------
Оригинальная статья:
[1] Autoencoding beyond pixels using a learned similarity metric, Larsen et al, 2016, <https://arxiv.org/abs/1512.09300>
Туториал по *VAE*:
[2] Tutorial on Variational Autoencoders, Carl Doersch, 2016, <https://arxiv.org/abs/1606.05908>
Туториал по использованию *keras* вместе с *tensorflow*:
[3] <https://blog.keras.io/keras-as-a-simplified-interface-to-tensorflow-tutorial.html> | https://habr.com/ru/post/332074/ | null | ru | null |
# Создаем комнатный детектор движения на Arduino и MATLAB
В этом примере будет создан простой **детектор движения**, на базе **фоторезистора** и **Arduino**. Управляется при помощи Arduino Support Package для **MATLAB**.
[](http://habrahabr.ru/post/262259/)
Введение
--------
Фоторезистор – это переменный резистор, который реагирует на интенсивность падающего света, следовательно, детектор движения будет обнаруживать только то движение, которое вызывает изменения освещенности.
Управляющая программа, написанная в MATLAB будет использовать команды из Support Package, чтобы считывать напряжение с контактов Arduino. Значения напряжения будут загружаться напрямую в MATLAB, с привязкой ко времени. Эти данные будут выведены на график и проанализированы в реальном времени для обнаружения движения.
Код использует комбинацию алгоритмов для обнаружения движения, но есть множество других алгоритмов машинного обучения и анализа данных, которые могут быть использованы в подобных проектах.
Пока детектор движения работает, программа MATLAB хранит все показания напряжения вместе с соответствующими временными отметками. Это позволяет пользователю обрабатывать полный набор данных в MATLAB после завершения записи. Далее в статье представлены результаты анализа нескольких таких записей и алгоритмов.
Что понадобится?
* Arduino или аналог
* Кабель USB
* 1 фоторезистор
* 10 кОм резистор
* Провода (МГТФ на 0,2 должно хватить)
* Небольшая макетная плата
Задача 1 — Подключение Arduino к MATLAB
---------------------------------------
Для подключения Arduino к MATLAB, необходимо установить пакет поддержки MATLAB для Arduino. Этот пакет поддержки доступен для MATLAB, начиная с релиза R2014a(текущий R2015а) и выше, и ставится с помощью установщика пакетов поддержки. Этот установщик может быть открыт из ленты MATLAB (Add-Ons -> Get Hardware Support Packages) или из командной строки при помощи команды supportPackageInstaller. После установки пакета поддержки, можно подключать Arduino.
Порядок действий
1. Подключить Arduino к компьютеру с помощью кабеля USB.
2. В MATLAB, инициализировать объект Arduino:
```
% Inputs: Port ID (from your computer), Arduino board type
myArduino = arduino('COM4','uno');
```
Задача 2 — Проверка соединения MATLAB-Arduino
---------------------------------------------
У большинства плат Arduino или клонов есть встроенный светодиод на выводе 13. Если у вашей платы есть светодиод, вы можете проверить соединение, просто помигав им.
Если встроенного светодиода нет, то можно подключить один последовательно к резистору между цифровым выводом (например, 13) и GND (см. электрическую схему ниже).
Номинал резистора будет разным для цвета светодиода, но для красных и желтых светодиодов должно быть достаточно резистора 330 Ом. Когда светодиод будет подключен, для проверки надо выполнить код ниже (5 раз помигаем светодиодом).
Задача 3 – Сборка схемы
-----------------------
Важно то, что, как и все резисторы, фоторезистор не имеет ориентации – не нужно беспокоиться о направлении тока, протекающего через него. Сначала, нужно создавать простой делитель напряжения с использованием фоторезистора:
1. На макетке, соединим последовательно фоторезистор и 10кОмный резистор.
2. Подключим свободный вывод 10 кОмного резистора к выводу GND Arduino.
3. Подключим свободный вывод фоторезистора к выводу 5V Arduino.
Чтобы померять напряжение между фоторезистором и 10 кОм резистором, надо подключить эту точку в цепи к аналоговому выводу Arduino при помощи провода. Эта связка будет работать как потенциометр.
Задача 4 — Проверка схемы и фоторезистора
-----------------------------------------
Следующим шагом является проверка схемы для того, чтобы убедиться в том, что фоторезистор правильно реагирует на меняющуюся освещенность.
Приведенный ниже скрипт показывает, как настроить Arduino и получить показания напряжения от фоторезистора через аналоговый вывод Arduino.
Попробуйте накрыть фоторезистор или включить/выключить свет в помещении, когда работает скрипт, чтобы увидеть, как фоторезистор реагирует на изменения освещенности.
**Принцип работы фоторезисторов с MATLAB**Фоторезистор – это резистор переменного сопротивления, который реагирует на интенсивность падающего света. Чем ярче свет, тем меньше сопротивление фоторезистора. Простой делитель напряжения, в виде последовательного подключения фоторезистора и резистора с постоянным сопротивлением, будет преобразовывать изменения сопротивления цепи в измеряемые перепады напряжения. MATLAB используется для считывания напряжения с аналогового вывода Arduino. Когда значение напряжения записывается в MATLAB, программа может соотнести каждое значение напряжения с соответствующим уровнем света. Даже простые фоторезисторы могут быть очень чувствительными, обеспечивая чтение полного диапазона напряжений (0-5 В) с аналогового вывода Arduino. MATLAB прочитает значения этих напряжений с округлением до ближайших 0,0049 вольт, потому что аналоговый сигнал преобразуется в 10- битный цифровой сигнал:
Задача 5 – Калибровка алгоритма детектора движения
--------------------------------------------------
Так как фоторезистор обладает высокой чувствительностью, алгоритмы обнаружения движения потребуют калибровки, которая будет зависеть от окружающих условий освещения и сценария использования детектора движения. Программные уровни освещенности также должны быть скорректированы с учетом желаемой чувствительности.
Код MATLAB для детектора движения (Run\_Motion\_Detector.m) применяет три вида расчетов в режиме реального времени, для определения того, что текущее значение напряжения соответствует движению.
Каждый расчет– это простой способ количественной оценки изменчивости в пределах небольшого окна данных. Каждый результат расчетов сравнивается с соответствующей пороговой величиной, для определения, показывает ли это изменение движение. Если какой-либо из результатов превышает соответствующее пороговое значение переменной, текущее значение напряжения обозначается как движение.
Пороговые переменные имеют непосредственное отношение к чувствительности детектора движения и должны быть откалиброваны для каждой конкретной ситуации.
Всего реализовано 3 метода:
1. Метод стандартных отклонений-вычисляет стандартное отклонение всех точек внутри окна данных, используя **std****(****voltages****)**. Это основной расчет разницы между показаниями напряжения.
2. Метод разностей- вычисляет сумму абсолютных значений разностей между последовательными точками с использованием **sum(****abs(****diff(****voltages)))**. Это расчет чистого изменения между последовательными точками данных в окне данных.
3. Метод Slope -вычисляет наиболее подходящий линейный тренд (slope) для окна данных. Требуются как показания напряжения, таки соответствующие отсчеты времени.
Для описательного анализа условий освещения, функция getLightingCondition качественно описывает интенсивность света при каждом считывании напряжения.
Эта функция так же должна быть откалибрована и расширена соответствующим образом для описания уровня освещенности на месте установки вашего детектора движения.
Задача 6 – Обработка записанных данных
--------------------------------------
Многие датчики движения предназначены только для обнаружения движения в режиме реального времени, так как они предназначены для автоматизации определенной задачи. Это очень распространенный тип детектора движения, применяемый в автоматических дверях в аэропортах и магазинах, или активируемых движением выключателей в офисных зданиях.
Детектор движения, созданный с использованием MATLAB, построенный в этом примере может не только обнаружить движение в реальном времени, а также дополнительно записывать и собирать показания датчика в течение всего сеанса записи.
Функция Run\_Motion\_Detector автоматически сохраняет необработанные значения аналоговых напряжений и временные отсечки переменных analogVoltage и sensorTime в базовом рабочем пространстве MATLAB.
После сохранения в MATLAB, эти данные могут быть переданы функции Analyze\_Motion\_Detector\_Data для реализации и сравнения различных алгоритмов обнаружения движения. На рисунке ниже показаны результаты работы трех алгоритмов обнаружения движения применительно к полному набору данных.
Красные маркеры данных характеризуются как движение по всем трем способами. Показательно, что некоторые движения обнаруживается только по методу Slope (показан зелеными маркерами), в то время как другое движение обнаруживается только методом стандартного отклонения и / или разностным методом (показано голубыми маркерами).
Используя комбинацию этих трех методов для определения движения, детектор движения, реализованный в MATLAB может создать полную запись движения.
Задача 7 – Классификация движения
---------------------------------
Используя MATLAB для обработки данных, легко выделить события движения и характеризовать каждое по нескольким рассчитанным параметрам.
Некоторые простые параметры, которые могут быть рассчитаны включают в себя:
* уровень освещенности, прежде чем произошло событие движения
* уровень освещенности после движения
* Средняя освещенность в течение события движения
* Общее время для события движения
Функция Categorize\_Motion\_Events вычисляет эти четыре параметра для каждого события движения и использует их для качественного описания записей движения.
Описания используются для создания отметок на графике напряжения. Отметки движения состоят из трех символов и расположены выше события движения.
1. Первый символ — плюс, минус, или знак равенства указывает на увеличение интенсивности освещения (+), снижение (-), или неизменности (=) в окрестности события движения.
2. Следующий символ является буквой, обозначающей определенный тип движения.Типы движения с соответствующимибуквамиперечислены ниже.
* G: Длительное движение (перемена освещения происходит в течение более чем 20 секунд)
* Е: Расширенное движения (перемена освещения происходит в течение нескольких секунд)
* М: Значительное изменение освещенности (изменения освещенности резко вокруг события)
* С: Комбинация (изменение освещенности во время и вокруг события)
* L: изменение освещенности (небольшое изменение освещенности вокруг события)
* Т: Временное движение (никаких существенных изменений освещенности вокруг события)
3. Третий знак(если указан) показывает, как среднее значение освещенности в течение каждого события движения связано с предыдущей и следующей интенсивностями света, используя те же знаки плюс, минус, и знак равенства, как и для первого символа.
Если требуется отслеживать конкретные виды движения, то можно ужесточить ограничения, чтобы получить более точную классификацию, или использовать методы машинного обучения в MATLAB для программирования автоматически настраиваемого детектора движения.
Практическое применение: Наблюдение за активностью в холле
----------------------------------------------------------
Так как детектор движения чувствителен к изменениям освещенности, лучше всего он будет работать, когда движение, которое вы хотите отследить, соответствует резкому увеличению или резкому снижению освещенности.
Одним из сценариев, который хорошо работает для обнаружения людей, является расположение детектора движения в коридоре на хорошо освещенной стене или рядом с источником света. Когда люди будут проходить по коридору, будет происходить резкое падение напряжения, когда их тени будут попадать на фоторезистор.
На графике ниже представлены данные, которые собраны детектором движения в холле. События движения классифицируются с использованием версии функции Categorize\_Motion\_Events, которая была специально модифицирована для анализа данных собранных в холле.
События движения, классифицированные как изменения освещения (M или L) могут быть отброшены, поскольку они, скорее всего, не указывают людей, проходящих через холл.
Это оставляет девять событий, которые, по всей видимости, указывают на проход людей. Может быть выполнен дальнейший анализ, чтобы вычислить скорость человека при ходьбе или, как много людей было в группе, изучая длину события движения.
Вывод
-----
При помощи Arduino был создан простой детектор движения, MATLAB был использован для калибровки детектора и классификации движения.
Практическое применение: потренироваться на кошках для оттачивания своего алгоритма с последующим переносом на более серьезную компонентную базу.
Материалы статьи
----------------
* [Arduino Support Package](http://www.mathworks.com/hardware-support/arduino-matlab.html)
* [Код программы](http://www.mathworks.com/matlabcentral/fileexchange/47605-creating-a-motion-detector-using-an-arduino--a-photoresistor-and-matlab) | https://habr.com/ru/post/262259/ | null | ru | null |
# Получаем информацию о рабочем месте пользователя
0. Предисловие
--------------
Все началось с очередного звонка пользователя, который с гордостью сообщил сообщил: — „Всё сломалось“, и с моих „потуг“ удаленно найти PC, на котором работает данный пользователь..
Решение планировало быть простым до безумия и собираться на коленке. Так-как большинство наших сотрудников работают под "виндой" и все рабочие станции входят в домен, был задан вектор поиска решения. Изначально, планировалось написать небольшой скрипт. В его задачу входило собрать базовую информацию о системе и сотруднике, который за этой системой работает. Набор информации минимальный. А именно: логин, название рабочей станции и ее ip. Результат работы сохраняем на сервере, а сам скрипт "вешаем" на пользователя через GPO.
В такой реализации были существенные недостатки в виде:
* получить информацию можно было бы только зайдя на сервер (его сетевую папку где хранился файл), что не всегда удобно
* поддерживать файл в актуальном состоянии
* получать данные в реальном времени
После раздумий пришло решение: использовать бота в Telegram. Прибегнув к небольшой ловкости рук, скрипт был переписан в небольшую программку для отправки информации в чат, за место "скучной" записи в файл на сервере. (+ были добавлены еще некоторые параметры которые оправлялись боту)
*P.S. Данные приведенные на изображение отцензурированы для сохранения коммерческой тайны.*
Но и такой подход решил только проблему с доступностью информации, одновременно сохраняя остальные минусы старого подхода.
Нужно было что-то менять. Было решено написать полноценное клиент-серверное приложение.
Концепция проста. Пишем сервер который будет обслуживать входящие соединения от клиента и отсылать ему запрашиваемую информацию.
1. Пишем сервер
---------------
Для начала выбираем протокол для "общения". Выбор не велик — UDP/TCP. Я решил в пользу TCP. Преимущества очевидны:
* обеспечивает надежную связь
* обмен данными в рамках одной сессии
Начнем с создания класса пользователя
```
public class User
{
public string Name { get; set; }
public string PC { get; set; }
public string IP { get; set; }
public string Version { get; set; }
public byte[] Screen { get; set; }
}
```
Изначально он имел только 3 свойства. Но в процессе разработки, код сервера вида изменялся. Появлялся новый функционал. Версия стала необходима для совместимости клиента и сервера. Брать версию из сборки я не стал, решив что она избыточна. Так-же появилась возможность делать скрин экрана пользователя.
Конструктор:
```
public User(string name, string pc, string ip, string version)
{
this.Name = name;
this.PC = pc;
this.IP = ip;
this.Version = version;
}
```
Нам не всегда нужно передавать снимок экрана. Поэтому создаем перегрузку конструктора:
```
public User(string name, string pc, string ip, string version, byte[] screen)
{
this.Name = name;
this.PC = pc;
this.IP = ip;
this.Version = version;
this.Screen = screen;
}
```
Забегая немного в перед, скажу что изначально данные передавались через BinaryWriter "построчно" и без приведения к общему типу данных. Что было очень неудобно при добавление новых функций в приложение. Переписывание функции отправки данных привело к добавлению возможности их сериализации. Теперь объект User можно было представить в трех видах:
* Binary
* JSON
* XML
```
[Serializable, DataContract]
public class User
{
[DataMember]
public string Name { get; set; }
[DataMember]
public string PC { get; set; }
[DataMember]
public string IP { get; set; }
[DataMember]
public string Version { get; set; }
[DataMember]
public byte[] Screen { get; set; }
public User(string name, string pc, string ip, string version)
{
this.Name = name;
this.PC = pc;
this.IP = ip;
this.Version = version;
}
public User(string name, string pc, string ip, string version, byte[] screen)
{
this.Name = name;
this.PC = pc;
this.IP = ip;
this.Version = version;
this.Screen = screen;
}
public byte[] GetBinary()
{
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, this);
return stream.ToArray();
}
}
public byte[] GetXML()
{
XmlSerializer formatter = new XmlSerializer(typeof(User));
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, this);
return stream.ToArray();
}
}
public byte[] GetJSON()
{
DataContractJsonSerializer jsonFormatter = new DataContractJsonSerializer(typeof(User));
using (MemoryStream stream = new MemoryStream())
{
jsonFormatter.WriteObject(stream, this);
return stream.ToArray();
}
}
}
```
Что-бы иметь возможность десериализации бинарного объекта User, пришлось вынести его в отдельную библиотеку и использовать в программе уже через нее.
Также хочу обратить внимание на поток который мы получаем на выходе. Массив байтов возвращается через метод ToArray. Его минус — он создает копию стрима в памяти. Но это не критично, в отличие от использования метода GetBuffer, который возвращает нам не чистый массив данных, а полностью весь поток (смысл в том что память выделенная под поток может быть заполнена не полностью), в результате мы получаем увеличения массива. К сожалению этот нюанс я увидел не сразу. А только при детальном анализе данных.
За обработку наших соединений отвечает класс ClientObject
```
public class ClientObject
{
public TcpClient client;
[Flags]
enum Commands : byte
{
GetInfoBin = 0x0a,
GetInfoJSON = 0x0b,
GetInfoXML = 0x0c,
GetScreen = 0x14,
GetUpdate = 0x15,
GetTest = 0xff
}
public ClientObject(TcpClient tcpClient)
{
client = tcpClient;
}
protected void Sender(TcpClient client, byte[] data)
{
try
{
Logger.add("Sender OK 0xFF");
BinaryWriter writer = new BinaryWriter(client.GetStream());
writer.Write(data);
writer.Flush();
writer.Close();
}
catch (Exception e)
{
Logger.add(e.Message + "0xFF");
}
}
protected byte[] _Info ()
{
return new User.User(Environment.UserName, Environment.MachineName, GetIp(),
Settings.Version, _Screen()).GetBinary();
}
protected byte[] _Info(string type)
{
User.User tmp = new User.User(Environment.UserName, Environment.MachineName, GetIp(),
Settings.Version);
switch (type)
{
case "bin": return tmp.GetBinary();
case "json": return tmp.GetJSON();
case "xml": return tmp.GetXML();
}
return (new byte[1] { 0x00 });
}
protected byte[] _Screen()
{
Bitmap bm = new Bitmap(Screen.PrimaryScreen.Bounds.Width,
Screen.PrimaryScreen.Bounds.Height);
Graphics gr = Graphics.FromImage(bm as Image);
gr.CopyFromScreen(0, 0, 0, 0, bm.Size);
using (MemoryStream stream = new MemoryStream())
{
bm.Save(stream, ImageFormat.Jpeg);
return stream.ToArray();
}
}
protected byte[] _Test()
{
return Encoding.UTF8.GetBytes("Test send from server");
}
public void CmdUpdate(Process process)
{
Logger.add("Command from server: Update");
try
{
string fileName = "Update.exe", myStringWebResource = null;
WebClient myWebClient = new WebClient();
myStringWebResource = Settings.UrlUpdate + fileName;
myWebClient.DownloadFile(myStringWebResource, fileName);
Process.Start("Update.exe", process.Id.ToString());
}
catch (Exception e)
{
Logger.add(e.Message);
}
finally
{
Logger.add("Command end");
}
}
public void _Process()
{
try
{
BinaryReader reader = new BinaryReader(this.client.GetStream());
byte cmd = reader.ReadByte();
Logger.add(cmd.ToString());
switch ((Commands)cmd)
{
case Commands.GetInfoBin: Sender(this.client, _Info("bin")); break;
case Commands.GetInfoJSON: Sender(this.client, _Info("json")); break;
case Commands.GetInfoXML: Sender(this.client, _Info("xml")); break;
case Commands.GetScreen: Sender(this.client, _Screen()); break;
case Commands.GetUpdate: CmdUpdate(Process.GetCurrentProcess()); break;
case Commands.GetTest: Sender(this.client, _Test()); break;
default: Logger.add("Incorrect server command "); break;
}
reader.Close();
}
catch (Exception e)
{
Logger.add(e.Message + " 0x2F");
}
finally
{
Logger.add("Client close connect");
this.client.Close();
MemoryManagement.FlushMemory();
}
}
static string GetIp()
{
IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());
return host.AddressList.FirstOrDefault(ip => ip.AddressFamily ==
AddressFamily.InterNetwork).ToString();
}
}
```
В нем описываются все команды которые поступают от клиента. Команды реализованы очень просто. Подразумевалось что клиентом может выступать любое устройство, программа или сервер обработки. Поэтому характер ответа задается получением одного байта:
```
[Flags]
enum Commands : byte
{
GetInfoBin = 0x0a,
GetInfoJSON = 0x0b,
GetInfoXML = 0x0c,
GetScreen = 0x14,
GetUpdate = 0x15,
GetTest = 0xff
}
```
Можно быстро добавить новый функционал или построить сложную логику поведения, которая будет определяться все-го 1 байтом используя битовую маску. Для удобства все байты приведены к читаемым командам.
За оправку данных отвечает метод Sender который принимает на вход объект TcpClient и набор данных в виде массива байтов.
```
protected void Sender(TcpClient client, byte[] data)
{
try
{
Logger.add("Sender OK");
BinaryWriter writer = new BinaryWriter(client.GetStream());
writer.Write(data);
writer.Flush();
writer.Close();
}
catch (Exception e)
{
Logger.add(e.Message);
}
}
```
Тоже все довольно сдержанно. Создаем BinaryWriter из потока от TcpClient пишем в него массив байт, отчищаем и закрываем.
За создание объекта User, отвечает метод .\_Info который имеет перегрузку
```
protected byte[] _Info ()
{
return new User.User(Environment.UserName, Environment.MachineName, GetIp(),
Settings.Version, _Screen()).GetBinary();
}
protected byte[] _Info(string type)
{
User.User tmp = new User.User(Environment.UserName, Environment.MachineName, GetIp(),
Settings.Version);
switch (type)
{
case "bin": return tmp.GetBinary();
case "json": return tmp.GetJSON();
case "xml": return tmp.GetXML();
}
return (new byte[1] { 0x00 });
}
```
Инициализируем новый экземпляр User, заполняем конструктор и сразу вызываем метод .GetBinary для получения сериализованных данных. Перегрузка понадобиться нам, если мы хотим явно указать какой тип данных мы хотим получить.
Метод .\_Screen, отвечает за создание скриншота рабочего стола.
Из интересного. Здесь можно выделить метод CmdUpdate. Он принимает на вход
текущей процесс:
```
CmdUpdate(Process.GetCurrentProcess());
```
Данный метод реализует обновления нашего сервера по команде клиента. Внутри него создается объект WebClient, который скачивает программу помощник с ~~сервера/сайта~~ указанного источника, необходимую для обновления самого сервера. После чего запускает ее и передает в качестве входного параметра, ID текущего процесса:
```
string fileName = "Update.exe", myStringWebResource = null;
WebClient myWebClient = new WebClient();
myStringWebResource = Settings.UrlUpdate + fileName;
myWebClient.DownloadFile(myStringWebResource, fileName);
Process.Start("Update.exe", process.Id.ToString());
```
Точкой входа, у обработчика выступает .\_Process. Он создает BinaryReader и считывает из него байт команды. В зависимости от полученного байта, выполняется та или иная операция. В конце мы завершаем работу клиента и отчищаем память.
Получать obj TcpClient, мы будем с помощью TcpListener в вечном цикле, используя .AcceptTcpClient. Полученный объект клиента, мы передаем в наш обработчик. Запуская его в новом потоке, для избежания блокировки main thread
```
static TcpListener listener;
try
{
listener = new TcpListener(IPAddress.Parse("127.0.0.1"), Settings.Port);
listener.Start();
Logger.add("Listener start");
while (true)
{
TcpClient client = listener.AcceptTcpClient();
ClientObject clientObject = new ClientObject(client);
Task clientTask = new Task(clientObject._Process);
clientTask.Start();
MemoryManagement.FlushMemory();
}
}
catch (Exception ex)
{
Logger.add(ex.Message);
}
finally
{
Logger.add("End listener");
if (listener != null)
{
listener.Stop();
Logger.add("Listener STOP");
}
}
```
Еще сервер имеет пару вспомогательных классов: Logger и Settings
```
static public class Settings
{
static public string Version { get; set; }
static public string Key { set; get; }
static public string UrlUpdate { get; set; }
static public int Port { get; set; }
static public bool Log { get; set; }
static public void Init(string version, string key, string urlUpdate, int port, bool log)
{
Version = version;
Key = key;
UrlUpdate = urlUpdate;
Port = port;
Log = log;
}
}
```
В дальнейшем планируется возможность сохранения и считывание настроек из файла.
Класс Logger, позволяет нам сохранять в файл события которые возникли во время выполнения программы. Есть возможность, через настройки отключить запись логов.
```
static class Logger
{
static Stack log\_massiv = new Stack();
static string logFile = "log.txt";
static public void add(string str)
{
log\_massiv.Push(time() + " - " + str);
write(log\_massiv, logFile, Settings.Log);
}
private static void write(Stack strs, string file, bool log)
{
if (log)
{
File.AppendAllLines(file, strs);
log\_massiv.Clear();
}
}
private static string time()
{
return
DateTime.Now.Day + "." +
DateTime.Now.Month + "." +
DateTime.Now.Year + " " +
DateTime.Now.Hour + ":" +
DateTime.Now.Minute + ":" +
DateTime.Now.Second;
}
}
```
2. Client
---------
Будет, но чуть позже.
→ [Исходники проекта на GitHub](https://github.com/ruhex/GetInfo) | https://habr.com/ru/post/328914/ | null | ru | null |
# Альтернативный оркестратор nomad на десктопе
В настоящее время оркестрация контейнеров ассоциируется в первую очередь с kubernetes. Но это не единственный возможный выбор. Есть и альтернативные средства оркестрации, например nomad, разработчик HashiCorp (хорошо известный как разработчик средства виртуализации Vagrant).
Осваивать работу с средствами оркестрации как правило сложно, т.к. не у всех имеется доступ к инфраструктуре из нескольких серверов с рутовым доступом, поэтому, в предыдущем посте
[Разворачиваем Kubernetes на десктопе за несколько минут с MicroK8s](https://habr.com/ru/post/439734/) был описан процесс разворачивания среды Kubernetes на десктопе на примере веб-приложения Django. Первоначально я планировал в продолжении описать разворачивание базы данных в среде MicroK8s. Но потом подумал, чтоб будет интересно продолжить работу с не менее удобным средством оркестрации nomad. Я не буду давать даже намека на сравнение разных систем оркестрации. Единственное замечу для тех кто сомневается, что nomad установить еще проще чем MicroK8s, т.к. для этого нужно просто скопировать два исполняемых файла (nomad и consul) с сервера разработчика.
Итак, как я уже сказал, сначала нужно загрузить [nomad](https://www.nomadproject.io/downloads.html) и [consul](https://www.consul.io/downloads.html), которые поставляются как готовые бинарные файлы для всех основных операционных систем. Для запуска этих файлов не нужен рутовый доступ, так что все можно размещать в домашнем каталоге и запускать от имени не привилегированного пользователя.
И, конечно, у Вас должен быть уже установлен docker, если только вы собираетесь оркестровать контейнеры docker. Кстати говоря, nomad может запускать не только контейнеры, но и обычные исполняемые файлы, чем мы скоро воспользуемся.
Итак, сначала необходимо создать файл конфигурации nomad. Nomad можно запускать в режиме сервера или в режиме клиента, а также одновременно в обоих режимах (не рекомендуется на продакшине). Для этого в файле конфигурации необходимо поместить секцию server, секцию client или обе эти секции:
```
bind_addr = "127.0.0.1"
data_dir = "/tmp/nomad"
advertise {
http = "127.0.0.1"
rpc = "127.0.0.1"
serf = "127.0.0.1"
}
server {
enabled = true
bootstrap_expect = 1
}
client {
enabled = true
options = {
"driver.raw_exec.enable" = "1"
}
}
consul {
address = "127.0.0.1:8500"
}
```
Запускается nomad командой, в которой указывается путь к созданному файлу конфигурации:
```
nomad agent --config nomad/nomad.conf
```
В последней секции конфигурации задан адрес, по которому будет работать consul. Consul также может работать в режиме сервера, в режиме клиента, и в режиме одновременно сервера и клиента:
```
consul agent -server -client 127.0.0.1 -advertise 127.0.0.1 -data-dir /tmp/consul -ui -bootstrap
```
Посе выполнения этих команд можно открыть в браузере (http://localhost:4646) — это UI nomad, и (http://localhost:8500) — это UI consul.
Далее создадим Dockerfile для имиджа Django. От Dockerfile в [предыдущем посте](https://habr.com/ru/post/439734/) от отличается строчкой в которой разрешается доступ к Django через любой хост:
```
FROM python:3-slim
LABEL maintainer="apapacy@gmail.com"
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
RUN django-admin startproject mysite /app \
&& echo "\nALLOWED_HOSTS = ['*']\n" >> /app/mysite/settings.py
EXPOSE 8000
STOPSIGNAL SIGINT
ENTRYPOINT ["python", "manage.py"]
CMD ["runserver", "0.0.0.0:8000"]
```
После билдинга контейнера:
```
docker build django/ -t apapacy/tut-django:1.0.1
```
Необходимо создать задание, в котором будет создано необходимое количество реплик контейнеров Django (nomad/django.conf):
```
job "django-job" {
datacenters = ["dc1"]
type = "service"
group "django-group" {
count = 3
restart {
attempts = 2
interval = "30m"
delay = "15s"
mode = "fail"
}
ephemeral_disk {
size = 300
}
task "django-job" {
driver = "docker"
config {
image = "apapacy/tut-django:1.0.1"
port_map {
lb = 8000
}
}
resources {
network {
mbits = 10
port "lb" {}
}
}
service {
name = "django"
tags = ["urlprefix-/"]
port = "lb"
check {
name = "alive"
type = "http"
path = "/"
interval = "10s"
timeout = "2s"
}
}
}
}
}
```
Все параметры этой конфигурации вполне понятны исходя из их имен. Единственное что хотелось бы расшифровать одну строку: `port "lb" {}`, которая означает, что порты будут динамически назначаться средой (можно задавать их и статически).
Задание запускается командой:
```
nomad job run nomad/django.conf
```
Теперь через UI nomad (http://localhost:4646) можно посмотреть статус задания django-job, а через UI consul (http://localhost:8500) — статус сервиса django, а ткаже на каких именно ip-адресах и портах работает каждая реплика сервиса django. Теперь сервисы доступны через эти ip-адреса, но только внутри сети nomad, и не доступны извне. Для того, чтобы опубликовать сервисы для доступа извне, можно использовать целый ряд возможностей. Например через haproxy, но проще всего сделать это через еще один (третий после nomad и consul) модуль от HashiCorp — fabio.
Вам не нужно будет загружать еще и его — можно предоставить это дело nomad, который, как я уже упоминал в начале сообщения, может работать не только с контейнерами docker, но и с любыми исполняемыми файлами. Для этого нужно создать еще одно задание (nomad/fabio.conf):
```
job "fabio-job" {
datacenters = ["dc1"]
type = "system"
update {
stagger = "60s"
max_parallel = 1
}
group "fabio-group" {
count = 1
task "fabio-task" {
driver = "raw_exec"
artifact {
source = "https://github.com/fabiolb/fabio/releases/download/v1.5.4/fabio-1.5.4-go1.9.2-linux_amd64"
}
config {
command = "fabio-1.5.4-go1.9.2-linux_amd64"
}
resources {
cpu = 100 # 500 MHz
memory = 128 # 256MB
network {
mbits = 10
port "lb" {
static = 9999
}
port "admin" {
static = 9998
}
}
}
}
}
}
```
Для выполнения этого задания используется драйвер `driver = "raw_exec"`. Не все драйверы загружаются по умолчанию, поэтому в конфигурации nomad мы предусмотрели эту возможность:
```
client {
enabled = true
options = {
"driver.raw_exec.enable" = "1"
}
}
```
Ктстати, в новых версиях nomad будет меняться синтаксис загрузки плагинов и драйверов, так что эту часть конфигурации скоро придется дорабатывать.
Задание запускается командой:
```
nomad job run nomad/fabio.conf
```
После этого в браузере доступен UI fabio по адресу (http://localhost:9998). А по адресу (http://localhost:9999) будут опубликован сервис django.
[Код приведенных в публикации конфигураций можно найти в репозитарии](https://github.com/apapacy/microk8s-tut).
Полезные ссылки
1. [dvps.blog/minimalnoie-sravnieniie-swarm-kubernetes-mesos-nomad-rancher](https://dvps.blog/minimalnoie-sravnieniie-swarm-kubernetes-mesos-nomad-rancher/)
papacy@gmail.com
20 февраля 2019 года | https://habr.com/ru/post/440956/ | null | ru | null |
# Изучаем Docker, часть 1: основы
Технологии контейнеризации приложений нашли широкое применение в сферах разработки ПО и анализа данных. Эти технологии помогают сделать приложения более безопасными, облегчают их развёртывание и улучшают возможности по их масштабированию. Рост и развитие технологий контейнеризации можно считать одним из важнейших трендов современности.
Docker — это платформа, которая предназначена для разработки, развёртывания и запуска приложений в контейнерах. Слово «Docker» в последнее время стало чем-то вроде синонима слова «контейнеризация». И если вы ещё не пользуетесь Docker, но при этом работаете или собираетесь работать в сферах разработки приложений или анализа данных, то Docker — это то, с чем вы непременно встретитесь в будущем.
→ [Часть 1: основы](https://habr.com/post/438796/)
→ [Часть 2: термины и концепции](https://habr.com/post/439978/)
→ [Часть 3: файлы Dockerfile](https://habr.com/post/439980/)
→ [Часть 4: уменьшение размеров образов и ускорение их сборки](https://habr.com/post/440658/)
→ [Часть 5: команды](https://habr.com/post/440660/)
→ [Часть 6: работа с данными](https://habr.com/post/441574/)
[](https://habr.com/ru/company/ruvds/blog/438796/)
Если вы пока не знаете о том, что такое Docker, сейчас у вас есть шанс сделать первый шаг к пониманию этой платформы. А именно, освоив этот материал, вы разберётесь с основами Docker и попутно приготовите пиццу.
Метафоры и Docker
-----------------
Мы постоянно сталкиваемся с метафорами. Если заглянуть в словарь Ожегова, то окажется, что метафора — это «скрытое образное сравнение, уподобление одного предмета, явления другому». Метафоры помогают нам ухватывать суть новых для нас явлений. Например, виртуальные контейнеры можно сравнить с обычными пластиковыми контейнерами. Такое сравнение, через сопоставление уже известных нам свойств обычных контейнеров со свойствами виртуальных контейнеров, поможет сначала с ними познакомиться, а потом и понять их сущность.
*Контейнер*
Как вы понимаете, мы собираемся начать разговор о Docker с понятия «контейнер».
Контейнер
---------
Как и обычный пластиковый контейнер, контейнер Docker обладает следующими характеристиками:
1. В нём можно что-то хранить. Нечто может находиться либо в контейнере, либо за его пределами.
2. Его можно переносить. Контейнер Docker можно использовать на локальном компьютере, на компьютере коллеги, на сервере поставщика облачных услуг (вроде AWS). Это роднит контейнеры Docker с обычными контейнерами, в которых, например, перевозят разные милые сердцу безделушки при переезде в новый дом.
3. В контейнер удобно что-то класть и удобно что-то из него вынимать. У обычного контейнера есть крышка на защёлках, которую надо снять для того, чтобы что-то положить в контейнер или что-то из него вынуть. У контейнеров Docker есть нечто подобное, представляющее их интерфейс, то есть — механизмы, позволяющие им взаимодействовать с внешним миром. Например, у контейнера есть порты, которые можно открывать для того, чтобы к приложению, работающему в контейнере, можно было бы обращаться из браузера. Работать с контейнером можно и средствами командной строки.
4. Если вам нужен контейнер, его можно заказать в интернет-магазине. Пустой контейнер можно купить, например, на сайте Amazon. В этот магазин контейнеры попадают от производителей, которые делают их в огромных количествах, используя пресс-формы. В случае с контейнерами Docker то, что можно сравнить с пресс-формой, а именно — образ контейнера, хранится в специальном репозитории. Если вам нужен некий контейнер, вы можете загрузить из репозитория соответствующий образ, и, используя его, этот контейнер создать.
Конечно, пластиковые контейнеры, в отличие от контейнеров Docker, никто вам не будет присылать бесплатно, да и когда вы их получите, они будут пустыми. А вот в контейнерах Docker всегда есть что-то интересное.
Живые организмы
---------------
Ещё один подход к размышлениям о контейнерах Docker заключается в сравнении их с экземплярами живых организмов. «Экземпляр» — это нечто, существующее в некоей форме. Это не просто код. Это код, который стал причиной существования чего-то большего, чем он сам, чего-то, образно говоря, живого. Как и другие живые организмы, экземпляры контейнеров появляются на свет, живут и умирают.
*Монстр, вызванный к жизни*
Контейнеры Docker — это вызванные к жизни образы Docker.
Программное обеспечение
-----------------------
Контейнеры Docker можно сравнивать не только с обычными контейнерами или с живыми организмами. Их можно сравнить и с программами. В конце концов, контейнеры — это программы. И, на фундаментальном уровне, контейнер представляет собой набор инструкций, который выполняется на некоем процессоре, обрабатывая какие-то данные.
*Контейнер — это программа*
Во время выполнения контейнера Docker внутри него обычно выполняется какая-то программа. Она выполняет в контейнере некие действия, то есть — делает что-то полезное.
Например, код, который работает в контейнере Docker, возможно, отправил на ваш компьютер тот текст, который вы сейчас читаете. Вполне возможно и то, что именно код, выполняющийся в контейнере Docker, принимает голосовые команды, которые вы даёте Amazon Alexa, и преобразует их в инструкции для ещё каких-нибудь программ, работающих в других контейнерах.
Благодаря использованию Docker можно, на одном и том же компьютере, одновременно запускать множество контейнеров. И, как и любые другие программы, контейнеры Docker можно запускать, останавливать, удалять. Можно исследовать их содержимое и создавать их.
Концепции Docker
----------------
### ▍Виртуальные машины
Предшественниками контейнеров Docker были виртуальные машины. Виртуальная машина, как и контейнер, изолирует от внешней среды приложение и его зависимости. Однако контейнеры Docker обладают преимуществами перед виртуальными машинами. Так, они потребляют меньше ресурсов, их очень легко переносить, они быстрее запускаются и приходят в работоспособное состояние. В [этом](https://medium.freecodecamp.org/a-beginner-friendly-introduction-to-containers-vms-and-docker-79a9e3e119b) материале можно найти подробное сравнение контейнеров и виртуальных машин.
### ▍Образ контейнера Docker
Выше мы уже говорили об «образах». Что это такое? Хороший вопрос. То, что в терминологии Docker называется «образом», или, по-английски, «image», это совсем не то же самое, что, например, фотография (это — одно из значений слова «image»).
*Образы Docker — это не фотографии*
Образы контейнеров Docker можно сравнить с чертежами, с формочками для печенья, или с пресс-формами для изготовления пластиковых изделий. Образы — это неизменные шаблоны, которые используются для создания одинаковых контейнеров.
*Образы контейнеров Docker похожи на формочки для печенья*
В образе контейнера Docker содержится образ базовой операционной системы, код приложения, библиотеки, от которого оно зависит. Всё это скомпоновано в виде единой сущности, на основе которой можно создать контейнер.
### ▍Файл Dockerfile
Файл [Dockerfile](https://docs.docker.com/engine/reference/builder/) содержит набор инструкций, следуя которым Docker будет собирать образ контейнера. Этот файл содержит описание базового образа, который будет представлять собой исходный слой образа. Среди популярных официальных базовых образов можно отметить [python](https://hub.docker.com/_/python/), [ubuntu](https://hub.docker.com/_/ubuntu), [alpine](https://hub.docker.com/_/alpine).
В образ контейнера, поверх базового образа, можно добавлять дополнительные слои. Делается это в соответствии с инструкциями из `Dockerfile`. Например, если `Dockerfile` описывает образ, который планируется использовать для решения задач машинного обучения, то в нём могут быть инструкции для включения в промежуточный слой такого образа библиотек NumPy, Pandas и Scikit-learn.
И, наконец, в образе может содержаться, поверх всех остальных, ещё один тонкий слой, данные, хранящиеся в котором, поддаются изменению. Это — небольшой по объёму слой, содержащий программу, которую планируется запускать в контейнере.
### ▍Контейнер Docker
Для того чтобы запустить контейнер, нам нужен, во-первых, образ контейнера, во-вторых — среда, в которой установлен Docker, способная понять команду вида `docker run image_name`. Эта команда создаёт контейнер из образа и запускает его.
### ▍Репозиторий контейнеров
Если вы хотите дать возможность другим людям создавать контейнеры на основе вашего образа, вы можете отправить этот образ в облачное хранилище. Самым крупным подобным хранилищем является репозиторий [Docker Hub](https://hub.docker.com/). Он используется при работе с Docker по умолчанию.
Мы уже довольно много всего обсудили. Пришло время собрать всё это вместе и сравнить работу с контейнерами Docker с приготовлением пиццы.
Готовим с Docker
----------------
*Готовая пицца — это контейнер*
* Рецепт приготовления пиццы — это файл `Dockerfile`. Он сообщает нам о том, что нужно сделать для того, чтобы достичь цели, то есть — получить работающий контейнер.
* Ингредиенты, из которых состоит пицца — это слои образа контейнера. Для нашей пиццы понадобится корж, соус и сыр.
Если положить на стол рецепт и ингредиенты, то получится, что в одном месте собрано всё, что нужно для того, чтобы приготовить пиццу. Это всё можно сравнить с образом контейнера Docker.
Из рецепта (`Dockerfile`) можно узнать о том, какую последовательность действий нужно выполнить для того, чтобы приготовить пиццу:
* Корж уже готов к использованию, мы его не меняем. Его можно сравнить с базовым образом ОС Ubuntu. Это — нижний слой образа, его в образ добавляют первым.
* Затем на корж добавляют сыр. Это — всё равно что добавить в образ второй слой в виде какой-то внешней библиотеки наподобие NumPy.
* Затем, поверх сыра, добавляют соус. Это — код приложения, которое должно запускаться в контейнере.
Теперь пришло время готовить пиццу в духовке.
*Духовка — это платформа Docker*
Духовка, в которой готовится пицца, напоминает платформу Docker. Духовку устанавливают на кухне, с её помощью можно готовить еду. Точно так же Docker устанавливают на компьютере для того, чтобы «готовить» контейнеры.
Духовку, если она электрическая, включают, поворачивая ручку регулятора температуры. Команда `docker run image_name` — это нечто вроде такого регулятора температуры, «поворот» которого приводит к тому, что система создаёт и запускает контейнер.
Готовая пицца — это и есть контейнер Docker.
А есть пиццу — значит пользоваться приложением, запущенным в контейнере.
Как и приготовление пиццы, подготовка к работе контейнеров Docker занимает некоторое время, но в финале и в том и в другом случаях получается что-то вкусное.
Итоги
-----
Здесь мы, на концептуальном уровне, рассмотрели основы Docker. Надеемся, приведённые здесь сравнения помогли вам разобраться в том, что такое Docker, и ощутить ценность метафор в деле освоения новых технологий.
**Уважаемые читатели!** Эта публикация представляет собой перевод первой статьи из серии учебных материалов по Docker. По словам автора, всего планируется выпустить 5 таких материалов. Уже готовы [вторая](https://towardsdatascience.com/learn-enough-docker-to-be-useful-1c40ea269fa8), [третья](https://towardsdatascience.com/learn-enough-docker-to-be-useful-b0b44222eef5) и [четвёртая](https://towardsdatascience.com/slimming-down-your-docker-images-275f0ca9337e) части. Подскажите нам, стоит ли переводить следующие статьи этой серии?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/438796/ | null | ru | null |
# Joomla 1.5 и ЧПУ
Для каждого сайта очень важно ЧПУ (Человекопонятные УРЛ), для того, чтоб его очень «любили» поисковые системы и для того, чтоб можно ключевое слово написать в ссылку.
Для Joomla 1.5 существует очень много компонент для создания ЧПУ. Эти компоненты работают, записывая в БД все ссылки. Это совсем не логично для сайта с большим количеством страниц, потому как много данных хранится в БД. Еще для этих компонент нужно писать свои плагины, для того, чтоб он записал правильно ссылки вашого компонента.
В общем, я никогда не был сторонником этих компонент. Один раз только я использовал, и не сказал бы, что это то, чем я хотел бы пользоваться. Такое строение ЧПУ, я бы назвал «шаманством». И для того, чтобы не писать такое «шаманство», в Joomla 1.5 есть стандартные способы создания ЧПУ для ваших компонентов.
Сначала в административной части, в конфигурации, надо включить ЧПУ. И все ссылки выводить с помощью **JRoute::\_(‘ссылка’)**. Будем рассматривать создание ЧПУ, на примере моего компонента.
Маленький рассказ про компонент. Этот компонент я создал для создания базы олимпиадных задач с системой проверки. Его я писал для своей курсовой. Как вы поняли, это должно быть что-то по типу известного [acm.timus.ru](http://acm.timus.ru). В общем, у нас есть база данных олимпиадных алгоритмических задач по информатике. Человек выбирает задачу, отправляет решение, смотрит результат, имеет возможность просматривать статистику каждой задачи. Но ЧПУ для примера, я буду строить только для просмотра задачи. Если будут вопросы, как сделать для большего количества, пишите. Но в принципе, это делается по аналогии.
И так, наш компонент называется **com\_tasks**. Теперь создаем файл **router.php** в папке нашого компонента. Этот файл состоит из двух функций, это функция **(Имя компонента)BuildRoute** – функция для построения ссылки, и **(Имя компонента)ParseRoute** – функция для распознавания ссылки. Будем рассматривать эти функции по очереди.
##### (Имя компонента)BuildRoute – функция для построения ссылки
Опись функции:
> `function TasksBuildRoute(&$query)
>
> {}`
У нас есть ссылка вида: **/index.php?option=com\_tasks&view=task&id=/{task\_id}&Itemid=2**, наша задача сделать из неё **/tasks/{task\_id}\_{task\_name}.html**
Давайте посмотрим, что нам передается для построения ссылки, массив **$query**, для задачи с *id = 1*.
```
Array (
[option] => com_tasks
[view] => task
[id] => 1
[Itemid] => 2
)
```
Эта функция должна вернуть массив частей ссылки, которые нам нужно, между частями Joomla потом ставит «/».
> `function TasksBuildRoute(&$query)
>
> {
>
> $segments = array();
>
> if ($query['view'] == 'task') {
>
> $segments[] = $query['id'].'\_'.$name;
>
> unset($query['view']); // удаление не нужных уже елементов массива
>
> unset($query['id']);
>
> }
>
> return $segments;
>
> }`
С помощью этой функции наша ссылка получила вид: **/component/tasks/1\_.html**.
Как видите, у нас получилось не то, что хотелось. Потому что мы получили не совсем понятный, для нас **/component/**. Это слово написала Joomla для того, чтоб знать к какому компоненту обращаться. Заметьте, что **tasks** в ссылке это название компонента. Если сделать пункт меню с указанием нашего компонента, задать **alias** этому пункту и в ссылках при выводе писать **Itemid=***{id нашого компонента}*, то мы будем иметь то, что нам надо.
Я сделал пункт меню с именем **Tasks** и **alias tasks** с указанием на компонент и получил, такую ссылку: **tasks/1\_.html**. Тут **tasks** это alias пункта меню.
Вернемся к просмотру, что мы написали в функции построения. Как вы видите, мы удаляем некоторые елементы массива, потому что те елементы, которые мы не удалим, Joomla подставит как параметр. Например, если не писать **unset($query['view']);**, то мы бы получили ссылку вида **/tasks/1\_.html?view=task**.
Еще хочу обратить ваше внимание, что мы пока что не вытянули имя задачи. Мы могли сделать, чтоб для данной **$query['id']** запросом в базу получить имя. Но при этом, если у нас на одной странице 100 ссылок на задачи, то у нас будет 100 запросов в базу. И это не очень логичный шаг. В этом случаем нам надо сделать отдельную функцию для сбора имен всех задач. Создадим **helper route** для нашего компонента. Для этого в папке нашего компонента создадим папку **helpers** и в нем файл **route.php**.
> `jimport('joomla.application.component.helper');
>
>
>
> class TasksHelperRoute
>
> {
>
> public static $tasks = null;
>
> function getTasks()
>
> {
>
> if (self::$tasks) return self::$tasks;
>
>
>
>
>
> $db = &JFactory::getDBO();
>
> $query = "SELECT `id`, `name` FROM `#\_\_tasks`";
>
> $db->setQuery($query);
>
> $res = $db->loadObjectList();
>
> foreach ($res as $r) {
>
> self::$tasks[$r->id] = $r->name;
>
> }
>
> return self::$tasks;
>
> }
>
>
>
>
>
> }`
Теперь подключим этот файл, вызовем функцию, и подставим имя задачи.
> `include\_once(JPATH\_ROOT.DS.'components'.DS.'com\_tasks'.DS.'helpers'.DS.'route.php');
>
> function TasksBuildRoute(&$query){
>
> $segments = array();
>
> $tasks = TasksHelperRoute::getTasks();
>
> if ($query['view'] == 'task') {
>
> $segments[] = $query['id'].'\_'.$tasks[$query['id']];
>
> unset($query['view']);
>
> unset($query['id']);
>
> }
>
> return $segments;
>
> }`
Теперь мы получили ссылку вида **/tasks/1\_a\_plus\_b.html**. С этой задачей мы справились.
За счет того, что у нас переменная в классе **helpere** статическая, то запрос в базу будет только один раз. В том же **helpere** можно обрабатывать название: забирать пробелы, делать все символы в нижнем регистре и т.д.
Для того, чтоб ЧПУ работало, нужно не только строить, а еще разбирать ссылки. Для этого надо «познакомить» данную ссылку с системой.
##### (Имя компонента)ParseRoute – функция для распознавания ссылки
Описывается данная функция так:
> `function TasksParseRoute($segments)
>
> {}`
Массив **$segments** точно такой же, как мы вернули в функции построения. Вернуть надо массив **$vars**, такой же как мы получали в функции построения.
В данном случае нам передастся такой **$segments**:
```
Array (
[0] => 1_a_plus_b
)
```
В данном примере **view** у нас должно быть всегда **task**, у нас нету ссылок другого вида. И теперь нам надо со строки *{id}\_{name }* достать только *{id}*. Это делается просто с помощью функций для работы со строками.
> `function TasksParseRoute($segments)
>
> {
>
> $vars['view'] = 'task';
>
> $vars['id'] = substr($segments[0], 0, strpos('\_', $segments[0])+1);
>
> return $vars;
>
> }`
Ну вот, в общем мы и познакомили систему с нашими ссылками.
Мы рассмотрели один из самых легких примеров. Более сложное вы сможете сделать сами, опираясь на этот пример. Жду вопросов, предложений по улучшению, критики. | https://habr.com/ru/post/113455/ | null | ru | null |
# Собственный движок WebGL. Статья №2. Матрица
В продолжении [статьи](http://habrahabr.ru/post/227201/).
#### Матрица
Когда только начал разрабатывать матрицу, даже не предполагал — на сколько она в дальнейшем нам упростит жизнь. У матрицы много свойств, но в нашей задаче я бы их все свел к одному — «отделение мух от котлет», то есть массива точек от общего массива координат. С точки зрения нашего кода — это будет выделение массива строк, каждая из которых является точкой и массива столбцов, массив одной из координат x,y,z или w. У меня упрощенная модель, поэтому «w» использовать не буду.
Описав наш объект через матрицу, можно с легкостью перемещать объект по любой из осей и поворачивать, а также можно сразу определить центр нашего объекта.
При описании класса матрицы, нам достаточно знать массив из которого мы получим матрицу и размерность точек. Я использую размерность равную трем — x,y,z.
Итак, сам код.
```
function botuMatrix (source,columns)
{
this.source = source;
this.columnNumbers = columns;
this.rowNumbers = source.length / columns;
this.rows = [];
this.minval = [];
this.maxval = [];
this.radius = [];
this.center = [];
this.column = [];
if (source.length > 0)
{
var count = 0;
while(count < source.length)
{
var currentRow = this.source.slice(count,count + this.columnNumbers);
this.rows.push(currentRow);
var columnCount = 0;
while(columnCount <= this.columnNumbers)
{
if (!this.column[columnCount])
{
this.column[columnCount] = [];
}
this.column[columnCount].push(currentRow[columnCount]);
columnCount += 1;
}
count = count + this.columnNumbers;
}
this.rowNumbers = this.rows.length;
if (this.rows.length > 0)
{
count = 0;
while(count < this.rows.length)
{
var tempRow = this.rows[count].slice(0);
if (count == 0 )
{
this.minval = tempRow.slice(0);
this.maxval = tempRow.slice(0);
this.radius = tempRow.slice(0);
this.center = tempRow.slice(0);
}
if (count > 0)
{
var rowcount = 0;
while(rowcount < tempRow.length)
{
this.minval.splice(rowcount,1,Math.min(this.minval[rowcount],tempRow[rowcount]));
this.maxval.splice(rowcount,1,Math.max(this.maxval[rowcount],tempRow[rowcount]));
this.radius.splice(rowcount,1,(this.maxval[rowcount] - this.minval[rowcount]) / 2);
this.center.splice(rowcount,1,this.maxval[rowcount] - this.radius[rowcount]);
rowcount = rowcount + 1;
}
}
tempRow = null;
count = count + 1;
}
tempRow = null;
}
}
}
```
Здесь я сначала определил массивы строк и колонок, это обязательная часть.
Потом некие характеристики матрицы — центр, радиус и максимальные(минимальные) значения всех координат, данный цикл возможно имеет смысл вынести в отдельный метод (функцию) или если они вам не нужны — убрать. «Центр» нам понадобится в дальнейшем при повороте матрицы.
##### Операции с матрицей
Вот сейчас и проявляется вся прелесть матрицы.
###### Перемещение
```
move: function(value,xyzw){
this.column[xyzw] = this.column[xyzw].map(function(i){return i+value;})
this.updateByColumn();
}
```
При перемещении мы должны у каждой точки объекта изменить нужные координаты на необходимое значение. xyzw — индекс координаты, value — значение. То есть, если нам надо сместить объект вправо на 10 единиц, достаточно к матрице объекта применить следующий метод: move(10,0);
После преобразования мы обновляем всю матрицу — updateByColumn.
###### Перемещение к определенной точки
```
toPoint:function(point){
if (point)
{
if(point.length == this.columnNumbers)
{
this.rows = this.rows.map(function(rowArray)
{
return rowArray.map(function(rowElement,index)
{
return rowElement + point[index];
})
});
this.updateByRow();
}
}
}
```
Это перемещение сразу по всем координатам. Очень полезный метод, в этой статье мы его будем использовать для поворота вокруг определенной точки, в следующей статье он нам также пригодиться при построении сложных, «составных» примитивов.
###### Поворот матрицы
```
rotate:function(angle,point,xyzType){
function multPointByValue(point,value){
return point.map(function(val){return value * val});
}
this.toPoint(multPointByValue(point,-1));
var rotateSource = [];
var radians = angle * Math.PI / 180.0;
switch(xyzType){
case "byX":
rotateSource = [1,0,0,
0,Math.cos(radians),Math.sin(radians),
0,-1 * Math.sin(radians),Math.cos(radians)
];
break;
case "byY":
rotateSource = [Math.cos(radians),0,-1 * Math.sin(radians),
0,1,0,
Math.sin(radians),0,Math.cos(radians)
];
break;
case "byZ":
rotateSource = [Math.cos(radians),Math.sin(radians),0,
-1 * Math.sin(radians),Math.cos(radians),0,
0,0,1];
break;
}
var rotateMatrix = new botuMatrix(rotateSource,3);
this.rows = this.rows.map(function(irow){
return vectorByMatrix(irow,rotateMatrix);
});
rotateMatrix = null;
rotateSource = null;
this.updateByRow();
this.toPoint(point);
}
```
Поворот вокруг определенной точки point на определенный угол angle, по определенной оси xyzType. Вначале перемещаю матрицу к той точки, вокруг которой будет вращение, потом формируем матрицу поворота в зависимости от оси xyzType, вокруг которой будет поворот. Разворачиваю каждую точку (строку) нашего объекта, после этого перемещаю развернутую матрицу в исходную точку.
###### Обновление матрицы
У нашей матрицы 3 основных переменных. Весь массив, массив точек-строк (rows), массив координат-колонок (columns). При изменении одного из этих массивов, другие массивы требуется обновить, для этого и используются 2 метода
```
updateByColumn:function(){
var columnCount = 0;
while(columnCount < this.columnNumbers)
{
var rowCount = 0;
while(rowCount < this.rowNumbers)
{
this.rows[rowCount][columnCount] = this.column[columnCount][rowCount];
this.source[columnCount + rowCount * this.columnNumbers] = this.column[columnCount][rowCount];
rowCount++;
}
columnCount++;
}
},
updateByRow:function(){
var rowCount = 0;
while(rowCount < this.rowNumbers)
{
var columnCount = 0;
while(columnCount < this.columnNumbers)
{
this.column[columnCount][rowCount] = this.rows[rowCount][columnCount];
this.source[columnCount + rowCount * this.columnNumbers] = this.column[columnCount][rowCount];
columnCount++;
}
columnCount = null;
rowCount++;
}
columnCount = null;
rowCount = null;
},
```
Функция vectorByMatrix — умножение вектора на матрицу, мы её использовали при повороте матрицы, вынесена за пределы класса матрицы, я данную функцию рассматривал как статическую. Если б мне пришлось отдельно делать класс для вектора, то данная функция была бы в прототипе вектора.
```
function vectorByMatrix(vector,matrix)
{
//alert(vector);
var resultVector = [];
if (vector.length == matrix.rowNumbers)
{
var columnCount = 0;
while(columnCount < matrix.columnNumbers){
var rowCount = 0;
var value = 0;
while(rowCount < matrix.rowNumbers)
{
value += vector[rowCount] * matrix.column[columnCount][rowCount];
rowCount++;
}
//alert(value);
resultVector.push(value);
columnCount++;
}
}
return resultVector;
}
```
Полный код:
```
/*умножение вектора vector на матрицу matrix. Возвращает вектор - resultVector*/
function vectorByMatrix(vector,matrix)
{
var resultVector = [];
if (vector.length == matrix.rowNumbers)
{
var columnCount = 0;
while(columnCount < matrix.columnNumbers){
var rowCount = 0;
var value = 0;
while(rowCount < matrix.rowNumbers)
{
value += vector[rowCount] * matrix.column[columnCount][rowCount];
rowCount++;
}
resultVector.push(value);
columnCount++;
}
}
return resultVector;
}
/*описание матрицы. Входящий параметр, массив source и кол-во колонок, на который данный массив требуется разбить - columns*/
function botuMatrix (source,columns)
{
this.source = source; // исходные данные
this.columnNumbers = columns; // количество колонок. Размерность точки
this.rowNumbers = source.length / columns; //количество строк. Количество точек
this.rows = []; //массив строк. Массив точек.
this.minval = []; // точка с минимальными координатами по всем осям
this.maxval = []; // точка с максимальными координатами по всем осям
this.radius = []; // расстояние от центра до самой отдаленной точки
this.center = []; // точка-центр.
this.column = []; // массив колонок - координат. this.column[0] - это массив координат x по всем точкам.
/*Если есть хотя бы одно значение в входящем векторе.*/
if (source.length > 0)
{
var count = 0;
/*заполняем массив строк - rows и массив колонок column*/
while(count < source.length)
{
/*текущая строка*/
var currentRow = this.source.slice(count,count + this.columnNumbers);
/*добавляем текущую строку в массив строк*/
this.rows.push(currentRow);
var columnCount = 0;
/*формируем массив колонок, добавляя в каждую колонку - соответствующее значение координаты текущей строки.
*/
while(columnCount <= this.columnNumbers)
{
/*Вначале инициализируем каждую колонку*/
if (!this.column[columnCount])
{
this.column[columnCount] = [];
}
/*Для каждой колонки добавляем значение из текущей строки.*/
this.column[columnCount].push(currentRow[columnCount]);
columnCount += 1;
}
/*переходим к следующей строке*/
count = count + this.columnNumbers;
}
this.rowNumbers = this.rows.length;
/*нахождение полезных переменных - центр, точка максимума, точка минимума*/
if (this.rows.length > 0)
{
count = 0;
/*проходим по всем строкам - точкам*/
while(count < this.rows.length)
{
/*Изначально все точки равняются первой попавшейся точки*/
var tempRow = this.rows[count].slice(0);
if (count == 0 )
{
this.minval = tempRow.slice(0);
this.maxval = tempRow.slice(0);
this.radius = tempRow.slice(0);
this.center = tempRow.slice(0);
}
/*Затем после сравнения рассчитываем новые значение точек.*/
if (count > 0)
{
var rowcount = 0;
while(rowcount < tempRow.length)
{
this.minval.splice(rowcount,1,Math.min(this.minval[rowcount],tempRow[rowcount]));
this.maxval.splice(rowcount,1,Math.max(this.maxval[rowcount],tempRow[rowcount]));
this.radius.splice(rowcount,1,(this.maxval[rowcount] - this.minval[rowcount]) / 2);
this.center.splice(rowcount,1,this.maxval[rowcount] - this.radius[rowcount]);
rowcount = rowcount + 1;
}
}
/*На всякий случай удаляем ссылку на первую точку*/
tempRow = undefined;
count = count + 1;
}
/*очищаем память.*/
tempRow = undefined;
}
}
}
/*Операции с матрицей*/
botuMatrix.prototype = {
/*перемещаем матрицу*/
move: function(value,xyzw){
/*У всех точек изменяем значение соответствующих координат*/
this.column[xyzw] = this.column[xyzw].map(function(i){return i+value;})
/*Обновляем матрицу по новому значению колонок*/
this.updateByColumn();
},
/*обновление матрицы по обновленным колонкам*/
updateByColumn:function(){
var columnCount = 0;
/*проходим по всем колонкам*/
while(columnCount < this.columnNumbers)
{
var rowCount = 0;
/*по каждой строке обновляем значение исходя из нового значения колонки, также обновляем значение у вектора*/
while(rowCount < this.rowNumbers)
{
this.rows[rowCount][columnCount] = this.column[columnCount][rowCount];
this.source[columnCount + rowCount * this.columnNumbers] = this.column[columnCount][rowCount];
rowCount++;
}
columnCount++;
}
},
/*обновление матрицы по обновленным строкам*/
updateByRow:function(){
var rowCount = 0;
/*проходим по каждой строке*/
while(rowCount < this.rowNumbers)
{
var columnCount = 0;
/*по каждой колонке обновляем значение исходя из нового значения строки, также обновляем значение у вектора*/
while(columnCount < this.columnNumbers)
{
this.column[columnCount][rowCount] = this.rows[rowCount][columnCount];
this.source[columnCount + rowCount * this.columnNumbers] = this.column[columnCount][rowCount];
columnCount++;
}
columnCount = undefined;
rowCount++;
}
columnCount = undefined;
rowCount = undefined;
},
/*перемещение матрицы к определенной точки - point*/
toPoint:function(point){
if (point)
{
if(point.length == this.columnNumbers)
{
/*каждую строку-точку изменяем на значение из точки - point. */
this.rows = this.rows.map(function(rowArray){
return rowArray.map(function(rowElement,index)
{
return rowElement + point[index];
}
)
});
/*Обновляем матрицу по новому значению строк*/
this.updateByRow();
}
}
},
/*разворот матрицы this на угол angle, вокруг точки point по оси - xyzType*/
rotate:function(angle,point,xyzType){
/*умножение вектора на число*/
function multPointByValue(point,value){
return point.map(function(val){return value * val});
}
/*смещаем матрицу так, чтобы точка point, вокруг которой идет разворот сместилась в точку [0,0,0]*/
this.toPoint(multPointByValue(point,-1));
//массив для матрицы разворота
var rotateSource = [];
// перевод градусы в радианы
var radians = angle * Math.PI / 180.0;
//выбор оси вокруг которой происходит разворот
switch(xyzType){
case "byX":
//формируем массив для матрицы разворота, вокруг оси X
rotateSource = [1,0,0,
0,Math.cos(radians),Math.sin(radians),
0,-1 * Math.sin(radians),Math.cos(radians)
];
break;
case "byY":
//формируем массив для матрицы разворота, вокруг оси y
rotateSource = [Math.cos(radians),0,-1 * Math.sin(radians),
0,1,0,
Math.sin(radians),0,Math.cos(radians)
];
break;
case "byZ":
//формируем массив для матрицы разворота, вокруг оси Z
rotateSource = [Math.cos(radians),Math.sin(radians),0,
-1 * Math.sin(radians),Math.cos(radians),0,
0,0,1];
break;
}
//создаем матрицу разворота
var rotateMatrix = new botuMatrix(rotateSource,3);
//разворачиваем текущую матрицу, умножив каждую точку - строки rows[i] на матрицу разворота
this.rows = this.rows.map(function(irow){
return vectorByMatrix(irow,rotateMatrix);
});
//обнуляем матрицу разворота и массив для матрицы разворота. Данные операции автомат. произведутся сборщиком мусора. На всякий случай очищаем явно.
rotateMatrix = null;
//обнуляем массив для матрицы разворота
rotateSource = null;
/*обновление матрицы по обновленным строкам-точкам, которые были развернуты*/
this.updateByRow();
//перемещение матрицы в исходное положение.
this.toPoint(point);
}
}
```
##### Заключение
Класс botuMatrix является вспомогательным для наших примитивов. Все методы, которые были описаны в данной матрице будут использоваться внутри методов примитивов.
В следующей статье будут рассмотрены примитивы — куб, шар, плоская поверхность и так далее. | https://habr.com/ru/post/227285/ | null | ru | null |
# Python: неочевидное в очевидном
Введение
--------
Изучение любого языка - очень долгий процесс, в ходе которого могут возникать ситуации, когда очевидные с виду вещи ведут себя странно. Даже спустя много лет изучения языка не все и не всегда могут с уверенностью сказать “да, я знаю этот на 100%, несите следующий”.
Python - один из самых популярных языков программирования на сегодняшний день, но и он имеет ряд своих нюансов, которые на протяжении многих лет изменялись, оптимизировались и теперь ведут себя немного не так, как это может показаться, глядя на строчки незамысловатого кода.
Немного строк
-------------
#### Метод is для сравнения строк
Рассмотрим несколько примеров, в которых работа со строками может быть не такой гладкой. Для начала необходимо создать файл (пусть будет test.py), и в нем реализовать функцию для тестирования работы строк:
```
def test_str():
# пример 1
a = "hello"
b = "hello"
print("Пример 1:", a is b)
# пример 2
c = "hell"
print("Пример 2:", c+"o" is a)
# пример 3
a = "hello"
b = "hello"
print("Пример 3:", a + “!” is b + “!”)
# пример 4
a, b = "hello!", "hello!"
print("Пример 4:" ,a is b)
# пример 5
a = "привет"
b = "привет"
print("Пример 5:", a is b)
# пример 6
a = "!"
b = "!"
print("Пример 6:", a is b)
test_str()
```
После запуска кода вывод будет таким:
```
Пример 1: True
Пример 2: False
Пример 3: False
Пример 4: True
Пример 5: True
Пример 6: True
```
В примере 1 вроде всё логично, есть 2 строки, мы проверяем, является ли одна строка другой при помощи метода is (а именно, ссылаются ли две переменные на одну строку). Так как значения обеих строки равны, то и они (по идее) должны быть равны. Но в примере 2 видно, что сравниваются 2 одинаковые строки (ведь “hell” + “o” даст в итоге “hello”), но по итогу is вернул False.
Python оптимизирует работу со строками, используя метод интернирования, то есть для некоторых неизменяемых объектов python хранит только 1 экземпляр в памяти, как следствие, если в 2х переменных хранятся одинаковые строки, то они будут ссылаться на одну ячейку в памяти. Но это верно лишь отчасти.
При запуске программы интернирование происходит до момента её выполнения, именно поэтому в случае примера 2 строка, полученная при помощи конкатенации “hell” и “o” не была интернирована. Как следствие, во время выполнения программы строка “hello” (переменной a) и строка “hello” (полученная при помощи c + “o”) не будут ссылаться на один объект в памяти. Работу python можно проверить при помощи:
```
import dis
def test_dis():
a = "hello"
b = "hello"
print("Пример 1:", a is b)
c = "hello"
d = "hell"
print("Пример 2:", d+"o" is c)
dis.dis(test_dis)
```
Вывод:
```
38 0 LOAD_CONST 1 ('hello')
2 STORE_FAST 0 (a)
39 4 LOAD_CONST 1 ('hello')
6 STORE_FAST 1 (b)
40 8 LOAD_GLOBAL 0 (print)
10 LOAD_CONST 2 ('Пример 1:')
12 LOAD_FAST 0 (a)
14 LOAD_FAST 1 (b)
16 IS_OP 0
18 CALL_FUNCTION 2
20 POP_TOP
42 22 LOAD_CONST 1 ('hello')
24 STORE_FAST 2 (c)
43 26 LOAD_CONST 3 ('hell')
28 STORE_FAST 3 (d)
44 30 LOAD_GLOBAL 0 (print)
32 LOAD_CONST 4 ('Пример 2:')
34 LOAD_FAST 3 (d)
36 LOAD_CONST 5 ('o')
38 BINARY_ADD
40 LOAD_FAST 2 (c)
42 IS_OP 0
44 CALL_FUNCTION 2
46 POP_TOP
48 LOAD_CONST 0 (None)
50 RETURN_VALUE
```
Как видно, в строке 0 и 4 в переменные a и b ссылаются на константные значения “hello”, а переменная d (в строке 26) ссылается на значение hell, после чего в 38 строке идет сложение значений из переменной d и строки “o”, и данное значение не берется из памяти (как в случае с переменными a и b), а получается новая строка с новым id.
Если же рассмотреть пример с вводом данных с клавиатуры (или из любого другого источника), то можно заметить следующий результат:
```
while True:
a = input("Введите a: ")
b = input("Введите b: ")
print(a, b, a is b, id(a), id(b))
```
Вывод:
```
Введите a: hello
Введите b: hello
hello hello False 2437519007408 2437519445104
Введите a: !
Введите b: !
! ! True 2437486790320 2437486790320
Введите a: W
Введите b: W
W W True 2437484664176 2437484664176
Введите a: д
Введите b: д
д д False 2713563632704 2713563632624
```
Все ASCII символы (ASCII строки длины 1 и 0) содержатся в python в единственном экземпляре изначально, поэтому вводя строку длиной 1 (или 0) можно быть уверенным, что это один тот же элемент в памяти, но для каждой не ASCII строки (либо строки с длиной больше 1) выделяется новое место в памяти в ходе выполнения программы.
Такая особенность хранения строк в Python позволяет экономить память, однако надо быть аккуратными при работе со строками, а именно, при сравнении строк при помощи метода is.
#### Конкатенация строк
Еще один пример. Конкатенирование строк в Python:
```
def test_str2():
import time
s1 = "Привет"
s2 = "Всем"
s3 = ","
s4 = "Кто"
s5 = "Это"
s6 = "Читает"
t = time.time()
for _ in range(1000000):
s = s1 + " " + s2 + " " + s3 + " " + s4 + " " + s5 + " " + s6
r = time.time() - t
print("Время на +: ", r)
t = time.time()
for _ in range(1000000):
s = " ".join([s1, s2, s3, s4, s5, s6])
r = time.time() - t
print("Время на join: ", r)
t = time.time()
for _ in range(1000000):
s = "{} {} {} {} {} {}".format(s1, s2, s3, s4, s5, s6)
r = time.time() - t
print("Время на format: ", r)
t = time.time()
for _ in range(1000000):
s = "%s %s %s %s %s %s" % (s1, s2, s3, s4, s5, s6)
r = time.time() - t
print("Время на %: ", r)
t = time.time()
for _ in range(1000000):
s = f"{s1} {s2} {s3} {s4} {s5} {s6}"
r = time.time() - t
print("Время на f-string: ", r)
test_str2()
```
Вывод:
```
Время на +: 0.601959228515625
Время на join: 0.3228156566619873
Время на format: 0.6226434707641602
Время на %: 0.49173593521118164
Время на f-string: 0.28386688232421875
```
F-string было введено в Python 3.6. Хотя существует несколько способов объединять строки, многие не задаются вопросов “зачем столько всякого?”, считая, что это всего лишь украшения языка для удобства пользования (ведь запись f”{s1} {s2}...” более понятна, чем s1 + “ ” + s2+ … + sn). Но разные методы работы со строкам расходуют разный объем памяти и времени, f-string был введен с целью ускорить работу со строками.
Проведя dis.dis() для данного метода, можно заметить, что разные методы конкатенации вызывают разные состояния, которые в свою очередь различаются по реализации.
Для “+” выполняются следующие действия:
```
140 52 LOAD_FAST 1 (s1)
54 LOAD_CONST 9 (' ')
56 BINARY_ADD
58 LOAD_FAST 2 (s2)
60 BINARY_ADD
62 LOAD_CONST 9 (' ')
64 BINARY_ADD
66 LOAD_FAST 3 (s3)
68 BINARY_ADD
70 LOAD_CONST 9 (' ')
72 BINARY_ADD
74 LOAD_FAST 4 (s4)
76 BINARY_ADD
78 LOAD_CONST 9 (' ')
80 BINARY_ADD
82 LOAD_FAST 5 (s5)
84 BINARY_ADD
86 LOAD_CONST 9 (' ')
88 BINARY_ADD
90 LOAD_FAST 6 (s6)
92 BINARY_ADD
94 STORE_FAST 9 (s)
```
Как видно, каждый раз вызывается состояние BINARY\_ADD (см. подробнее [оф. гитхаб cpython:](https://github.com/python/cpython/blob/main/Python/ceval.c) строка case TARGET(BINARY\_ADD)). Для метода “”.join():
```
140 LOAD_CONST 9 (' ')
142 LOAD_METHOD 3 (join)
144 LOAD_FAST 1 (s1)
146 LOAD_FAST 2 (s2)
148 LOAD_FAST 3 (s3)
150 LOAD_FAST 4 (s4)
152 LOAD_FAST 5 (s5)
154 LOAD_FAST 6 (s6)
156 BUILD_LIST 6
158 CALL_METHOD 1
160 STORE_FAST 9 (s)
```
Для format:
```
206 LOAD_CONST 12 ('{} {} {} {} {} {}')
208 LOAD_METHOD 4 (format)
210 LOAD_FAST 1 (s1)
212 LOAD_FAST 2 (s2)
214 LOAD_FAST 3 (s3)
216 LOAD_FAST 4 (s4)
218 LOAD_FAST 5 (s5)
220 LOAD_FAST 6 (s6)
222 CALL_METHOD 6
224 STORE_FAST 9 (s)
```
Для %s:
```
270 LOAD_CONST 14 ('%s %s %s %s %s %s')
272 LOAD_FAST 1 (s1)
274 LOAD_FAST 2 (s2)
276 LOAD_FAST 3 (s3)
278 LOAD_FAST 4 (s4)
280 LOAD_FAST 5 (s5)
282 LOAD_FAST 6 (s6)
284 BUILD_TUPLE 6
286 BINARY_MODULO
288 STORE_FAST 9 (s)
290 EXTENDED_ARG 1
```
Для f-string:
```
336 LOAD_FAST 1 (s1)
338 FORMAT_VALUE 0
340 LOAD_CONST 9 (' ')
342 LOAD_FAST 2 (s2)
344 FORMAT_VALUE 0
346 LOAD_CONST 9 (' ')
348 LOAD_FAST 3 (s3)
350 FORMAT_VALUE 0
352 LOAD_CONST 9 (' ')
354 LOAD_FAST 4 (s4)
356 FORMAT_VALUE 0
358 LOAD_CONST 9 (' ')
360 LOAD_FAST 5 (s5)
362 FORMAT_VALUE 0
364 LOAD_CONST 9 (' ')
366 LOAD_FAST 6 (s6)
368 FORMAT_VALUE 0
370 BUILD_STRING 11
372 STORE_FAST 9 (s)
374 EXTENDED_ARG 1
```
Сравнение объектов
------------------
Рассмотрим небольшой пример сравнения двух экземпляров классов:
```
def test_class():
class my_class():
pass
a, b = my_class(), my_class()
print(a == b)
print(a is b)
print(id(a) == id(b))
print(hash(a) == hash(b))
test_class()
```
Вывод:
```
False
False
False
False
```
Всё замечательно. Теперь посмотрим на другой пример:
```
def test_class2():
class my_class():
pass
print(my_class() == my_class())
print(my_class() is my_class())
print(hash(my_class()) == hash(my_class()))
print(id(my_class()) == id(my_class()))
test_class()
```
Вывод:
```
False
False
True
True
```
Что-то пошло не так. Вроде так же создаются 2 экземпляра класса, но при этом вывод показывает, что hash и id этих экземпляров одинаковы, но is показывает, что это получаются разные объекты. Рассмотрим еще пример:
```
def test_class3():
class my_class():
pass
print(my_class() == my_class())
print(my_class() is my_class())
print(hash(a:=my_class()) == hash(b:=my_class()))
print(id(c:=my_class()) == id(d:=my_class()))
test_class3()
```
Вывод:
```
False
False
False
False
```
Всё опять встало на свои места. Дополним немного my\_class во всех примерах:
```
class my_class():
def __init__(self):
print("__init__")
def __del__(self):
print("__del__")
```
Как это работает? Когда создается экземпляр класса, он получает свой уникальный id, но как только у него вызывается метод \_\_del\_\_, тот самый id уже перестает принадлежать этому объекту, и точно такой же id может быть присвоен другому объекту, например:
```
class my_class():
pass
a = my_class()
print(id(a))
>>> 2082631974720
del a
b = my_class()
print(id(b))
>>> 2082631974720
```
Когда python создает объект класса, как в случае 1 (в методе test\_class), то на этот объект ссылается переменная, следовательно, этот объект хранится в памяти до тех пор, пока на него что-то ссылается. В примере 3 аналогично, a := my\_class() и b := my\_class() - “моржовый” оператор := создает переменную a, которая во время выполнения функции print живёт и ссылается на объект, а переменная b ссылается уже на другой объект, так как у объекта в a:=my\_class() не был вызван метод \_\_del\_\_.
Пример 2 самый интересный. Когда вызывается id(my\_class()), то происходит следующее: создается экземпляр класса my\_class, этот только что созданный объект передается функции id, которая берёт id объекта, затем объект уничтожается и вызывается часть id(my\_class()), стоящая справа от ==. Опять создается my\_class (который, как мы определили чуть выше, будет иметь такой же id, как был у предыдущего my\_class(), который уже не существует), и правая функция id получается значение id этого объекта. Так получается, что id слева и справа от == получают идентификаторы своих объектов в то время, когда физически существует только один из этих объектов, следовательно id, полученное слева будет таким же, как id полученное справа.
Назревает вопрос: почему метод is в примере 2 выдает False, id объектов должны же быть одинаковы, значит, они ссылаются на один объект? Чуть выше был изменён класс my\_class. Для наглядности можно запустить пример 2 еще раз. Получим такой результат:
```
__init__
__init__
__del__
__del__
False
__init__
__init__
__del__
__del__
False
__init__
__del__
__init__
__del__
True
__init__
__del__
__init__
__del__
True
```
Когда выполнялся print с hash или id, видно, что по отдельности сначала вызывается конструктор, потом деструктор одного объекта, а потом конструктор и деструктор другого объекта, именно после того, как функции hash или id завершали свои действия, вызывался метод \_\_del\_\_ и создавался новый объект. В примере с is видно, что сначала создались оба экземпляра класса, а только потом вызывался метод \_\_del\_\_ у каждого из них. Это дает понять, что метод is выполнялся таким образом, что сначала создавались оба объекта my\_class(), потом они сравнивались, а только лишь после выполнения is они оба удалялись (т.е. два экземпляра my\_class жили в одно время и физически не могли иметь 2 одинаковых id).
И еще немного
-------------
#### Изменение данных внутри кортежа
Создадим кортеж, который содержит в себе список, и попробуем расширить этот список, добавив новые элементы:
```
def test_list():
a = ([], 0)
a[0].extend([1])
print("Применили extend: ", a)
a[0].append(2)
print("Применили append: ", a)
a[0].insert(0,0)
print("Применили insert: ", a)
try:
a[0] += [4]
print("Применяем +=: ", a)
except Exception as e:
print(e)
print("Итоговый кортеж:", a)
test_list()
```
Вывод:
```
Применили extend: ([1], 0)
Применили append: ([1, 2], 0)
Применили insert: ([0, 1, 2], 0)
'tuple' object does not support item assignment
Итоговый кортеж: ([0, 1, 2, 4], 0)
```
Очень забавная ситуация, кортеж выкинул ошибку, однако список все равно был расширен. Аналогично будет себя вести пример со словарями ( оператор |= - был добавлен в версии 3.9).
```
def test_dicts():
a = ({}, 0)
a[0]["cat"] = 100
print("Изменяем словарь: ", a)
a[0].update([("dog", 200)])
print("Применили update: ", a)
a[0].update({"bird": 50})
print("Применили update: ", a)
try:
a[0] |= {"lion": 200}
print("Применили |=: ", a)
except Exception as e:
print(e)
print("Итоговый словарь: ", a)
test_dicts()
```
Вывод:
```
Изменяем словарь: ({'cat': 100}, 0)
Применили update: ({'cat': 100, 'dog': 200}, 0)
Применили update: ({'cat': 100, 'dog': 200, 'bird': 50}, 0)
'tuple' object does not support item assignment
Итоговый словарь: ({'cat': 100, 'dog': 200, 'bird': 50, 'lion': 200}, 0)
```
#### Создание таблицы
Допустим, необходимо создать таблицу (матрицу, двумерный массив) с данными и поменять в нём первый элемент:
```
def test_list_2():
row = ["_"] * 3
table = [row] * 3
print("Создали таблицу:\n",table )
table[0][0] = "X"
print("Изменили первый элемент:\n",table )
test_list_2()
```
Вывод:
```
Создали таблицу:
[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
Изменили первый элемент:
[['X', '_', '_'], ['X', '_', '_'], ['X', '_', '_']]
```
Поменялся не только самый первый элемент таблицы, но и первые элементы в каждой строке. Если использовать инициализацию таблицы путем умножения одного списка, то каждая строка таблицы будет содержать один и тот же список (ссылаться на один список row).
Убедиться в этом можно, выполнив следующий код:
```
for table_row in table:
print(id(table_row))
```
Вывод:
```
1707508645824
1707508645824
1707508645824
```
#### Метод all
Немного о методе all:
```
def test_all():
print(all([]))
print(all([[]]))
print(all([[[]]]))
print(all([[[[]]]]))
test_all()
```
Вывод:
```
True
False
True
True
```
Почему так? all([]) - по определению выдаст True. Ситуация с all([[]]) объясняется тем, что для каждый элемент во внешнем списке приводится к булевскому значению (как известно, к False приводятся: ноль, пустая строка, пустой список и др.), поэтому внешний список содержит [], который интерпретируется как False. В all([[[]]]), внешний список содержит список, в котором есть список, а список с 1 элементов уже интерпретируется, как True, то есть all не проверяет вложенность списков.
Вывод
-----
Все эти примеры довольно очевидны для опытного программиста, но иногда могут вводить в ступор, особенно, если приходится читать чужой код и пытаться найти в нём ошибку. Такого рода ошибки порождают массу проблем, если плохо разбираться в нюансах работы языка. Поэтому иногда стоит читать и изучать чужой код, изучать статьи по языку и читать документацию к работе методов, чтобы видеть и понимать, какие сюрпризы может преподнести язык. И не стоит забывать, используя два разных языка и описав в них одинаковые конструкции, они могут вести себя совершенно по-разному, потому что внутренняя реализация у каждого языка своя.
*P.s. всё тестировал на Python 3.9 в стандартной IDLE. Картинка - кликбейт.* | https://habr.com/ru/post/564804/ | null | ru | null |
# Как делаются Z-Wave устройства
В этой статье мы расскажем, как создаются устройства Z-Wave. С точки зрения схемотехники и программирования разработка Z-Wave устройства не сильно отличается от разработки устройства на базе Arduino, AVR или PIC. Однако есть в Z-Wave свои нюансы. О них-то и пойдёт речь под катом.
О протоколе Z-Wave я [уже писал](http://geektimes.ru/post/257684/). Поэтому не буду подробно описывать детали протокола, а пройдусь по аппаратной платформе. Говорить будем только о последнем 5ом поколении чипов и модулей, которые были представлены более двух лет назад.
#### Железо
Итак, с железной точки зрения чипы и модули Z-Wave — это модернизированное ядро 8051. Чип выполнен в формате SoC, со следующей периферией:
* 128 КБ флэш памяти для вашего кода,
* 16 КБ оперативной памяти (XRAM) и 256 байт (IRAM), куда мапятся SFR-регистры,
* 256 байт NVR (там же хранятся калибровочные данные кристалла и lock bit),
* 30 GPIO,
* 2 UART,
* 2 SPI (Master и Master/Slave),
* 1 USB (только для Serial),
* 4 АЦП 12/8 бит,
* 1 сканер на 88 клавиш (с возможностью сканирования в режиме глубокого сна),
* 1 TRIAC-контроллер генератор с ZEROX-детектором,
* 5 ШИМ с разрешением 16 бит,
* 4 ИК-контроллера и 1 ИК декодер для обучения,
* загрузчик (включается по пину RESET или из кода записью в соответствующий SFR регистр) для перепрошивки по SPI или UART, а также возможность перепрограммировать себя (перезапись флэш-памяти используется для OTA-перепрошивки),
* встроенный криптоускоритель для 128-битного шифрования AES,
* монитор питания (для оценки заряда батарейки).
Питание чипа 2.3–3.6 В. Потребление составляет порядка 15 мА в режиме работы, 35 мА в режиме приёма и до 45 мА в режиме передачи. Также имеется режим глубокого сна с потреблением 1 мкА (пробуждение от INT1) и WUT (+0.7 мкА).
Очевидно, многие функции и ноги пересекаются и недоступны одновременно.
Такое обилие функций в одном чипе позволяет существенно снизить стоимость создаваемого устройства, т.к. не требует использования дополнительных микроконтроллеров. Например, диммер, дверной замок, брелок на батарейках, составной датчик (температура/влажность/осовещённость/...) можно сделать прямо на микроконтроллере Z-Wave с соответствующим обвязом.
Но главное, в чип встроен радио трансивер. Однако доступ к нему осуществляется только через библиотеки Sigma Designs (об этом ниже). Потому много про него неизвестно. Скажем лишь, что
* чувствительность на рабочей частоте Z-Wave составляет -104dBm,
* выходная мощность 5dBm,
* рабочий диапазон 850–940 МГц. (Мы уверены, что больше, но описание RF части вообще отсутствует, потому доступной информации об ином использовании радио трансивера нет. Очевидно, что это типичный SDR-чип, и велосипед Sigma Designs тут не изобретала).
Минимальный «обвяз» для Z-Wave требует лишь кварца (входит в модули), согласование антенны, несколько конденсаторов для стабилизации питания и подтяжка ноги RESET. Большинству устройств Z-Wave ещё требуется минимум 16 КБ EEPROM (для OTA обновления прошивки требуется 128 КБ).
##### Поставщики
Чипы производятся только Sigma Designs и по лицензии японской Mitsumi. На данный момент выпускается уже 5ое поколение чипов. Очень важным аспектом в развитии Z-Wave является обратная совместимость. Причём не только на программном уровне, но и в плане форм-фактора и характеристик чипов. В линейке новых модулей есть pin-to-pin совместимые со всеми предыдущими поколениями. Это позволяет быстро модернизировать уже производимые устройства без изменения схем и переразводки плат.
##### Варианты доступных чипов
Z-Wave чипы доступны в двух вариантах:
| | |
| --- | --- |
| | [SD3502](http://z-wave.sigmadesigns.com/docs/brochures/SD3502_br.pdf), 48-QFN 7x7 мм, |
| | [SD3503](http://z-wave.sigmadesigns.com/docs/brochures/SD3503_br.pdf), 32-QFN 5x5 мм (урезанная версия по сравнению с SD3502). |
Также доступны следующие SiP модули, включающие в себя кварц и минимальную обвязку для работы чипа:
| | |
| --- | --- |
| | [ZM5101](http://z-wave.sigmadesigns.com/docs/brochures/ZM5101_br.pdf), 56-QFN 8x8 мм, совместим с ZM4101 (4ое поколение), |
| | [ZM5202](http://z-wave.sigmadesigns.com/docs/brochures/ZM5202_br.pdf), PCB 12.5x13.6 мм, на базе SD3502, совместим с ZM3102 (3ее поколение), |
| | [ZM5304](http://z-wave.sigmadesigns.com/docs/brochures/ZM5304_br.pdf), PCB 27x15.2 мм, на базе SD3503, включает память EEPROM, SAW-фильтр, спиральную антенну и защитный экран (предназначен для «модемов», т.е. для контроллеров Z-Wave), |
И серия от Mitsumi:
| | |
| --- | --- |
| | [WML-C84](http://www.mitsumi.co.jp/latest/Catalog/pdf/commun_wml_c84_e.pdf), 56-QFN 8x8 мм, полный аналог ZM5101, |
| | WML-C85, 56-QFN 8x8 мм, по сравнению с C84 имеет встроенный SAW-фильтр, |
| | WML-C86, 56-QFN 15x15 мм, встроенные SAW-фильтр и EEPROM, увеличенные мощность TX и чувствительность RX, защитный экран, |
| | WML-C87, 56-QFN 15x15 мм, встроенные SAW-фильтр и EEPROM, увеличенная чувствительность RX, защитный экран. |
У разных вариаций модулей «отрезаны» разные ноги и функции. Выше были указаны доступные функции «полной» версии, т.е. SD3502, а также ZM5101 и WML-C84/C85.
Модули со встроенным SAW-фильтром идут в трёх вариантах в зависимости от региона (т.е. диапазона частот): EU/RU/CN/MY/UAE/IN, US/IL и ANZ/BR/JP/TW/HK/KR.
Многие из этих модулей можно купить даже на DigiKey. Однако чипы Sigma Designs продаёт [только на большом объёме](http://z-wave.sigmadesigns.com/volume) по особой договорённости.
Кстати, некоторые производители делают свои модули. Например, [Philio Tech делает](http://philio-tech.com/products/MD003&006&008.pdf) MD003 (аналог ZM5304 на базе SD3503, но без антенны), MD006 (на базе SD3503) и MD008 (что-то среднее между ZM5101 и ZM5202 на базе SD3502). На КДПВ устройство Philio PST-02 на базе MD008.
##### DevKit
Sigma Designs также предлагает комплект разработчика. Сюда входит:
* набор чипов разных форм-факторов в том числе на платах разработчика, которые устанавливаются прямо на программатор (очень удобно для прототипирования),
* программатор (Z-Wave чипы программируются специальным программатором — на рынке есть выбор: вот этот от Sigma Designs, более подходящий для производства [от нас, Z-Wave.Me](http://z-wave.me/index.php?id=42) и совсем [промышленный от Equinox](http://www.equinox-tech.com/products/details.asp?ID=1733)),
* сниффер (для прослушки эфира — просто необходимая вещь при отладке устройств),
* USB-стик для центрального контроллера,
* несколько датчиков и исполнителей,
* ПО под Windows для программатора, сниффера, контроллера, а также всякие вспомогательные утилиты,
* Z-Wave SDK для создания прошивок для чипов Z-Wave (об этом ниже),
* всякие провода и блоки питания.
Кит поставляется в двух частях: общая для всех и региональная (в зависимости от частоты, принятой в вашем регионе).
Стоимость кита от $1500 до $3500 в зависимости от количества плат разработчика и программаторов и наличия или отсутствия датчиков/исполнителей.
##### Легальная сторона
Патенты, лицензии и NDA не позволяют использовать чипы и модули Z-Wave для иных целей, кроме как для Z-Wave. Также Z-Wave устройства нельзя делать не на чипе Z-Wave (напомню, два уровня OSI имеют запатентованный функционал, что не даёт возможности создать полноценный стек Z-Wave без разрешения Sigma Designs). Это позволяет Sigma Designs включать стоимость лицензии (т.е. плату за развитие протокола, ПО, утилит, маркетинг) сразу в стоимость чипов и модулей.
Для того, чтобы назвать своё устройство Z-Wave совместимым необходимо пройти сертификацию (о ней ниже).
Кстати, по лицензионному соглашению на каждом устройстве Z-Wave (обычно на задней стороне; исключение составляют слишком компактные устройства) и на упаковке должен присутствовать логотип Z-Wave. Это способствует продвижению Z-Wave как технологии-бренда.
##### Типичная схема
Вернёмся к железу. Типичная схема подключения ZM5101 выглядит следующим образом:
В роли NVM выступает SPI EEPROM или FLASH память минимум 16 КБ. Она необходима для хранения данных об узлах сети, маршрутах и прочее. Есть возможность создавать устройства без внешней EEPROM (при этом под память используется блок флэш-памяти, что уменьшает пространство для кода). EEPROM занимает один SPI и одну ногу для CS. Ноги SPI можно без проблем использовать как GPIO или для подключения другого SPI Slave, пока CS поднят к 3.3 В. Через этот же SPI происходит программирование чипа Z-Wave, когда RESET подтянут вниз. Именно для этого нужна подтяжка на CS (ZM5101 становится SPI Slave, и второй Slave тут явно не нужен).
Часть, связанную с антенной и согласованием мы здесь описывать не будем, так как это тема отдельной научной работы.
Все остальные ноги можно использовать для реализации функционала устройства.
Допустим, мы хотим создать сложное устройство: 3 реле (через сборку дарлингтона ULN2003, так как предельного тока 20 мА с ноги ZM5101 недостаточно для электромагнитного реле, да и это позволит питать реле от 5 В или 12 В), один датчик сухих контактов, датчик освещённости (фоторезистор) и красиво мигающий трёхцветный светодиод. Всё это можно сразу подключить к чипу Z-Wave:
* 3 входа реле посадим на GPIO, например, P2.0, P2.1, P2.5 (ноги P2.2–P2.4 занимает EEPROM, подключенная по SPI)
* датчик сухих контактов подключим к INT0 (P1.0), INT1 (P1.1) или любой другой ноге GPIO, если планируется простой опрос, а не ISR-обработчик,
* датчик освещённости в составе делителя подключим к ADC0, она же P3.4 (второе плечо нужно подобрать так, чтобы уложить все возможные значения в диапазон 0–3.3В),
* наш трёхцветный светодиод подключим к PWM0–2 (P0.4–P0.6), что позволит плавно менять цвета в режиме новогодней гирлянды.
[](https://habrastorage.org/files/76a/fd2/1ba/76afd21ba5524dae9b383b80b34520d5.png)
Заметьте, у нас осталась ещё куча (18) ног! Для сравнения, 3ее поколение чипов и модулей Z-Wave (ZM3202) не позволяло подключить даже такого скромного набора периферии.
#### Прошивка
GPIO ноги в чипах Z-Wave, как и в других 8051 объединены в порты по 8 штук. Один SFR отвечает за режим (in/out), другой позволяет включить pull-up для режима in, третий для чтения/записи значения. Timer, UART, SPI и другие функции тоже похожи на другие 8051: TMOD/THx/TLx, UARTCON/UARTBUF/UARTSTAT, SPIxCON/SPIxDATA/SPISTAT,… Всяких регистров так много, что в 5ом поколении чипов пришлось ввести регистр SFRPAGE для переключения между страницами маппинга SFR на IRAM. Размер флэш памяти 128 КБ также потребовал использования банков памяти, что существенно усложняет транслированный код, наполняя его множеством переходов из банка в банк через COMMON BANK.
В теории для работы с чипом Z-Wave можно было бы использовать любой компилятор, например, [SDCC](http://sdcc.sourceforge.net/) (под GNU/GPL). Но увы документации на все эти порты, регистры, маппинг внутренней памяти и прочее нет. Вместо этого Sigma Designs выбрала другой путь: поставлять в бинарном виде пре-компилированную библиотеку (а на деле набор библиотек под разные классы устройств: под контроллеры, под датчики/исполнители, под шлюзы). Эти библиотеки, собранные под вполне конкретную версию Keil, предоставляют разработчикам удобный API как для работы с железом (фактически, wrapper'ы для обращения к SFR), так и для более сложных операций с сетью Z-Wave: отправки команд другим узлам, обслуживание сети Z-Wave, обновления маршрутов и прочее. Данная библиотека реализует следующие уровни протокола Z-Wave: PHY (непосредственно кодирование и декодирование на нужной частоте, выбор канала передачи, LBT), MAC (контроль ошибок, адресация в пределах зоны видимости), транспортный (подтверждения, повтор) и сетевой (маршрутизация, ретрансляция, обновление маршрутов, поиск новых маршрутов, включение в сеть, удаление из сети).
Именно Sigma Designs занимается совместимостью на этом уровне, обеспечивая развитие протокола и преемственность. К плюсам такого подхода стоит отнести гарантированную совместимость между Z-Wave устройствами и простоту работы на «верхнем» уровне, к минусам — низкую скорость реакции на найденные ошибки.
Для взаимодействия с сетью Z-Wave пользователю разработчику остаются лишь простые функции для взаимодействия с другими узлами. Однако стандарт требует жёсткой совместимости и на уровнях выше: сеансовом, представительском и прикладном. Эти уровни уже во власти разработчиков конечных устройств. Библиотека позволяет узлу А отправить команду узлу Б. При этом команда должны иметь строго определённый формат, описанный протоколом Z-Wave в разделе Command Classes Specification (около 900 страниц текста). Это позволит узлу Б правильно разобрать команду и выполнить соответствующее действие с периферией.
Библиотеки Z-Wave выполнены в формате «callback». Точка старта (main) находится в библиотеке, а управление пользователю передаётся только в определённые моменты:
* при старте (две точки входа — сразу после старта чипа для инициализации железа и позже, когда библиотека инициализировалась и можно уже некоторыми её функциями пользоваться — аналог setup() в Arduino,
* когда библиотека не занята (приёмом/отправкой данных, пересылкой пакетов других узлов сети, ответом на запросы контроллеров) — здесь можно опрашивать кнопки, измерять значение на АЦП и т.д. — аналог loop() в Arduino,
* когда получена команда (где получатель именно мы, CRC сошлась и отправитель из нашей сети).
Во все функции, требующие времени и работающие «асинхронно», можно тоже передать callback. Например, при вызове функции отправки пакета можно указать обработчик, который получит статус отправки (доставлен, не доставлен и код ошибки). Аналогично выполнена подсистема таймеров (помимо точных на базе TIMER1 и GPT): можно запустить до 5 программных таймеров, которые работают с шагом 10 мс (TIMER0 использовать нельзя, его использует библиотека для внутренних нужд и программных таймеров). Всё это облегчает работу программистам производителя конечного устройства.
Вместе с библиотеками Z-Wave также поставляется огромное множество предопределённых в заголовочных файлах структур и констант, соответствующих стандарту, что существенно упрощает разработку. Также Sigma Designs поставляет два десятка примеров, реализующих простые устройства, например, реле или бинарный датчик или дверной замок, с минимальным функционалом, необходимым для работы и прохождения сертификации Z-Wave Plus. Забавно, но более половины устройств Z-Wave, выпускаемых в поднебесной, основаны на этих примерах без единой изменённой строчки, кроме идентификаторов ManufacturerId, ProductId, ProductTypeId (речь про идентификаторы производителя, серии и модели; они для сертификации должны быть уникальными, так что если бы не это требование, то они бы вообще не отличались ;)
Совокупность всех заголовков, библиотек и sample code составляет Z-Wave SDK или ZDK. ZDK распространяется под NDA. Обычно NDA подписывается при приобретении DevKit.
Как уже было сказано ранее, для разработки собственного устройства нам понадобится ещё [Keil C51](http://www.keil.com/dd/chip/7310.htm). Стоит примерно 2600 Евро. Но это ещё не все траты, нас ждёт ещё один этап.
##### Классы команд и NIF
Помимо программирования логики работы с периферией необходимо объявить список поддерживаемых классов команд создаваемого устройства в NIF, а также реализовать объявленные классы команд (подробней о классах команд [читайте в этой статье](http://geektimes.ru/post/257684/)). Фактически это сводится к написанию кода, обрабатывающего все возможные команды всех поддерживаемых классов.
Например, для класса Switch Binary (ID 0x25) необходимо обработать команду Set (25 01), включив реле или светодиод или что-то там ещё, команду Get (25 02), ответив на неё командой Report (25 03 xx), где xx = 00 или FF в зависимости от текущего состояния реле, лампочки или что у вас там.
Для нашего примера «сложного» устройства это будет выглядеть как-то так
**Псевдокод обработчика**NIF будет содержать 0x25 (SwitchBinary), 0x26 (SwitchMultilevel), 0x30 (SensorBinary), 0x31 (SensorMultilevel), 0x60 (MultiChannel) и десяток других служебных классов, нужных лишь для служебных задач и настройки.
```
switch (pCmd[0]) {
case COMMAND_CLASS_MULTI_CHANNEL:
switch (pCmd[1]) {
case MULTI_CHANNEL_CMD_ENCAP:
switch (pCmd[4]) {
case COMMAND_CLASS_MULTI_SWITCH_BINARY:
// проверить номер канала
if (pCmd[3] == 1) {
switch(pCmd[5]) {
case SWITCH_BINARY_SET:
pin_set(P2_0, pCmd[6] ? 1 : 0);
break;
case SWITCH_BINARY_GET:
// первые параметры: кто запросил; канал того, кто спрашивал; наш канал; класс команд; команда; ... данные
SendMultiChannelReport(srcNodeId, pCmd[2], pCmd[3], COMMAND_CLASS_MULTI_SWITCH_BINARY, SWITCH_BINARY_REPORT, pin_get(P2_0));
break;
}
}
if (pCmd[3] == 2) {
switch(pCmd[5]) {
case SWITCH_BINARY_SET:
pin_set(P2_1, pCmd[6] ? 1 : 0);
break;
case SWITCH_BINARY_GET:
SendMultiChannelReport(srcNodeId, pCmd[2], pCmd[3], COMMAND_CLASS_MULTI_SWITCH_BINARY, SWITCH_BINARY_REPORT, pin_get(P2_1));
break;
}
}
if (pCmd[3] == 3) {
switch(pCmd[5]) {
case SWITCH_BINARY_SET:
pin_set(P2_5, pCmd[6] ? 1 : 0);
break;
case SWITCH_BINARY_GET:
SendMultiChannelReport(srcNodeId, pCmd[2], pCmd[3], COMMAND_CLASS_MULTI_SWITCH_BINARY, SWITCH_BINARY_REPORT, pin_get(P2_5));
break;
}
}
break;
case COMMAND_CLASS_MULTI_SENSOR_BINARY:
if (pCmd[3] == 4) {
switch(pCmd[5]) {
case SENSOR_BINARY_GET:
SendMultiChannelReport(srcNodeId, pCmd[2], pCmd[3], COMMAND_CLASS_MULTI_SENSOR_BINARY, SENSOR_BINARY_REPORT, SENSOR_BINARY_TYPE_GENERAL_PURPOSE /* датчик общего назначения */, pin_get(P1_0));
break;
}
}
case COMMAND_CLASS_MULTI_SENSOR_MULTILEVEL:
if (pCmd[3] == 5) {
switch(pCmd[5]) {
case SENSOR_MULTILEVEL_GET:
SendMultiChannelReport(srcNodeId, pCmd[2], pCmd[3], COMMAND_CLASS_MULTI_SENSOR_MULTILEVEL, SENSOR_MULTILEVEL_REPORT, SENSOR_MULTILEVEL_TYPE_LUMINESENCE /* освещённость */, 0 /* целое в % */, analog_get(P3_4));
break;
}
}
case COMMAND_CLASS_MULTI_SWITCH_MULTILEVEL:
if (pCmd[3] == 6) {
switch(pCmd[5]) {
case SWITCH_MULTILEVEL_SET:
pwm_set(P0_4, pCmd[6] > 99? 99 : pCmd[6]);
break;
case SWITCH_MULTILEVEL_GET:
SendMultiChannelReport(srcNodeId, pCmd[2], pCmd[3], COMMAND_CLASS_MULTI_SWITCH_MULTILEVEL, SWITCH_MULTILEVEL_REPORT, pwm_current(P0_4));
break;
}
}
case COMMAND_CLASS_MULTI_SWITCH_MULTILEVEL:
if (pCmd[3] == 7) {
switch(pCmd[5]) {
case SWITCH_MULTILEVEL_SET:
pwm_set(P0_5, pCmd[6] > 99? 99 : pCmd[6]);
break;
case SWITCH_MULTILEVEL_GET:
SendMultiChannelReport(srcNodeId, pCmd[2], pCmd[3], COMMAND_CLASS_MULTI_SWITCH_MULTILEVEL, SWITCH_MULTILEVEL_REPORT, pwm_current(P0_5));
break;
}
}
case COMMAND_CLASS_MULTI_SWITCH_MULTILEVEL:
if (pCmd[3] == 8) {
switch(pCmd[5]) {
case SWITCH_MULTILEVEL_SET:
pwm_set(P0_6, pCmd[6] > 99? 99 : pCmd[6]);
break;
case SWITCH_MULTILEVEL_GET:
SendMultiChannelReport(srcNodeId, pCmd[2], pCmd[3], COMMAND_CLASS_MULTI_SWITCH_MULTILEVEL, SWITCH_MULTILEVEL_REPORT, pwm_current(P0_6));
break;
}
}
break;
}
}
}
```
Как видно, мы тут обработали 8 каналов разных типов.
(Это сильно упрощённый для понимания код, но основная идея сохранена. Мы, конечно, не так пишем — просто решили вас не пугать и NDA лишний раз не нарушать. Подробности [тут](https://github.com/yepher/RaZBerry/#more-zwave-references).)
Очевидно, все устройства должны более-менее одинаково обрабатывать эти команды. 3 года назад мы неплохо шаблонизировали наш код, создав общую базу кода (code base) наших устройств. Многие наши устройства отличаются только одним .h файлом. Более сложные имеют ещё пару сишников для спец. функционала. С выходом 5-ого поколения чипов Sigma Designs сделала нечто похожее, так что код примеров легко адаптировать под свои нужды.
#### Сертификация
После того, как вы придумали устройство, сделали опытный образец, написали для него прошивку, необходимо сертифицировать ваше устройство. Процесс сертификации необходим для проверки соответствия вашего устройства протоколу Z-Wave, состоит из двух частей: Technical Certification (проверка самого устройства) и Market Certification, где также проверяется документация (упоминание ключевых терминов Z-Wave), наличие и корректность использования логотипа Z-Wave или Z-Wave Plus.
Z-Wave сертификация проводится одним из трёх центров сертификации: Pepper One в Германии, BuLogics в США или в самой Sigma Designs. Перед сертификацией требуется пройти процесс сертификации самостоятельно (self-certification), что позволяет сразу же обнаружить и устранить многие ошибки, а также уменьшить вероятность фэйла на сертификации. Для этого есть специальная утилита CTT, доступная полноправным членам Z-Wave Альянса. Её же используют сертификаторы. Также существует сертификационная форма (в зависимости от устройства в ней от 100 до 300 пунктов), по которой нужно описать устройство. По этой форме будет проходить сертификация. Для всех пунктов есть подробное описание, как тестируется и что ожидается от устройства. Стоит отметить, что весь процесс достаточно прозрачен — заранее понятно, что и как будут проверять (если все доки заранее прочесть ;)
Сертификация — процесс трудоёмкий и кропотливый. Сертификация также стоит денег: в зависимости от сложности устройства от $3000 до $5500. Тут всё примерно как на экзаменах в ГИБДД: допускается какое-то разумное количество fail'ов, которые требуется устранить в течение месяца (так называемый ad-hoc период). Если фэйлов больше или не получилось исправить, то потребуется повторная сертификация с новой оплатой. Это неплохо стимулирует хорошо проверять свои устройства. Лично мы зафэйлились только один раз, но он сильно подбил наше самолюбие.
Существенные изменения в функционале устройства или поведении в сети Z-Wave требуют повторной сертификации (re-certification, стоит половину цены). Нередко одно устройство без изменений продаётся в разных вариантах и цветах. В этом случае нужно только повторить Market Certification (бесплатно).
Опять же на примере нашего «сложного» устройства, CTT увидит, что мы в классе SwitchMultilevel не обрабатываем команды StartLevelChange и StopLevelChange, необходимые для диммирования. Если мы это не исправим, то сертификацию наше устройство не пройдёт. (Мы просто не хотели увеличивать итак страшный кусок кода обработчика).
Также заметим, что сертификация (и CTT) доступны только полноправным членам Z-Wave Альянаса (Full или Principal Member, но не Affiliate Member). Это ещё [$4000 в год](http://z-wavealliance.org/z-wave-oems-developers/).
#### Отладка
Сразу замечу, что JTAG или иного средства отладки в чипе Z-Wave нет! Это делает жизнь разработчиков ужасной и невыносимой. Поэтому нередко сложный код тестируется и отлаживается сначала на каком-нибудь чипе семейства 8051 от, например, Silicon Labs, которые не поскупились на нормальный JTAG или C2, удобно интегрируемый во встроенный в Keil отладчик. Также части кода мы тестируем, собирая его на Linux с gcc и прогоняя различные тесты (так, например, мы тестируем наш движок очереди пакетов на отправку в устройствах). Это не даёт возможности поймать переполнения свойственные самой архитектуре микроконтроллера (например, вылезание за пределы маленького стека, нехватку регистров при рекурсивных или просто глубоко вложенных вызовах функций) или отладить код, связанный с SFR или аппаратной частью чипа, но базовые «платформо-независимые» проблемы легко отлавливаются. Нередко приходится ковырять ASM-код ([d52](http://www.brouhaha.com/~eric/software/d52/) наше всё!), а также использовать удобные средства самого Keil с map-файлами.
В остальном приходится довольствоваться отладкой через I2C, SPI или UART (что работает для простых проблем, когда не происходит порчи стека или памяти из далёких кусков кода).
Отдельным упражнением является создание устройств, работающих от батареек — для понижения энергопотребления требуется писать качественный код, учитывающий время работы долгих операций (АЦП, отправка по радио, доступ к EEPROM) и расположение переменных (256 байт XRAM питаются даже в режиме глубокого сна, позволяя при просыпании не читать медленную EEPROM, а быстро принять решение и уйти спать дальше).
#### Сложные устройства
При создании более сложных устройств, для которых требуется много ног, бывает необходимо использовать несколько чипов, общающихся по UART, SPI или I2C. В этом случае часть функционала работы с периферией (или весь) переходит на второй чип. Очень удобным бывает использование более продвинутого в плане возможностей периферии и энергопотребления Atmel (с пониженной частотой) или Cortex. Такой подход позволяет использовать Z-Wave чип только как «модем».
##### Z-Wave Serial API
Частным случаем такого подхода является использование Z-Wave чипа совместно с другим CPU с полноценной ОС (например, PC или Raspberry Pi). Дабы не толкать производителей изобретать велосипед, Sigma Designs предложила свой стандарт для обмена данными между CPU и чипом Z-Wave по UART, который называется Z-Wave Serial API. В этом случае прошивка реализует UART обмен данными, отображая почти 1:1 все доступные разработчику функции на Serial API команды от CPU, а возврат значений и callback через команды к CPU. Пример такой прошивки имеется в ZDK и доступен всем разработчикам.  Такой подход позволил создать «рынок» USB-стиков Z-Wave отдельно от «рынка» софта для них: множество производителей предлагают взаимозаменяемые стики, в то время как производители ПО создают софт, работающий с любым стиком. Именно такой софт под название Z-Wave PC Controller входит в ZDK (доступен в сурсах).
Кроме того, этот подход способствует распространению технологии: производитель TV-приставки или роутера, создав решение на базе стороннего Z-Wave USB-стика, с ростом объёма продаж может решить заказать партию PCB с установленным Z-Wave модулем, удешевив тем самым решение. В этом случае чаще всего используется модуль ZM5304 (в ZDK есть прошивка для него, реализующая Serial API).
Однако некоторые компании, производящие и железо, и ПО (к ним и мы относимся с нашими стиками UZB, платами расширения RaZberry и нашим ПО Z-Way) предпочитают «привязывать» софт к стикам, так как в этом случае меньше поддержки (мы, например, устраняем многие проблемы кода Sigma Designs и дополняем его своими расширениями) и проще собирать деньги за ПО (стоимость уже включена в стик). Иные (например, Merten) вообще создали свой собственный формат обмена данными отличный от Z-Wave Serial API.
#### Обучение и поддержка
За каждым регионом закреплены несколько FAE от Sigma Designs. Они помогают новым производителям начать работу с Z-Wave, принимают bug report'ы и помогают со спорными ситуациями в процессе сертификации.
Z-Wave Альянс также активно участвует в жизни производителей, предлагая не только утилиты для тестирования и обучающие материалы. Несколько раз в год в разных частях света Альянс собирает разработчиков на конференции UnPlug Fest для обмена опытом и тестирования своих устройств другими участниками. В этих мероприятиях также принимают участие FAE Sigma Designs. UnPlug Fest всегда сопровождается двухдневным тренингом для новых разработчиков.
Также Z-Wave Альянс организует работу Interoperability Lab в Нью Джерси, США, где можно протестировать свои устройства как на совместимость, так и в специальной радио-лаборатории.
Кроме того в Альянсе есть рабочие группы по развитию протокола Z-Wave. Все разработчики могут предлагать свои идеи и влиять на функционал следующих версий всех классов команд и протокола в целом.
Более подробную информацию можно получить на сайте [Z-Wave Альянса](http://www.z-wavealliance.org).
#### Ещё немного о деньгах
Вернёмся к вопросу экономики и посчитаем, что сколько нам будет стоить в расчёте на устройство. Я сделаю это очень грубо и оценочно — не судите строго. Детальный финансовый анализ не является целью данной статьи. Для оценки я даже положил €=$ (да простят меня брокеры).
Представим, что мы собираемся выпустить 5000 устройств какого-то типа. Цена единицы будет состоять из BOM и затрат на разработку.
 Забудем о нашем «сложном» устройстве и поговорим о, например, простом брелоке (слева плата нашего брелока на 5ом поколении, справа на 3ем). Грубый расчёт показывает, что компоненты (кроме чипа Z-Wave) и PCB со сборкой стоят примерно 7 баксов (речь о мелкосерийном производстве нашей партии, а не про миллион китайских брелоков). Модуль ZM5202 стоит ещё 5 (аналоги стоят примерно 2 бакса, т.е. около 3 ушло на лицензию Z-Wave). Ещё корпус за 1 бакс (да поможет Alibaba!). Итого 13.
Теперь посчитаем затраты на разработку прошивки: 2600 (Keil) + 2500 (DevKit/ZDK) + 4000 (членство в Альянсе на год) + 3500 (сертификация) ≈ 2.5 бакса на устройство. Причём с производством нескольких моделей первые три слагаемых будут распределяться по всем типам устройств, т.е. цена будет существенно падать.
Также стоит учесть работу программистов. По нашему опыту, на первом устройстве они «сожрут» не менее 10 человеко–месяцев, а то и более. Что для первого устройства выльется в 2–4 бакса (для последующих устройств будет меньше раза в 2–3 благодаря накоплению опыта).
Таким образом ваши первые 5000 (весьма простых) устройств будут стоить по 19.5 баксов. Добавим НДС, транспорт, пошлины (при импорте), сертификацию, маржу себе и продающим партнёрам в канале, минимальный маркетинг и получим ~~три конца~~ примерно 60 баксов. С опытом и ростом объёма производства эта цифра будет уже ближе к 15 баксам, т.е. ближе к 45 в рознице. Это и есть розничная цена устройства здесь. Это к вопросу о том, что сколько стоит, и почему.
Также замечу, что первый опытный сертифицированный образец обойдётся минимум в 20 000 баксов. Меньше ну никак у новичков не получается.
Можно ли сделать дешевле на проприетарном протоколе и каком-нибудь чипе от TI или Silicon Labs? Не факт, если речь идёт не о колхозе на коленках, а о серийном устройстве с хорошей поддержкой. Да, Z-Wave стоит на 20%–30% дороже, но это часто оправдано.
#### Мораль сей басни
Как видите, процесс создание собственных устройств на базе протокола Z-Wave не таит в себе каких-либо загадок и вполне доступен любой IT-компании, знакомой с микроконтроллерами. Благодаря формату SoC многие устройства можно сделать на чипе Z-Wave и небольшом количестве дополнительных компонентов. Да, вам придётся прочесть около 2000 страниц спецификации и пройти через сертификацию.
Стоит ли во всё это влезать, и зачем вам Z-Wave? Если вы хотите создать только управляемую лампочку и датчик движения, да ещё и подешевле, то Z-Wave вам будет в тягость. Но если вы хотите создать полноценные компоненты умного дома, то вам лучше «вписаться» в существующий хорошо развитый протокол, такой как Z-Wave. Ведь мало компаний на рынке способных самостоятельно выпустить линейку из 30–50 устройств разного назначения: от брелоков и реле до термостатов и дверных замков. Приобщившись к популярному протоколу, вы сможете увеличить продажи своего устройства, вписав его в существующую экосистему устройств умного дома.
#### Как-то сложно для простого гика...
Вы гик, не согласный платить кучу денег и изучать так подробно внутренности Z-Wave? Но и готовые устройства вас не устраивают? Тогда на правах рекламы расскажем об одном нашем новом устройстве. Встречайте Z-Uno!
О Z-Uno мы на напишем отдельную статью (ссылка из будущего: [geektimes.ru/post/268980](http://geektimes.ru/post/268980/)). Если кратко, то это маленькая плата, основанная на ZM5101. Почти все ноги этого модуля мы вывели для вас. В этом устройстве специальная прошивка, которая позволяет подгружать пользовательский код, написанный в среде Arduino IDE на привычном для «ардуинщиков» языке. Мы дополнили «синтаксис» Arduino своими макросами, которые позволяют описать Z-Wave функции устройства (до 10 функций) и определить, что отправлять для каждой функции. Таким образом Z-Uno — это клон Arduino (с небольшими оговорками — это не Atmel, а 8051) со встроенной поддержкой Z-Wave. Ждите следующую статью или читайте на [z-uno.z-wave.me](http://z-uno.z-wave.me). | https://habr.com/ru/post/367509/ | null | ru | null |
# Защита web.config с помощью цифровых сертификатов в Windows и Azure
Поскольку утечки данных случаются в наши дни все чаще, крайне важно делать приложения максимально защищенными. Одной из основных областей, где можно найти бреши в защите, является файл web.config. Получив доступ к этому файлу, который обычно хранится в виде незашифрованного текста, злоумышленник затем может легко получить доступ к базам данных и множеству других ресурсов, как внутренних, так и внешних.
Так было не всегда. Когда .NET был еще совсем молод, большинство приложений работали в рамках одного домена Windows. Обычно в файле web.config не нужно было хранить пароли; права доступа к базе данных предоставлялись непосредственно учетной записи пользователя, под которой работало приложение.
Для нынешних приложений это больше не вариант. В современном мире распределенных систем базы данных и другие ресурсы часто работают за пределами домена Windows и даже могут контролироваться разными компаниями. В таких условиях правильное хранение паролей, токенов приложений и других идентификаторов системного уровня имеет очень важное значение.
Представленная здесь техника не нова; [Йоуни Хейкниеми](http://www.heikniemi.net/hardcoded/2013/06/encrypting-connection-strings-in-windows-azure-web-applications/) (Jouni Heikniemi) рассказывал о ней еще в 2013 году, как и команда SQL Azure за три года до этого. Но с годами некоторые шаги перестали работать из-за устаревших инструментов и изменения пользовательских интерфейсов. Тем не менее, первоначальная концепция по-прежнему актуальна.
### Дополнительная защита
Прежде чем мы начнем разговор о конкретных методах, важно понять, что шифрование файла web.config — это только один шаг в комплексном процессе обеспечения безопасности приложения. Важно очень четко понимать, что оно защищает, а что нет.
Чтобы от файла web.config была хоть какая-нибудь польза, приложение должно уметь его расшифровывать. Если вы будете хранить ключ дешифрования в файле неподалеку от файла web.config, очевидно, что злоумышленник просто получит доступ к этому в дополнение к файлу web.config. Встраивание ключа дешифрования в приложение немного усложняет работу злоумышленника, но с этим можно справиться, просто запустив декомпилятор на украденном коде вашего приложения.
Цифровые сертификаты бывают разные. Они хранятся на уровне ОС, поэтому злоумышленники не могут просто взять и выудить их с жесткого диска. Если вы явно не разрешите это, их нельзя даже экспортировать с компьютера, на котором они находятся.
Нельзя сказать, что это идеальное решение. Если злоумышленник может производить запись в каталог приложения, приложение может быть изменено для расшифровки и раскрытия содержимого web.config. Это означает, что вы должны заботиться о защите каталогов, содержащих код приложения, от записи. В идеале только ваш сервер сборки может производить запись в ваши каталоги приложений на рабочем сервере, но это уже выходит за рамки этой статьи.
Другой проблемой является защита копий самого цифрового сертификата. Они нужны для настройки новых серверов, но во всех остальных случаях их следует хранить в какой-нибудь оффлайн-хранилище или другом безопасном месте. С другой стороны, вы все-таки можете делиться цифровыми сертификатами, но только в этом есть крайняя необходимость.
### Создание цифрового сертификата
Цифровые сертификаты состоят из публичного и приватного ключа. Они аналогичны сертификатам SSL/TLS, но являются самоподписанными, поскольку им не нужно удостоверять, кто создал зашифрованный файл. Раньше Windows-разработчики использовали makecert.exe, но этот инструмент уже устарел. (Его все еще можно найти в Windows SDK.)
В наши дни правильным инструментом для создания сертификатов на компьютерах с Windows считается PowerShell. Чтобы создать сертификат, используйте следующие команды:
ПРЕДУПРЕЖДЕНИЕ: Возможно, вам придется запускать PowerShell-команды от имени администратора.
```
$cert = New-SelfSignedCertificate -Type DocumentEncryptionCert -Subject "CN=DevConfig" -KeyExportPolicy Exportable -KeySpec KeyExchange
Export-Certificate -Cert $cert -FilePath ".\DevConfig.cer"
$mypwd = ConvertTo-SecureString -String "1234" -Force -AsPlainText
Export-PfxCertificate -Cert $cert -FilePath ".\DevConfig.pfx" -Password $mypwd
$cert
```
Как вы могли догадаться сами из ее названия, команда [New-SelfSignedCertificate](https://docs.microsoft.com/en-us/powershell/module/pkiclient/new-selfsignedcertificate?view=win10-ps) создает сертификат. В этом примере он называется “DevConfig”, но вы можете назвать его как хотите.
Затем мы экспортируем сертификат шифрования в “.cer”-файл с помощью команды [Export-Certificate](https://docs.microsoft.com/en-us/powershell/module/pkiclient/export-certificate?view=win10-ps). Это публичный ключ, используемый для создания зашифрованных файлов конфигурации.
Следующие две строки позволяют нам экспортировать сертификат расшифровки в виде “.pfx”-файла с помощью [Export-PfxCertificate](https://docs.microsoft.com/en-us/powershell/module/pkiclient/export-pfxcertificate?view=win10-ps). Крайне важно, чтобы этот файл хранился в безопасном оффлайновом месте отдельно от пароля, который вы определили с помощью [ConvertTo-SecureString](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.security/convertto-securestring?view=powershell-6). (И, конечно, вам следует заменить “1234” более безопасным паролем.)
Для последующих шаговам вам потребуется узнать thumbprint сертификата. Последняя строка, “$cert”, сама по себе будет отображать thumbprint на экране. Thumbprint больше не считается секретом.
### Импорт сертификата шифрования в Windows
Если вы настраиваете машину, которая может шифровать, но не расшифровывать файлы конфигурации, тогда вам будет полезен этот шаг. В противном случае перейдите сразу к следующему.
```
Import-Certificate -Filepath ".\DevConfig.cer" -CertStoreLocation cert:\LocalMachine\My
```
В разделе [Import-Certificate](https://docs.microsoft.com/en-us/powershell/module/pkiclient/import-certificate?view=win10-ps) вы найдете больше информации.
### Импорт сертификата расшифровки в Windows
На этом шаге будет фактически импортирован и сертификат расшифровки, и сертификат шифрования (также известные как публичный и приватный ключи).
```
$mypwd = ConvertTo-SecureString -String "1234" -Force -AsPlainText
Import-PfxCertificate -FilePath ".\DevConfig.pfx" -CertStoreLocation Cert:\LocalMachine\My -Password $mypwd
```
Если вы импортируете сертификат с помощью [Import-PfxCertificate](https://docs.microsoft.com/en-us/powershell/module/pkiclient/import-pfxcertificate?view=win10-ps), то по умолчанию он не экспортируется. Это означает, что кто-либо другой не сможет экспортировать его с этой машины на другую. Хотя для продакшена так делать в принципе желательно, вы можете пометить его как экспортируемый для машин разработчиков.
Вы можете использовать [средство управления сертификатами](https://docs.microsoft.com/en-us/dotnet/framework/tools/certmgr-exe-certificate-manager-tool), чтобы убедиться, что сертификат был правильно установлен.
### Импорт сертификата расшифровки в Windows Azure
Сертификат расшифровки недоступна в бесплатной версии Azure App Services. На момент написания этой статьи вам нужен как минимум уровень B1, который разрешает SSL-подключения.
На портале Azure вам нужно найти вкладку “SSL Settings”. Затем нажмите кнопку “Upload Certificate” , чтобы указать сертификат. Затем вы должны увидеть его в нижней части экра:
Далее вам нужно предоставить приложению ваши сертификаты. Это делается путем добавления ключа WEBSITE\_LOAD\_CERTIFICATES на вкладку “Application Settings”. Вы можете использовать несколько значений thumbprint’ов, разделенных запятыми, или можете установить это значение на “\*”, чтобы предоставить все ваши сертификаты вашему веб-приложению.
### Защищенный поставщик конфигурации
Шифрование и дешифрование обрабатывается [ProtectedConfigurationProvider](https://docs.microsoft.com/en-us/dotnet/api/system.configuration.protectedconfigurationprovider?view=netframework-4.7.2&viewFallbackFrom=netstandard-2.0). Тот, который мы используем в этой статье, называется Pkcs12ProtectedConfigurationProvider. Первоначально он был создан корпорацией Microsoft, но в него были внесены незначительные изменения для совместимости со службами приложений Azure.
ProtectedConfigurationProvider вставляет себя в конвейер чтения конфигурации, поэтому код вашего приложения на самом деле не должен знать об этом. Это полезно, когда вам нужна гибкость использования как зашифрованных, так и незашифрованных файлов конфигурации.
Вы можете [добавить Pkcs12ProtectedConfigurationProvider непосредственно в свой проект](https://github.com/Grauenwolf/WebConfigEncrypter/blob/master/WebConfigEncrypter/Pkcs12ProtectedConfigurationProvider.cs) или загрузить его с помощью NuGet-пакета [WebConfigEncrypter](https://www.nuget.org/packages/WebConfigEncrypter). В этой статье предполагается, что вы будете использовать NuGet-пакет.
### Подготовка файла web.config к шифрованию
После добавления в проект класса Pkcs12ProtectedConfigurationProvider вам потребуется подготовить файл web.config для шифрования.
1. Добавьте этот раздел в свой файл web.config.
```
[...]
```
2. Измените атрибут thumbprint, чтобы он соответствовал вашему сертификату.
3. Если вы не используете NuGet-пакет, обновите атрибут type, чтобы он соответствовал полностью квантийицированному классу и имени сборки DLL-библиотеки вашего `ProtectedConfigurationProvider`.
### Шифрование строк подключения в файле web.config
Прежде чем начать это делать, убедитесь, что у вас есть резервная копия файла `web.config`.
В командной строке Visual Studio введите “where aspnet\_regiis”. Затем скопируйте в эту папку следующие файлы. Это позволит инструментам командной строки aspnet использовать ваш класс `ProtectedConfigurationProvider`:
* WebConfigEncrypter.dll
* System.Configuration.ConfigurationManager.dll
* System.Security.Cryptography.Xml.dll
Затем запустите эту команду из той же папки, что и файл `web.config`:
`aspnet_regiis -pef "connectionStrings" "." -prov "Pkcs12Provider"`
Ваш раздел зашифрованной конфигурации должен выглядеть примерно так:
```
rsaKey
Moy/a2XO2zvnn/HZW53DyC8aAJWo16+0KmnpC4SCSmuQZU0RT+HNFEA33pAGCzve+m6MTaRzhx6jVVRoAvpSNzfYG1bU1z7a1YnbW4OGxrmYYfdWW6cZQZ57dZnL6YSAlkJ5WlqPDGUPJa6FV/hTic3x4fJYy5vdSucmO6X3opuo1998LWNkL6fIS4WkjkG/SOFbI2Qx3HHogdN670jDHKNDON1z7bFHhLNyVj7RTO3xuQN9kF4PqbFtvwm1bYXTbZpdNxu/fcXZKONSAu8HN3QX5vTRyP/I4BG+NK7TUig3gxD4tq9GR7aSSGKJyt02PiCEO0JpyyIbHZ9xbck9kw==
TeV0yJaFlEhpyZUlQoG7M3O7sfQ7uG3ndgmhxipOrwoEsrI+Zvt1NI7arefOFWGNW4CEaoLo4mKy2Kwr4ZgK+6rAwOmx1IRyheWtF7z/8+CiGOqSRXLyGEkDQBEVOWKU0Y6TaWtPu0ZM3bp5pvKaztBnthgGnrGYmigaufu5rZW1GWPtHyL2iWdAkU9iaf+AOpA/GSvoVtZmnfJ1rwy6U8PTO0h0Ws/PdkcOKuXGkx31t/Y32ivFoy7xYPnPt/Z/aNMiHvbO7faQAwuJ/NsG9G1FFRRHCqc73TUsRdKHVuf17BEp526RG6RBZtM3F3V3o0d8/sLmyrNI9tFfksB4qcWiN4P+BRtGr0iacmBfBOvAFSozfUYxjMpx+BYPOpD1pf4fMFoKxxKeJYY31XqZoQLp75RgmWhWYm8URHq4Cjs=
```
Вот и все (для Windows IIS). Ключ `configProtectionProvider` сообщит вашему приложению, какой класс дешифрования и сертификат использовать. Если это не сработает, повторно запустите описанную выше команду Import-PfxCertificate.
### Шифрование пользовательских разделов конфигурации
В дополнение к строкам подключения вы можете зашифровать [пользовательские разделы конфигурации, созданные с помощью IConfigurationSectionHandler](https://msdn.microsoft.com/en-us/library/ms228056.aspx). Для этого необходимо скопировать библиотеку, определяющую пользовательский класс конфигурации, в ту же папку, что и aspnet\_regiis, точно так же, как вы сделали с `WebConfigEncrypter.dll`.
Убедитесь, что в своем списке configSections вы используете полностью квантифицированный класс и имя сборки для пользовательского класса конфигурации. Например:
```
```
Это необходимо для `aspnet_regiis`, даже если в противном случае вы можете просто указать имя класса.
Затем вы можете снова запустить команду шифрования, заменив параметр -pef именем раздела.
`aspnet_regiis -pef "protectedSettings" "." -prov "Pkcs12Provider"`
### Особые рекомендации для Azure App Services
Azure Поскольку службы приложений Azure хранят и предоставляют сертификаты для текущего пользователя, а не для компьютера, вам потребуется изменить атрибут `storeLocation`, как показано ниже:
```
```
Перевод статьи подготовлен в преддверии старта курса C# ASP.NET Core разработчик. Приглашаем всех на [бесплатный урок курса](https://otus.pw/XRGb/), в рамках которого познакомимся с видами баз данных. Разберем как работать с реляционными и нереляционными базами данных - напрямую и через ORM. Регистрация доступна по [ссылке](https://otus.pw/XRGb/).
* [Зарегистрироваться на бесплатный урок](https://otus.pw/XRGb/) | https://habr.com/ru/post/696164/ | null | ru | null |
# X-сервер для Android
Австралийский разработчик Мэтт Квэн (Matt Kwan) создал [X-сервер для Android](http://my20percent.wordpress.com/about/) (на Java), который уже можно [скачать в Android Market](https://play.google.com/store/apps/details?id=au.com.darkside.XServer), исходный код также [опубликован на Google Code](http://code.google.com/p/android-xserver/source/browse/) (лицензия MIT или Apache).
X-сервер реализует протокол X11 на Android-устройствах, то есть позволяет отображать на планшете/смартфоне интерфейс приложения, которое выполняется на другой \*nix-машине в сети, например, на десктопе или ноутбуке Linux, MacOS или \*BSD. Чтобы сделать это, зная IP-адрес планшета, достаточно просто указать в переменной `display` IP-адрес планшета с параметром `:0` (по крайней мере, в Австралии смартфонам раздают адреса IPv4). С планшета осуществляется управление приложением на десктопе: нажатием по тачскрину передвигается курсор, а кнопки громкости эмулируют нажатия левой и правой кнопки мыши, поддерживаются физическая и виртуальная клавиатуры.
Таким образом, в перспективе на планшете можно будет запускать нормальный десктопный софт.
Данная разработка является концептуальной и вряд ли пока можно говорить о её реальном применении в практических задачах. X-сервер написан на Java и состоит из 14100 строк кода, в бета-версии X-сервера отсутствует динамическая карта цветов и многие другие части протокола X11. В данной версии также отсутствует оконный менеджер, но его можно запустить удалённо командой **`fvwm -d xxx.xxx.xxx.xxx:0`**.
 | https://habr.com/ru/post/139705/ | null | ru | null |
# Перевод: Настройка ваших приложений и игр для устройств с длинным экраном
Привет, Хабр! Представляю вашему вниманию перевод статьи [Tuning your apps and games for long screen devices](https://android-developers.googleblog.com/2017/12/tuning-your-apps-and-games-for-long.html) автора Fred Chung.
В последние месяцы растет тенденция к тому, что производители телефонов представляют новые устройства с длинным экраном (более 16: 9), многие из которых имеют закругленные углы. Pixel 2 XL и Huawei Mate 10 Pro — всего лишь два из множества примеров. Эти особенности экрана могут принести пользователям впечатляющий опыт, но они обращают внимание на приложения и игры, которые не используют экран длинного формата на новых устройствах. Поэтому для разработчиков важно оптимизировать такие экраны. Давайте посмотрим на соответствующую поддержку, предоставляемую ОС Android.
Оптимизация для экранов с длинным соотношением сторон
-----------------------------------------------------
Большинство приложений, использующих стандартные виджеты пользовательского интерфейса, скорее всего, будут работать на этих устройствах. В [документации Android](https://developer.android.google.cn/guide/practices/screens_support.html) уточняются методы для гибкой работы на экранах разных размеров. Однако некоторые игры и приложения с пользовательскими интерфейсами могут столкнуться с проблемами из-за неправильных предположений относительно определенных пропорций. Мы разделяем несколько типичных проблем, с которыми сталкиваются разработчики, поэтому вы можете обратить внимание на те, которые относятся к вам:
* **Определенные стороны экрана обрезаны.** Из-за этого любые графические элементы или элементы пользовательского интерфейса в затронутых областях выглядят неполными.
* **Сенсорные цели смещаются от элементов пользовательского интерфейса (например, кнопок).** Пользователи могут путать элементы
* В полноэкранном режиме на округлых углах устройств любые **элементы пользовательского интерфейса, очень близкие к углам, могут находиться вне изогнутой области просмотра углов.** Представьте, что нажатие на кнопку «Покупка» коммерческого приложения затруднено? Мы рекомендуем ссылаться на [рекомендации по проектированию материалов](https://material.io/guidelines/layout/metrics-keylines.html#metrics-keylines-keylines-spacing), оставив боковые поля 16dp в макетах.
Если отзывчивый пользовательский интерфейс действительно не подходит для вашей ситуации, в крайнем случае объявите явное максимальное поддерживаемое соотношение сторон следующим образом. На устройствах с более высоким соотношением сторон приложение будет показано в режиме совместимости с системным почтовым ящиком. Имейте в виду, что некоторые модели устройств обеспечивают переопределение для пользователей, чтобы заставить приложение работать в полноэкранном режиме совместимости, поэтому обязательно протестируйте этот способ оптимизации и в такой ситуации.
Targets API level 26 или выше: используйте атрибуты
```
android: maxAspectRatio
```
Targets API level 25 или ниже: используйте метаданные
```
android.max_aspect
```
Обратите внимание, что максимальные значения соотношения сторон будут соблюдаться только в том случае, если ваши действия не поддерживают
```
resizableActivity
```
Подробнее см. [Документацию](https://developer.android.google.cn/guide/practices/screens_support.html#MaxAspectRatio).
*Системные почтовые ящики в приложении используются когда объявленное максимальное соотношение сторон меньше экрана устройства.*
Примите во внимание возможность использования параллельных действий
-------------------------------------------------------------------
Устройства с длинным соотношением сторон обеспечивают еще больше возможностей использования нескольких окон, что может повысить производительность пользователей. Начиная с Android 7.0, платформа предлагает стандартный способ для разработчиков реализовывать многооконный режим на поддерживаемых устройствах, а также выполнять перетаскивание данных между действующими окнами. Подробнее см. В [документации](https://developer.android.com/guide/topics/ui/multi-window.html#configuring).
Тестирование имеет решающее значение. Если у вас нет доступа к одному из устройств с длинным экраном, обязательно проверьте на эмуляторе необходимые свойства экрана и разрешения, которые описаны в [документации эмулятора](https://developer.android.com/studio/run/managing-avds.html#hpproperties).
Мы знаем, что вы хотите порадовать своих пользователей устройствами с длинным экраном. С помощью нескольких шагов вы сможете гарантировать, что ваши приложения и игры будут в полной мере использовать эти устройства! | https://habr.com/ru/post/345438/ | null | ru | null |
# Sberbank Online iOS testing
Theory of testing is usually differs from practice. Today we want to talk about our practical experience in testing [application](https://itunes.apple.com/ru/app/%D1%81%D0%B1%D0%B5%D1%80%D0%B1%D0%B0%D0%BD%D0%BA-%D0%BE%D0%BD%D0%BB%D0%B0%D0%B9%D0%BD/id492224193?mt=8)'s code which is used by millions of iOS users and about the difficult path that our team finished in order to achieve stable code.
Let’s imagine: the developers successfully convinced themselves and the business of the need to cover the code with tests. Over time, in the project were created more than a dozen thousand unit- and more than a thousand UI-tests. Such a large test base araised several problems, and we successfully found the solution for them.
In the first part of the article, we will get acquainted with the difficulties that arise while working with clean (non-integration) unit-tests, in the second part we will consider UI-tests closely.
In an ideal world, with unchanged source code, unit tests should always show the same result regardless of the number and sequence of it’s starts and constantly falling tests should never pass through the Continuous Integration(CI) server barrier.
In reality we may encounter the fact that the same unit-test will show either a positive or a negative result — “blinking” test. The reason for this behavior is a bad test implementation. Moreover, such test can pass CI with successful status, and later it will begin to fall on other people's Pull Request (PR). In such situation, there is a desire to disable this test or play trigger build-roulette and run the CI again. However, this approach is anti-productive, it undermines the credibility of tests and loads CI with meaningless work.
This issue was highlighted yesteryear at Apple's WWDC international conference:
* [This session](https://developer.apple.com/videos/play/wwdc2018/403/) discusses about parallel testing, individual target coverage analysis and test run process.
* [Here](https://developer.apple.com/videos/play/wwdc2018/417/) Apple narrates about testing network requests, mocking, testing notifications and the performance of tests.
### Unit tests
To struggle blinking tests we use the following sequence of actions:
0. Evaluate test’s code quality according to basic criteria: isolation, mocks’ correctness, etc. We follow the rule: with a blinking test, we change the test’s code, and never the code that we test.
If this does not help, proceed as follows:
1. Fix and reproduce the conditions under which the test falls;
2. Find the reason why it falls;
3. Change the test’s code;
4. Go to the first step and check whether the cause of the fall has been eliminated.
### Reproduce the fall
The simplest and most obvious option to reproduce the blinking fail is to run a problem test on the same version of iOS and on the same device, and usually in this case the test is successful! We have a thought: “Everything works for me locally, I will restart the build on CI”. But in fact, the problem has not been solved, and the test continues to fall on the build of another developer.
Therefore, at the next step, you need to run locally all the unit tests of the application to identify the potential affect of one test on another. But even after this check, your test result may be positive, while the problem remains undetected.
So, if test run was successful and the expected fail was not caught, you can repeat the run many times.
To do this you need to run a loop in terminal with xcodebuild:
```
#! /bin/sh
x=0
while [ $x -le 100 ];
do xcodebuild -configuration Debug -scheme "TargetScheme" -workspace App.wcworkspace -sdk iphonesimulator -destination "platfrom=iOS Simulator, OS=11.3, name=iPhone 7" test >> "report.txt";
x=$(( $x +1 ));
done
```
This should be enough to reproduce the fall and move on to the next step — identifying the cause of the recorded fall.
### Test’s fall reasons and possible solutions
Let’s dive deeper into the main causes of unit-tests blinking, which you may encounter, tools to identify problems, and possible solutions.
There are three main groups of reasons for blinking tests:
**Bad test isolation**
By isolation we mean a special case of encapsulation: a mechanism that allows restricting access of some program components to others.
Isolation of the environment has an important role for the purity of the test, nothing should affect the tested entities. Particular attention should be paid to tests that are aimed at checking the code and use global state entities, such as: global variables, Keychain, Network, CoreData, Singleton, NSUserDefaults and so on.
Imagine that while creating a test environment, a global state is set, which is implicitly used in another test code. In such case, the test may start to “blink” — due to the fact that, depending on the sequence of tests, two situations can arise — when the global state is set and when not set.
Oftenly, the described dependencies are implicit, so you may accidentally forget to set / reset such global states.
To make the dependencies clearly visible, you can use the principle of Dependency Injection (DI): pass the dependency through the parameters of the constructor, or a property of an object. This will make it easy to substitute mock dependencies instead of a real object.
**Asynchronous calls**
All unit tests are performed synchronously. The difficulty of testing asynchrony arises due to the call of the test method that “freezes” awaiting of the unit-test’s scope completion. The result will be a stable fail.
```
//act
[self.testService loadImageFromUrl:@"www.google.ru" handler:^(UIImage * _Nullable image, NSError * _Nullable error) {
//assert
OCMVerify([cacheMock imageAtPath:OCMOCK_ANY]);
OCMVerify([cacheMock dateOfFileAtPath:OCMOCK_ANY]);
OCMVerify([imageMock new]);
[imageMock stopMocking];
}];
[self waitInterval:0.2];
```
There are several approaches to test such a case:
1. Run NSRunLoop
2. waitForExpectationsWithTimeout
Both options require to specify an argument with a timeout. However, it cannot be guaranteed that the selected interval is sufficient. Locally, your test will pass, but on a heavily loaded CI there may not be enough power and it will fall — thus “blink” will appear.
Let’s imagine that we have some kind of data processing service. We want to verify that after receiving a response from the server, it transfers this data for further processing. To send requests via the network, the service uses the client to work with it. This case can be written asynchronously using a mock server to guarantee stable network responses.
```
@interface Service : NSObject
@property (nonatomic, strong) id apiClient;
@end
@protocol APIClient
- (void)getDataWithCompletion:(void (^)(id responseJSONData))completion;
@end
- (void)testRequestAsync
{
// arrange
\_\_auto\_type service = [Service new];
service.apiClient = [APIClient new];
XCTestExpectation \*expectation = [self expectationWithDescription:@"Request"];
// act
id receivedData = nil;
[self.service receiveDataWithCompletion:^(id responseJSONData) {
receivedData = responseJSONData;
[expectation fulfill];
}];
[self waitForExpectationsWithTimeout:10 handler:^(NSError \* \_Nullable error) {
expect(receivedData).notTo.beNil();
expect(error).to.beNil();
}];
}
```
But the synchronous version of the test will be more stable and will allow you to get rid of working with timeouts. For this we need a synchronous APIClient mock.
```
@interface APIClientMock : NSObject
@end
@implementation
- (void)getDataWithCompletion:(void (^)(id responseJSONData))completion
{
\_\_auto\_type fakeData = @{ @"key" : @"value" };
if (completion != nil)
{
completion(fakeData);
}
}
@end
```
Then the test will look simpler and it will work stabler.
```
- (void)testRequestSync
{
// arrange
__auto_type service = [Service new];
service.apiClient = [APIClientMock new];
// act
id receivedData = nil;
[self.service receiveDataWithCompletion:^(id responseJSONData) {
receivedData = responseJSONData;
}];
expect(receivedData).notTo.beNil();
expect(error).to.beNil();
}
```
Asynchronous operation can be isolated by encapsulating to a separate entity, which can be tested independently. Other part of the logic should be tested synchronously. Using approach you will avoid most of the pitfalls brought by asynchrony.
As an option, in the case of updating the UI layer from the background thread, you can check whether it’s the main thread and what will happen if we make a call from the test:
```
func performUIUpdate(using closure: @escaping () -> Void) {
// If we are already on the main thread, execute the closure directly
if Thread.isMainThread {
closure()
} else {
DispatchQueue.main.async(execute: closure)
}
}
```
For a detailed explanation, see [the article](https://www.swiftbysundell.com/posts/reducing-flakiness-in-swift-tests) by D. Sandell.
**Testing code beyond your control**
Often we forget about the following things:
* the implementation of the methods may depend on the localization of the application,
* there are private methods in the SDK that can be called by framework classes,
* the implementation of the methods may depend on the version of the SDK.
These cases bring some uncertainty in the process of writing and running tests. To avoid negative consequences, you need to run tests on all locales, on all versions of iOS supported by your application. Separately, it should be noted that there is no need to test code whose implementation is hidden from you.
Finally, we want to complete this part about automated testing of the Sberbank Online iOS application, dedicated to unit testing.
The article was written with @[regno](https://habr.com/users/regno/) — Anton Vlasov, head of iOS development. | https://habr.com/ru/post/511384/ | null | en | null |
# Итоги: что сильнее – ассемблер или Хабраэффект?
 Отшумели страсти после моей [первой статьи](https://habrahabr.ru/post/318916/) на Хабре.
Тема была о веб сайте на ассемблере, так что нет ничего удивительного в количестве комментариев к статье, а также в Хабраэффекте на сайте. В течение первых нескольких суток тысячи людей посетили демо сайт AsmBB.
Сайт уже был один раз под подобным наплывом посетителей — когда в августе кто то опубликовал ссылку на сайт одновременно в Твиттер, ФБ и Реддит.
Но, судя по счетчику посещений, Хабрахабр оказался вдвое круче буржуйских сайтов и в этот раз демо сайт был нагружен значительно больше чем в прошлый раз.
Как и ожидалось, чудо свершилось. Несмотря на то, что хостинг предельно слабенький (я его взял такой специально), несмотря на то, что сайт использует БД SQLite, которую все считают очень медленной, форум не упал. Он даже не замедлился. Все время сайт работал исправно и обслуживал всех посетителей.
Посмотрим как выглядит Хабраэффект изнутри:
Статистика посещений
====================
Статья на Хабре была опубликована 2-го января. За те нескольких дней, пока длился Хабраэффект, она была просмотрена около 40000 раз. Некоторое число людей, прочитавших статью, посетили и демо AsmBB. Эти посещения выглядят так:
| Дата | Посетители | Страницы | Запросы | Траффик | Время
ЦПУ [с] | Время обс.
запр. [ms] |
| --- | --- | --- | --- | --- | --- | --- |
| 02 янв | 637 | 4461 | 12224 | 63.06 MB | 152 | 12.43 |
| 03 янв | 5402 | 36453 | 84876 | 385.48 MB | 795 | 9.37 |
| 04 янв | 1961 | 14531 | 33445 | 171.60 MB | 325 | 9.72 |
| 05 янв | 743 | 5220 | 12504 | 53.17 MB | 170 | 13.6 |
| 06 янв | 343 | 2370 | 5421 | 23.21 MB | 69 | 12.73 |
| **В сумме** | **9086** | **63035** | **148470** | **696.52 MB** | |
Из графика нагрузки CPU видно, что веб-сайт 3-его января был нагружен приблизительно наполовину. То есть он мог бы обслужить примерно 180 000 запросов или 12000 посетителей в сутки, прежде чем сервер начал тупить из за ограничений на CPU.
В пиках посещаемости веб сервер (Apache) запускал не более 6 FastCGI процессов форума. Это означает и 6 одновременных коннектов к БД.
SQLite, несмотря на пессимистичные мнения в комментариях, вела себя все время прекрасно, особо не замедляясь. При том что движок форума активно пишет в БД не только когда посетители публикуют посты, но и когда только читают. Там ведется статистика посещении, есть счетчик просмотров на каждый пост, для каждого гостя или пользователя записывается время последней активности. Все это постоянно пишется в БД.
Настройки SQLite такие:
```
PRAGMA journal_mode = WAL;
PRAGMA foreign_keys = TRUE;
PRAGMA synchronous = OFF;
PRAGMA threads = 2;
PRAGMA secure_delete = FALSE;
```
Посетители
==========
Вполне ожидаемо, посетители были на 90% из России, Украины и Белоруссии.
Должен отметить что эти посетители оказались намного активнее и вовлеченнее, чем западные. Это мне очень понравилось, потому что помогло протестировать сайт не только на скорость работы, но и на недостатки кода. В процессе Хабраэффекта и обсуждения статьи были выявлены и исправлены несколько багов, в том числе и критических.
Зарегистрировались 32 новых пользователей, которые написали несколько десятков постов, пытаясь протестировать форум на прочность.
Спасибо, ребята! Вы очень помогли.
Вот и список исправлений, которые были сделаны во время Хабраэффекта. Там не только багфиксы, но и новые функции:
1. [Ошибка, вызывающая исключение](https://asm32.info/fossil/repo/asmbb/info/18ace583a3fc0624)
2. [XSS уязвимость и еще одна ошибка вызывающая исключение](https://asm32.info/fossil/repo/asmbb/info/18ace583a3fc0624)
3. [Ошибка в кэшировании аватаров на стороне клиента](https://asm32.info/fossil/repo/asmbb/info/d86f8027078fe46a)
4. [Кэширование HTML постов](https://asm32.info/fossil/repo/asmbb/info/8b5016ce39246bea)
Насчет п.4 надо сказать, что я решил сделать эту функцию, измеряя время реализации, как доказательство того что код на ассемблере намного легче поддерживать, чем это принято считать.
Время реализации – ровно 78 минут. Наверное это несколько больше чем на ЯВУ, но все же вполне нормальный результат.
Выводы
======
А выводы делайте сами.
---
Спасибо [gearbox](https://habrahabr.ru/users/gearbox/) за помощь в редактировании. | https://habr.com/ru/post/319028/ | null | ru | null |
# Книга «React: современные шаблоны для разработки приложений 2-е издание»
[](https://habr.com/ru/company/piter/blog/577862/) Привет, Хаброжители! Хотите создавать эффективные приложения с помощью React? Тогда эта книга написана для вас. Познакомьтесь c лучшими практиками и шаблонами создания современного кода.
Вам не потребуются глубокие знания React или функционала JavaScript — достаточно знакомства с принципами работы JavaScript, CSS и HTML.
Алекс Бэнкс и Ева Порселло научат вас создавать пользовательские интерфейсы, которые будут динамически отображать изменения без необходимости перезагрузки страницы даже на крупномасштабных сайтах, работающих с огромными массивами данных.
В этой книге вы:
* Разберетесь с ключевыми аспектами функционального программирования на JavaScript.
* Узнаете, как устроена работа React в браузере.
* Создадите слои представления приложения с помощью компонентов React.
* Научитесь управлять данными и тратить меньше времени на отладку.
* Внедрите в проект хуки React для управления состояниями и перехвата данных.
* Используете маршрутизатор для полноценной работы с одностраничными приложениями.
* Научитесь структурировать приложения React с учетом особенности работы сервера.
Как работает React
------------------
Итак, мы изучили последний актуальный синтаксис и ознакомились с паттернами функционального программирования, лежащими в основе React. Теперь перейдем к следующему шагу — а именно к нашей цели: изучению работы React. Приступим к написанию реального кода на React.
Работая с React, вы, скорее всего, будете создавать свои приложения с помощью JSX — синтаксиса JavaScript на основе тегов, который очень похож на синтаксис HTML. Мы подробно рассмотрим его в следующей главе и продолжим использовать на протяжении всей книги. Однако, чтобы по-настоящему разобраться в React, вам нужно понять его минимальные единицы — элементы. После элементов мы обсудим компоненты и создадим пользовательские компоненты, из которых состоят другие компоненты и элементы.
### Настройка страницы
Для работы с React в браузере необходимо импортировать две библиотеки: React и ReactDOM. React — это библиотека для создания представлений. ReactDOM — это библиотека для рендеринга пользовательского интерфейса в браузере. Обе библиотеки доступны в виде сценариев из распакованного CDN (ссылки приведены в коде ниже). Создадим HTML-документ:
```
React Samples
// Pure React and JavaScript code
```
Это минимальные требования для работы с React в браузере. Можно разместить свой сценарий JavaScript в отдельном файле, но он должен быть загружен где-нибудь на странице после загрузки React. Мы собираемся использовать версию React для разработки, чтобы все сообщения об ошибках и предупреждения выводились в консоли браузера. Вы можете использовать уменьшенную релизную версию (react.production.min.js и react.production.min.js), если захотите убрать предупреждения.
### Элементы React
HTML — это просто набор инструкций, которые браузер выполняет при создании DOM. Элементы, составляющие HTML-документ, становятся элементами DOM, когда браузер загружает код HTML и отображает пользовательский интерфейс.
Допустим, вам нужно построить иерархию HTML для рецепта. Возможное решение такой задачи может выглядеть примерно так:
```
Baked Salmon
============
* 2 lb salmon
* 5 sprigs fresh rosemary
* 2 tablespoons olive oil
* 2 small lemons
* 1 teaspoon kosher salt
* 4 cloves of chopped garlic
Cooking Instructions
--------------------
Preheat the oven to 375 degrees.
Lightly coat aluminum foil with oil.
Place salmon on foil
Cover with rosemary, sliced lemons, chopped garlic.
Bake for 15-20 minutes until cooked through.
Remove from oven.
```
В HTML элементы связаны друг с другом в иерархии, напоминающей генеалогическое древо. Можно сказать, что у корневого элемента (в данном случае раздела) есть три дочерних элемента: заголовок, неупорядоченный список ингредиентов и раздел для инструкций.
В прошлом веб-сайты состояли из отдельных HTML-страниц. Когда пользователь перемещался по этим страницам, браузер запрашивал и загружал различные HTML-документы. Изобретение AJAX (асинхронного JavaScript и XML) подарило нам одностраничные приложения, или SPA (https://ru.wikipedia.org/wiki/Одностраничное\_приложение). Поскольку браузеры теперь могут с помощью AJAX запрашивать и загружать маленькие фрагменты данных, целые веб-приложения теперь могут работать на одной странице и обновлять пользовательский интерфейс инструментами JavaScript.
В SPA браузер изначально загружает один HTML-документ. Перемещаясь по сайту, пользователи фактически остаются на той же странице. JavaScript уничтожает пользовательский интерфейс и создает новый всякий раз, когда пользователь взаимодействует с приложением. Может показаться, что вы перемещаетесь со страницы на страницу, но на самом деле вы находитесь на одной HTML-странице, а JavaScript выполняет всю работу.
DOM API (https://developer.mozilla.org/en-US/docs/Web/API/Document\_Object\_Model) представляет собой набор объектов, которые JavaScript может использовать при взаимодействии с браузером для изменения модели DOM. Если вы когда-либо использовали функцию document.createElement или document.appendChild, то вы уже работали с DOM API.
React — это библиотека, которая предназначена для обновления DOM браузера. Нам больше не нужно беспокоиться о сложностях, связанных с созданием высокопроизводительных SPA, потому что React делает все сам. В React мы не взаимодействуем напрямую с DOM API. Вместо этого мы сообщаем React, что нам нужно построить, а она сама занимается рендерингом и согласованием элементов, которые нужно создать.
Модель DOM браузера состоит из элементов DOM. Аналогично React DOM состоит из элементов React. Элементы DOM и React на вид похожи, но на самом деле они совершенно разные. Элемент React — это описание того, как должен выглядеть фактический элемент DOM. Другими словами, элементы React — это инструкции по созданию DOM браузера.
Мы можем создать элемент React для представления тега h1с с помощью функции React.createElement:
```
React.createElement("h1", { id: "recipe-0" }, "Baked Salmon");
```
Первый аргумент определяет тип элемента, который мы хотим создать — в данном случае h1. Второй аргумент определяет свойства элемента. Элемент h1 имеет идентификатор recipe-0. Третий аргумент соответствует дочерним элементам: это могут быть любые узлы, вставленные между открывающим и закрывающим тегами (в данном случае только некоторый текст).
Во время рендеринга React преобразует этот элемент в реальный элемент DOM:
```
Baked Salmon
============
```
Свойства аналогичным образом применяются к новому элементу DOM: они добавляются к тегу как атрибуты, а дочерний текст добавляется как текст внутри элемента. Элемент React — это просто литерал JavaScript, который сообщает React, как создать элемент DOM.
В журнале этот элемент выглядит так:
```
{
$$typeof: Symbol(React.element),
"type": "h1",
"key": null,
"ref": null,
"props": {id: "recipe-0", children: "Baked Salmon"},
"_owner": null,
"_store": {}
}
```
Именно так выглядит структура элемента React. Некоторые поля используются самим React: \_owner, \_store, и $$typeof. Поля key и ref тоже важны для элементов React, но мы познакомимся с ними позже. А пока подробнее рассмотрим поля type и props.
Свойство type элемента React сообщает React, какой тип элемента HTML или SVG нужно создать. Свойство props содержит данные и дочерние элементы, необходимые для создания элемента DOM. Свойство children предназначено для рендеринга других вложенных элементов в виде текста.
> **СОЗДАНИЕ ЭЛЕМЕНТОВ**
>
> Мы заглядываем в объект, который возвращает функция React.createElement. Но создавать подобные элементы вручную не нужно, вместо этого вы всегда будете использовать функцию React.createElement.
### ReactDOM
Создав элемент React, мы захотим увидеть его в браузере. ReactDOM содержит необходимые для этого инструменты, например метод render.
Мы можем отобразить элемент React и его дочерние элементы в DOM с помощью метода React DOM.render. Для этого мы передадим этот элемент в качестве первого аргумента, а вторым аргументом будет целевой узел, в котором нужно отобразить элемент:
```
const dish = React.createElement("h1", null, "Baked Salmon");
ReactDOM.render(dish, document.getElementById("root"));
```
Рендеринг элемента title в DOM добавит элемент h1 в div с идентификатором root, который мы уже определили в нашем HTML. Этот div размещается внутри тега body:
```
Baked Salmon
============
```
Все, что связано с рендерингом элементов в DOM, находится в пакете ReactDOM. В версиях React вплоть до React 16 в DOM можно было отображать только один элемент. Сегодня можно также отображать массивы. Когда такая возможность была анонсирована на ReactConf 2017, все аплодировали и кричали. Это было большое дело. Вот как оно выглядит:
```
const dish = React.createElement("h1", null, "Baked Salmon");
const dessert = React.createElement("h2", null, "Coconut Cream Pie");
ReactDOM.render([dish, dessert], document.getElementById("root"));
```
Этот код отобразит оба элемента как одноуровневые внутри корневого контейнера. Надеемся, вы тоже аплодируете и кричите!
В следующем разделе мы узнаем, как использовать метод props.children.
#### Потомки
React отображает дочерние элементы с помощью метода props.children. В предыдущем разделе мы отобразили текстовый элемент как дочерний элемента h1, и поэтому для метода props.children было установлено значение «Baked Salmon». Мы можем отображать другие элементы React как дочерние, создавая *дерево элементов*. Вот почему мы используем термин дерево элементов: у него есть один корневой элемент, от которого вырастает множество ветвей.
Рассмотрим неупорядоченный список ингредиентов:
```
* 2 lb salmon
* 5 sprigs fresh rosemary
* 2 tablespoons olive oil
* 2 small lemons
* 1 teaspoon kosher salt
* 4 cloves of chopped garlic
```
В этом примере неупорядоченный список является корневым элементом и имеет шесть дочерних элементов. Мы можем представить этот ul и его дочерние элементы с помощью React.createElement:
```
React.createElement(
"ul",
null,
React.createElement("li", null, "2 lb salmon"),
React.createElement("li", null, "5 sprigs fresh rosemary"),
React.createElement("li", null, "2 tablespoons olive oil"),
React.createElement("li", null, "2 small lemons"),
React.createElement("li", null, "1 teaspoon kosher salt"),
React.createElement("li", null, "4 cloves of chopped garlic")
);
```
Каждый дополнительный аргумент, передаваемый функции createElement, является еще одним дочерним элементом. React создает массив этих дочерних элементов и устанавливает для него значение props.children.
Проверив получившийся элемент React, мы увидим, что каждый элемент списка представлен элементом React и добавлен в массив props.children. Если мы выведем этот элемент в журнал:
```
const list = React.createElement(
"ul",
null,
React.createElement("li", null, "2 lb salmon"),
React.createElement("li", null, "5 sprigs fresh rosemary"),
React.createElement("li", null, "2 tablespoons olive oil"),
React.createElement("li", null, "2 small lemons"),
React.createElement("li", null, "1 teaspoon kosher salt"),
React.createElement("li", null, "4 cloves of chopped garlic")
);
console.log(list);
```
то результат будет таким:
```
{
"type": "ul",
"props": {
"children": [
{ "type": "li", "props": { "children": "2 lb salmon" } … },
{ "type": "li", "props": { "children": "5 sprigs fresh rosemary"} … },
{ "type": "li", "props": { "children": "2 tablespoons olive oil" } … },
{ "type": "li", "props": { "children": "2 small lemons"} … },
{ "type": "li", "props": { "children": "1 teaspoon kosher salt"} … },
{ "type": "li", "props": { "children": "4 cloves of chopped garlic"} … }
]
...
}
}
```
Теперь видно, что каждый элемент списка является дочерним. Ранее в этой главе мы писали код HTML для всего рецепта, расположив его в элементе section. Чтобы повторить это с помощью React, мы будем использовать серию вызовов createElement:
```
React.createElement(
"section",
{ id: "baked-salmon" },
React.createElement("h1", null, "Baked Salmon"),
React.createElement(
"ul",
{ className: "ingredients" },
React.createElement("li", null, "2 lb salmon"),
React.createElement("li", null, "5 sprigs fresh rosemary"),
React.createElement("li", null, "2 tablespoons olive oil"),
React.createElement("li", null, "2 small lemons"),
React.createElement("li", null, "1 teaspoon kosher salt"),
React.createElement("li", null, "4 cloves of chopped garlic")
),
React.createElement(
"section",
{ className: "instructions" },
React.createElement("h2", null, "Cooking Instructions"),
React.createElement("p", null, "Preheat the oven to 375 degrees."),
React.createElement("p", null, "Lightly coat aluminum foil with oil."),
React.createElement("p", null, "Place salmon on foil."),
React.createElement(
"p",
null,
"Cover with rosemary, sliced lemons, chopped garlic."
),
React.createElement(
"p",
null,
"Bake for 15-20 minutes until cooked through."
),
React.createElement("p", null, "Remove from oven.")
)
);
```
> **CLASSNAME В REACT**
>
> Любой элемент, имеющий атрибут HTML class, использует свойство className вместо class, поскольку class — зарезервированное слово в JavaScript. Вот так выглядит чистый код React. В конечном итоге чистый код React — это то, что работает в браузере. Приложение React — это дерево элементов React, которые происходят из одного корневого элемента. Элементы React — это инструкции, которые React будет использовать для создания пользовательского интерфейса в браузере.
#### Создание элементов с данными
Основным преимуществом React является его способность отделять данные от элементов пользовательского интерфейса. Поскольку React — это JavaScript, мы можем добавить логику JavaScript, которая поможет нам построить дерево компонентов React. Например, ингредиенты можно хранить в массиве, и мы можем сопоставить массив с элементами React.
Вернемся назад и вспомним о неупорядоченном списке:
```
React.createElement(
"ul",
null,
React.createElement("li", null, "2 lb salmon"),
React.createElement("li", null, "5 sprigs fresh rosemary"),
React.createElement("li", null, "2 tablespoons olive oil"),
React.createElement("li", null, "2 small lemons"),
React.createElement("li", null, "1 teaspoon kosher salt"),
React.createElement("li", null, "4 cloves of chopped garlic")
);
```
Данные, используемые в этом списке ингредиентов, можно представить с помощью массива JavaScript:
```
const items = [
"2 lb salmon",
"5 sprigs fresh rosemary",
"2 tablespoons olive oil",
"2 small lemons",
"1 teaspoon kosher salt",
"4 cloves of chopped garlic"
];
```
Из этих данных можно создать список с правильным количеством элементов без необходимости жесткого кодирования каждого из них. Мы можем отображать массив и создавать элементы списка для любого количества ингредиентов:
```
React.createElement(
"ul",
{ className: "ingredients" },
items.map(ingredient => React.createElement("li", null, ingredient))
);
```
Этот синтаксис создает элемент React для каждого ингредиента в массиве. Каждая строка отображается в дочерних элементах списка как текст. Значение для каждого ингредиента отображается как элемент списка.
При запуске этого кода вы увидите предупреждение консоли, подобное показанному на рис. 4.1.
Когда мы создаем список дочерних элементов путем итерации по массиву, React хочет, чтобы каждый из них имел свойство key. Свойство key помогает React эффективно обновлять DOM. Вы можете убрать это предупреждение, добавив уникальное свойство key для каждого элемента записи списка. Вы можете использовать индекс массива для каждого ингредиента как уникальное значение:
```
React.createElement(
"ul",
{ className: "ingredients" },
items.map((ingredient, i) =>
React.createElement("li", { key: i }, ingredient)
)
);
```
О ключах мы позже поговорим более подробно, когда будем обсуждать JSX, но их добавление к каждому элементу списка уберет предупреждение из консоли.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/react-sovremennye-shablony-dlya-razrabotki-prilozheniy-2-e-izdanie)
» [Оглавление](https://www.piter.com/collection/new/product/react-sovremennye-shablony-dlya-razrabotki-prilozheniy-2-e-izdanie#Oglavlenie-1)
» [Отрывок](https://www.piter.com/collection/new/product/react-sovremennye-shablony-dlya-razrabotki-prilozheniy-2-e-izdanie#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **React**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/577862/ | null | ru | null |
# Типограф Евгения Муравьева для TinyMCE
В топике [Новая версия веб-типографа Студии Муравьёва](http://habrahabr.ru/blogs/typography/67010/) был представлен замечательный типограф.
> Типограф обрабатывает тексты не только по классическим законам (неразрывные пробелы, правильные кавычки, свисающая пунктуация и др.), но и по взятым канонам из «Справочника издателя и автора» Мильчина А. Э. Любители типографики должны это оценить.
>
>
Я использовал его в своем движке магазина, и побочным продуктом стал простой и удобный плагин для TinyMCE.
При нажатии на кнопку не отображается никаких всплывающих окон, текс молча типографируется.
[Скачать этот типограф для TinyMCE](http://simplacms.ru/jaretypograph.zip)
[Онлайн-демо](http://simplacms.ru/demo/admin/index.php?section=Section&menu=1)
Как прикрутить его к TinyMCE
----------------------------
### 1. Скопировать папку jaretypograph в tiny\_mce/plugins
### 2. Подключить плагин при инициализации Tinymce
Примерно так:
`tinyMCE.init({
...
plugins : "jaretypograph",
...
});`
### 3. Вывести на тулбар редактора кнопку плагина
Примерно так:
`tinyMCE.init({
...
theme_advanced_buttons1 : "jaretypograph",
...
});`
Типограф работает на PHP5 и UTF8.
**UPD.** ~~При типографировании выделенного фрагмента иногда происходит глюк по причине того, что TinyMCE обрамляет выделенный фрагмент лишними тегами, если внутри фрагмента есть разорванные теги. Если кто-то знает как это обойти, буду благодарен.~~
Спасибо [dfuse](https://habrahabr.ru/users/dfuse/) за помощь, исправлено!
**UPD2.** ~~В некоторых браузерах при типографировании вставляется лишний перевод строки в начало текста. Исправляем.~~
Исправлено! | https://habr.com/ru/post/67387/ | null | ru | null |
# Уязвимость старой Ubuntu через аудиофайл, проигрываемый эмуляцией процессора 1975 года
Уязвимость и ошибка логического разделения поселились в плеере [gstreamer](https://ru.wikipedia.org/wiki/GStreamer) версий 0.10.x для [музыкальных файлов](https://ru.wikipedia.org/wiki/NES_Sound_Format) Nintendo Entertainment System, [сообщил](https://scarybeastsecurity.blogspot.ru/2016/11/0day-exploit-compromising-linux-desktop.html) Крис Эванс в своем блоге о кибербезопасности. Уязвимость системы позволяет получить стабильный доступ к использованию и обхождению 64-битных [ASLR](https://ru.wikipedia.org/wiki/ASLR), [DEP](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B4%D0%BE%D1%82%D0%B2%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85) и так далее. Такое стало возможным благодаря наличию поддержки тьюринг-полного скриптования музыкальных файлов внутри плеера. Уязвимость кроется в поддержке обратной совместимости.
Уязвимости подвержена Ubuntu старой, все еще поддерживаемой LTS-версии 12.04.5. В последующих версиях используется новый glibc, и эксплойт в системе уже не работает.
### Что собой представляет
Автор анализа приводит скриншот вызова эксплойта.
Процесс активации происходит без инициализации зараженного файла, для этого достаточно зайти в папку с ним.
Находится баг в файле звукового декодера `libgstnsf.so` из дистрибутива `gstreamer-0.10`, который используется в системе по умолчанию для всех задач, связанных со звуком. В Ubuntu 14.04 тоже есть этот декодер, но по умолчанию в большинстве случаев используется `gstreamer-1.0`.
В процессе инсталляции Ubuntu система как бы между прочим задает вопрос, хочет ли пользователь работать с mp3-файлами. Множество дополнительных пакетов устанавливаются после положительного ответа, включая плагины из пакета Bad — те, которые не всегда радуют качеством: у них нет ревью кода, мейнтейнера, документации и так далее.
### Как выглядит атака
Эксплойт злоупотребляет уязвимостью плагина для воспроизведения музыкальных файлов NSF. Эти аудиотреки не похожи на обычные дорожки, которые воспроизводит персональный компьютер.
Файлы формата NSF проигрывает эмулятор процессора консоли NES и звуковое аппаратное обеспечение в реальном времени. Кроме этого внутри NSF-файла может быть набор инструкций. Чтобы проиграть его, уязвимый аудиоплеер эмулировал процессор сорокалетней давности. В подверженной уязвимости версии Ubuntu два плеера, но во втором `libgme` ошибки нет.
Плагин `gstreamer` создает виртуальное аппаратное окружение процессора 6502 и проигрывает музыку, запуская часть кода на эмуляторе. Затем он считывает результирующие значения из виртуальных звуковых регистрах и рендерит звуковые сэмплы на их основе.
Формат звука NES — стандарт музыкального файла, который сжимает музыку к игре NES для воспроизведения. Он содержит язык скрипта, который используется для запуска уязвимости. Когда вы открываете файл NSF на зараженной системе Ubuntu, он находит свой путь к файлу `libgstnsf.so` через музыкальный плеер и мультимедийный фреймворк gstreamer.
Интересующиеся примером могут скачать файл аудио из Castlevania 2 [cv2.nsf](http://security.appspot.com/security/nsf/cv2.nsf). Если ваша Linux поддерживает данный формат, звук проиграется командой вроде `totem cv2.nsf`. Это крохотный файл в 17264 байта содержит небольшую программу — сэмплы в таком на поместятся. Если система не распознает такой формат, она предложит скачать недостающий плагин.
Плагин работает в процессе эмуляции реального 6502, как в NES для получения музыки на выходе и где-то здесь и находится уязвимость. Так что дело не только в многослойной обратной совместимости для проигрывания непонятных форматов музыкальных файлов, но и эмуляции программы для «восьмибитки» из 1970-х годов.
Какими способами можно использовать такую уязвимость:
* Переслать эксплойт как приложение к письму. Если жертва загружает и открывает файлы, ее система под угрозой. Многие конфигурации Linux не знают, как работать с файлом NSF — так что вы можете переименовать его в mp3. Большинство медиа-плееров на основе `gstreamer` проигнорируют расширение файла и применят автоматическое определение формата для загрузки соответствующего декодера к нему.
* Частичная [drive-by download](https://en.wikipedia.org/wiki/Drive-by_download). Используя, в некотором смысле рискованную, загрузку файлов через Google Chrome, возможно свалить файлы в папку загрузок системы жертвы, когда пользователь посещает «неправильные» веб-страницы. Когда позже директория загрузок открывается файловым менеджером, то ПО пытается показать иконки к файлам с понятными системе расширениями.
* Полная drive-by download. При аналогичной небезопасной загрузке через браузер Google Chrome существует путь возможной полной попутной загрузки. Крис обещал рассказать об этом в следующей статье своего [блога.](https://scarybeastsecurity.blogspot.ru/)
* Атака на основе USB-накопителя. Если открыть флешку в файловом менеджере, он опять же попытается отрисовать иконки файлов.
### Дополнительные объяснения
Этот эксплойт работает одинаково хорошо при запуске в следующих программах:
* [Totem](https://ru.wikipedia.org/wiki/Totem)
* [Rhythmbox](https://ru.wikipedia.org/wiki/Rhythmbox)
* [gst-launch-0.10](https://linux.die.net/man/1/gst-launch-0.10)
* [Nautilus](https://ru.wikipedia.org/wiki/Nautilus_(%D1%84%D0%B0%D0%B9%D0%BB%D0%BE%D0%B2%D1%8B%D0%B9_%D0%BC%D0%B5%D0%BD%D0%B5%D0%B4%D0%B6%D0%B5%D1%80)) (может запустить подпроцесс)
Подробности описаны в соответствующих разделах [поста Криса](https://scarybeastsecurity.blogspot.ru/2016/11/0day-exploit-compromising-linux-desktop.html): обзор самого эксплойта, возможные варианты уязвимостей, детали эксплойта.
Также он пишет о том, что найденная ошибка формально относится к 0-day уязвимостям, но поражает только старую Ubuntu 12.04, которая вышла в апреле 2012 года и является long-term support-версией. Ее [будут поддерживать](https://en.wikipedia.org/wiki/Ubuntu_version_history#Ubuntu_12.04_LTS_.28Precise_Pangolin.29) до 26 апреля 2017 года. Проблема скорее minor, чем major. Факт того, что она пришла через процессор 1975 года, остается забавным.
**P.S.** Уязвимость уже была [исправлена](http://changelogs.ubuntu.com/changelogs/pool/universe/g/gst-plugins-bad0.10/gst-plugins-bad0.10_0.10.23-7.2ubuntu1.2/changelog) членами команды Ubuntu. | https://habr.com/ru/post/315378/ | null | ru | null |
# Время Perl
Perl и CPAN предоставляют множество самых разных инструментов для работы с временем. Традиционный и наиболее известный `DateTime` вызывает столь же традиционные серьёзные нарекания к скорости работы и потреблению памяти, поэтому он постепенно стал вытесняться из нашей системы альтернативными модулями. TIMTOWDI — это замечательно, но в проекте всё-таки хочется иметь какой-никакой порядок. Поэтому мы решили протестировать несколько самых популярных модулей по скорости, функционалу и удобству использования и выбрать тот самый единственный, который станет нашим основным инструментом.
### **Начальные условия**
Прежде чем проводить тесты, нужно было определиться с требованиями к модулям. Для нашего проекта были поставлены следующие условия.
Необходимый функционал:
* работа с временными зонами (вычисления с зонами, определение локальной);
* парсинг и форматирование строки с временем по шаблону;
* работа с интервалами времени (прибавить день, отнять неделю, посчитать разницу между датами);
* работа с такими понятиями как «первая неделя октября» или «двенадцатая неделя года» и т. п.
Дополнительные условия:
* желательно один объект времени, с которым можно было бы работать;
* лаконичный код;
* модуль не должен быть заброшенным (давно не обновлялся, множество незакрытых багов);
* работа в Debian со стандартным Perl (сейчас это v5.14.2).
Критерии оценки:
* соответствие требованиям по функционалу;
* скорость работы;
* адекватный интерфейс;
* субъективное удобство использования.
### **Модули**
Модулей для работы с временем очень много, я выбрал наиболее популярные из них — чаще всего встречающиеся как в коде, так и в публикациях и рассказах коллег. Получившийся список (с номером версии, используемой в тестах):
* [DateTime](https://metacpan.org/pod/DateTime) (1.18);
* [Date::Manip](https://metacpan.org/pod/Date::Manip) (6.48);
* [Time::Piece](https://metacpan.org/pod/Time::Piece) (1.29);
* [Panda::Date](https://metacpan.org/pod/Panda::Date) (3.0.2);
* [Date::Calc](https://metacpan.org/pod/Date::Calc) (6.4);
* [Time::Moment](https://metacpan.org/pod/Time::Moment) (0.22).
Я сделаю краткий обзор возможностей и особенностей, влияющих на результаты тестов, и приведу результаты замеров. Подробное описание каждого модуля можно найти в родной документации.
#### ***[DateTime](https://metacpan.org/pod/DateTime)***
Наверное, наиболее популярный модуль. Точнее, даже группа модулей, т. к. разный функционал разделён по разным пространствам имён. В целом функционал `DateTime` очень широк, но модуль часто подвергается критике за низкую производительность.
При создании нового объекта учитывается время с точностью до секунды, но работать может с точностью до наносекунд.
Парсить строки с датами сам по себе не умеет, но есть множество готовых парсеров (форматтеров), `DateTime::Format::*`. Они же используются и для формирования строки с временем в необходимом формате, если реализуют метод `format_datetime`. Для тестов я буду использовать `DateTime::Format::ISO8601` (чаще используется в разных API и сервисах) и `DateTime::Format::Strptime` (позволяет использовать свой шаблон, аналогичный strptime). Также можно создать свой собственный парсер с помощью `DateTime::Format::Builder`.
Для работы с временными зонами можно использовать объекты `DateTime::TimeZone`, но это необязательно. Например, создать объект времени в определённой зоне можно просто указав `time_zone => 'Asia/Taipei'`. Важно понимать, что описание зон находится в самом модуле и за их актуальностью нужно следить отдельно. Также можно вместо строки передать заранее подготовленный объект `DateTime::TimeZone`, что может быть полезно, когда мы используем локальную временную зону. Определение её может быть долгим и эффективнее заранее подготовить объект, например, так:
```
state $tz = DateTime::TimeZone->new( name => 'local' );
```
Для работы с интервалами используются объекты `DateTime::Duration`, эти же объекты возвращаются при вычитании дат.
Сравнение дат можно выполнять как с учетом долей секунд, так и по целым значениям, используя соответствующие методы `DateTime->compare( $dt1, $dt2 )` и `DateTime->compare_ignore_floating( $dt1, $dt2 )`.
В целом интерфейс модуля мне кажется достаточно простым и понятным. Использование множества модулей может кому-то показаться неудобным, но организованы они грамотно и я не могу назвать это недостатком.
```
# Пустой объект создавать не умеет, для new всегда нужны параметры.
my $dt = DateTime->new(
year => 1964,
month => 10,
day => 16,
hour => 16,
minute => 12,
second => 47,
nanosecond => 500_000_000,
time_zone => 'Asia/Taipei',
);
# Объект с текущим локальным временем
$dt = DateTime->now();
# Объект с текущим временем UTC
$dt = DateTime->now( time_zone => 'UTC' );
# Объект с текущим временем в заданной временной зоне
$dt = DateTime->now( time_zone => '+1000' );
# Парсинг строки (ISO8601)
$dt = DateTime::Format::ISO8601->parse_datetime('2015-02-18T10:50:31.521345123+10:00');
# Парсинг строки по шаблону (медленнее, чем ISO8601)
my $dt_format = DateTime::Format::Strptime->new(
pattern => '%Y-%m-%dT%H:%M:%S.%9N%z',
on_error => 'croak',
);
$dt = $dt_format->parse_datetime('2015-02-18T10:50:31.521345123+1000');
# Генерация строки по шаблону
my $str = $dt_format->format_datetime($dt);
# Прибавить 1 год 2 месяца 3 дня 4 часа 5 минут и 6 секунд
my $dt_duration = DateTime::Duration->new(
years => 1,
months => 2,
days => 3,
hours => 4,
minutes => 5,
seconds => 6,
);
my $dt2 = $dt + $dt_duration;
# Сравнить даты
my $result = DateTime->compare( $dt, $dt2 ); # результат: -1 т. к. $dt < $dt2
# Интервал между датами
my $interval = $dt2->subtract_datetime( $dt1 );
# Определение начала / конца недели и месяца
my $week_begin = $dt->clone->truncate( to => 'week' );
my $week_end = $week_begin->clone->add( days => 6 );
my $month_begin = $dt->clone->truncate( to => 'month' );
my $month_end = $month_begin->clone->add( months => 1 )->subtract( days => 1 );
```
#### ***[Date::Manip](https://metacpan.org/pod/Date::Manip)***
Главной особенностью этого модуля я бы назвал всеядность. Он умеет делать весьма хитрые манипуляции, например, определять дату по строке «8:00pm December tenth», и даже на разных языках. Но документация к этому модулю — самая непонятная (по крайней мере мне). Подобно `DateTime`, функционал разделён по множеству модулей, но логика их разделения не очевидна. Для того, чтобы создать новый объект, приходится использовать документацию сразу к трём модулям — `Date::Manip`, `Date::Manip::Date`, `Date::Manip::Obj`.
С долями секунды работать не умеет, хотя это и не всегда необходимо, но для кого-то может оказаться критичным.
Умеет парсить строковые даты вроде «8:00pm December tenth» или «4 business days later», ещё и на разных языках. Это очень круто, но я лично с такой задачей никогда не сталкивался. Наверное, это имеет смысл при работе с каким-то слабостандартизированным (или намеренно очень свободным) пользовательским вводом.
Интервалы представлены объектами `Date::Manip::Delta`, они же возвращаются как разность между датами.
Для сравнения дат используется специальный метод:
```
$dm_date1->cmp( $dm_date2 );
```
Определение начала и конца недели и месяца возможно, но неудобно и очень медленно — для этого приходится выполнять несколько операций, и все они не радуют скоростью.
Не умеет создавать копию существующего объекта.
В целом интерфейс довольно специфичный. Наверное, к нему можно привыкнуть, и тогда он будет казаться более красивым (как с ObjectiveC), но нужно ли это делать?
```
# Новые пустые объекты. Отдельно для модуля и отдельно для даты, рекомендуется именно так,
# потому что внутри создаются и переиспользуются базовые объекты.
my $dm = Date::Manip::Date->new;
my $dt = $dm->new_date;
# Текущее локальное время. Только через парсинг.
$dt->parse('now');
# Текущее время UTC
$dt->parse('now gmt');
# Время в заданной зоне
$date->parse('now gtm+10');
# Парсинг строки (ISO8601)
$date->parse('2015-02-18T10:50:31.521345123+10:00');
# Генерация строки по шаблону
my $str = $dm_date->printf("%Y.%m.%d %H-%M-%S %z");
# Прибавить 1 год 2 месяца 3 дня 4 часа 5 минут и 6 секунд
my $dm_delta = Date::Manip::Delta->new;
$dm_delta->parse('1:2:0:3:4:5:6'); # 0 — недели
my $dm_date2 = $dm_date->calc( $dm_delta );
# Сравнить даты
my $result = $dm_date1->cmp( $dm_date2 ); # -1
# Интервал между датами
my $interval = $dm_date2->calc( $dm_date1 );
# Определение начала и конца текущих недели и месяца
# (каждый раз использую parse('now') т. к. не знаю, как копировать готовый объект)
my $week_begin = $dm_date->new_date;
$week_begin->parse('now');
$week_begin->prev(1,1,[0,0,0]); # Перевести дату на понедельник 00:00:00
# первый аргумент значит, что ищем понедельник (1-й день недели)
# второй значит, что текущий день тоже считается
# третий - время дня (ч,м,с)
my $week_end = $dm_date->new_date;
$week_end->parse('now');
$week_end->prev(7,1,[0,0,0]);
my $month_begin = $dm_date->new_date;
$month_begin->parse('now');
$month_begin->set('time',[0,0,0]);
$month_begin->set('d',1);
my $delta = Date::Manip::Delta->new;
$delta->parse('0:1:0:-1:0:0:0');
my $month_end = $dm_m1->calc( $delta );
```
#### ***[Time::Piece](https://metacpan.org/pod/Time::Piece)***
Ещё один очень популярный модуль. К тому же, это core-модуль, входящий в поставку Perl. По сути своей является ОО-оберткой над стандартными функциями. По умолчанию перекрывает `localtime` и `gmtime`. Пустой объект создавать не умеет, при вызове `new` делает то же самое, что и `localtime`, но если передан другой объект `Time::Piece`, то создаёт его копию.
Не умеет менять временную зону созданного объекта, но время в нужной зоне можно получить по смещению (в секундах).
Парсить умеет только по шаблону `strptime`, что достаточно в большинстве случаев.
С долями секунды работать не умеет.
Все вычисления производятся с секундами. Для удобства есть предустановленные константы из `Time::Seconds` (`ONE_DAY`, например). Результаты вычислений получаются не совсем очевидные, так `'2015-02-25 10:33:25' + ONE_YEAR = '2016-02-25 16:22:15'`. Все дело в том, что `ONE_YEAR` это 31556930 секунд или 365.24225 дня (да, с округлением). C месяцем то же самое: `'2015-02-01 00:00:00' + ONE_MONTH = '2015-03-03 10:29:04'`. Автор, понимая эту проблему, предусмотрел два метода объекта: `add_months` и `add_years`. Но работают они тоже с особенностями: отняв месяц от 2008-03-31, мы получим 2008-03-02. Это нужно всегда помнить и учитывать.
Можно работать с объектами, используя стандартные арифметические операторы и операторы сравнения: `-`, `+=`, `<`, `>=`, `<=>` и т. п.
В качестве разности дат возвращается объект `Time::Seconds`.
Не умеет менять день недели и месяца, только определять. В последнем тесте (определение начала и конца недели и месяца) часть работы приходится делать руками, что не очень удобно.
В целом интерфейс достаточно простой, понятный и без излишеств. Во многих случаях его будет достаточно.
```
# Текущее локальное время. Можно через ->new или через localtime
my $tp = Time::Piece->new;
$tp = localtime;
# Текущее время UTC
$tp = gmtime;
# Смещение в заданную зону делается простым сложением.
$tp += 60*60*10; # тут смещение в секундах
# Парсинг строки (по заданному шаблону)
$tp = Time::Piece->strptime('2015-02-18T10:50:31+1000', '%Y-%m-%dT%H:%M:%S%z');
# Генерация строки по шаблону
my $str = $tp->strftime("%Y.%m.%d %H-%M-%S %z");
# Прибавить 1 год 2 месяца 3 дня 4 часа 5 минут и 6 секунд
my $tp2 = $tp1 + 3 * ONE_DAY + 4 * ONE_HOUR + 5 * ONE_MINUTE + 6;
$tp2->add_years(1);
$tp2->add_months(2);
# Сравнить даты
my $result = $tp1 <=> $tp2; # -1
# Вычитание
my $interval_in_seconds = $tp1 - $tp2;
```
#### ***[Panda::Date](https://metacpan.org/pod/Panda::Date)***
Модуль написан с использованием XS и позиционируется как очень быстрый. Имеет существенное ограничение — для сборки требуется Perl 5.18 или выше.
По умолчанию для парсинга принимает строки вида '2013-03-05 23:45:56'. Но можно задать и другой формат (глобально):
```
Panda::Date::string_format("%Y%m%d%H%M%S");
```
При парсинге создаются объекты с локальной временной зоной.
С долями секунды работать не умеет.
Может производить вычисления без использования дополнительных объектов (складывать даты с датам, а не с интервалами), но можно использовать и объекты `Panda::Date::Int`. Умеет прибавлять строки вида '3Y 2D' (3 года и 2 дня) или объекты типа `Panda::Date::Rel`, такое сложение работает даже быстрее, чем сложение с `ARRAYREF`. При вычитании дат возвращает объект `Panda::Date::Int`.
Для сравнения используется только оператор `<=>`.
Позволяет манипулировать днём недели через `day_of_week`, при этом неделя начинается с воскресенья (значение 0). Или можно использовать `ewday`, тогда неделя начинается с понедельника (значение 1) и заканчивается воскресеньем (7).
```
# Пустой объект создать нельзя
# Можно создать объект с текущим временем тремя разными способами
my $pd = Panda::Date->new;
my $pd = Panda::Date->new( time );
my $pd = now; # импортировано по умолчанию
# При этом скорость у всех разная. Результат теста
# Rate Panda::Date new(time) Panda::Date new Panda::Date now
# Panda::Date new(time) 742853/s -- -9% -23%
# Panda::Date new 813840/s 10% -- -16%
# Panda::Date now 967947/s 30% 19% --
# Текущее локальное время (рекомендуется использовать now).
$pd = now;
# Текущее время UTC
$pd = Panda::Date->new( time, 'UTC' );
# Время в заданной зоне
$pd->to_tz('UTC-10');
# Парсинг строки (только в заданном глобально формате)
$pd = Panda::Date->new('2015-02-18 10:50:31');
# Генерация строки по шаблону
my $str = $pd->strftime("%Y.%m.%d %H-%M-%S %z");
# Прибавить 1 год 2 месяца 3 дня 4 часа 5 минут и 6 секунд
my $pd1 = Panda::Date::now;
my $pd2 = $pd1 + [1,2,3,4,5,6];
my $pd2 = $pd1 + '1Y 2M 3D 4h 5m 6s'; # работает быстрее
# Сравнить даты
my $result = $pd1 <=> $pd2;
# Вычитание дат
my $interval = $pd1 - $pd2;
```
#### ***[Date::Calc](https://metacpan.org/pod/Date::Calc)***
Ещё один популярный модуль. Отличительной особенностью его является то, что он использует простой массив для хранения информации о дате и времени вместо специального объекта. Интерфейс достаточно прост и понятен. Много разных функций для манипуляций с датами, чуть меньше для манипуляций с временем. Работает с точностью до секунд.
В отличие от других модулей, не имеет встроенного механизма для генерации строк с временем, а парсить умеет только даты, и то в специфичном формате. Поэтому в тестах на парсинг и генерацию строк не участвует.
Функции для сравнения дат нет, но для этого вполне можно использовать функции вычисления разницы между датами, как рекомендуется в описании к модулю.
```
# Получение локальных даты и времени
my @dc = Today_and_Now();
# Получение времени UTC осуществляется передачей дополнительного параметра.
@dc = Today_and_Now(1);
# Для определения времени в том или ином часовом поясе можно использовать время UTC и смещение
# на необходимое количество часов
my @delta_tz = (0, 10, 0, 0); # дни, часы, минуты, секунды
my @dc_tz =Add_Delta_DHMS( Today_and_Now(1), @delta_tz );
# Прибавить 1 год 2 месяца 3 дня 4 часа 5 минут и 6 секунд
@dc = Add_Delta_YMDHMS( @dc, (1,2,3,4,5,6) );
# Сравнить даты
my @dc1 = (2015,2,18,10,50,31);
my @dc2 = (2015,2,18,10,50,32);
my $result = 0+Delta_DHMS( @dc1, @dc2 ); # положительный результат означает,
# что дата 2 больше даты 1
# Вычитание
my @interval = Delta_YMDHMS( @dc1, @dc2 );
# Определение начала / конца недели и месяца. Многое нужно делать вручную.
@dc =Today(); # получаем сразу без времени
my $dow =Day_of_Week( @dc );
my @week_begin =Add_Delta_Days( @dc, (1 - $dow) );
my @week_end =Add_Delta_Days( @week_begin, 6 );
my @month_begin = @dc;
$month_begin[2] = 1; # просто меняем день месяца
my @month_end =Add_Delta_Days( Add_Delta_YMD( @month_begin, (0,1,0) ), -1 );
```
#### ***[Time::Moment](https://metacpan.org/pod/Time::Moment)***
Достаточно новый модуль (текущая версия — 0.22), я узнал о нём только когда начал готовить эту статью.
Умеет работать с наносекундами, но по умолчанию создаёт объект с временем (локальное и UTC) с точностью до микросекунд.
Может парсить даты только в строго определённом формате — ISO 8601. Что может быть не очень удобно. При ошибке парсинга выкидывает исключение.
Может выполнять простые операции ± год / месяц / день и т. д. через специальные методы (`plus_years` например). В отличие от многих других модулей, при вычислении 2013-01-31 + 1 месяц даёт результат 2013-02-28. Что правильно, на мой взгляд. Хотя, возможно, кто-то ожидает и другого поведения.
Для сравнения дат использует стандартные операторы сравнения чисел: `<=>`, `==`, `>=` и т. д.
Нет методов для определения интервала между двумя датами. Но можно выполнить вычитание секунд с начала эпохи, полученных методом `epoch`. Это накладывает ограничения и теряется точность, но в каких-то случаях такой точности может быть достаточно (`Time::Piece` тоже ведь с секундами работает).
Для определения начала / конца месяца / недели можно использовать методы `with_day_of_week` (понедельник 1, воскресенье 7), `with_day_of_month` и математику. Для обнуления времени суток приходится использовать методы `with_*`.
В целом интерфейс очень прост, понятен и без заметных специфических особенностей (как с математикой у `Time::Piece`, например).
```
# Создать пустой объект
my $tm = Time::Moment->new;
# Создать объект с текущим локальным временем
$tm = Time::Moment->now;
# Создать объект с текущим временем UTC
$tm = Time::Moment->now_utc;
# Время в определённой зоне (заданной смещением в минутах)
my $tm_with_offset = $tm->with_offset_same_instant(600); # тут смещение в минутах
# Парсинг строки (в формате ISO8601)
$tm = Time::Moment->from_string('2015-02-18T10:50:31.521345123+10:00');
# Генерация строки по шаблону
my $str = $tm->strftime("%Y.%m.%d %H-%M-%S (%f) %z");
# Прибавить 1 год 2 месяца 3 дня 4 часа 5 минут и 6 секунд
my $tm2 = $tm1->plus_years(1)->plus_months(2)->plus_days(3)
->plus_hours(4)->plus_minutes(5)->plus_seconds(6);
# Сравнить даты
my $result = $tm1 <=> $tm2; # результат: -1
# Вычитание
my $interval_in_seconds = $tm1->epoch - $tm2->epoch;
# Определение начала / конца недели и месяца
$tm = $tm->with_hour(0)
->with_minute(0)
->with_second(0)
->with_nanosecond(0)
my $week_begin = $tm->with_day_of_week(1);
my $week_end = $tm->with_day_of_week(7)
my $month_begin = $tm->with_day_of_month(1);
my $month_end = $tm->with_day_of_month( $tm->length_of_month );
```
### **Тесты и результаты**
Код тестов [доступен на GitHub](https://github.com/sfx-public/perl_time).
Тестовая среда:
Intel Core i5-2557M CPU @ 1.70GHz, 4Gb, Mac OS X 10.10.2
Perl 5.20.1 (в Perlbrew)
Benchmark (1.18)
В результатах теста для удобства используются сокращённые названия модулей: `Date::Manip` = `D::M`, `DateTime` = `DT` и т. д.
##### *Создание объектов с текущим локальным временем*
```
Rate D::M DT T::P D::C P::D (new time) P::D (new) T::M P::D (now)
D::M 3373/s -- -73% -97% -98% -99% -100% -100% -100%
DT 12582/s 273% -- -89% -92% -98% -98% -98% -99%
T::P 119244/s 3435% 848% -- -20% -81% -82% -86% -86%
D::C 149116/s 4321% 1085% 25% -- -77% -78% -82% -82%
P::D (new time) 644519/s 19009% 5022% 441% 332% -- -5% -22% -23%
P::D (new) 677138/s 19976% 5282% 468% 354% 5% -- -18% -19%
T::M 830755/s 24531% 6503% 597% 457% 29% 23% -- -1%
P::D (now) 839971/s 24804% 6576% 604% 463% 30% 24% 1% --
```
`Panda::Date` — ожидаемо самый быстрый. Но `Time::Moment` неожиданно почти так же быстр!
##### *Создание объектов с текущим временем UTC*
```
Rate D::M DT T::P D::C P::D T::M
D::M 1999/s -- -83% -98% -99% -100% -100%
DT 11498/s 475% -- -90% -93% -98% -99%
T::P 120130/s 5909% 945% -- -26% -82% -92%
D::C 161964/s 8001% 1309% 35% -- -76% -89%
P::D 671656/s 33495% 5741% 459% 315% -- -55%
T::M 1476686/s 73761% 12743% 1129% 812% 120% --
```
Все становятся медленнее на этой операции. Все, кроме `Time::Moment`. Он становится значительно быстрее и выходит на первое место.
##### *Определение времени в конкретной временной зоне*
Определение смещения по зоне в этом тесте не производим. Смещение задаём заранее +10 часов. Разные модули по-разному предлагают задавать смещение. Одни в секундах, другие в минутах, третьи строкой типа '+1000'.
```
Rate D::M DT D::C T::P P::D T::M
D::M 1725/s -- -61% -95% -97% -100% -100%
DT 4439/s 157% -- -87% -92% -99% -99%
D::C 33939/s 1868% 665% -- -39% -92% -95%
T::P 55584/s 3122% 1152% 64% -- -87% -92%
P::D 438601/s 25327% 9782% 1192% 689% -- -40%
T::M 735173/s 42520% 16463% 2066% 1223% 68% --
```
##### *Парсинг строки (дата, время и зона)*
`Date::Calc` умеет парсить только даты (без времени) и только в определённом формате, поэтому в данном тесте он не участвует.
```
Rate D::M DT (Strptime) DT (ISO8601) T::P P::D T::M
D::M 1138/s -- -43% -63% -99% -100% -100%
DT (Strptime) 1993/s 75% -- -36% -98% -100% -100%
DT (ISO8601) 3090/s 171% 55% -- -98% -100% -100%
T::P 127471/s 11097% 6297% 4025% -- -84% -90%
P::D 792571/s 69519% 39675% 25547% 522% -- -37%
T::M 1266979/s 111190% 63482% 40899% 894% 60% --
```
##### *Генерация по шаблону*
`Date::Calc` не умеет самостоятельно форматировать строки и данный тест тоже пропускает.
```
Rate DT D::M T::P P::D T::M
DT 10895/s -- -55% -95% -98% -98%
D::M 24273/s 123% -- -88% -95% -95%
T::P 202159/s 1756% 733% -- -57% -59%
P::D 473339/s 4245% 1850% 134% -- -3%
T::M 488258/s 4382% 1912% 142% 3% --
```
##### *Вычисление даты (сложение / вычитание)*
```
Rate D::M DT T::P D::C T::M P::D (array) P::D (string)
D::M 3493/s -- -21% -71% -88% -99% -99% -100%
DT 4403/s 26% -- -64% -85% -99% -99% -100%
T::P 12092/s 246% 175% -- -58% -98% -98% -99%
D::C 29019/s 731% 559% 140% -- -94% -95% -97%
T::M 487483/s 13854% 10972% 3932% 1580% -- -16% -48%
P::D (array) 579109/s 16477% 13053% 4689% 1896% 19% -- -38%
P::D (string) 934644/s 26655% 21129% 7630% 3121% 92% 61% --
```
##### *Сравнение дат*
Нужно понимать, что разные модули работают с разной точностью. `Time::Moment` и `DateTime` — с точностью до наносекунды (для них разница между датами была 1 наносекунда), остальные до секунды (разница 1 секунда).
```
Rate D::M D::C DT T::P P::D T::M
D::M 27427/s -- -34% -64% -92% -99% -99%
D::C 41837/s 53% -- -46% -88% -99% -99%
DT 77067/s 181% 84% -- -79% -98% -98%
T::P 363376/s 1225% 769% 372% -- -88% -89%
P::D 3145500/s 11369% 7418% 3981% 766% -- -7%
T::M 3399073/s 12293% 8025% 4311% 835% 8% --
```
Работа с более высокой точностью не мешает `Time::Moment` и тут занять первое место.
##### *Определение интервала между датами (вычитание дат)*
```
Rate DT D::M D::C T::P P::D T::M
DT 6892/s -- -42% -88% -97% -99% -100%
D::M 11964/s 74% -- -78% -95% -98% -99%
D::C 55448/s 704% 363% -- -75% -93% -97%
T::P 219763/s 3089% 1737% 296% -- -71% -89%
P::D 767510/s 11036% 6315% 1284% 249% -- -63%
T::M 2085234/s 30155% 17329% 3661% 849% 172% --
```
`Time::Moment` хоть и работает быстрее всех, но делает наиболее ограниченную операцию — вычитание `epoch` (впрочем, достаточную во многих случаях). `DateTime` работает медленнее всех, но единственный, кто работает с точностью до наносекунд (что может быть лишним, но всё же).
##### *Определение начала и конца недели и месяца от текущей даты*
Комплексный тест, выполняющий сразу несколько операций. В качестве окончания недели / месяца использую начало последнего дня (время 00:00:00).
```
Rate D::M DT T::P D::C P::D T::M
D::M 93.9/s -- -88% -99% -99% -100% -100%
DT 790/s 741% -- -92% -96% -99% -100%
T::P 10060/s 10608% 1173% -- -45% -93% -94%
D::C 18309/s 19388% 2217% 82% -- -87% -90%
P::D 138748/s 147586% 17458% 1279% 658% -- -22%
T::M 177777/s 189129% 22397% 1667% 871% 28% --
```
##### *Диаграмма по результатам всех тестов*
Там, где значений не видно — они ничтожны (за исключением тех тестов, где модуль совсем не участвует).
### **Выводы**
**`Time::Moment`** — самый быстрый модуль, и при этом работает с точностью до наносекунд. Позволяет выполнять почти все необходимые операции, кроме парсинга по кастомному шаблону и вычитания дат. Мой личный фаворит по результатам тестов и по удобству интерфейса.
**`DateTime`** — наоборот, один из самых медленных модулей. Но при этом один из самых функциональных и способен работать с высокой точностью.
**`Date::Calc`** — неплохой модуль с простым и понятным интерфейсом. По сравнению с конкурентами никаких преимуществ не имеет.
**`Panda::Date`** — второй по скорости модуль. По сравнению с `Time::Moment` особыми преимуществами не обладает, а ограничение его (Perl 5.18) может быть критичным.
**`Time::Piece`** — достаточно быстрый core-модуль, но со своими особенностями в математике, которые нужно учитывать.
**`Date::Manip`** — самый медленный модуль с очень специфичным интерфейсом. Главное его преимущество — возможность парсить строки типа «8:00pm December tenth». Если есть необходимость в таком функционале, то, наверное, можно использовать этот модуль, но я бы поискал другие решения под свои задачи.
К сожалению, главной цели мне добиться не удалось — нет модулей, способных решить все поставленные задачи и работающих достаточно быстро. Но есть явный лидер — **`Time::Moment`**. И моя рекомендация будет такая:
использовать **`Time::Moment`** везде, где его функционала достаточно, а недостающий функционал закрывать модулями **`Time::Piece`** (благо доступен всегда как core-модуль) или **`DateTime`** (в самом крайнем случае).
Статьи на тему:
[www.perl.com/pub/2003/03/13/datetime.html](http://www.perl.com/pub/2003/03/13/datetime.html)
[blogs.perl.org/users/chansen/2014/08/timemoment-vs-datetime.html](http://blogs.perl.org/users/chansen/2014/08/timemoment-vs-datetime.html)
[perltricks.com/article/148/2015/2/2/Time--Moment-can-save-time](http://perltricks.com/article/148/2015/2/2/Time--Moment-can-save-time) | https://habr.com/ru/post/254453/ | null | ru | null |
# Реферер Google Search не передается в теле запроса в iOS 6
Риан Джонс [заметил](http://www.dotcult.com/google-not-sending-any-referer-data-on-ios-default-search), что реферер Google Search не передается в теле запроса, когда пользователи используют Google Search на iOS 6 (последняя версия мобильной ОС от Apple).
Я проверил этот факт и попробовал поискать на своих iPhone и iPad с iOS 6 на борту — кликнул на ссылку в результатах, и действительно, реферальная ссылка не передалась в теле запроса. Вкратце, это значит что клик по ссылке засчитывается не как переход с другого сайта, а как прямой заход на сайт.
Пример запроса при клике на ссылку в результатах Google с моего iPhone 5 с iOS 6:
```
www.rustybrick.com 142.54.83.140 – - [27/Sep/2012:09:36:28 -0400] “GET / HTTP/1.1″ 200 4386 “-” “Mozilla/5.0 (iPhone; CPU iPhone OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A405 Safari/8536.25″
```
Тот же клик на ту же ссылку, только в iOS 5:
```
www.rustybrick.com 142.54.83.140 – - [27/Sep/2012:09:37:06 -0400] “GET / HTTP/1.1″ 200 4386 “http://www.google.com/url?sa=t&source=web&cd=1&ved=0CCcQFjAA&url=http%3A%2F%2Fwww.rustybrick.com %2F&rct=j&q=rustybrick&ei=eVZkUP_-HMa_0QGjgYH4AQ&usg=AFQjCNHDkFv2w5fqS9Doczm4LbK4o6QQfg” “Mozilla/5.0 (iPhone; CPU iPhone OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3″
```
Как вы видите, в этом примере реферер показывает, что вы пришли на эту страницу именно с поисковой системы Google. В этот пример я также добавил сам GET запрос, чтобы показать, что я не использовал Google SSL.
Я решил протестировать, как iOS 6 поведет себя с Bing'ом, но реферер сохранился:
```
www.rustybrick.com 142.54.83.140 – - [27/Sep/2012:09:45:37 -0400] “GET / HTTP/1.1″ 200 4386 “http://m.bing.com/search?q=rustybrick&qs=n∣=10006&FORM=BLXBSS&btsrc=internal≻=3-10&cbt=1348753533365″ “Mozilla/5.0 (iPhone; CPU iPhone OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A405 Safari/8536.25″
```
Что бы это ни было, я подозреваю что это ошибка (фича) на стороне Google. | https://habr.com/ru/post/152549/ | null | ru | null |
# Как изучение Smalltalk может улучшить ваши навыки программиста
Smalltalk обычно воспринимается как старый, умирающий язык – антиквариат из ушедшей эпохи. Нет ничего более далёкого от истины.
Smalltalk по-прежнему очень актуален. Это отличный язык для обучения программированию людей, не имеющих технического образования. Это превосходный язык прототипирования для стартапов. Это мощный промышленный язык, [используемый как крупными, так и малыми компаниями по всему миру](https://medium.com/smalltalk-talk/who-uses-smalltalk-c6fdaa6319a). Есть веские причины рассмотреть использование современного Smalltalk сегодня, поскольку многое было сделано за последнее время, чтобы улучшить его возможности.
Вы не обязаны использовать Smalltalk в промышленном программировании, но попробуйте кое-что написать на нём и прислушайтесь к своим ощущениям. Они должны быть знакомы, потому что реализация объектно-ориентированной парадигмы в Smalltalk настолько великолепна, что повлияла на целое поколение ОО языков, таких как Objective-C, Python, Ruby, CLOS, PHP 5, [Perl 6](http://techbeacon.com/why-perl-6-game-thrones-programming-languages), Erlang, Groovy, Scala, Dart, Swift и многих иных.
Изучая Smalltalk, вы поймете, как все эти полезные функции в современных языках стали реальностью. Изучение Smalltalk может также дать вам преимущество среди ваших коллег, и ещё он может быть отличным инструментом для обучения программированию.
### Что нам дал Smalltalk?
Вклад Smalltalk в индустрию программного обеспечения огромен. Просто взгляните на этот список функций и технологий, которые он представил:
* Smalltalk представил миру виртуальную машину (VM), которая позволяет программному обеспечению быть независимым от платформы. Это та же технология, которую поддерживает Java (JVM) и .NET, а также Android (Dalvik).
* Smalltalk был пионером [JIT компиляции](https://en.wikipedia.org/wiki/Just-in-time_compilation) (just-in-time), методики резкого повышения производительности программного обеспечения байт-кодов, такого как Java.
* В Smalltalk появилась первая современная среда разработки (IDE), которая включала текстовый редактор, браузер системы и классов, инспектор объектов и свойств и отладчик. Это привело к возникновению многих IDE, которые сегодня используют разработчики, такие как Visual Studio, Xcode и IntelliJ IDEA. Лично я считаю, что ни одна из этих IDE не может сравниться со Smalltalk в простоте, элегантности и скорости разработки; оригинал все ещё лучший!
* С самого начала Smalltalk имел *замыкания*, представляющие собой функции первого класса, имеющие лексическую область видимости. По сути, [замыкание](https://en.wikipedia.org/wiki/Closure_(computer_programming)) – это функция обратного вызова (callback) которая может видеть нелокальные переменные в том месте, где они были определены. Это может помочь вам написать гораздо более компактный и читаемый код. Замыкания находят своё применение во многих языках, например, в Java, C# и PHP.
* Smalltalk был первым языком, поддерживающим «живое» программирование и усовершенствованные методы отладки, такие как проверка и изменение кода *во время выполнения*. Сегодня отладка в реальном времени возможна в C# с помощью Visual Studio функции «Edit and Continue» и Java с использованием HotSwap.
* Smalltalk представил миру концепцию [MVC](https://ru.wikipedia.org/wiki/Model-View-Controller) (Model-View-Controller). MVC – это программный архитектурный шаблон для реализации пользовательских интерфейсов. Он популярен в настольных графических приложениях и веб-приложениях. В наши дни это та самая архитектура, которую в первую очередь изучают веб-разработчики.
* В значительной степени именно Smalltalk ответственен за [разработку на основе тестов](https://en.wikipedia.org/wiki/Test-driven_development) (TDD) и [экстремальное программирование](https://en.wikipedia.org/wiki/Extreme_programming) (XP), которые очень важны в нынешних «гибких» (Agile) практиках.
* Smalltalk сделал «утиную типизацию» расхожим выражением (ну, если оно ещё расхаживает по вашему дому). В утиной типизации проверка типов отложена до выполнения программы – когда *рефлексия* используются для обеспечения правильного поведения. Сегодня мы находим утиную типизацию во многих языках, включая Java, Python, Common Lisp, Go, Groovy, Objective-C и PHP.
* Smalltalk первым ввёл использование объектных баз данных. Хотя они и не получили широкого распространения, всё же объектные базы данных имеют свои нишевые рынки. Лучшим примером объектной базы данных является [GemStone/S](https://gemtalksystems.com/products/gs64), который хорошо подходит для масштабируемых, высокопроизводительных, многоуровневых распределённых систем.
* Smalltalk представил нам [первый браузер *рефакторинга*](http://c2.com/cgi/wiki?RefactoringBrowser). Конечно, поддержку рефакторинга можно найти в большинстве современных IDE.
* Smalltalk сыграл важную роль в разработке графического пользовательского интерфейса (GUI) и пользовательского интерфейса «что видишь, то и получишь» (WYSIWYG).
### Но как изучение Smalltalk сделает меня лучшим разработчиком?
Smalltalk имеет целый ряд функций, намного опередивших своё время:
* Основанное на образе сохранение
* Объекты: все является объектом, а объекты обмениваются только сообщениями (наиболее «чистая» реализация ООП и одна из самых ранних)
* «Живое» программирование
* Расширенные методы отладки, такие как изменение кода на лету
* Простой, незагромождённый интерфейс IDE
* [Предметно-ориентированные языки](https://en.wikipedia.org/wiki/Domain-specific_language) (DSL): единственный способ работы Smalltalk, поэтому программистам необходимо [сосредоточиться на проблеме](http://techbeacon.com/why-you-need-domain-driven-design), используя язык и нотацию, являющуюся естественной для этой проблемы
И есть ещё несколько [фич](http://stackoverflow.com/questions/1821266/what-is-so-special-about-smalltalk), которые делают Smalltalk особенным.
По существу, ключевым преимуществом Smalltalk как продуктивного языка и инструмента обучения является то, что он снимает большую часть, если не весь, когнитивный стресс в промышленных OO языках, таких как Java. Smalltalk не содержит синтаксического мусора или сбивающих с толку функций. Он вежливо уступает вам дорогу, так что вы можете сосредоточить всё своё внимание на проблеме или приложении. Дело не в том, что Java – плохой язык, потому что он более сложный (и имеющий 30-символьные имена классов); я говорю о том, что изучение необремененного лишними функциями OO языка на самом деле может сделать вас *лучшим* Java-программистом, как только вы поймёте концепции OOП с другой точки зрения.
Устранение когнитивного стресса является целью многих языков – например, Python, Ruby, Elixir, Elm и Go. Даже если вы его не *чувствуете*, стресс есть. Часто говорят, что программирование в Smalltalk или Python похоже на Дзен; ваше сознание просто течёт легко и непринуждённо вместе с решаемой задачей. Это красота и ценность языковой простоты, и Smalltalk обладает ею в полной мере.
В Smalltalk концепция ООП очищена до базовых понятий классов и методов, метаклассов и рефлексии, и, самое главное, передачи сообщений. Smalltalk, в силу своей объектной чистоты и согласованности, даст вам глубокое понимание объектно-ориентированного программирования и того, как использовать его с максимальной эффективностью.
Простота Smalltalk также делает его идеальным учебным языком для обучения программированию, особенно если у вас нет технической подготовки. Простота языка и инструментов позволяет сосредоточить ваши усилия на изучении *методов программирования*, а не языковых конструкций и формализма.
*«Живой» отладчик значительно сокращает цикл редактирование – тестирование – отладка.*
### Как работает Smalltalk? Основанный на образе подход к программированию
Главная причина успеха Smalltalk – подход к созданию программного обеспечения, основанный на образе. *Образ* представляет собой моментальный снимок памяти, который содержит все объекты в вашем запущенном приложении. Он инкапсулирует всё состояние выполнения вашей программы. Образ можно сохранить на диск и позже возобновить точно с того места, где вы остановились!
«Образ Smalltalk» может звучать немного необычно, но на самом деле он очень похож на нечто, широко используемое сегодня в ИТ: системные образы в виртуализации ОС, такие как в VMware и VirtualBox. Не забывайте, что Smalltalk первоначально был автономной операционной системой, созданной в Xerox PARC в 1970-х годах.
Образ Smalltalk похож на DOM (Document Object Model) в веб-приложении. Обратите внимание, что веб-приложение представляет собой по существу операционную систему, изолированную в веб-браузере и лишённую прямого доступа к файловой системе хоста и другим ресурсам. Когда веб-браузер закрывается, состояние динамического веб-сайта может быть сохранено или кэшировано, и в следующий раз, когда браузер возобновит работу, веб-сайт может быть восстановлен в браузере (с некоторыми ограничениями).
Даже электронная таблица очень близка к концепции образа. Она инкапсулирует всю нужную информацию. Она не может получить доступ к системным ресурсам. Её можно сохранить и восстановить. И вы должны знать, что электронные таблицы по-прежнему используются для разработки сложных моделей и приложений с собственным языком.
В общем, концепция образа широко распространена. Это настолько удобный способ разработки программного обеспечения, что версия образа была создана для JavaScript в [Lively Kernel](http://www.lively-kernel.org).
### Всё в Smalltalk является объектом
Без исключений: всё есть объект. Нет примитивных типов данных. Нет таких управляющих структур, как выбор и итерация! Всё в Smalltalk делается путём посылки *сообщений* *объектам*. Именно это делает Smalltalk настолько простым, элегантным и лёгким в освоении. Именно это делает язык настолько чистым синтаксически.
Например, следующий фрагмент кода расширяет класс `Number` для поддержки нерекурсивной операции факториала:
```
Number extend [
my_factorial [
(self < 2) ifTrue: [ ^1 ]
ifFalse: [ |c|
c := OrderedCollection new.
2 to: self do: [ :i | c add: i ].
^ (c fold: [ :a :b | a * b ] ) ]
]].
7 factorial printNl.
7 my_factorial printNl. “should be the same result as the previous line”
```
Здесь **ifTrue:** это *ключевое* сообщение посылаемое булевому объекту, возвращённому выражением **(self < 2)**. Аргументом для сообщения является блок кода (обозначенный квадратными скобками). На самом деле **ifTrue:** это первая часть сообщения с двумя аргументами, вторая часть **ifFalse:**.
*Унарное* сообщение **new** отправляется классу `OrderedCollection` для создания новой коллекции. Сообщение **printNl** отправляется в результат (являющийся объектом) отправки сообщения **my\_factorial** числу 7. Всё это очень похоже на естественный язык!
### Рефлексия в Smalltalk
Рефлексия в Smalltalk особенно ценна как механизм проверки собственной структуры и вычислений во время выполнения. Это очень мощный механизм, позволяющий программам расширять себя новыми классами и методами или задавать вопрос «кто послал это сообщение мне?»
Рефлексия используется для реализации мощного способа обработки ошибок. Когда объект получает сообщение, которое он не реализует, ему посылается сообщение **doesNotUnderstand:** и код исходного сообщения. Есть много вещей, которые программа может делать с сообщением **doesNotUnderstand:**, включая расширение своей функциональности!
Концепция образа и рефлексия также позволяют Smalltalk устранить границу между приложением и IDE. Всё, что нужно для разработки, отладки и запуска приложения, находится в образе. Нет необходимости когда-либо покидать среду вашего приложения. Это совершенно целостный подход к разработке программного обеспечения, который делает всё более дзен-подобным и продуктивным.
### Возрождение Smalltalk
Последние 15 лет развития в мире Smalltalk сделали язык более привлекательным.
Smalltalk теперь доступен для программирования веб-интерфейсов с использованием [Amber Smalltalk](http://amber-lang.net), который транслируется в JavaScript. Выполнение Amber происходит исключительно в браузере. Одна из удивительных особенностей Amber в том, что при импорте библиотеки JavaScript её объекты можно обрабатывать так же, как объекты Smalltalk.
В 2002 году была выпущена веб-платформа [Seaside](http://seaside.st), которая стала самым популярным инструментом для веб-разработки в Smalltalk. Подход, основанный на продолжениях (сontinuation), обеспечил обычный механизм «call / return» для вашего веб-приложения. Это позволило решить проблемы с двойным запросом и кнопкой «Назад». Весьма революционно для своего времени, и до сих пор не реализовано в других веб-фреймворках.
Проект [Pharo](http://pharo.org) начался в 2008 году, чтобы сосредоточиться на современных методах разработки программного обеспечения. Он продвинул Smalltalk гораздо дальше, чем предыдущий проект с открытым исходным кодом – Squeak, основанный на диалекте Smalltalk-80. Проект Pharo также начал исследования нового типа IDE под названием [Glamorous Toolkit](http://gtoolkit.org). Он основан на идее, что ваша среда программирования должна быть «пластичной», чтобы соответствовать вашим потребностям.
В прошлом году любимый многими Dolphin Smalltalk стал открытым проектом, предложив ещё один прекрасный вариант для поклонников Smalltalk. [Dolphin Smalltalk часто хвалят](https://medium.com/smalltalk-talk/choosing-smalltalk-on-porpoise-9bccb7cd53f) за то, что он обладает одной из лучших реализаций IDE.
### Наследие Smalltalk: программируй с удовольствием
Когда вы используете современные средства разработки программного обеспечения, такие как JVM, Eclipse IDE, замыкания, «живое программирование», MVC, TDD, VMware и даже простое веб-приложение, вспомните об их происхождении в Smalltalk и испытайте уважение к тому, что вы делаете. Будьте признательны ему за языки, которые вы используете, будь то Objective-C, Python, Ruby, Groovy, Scala, Dart или Swift.
Работа с языком, из которого произошли все эти замечательные функции и технологии, предоставляет уникальную возможность значительно улучшить ваши знания, остроту ума и производительность в качестве разработчика программного обеспечения. Слово «удовольствие» не всегда используется в разговорах о программной инженерии, но я думаю, что Smalltalk и его ОО собратья обеспечивают более низкий когнитивный барьер и простоту программирования, которые могут превратить разработку программ в удовольствие.
### Об авторе
[Ричард Энг](https://www.linkedin.com/in/richard-kenneth-eng-28405698) – отставной разработчик программного обеспечения из Канады с более чем 30-летним опытом работы в ИТ-индустрии. Он работал в сфере видео графики, баз данных и финансов, программного обеспечения реального времени, мобильных приложений для iOS и Android, а также в веб-разработке. Он писал в основном на C, но также использовал FORTRAN, Tandem TAL, C++, C#, Objective-C, Java, Smalltalk, Python и Go. Сейчас он возглавляет кампанию Smalltalk Renaissance. Большую часть времени Ричард проводит за написанием статей и эссе. | https://habr.com/ru/post/328156/ | null | ru | null |
# Еще есть пользователи windows 9x? Пишем утилиту для чтения NTFS
В последнее время найти пользователей windows 9x стало сложно, но возможно. Но все таки они есть такие. Так же известно что использовать жесткие диски с разделами NTFS штатными средствами операционной системы нельзя. Попробуем исправить это написав программу позволяющую читать данные с разделов NTFS.
**Что будем требовать от своей программы?**
Да вообщем то не многое. Разрабатываемая программа должна осуществлять копирование с разделов жесткого диска с файловой системой NTFS5 в разделы FAT. Данная программа должна быть использована в том случае, если Windows 2000 (которая использует NTFS 5) отсутствует или недоступна. Должны поддерживаться длинные имена файлов, а также жесткие диски любой ёмкости (в т.ч. больше 8Гб). Среда функционирования – ОС DOS, Windows 9x. Программа должна иметь «стандартный» двухпанельный «нортоновский» интерфейс.
**Определимся с алгоритмом**
После запуска программы на экране появляется список существующих разделов с указанием жесткого диска, типа раздела и размера раздела. По умолчанию выбор разделов с типом, отличающимся от NTFS, запрещен (выдается соответствующее сообщение). При выборе раздела с типом NTFS осуществляется проверка по сигнатурам, действительно ли это раздел NTFS. В случае несовпадения выдается соответствующее сообщение. Если раздел опознан как NTFS, на экран выводятся 2 файловые панели. На левой панели отображается список файлов и каталогов в корневом каталоге раздела NTFS. На правой отображается содержимое текущего каталога текущего логического диска.
Пользователь осуществляет необходимые действия (как-то просмотр файлов разделов, копирование с раздела NTFS в раздел FAT) и выходит из программы
**Как тут все устроенно**
При запуске программы определяются параметры всех жестких дисков, находящиеся в системе. Определяются: геометрия, объем, а также поддержка функций расширенных чтения и записи. Результат на каждый накопитель заносится в следующую структуру:
```
struct sDrvInfo
{
unsigned char Drive; // Номер накопителя (80h..FFh)
unsigned char ExtSupp; // Флаг поддержки Int13 Ext (0 - нет)
unsigned short NumCyl; // Количество дорожек
unsigned short NumHead; // Количество головок
unsigned short NumSect; // Количество секторов на дорожку
unsigned long NumAll; // Общее количество секторов на накопителе
sDrvInfo *Next; // Указатель на следующий элемент
};
```
Стандарные функции чтения/записи (реализованные через функции 02h и 03h прерывания 13h) требуют указания 3-х мерного номера сектора (дорожка-головка-сектор) и работают только для жестких дисков объемом не более 8Гб. Расширенные функции (Int13 Ext) (42h и 43h прерывания 13h) позволяют указывать абсолютный номер сектора и работают на жестких дисках любого объема. Поэтому при наличии такой поддержки чтение секторов выполняется только через эти функции.
Затем для каждого жесткого диска определяются находящиеся на нем разделы. Результат по каждому разделу заносится в структуру:
```
struct sPartInfo
{
unsigned char Drive; // Номер накопителя (80h..FFh)
unsigned char Type; // Тип раздела
unsigned long Start; // Абсолютный номер сектора начала раздела
unsigned long Size; // Общий размер раздела в секторах
unsigned long Table; // Абсолютный номер сектора с таблицей
// разделов, где ссылка на данный раздел
unsigned char NumEnt; // Номер входа таблицы разделов
sPartInfo *Next; // Указатель на следующий элемент
};
```
Процедура поиска разделов рекурсивная, так как наличие расширенных разделов дает в общем случае дерево. Расширенный раздел может иметь один из 2 типов: 05h (для HDD<=8Гб) или 0Fh (для HDD>8Гб). Во втором случае доступ к разделу возможен только через Int13 Ext.
Работа с логическими дисками FAT выполнена стандартным образом (через прерывание 21h), поэтому интереса не представляет. Стоит только отметить, что в зависимости от того, поддерживаются ли длинные имена файлов, используются либо стандартные функции, либо функции группы 71h прерывания 21h.
Работа с разделом NTFS основывается на ручном разборе всех структур. В соответствии со структурой NTFS, последовательность анализа раздела такова (примечание: после считывания каждой записи MFT или индексного блока обязательно производится коррекция области fixup — подробнее см. структуру NTFS):
1. Из Boot-сектора раздела извлекаются 2 важных параметра: количество секторов на кластер и номер кластера, где начинается MFT.
2. Считывается запись MFT номер 3 (информация о томе) и производится попытка извлечь из нее имя (метку) тома. В случае неудачи считается, что том не имеет метки.
3. Считывается запись MFT номер 5 (корневой каталог). По содержащемуся в нем индексу строится список файлов и каталогов.
4. При переходе в какой-либо каталог (над- или под-) считывается запись MFT, отвечающая за требуемый каталог, из нее также извлекается индекс.
5. При обращении к файлу (например, для чтения) считывается и анализируется запись MFT, отвечающая за данный файл.
Если будет интересно, распишу подробнее. Исходные коды [здесь](http://taxul.com.ua/q/Source.rar).
P.S.:
Исходные коды zip [здесь](http://taxul.com.ua/q/Source.zip).
**А выглядит в картинках это так:**
 | https://habr.com/ru/post/126151/ | null | ru | null |
# Настройка аутентификации в OpenVPN через Active Directory в CentOS 7
Представим что у нас уже есть настроенный OpenVPN, и мы решили сделать двухфакторную аутентификацию, включающую в себя проверку логина, пароля и членства пользователя в группе AD.
Традиционный openvpn-auth-ldap.so не существует в CentOS 7, поэтому рассмотрим вариант с использованием PAM (openvpn-plugin-auth-pam.so).
1. В конфиг клиента добавляем строку, чтобы клиент запрашивал логин и пароль при соединении:
`auth-user-pass`
2. В конфиг сервера добавляем строку, включающую аутентификацию в OpenVPN через PAM:
`plugin /usr/lib64/openvpn/plugins/openvpn-plugin-auth-pam.so openvpn`
3. Добавляем политику OpenVPN в PAM:
```
echo 'account required pam_ldap.so
auth required pam_ldap.so' >> /etc/pam.d/openvpn
```
3. Устанавливаем и включаем nslcd — этот модуль будет получать запросы от PAM и обращаться с ними к AD.
```
yum install nss-pam-ldapd -y
systemctl enable nslcd
```
5. Теперь редактируем параметры в /etc/nslcd.conf, чтобы они соответствовали примеру:
`uri ldap://dc1.contoso.com
base dc=contoso,dc=com
binddn CN=ldapquery,OU=ServiceAccounts,OU=DomainUsers,DC=contoso,DC=com
bindpw P@ssw0rd
pagesize 1000
referrals off
filter passwd (&(objectClass=user)(!(UserAccountControl:1.2.840.113556.1.4.803:=2))(!(objectClass=computer))(memberOf=CN=VPNUsers,OU=Groups,DC=contoso,DC=com))
map passwd uid sAMAccountName`
binddn — путь к той учётной записи, которая будет соединяться с AD. Фильтр проверяет не отключен ли пользователь и состоит ли в указанной группе. Вообще на этом этапе настройки очень поможет [AD Explorer](https://technet.microsoft.com/en-us/sysinternals/adexplorer.aspx).
6. Запускаем nslcd в консольном дебаг режиме
```
nslcd -d
```
и пытаемся подключиться через OpenVPN. Если возникнут ошибки — их сразу будет видно. Если всё в порядке, запускаем демона nslcd:
```
systemctl start nslcd
```
7. Готово! | https://habr.com/ru/post/276653/ | null | ru | null |
# MVCC-1. Изоляция
Привет, Хабр! Этой статьей я начинаю серию циклов (или цикл серий? в общем, задумка грандиозная) о внутреннем устройстве PostgreSQL.
Материал будет основан на [учебных курсах](https://postgrespro.ru/education/courses) по администрированию, которые делаем мы с Павлом [pluzanov](https://habr.com/ru/users/pluzanov/). Смотреть видео не все любят (я точно не люблю), а читать слайды, пусть даже с комментариями, — совсем «не то».
Конечно, статьи не будут повторять содержание курсов один в один. Я буду говорить только о том, как все устроено, опуская собственно администрирование, зато постараюсь делать это более подробно и обстоятельно. И я верю в то, что такие знания полезны прикладному разработчику не меньше, чем администратору.
Ориентироваться я буду на тех, кто уже имеет определенный опыт использования PostgreSQL и хотя бы в общих чертах представляет себе, что к чему. Для совсем новичков текст будет тяжеловат. Например, я ни слова не скажу о том, как установить PostgreSQL и запустить psql.
Вещи, о которых пойдет речь, не сильно меняются от версии к версии, но использовать я буду текущий, 11-й «ванильный» PostgreSQL.
Первый цикл посвящен вопросам, связанным с изоляцией и многоверсионностью, и план его таков:
1. Изоляция, как ее понимают стандарт и PostgreSQL (эта статья);
2. [Слои, файлы, страницы](https://habr.com/ru/company/postgrespro/blog/444536/) — что творится на физическом уровне;
3. [Версии строк, виртуальные и вложенные транзакции](https://habr.com/ru/company/postgrespro/blog/445820/);
4. [Снимки данных и видимость версий строк, горизонт событий](https://habr.com/ru/company/postgrespro/blog/446652/);
5. [Внутристраничная очистка и HOT-обновления](https://habr.com/ru/company/postgrespro/blog/449704/);
6. [Обычная очистка](https://habr.com/ru/company/postgrespro/blog/452320/) (vacuum);
7. [Автоматическая очистка](https://habr.com/ru/company/postgrespro/blog/452762/) (autovacuum);
8. [Переполнение счетчика транзакций и заморозка](https://habr.com/ru/company/postgrespro/blog/455590/).
Ну, поехали.
> Читайте и другие серии.
>
>
>
> Индексы:
>
>
>
> 1. [Механизм индексирования](https://habr.com/ru/company/postgrespro/blog/326096/);
> 2. [Интерфейс метода доступа](https://habrahabr.ru/company/postgrespro/blog/326106/), классы и семейства операторов;
> 3. [Hash](https://habrahabr.ru/company/postgrespro/blog/328280/);
> 4. [B-tree](https://habrahabr.ru/company/postgrespro/blog/330544/);
> 5. [GiST](https://habrahabr.ru/company/postgrespro/blog/333878/);
> 6. [SP-GiST](https://habrahabr.ru/company/postgrespro/blog/337502/);
> 7. [GIN](https://habrahabr.ru/company/postgrespro/blog/340978/);
> 8. [RUM](https://habrahabr.ru/company/postgrespro/blog/343488/);
> 9. [BRIN](https://habrahabr.ru/company/postgrespro/blog/346460/);
> 10. [Bloom](https://habrahabr.ru/company/postgrespro/blog/349224/).
>
>
>
> Журналирование:
>
>
>
> 1. [Буферный кеш](https://habr.com/ru/company/postgrespro/blog/458186/);
> 2. [Журнал предзаписи](https://habr.com/ru/company/postgrespro/blog/459250/) — как устроен и как используется при восстановлении;
> 3. [Контрольная точка](https://habr.com/ru/company/postgrespro/blog/460423/) и фоновая запись — зачем нужны и как настраиваются;
> 4. [Настройка журнала](https://habr.com/ru/company/postgrespro/blog/461523/) — уровни и решаемые задачи, надежность и производительность.
>
>
>
> Блокировки:
>
>
>
> 1. [Блокировки отношений](https://habr.com/ru/company/postgrespro/blog/462877/);
> 2. [Блокировки строк](https://habr.com/ru/company/postgrespro/blog/463819/);
> 3. [Блокировки других объектов](https://habr.com/ru/company/postgrespro/blog/465263/) и предикатные блокировки;
> 4. [Блокировки в оперативной памяти](https://habr.com/ru/company/postgrespro/blog/466199/).
>
>
>
>
Что такое изоляция и почему это важно
=====================================
Наверное, все как минимум знают про существование транзакций, встречали аббревиатуру ACID и слышали про уровни изоляции. Но приходится еще встречать мнение, что это-де теория, на практике не нужная. Поэтому я потрачу некоторое время на попытку объяснить, почему это действительно важно.
Вряд ли вы обрадуетесь, если приложение получит из базы некорректные данные, или если приложение запишет некорректные данные в базу.
Но что такое “корректные” данные? Известно, что на уровне базы данных можно создавать *ограничения целостности* (integrity constraints, такие как NOT NULL или UNIQUE). Если данные всегда удовлетворяют ограничениям целостности (а это так, потому что СУБД это гарантирует), то они целостны.
*Корректны* и *целостны* — одно и то же? Не совсем. Не все ограничения можно сформулировать на уровне базы данных. Часть ограничений слишком сложна, например, охватывает сразу несколько таблиц. И даже если ограничение в принципе можно было бы определить в базе данных, но из каких-то соображений это не сделали, это ведь не означает, что его можно нарушать.
Итак, *корректность* строже, чем *целостность*, но что это такое, мы точно не знаем. Остается признать, что эталоном корректности является приложение, которое, как нам хочется верить, написано *корректно* и никогда не ошибается. Во всяком случае, если приложение не нарушит целостность, но нарушит корректность, СУБД не узнает об этом и не поймает его за руку.
Дальше мы будет называть корректность термином *согласованность* (consistency).
Давайте, однако, предположим, что приложение выполняет только корректные последовательности операторов. В чем тогда роль СУБД, если приложение и так корректно?
Во-первых, оказывается, что корректная последовательность операторов может временно нарушать согласованность данных, и это — как ни странно — нормально. Заезженный, но понятный пример состоит в переводе средств с одного счета на другой. Правило согласованности может звучать так: *перевод никогда не меняет общей суммы денег на счетах* (такое правило довольно трудно записать на SQL в виде ограничения целостности, так что оно существует на уровне приложения и невидимо для СУБД). Перевод состоит из двух операций: первая уменьшает средства на одном счете, вторая — увеличивает на другом. Первая операция нарушает согласованность данных, вторая — восстанавливает.
> Хорошее упражнение — реализовать описанное выше правило на уровне ограничений целостности. А вам слабо? ©
>
>
Что, если первая операция выполнится, а вторая — нет? Ведь запросто: во время второй операции может пропасть электричество, упасть сервер, произойти деление на ноль — да мало ли. Понятно, что согласованность нарушится, а этого допускать нельзя. Разрешать такие ситуации на уровне приложения в принципе можно ценой неимоверных усилий, но, к счастью, не нужно: это берет на себя СУБД. Но для этого она должна знать, что две операции составляют неделимое целое. То есть *транзакцию*.
Получается интересное: зная, что операции составляют транзакцию, СУБД помогает поддерживать согласованность, гарантируя атомарность транзакций, при этом ничего не зная о конкретных правилах согласованности.
Но есть и второй, более тонкий момент. Как только в системе появляется несколько одновременно работающих транзакций, абсолютно корректных поодиночке, совместно они могут работать некорректно. Это происходит из-за того, что перемешивается порядок выполнения операций: нельзя считать, что сначала выполняются все операции одной транзакции, а только потом — все операции другой.
Замечание по поводу одновременности. Действительно одновременно транзакции могут работать на системе с многоядерным процессором, с дисковым массивом и т. д. Но все те же рассуждения справедливы и для сервера, который выполняет команды последовательно, в режиме разделения времени: столько-то тактов выполняется одна транзакция, столько тактов другая. Иногда для обобщения используют термин *конкурентное* выполнение.
Ситуации, когда корректные транзакции некорректно работают вместе, называются *аномалиями* одновременного выполнения.
Простой пример: если приложение хочет получить из базы корректные данные, то оно, как минимум, не должно видеть изменения других незафиксированных транзакций. Иначе можно не просто получить несогласованные данные, но и увидеть что-то такое, чего в базе данных никогда не было (если транзакция будет отменена). Такая аномалия называется *грязным чтением*.
Если и другие, более сложные аномалии, с которыми мы разберемся чуть позже.
Отказываться от одновременного выполнения, конечно, нельзя: иначе о какой производительности может идти речь? Но нельзя и работать с некорректными данными.
И снова на помощь приходит СУБД. Можно сделать так, чтобы транзакции выполнялись *как будто* последовательно, *как будто* одна за другой. Иными словами — *изолированно* друг от друга. В реальности СУБД может выполнять операции вперемешку, но гарантировать при этом, что результат одновременного выполнения будет совпадать с результатом какого-нибудь из возможных последовательных выполнений. А это устраняет любые возможные аномалии.
Итак, мы подошли к определению:
> Транзакцией называется множество операций, выполняемое приложением, которое переводит базу данных из одного корректного состояния в другое корректное состояние (согласованность) при условии, что транзакция выполнена полностью (атомарность) и без помех со стороны других транзакций (изоляция).
>
>
Это определение объединяет три первые буквы аббревиатуры ACID. Они настолько тесно связаны друг с другом, что рассматривать одно без другого просто нет смысла. На самом деле сложно оторвать и букву D (durability). Ведь при крахе системы в ней остаются изменения незафиксированных транзакций, с которыми приходится что-то делать, чтобы восстановить согласованность данных.
Все было бы хорошо, но реализация полной изоляции — технически сложная задача, сопряженная с уменьшением пропускной способности системы. Поэтому на практике очень часто (не всегда, но почти всегда) применяется ослабленная изоляция, которая предотвращает некоторые, но не все аномалии. А это означает, что часть работы по обеспечению корректности данных ложится на приложение. Именно поэтому очень важно понимать, какой уровень изоляции используется в системе, какие гарантии он дает, а какие — не дает, и как в таких условиях писать корректный код.
Уровни изоляции и аномалии в стандарте SQL
==========================================
Стандарт SQL с давних пор описывает четыре уровня изоляции. Эти уровни определяются перечислением аномалий, которые допускаются или не допускаются при одновременном выполнении транзакций на этом уровне. Поэтому чтобы говорить об этих уровнях, надо познакомиться с аномалиями.
Подчеркну, что в этой части речь идет о стандарте, то есть о некой теории, на которую практика существенно опирается, но с которой в то же время изрядно расходится. Поэтому и все примеры здесь умозрительные. Они будут использовать те же операции над счетами клиентов: это довольно наглядно, хотя, надо признать, не имеет ни малейшего отношения к тому, как банковские операции устроены в действительности.
Потерянное обновление
---------------------
Начнем с *потерянного обновления*. Такая аномалия возникает, когда две транзакции читают одну и ту же строку таблицы, затем одна транзакция обновляет эту строку, а после этого вторая транзакция тоже обновляет ту же строку, не учитывая изменений, сделанных первой транзакцией.
Например, две транзакции собираются увеличить сумму на одном и том же счете на 100 ₽. Первая транзакция читает текущее значение (1000 ₽), затем вторая транзакция читает то же значение. Первая транзакция увеличивает сумму (получается 1100 ₽) и записывает это значение. Вторая транзакция поступает так же — получает те же 1100 ₽ и записывает их. В результате клиент потерял 100 ₽.
Потерянное обновление не допускается стандартом ни на одном уровне изоляции.
Грязное чтение и Read Uncommitted
---------------------------------
С *грязным чтением* мы уже познакомились выше. Такая аномалия возникает, когда транзакция читает еще не зафиксированные изменения, сделанные другой транзакцией.
Например, первая транзакция переводит все деньги со счета клиента на другой счет, но не фиксирует изменение. Другая транзакция читает состояние счета, получает 0 ₽ и отказывает клиенту в выдаче наличных — несмотря на то, что первая транзакция прерывается и отменяет свои изменения, так что значения 0 никогда не существовало в базе данных.
Грязное чтение допускается стандартом на уровне Read Uncommitted.
Неповторяющееся чтение и Read Committed
---------------------------------------
Аномалия *неповторяющегося чтения* возникает, когда транзакция читает одну и ту же строку два раза, и в промежутке между чтениями вторая транзакция изменяет (или удаляет) эту строку и фиксирует изменения. Тогда первая транзакция получит разные результаты.
Например, пусть правило согласованности *запрещает отрицательные суммы на счетах клиентов*. Первая транзакция собирается уменьшить сумму на счете на 100 ₽. Она проверяет текущее значение, получает 1000 ₽ и решает, что уменьшение возможно. В это время вторая транзакция уменьшает сумму на счете до нуля и фиксирует изменения. Если бы теперь первая транзакция повторно проверила сумму, она получила бы 0 ₽ (но она уже приняла решение уменьшить значение, и счет “уходит в минус”).
Неповторяющееся чтение допускается стандартом на уровнях Read Uncommitted и Read Committed. А вот грязное чтение Read Committed не допускает.
Фантомное чтение и Repeatable Read
----------------------------------
*Фантомное чтение* возникает, когда транзакция два раза читает набор строк по одному и тому же условию, и в промежутке между чтениями вторая транзакция добавляет строки, удовлетворяющие этому условию (и фиксирует изменения). Тогда первая транзакция получит разные наборы строк.
Например, пусть правило согласованности *запрещает клиенту иметь более 3 счетов*. Первая транзакция собирается открыть новый счет, проверяет их текущее количество (скажем, 2) и решает, что открытие возможно. В это время вторая транзакция тоже открывает клиенту новый счет и фиксирует изменения. Если бы теперь первая транзакция перепроверила количество, она получила бы 3 (но она уже выполняет открытие еще одного счета и у клиента их оказывается 4).
Фантомное чтение допускается стандартом на уровнях Read Uncommitted, Read Committed и Repeatable Read. Но на уровне Repeatable Read не допускается неповторяющееся чтение.
Отсутствие аномалий и Serializable
----------------------------------
Стандарт определяет и еще один уровень — Serializable, — на котором не допускаются никакие аномалии. И это совсем не то же самое, что запрет на потерянное обновление и на грязное, неповторяющееся и фантомное чтения.
Дело в том, что существует значительно больше известных аномалий, чем перечислено в стандарте, и еще неизвестное число пока неизвестных.
Уровень Serializable должен предотвращать *вообще все* аномалии. Это означает, что на таком уровне разработчику приложения не надо думать об одновременном выполнении. Если транзакции выполняют корректные последовательности операторов, работая в одиночку, данные будут согласованы и при одновременной работе этих транзакций.
Итоговая табличка
-----------------
Вот теперь можно и привести всем известную таблицу. Но здесь для ясности к ней добавлен последний столбец, которого нет в стандарте.
| | потерянные изменения | грязное чтение | неповторяющееся чтение | фантомное чтение | другие аномалии |
| --- | --- | --- | --- | --- | --- |
| Read Uncommitted | — | да | да | да | да |
| Read Committed | — | — | да | да | да |
| Repeatable Read | — | — | — | да | да |
| Serializable | — | — | — | — | — |
Почему именно эти аномалии?
---------------------------
Почему из множества возможных аномалий в стандарте перечислены только несколько и почему именно такие?
Достоверно этого, видимо, никто не знает. Но практика здесь точно обогнала теорию, так что не исключено, что о других аномалиях тогда (речь о стандарте SQL:92) просто не задумывались.
Кроме того, предполагалось, что изоляция должна быть построена на блокировках. Идея широко применявшегося *протокола двухфазного блокирования* (2PL) состоит в том, что в процессе выполнения транзакция блокирует строки, с которыми работает, а при завершении — освобождает блокировки. Сильно упрощая, чем больше блокировок захватывает транзакция, тем лучше она изолирована от других транзакций. Но и тем сильнее страдает производительность системы, поскольку вместо совместной работы транзакции начинают выстраиваться в очередь за одними и теми же строками.
Как мне представляется, разница между уровнями изоляции стандарта объясняется как раз количеством необходимых блокировок.
Если транзакция блокирует изменяемые строки от изменения, но не от чтения, получаем уровень Read Uncommitted: потерянные изменения не допускаются, но можно прочитать незафиксированные данные.
Если транзакция блокирует изменяемые строки и от чтения, и от изменения, получаем уровень Read Committed: незафиксированные данные прочитать нельзя, но при повторном обращении к строке можно получить другое значение (неповторяющееся чтение).
Если транзакция блокирует и читаемые, и изменяемые строки и от чтения, и от изменения, получаем уровень Repeatable Read: повторное чтение строки будет выдавать то же значение.
Но с Serializable проблема: невозможно заблокировать строку, которой еще нет. Из-за этого остается возможность фантомного чтения: другая транзакция может добавить (но не удалить) строку, попадающую под условия выполненного ранее запроса, и эта строка попадет в повторную выборку.
Поэтому для реализации уровня Serializable обычных блокировок не хватает — нужно блокировать не строки, а условия (предикаты). Такие блокировки и были названы *предикатными*. Предложены они были еще в 1976 году, но их практическая применимость ограничена достаточно простыми условиями, для которых понятно, как объединять два разных предиката. До реализации таких блокировок в какой-либо системе дело, насколько мне известно, не дошло.
Уровни изоляции в PostgreSQL
============================
Со временем на смену блокировочным протоколам управления транзакциями пришел *протокол изоляции на основе снимков* (Snapshot Isolation). Его идея состоит в том, что каждая транзакция работает с согласованным снимком данных на определенный момент времени, в который попадают только те изменения, которые были зафиксированы до момента создания снимка.
Такая изоляция автоматически не допускает грязное чтение. Формально в PostgreSQL можно указать уровень Read Uncommitted, но работать она будет точно так же, как Read Committed. Поэтому про уровень Read Uncommitted мы дальше вообще не будем говорить.
В PostgreSQL реализован *многоверсионный* вариант такого протокола. Идея многоверсионности состоит в том, что в СУБД могут сосуществовать несколько версий одной и той же строки. Это позволяет строить снимок данных, используя имеющиеся версии, и обходиться минимумом блокировок. Фактически блокируется только повторное изменение одной и той же строки. Все остальные операции выполняются одновременно: пишущие транзакции никогда не блокируют читающих транзакций, а читающие никогда не блокируют никого.
За счет использования снимков данных изоляция в PostgreSQL получается строже, чем того требует стандарт: уровень Repeatable Read не допускает не только неповторяющегося, но и фантомного чтения (хотя и не обеспечивает полную изоляцию). И достигается это без потери эффективности.
| | потерянные изменения | грязное чтение | неповторяющееся чтение | фантомное чтение | другие аномалии |
| --- | --- | --- | --- | --- | --- |
| Read Uncommitted | — | — | да | да | да |
| Read Committed | — | — | да | да | да |
| Repeatable Read | — | — | — | — | да |
| Serializable | — | — | — | — | — |
Как многоверсионность реализована “под капотом”, мы поговорим в следующих статьях, а сейчас подробно посмотрим на каждый из трех уровней глазами пользователя (как вы понимаете, самое интересное скрывается за «другими аномалиями»). Для этого создадим таблицу счетов. У Алисы и Боба по 1000 ₽, но у Боба открыто два счета:
```
=> CREATE TABLE accounts(
id integer PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
number text UNIQUE,
client text,
amount numeric
);
=> INSERT INTO accounts VALUES
(1, '1001', 'alice', 1000.00),
(2, '2001', 'bob', 100.00),
(3, '2002', 'bob', 900.00);
```
Read Committed
--------------
### Отсутствие грязного чтения
Легко убедиться в том, что грязные данные прочитать невозможно. Начнем транзакцию. По умолчанию она будет использовать уровень изоляции Read Committed:
```
=> BEGIN;
=> SHOW transaction_isolation;
```
```
transaction_isolation
-----------------------
read committed
(1 row)
```
Говоря точнее, умолчательный уровень задается параметром, его при необходимости можно изменить:
```
=> SHOW default_transaction_isolation;
```
```
default_transaction_isolation
-------------------------------
read committed
(1 row)
```
Итак, в открытой транзакции снимаем средства со счета, но не фиксируем изменения. Свои собственные изменения транзакция видит:
```
=> UPDATE accounts SET amount = amount - 200 WHERE id = 1;
=> SELECT * FROM accounts WHERE client = 'alice';
```
```
id | number | client | amount
----+--------+--------+--------
1 | 1001 | alice | 800.00
(1 row)
```
Во втором сеансе начнем еще одну транзакцию с тем же уровнем Read Committed. Чтобы отличать разные транзакции, команды второй транзакции будут показаны с отступом и отчеркнуты.
Для того, чтобы повторить приведенные команды (а это полезно), надо открыть два терминала и в каждом запустить psql. В первом можно вводить команды одной транзакции, а во втором — команды другой.
```
| => BEGIN;
| => SELECT * FROM accounts WHERE client = 'alice';
```
```
| id | number | client | amount
| ----+--------+--------+---------
| 1 | 1001 | alice | 1000.00
| (1 row)
```
Как и ожидалось, другая транзакция не видит незафиксированные изменения — грязное чтение не допускается.
### Неповторяющееся чтение
Пусть теперь первая транзакция зафиксирует изменения, а вторая повторно выполнит тот же самый запрос.
```
=> COMMIT;
```
```
| => SELECT * FROM accounts WHERE client = 'alice';
```
```
| id | number | client | amount
| ----+--------+--------+--------
| 1 | 1001 | alice | 800.00
| (1 row)
```
```
| => COMMIT;
```
Запрос получает уже новые данные — это и есть аномалия *неповторяющегося чтения*, которая допускается на уровне Read Committed.
*Практический вывод*: в транзакции нельзя принимать решения на основании данных, прочитанных предыдущим оператором — потому что за время между выполнением операторов все может измениться. Вот пример, вариации которого встречается в прикладном коде так часто, что он является классическим антипаттерном:
```
IF (SELECT amount FROM accounts WHERE id = 1) >= 1000 THEN
UPDATE accounts SET amount = amount - 1000 WHERE id = 1;
END IF;
```
За время, которое проходит между проверкой и обновлением, другие транзакции могут как угодно изменить состояние счета, так что такая «проверка» ни от чего не спасает. Удобно представлять себе, что между операторами одной транзакции могут «вклиниться» любые другие операторы других транзакций, например вот так:
```
IF (SELECT amount FROM accounts WHERE id = 1) >= 1000 THEN
-----
| UPDATE accounts SET amount = amount - 200 WHERE id = 1;
| COMMIT;
-----
UPDATE accounts SET amount = amount - 1000 WHERE id = 1;
END IF;
```
Если, переставив операторы, можно все испортить, значит код написан некорректно. И не стоит обманывать себя, что такого стечения обстоятельств не произойдет — произойдет обязательно.
А как написать код корректно? Возможности, как правило, сводятся к следующему:
* Не писать код.
Это не шутка. Например, в данном случае проверка легко превращается в ограничение целостности:
`ALTER TABLE accounts ADD CHECK amount >= 0;`
Теперь никакие проверки не нужны: достаточно просто выполнить действие и при необходимости обработать исключение, которое возникнет в случае попытки нарушения целостности.
* Использовать один SQL-оператор.
Проблемы с согласованностью возникают из-за того, что в промежутке между операторами может завершиться другая транзакция и изменятся видимые данные. А если оператор один, то и промежутков никаких нет.
В PostgreSQL достаточно средств, чтобы одним SQL-оператором решать сложные задачи. Отметим общие табличные выражения (CTE), в которых в том числе можно использовать операторы INSERT/UPDATE/DELETE, а также оператор INSERT ON CONFLICT, который реализует логику «вставить, а если строка уже есть, то обновить» в одном операторе.
* Пользовательские блокировки.
Последнее средство — вручную установить исключительную блокировку или на все нужные строки (SELECT FOR UPDATE), или вообще на всю таблицу (LOCK TABLE). Это всегда работает, но сводит на нет преимущества многоверсионности: вместо одновременного выполнения часть операций будет выполняться последовательно.
### Несогласованное чтение
Прежде чем приступать к следующему уровню изоляции, придется признать, что не все так просто. Реализация PostgreSQL такова, что допускает другие, менее известные аномалии, которые не регламентируются стандартом.
Допустим, первая транзакция начала перевод средств с одного счета Боба на другой:
```
=> BEGIN;
=> UPDATE accounts SET amount = amount - 100 WHERE id = 2;
```
В это время другая транзакция подсчитывает баланс Боба, причем подсчет выполняется в цикле по всем счетам Боба. Фактически транзакция начинает с первого счета (и, очевидно, видит прежнее состояние):
```
| => BEGIN;
| => SELECT amount FROM accounts WHERE id = 2;
```
```
| amount
| --------
| 100.00
| (1 row)
```
В этот момент первая транзакция успешно завершается:
```
=> UPDATE accounts SET amount = amount + 100 WHERE id = 3;
=> COMMIT;
```
А другая читает состояние второго счета (и видит уже новое значение):
```
| => SELECT amount FROM accounts WHERE id = 3;
```
```
| amount
| ---------
| 1000.00
| (1 row)
```
```
| => COMMIT;
```
Таким образом вторая транзакция получила в сумме 1100 ₽, то есть некорректные данные. Это и есть аномалия *несогласованного чтения*.
Как избежать такой аномалии, оставаясь на уровне Read Committed? Конечно, использовать один оператор. Например так:
```
SELECT sum(amount) FROM accounts WHERE client = 'bob';
```
До сих пор я утверждал, что видимость данных может поменяться только между операторами, но так ли это очевидно? А если запрос выполняется долго, может ли он увидеть часть данных в одном состоянии, а часть — в другом?
Проверим. Удобный способ для этого — вставить в оператор искусственную задержку, вызвав функцию pg\_sleep. Ее параметр задает время задержки в секундах.
```
=> SELECT amount, pg_sleep(2) FROM accounts WHERE client = 'bob';
```
Пока эта конструкция выполняется, в другой транзакции выполняем перенос средств обратно:
```
| => BEGIN;
| => UPDATE accounts SET amount = amount + 100 WHERE id = 2;
| => UPDATE accounts SET amount = amount - 100 WHERE id = 3;
| => COMMIT;
```
Результат показывает, что оператор видит данные в таком состоянии, в котором они находились на момент начала его выполнения. Это, безусловно, правильно.
```
amount | pg_sleep
---------+----------
0.00 |
1000.00 |
(2 rows)
```
Но и тут не все так просто. PostgreSQL позволяет определять функции, а у функций есть понятие *категории изменчивости*. Если в запросе вызывается *изменчивая* функция (с категорией VOLATILE), и в этой функции выполняется другой запрос, то этот запрос внутри функции будет видеть данные, не согласованные с данными основного запроса.
```
=> CREATE FUNCTION get_amount(id integer) RETURNS numeric AS $$
SELECT amount FROM accounts a WHERE a.id = get_amount.id;
$$ VOLATILE LANGUAGE sql;
```
```
=> SELECT get_amount(id), pg_sleep(2)
FROM accounts WHERE client = 'bob';
```
```
| => BEGIN;
| => UPDATE accounts SET amount = amount + 100 WHERE id = 2;
| => UPDATE accounts SET amount = amount - 100 WHERE id = 3;
| => COMMIT;
```
В этом случае получим некорректные данные — 100 ₽ потерялись:
```
get_amount | pg_sleep
------------+----------
100.00 |
800.00 |
(2 rows)
```
Подчеркну, что такой эффект возможен только на уровне изоляции Read Committed, и только с категорией изменчивость VOLATILE. Беда в том, что умолчанию используется именно этот уровень изоляции и именно эта категория изменчивости, так что надо признать — грабли лежат очень удачно. Не наступайте!
### Несогласованное чтение в обмен на потерянные изменения
Несогласованное чтение в рамках одного оператора можно — несколько неожиданным образом — получить и при обновлении.
Посмотрим, что происходит при попытке изменения одной и той же строки двумя транзакциями. Сейчас у Боба 1000 ₽ на двух счетах:
```
=> SELECT * FROM accounts WHERE client = 'bob';
```
```
id | number | client | amount
----+--------+--------+--------
2 | 2001 | bob | 200.00
3 | 2002 | bob | 800.00
(2 rows)
```
Начинаем транзакцию, которая уменьшает баланс Боба:
```
=> BEGIN;
=> UPDATE accounts SET amount = amount - 100 WHERE id = 3;
```
В это же время другая транзакция начисляет проценты на все счета клиентов с общим балансом, равным или превышающим 1000 ₽:
```
| => UPDATE accounts SET amount = amount * 1.01
| WHERE client IN (
| SELECT client
| FROM accounts
| GROUP BY client
| HAVING sum(amount) >= 1000
| );
```
Выполнение оператора UPDATE состоит из двух частей. Сначала фактически выполняется SELECT, который отбирает для обновления строки, соответствующие условию. Поскольку изменение первой транзакции не зафиксировано, вторая транзакция не может его видеть и оно никак не влияет на выбор строк для начисления процентов. Итак, счета Боба попадают под условие и после выполнения обновления его баланс должен увеличиться на 10 ₽.
Второй этап выполнения — выбранные строки обновляются одна за другой. Тут вторая транзакция вынуждена «подвиснуть», поскольку строка id = 3 уже заблокирована первой транзакцией.
Между тем первая транзакция фиксирует изменения:
```
=> COMMIT;
```
Что же получится в результате?
```
=> SELECT * FROM accounts WHERE client = 'bob';
```
```
id | number | client | amount
----+--------+--------+----------
2 | 2001 | bob | 202.0000
3 | 2002 | bob | 707.0000
(2 rows)
```
Да, с одной стороны, команда UPDATE не должна видеть изменений второй транзакции. Но с другой — она не должна потерять изменения, зафиксированные во второй транзакции.
После снятия блокировки UPDATE перечитывает строку, которую пытается обновить (но только ее одну!). В результате получается, что Бобу начислено 9 ₽, исходя из суммы 900 ₽. Но если бы у Боба было 900 ₽, его счета вообще не должны были попасть в выборку.
Итак, транзакция получает некорректные данные: часть строк видна на один момент времени, часть — на другой. Взамен потерянного обновления мы снова получаем аномалию *несогласованного чтения*.
> Внимательные читатели отмечают, что при некоторой помощи со стороны приложения на уровне Read Committed можно получить и потерянное обновление. Например так:
>
>
>
>
> ```
> x := (SELECT amount FROM accounts WHERE id = 1);
> UPDATE accounts SET amount = x + 100 WHERE id = 1;
>
> ```
>
>
> База данных не виновата: она получает два SQL-оператора и ничего не знает о том, что значение x + 100 как-то связано с accounts.amount. Не пишите код таким образом.
>
>
Repeatable Read
---------------
### Отсутствие неповторяющегося и фантомного чтений
Само название уровня изоляции говорит о том, что чтение является повторяемым. Проверим это, а заодно убедимся и в отсутствии фантомных чтений. Для этого в первой транзакции вернем счета Боба в прежнее состояние и создадим новый счет для Чарли:
```
=> BEGIN;
=> UPDATE accounts SET amount = 200.00 WHERE id = 2;
=> UPDATE accounts SET amount = 800.00 WHERE id = 3;
=> INSERT INTO accounts VALUES
(4, '3001', 'charlie', 100.00);
=> SELECT * FROM accounts ORDER BY id;
```
```
id | number | client | amount
----+--------+---------+--------
1 | 1001 | alice | 800.00
2 | 2001 | bob | 200.00
3 | 2002 | bob | 800.00
4 | 3001 | charlie | 100.00
(4 rows)
```
Во втором сеансе начнем транзакцию с уровнем Repeatable Read, указав его в команде BEGIN (уровень первой транзакции не важен).
```
| => BEGIN ISOLATION LEVEL REPEATABLE READ;
| => SELECT * FROM accounts ORDER BY id;
```
```
| id | number | client | amount
| ----+--------+--------+----------
| 1 | 1001 | alice | 800.00
| 2 | 2001 | bob | 202.0000
| 3 | 2002 | bob | 707.0000
| (3 rows)
```
Теперь первая транзакция фиксирует изменения, а вторая повторно выполняет тот же самый запрос.
```
=> COMMIT;
```
```
| => SELECT * FROM accounts ORDER BY id;
```
```
| id | number | client | amount
| ----+--------+--------+----------
| 1 | 1001 | alice | 800.00
| 2 | 2001 | bob | 202.0000
| 3 | 2002 | bob | 707.0000
| (3 rows)
```
```
| => COMMIT;
```
Вторая транзакция продолжает видеть ровно те же данные, что и в начале: не видно ни изменений в существующих строках, ни новых строк.
На таком уровне можно не беспокоиться о том, что между двумя операторами что-то поменяется.
### Ошибка сериализации в обмен на потерянные изменения
Выше мы говорили о том, что при обновлении одной и той же строки двумя транзакциями на уровне Read Committed может возникнуть аномалия несогласованного чтения. Это происходит из-за того, что ожидающая транзакция перечитывает заблокированную строку и, таким образом, видит ее не на тот же самый момент времени, что остальные строки.
На уровне Repeatable Read такая аномалия не допускается, но, если она все-таки возникает, сделать уже ничего нельзя — поэтому транзакция обрывается с ошибкой сериализации. Проверим, повторив тот же сценарий с процентами:
```
=> SELECT * FROM accounts WHERE client = 'bob';
```
```
id | number | client | amount
----+--------+--------+--------
2 | 2001 | bob | 200.00
3 | 2002 | bob | 800.00
(2 rows)
```
```
=> BEGIN;
=> UPDATE accounts SET amount = amount - 100.00 WHERE id = 3;
```
```
| => BEGIN ISOLATION LEVEL REPEATABLE READ;
| => UPDATE accounts SET amount = amount * 1.01
| WHERE client IN (
| SELECT client
| FROM accounts
| GROUP BY client
| HAVING sum(amount) >= 1000
| );
```
```
=> COMMIT;
```
```
| ERROR: could not serialize access due to concurrent update
```
```
| => ROLLBACK;
```
Данные остались согласованными:
```
=> SELECT * FROM accounts WHERE client = 'bob';
```
```
id | number | client | amount
----+--------+--------+--------
2 | 2001 | bob | 200.00
3 | 2002 | bob | 700.00
(2 rows)
```
Такая же ошибка будет и в случае любого другого конкурентного изменения строки, даже если интересующие нас столбцы фактически не изменились.
*Практический вывод*: если приложение использует уровень изоляции Repeatable Read для пишущих транзакций, оно должно быть готово повторять транзакции, завершившиеся ошибкой сериализации. Для только читающих транзакций такой исход невозможен.
### Несогласованная запись
Итак, в PostgreSQL на уровне изоляции Repeatable Read предотвращаются все аномалии, описанные в стандарте. Но не все вообще. Оказывается, есть *ровно две* аномалии, которые остаются возможными. (Это верно не только для PostgreSQL, но и для других реализаций изоляции на основе снимков.)
Первая из этих аномалий — *несогласованная запись*.
Пусть действует такое правило согласованности: *допускаются отрицательные суммы на счетах клиента, если общая сумма на всех счетах этого клиента остается неотрицательной*.
Первая транзакция получает сумму на счетах Боба: 900 ₽.
```
=> BEGIN ISOLATION LEVEL REPEATABLE READ;
=> SELECT sum(amount) FROM accounts WHERE client = 'bob';
```
```
sum
--------
900.00
(1 row)
```
Вторая транзакция получает ту же сумму.
```
| => BEGIN ISOLATION LEVEL REPEATABLE READ;
| => SELECT sum(amount) FROM accounts WHERE client = 'bob';
```
```
| sum
| --------
| 900.00
| (1 row)
```
Первая транзакция справедливо полагает, что сумму одного из счетов можно уменьшить на 600 ₽.
```
=> UPDATE accounts SET amount = amount - 600.00 WHERE id = 2;
```
И вторая транзакция приходит к такому же выводу. Но уменьшает другой счет:
```
| => UPDATE accounts SET amount = amount - 600.00 WHERE id = 3;
| => COMMIT;
```
```
=> COMMIT;
=> SELECT * FROM accounts WHERE client = 'bob';
```
```
id | number | client | amount
----+--------+--------+---------
2 | 2001 | bob | -400.00
3 | 2002 | bob | 100.00
(2 rows)
```
У нас получилось увести баланс Боба в минус, хотя каждая из транзакций работает корректно поодиночке.
### Аномалия только читающей транзакции
Это вторая и последняя из аномалий, возможных на уровне Repeatable Read. Чтобы продемонстрировать ее, потребуются три транзакции, две из которых будут изменять данные, а третья — только читать.
Но сначала восстановим состояние счетов Боба:
```
=> UPDATE accounts SET amount = 900.00 WHERE id = 2;
=> SELECT * FROM accounts WHERE client = 'bob';
```
```
id | number | client | amount
----+--------+--------+--------
3 | 2002 | bob | 100.00
2 | 2001 | bob | 900.00
(2 rows)
```
Первая транзакция начисляет Бобу проценты на сумму средств на всех счетах. Проценты зачисляются на один из его счетов:
```
=> BEGIN ISOLATION LEVEL REPEATABLE READ; -- 1
=> UPDATE accounts SET amount = amount + (
SELECT sum(amount) FROM accounts WHERE client = 'bob'
) * 0.01
WHERE id = 2;
```
Затем другая транзакция снимает деньги с другого счета Боба и фиксирует свои изменения:
```
| => BEGIN ISOLATION LEVEL REPEATABLE READ; -- 2
| => UPDATE accounts SET amount = amount - 100.00 WHERE id = 3;
| => COMMIT;
```
Если в этот момент первая транзакция будет зафиксирована, никакой аномалии не возникнет: мы могли бы считать, что сначала выполнена первая транзакция, а затем вторая (но не наоборот, потому что первая транзакция увидела состояние счета id = 3 до того, как этот счет был изменен второй транзакцией).
Но представим, что в этот момент начинается третья (только читающая) транзакция, которая читает состояние какого-нибудь счета, не затронутого первыми двумя транзакциями:
```
| => BEGIN ISOLATION LEVEL REPEATABLE READ; -- 3
| => SELECT * FROM accounts WHERE client = 'alice';
```
```
| id | number | client | amount
| ----+--------+--------+--------
| 1 | 1001 | alice | 800.00
| (1 row)
```
И только после этого первая транзакция завершается:
```
=> COMMIT;
```
Какое состояние теперь должна увидеть третья транзакция?
```
| SELECT * FROM accounts WHERE client = ‘bob’;
```
Начавшись, третья транзакция могла видеть изменения второй транзакции (которая уже была зафиксирована), но не первой (которая еще не была зафиксирована). С другой стороны, мы уже установили выше, что вторую транзакцию следует считать начавшейся после первой. Какое состояние ни увидит третья транзакция, оно будет несогласованным — это и есть аномалия только читающей транзакции. Но на уровне Repeatable Read она допускается:
```
| id | number | client | amount
| ----+--------+--------+--------
| 2 | 2001 | bob | 900.00
| 3 | 2002 | bob | 0.00
| (2 rows)
```
```
| => COMMIT;
```
Serializable
------------
На уровне Serializable предотвращаются все возможные аномалии. Фактически Serializable реализован как надстройка над изоляцией на основе снимков данных. Те аномалии, которые не возникают при Repeatable Read (такие, как грязное, неповторяемое, фантомное чтение), не возникают и на уровне Serializable. А те аномалии, которые возникают (несогласованная запись и аномалия только читающей транзакции), обнаруживаются и транзакция прерывается — возникает уже знакомая ошибка сериализации could not serialize access.
### Несогласованная запись
Для иллюстрации повторим сценарий с аномалией несогласованной записи:
```
=> BEGIN ISOLATION LEVEL SERIALIZABLE;
=> SELECT sum(amount) FROM accounts WHERE client = 'bob';
```
```
sum
----------
910.0000
(1 row)
```
```
| => BEGIN ISOLATION LEVEL SERIALIZABLE;
| => SELECT sum(amount) FROM accounts WHERE client = 'bob';
```
```
| sum
| ----------
| 910.0000
| (1 row)
```
```
=> UPDATE accounts SET amount = amount - 600.00 WHERE id = 2;
```
```
| => UPDATE accounts SET amount = amount - 600.00 WHERE id = 3;
| => COMMIT;
```
```
=> COMMIT;
```
```
ERROR: could not serialize access due to read/write dependencies among transactions
DETAIL: Reason code: Canceled on identification as a pivot, during commit attempt.
HINT: The transaction might succeed if retried.
```
Так же, как и на уровне Repeatable Read, приложение, использующее уровень изоляции Serializable, должно повторять транзакции, завершившиеся ошибкой сериализации, о чем нам сообщает и подсказка в сообщении об ошибке.
Мы приобретаем простоту программирования, но цена за нее — принудительный обрыв некоторой доли транзакций и необходимость их повторения. Весь вопрос, конечно, в том, насколько велика эта доля. Если бы обрывались только те транзакции, которые действительно несовместимо пересекаются по данным с другими транзакциями, все было бы неплохо. Но такая реализация неизбежно оказалась бы ресурсоемкой и неэффективной, поскольку пришлось бы отслеживать операции с каждой строкой.
В действительности реализация PostgreSQL такова, что допускает ложноотрицательные срабатывания: будут обрываться и некоторые совершенно нормальные транзакции, которым просто «не повезло». Как мы увидим позже, это зависит от многих причин, например, от наличия подходящих индексов или доступного объема оперативной памяти. Кроме того, есть и некоторые другие (довольно серьезные) ограничения реализации, например, запросы на уровне Serializable не будут работать на репликах, для них не будут использоваться параллельные планы выполнения. И, хотя работа над улучшением реализации не прекращается, но имеющиеся ограничения снижают привлекательность такого уровня изоляции.
> Параллельные планы появятся уже в PostgreSQL 12 ([патч](https://commitfest.postgresql.org/22/1004/)). А запросы на репликах могут заработать в PostgreSQL 13 ([другой патч](https://commitfest.postgresql.org/22/1799/)).
>
>
### Аномалия только читающей транзакции
Чтобы только читающая транзакция не могла привести к аномалии и не могла пострадать от нее, PostgreSQL предлагает интересный механизм: такая транзакция может быть заблокирована до тех пор, пока ее выполнение не будет безопасным. Это единственный случай, когда оператор SELECT может быть заблокирован обновлениями строк. Вот как это выглядит:
```
=> UPDATE accounts SET amount = 900.00 WHERE id = 2;
=> UPDATE accounts SET amount = 100.00 WHERE id = 3;
=> SELECT * FROM accounts WHERE client = 'bob' ORDER BY id;
```
```
id | number | client | amount
----+--------+--------+--------
2 | 2001 | bob | 900.00
3 | 2002 | bob | 100.00
(2 rows)
```
```
=> BEGIN ISOLATION LEVEL SERIALIZABLE; -- 1
=> UPDATE accounts SET amount = amount + (
SELECT sum(amount) FROM accounts WHERE client = 'bob'
) * 0.01
WHERE id = 2;
```
```
| => BEGIN ISOLATION LEVEL SERIALIZABLE; -- 2
| => UPDATE accounts SET amount = amount - 100.00 WHERE id = 3;
| => COMMIT;
```
Третью транзакцию явно объявляем только читающий (READ ONLY) и откладываемой (DEFERRABLE):
```
| => BEGIN ISOLATION LEVEL SERIALIZABLE READ ONLY DEFERRABLE; -- 3
| => SELECT * FROM accounts WHERE client = 'alice';
```
При попытке выполнить запрос транзакция блокируется, потому что иначе ее выполнение приведет к аномалии.
```
=> COMMIT;
```
И только после того, как первая транзакция зафиксирована, третья продолжает выполнение:
```
| id | number | client | amount
| ----+--------+--------+--------
| 1 | 1001 | alice | 800.00
| (1 row)
```
```
| => SELECT * FROM accounts WHERE client = 'bob';
```
```
| id | number | client | amount
| ----+--------+--------+----------
| 2 | 2001 | bob | 910.0000
| 3 | 2002 | bob | 0.00
| (2 rows)
```
```
| => COMMIT;
```
Еще одно важное замечание: если используется изоляция Serializable, то все транзакции в приложении должны использовать этот уровень. Нельзя смешивать транзакции Read Committed (или Repeatable Read) с Serializable. То есть смешивать-то можно, но тогда Serializable будет без всяких предупреждений вести себя, как Repeatable Read. Почему так происходит, мы рассмотрим позже, когда будем говорить о реализации.
Так что если решили использовать Serializble — лучше всего глобально установить умолчательный уровень (хотя это, конечно, не запретит указать неправильный уровень явно):
```
ALTER SYSTEM SET default_transaction_isolation = 'serializable';
```
> Более строгое изложение вопросов, связанных с транзакциями, согласованностью и аномалиями, вы найдете в [книге](https://postgrespro.ru/education/books/dbtech) и [курсе лекций](https://postgrespro.ru/education/university/dbtech) Бориса Асеновича Новикова «Основы технологий баз данных».
>
>
Какой уровень изоляции использовать?
====================================
Уровень изоляции Read Committed используется в PostgreSQL по умолчанию и, по всей видимости, именно этот уровень используется в абсолютном большинстве приложений. Он удобен тем, что на нем обрыв транзакции возможен только в случае сбоя, но не для предотвращения несогласованности. Иными словами, ошибка сериализации возникнуть не может.
Обратной стороной медали является большое число возможных аномалий, которые были подробно рассмотрены выше. Разработчику приходится постоянно иметь их ввиду и писать код так, чтобы не допускать их появления. Если не получается сформулировать нужные действия в одном SQL-операторе, приходится прибегать к явной установке блокировок. Самое неприятное то, что код сложно тестировать на наличие ошибок, связанных с получением несогласованных данных, а сами ошибки могут возникать непредсказуемым и невоспроизводимым образом и поэтому сложны в исправлении.
Уровень изоляции Repeatable Read снимает часть проблем несогласованности, но, увы, не все. Поэтому приходится не только помнить об оставшихся аномалиях, но и изменять приложение так, чтобы оно корректно обрабатывало ошибки сериализации. Это, конечно, неудобно. Но для только читающих транзакций этот уровень прекрасно дополняет Read Committed и очень удобен, например, для построения отчетов, использующих несколько SQL-запросов.
Наконец, уровень Serializable позволяет вообще не заботиться о несогласованности, что значительно упрощает написание кода. Единственное, что требуется от приложения — уметь повторять любую транзакций при получении ошибки сериализации. Но доля прерываемых транзакций, дополнительные накладные расходы, а также невозможность распараллеливать запросы могут существенно снизить пропускную способность системы. Также следует учитывать, что уровень Serializable не применим на репликах, и то, что его нельзя смешивать с другими уровнями изоляции.
[Продолжение](https://habr.com/ru/company/postgrespro/blog/444536/). | https://habr.com/ru/post/442804/ | null | ru | null |
# IPython: замена стандартного Python shell
Python shell достаточно удобная вещь для тестирования и изучения возможностей языка, кто-то даже использует его в качестве калькулятора(что между прочим весьма удобно), в этом цикле статей я бы хотел рассказать о IPython — замене стандартного Python shell'а, который предоставляет расширенный список возможностей, что делает работу с ним более эффективной.
Скачать и установить IPython можно с [официального сайта](http://ipython.scipy.org/moin/)
### Пространство имен
Запускаем IPython shell командой 'ipython', как и в в стандартном Python shell'е мы можем присваивать переменным значения:
`In [1]: msgflag = 1
In [2]: pi = 3
In [3]: msg = "hello"
In [4]: warning = None`
Во время ввода можно пользоваться автокомплитом, например набрав msg и нажав Tab, мы получим возможные варианты:
`In [5]: msg
msg msgflag`
Если вариант один, то он автоматически появится в поле ввода.
IPython предоставлять возможность использования пространств имен, например, команда 'who' выводит список доступных переменных:
`In [5]: who
msg msgflag pi warning`
Она имеет ряд опций, например, чтобы вывести переменные типа int, следует написать:
`In [6]: who int
msgflag pi`
Если требуется получить дополнительную информацию о переменных, можно воспользоваться командой 'whos':
````
In [7]: whos
Variable Type Data/Info
--------------------------------
msg str hello
msgflag int 1
pi int 3
warning NoneType None
````
Так же есть возможность поиска по имени переменной, для этого нужно использовать команду 'psearch':
`In [8]: psearch msg*
msg
msgflag`
Возможно расширить критерии поиска типом переменной, например:
`In [9]: psearch msg* int
msgflag`
Для того чтобы сохранить переменную в профайле(она будет доступна после перезапуска IPython) есть команда 'store':
`In [10]: store msgflag
Stored 'msgflag' (int)`
Так же есть возможность сохранить переменную в отдельный файл:
`In [11]: store msgflag > /tmp/m.txt
Writing 'msgflag' (int) to file '/tmp/m.txt'.`
Чтобы посмотреть сохраненные переменные, вводится команда 'store' без параметров:
`In [12]: store
Stored variables and their in-db values:
msgflag -> 1`
Чтобы очистить текущее пространство имен, воспользуемся командой 'reset' и убедимся, что оно очистилось при помощи команды 'who':
`In [13]: reset
Once deleted, variables cannot be recovered. Proceed (y/[n])? y
In [14]: who
Interactive namespace is empty.`
Можно восстановить переменные, которые были ранее сохранены при помощи команды 'store' и убедиться, что они восстановились командой 'who':
`In [15]: store -r
In [16]: who
msgflag`
Так же можно очистить все, что находится в store и при следующем старте пространство имен будет пустым:
`In [17]: store -z`
### Логгирование
Другая полезная возможность IPython — логгирование. Команда 'logstate' проверяет текущее состояние логгера:
`In [18]: logstate
Logging has not been activated.`
Командой 'logstart' можно начать логгирование:
`In [19]: logstart
Activating auto-logging. Current session state plus future input saved.
Filename : ipython_log.py
Mode : rotate
Output logging : False
Raw input log : False
Timestamping : False
State : active`
Лог сохраняется в текущей директории как исходный код Python
Команды 'logon' и 'logoff' используются для включения/выключения логгирования:
`In [20]: logoff
Switching logging OFF
In [21]: logon
Switching logging ON`
### Магические команды
Команды, описанные выше в терминологии IPython называются magic commands(магические команды). Для того, чтобы посмотреть полный список magic команд, нужно ввести 'lsmagic':
`In [22]: lsmagic
Available magic functions:
%Exit %Pprint %Quit %alias %autocall %autoindent %automagic %bg %bookmark %cd %clear %color_info %colors %cpaste %debug %dhist %dirs %doctest_mode %ed %edit %env %exit %hist %history %logoff %logon %logstart %logstate %logstop %lsmagic %macro %magic %p %page %pdb %pdef %pdoc %pfile %pinfo %popd %profile %prun %psearch %psource %pushd %pwd %pycat %quickref %quit %r %rehash %rehashx %rep %reset %run %runlog %save %sc %store %sx %system_verbose %time %timeit %unalias %upgrade %who %who_ls %whos %xmode
Automagic is ON, % prefix NOT needed for magic functions.`
Магические команды могут использовать знак процента в качестве префикса. Это полезно в случае, если имя переменной совпадает с именем команды.
Для вызова помощи по всем магическим командам используется 'magic' команда. Для получения справки по определенный магической команды достаточно просто поставить знак вопроса в конце:
`In [23]: lsmagic?
Type: Magic function
Base Class:
String Form: >
Namespace: IPython internal
File: /Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/site-packages/ipython-0.9.1-py2.5.egg/IPython/Magic.py
Definition: lsmagic(self, parameter\_s='')
Docstring:
List currently available magic functions.`
Для получения дополнительной информации следует ввести 2 знака вопроса в конце команды, в таком случае выводится и исходный код команды-функции.
Для переменных определенных самостоятельно, можно так же использовать знак вопроса:
`In [24]: msgflag?
Type: int
Base Class:
String Form: 1
Namespace: Interactive
Docstring:
int(x[, base]) -> integer
Convert a string or number to an integer, if possible. A floating point
argument will be truncated towards zero ...`
### Некоторые «косметические» команды
Можно использовать 'p' как сокращение для 'print':
`In [25]: import sys
In [26]: p sys.path
['', '/Library/Frameworks/Python.framework/Versions/2.5/bin', '/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/site-packages/setuptools-0.6c9-py2.5.egg', '/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/site-packages/bdist_mpkg-0.4.3-py2.5.egg', '/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/site-packages/macholib-1.1-py2.5.egg',
...`
Так же можно пользоваться сокращенной формой для вызова функций:
`In [27]: def x(a, b):
....: print a, b
....:
....:
In [28]: x 3, 4
-------> x(3, 4)
3 4`
Для вызова функции можно сделать так:
`In [29]: def x(): print "123"
....:
In [30]: /x
-------> x()
123`
Можно вызвать функцию, которая в качестве параметров принимает строки, без необходимости заключать их в кавычки:
`In [31]: def x(a,b): print "%s-%s" % (a, b)
....:
In [32]: , x astr bstr
-------> x("astr", "bstr")
astr-bstr`
### Интроспекция
Если вы забыли какие аргументы нужны для вызова функции или метода, вы всегда можете узнать это при помощи команды 'pdef':
`In [37]: import re
In [38]: pdef re.match
re.match(pattern, string, flags=0)`
Так же можно посмотреть документацию по этой функции:
`In [39]: pdoc re.match
Class Docstring:
Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found.
Calling Docstring:
x.__call__(...) <==> x(...)`
Всю информацию о функции можно посмотреть при помощи команды 'pinfo':
`In [40]: pinfo re.match
Type: function
Base Class:
String Form:
Namespace: Interactive
File: /Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/re.py
Definition: re.match(pattern, string, flags=0)
Docstring:
Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found.`
Вы так же можете посмотреть исходный код функции:
`In [41]: psource re.match
def match(pattern, string, flags=0):
"""Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found."""
return _compile(pattern, flags).match(string)`
Если вы хотите посмотреть исходный код файла, в котором определен тот или иной объект, используйте команду 'pfile':
`In [42]: pfile re.match`
Так же можно запустить ваш любимый редактор для редактирования файла, в котором определен тот или иной объект:
`In [43]: edit -x re.match
Editing...`
#### Ссылки на источники
Скринкаст — <http://showmedo.com/videos/video?name=1000010&fromSeriesID=100>
Официальная документация — <http://ipython.scipy.org/moin/Documentation>
PS: На этом пока все, если эта тема кому-то интересна, то в следующих статьях продолжу описание возможностей IPython. | https://habr.com/ru/post/49685/ | null | ru | null |
# Micropython на GSM+GPS модуле A9G
В этот раз я задумался о том, чтобы спрятать в велосипед GPS-трэкер в качестве меры предосторожности. На рынке есть масса автономных устройств для слежения за автомобилями, грузом, велосипедами, багажом, детьми и животными. Подавляющее большинство из них взаимодействуют с пользователем с помощью СМС. Более дорогие варианты предоставляют функциональность Find my phone, но привязаны к конкретному онлайн-сервису.
В идеале хотелось бы иметь полный контроль над трекером: использовать его в удобном режиме без СМС и регистрации. Поверхностное гугление вывело меня на пару модулей из поднебесной, один из которых, A9G pudding board, я и заказал (~15$).
Эта статья о том, как я заставил работать python на этом модуле.
Если A9G — аналог ESP (производитель, кстати, один и тот же), то сам pudding board является аналогом платы NodeMCU за исключением того, что на pudding board нет встроенного конвертера USB-UART. Зато есть много другого интересного. Спецификации от [производителя](https://github.com/Ai-Thinker-Open/GPRS_C_SDK/blob/master/README_EN.md):
* ядро 32 bit (RISC), до 312MHz
* 29x GPIO (все распаяны, в это число включены все интерфейсы)
* часы и watchdog
* 1x интерфейс USB 1.1 (я его там не нашел, но копирую с офсайта) и microUSB для питания
* 2x UART (+1 сервисный)
* 2x SPI (не пробовал)
* 3x I2C (не пробовал)
* 1x SDMMC (с физическим слотом)
* 2x аналоговых входа (10 бит, возможно, один из них используется контроллеров литиевых аккумуляторов)
* 4Mb flash
* 4Mb PSRAM
* ADC (микрофон, физически существует на плате) и DAC (динамик, отсутствует)
* контроллер заряда аккумулятора (самого аккумулятора нет)
* собственно, GSM (800, 900, 1800, 1900 MHz) с SMS, голосом и GPRS
* GPS, подключенный через UART2 (есть модуль "A9" без него)
* слот для SIM (nanoSIM)
* две кнопки (одна reset, другая — включение и программируемая функция)
* два светодиода
Рабочее напряжение 3.3В, входное напряжение — 5-3.8В (в зависимости от подключения). Вообще, модуль имеет всё необходимое железо для того, чтобы собрать из него простенький кнопочный мобильный аппарат. Но из примеров создаётся впечатление, что китайцы его покупают для продажи из автоматов или автоматов с азартными играми или что-то вроде этого. Альтернативами модулю являются довольно популярные модули SIM800, у которых, к сожалению, нет SDK в свободном доступе (т.е. модули продаются как AT модемы).
SDK
===
К модулю прилагается [SDK](https://github.com/Ai-Thinker-Open/GPRS_C_SDK) на удовлетворительном английском. Устанавливается под Ubuntu, но предпочтительными являются Windows и контейнеры. Всё работает через тыкание в GUI: ESPtool для этого модуля только предстоит зареверсить. Сама прошивка собирается Makefile-ом. Дебаггер наличествует: прежде чем зависнуть, модуль вываливает stack trace в сервисный порт. Но лично я так и не смог перевести адреса в строчки кода (gdb сообщает, что адреса ничему не соответствуют). Вполне возможно, что это связано с плохой поддержкой Linux как такового. Соответственно, если хотите повозиться с модулем — попробуйте это сделать под Windows (и отписаться на github). В противном случае вот [инструкция](https://ai-thinker-open.github.io/GPRS_C_SDK_DOC/en/c-sdk/installation_linux.html) для Linux. После установки нужно проверить правильность путей в .bashrc и удалить (переименовать) все файлы `CSDTK/lib/libQt*`: иначе, прошивальщик (он же дебаггер) просто не запустится из-за конфликта с, вероятно, установленным libQt.
К прошивальщику идёт [инструкция](https://ai-thinker-open.github.io/GPRS_C_SDK_DOC/en/c-sdk/burn-debug.html).
Подключение
===========
Тут всё сложнее, чем, на NodeMCU. Модули выглядят похоже, но на pudding board нет USB-TTY чипа и microUSB используется только для питания. Соответственно, вам понадобится USB-TTY на 3.3V. А лучше — два: один для дебаг порта и ещё один для UART1: первый используется для заливки прошивки а второй вы сможете использовать как обычный терминал. Чтобы не тащить все эти сопли к компьютеру я дополнительно приобрел USB разветвитель на 4 порта с двухметровым проводом и внешним блоком питания (обязателен). Суммарная стоимость этого набора с самим модулем составит 25-30$ (без блока питания: используйте от телефона).
Прошивка
========
Модуль приходит с AT прошивкой: можно подключить к 3.3В ардуине и использовать в качестве модема через UART1. Свои прошивки пишутся на C. `make` создает два файла прошивки: один шьётся около минуты, другой — достаточно быстро. Шить можно только один из этих файлов: первый раз — большой, последующие разы — маленький. Суммарно, у меня в процессе разработки на рабочем столе открыта китайская SDK (`coolwatcher`) для управления модулем, miniterm в качестве stdio и редактор кода.
API
===
Содержание [API](https://ai-thinker-open.github.io/GPRS_C_SDK_DOC/en/) отражает список наверху и напоминает ESP8266 в свои ранние дни: у меня ушло часа 3 на то, чтобы запустить HelloWorld. К сожалению, набор функций, доступных пользователю, весьма ограничен: к примеру, нет доступа к телефонной книге на SIM-карте, низкоуровневой информации о подключении к сотовой сети и тому прочее. Документация по API ещё менее полная, поэтому опираться приходится на примеры (которых два десятка) и include-файлы. Тем не менее, модуль может очень многое вплоть до SSL-подключений: очевидно, производитель сфокусировался на наиболее приоритетных функциях.
Впрочем, программирование китайских микроконтроллеров посредством китайского API надо любить. Для всех остальных производитель [начал портировать](https://github.com/Neutree/micropython/) [micropython](https://micropython.org/) на этот модуль. Я решил попробовать себя в open-source проекте и продолжить это доброе дело (ссылка в конце статьи).
micropython
===========
Micropython — это open-source проект портирующий cPython на микроконтроллеры. Разработка ведётся в двух направлениях. Первое — это поддержка и развитие общих для всех микроконтроллеров core-библиотек, описывающих работу с основными типами данных в python: объекты, функции, классы, строки, атомарные типы и тому прочее. Второе — это, собственно, порты: для каждого микроконтроллера необходимо "научить" библиотеку работать с UART для ввода-вывода, выделить стэк под виртуальную машину, указать набор оптимизаций. Опционально, описывается работа с железом: GPIO, питание, беспроводная связь, файловая система.
Всё это пишется на чистых С с макросами: у micropython есть набор рекомендованных рецептов начиная с объявления строк в ROM до написания модулей. В дополнение к этому, полностью поддерживаются самописные модули на питоне (главное — не забывать об объёме памяти). Кураторы проекта ставят целью [возможность запустить джангу](https://github.com/micropython/micropython/wiki/ContributorGuidelines) (картинка с буханкой хлеба). В качестве рекламы: проект продаёт собственную плату для студентов [pyboard](https://store.micropython.org/), но также популярны порты для модулей ESP8266 и ESP32.
Когда прошивка готова и залита — вы просто подключаетесь к микроконтроллеру через UART и попадаете в питонский REPL.
```
$ miniterm.py /dev/ttyUSB1 115200 --raw
MicroPython cd2f742 on 2017-11-29; unicorn with Cortex-M3
Type "help()" for more information.
>>> print("hello")
hello
```
После этого можно начинать писать [на почти обычном python3](https://github.com/micropython/micropython/wiki/Differences), не забывая об ограничениях памяти.
Модуль A9G не поддерживается официально (список официально поддерживаемых модулей доступен в `micropython/ports`, их около десятка). Тем не менее, производитель железа форкнул micropython и создал окружение для порта A9G: [`micropython/ports/gprs_a9`](https://github.com/Neutree/micropython/tree/master/ports/gprs_a9), за что ему большое спасибо. На момент, когда я заинтересовался этим вопросом, порт успешно компилировался и микроконтроллер приветствовал меня REPL. Но, к сожалению, из сторонних модулей присутствовала только работа с файловой системой и GPIO: ничего, связанного с беспроводной сетью и GPS доступно не было. Я решил исправить эту недоработку и поставил себе цель портировать все функции, необходимые для GPS-трекера. [Официальная документация](https://micropython-dev-docs.readthedocs.io/en/latest/adding-module.html) на этот случай излишне лаконична: поэтому, пришлось ковыряться в коде.
С чего начать
-------------
Первым делом идём в `micropython/ports` и копируем `micropython/ports/minimal` в новую папку, в которой будет находится порт. Затем, редактируем `main.c` под вашу платформу. Имейте ввиду, что вся вкуснятина находится в функции `main`, где нужно вызвать инициализатор `mp_init()`, предварительно подготовив для него настройки микроконтроллера и стэк. Потом, для event-driven API, необходимо вызвать `pyexec_event_repl_init()` и скармливать вводимые через UART символы в функцию `pyexec_event_repl_process_char(char)`. Это и обеспечит взаимодействие через REPL. Второй файл — `micropython/ports/minimal/uart_core.c` описывает блокирующий ввод и вывод в UART. Привожу оригинальный код для STM32 для тех, кому лень искать.
`main.c`
```
int main(int argc, char **argv) {
int stack_dummy;
stack_top = (char*)&stack_dummy;
#if MICROPY_ENABLE_GC
gc_init(heap, heap + sizeof(heap));
#endif
mp_init();
#if MICROPY_ENABLE_COMPILER
#if MICROPY_REPL_EVENT_DRIVEN
pyexec_event_repl_init();
for (;;) {
int c = mp_hal_stdin_rx_chr();
if (pyexec_event_repl_process_char(c)) {
break;
}
}
#else
pyexec_friendly_repl();
#endif
//do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\\n')", MP_PARSE_SINGLE_INPUT);
//do_str("for i in range(10):\r\n print(i)", MP_PARSE_FILE_INPUT);
#else
pyexec_frozen_module("frozentest.py");
#endif
mp_deinit();
return 0;
}
```
`uart_core.c`
```
// Receive single character
int mp_hal_stdin_rx_chr(void) {
unsigned char c = 0;
#if MICROPY_MIN_USE_STDOUT
int r = read(0, &c, 1);
(void)r;
#elif MICROPY_MIN_USE_STM32_MCU
// wait for RXNE
while ((USART1->SR & (1 << 5)) == 0) {
}
c = USART1->DR;
#endif
return c;
}
// Send string of given length
void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
#if MICROPY_MIN_USE_STDOUT
int r = write(1, str, len);
(void)r;
#elif MICROPY_MIN_USE_STM32_MCU
while (len--) {
// wait for TXE
while ((USART1->SR & (1 << 7)) == 0) {
}
USART1->DR = *str++;
}
#endif
}
```
После этого нужно переписать Makefile используя рекомендации / компилятор от производителя: тут всё индивидуально. Всё, этого в идеале должно хватить: собираем, заливаем прошивку и видим REPL в UART.
После оживления `micropython` необходимо позаботиться о его хорошем самочувствии: настроить сборщик мусора, правильную реакцию на Ctrl-D (soft reset) и некоторые другие вещи, на которых я не буду останавливаться: см. файл `mpconfigport.h`.
Создаём модуль
--------------
Самое интересное — написание собственных модулей. Итак, модуль (не обязательно, но желательно) начинается с собственного файла `mod[имя].c`, который добавляется `Makefile` (переменная `SRC_C` если следовать конвенции). Пустой модуль выглядит следующим образом:
```
// nlr - non-local return: в C исключений нет, и чтобы их имитировать используется goto-магия и ассемблер.
// Функция nlr_raise прерывает исполнение кода в точке вызова и вызывает ближайший по стэку обработчик ошибок.
#include "py/nlr.h"
// Основные питонские типы. К примеру, структура mp_map_elem_t, статичный словарь, объявлен именно там.
#include "py/obj.h"
// Высокоуровневое управление рантаймом. mp_raise_ValueError(char* msg) и mp_raise_OSError(int errorcode) находятся именно здесь.
// В дополнение, набор функций mp_call_function_* используется для вызова питонских Callable (полезно для callback-логики).
#include "py/runtime.h"
#include "py/binary.h"
// Общий header для всех модулей: тут как хотите так и организовывайте
#include "portmodules.h"
// Словарь со списком всех-всех-всех атрибутов модуля. Имена задаются через макрос MP_QSTR_[имя атрибута]. MP_OBJ_NEW_QSTR делает питонскую обертку.
// В этих двух макросах используются всевозможные оптимизации чтобы не хранить строку в RAM.
// Единственная запись на текущий момент - имя модуля в магическом поле __name__
STATIC const mp_map_elem_t mymodule_globals_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) },
};
// Питонская обёртка вокруг словаря сверху
STATIC MP_DEFINE_CONST_DICT (mp_module_mymodule_globals, mymodule_globals_table);
// Объявление самого модуля: объект нашего модуля наследует объект базового модуля и содержит список атрибутов сверху
const mp_obj_module_t mp_module_mymodule = {
.base = { ∓_type_module },
.globals = (mp_obj_dict_t*)∓_module_mymodule_globals,
};
```
Конечно, порт сам по себе не узнает о константе `mp_module_mymodule`: её необходимо добавить в переменную `MICROPY_PORT_BUILTIN_MODULES` в настройках порта `mpconfigport.h`. Кстати, ~~нескучные обои~~ имя чипа и название порта меняются тоже там. После всех этих изменений можно попытаться скомпилировать модуль и импортировать его из REPL. У модуля будет доступен только один атрибут `__name__` с именем модуля (отличный случай для проверки автодополнения в REPL через Tab).
```
>>> import mymodule
>>> mymodule.__name__
'mymodule'
```
Константы
---------
Следующий этап по сложности — добавление констант. Константы часто необходимы для настроек (`INPUT`, `OUTPUT`, `HIGH`, `LOW` и т.п.) Тут всё достаточно просто. Вот, к примеру, константа `magic_number = 10`:
```
STATIC const mp_map_elem_t mymodule_globals_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) },
};
```
Тестируем:
```
>>> import mymodule
>>> mymodule.magic_number
10
```
Функции
-------
Добавление функции в модуль следует общему принципу: объявить, обернуть, добавить (привожу чуть более сложный пример, чем в документации).
```
// Объявляем
STATIC mp_obj_t conditional_add_one(mp_obj_t value) {
// Получаем целое int. Если передали строку или любой другой несовместимый объект - нет проблем: исключение вывалится автоматически.
int value_int = mp_obj_get_int(value);
value_int ++;
if (value_int == 10) {
// Возврат None
return mp_const_none;
}
// Возврат питонского int
return mp_obj_new_int(value);
}
// Оборачиваем функцию одного аргумента. Для заинтересованных предлагаю посмотреть
// runtime.h относительно других вариантов.
STATIC MP_DEFINE_CONST_FUN_OBJ_1(conditional_add_one_obj, conditional_add_one);
// Добавляем
STATIC const mp_map_elem_t mymodule_globals_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&conditional_add_one_obj },
};
```
Тестим:
```
>>> import mymodule
>>> mymodule.conditional_add_one(3)
4
>>> mymodule.conditional_add_one(9)
>>>
```
Классы (типы)
-------------
С классами (типами) всё тоже относительно просто. Вот пример из документации (ну почти):
```
// Пустая таблица атрибутов класса
STATIC const mp_map_elem_t mymodule_hello_locals_dict_table[] = {};
// Словарная обёртка
STATIC MP_DEFINE_CONST_DICT(mymodule_hello_locals_dict, mymodule_hello_locals_dict_table);
// Структура, определяющая объект, являющийся типом
const mp_obj_type_t mymodule_helloObj_type = {
// Наследуем базовый тип
{ ∓_type_type },
// Имя: helloObj
.name = MP_QSTR_helloObj,
// Атрибуты
.locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict,
};
// Добавляем в модуль
STATIC const mp_map_elem_t mymodule_globals_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_mymodule) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_magic_number), MP_OBJ_NEW_SMALL_INT(10) },
{ MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&conditional_add_one_obj },
{ MP_OBJ_NEW_QSTR(MP_QSTR_conditional_add_one), (mp_obj_t)&mymodule_helloObj_type },
};
```
Тестим:
```
>>> mymodule.helloObj
```
Получившийся тип можно наследовать, сравнивать, но у него нет ни конструктора ни каких-либо ассоциированных данных. Данные добавляются "рядом" с конструктором: предлагается создать отдельную структуру, в которой будет хранится отдельно питонский тип и отдельно — произвольный набор данных.
```
// Произвольная над-структура. Да, с именами путаница
typedef struct _mymodule_hello_obj_t {
// Питонский тип
mp_obj_base_t base;
// Какие-то данные
uint8_t hello_number;
} mymodule_hello_obj_t;
```
Как взаимодействовать с этими данными? Один из самых сложных способов — через конструктор.
```
// Функция-конструктор, принимающая тип (который, вполне возможно, отличается от mymodule_helloObj_type
// по той причине, что тип был наследован чем-то другим), количество аргументов (args и kwargs) и
// указатель на сами аргументы в том же порядке: args, kwargs
STATIC mp_obj_t mymodule_hello_make_new( const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args ) {
// Проверить количество аргументов
mp_arg_check_num(n_args, n_kw, 1, 1, true);
// Создать экземпляр
mymodule_hello_obj_t *self = m_new_obj(mymodule_hello_obj_t);
// Положить тип куда надо
self->base.type = &mymodule_hello_type;
// Присвоить данные
self->hello_number = mp_obj_get_int(args[0])
// Вернуть экземпляр
return MP_OBJ_FROM_PTR(self);
// Второй аргумент в __init__, видимо, проигнорировали
}
// Конструктор должен сидеть в поле make_new
const mp_obj_type_t mymodule_helloObj_type = {
{ ∓_type_type },
.name = MP_QSTR_helloObj,
.locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict,
// Конструктор
.make_new = mymodule_hello_make_new,
};
```
Из других полей есть ещё `.print`, и, полагаю, вся остальная магия `Python3`.
Но `make_new` вовсе не обязателен для получения экземпляра объекта: инициализацию можно производить в произвольной функции. Вот неплохой пример из `micropython/ports/esp32/modsocket.c`:
```
// Другая сигнатура функции: количество аргументов и указатель на аргументы
STATIC mp_obj_t get_socket(size_t n_args, const mp_obj_t *args) {
socket_obj_t *sock = m_new_obj_with_finaliser(socket_obj_t);
sock->base.type = &socket_type;
sock->domain = AF_INET;
sock->type = SOCK_STREAM;
sock->proto = 0;
sock->peer_closed = false;
if (n_args > 0) {
sock->domain = mp_obj_get_int(args[0]);
if (n_args > 1) {
sock->type = mp_obj_get_int(args[1]);
if (n_args > 2) {
sock->proto = mp_obj_get_int(args[2]);
}
}
}
sock->fd = lwip_socket(sock->domain, sock->type, sock->proto);
if (sock->fd < 0) {
exception_from_errno(errno);
}
_socket_settimeout(sock, UINT64_MAX);
return MP_OBJ_FROM_PTR(sock);
}
// Обёртка для функции с 0-3 аргументами
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(get_socket_obj, 0, 3, get_socket);
```
Привязанные методы (bound methods)
----------------------------------
Следующий этап — добавление привязанных методов. Впрочем, это мало чем отличается от всех остальных методов. Возвращаемся к примеру из документации:
```
// Ещё один пример сигнатуры: количество аргументов строго равно 1 (self)
STATIC mp_obj_t mymodule_hello_increment(mp_obj_t self_in) {
mymodule_hello_obj_t *self = MP_OBJ_TO_PTR(self_in);
self->hello_number += 1;
return mp_const_none;
}
// Обёртка функции одной переменной
MP_DEFINE_CONST_FUN_OBJ_1(mymodule_hello_increment_obj, mymodule_hello_increment);
// Добавляем в аттрибуты под именем 'inc'
STATIC const mp_map_elem_t mymodule_hello_locals_dict_table[] = {
{ MP_OBJ_NEW_QSTR(MP_QSTR_inc), (mp_obj_t)&mymodule_hello_increment_obj },
}
```
Всё!
```
>>> x = mymodule.helloObj(12)
>>> x.inc()
```
Все остальные атрибуты: **getattr**, **setattr**
------------------------------------------------
Как насчёт добавления не-функций, использования `@property` и вообще собственного `__getattr__`? Пожалуйста: это делается вручную в обход `mymodule_hello_locals_dict_table`.
```
// Функция со специфической сигнатурой ...
STATIC void mymodule_hello_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
mymodule_hello_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (dest[0] != MP_OBJ_NULL) {
// __setattr__
if (attr == MP_QSTR_val) {
self->val = dest[1];
dest[0] = MP_OBJ_NULL;
}
} else {
// __getattr__
if (attr == MP_QSTR_val) {
dest[0] = self->val;
}
}
}
// ... идёт прямиком в магический attr
const mp_obj_type_t mymodule_helloObj_type = {
{ ∓_type_type },
.name = MP_QSTR_helloObj,
// Словарь больше не используется
//.locals_dict = (mp_obj_dict_t*)&mymodule_hello_locals_dict,
.make_new = mymodule_hello_make_new,
// Вместо него - attr
.attr = mymodule_hello_attr,
};
```
Что-то больно лаконичный attr получился, скажете вы. Где же все эти `mp_raise_AttributeError` (*прим*: такая функция не существует)? На самом деле, `AttributeError` будет вызван автоматически. Секрет в том, что `dest` — это массив из двух элементов. Первый элемент имеет смысл "вывода", write-only: он принимает значение `MP_OBJ_SENTINEL` если значение необходимо записать и `MP_OBJ_NULL` если его нужно прочитать. Соответственно, на выходе из функции ожидается `MP_OBJ_NULL` в первом случае и что-то `mp_obj_t` во втором. Второй элемент — "ввод", read-only: принимает значение объекта для записи, если значение необходимо записать и `MP_OBJ_NULL`, если его необходимо прочитать. Менять его не надо.
Вот и всё, можно проверять:
```
>>> x = mymodule.helloObj(12)
>>> x.val = 3
>>> x.val
3
```
Самое интересное — что автодополнение по Таb в REPL по-прежнему работает и предлагает `.val`! Я, если честно, никак не эксперт в C, поэтому могу только предполагать как это происходит (переопределением оператора '==').
Порт
----
Возвращаясь к модулю A9G, я [описал](https://github.com/pulkin/micropython/tree/master/ports/gprs_a9) поддержку всех основных функций, а именно, SMS, GPRS (usockets), GPS, управление питанием. Теперь можно залить что-то вроде этого на модуль и оно будет работать:
```
import cellular as c
import usocket as sock
import time
import gps
import machine
# Ожидаем сеть
print("Waiting network registration ...")
while not c.is_network_registered():
time.sleep(1)
time.sleep(2)
# Включаем GPRS
print("Activating ...")
c.gprs_activate("internet", "", "")
print("Local IP:", sock.get_local_ip())
# Включаем GPS
gps.on()
# Отдаём данные на thingspeak
host = "api.thingspeak.com"
api_key = "some-api-key"
fields = ('latitude', 'longitude', 'battery', 'sat_visible', 'sat_tracked')
# Какая прелесть, что эта мешанина работает на микроконтроллере!
fields = dict(zip(fields, map(lambda x: "field{}".format(x+1), range(len(fields))) ))
x, y = gps.get_location()
level = machine.get_input_voltage()[1]
sats_vis, sats_tracked = gps.get_satellites()
s = sock.socket()
print("Connecting ...")
s.connect((host, 80))
print("Sending ...")
# Пока что сокеты мало что поддерживают, поэтому запрос через сырой HTTP. В будущем можно будет использовать библиотеки на чистом питоне для HTTP, SSL и прочего
print("Sent:", s.send("GET /update?api_key={}&{latitude}={:f}&{longitude}={:f}&{battery}={:f}&{sat_visible}={:d}&{sat_tracked}={:d} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n\r\n".format(
api_key,
x,
y,
level,
sats_vis,
sats_tracked,
host,
**fields
)))
print("Receiving ...")
print("Received:", s.recv(128))
s.close()
```
Проект приветствует любую посильную помощь. Если вам понравился проект и/или эта статья — не забудьте оставить [лайк на гитхабе](https://github.com/pulkin/micropython/tree/master/ports/gprs_a9). | https://habr.com/ru/post/446090/ | null | ru | null |
# Адаптируем RoboVM для компиляции под iOS из Windows/Linux
Прошло полтора года как Microsoft закрыл случайно оказавшийся в корзине с Xamarin-ом RoboVM. Уже и официальный robovm.com канул в лету. Последняя opensource версия 1.8 была форкнута группой MobiVM и поддерживается ~~на искусственном дыхании~~ в рабочем состоянии и сейчас.
Сам RoboVM (тут и далее MobiVM форк я буду называть так) тесно переплетен с MacOSX и в оригинальном виде, будучи запущенным в Windows/Linux встречает сообщением, что код писать можно, компилировать нельзя. Встречая в cmake файлах/сети упоминании о Windows, принял вызов и решил довести дело к какому-либо результату.
Понадобится:
* linux/windows версия библиотеки llvm;
* linux/windows версия библиотеки libimobiledevice;
* линкер;
* iOS sdk;
* codesign;
* суррогатный набор утилит идентичный такому из Xcode;
С первыми четырьмя пунктами особых вопросов не возникло:
* сборка llvm и libimobiledevice уже присутствовала в репозитории RoboVM, и после адаптации cmake файлов были получены рабочие библиотеки;
* линкер был взят в проекте [tpoechtrager/cctools-port](https://github.com/tpoechtrager/cctools-port) и был изначально в рабочем состоянии. Однако собирался только в `cygwin`;
* iOS sdk для академических целей был получен методом `backup` папки Xcode из MacOSX;
Для proof of concept (или скорейшего облома) исходный код грубо рубился, кросскомпилировалось все на коленке и еще в августе был слинкован первый исполняемый файл из Windows. С подписанием кода так весело не пошло. Попытка подписать все так же на скорую используя [saucelabs/isign](https://github.com/saucelabs/isign) к успеху не привела: утилита могла переподписать только уже подписанные приложение (с выделенной LC\_CODE\_SIGNATURE), тащила в зависимостях openssl и в целом была написана в лучших традициях питона. Стоит отметить, что исходный код codesign от Apple не закрыт, но сборка его не под Мак платформу сложна и полна нерешенных зависимостей.
Решение проблемы пришло само-собой: был написал собственный ~~велосипед~~ [codesign](https://github.com/dkimitsa/robovm/tree/linuxwindows/compiler/codesign) на Java. За основу взят isign. Для лучшего понимания сначала был написан верификатор подписи, а далее, развернув его на 180 градусов получен signer.
Первый успех! Простое приложение, которое не требует утилит из Xcode(так же все мешающие части кода были безжалостно выпилены) было запущено на устройстве. Заканчивался октябрь.
Далее началась рутина: приведение исходного кода в чувство, вынос платформо-зависимого кода за фасад, формирование суррогатного набора утилит (аналогичного Xcode), боль и слезы кросскомпиляции и долгие часы сборки. Рутину разбавил своеобразно: портировал линковщик с `cygwin` на сборку под `MinGW` известным методом — заменяя `posix` функционал доступным суррогатом, что добавило новых побочных эффектов, например, притащило ограничение пути в 260 символов. Но теперь весь бестиарий собирался в одном месте, из-под Linux.
В результате получился такой набор:
* `actool` из [facebook/xcbuild](https://github.com/facebook/xcbuild)
* `plutil` из [facebook/xcbuild](https://github.com/facebook/xcbuild)
* `xib2nib` (аналог `ibtool`) с большим скрипом из нерабочего [Microsoft/WinObjC](https://github.com/dkimitsa/WinObjC/tree/xib2nib) (вероятно, в большинстве случаев работать не будет)
* `codesign_allocate`, `lipo`, `nm`, `otool`, `strip` из проекта линковщика [tpoechtrager/cctools-port](https://github.com/dkimitsa/cctools-port/tree/mingw)
* `dsymutil` из LLVM5, пришлось отдельно собирать, т.к. получаемый `dsymutil` во время компиляции libllvm для RoboVM оказался устаревшим и несовместимым (v3.6)
* утилита `file`, для Windows. В коде RoboVM используется для определения типа библиотек. Оказалось, проще собрать под Windows, чем менять логику.
В итоге получился забавный проект, в данный момент ограничен лицензией на использования iOS SDK за пределами оборудования Apple. Но можно же поставить Windows на мак и полноценно кросскомпилировать из-под него!
Ссылки:
* [исходный код RoboVM](https://github.com/dkimitsa/robovm/tree/linuxwindows)
* [сборщик toolchain](https://github.com/dkimitsa/robovm-toolchain)
* [линковщик для сборки (mingw)](https://github.com/dkimitsa/cctools-port/tree/mingw)
* [собранные бинарники и инструкция по установке](https://dkimitsa.github.io/2017/12/12/robovm-now-linux-windows/) | https://habr.com/ru/post/345348/ | null | ru | null |
# Наш опыт создания API Gateway
Некоторые компании, в том числе наш заказчик, развивают продукт через партнерскую сеть. Например, крупные интернет-магазины интегрированы со службой доставки — вы заказываете товар и вскоре получаете трекинговый номер посылки. Другой пример — вместе с авиабилетом вы покупаете страховку или билет на аэроэкспресс.
Для этого используется один API, который нужно выдать партнерам через API Gateway. Эту задачу мы и решили. В этой статье расскажем подробности.
Дано: экосистема и API-портал с интерфейсом, где пользователи зарегистрированы, получают информацию и т.п. Нам нужно сделать удобный и надежный API Gateway. В процессе нам нужно было обеспечить
* регистрацию,
* контроль подключения к API,
* мониторинг того, как пользователи используют конечную систему,
* учёт бизнес-показателей.
В статье мы расскажем о нашем опыте создания API Gateway, в ходе которого мы решали следующие задачи:
* аутентификация пользователя,
* авторизация пользователя,
* модификация исходного запроса,
* проксирование запроса,
* постобработка ответа.
Есть два вида API-менеджмента:
1. Стандартный, который работает следующим образом. Перед подключением пользователь тестирует возможности, затем оплачивает и встраивает на свой сайт. Чаще всего им пользуются в малом и среднем бизнесе.
2. Крупный B2B API Management, когда компания сначала принимает бизнес-решение о подключении, становится партнером компании с контрактным обязательством, после чего подключается к API. И уже после улаживания всех формальностей компания получает тестовый доступ, проходит тестирование и выходит в прод. Но это невозможно без управленческого решения о подключении.
### Наше решение
В этой части расскажем о создании API Gateway.
Конечные пользователи создаваемого шлюза к API — партнёры нашего заказчика. Для каждого из них у нас уже хранятся необходимые контракты. Нам нужно будет лишь расширить функциональность, отмечая предоставленный доступ к шлюзу. Соответственно, нужен контролируемый процесс подключения и управления.
Безусловно, можно было взять какое-нибудь готовое решение для решения задачи API Management и создания API Gateway в частности. Например, таким могло быть [Azure API Management](https://docs.microsoft.com/en-us/azure/api-management/). Нам оно не подошло, потому что в нашем случае у нас уже был API-портал и огромная экосистема, построенная вокруг него. Все пользователи уже были зарегистрированы, они уже понимали, где и как они могут получить нужную информацию. В API-портале уже существовали нужные интерфейсы, нам лишь был необходим API Gateway. Собственно, его разработкой мы и занялись.
То, что мы называем API Gateway — своего рода прокси. Тут у нас опять был выбор — можно написать свой прокси, а можно выбрать уже что-то готовое. В этом случае мы пошли вторым путём и выбрали связку nginx+Lua. Почему? Нам необходим был надежный, протестированный software, поддерживающий масштабирование. Мы не хотели после реализации проверять и корректность бизнес-логики, и корректность работы прокси.
У любого веб-сервера есть конвейер обработки запроса. В случае nginx он выглядит следующим образом:
(схема из [GitHub Lua Nginx](https://github.com/openresty/lua-nginx-module))
Нашей целью было встроиться в этот конвейер в тот момент, где мы можем модифицировать исходный запрос.
Мы хотим создать transparent proxy, чтобы функционально запрос оставался таким, каким и пришёл. Мы лишь контролируем доступ к конечному API, помогаем запросу добраться до него. В случае, если запрос был некорректным, ошибку должен показать конечный API, но не мы. Единственная причина, почему мы можем отклонить запрос — из-за отсутствия доступа у клиента.
Для nginx уже существует [расширение](https://github.com/openresty/lua-nginx-module) на [Lua](http://www.lua.ru/). Lua — скриптовый язык, он очень легковесный и лёгкий в освоении. Таким образом, необходимую логику мы реализовали с помощью Lua.
Конфигурация nginx’a (аналогия route приложения), где и выполняется вся работа, вполне понятная. Примечательна здесь последняя директива — post\_action.
```
location /middleware {
more_clear_input_headers Accept-Encoding;
lua_need_request_body on;
rewrite_by_lua_file 'middleware/rewrite.lua';
access_by_lua_file 'middleware/access.lua';
proxy_pass https://someurl.com;
body_filter_by_lua_file 'middleware/body_filter.lua';
post_action /process_session;
}
```
Рассмотрим, что происходит в этой конфигурации:
**more\_clear\_input\_headers** — очищает значение указанных после директивы хэдеров.
**lua\_need\_request\_body** — регулирует, следует ли прочитать исходное тело запроса перед тем, как выполнять директивы rewrite/access/access\_by\_lua или нет. По умолчанию nginx не читает тело запроса клиента, и если вам необходимо получить к нему доступ, то данная директива должна иметь значение on.
**rewrite\_by\_lua\_file** — путь до скрипты, в котором описана логика для модификации запроса
**access\_by\_lua\_file** — путь до скрипта, в котором описана логика, проверяющая наличие доступа к ресурсу.
**proxy\_pass** — url, на который будет проксироваться запрос.
**body\_filter\_by\_lua\_file** — путь до скрипта, в котором описана логика для фильтрации запроса перед возвращением клиенту.
И, наконец, **post\_action** — официально недокументированная директива, с помощью которой можно выполнять ещё какие-либо действия после того, как ответ отдан клиенту.
Далее расскажем по порядку, как мы решали свои задачи.
### Авторизация/аутентификация и модификация запроса
**Авторизация**
Авторизацию и аутентификацию мы построили с помощью доступов по сертификату. Есть корневой сертификат. Каждому новому клиенту заказчика генерируется его личный сертификат, с которым он может получить доступ к API. Этот сертификат настраивается в секции server настроек nginx.
```
ssl on;
ssl_certificate /usr/local/openresty/nginx/ssl/cert.pem;
ssl_certificate_key /usr/local/openresty/nginx/ssl/cert.pem;
ssl_client_certificate /usr/local/openresty/nginx/ssl/ca.crt;
ssl_verify_client on;
```
**Модификация**
Может возникнуть справедливый вопрос: что делать с сертифицированным клиентом, если мы внезапно захотели отключить его от системы? Не перевыпускать же сертификаты для всех остальных клиентов.
Так мы плавно и подошли к следующей задаче — модификация исходного запроса. Исходный запрос клиента, вообще говоря, не является валидным для конечной системы. Одна из задач состоит в том, чтобы дописать в запрос недостающие части, чтобы сделать его валидным. Соль в том, что недостающие данные — разные для каждого клиента. Мы знаем, что клиент приходит к нам с сертификатом, с которого мы можем взять отпечаток и вытянуть из базы необходимые данные клиента.
Если в какой-то момент потребуется отключить клиента от нашего сервиса, его данные пропадут из базы и он ничего не сможет делать.
### Работа с данными клиента
Нам нужно было обеспечить высокую доступность решения, особенно того, как мы получаем данные клиента. Сложность в том, что первоисточник этих данных — сторонний сервис, который не гарантирует бесперебойную и достаточно высокую скорость работы.
Поэтому нам нужно было обеспечить высокую доступность данных клиентов. В качестве инструмента мы выбрали [Hazelcast](https://hazelcast.org/), который предоставляет нам:
* быстрый доступ к данным,
* возможность организовать кластер из нескольких нод с реплицированными на разных нодах данными.
Мы пошли по самой простой стратегии доставки данных в кэш:
Работа с конечной системой происходит в рамках сессий и есть лимит на максимальное количество. Если же клиент не закрыл сессию, это придётся делать нам.
Данные об открытой сессии приходят от конечной системы и изначально обрабатываются на стороне Lua. Мы решили использовать Hazelcast для сохранения этих данных джобиком, написанным на .NET. Затем с некоторой периодичностью мы проверяем право на жизнь открытых сессий и закрываем протухшие.
### Доступ к Hazelcast и из Lua, и из .NET
Клиентов на Lua для работы с Hazelcast нет, но у Hazelcast есть REST API, которым мы и решили воспользоваться. Для .NET же есть [клиент](https://hazelcast.org/clients/net/), через который мы планировали получать доступ к данным Hazelcast на стороне .NET. Но не тут-то было.
При сохранении данных через REST и извлечении через .NET клиента используются разные сериализаторы\десериализаторы. Поэтому невозможно положить данные через REST, а достать через .NET client и наоборот.
Если будут заинтересованные, то подробнее расскажем об этой проблеме в отдельной статье. Спойлер — на схемке.
### Логирование и мониторинг
Наш корпоративный стандарт для логирования через .NET — Serilog, все логи в итоге попадают в Elasticsearch, их анализ ведём через Kibanа. Нечто подобное хотелось сделать и в этом случае. Единственный [клиент](https://github.com/DhavalKapil/elasticsearch-lua) для работы с Elastic на Lua, который был найден, сломался на первом же require. И мы использовали Fluentd.
[Fluentd](https://www.fluentd.org/) — open source решение для обеспечения единого слоя логирования приложения. Позволяет собирать логи с разных слоёв приложения, а потом транслировать их в единый источник.
API Gateway работает в K8S, поэтому мы решили добавить контейнер с fluentd в ту же самую подy, чтобы писать логи в имеющийся открытый tcp port fluentd.
Мы также исследовали, как будет вести себя fluentd, если у него не будет связи с Elasticsearch. В течение двух суток в шлюз непрерывно шли запросы, во fluentd отправлялись логи, но у fluentd был забанен IP Elastic. После восстановления связи fluentd отлично перегнал абсолютно все логи в Elastic.
### Заключение
Выбранный подход к реализации позволил нам доставить реально работающий продукт в боевую среду всего за 2.5 месяца.
Если когда-нибудь вам доведётся заниматься подобными вещами, советуем в первую очередь четко понять, какую задачу вы решаете и что из ресурсов у вас уже есть. Будьте внимательны к сложностям интеграции с существующими системами управления API.
Поймите для себя, что именно вы собираетесь разрабатывать — только бизнес-логику обработки запросов или, как могло быть в нашем случае, прокси целиком. Не забывайте, что всё, что вы сделаете сами, должно быть впоследствии тщательно протестировано. | https://habr.com/ru/post/446438/ | null | ru | null |
# PNG в IE. Ссылки должны работать.
В продолжение [темы о лечении Ослика](http://www.habrahabr.ru/blog/la_france/22751.html).
Столкнулся с проблемой — хотя PNG в фоне слоя заработал, и удалось даже как-то изобразить повторяемость по вертикали, ссылки в div'е не работали в IE.
Небольшой гуглинг на тему вскрыл следующий метод: у div'а, к которому применили фильтр AlphaImageLoader, ***не** должно быть указано* CSS-свойство `position` вообще, а у ссылок оно же должно быть установлено в любое значение (зная IE, лучше в `relative`). И все!
Моя ситуация оказалась чуть сложнее — div с меню был завернут еще в два, и у каждого тоже на фоне PNG (проклятые закругленные уголки). Требование неустановки свойства `position` распространяется и на них! Отказаться от него в одном случае удалось только ценой переписывания HTML-кода, но всё равно заработало! | https://habr.com/ru/post/14471/ | null | ru | null |
# Стиль WS_EX_LAYERED для дочерних окон в Windows 8
В **Windows** Вы не можете просто так сделать полупрозрачный элемент управления, Вы должны либо рисовать все контролы сами(Qt, FMX) либо использовать [DrawThemeParentBackground](http://msdn.microsoft.com/en-us/library/windows/desktop/bb773289(v=vs.85).aspx), что неминуемо приводит к тормозам.
Регионы тут не помогут т.к. они не поддерживают частичную прозрачность.
Было бы удобно использовать окна со стилем **WS\_EX\_LAYERED** («Слоистые» окна поддерживающие альфа прозрачность отдельных пикселей), однако **Windows** поддерживает этот стиль только для окон верхнего уровня. Так было до **Windows 8** в которой~~, не прошло и полвека,~~ наконец-то стало возможно назначать этот стиль дочерним окнам.
Что это дает? Первое что приходит в голову, это то, что композицией окон будет заниматься видео карта, что даст прирост производительности.
Под катом небольшое исследование этой возможности **Windows 8**.
Все примеры кода будут представлены на **Delphi**, однако подобный подход можно использовать и в других языках.
Попробуем создать такую полупрозрачную кнопку:
Для упрощения мы не будем рисовать ее средствами **GDI+**, а просто будем использовать готовый 32-х битный BitMap.
Создадим новое **Vcl** приложение, добавим на форму **TImage** и загрузим туда наш 32-х битный BitMap.
Также добавим на форму кнопку, при нажатии которой мы будем создавать 100 «кнопок».
Наш **Layered** компонент мы сделаем наследником от **TButton**, в котором мы добавим конструктор, принимающий 32-х битный BitMap, с изображением нашей кнопки, и переопределим процедуру **CreateWnd** отвечающую за создание окна:
```
TWin8Control = class(TButton)
private
WinBitMap: TBitMap;
public
procedure CreateWnd; override;
constructor Create(AOWner: TComponent; BitMap: TBitMap);
end;
// ...
constructor TWin8Control.Create(AOWner: TComponent; BitMap: TBitMap);
begin
inherited Create(AOwner);
WinBitMap := BitMap;
end;
procedure TWin8Control.CreateWnd;
var
bf: TBlendFunction;
BitmapSize: TSize;
BitmapPos:Tpoint;
begin
inherited;
if Assigned(WinBitMap) then
begin
// убедимся в том что у нас Premultiplied битмап
WinBitMap.AlphaFormat := afPremultiplied;
bf.BlendOp := AC_SRC_OVER;
bf.BlendFlags := 1;
bf.AlphaFormat := AC_SRC_ALPHA;
bf.SourceConstantAlpha := 255;
// получаем размеры BitMap
BitmapSize.cx := WinBitMap.Width;
BitmapSize.cy := WinBitMap.Height;
BitmapPos.X := 0;
BitmapPos.Y := 0;
// добавляем "слоистый" стиль окна
SetWindowLong(Handle, GWL_EXSTYLE, GetWindowLong(Handle, GWL_EXSTYLE) or WS_EX_LAYERED);
UpdateLayeredWindow(
Handle,
0,
nil,
@BitmapSize,
WinBitMap.Canvas.Handle,
@BitmapPos,
0,
@bf,
ULW_ALPHA
);
end;
end;
```
Давайте теперь в обработчике нашей кнопки сделаем создание 100 дочерних **Layered** окон:
```
procedure TfrmMain.btnAdd100Click(Sender: TObject);
var
i: Integer;
Win8Control: TWin8Control;
begin
for i := 0 to 99 do
begin
Win8Control := TWin8Control.Create(Self, Image.Picture.Bitmap);
Win8Control.Parent := Self;
Win8Control.Top := Random(400);
Win8Control.Left := Random(400);
end;
end;
```
Запустим приложение и нажмем на кнопку:
… И заметим, что к дочерним окнам почему-то не применился стиль **WS\_EX\_LAYERED**.
Как оказалось все дело в том, что эта фича не работает пока не указать в манифесте приложения поддержку Windows 8 (о чем не указано в явном виде на **msdn**):
```
```
Добавляем эти строчки в манифест, подключаем его к проекту, снова запускаем и жмем на кнопку:
Ура, работает!
Однако не все так радужно…
Первое что бросается в глаза это то, что создаются такие окна очень медлительно, раз в 10 медленней обычных.
Второе, это то, что стало тормозить даже элементарное перетаскивание окна, не говоря уже о ресайзе, при котором можно наблюдать замечательные артефакты (извиняюсь за фото с экрана, но из-за специфичной работы **Windows** с такими окнами, на скриншотах артефактов не видно):
Это надо видеть, не поленитесь и поиграйтесь с примером.
Если несколько раз жать на кнопку, то подвиснет не только приложение, но и… вся система, что не происходит при создании обычных окон.
Это приводит к выводу что, **к сожалению, такая прекрасная возможность была реализована не качественно, и использование ее в реальных приложениях не возможно**.
И еще один эксперимент, про то, как подвесить всю систему (только сначала сохраните все свои данные).
Добавьте еще одну кнопку на форму и сделайте в обработчике такой бесконечный цикл:
```
procedure TfrmMain.LoopClick(Sender: TObject);
var
Win8Control: TWin8Control;
begin
while True do
begin
Win8Control := TWin8Control.Create(Self, Image.Picture.Bitmap);
Win8Control.Parent := Self;
Win8Control.Top := Random(400);
Win8Control.Left := Random(400);
end;
end;
```
После нажатия на кнопку **Windows** будет занята только созданием **Layered** окон и ничем больше, не будет реагировать даже на **Ctrl+Alt+Del** :)
Проект на GitHub: <https://github.com/errorcalc/LayeredTest> | https://habr.com/ru/post/247397/ | null | ru | null |
# О добавлении репозиториев в Ubuntu 9.10
Начал читать Linux Format 11-2009 (124), дочитал до статьи «Ubuntu: ставим всё подряд», и очень удивился описанному способу добавления репозиториев.
Для установки chromium-browser автор рекомендует
сделать 3 шага:
а) открыть в GUI «Источники ПО» и добавить новый репозиторий:
```
http://ppa.launchpad.net/chromium-daily/ppa/ubuntu
```
б) выполнить в терминале:
`sudo apt-key adv --recv-keys --keyserver
keyserver.ubuntu.com 4E5E17B5`
в) выполнить в терминале:
`sudo apt-get update
sudo apt-get install chromium-browser`
Что мне не понравилось в таком подходе?"
----------------------------------------
1. «Это мы сделаем в GUI, а это мы сделаем консольно.» То ли автор не
умеет добавлять ключи через «Источники ПО» и устанавливать софт
используя synaptic, то ли автор считает, что
```
echo "deb http://ppa.launchpad.net/chromium-daily/ppa/ubuntu jaunty main" >> /etc/apt/sources.list
```
слишком сложно для домохозяйки. Не знаю.
Кроме того, автор говорит, что изменять jaunty на версию посвежее нельзя. Это не так.
2. Надо вручную добавлять ключ.
Хорошо, что в этот раз автор сообщает и ключ, и как его добавить.
Каждому не раз встречались вопросы на форумах: «как добавить ключ?» и
многие не раз находили или даже использовали костыли типа:
`#!/bin/sh
KEYS=`sudo apt-get update | awk '/NO_PUBKEY/ {print($NF)}'`
if [ -z $KEYS ]
then
echo "No missed public keys found."
else
echo "Missed public keys: $KEYS"
for KEY in $KEYS
do
gpg --keyserver keyserver.ubuntu.com --recv $KEY &&\
gpg --export --armor $KEY | sudo apt-key add -- &&\
echo "Public key $KEY has been added."
done
fi`
(ещё куча примеров как костылей, так и мучений [тут](http://kubuntu.ru/node/3996))
Что предлагают разработчики ubuntu в версии 9.10?
-------------------------------------------------
Совместить и автоматизировать добавление репозитория и ключа:
`sudo add-apt-repository ppa:chromium-daily/ppa
Executing: gpg --ignore-time-conflict --no-options --no-default-keyring
--secret-keyring /etc/apt/secring.gpg
--trustdb-name /etc/apt/trustdb.gpg --keyring /etc/apt/trusted.gpg
--keyserver keyserver.ubuntu.com --recv
FBEF0D696DE1C72BA5A835FE5A9BF3BB4E5E17B5
gpg: запрашиваю ключ 4E5E17B5 с hkp сервера keyserver.ubuntu.com
gpg: ключ 4E5E17B5: "Launchpad PPA for chromium-daily" не изменен
gpg: Всего обработано: 1
gpg: неизмененных: 1`
И всё! Система сама добавит репозиторий, найдет его ключ, и импортирует его:
```
$ ls /etc/apt/sources.list.d
"chromium-daily-ppa-karmic.list" "chromium-daily-ppa-karmic.list.save"
```
Вам останется обновить индексы пакетов и поставить chromium. Просто?
Быстро? Удобно? Мне кажется, да.
Спасибо за внимание!
**PS:** для jaunty идеологически правильного способа не
существовало, его добавили недавно.
**PS2:** Я знаю, что aptitude идеологически правильнее чистого apt (для семейства Ubuntu). Здесь используется apt только потому, что автор LF выбрал этот путь. Если будет 5-10 желающих, я наглядно и с картинками распишу, чем aptitude
лучше apt.
**PS3:** Статью написал мой коллега, который очень хочет инвайт. Решите поделиться — alakond@gmail.com, милости просим. | https://habr.com/ru/post/74429/ | null | ru | null |
# Flutter: локализация приложений средствами Android Studio
Про локализацию (интернационализацию) приложений Flutter написано уже достаточно много.
Официальная документация довольно [подробно останавливается на этом вопросе](https://flutter.dev/docs/development/accessibility-and-localization/internationalization), кроме этого ряд энтузиастов описывает [самые](https://medium.com/@datvt9312/flutter-internationalization-tutorials-d8f0f711e7f) [различные](https://medium.com/@datvt9312/flutter-internationalization-tutorials-part-2-intl-package-approach-and-as-plugin-approach-b0aabdb254d8) [подходы](https://proandroiddev.com/flutter-localization-step-by-step-30f95d06018d).
Эта статья не претендует на полноту охвата вопроса, а является описанием практики, на мой взгляд, очень эффективно уменьшающей ручной ввод.
Речь идет о локализации при помощи [flutter\_i18n](https://plugins.jetbrains.com/plugin/10128-flutter-i18n) — плагина Android Studio, используя который удается избавиться от рутинной работы и шаблонного кода.
Подготовка
----------
Сперва установите плагин **flutter-i18n**
После перезагрузки в структуру проекта автоматически добавятся файлы **generated/i18n.dart** и **res/values/strings\_en.arb**
(файл **strings\_ru.arb** добавлен мною вручную для русского языка)
***Обратите внимание**, что Android Studio 3.3.1 — 3.4 содержит какой-то косяк, из-за которого файлы локализации не генерятся. Я описывал эту проблему на stackoverflow, и [получил решение](https://stackoverflow.com/questions/54861411/android-studio-plugin-flutter-i18n-does-not-work/54869462?noredirect=1#comment97467379_54869462). Еще одним решением является временно остаться на AS 3.2, но это на любителя.*
Еще потребуется установить пакет [flutter\_localizations](https://docs.flutter.io/flutter/flutter_localizations/flutter_localizations-library.html) для локализации внутренних виджетов Flutter (это будет делаться за вас на системном уровне).
```
dev_dependencies:
flutter_localizations:
sdk: flutter
```
После этого вам достаточно будет внести в конструктор параметры локализации:
```
return MaterialApp(
localizationsDelegates: [
S.delegate,
GlobalMaterialLocalizations.delegate,
GlobalWidgetsLocalizations.delegate,
DefaultCupertinoLocalizations.delegate,
],
supportedLocales: S.delegate.supportedLocales,
```
и не забыть импортировать пакет
```
import 'package:f_latte/generated/i18n.dart';
```
Локализация
-----------
Просто начинайте добавлять необходимые строки, соблюдая нотацию JSON, вот так:
**strings\_en.arb:**
```
{
"title": "F-Latte",
"greeting": "Hi, $name!",
"pushingZero": "You pressed NONE (",
"pushingOne": "You pressed once",
"pushingTwo": "You pressed twice",
"pushingOther": "You pressed $cnt times",
}
```
*Кстати, плагин реализует логику работы с **plurals** (множественными числами), для этого следует определенным образом называть ключи в arb-файлах. Как это работает вам станет понятно из кода примера.*
Для добавления языков просто добавьте необходимые файлы в этот же пакет, и внесите туда локализованные строки с теми же самыми ключами, вот так:
**strings\_ru.arb:**
```
{
"title": "F-Латте",
"greeting": "Привет, ${name}!",
"pushingZero": "Ничего не нажималось",
"pushingOne": "Нажато разок",
"pushingTwo": "Нажато дважды",
"pushingOther": "Нажато $cnt раз(а)"
}
```
При любых изменениях в этих файлах плагин будет перестраивать файл **i18n.dart**. Кстати, рекомендую его хотя бы просмотреть, многое станет понятнее.
Вот и все. В любом месте, где требуется доступ к локализованным строкам следует просто вызывать статический метод локализатора:
```
/// так
title: Text(S.of(context).title),
...
/// или так
Text(S.of(context).greeting('User'), ),
...
/// или вот так
Text(
S.of(context).pushing(_counter),
style: Theme.of(context).textTheme.display1,
,
```
Вот как это выглядит
Код с примером находится [здесь](https://github.com/ValeriusGC/f_latte/tree/iter_0001_localiz) (ветка `iter_0001_localiz`).
---
[Источник иллюстрации.](https://appinventiv.com/blog/how-to-localize-your-app-to-increase-its-conversion-rate-by-200)
---
**PS**
По информации [awaik](https://habr.com/ru/users/awaik/)
> под iOS не заработает локализация. Чтобы она заработала надо в Xcode добавить языки в разделе инфо. Иначе не определяет ничего и ошибок не выдает.
[здесь](https://habr.com/ru/post/451556/#comment_20476751) | https://habr.com/ru/post/451556/ | null | ru | null |
# В ядро Linux 5.6 включили VPN WireGuard
Сегодня Линус перенёс к себе ветку net-next с VPN-интерфейсами [WireGuard](https://www.wireguard.com/). Об этом событии [сообщили](https://lists.zx2c4.com/pipermail/wireguard/2020-January/004906.html) в списке рассылки WireGuard.
В данный момент продолжается сбор кода для нового ядра Linux 5.6. WireGuard — быстрый VPN нового поколения, в котором реализована современная криптография. Он изначально разрабатывался как более простая и удобная альтернатива существующим VPN. Автор — канадский специалист по информационной безопасности Джейсон Доненфилд (Jason A. Donenfeld). В августе 2018 года WireGuard [удостоился похвалы](https://lists.openwall.net/netdev/2018/08/02/124) от Линуса Торвальдса. Примерно в то время началась работа по включению VPN в ядро Linux. Процесс немного затянулся.
«Вижу, что Джейсон сделал пул-реквест для включения WireGuard в ядро, — писал Линус 2 августа 2018 года. — Могу я просто ещё раз заявить о своей любви к этому VPN и надеяться на скорое слияние? Может, код и не идеален, но я просмотрел его, и по сравнению с ужасами OpenVPN и IPSec, это настоящее произведение искусства».
Несмотря на пожелание Линуса, слияние затянулось на полтора года. Основная проблема оказалась в привязке к собственным реализациям криптографических функций, которые применялись для повышения производительности. После длительных переговоров в сентябре 2019 года было [принято компромиссное решение](https://lists.zx2c4.com/pipermail/wireguard/2019-September/004560.html) перевести патчи на имеющиеся в ядре функции Crypto API, к которым у разработчиков WireGuard есть претензии в области производительности и общей безопасности. Но решили нативные криптофункции WireGuard выделить в отдельный низкоуровневые Zinc API и со временем портировать их в ядро. В ноябре разработчики ядра сдержали обещание и [согласились](https://lists.zx2c4.com/pipermail/wireguard/2019-November/004614.html) перенести в основное ядро часть кода из Zinc. Например, в Crypto API [включены](https://lore.kernel.org/linux-crypto/CAHmME9rxGp439vNYECm85bgibkVyrN7Qc+5v3r8QBmBXPZM=Dg@mail.gmail.com/) подготовленные в WireGuard быстрые реализации алгоритмов ChaCha20 и Poly1305.
В конце концов, 9 декабря 2019 года Дэвид Миллер (David S. Miller), отвечающий за сетевую подсистему ядра Linux, [принял](https://lists.zx2c4.com/pipermail/wireguard/2019-December/004704.html) в состав ветки net-next [патчи](https://lkml.org/lkml/2019/12/8/240) с реализацией VPN-интерфейса от проекта WireGuard.
А сегодня 29 января 2020 года изменения ушли к Линусу для включения в ядро.
Заявленные преимущества WireGuard над другими VPN решениями:
* Простой в использовании.
* Использует современную криптографию: Noise protocol framework, Curve25519, ChaCha20, Poly1305, BLAKE2, SipHash24, HKDF и т.д.
* Компактный читаемый код, проще исследовать на уязвимости.
* Высокая производительность.
* Чёткая и проработанная [спецификация](https://www.wireguard.com/papers/wireguard.pdf).
Вся основная логика WireGuard занимает менее 4000 строк кода, тогда как OpenVPN и IPSec это сотни тысяч строк.
> «В WireGuard применяется концепция маршрутизации по ключам шифрования, которая подразумевает привязку к каждому сетевому интерфейсу закрытого ключа и применение для связывания открытых ключей. Обмен открытыми ключами для установки соединения производится по аналогии с SSH. Для согласования ключей и соединения без запуска отдельного демона в пространстве пользователя применяется механизм Noise\_IK из [Noise Protocol Framework](http://noiseprotocol.org/), похожий на поддержание authorized\_keys в SSH. Передача данных осуществляется через инкапсуляцию в пакеты UDP. Поддерживается смена IP-адреса VPN-сервера (роуминг) без разрыва соединения с автоматической перенастройкой клиента, — [пишет](https://www.opennet.ru/opennews/art.shtml?num=51997) Opennet.
>
>
>
> Для шифрования [используется](https://www.wireguard.io/protocol/) потоковый шифр [ChaCha20](http://cr.yp.to/chacha.html) и алгоритм аутентификации сообщений (MAC) [Poly1305](http://cr.yp.to/mac.html), разработанные Дэниелом Бернштейном ([Daniel J. Bernstein](http://cr.yp.to/djb.html)), Таней Ланге (Tanja Lange) и Питером Швабе (Peter Schwabe). ChaCha20 и Poly1305 позиционируются как более быстрые и безопасные аналоги AES-256-CTR и HMAC, программная реализация которых позволяет добиться фиксированного времени выполнения без задействования специальной аппаратной поддержки. Для генерации совместного секретного ключа применяется протокол Диффи-Хеллмана на эллиптических кривых в реализации [Curve25519](http://cr.yp.to/ecdh.html), также предложенной Дэниелом Бернштейном. Для хеширования используются алгоритм [BLAKE2s (RFC7693)](https://www.opennet.ru/opennews/art.shtml?num=35676)».
Результаты [тестов производительности](https://www.wireguard.com/performance/) с официального сайта:
**Пропускная способность (мегабит/с)**
**Пинг (мс)**
#### Тестовая конфигурация:
* Intel Core i7-3820QM и Intel Core i7-5200U
* Гигабитные карты Intel 82579LM и Intel I218LM
* Linux 4.6.1
* Конфигурация WireGuard: 256-битный ChaCha20 с Poly1305 для MAC
* Первая конфигурация IPsec: 256-битный ChaCha20 с Poly1305 для MAC
* Вторая конфигурация IPsec: AES-256-GCM-128 (с AES-NI)
* Конфигурация OpenVPN: эквивалентный шифронабор 256-битного AES с HMAC-SHA2-256, режим UDP
* Производительность замерялась с помощью `iperf3`, показан средний результат за 30 минут.
Теоретически, после интеграции в сетевой стек WireGuard должен работать ещё быстрее. Но в реальности это не обязательно будет так из-за перехода на встроенные в ядро криптографические функции Crypto API. Возможно, не все из них ещё оптимизированы до уровня быстродействия нативного WireGuard.
> «С моей точки зрения, WireGuard вообще идеален для пользователя. Все низкоуровневые решения приняты в спецификации, поэтому процесс подготовки типичной VPN инфраструктуры занимает всего несколько минут. Напутать в конфигурации практически невозможно, — [писали](https://habr.com/ru/post/432686/) на Хабре в 2018 году. — Процесс установки [детально описан](https://www.wireguard.com/install/) на официальном сайте, отдельно хочется отметить отличную [поддержку OpenWRT](https://openwrt.org/docs/guide-user/network/tunneling_interface_protocols#protocol_wireguard_wireguard_vpn). Такой простоты использования и компактности кодовой базы удалось достичь за счёт отказа от дистрибьюции ключей. Здесь нет сложной системы сертификатов и всего этого корпоративного ужаса, короткие ключи шифрования распространяются примерно как SSH-ключи».
Проект WireGuard развивается с 2015 года, он прошёл аудит и [формальную верификацию](https://www.wireguard.com/formal-verification/). Поддержка WireGuard интегрирована в NetworkManager и systemd, а патчи для ядра входят в базовый состав дистрибутивов Debian Unstable, Mageia, Alpine, Arch, Gentoo, OpenWrt, NixOS, Subgraph и ALT. | https://habr.com/ru/post/486046/ | null | ru | null |
# Создание приложения для Windows Phone 7 от начала до конца. Часть 15. Доступ к фотографиям на Windows Phone
[Предыдущая часть](http://habrahabr.ru/blogs/windows_mobile/)
Вы можете использовать фотографии и другие изображения в виде ресурсов приложения для их отображения в пользовательском интерфейсе. Ваше приложение может обратиться к фотографиям в медиа-библиотеке телефона или позволить пользователям делать снимки с помощью встроенной камеры.
В этой части вы узнаете:
* Как получить доступ к фотографиям на Windows Phone.
#### Доступ к фотографиям на Windows Phone
Для того, чтобы получить доступ к изображениям из медиа-библиотеки и снимкам с камеры, используйте PhotoChooserTask и CameraCaptureTask. Эти классы известны как *choosers* (choose — выбирать), потому что они открывают отдельное окно, в котором пользователь и осуществляет выбор, который затем возвращается вашему приложению. Также существуют *launchers* (launch — запускать), которые открывают отдельное окно, но при этом не возвращают выбор пользователя приложению.
PhotoChooserTask и CameraCaptureTask требуют похожий код, так что мы опишем только PhotoChooserTask. Кроме того, будет описано, как сохранить выбранные фотографии в изолированном хранилище. Вы также можете получать и сохранять изображения в медиа-библиотеку через класса XNA MediaLibrary. Однако, этот класс не будет рассматриваться.
Чтобы использовать chooser, вам необходимо создать его экземпляр. На следующем изображении показан пример PhotoChooserTask.
После того, как пользователь осуществил выбор, вы должны обработать событие Completed, чтобы выполнить соответствующие действия. Следующий фрагмент кода (из CarDetailsPage.xaml.cs) демонстрирует, как создать PhotoChooserTask и обработать его событие Completed. Обратите внимание, что PhotoChooserTask должен являться глобальной переменной для страницы, а событие Completed должно быть подключено в конструкторе.
> `1. private readonly PhotoChooserTask photoTask = new PhotoChooserTask();
> 2.
> 3. public CarDetailsPage()
> 4. {
> 5. InitializeComponent();
> 6. photoTask.Completed += PhotoTask\_Completed;
> 7.
> 8. // ... other code ...
> 9. }
> 10.
> 11. private void PhotoButton\_Click(object sender, RoutedEventArgs e)
> 12. {
> 13. photoTask.Show();
> 14. }
> 15.
> 16. private void PhotoTask\_Completed(object sender, PhotoResult e)
> 17. {
> 18. if (e.TaskResult == TaskResult.OK)
> 19. {
> 20. var image = new System.Windows.Media.Imaging.BitmapImage();
> 21. image.SetSource(e.ChosenPhoto);
> 22. CarDataStore.SaveTempCarPhoto(image, delegate
> 23. {
> 24. MessageBox.Show("There is not enough space on " +
> 25. "your phone to save your selection. Free some " +
> 26. "space and try again.", "Warning", MessageBoxButton.OK);
> 27. });
> 28. car.Picture = image;
> 29. hasUnsavedChanges = true;
> 30. }
> 31. }
> \* This source code was highlighted with Source Code Highlighter.`
После того, как пользователь нажимает кнопку «Photo», отображается PhotoChooserTask. Это вызывает дезактивацию приложения. После того, как пользователь выбрал фото, приложение повторно активируется, хотя в данном случае, событие PhotoChooserTask.Completed происходит до того, как метод OnNavigatedTo вызывается для обработки повторной активации.
Обработчик события Completed создает новый BitmapImage и устанавливает в качестве его источника (source) выбранную фотографию. Далее, обработчик события помещает изображение в изолированное хранилище. Изображения не сериализуемы, поэтому они не могут быть сохранены в хранящиеся в памяти словари состояний, ни в словари состояний изолированного хранилища. Поэтому, если вы хотите сохранить изображение, вы должны сохранить его с помощью виртуального интерфейса файловой системы изолированного хранилища (isolated storage virtual file system interface). Класс **CarDataStore** должен также поместить фото в изолированное хранилище после того, как пользователь нажмёт кнопку «Save». Таким образом методы **SaveTempCarPhoto** и **GetTempCarPhoto** для того, чтобы обработать временное фото, просто оборачивают (wrap) методы **SaveCarPhoto** и **GetCarPhoto**, используемые для обработки сохраненной фотографии. Описание методов **SaveCarPhoto** и **GetCarPhoto** приводилось в части «Изолированное хранилище: сохранение и загрузка данных».
И в конце обработчик события назначает изображение свойству **Picture** объекта **Car**, хранящегося в поле **car**. После этого фото появится в элементе управления Image, связанном со свойством **Picture**.
**Примечание:**
Класс PhotoResult, переданный обработчику события Completed, содержит свойство OriginalFileName. Это свойство было бы удобно использовать для получения выбранной фотографии из XNA MediaLibrary так, чтобы вы не должны были сохранять его отдельно в изолированном хранилище. Однако, на момент написания статьи реализация OriginalFileName ведёт себя не так, как ожидалось: оно возвращает временное имя файла, что не является полезным для получения фото из класса XNA MediaLibrary позже. Однако, даже если вы могли бы использовать медиа-библиотеку таким образом, вы, скорее всего, по-прежнему предпочли бы хранить выбранные пользователем изображения в изолированном хранилище. В таком случае они останутся доступными для вашего приложения, даже если пользователь удалит позже изображения из медиа-библиотеки или изменит их содержание с помощью других приложений. | https://habr.com/ru/post/118462/ | null | ru | null |
# Безопасно подписываем Android сборки из Jenkins
Перевод <https://www.detroitlabs.com/blog/2017/05/24/securely-signing-jenkins-android-builds/>
Безопасная подпись Android сборок в Jenkins CI (Continuous Integration, далее просто CI) это общая проблема. Мы попробовали несколько вариантов за всё время разработки и каждый из них выглядел немного грязновато… кроме одного.
Сначала, небольшое вступление: CI это очень значимый инструмент для команды разработки. Когда он используется правильно и часто, он может значительно уменьшить время тратящееся на отладку и разрешение конфликтов. Проблемы видны всей команде и могут быть быстро решены, результаты сборки помогают определить корень проблемы, а тестирование помогает предотвратить появление регрессионных ошибок. CI также автоматизирует доставку ваших сборок, так что тестировщики или клиенты мгновенно получают последние результаты работы.
Итак, наши варианты:
### Включить подписывающий сертификат для сборки, непосредственно в сам репозиторий: Плохо!
Только если вы не используете закрытый репозиторий, вы на самом деле открываете свой сертификат всему миру. Даже если вы используете закрытый репозиторий, вы размещаете сертификат на машине каждого разработчика, что сильно увеличивает шансы что сертификат утечёт.
### Загрузить подписывающий сертификат в файловую систему Jenkins и ссылаться на него из Gradle: Неплохо...
Это неплохо потому что это позволяет нам использовать минимальное количество мест и может быть защищено теми же средствами, что регулируют доступ к Jenkins. Один нюанс, это то что вы всё ещё должны будете сохранять свой пароль и имя ключа где-то в файловой системе. Поиск способа сделать это безопасно может быть сложным. Данное решение также может оказаться не самым простым в использовании, если у вас есть несколько проектов и несколько сборок и каждой из них нужен сертификат.
### Использование плагина для подписи Android приложений(Android Signing Plugin): Отлично!
Это замечательное, чистое решение для хранения и подписи приложений на вашем Jenkins. Плагин использует стандартное хранилище Jenkins для работы с вашими сертификатами. Что ограничивает число разработчиков которым нужно знать пароли, помогает безопасно хранить сертификаты, и позволяет всем сборкам легко получать доступ к сертификату.
### Как настроить и использовать Jenkins Android Signing Plugin:
Первое, что вам нужно это убедиться что в вашем Jenkins установлен [Credentials Plugin](https://wiki.jenkins-ci.org/display/JENKINS/Credentials+Plugin).
Это легко можно проверить взглянув на левую панель в вашем Jenkins. Если вы видите "Credentials" секцию, как показано ниже, то он установлен.
Если у вас нет секции "Credentials", вам нужно не забыть установить Credentials Plugin, это можно сделать одновременно с установкой Android Signing Plugin.
Установка плагина происходит в несколько не сложных шагов:
1. Выбирете “Manage Jenkins” секцию как показано ниже.
2. Выберете "Manage Plugins."
3. Вы должны будете увидеть доступные обновления для текущих плагинов. В верху экрана выберете вкладку "Available".
4. Теперь вы можете использовать поиск в правом верхнем углу для того, чтобы найти "Credentials Plugin" (Если он не установлен) и "Android Signing Plugin". Поставьте галочки на левой стороне для каждого плагина, затем нажмите "Download now and install after restart" внизу экрана.
Отлично!
Теперь, когда всё установлено, вы можете добавить как минимум один сертификат для подписи приложений. Детальные инструкции по использованию "Credentials Plugin" не являются темой этой статьи, но могут быть легко найдены в [интернете](https://wiki.jenkins-ci.org/display/JENKINS/Credentials+Plugin). Вам нужно добавить один новый сертификат, как показано ниже.
Как видно, плагин поддерживает только PKCS12 сертификаты. К сожалению, последняя версия Android Studio выдаёт JKS сертификаты, которые оказываются несовместимы с плагином.
Хорошо, что мы имеем удобную утилиту для командной строки "keytool", которая может превратить наш "JKS" в "PKCS12".
```
keytool -importkeystore -srckeystore {REPLACE_WITH_JKS_FILE} -srcstoretype JKS -deststoretype PKCS12 -destkeystore ConvertedCertificate.p12
```
Как только у вас будет "PKCS12" файл, вы можете загрузить его. Убедитесь, что ввели пароль, до того как загрузили сертификат, иначе Jenkins не сможет загрузить файл. Теперь вы готовы использовать этот сертификат для любых Android сборок.
Единственно требование к исходному коду, это то что вам нужно оставить "[signingConfig](https://developer.android.com/studio/publish/app-signing.html#gradle-sign)" пустым для "buildType", который будет использоваться при сборке Jenkins'ом. Тогда будет создаваться неподписанный APK, который может быть подписан плагином. Имейте в виду, стандартный debug билд подписывается автоматически сгенерированным сертификатом.
Теперь всё готово для подписи приложений, вам нужно добавить шаг "Sign Android APKs" в вашу сборку. Ниже простой пример, сначала мы запускаем Gradle команду для сборки неподписанного релизного билда. После этого, на следующем шаге мы можем подписать билд. Вы должны выбрать сертификат, который вы хотели бы использовать из хранилища сертификатов, указать алиас ключа и путь к неподписанному APK.
Это всё! У вас теперь есть подписанный билд, готовый к распространению сразу же после сборки.
К слову у Google есть своё [хранилище сертификатов](https://developer.android.com/studio/publish/app-signing.html#google-play-app-signing), которое частично решает проблему с безопасным хранением ключа. | https://habr.com/ru/post/345910/ | null | ru | null |
# Гиперпространство на JavaScript
Хабровчане! С днем космонавтики!
В одном проекте, приуроченном к сегодняшнему празднику дизайнерами была поставлена задача создать имитацию гиперпространства. Немного поразмыслив решил что правильнее будет использовать Canvas элемент — для SVG достаточно много элементов, да и поддержка среди браузеров не такая хорошая, для видео слишком большой фон, а значит слишком большой размер файла и долгая загрузка. Canvas, к слову, тоже не идеальный вариант — он сильно нагружает процессор и забирает относительно много оперативной памяти. Но все же…
**Запись на полях**В коде будет использовать функция reqestAnimFrame нормализующая работу requestAnimationFrame в разных браузерах, а та же простая функция генерации случайно целого числа. Вот их исходный код:
```
window.requestAnimFrame = (function(){
return window.requestAnimationFrame ||
window.webkitRequestAnimationFrame ||
window.mozRequestAnimationFrame ||
window.oRequestAnimationFrame ||
window.msRequestAnimationFrame ||
function(/* function */ callback, /* DOMElement */ element){
window.setTimeout(callback, 1000 / 60);
};
})();
function getRandomInt(min, max){
return Math.floor( Math.random() * (max - min + 1) ) + min;
}
```
##### Подход 1. Наложение масштабированной картинки.
В дизайне была картинка звездного неба, которую я и решил использовать. Взял, загрузил, наложил на Canvas. Потом наложил с увеличением еще на один пиксель. Потом еще. Картинка получается красивая, но как-либо настраивать её не получится.
Полный код и демонстрация на [jsfiddle](http://jsfiddle.net/agegorin/rK8Bx/).
В коде комментировать нечего, поэтому просто код.
Этот подход не имеет жизни по нескольким причинам:
* Исходная картинка всегда одного размера, а значит поддерживать разные разрешения затруднительно.
* Мало возможностей для кастомизации результирующей картины.
* Стирать через некоторое время уже пройденный путь достаточно затруднительно.
* Качество при большом увеличении слишком низкое.
* Это неинтересное решение.
##### Подход 2. Боевой.
Было решено рисовать каждую звезду и шлейф от нее отдельно.
Полный код и демонстрация на [jsfiddle](http://jsfiddle.net/agegorin/sdMPZ/). Движение повешено на mousemove событие.
Итак, создаем массив звезд, генерируем для них начальные значения. Здесь x и y, понятное дело, координаты звезды, currentLife — показатель текущей длина шлейфа от звезды, nx, ny и life используются для реинициализации звезды, после остановки. color — один из вариантов в массиве colors. В принципе можно было сделать вообще любой цвет, но особенность в ограничении количества доступных цветов нам пригодится позже. Массива два, так в момент затухания необходимо показывать двигающиеся и неподвижные звезды одновременно. Конечно это можно (и, наверное, даже нужно) сделать через один массив с отдельным свойством у звезды, но от этого зависит дальнейшая логика и поэтому мне лень все переписывать.
```
var colors = ["white","rgb(200,200,255)"];
function newStar(){
var life = getRandomInt(50,150);
var dx = getRandomInt(0,canvas.width);
var dy = getRandomInt(0,canvas.height);
return {
x : dx,
y : dy,
nx : dx,
ny : dy,
life : life,
currentLife : life,
color : colors[getRandomInt(0,1)]
};
}
var stars = [];
var finStars = [];
var maxStars = 350;
for(var i = 0; i < maxStars; i++){
finStars.push(newStar());
}
```
Теперь поговорим про отображение звезды. Здесь у нас включается простая математика:
Думаю не надо объяснять что dx относится к dy так же, как и ax к ay. Если взять dx равным значению currentLife, то dy = currentLife \* ( y — cy ) / ( x — cx ). Кроме этого у каждой звезды есть два состояния — когда шлейф растет и когда убывает. Реализовать это достаточно просто через 4 значения: 2 постоянных и 2 переменных. Рисуем от (var1 > const1? var1: const1) до (var2 < const2? var2: const2). Получаем сначала растущую, а потом затухающую звезду.
Остается все это посчитать:
```
var x = stars[j].x, // (x,y) - это const1
y = stars[j].y,
dx = cx - stars[j].x,
dy = cy - stars[j].y;
if ( Math.abs(dx) > Math.abs(dy) ){
var xLife = dx > 0 ? stars[j].life : - stars[j].life, // (xLife, yLife) - const2. Вообще star.life это вся продолжительность "жизни" звезды
yLife = xLife * dy / dx,
xCur = dx > 0 ? - stars[j].currentLife : stars[j].currentLife, // (xCur,yCur) -var1
yCur = xCur * dy / dx,
xLast = dx > 0 ? xCur + stars[j].life : xCur - stars[j].life, // (xLast,yLast) - var2
yLast = xLast * dy / dx,
mod = "x";
} else {
var yLife = dy > 0 ? stars[j].life : - stars[j].life,
xLife = yLife * dx / dy,
yCur = dy > 0 ? - stars[j].currentLife : stars[j].currentLife,
xCur = yCur * dx / dy,
yLast = dy > 0 ? yCur + stars[j].life : yCur - stars[j].life,
xLast = yLast * dx / dy,
mod = "y";
}
if(dx > 0 && dy > 0)
{
var qx = x - ( xLife < xLast ? xLife : xLast);
var qy = y - ( yLife < yLast ? yLife : yLast);
ctx.moveTo( qx < cx ? qx : cx, qy < cy ? qy : cy);
var sx = x - ( xCur > 0 ? xCur : 0);
var sy = y - ( yCur > 0 ? yCur : 0);
ctx.lineTo( sx < cx ? sx : cx, sy < cy ? sy : cy);
if ( mod == "x"){
ctx.lineTo( qx < cx ? qx : cx, (qy < cy ? qy : cy) + 2);
} else {
ctx.lineTo( (qx < cx ? qx : cx) + 2, qy < cy ? qy : cy);
}
ctx.lineTo( qx < cx ? qx : cx, qy < cy ? qy : cy);
ctx.closePath();
stars[j].nx = sx < cx ? sx : cx;
stars[j].ny = sy < cy ? sy : cy;
}
if(dx < 0 && dy < 0)
{
var qx = x - ( xLife > xLast ? xLife : xLast);
var qy = y - ( yLife > yLast ? yLife : yLast);
ctx.moveTo( qx > cx ? qx : cx, qy > cy ? qy : cy);
var sx = x - ( xCur < 0 ? xCur : 0);
var sy = y - ( yCur < 0 ? yCur : 0);
ctx.lineTo( sx > cx ? sx : cx, sy > cy ? sy : cy);
if ( mod == "x" ){
ctx.lineTo( qx > cx ? qx : cx, (qy > cy ? qy : cy) + 2);
} else {
ctx.lineTo( (qx > cx ? qx : cx) + 2, qy > cy ? qy : cy);
}
ctx.lineTo( qx > cx ? qx : cx, qy > cy ? qy : cy);
ctx.closePath();
stars[j].nx = sx > cx ? sx : cx;
stars[j].ny = sy > cy ? sy : cy;
}
if(dx < 0 && dy > 0)
{
var qx = x - ( xLife > xLast ? xLife : xLast);
var qy = y - ( yLife < yLast ? yLife : yLast);
ctx.moveTo( qx > cx ? qx : cx, qy < cy ? qy : cy);
var sx = x - ( xCur < 0 ? xCur : 0);
var sy = y - ( yCur > 0 ? yCur : 0);
ctx.lineTo( sx > cx ? sx : cx, sy < cy ? sy : cy);
if ( mod == "x" ){
ctx.lineTo( qx > cx ? qx : cx, (qy < cy ? qy : cy) + 2);
} else {
ctx.lineTo( (qx > cx ? qx : cx) + 2, qy < cy ? qy : cy);
}
ctx.lineTo( qx > cx ? qx : cx, qy < cy ? qy : cy);
ctx.closePath();
stars[j].nx = sx > cx ? sx : cx;
stars[j].ny = sy < cy ? sy : cy;
}
if(dx > 0 && dy < 0)
{
var qx = x - ( xLife < xLast ? xLife : xLast);
var qy = y - ( yLife > yLast ? yLife : yLast);
ctx.moveTo( qx < cx ? qx : cx, qy > cy ? qy : cy);
var sx = x - ( xCur > 0 ? xCur : 0);
var sy = y - ( yCur < 0 ? yCur : 0);
ctx.lineTo( sx < cx ? sx : cx, sy > cy ? sy : cy);
if ( mod == "x" ){
ctx.lineTo( qx < cx ? qx : cx, (qy > cy ? qy : cy) + 2);
} else {
ctx.lineTo( (qx < cx ? qx : cx) + 2, qy > cy ? qy : cy);
}
ctx.lineTo( qx < cx ? qx : cx, qy > cy ? qy : cy);
ctx.closePath();
stars[j].nx = sx < cx ? sx : cx;
stars[j].ny = sy > cy ? sy : cy;
}
```
В зависимости от того, в какую четверть попадает наша звезда, знаки перед значениями и сравнения отличаются, поэтом код практически дублируется 4 раза. Кроме того в переменной mod запоминается в какую координату считать ведущей ( то есть приравнивать dx к currentLife или dy). Без mod-а звезды в близи оси ординат будут «пролетать» слишком быстро, из за большого угла.
И последнее замечание – в оригинале используется всего два цвета, поэтому за один проход отрисовка на Canvas происходит всего два раза (так как указано два цвета). Все звезды одного цвета формируются в один путь, после чего выводятся на Canvas.
Остается все это обернуть в цикл и запустить.
##### Подход 3. Правильный.
Под правильным подходом я понимаю использование распространенных готовых решений и библиотек. Готовых решений при беглом осмотре не нашлось. В качестве библиотеки я решил попробовать libcanvas. Благо на Хабрахабре он представлен достаточно сильно.
Полный код и демонстрация на [jsfiddle](http://jsfiddle.net/agegorin/UM3vR/). (JSFiddle может не подгрузить atom и libcanvas с github-а, так что возможно надо будет несколько раз перезагрузить страницу)
В итоге получилось следующее:
```
new function () {
var center, i, helper, stars;
LibCanvas.extract();
helper = new App.Light(new Size( document.width, document.height));
center = helper.app.rectangle.center;
stars = [];
for(i = 0; i < 350; i++){
new function() {
var point = new Point(getRandomInt(document.width/2,document.width),document.height/2),
length = getRandomInt(50,150),
angle = getRandomInt(0,360),
coords = [
new Point(0,0),
new Point(0,0),
new Point(0,0)
],
path = helper.createVector( new Path()
.moveTo( coords[0] )
.lineTo( coords[1] )
.lineTo( coords[2] )
.lineTo( coords[0] )).setStyle({fill:"rgb(150,150,150)",stroke:"rgb(150,150,150)"});
point.rotate( - angle.degree(), center);
var star = {
point : point,
length : length,
angle : angle,
coords : coords,
live : 0,
setLength : function(){
if (arguments.length > 0){
this.live = arguments[0];
}
this.coords[0].x = this.point.x;
this.coords[0].y = this.point.y;
this.coords[1].x = this.coords[0].x + this.live * Math.cos( this.angle.degree() );
this.coords[1].y = this.coords[0].y - this.live * Math.sin( this.angle.degree() );
this.coords[2].x = this.coords[1].x + 2 * Math.sin( this.angle.degree() );
this.coords[2].y = this.coords[1].y + 2 * Math.cos( this.angle.degree() );
},
path : path
};
star.setLength();
stars.push(star);
};
}
setInterval(function(){
for(var i = 0; i < 350; i++){
stars[i].setLength( stars[i].live + 1 );
stars[i].path.redraw();
}
},10);
};
```
Надо сказать, что здесь, в отличие от боевого варианта, используется адекватная математика с тригонометрией, но я не стал дописывать до того же функционала. Скорость выполнения кода на libCanvas не сильно отличается от нативного метода, а кода в разы меньше и скорость разработки заметно выше. С самого начала я не стал использовать libCanvas по нескольким причинам: я ни разу не пользовался им до этого, я привык к чистому JavaScript и я боялся, что версия надстройка будет заметно медленней. Как оказалось боялся зря.
##### **UPD** Правильная реализация на LibCanvas от [TheShock](http://habrahabr.ru/users/theshock/)
Пример на [jsfiddle](http://jsfiddle.net/UM3vR/24/). [Особенно приятно смотрится в fullScreen](http://fiddle.jshell.net/UM3vR/24/show/).
Создание и настройка звезды выносится в отдельный класс. Для каждой звезды определяется скорость, цвет и время жизни.
```
atom.declare( 'Star', App.Element, {
progress: 0,
opacity: 1,
configure: function () {
var screenRectangle = this.layer.ctx.rectangle;
this.animate = new atom.Animatable(this).animate;
this.from = screenRectangle.getRandomPoint();
this.shape = new Polygon(this.from.clone(), this.from.clone(), this.from.clone());
this.angle = -this.from.angleTo(screenRectangle.center);
this.sin = this.angle.sin();
this.cos = this.angle.cos();
this.progressSpeed = Math.random() + 0.5;
this.color = new atom.Color(128, 128, Number.random(128, 192)).toString();
setTimeout(this.fadeOut.bind(this), Number.random(1000, 8000));
},
fadeOut: function () {
this.animate({
time: 2000,
props: { opacity: 0 },
onComplete: this.destroy
});
},
onUpdate: function () {
var sin = this.sin, cos = this.cos, p = this.shape.points;
this.progress += this.progressSpeed;
p[1].x = p[0].x + this.progress * cos;
p[1].y = p[0].y - this.progress * sin;
p[2].x = p[1].x + 2 * sin;
p[2].y = p[1].y + 2 * cos;
this.redraw();
},
renderTo: function (ctx) {
ctx.save();
if (this.opacity < 1) ctx.set({ globalAlpha: this.opacity });
ctx.fill( this.shape, this.color );
ctx.restore();
}
});
```
Изначально звёзд создаётся меньше, а потом добавляются в каджом кадре:
```
new function () {
var helper = new App.Light(
new Size(document.width || 800, document.height || 800),
{ intersection: 'full', invoke: true }
);
for(i = 0; i < 200; i++) new Star(helper.layer);
atom.frame.add(function () {
new Star(helper.layer);
});
};
```
// **UPD** end
На этом все и еще раз с днем космонавтики!
Ссылки:
Пример с картинкой на [jsfiddle](http://jsfiddle.net/agegorin/rK8Bx/).
«Боевой» пример на [jsfiddle](http://jsfiddle.net/agegorin/sdMPZ/).
[AtomJS](https://github.com/theshock/atomjs) и [libCanvas](https://github.com/theshock/libcanvas/) для третьего примера.
Третий пример на libCanvas на [jsfiddle](http://jsfiddle.net/agegorin/UM3vR/). (может не заработать сразу из-за особенностей работы jsfiddle и github)
[Промо сайт](http://iamastronaut.ru/), для которого и создавался эффект. | https://habr.com/ru/post/176325/ | null | ru | null |
# Как запустить UI-автотесты в любом Chromium-браузере
Привет, Хабр! Меня зовут Кристина Курашова и я отвечаю за качество в [**VK Assistant**](https://tech.mail.ru/product/vk-assistant). Это платформа по созданию диалогового ассистента с использованием NLP-моделей. Его можно интегрировать с любой корпоративной системой (как SAP и CRM, например) и подключить к корпоративному мессенджеру или даже web-приложению с возможностью голосового управления.
Одной из киллер фич нашего продукта является многофункциональная админка для настройки всего-всего-всего. В том числе и для обучения моделей, составления сценариев диалогов, интеграции с корпоративными системами и многого другого.
Некоторое время назад я приступила к автоматизации ее регрессионного тестирования. И вот февраль 2022 принес в нашу команду новые вызовы. Один из них — запуск этих тестов также в Atom Browser и Yandex Browser. Ок, запускаем.
> ***Внимание!*** *Эта статья будет полезна тем, кто, как и я, столкнулся с задачей запуска UI-автотестов в том числе в браузерах на основе Chromium (не только Chrome).* *Пройдя этот путь, решила поделиться с вами. Возможно, кому-то это поможет сэкономить время.*
>
>
Для UI-автотестов мы используем Nightwatch.js без Selenuim-сервера. [Nightwatch.js](https://nightwatchjs.org/) — это фреймворк для автоматизации end-to-end тестирования на Node.js. Один из плюсов этого фреймворка, на мой взгляд, очень подробная документация. Про Selenium-сервер можно почитать [здесь](https://www.selenium.dev/documentation/grid/). Вкратце, он помогает запускать автотесты параллельно с использованием нескольких машин (реальных или виртуальных). Пока для нас скорость выполнения тестов не так важна, мы отложили его в сторону, и вот так выглядит наша текущая схема:
Источник https://nightwatchjs.org/То есть для запуска достаточно установленных на машине [Node.js](https://nodejs.org/en/), Nightwatch.js и драйвера, который будет выполнять команды теста. Под каждый браузер потребуется свой драйвер. Об этом расскажу далее.
Схема с использованием Selenium-сервера будет выглядеть так:
Источник https://nightwatchjs.org/ На месте Nightwatch.js может быть любой другой фреймворк. Независимо от использования Selenium-сервера для запуска понадобится драйвер конкретного браузера.
В этой статье речь идет о запуске именно в **Chromium**-браузерах.
Спойлер*Схема одинаковая. Отличается только драйвер, который будем подкладывать* 🙂 *Но обо всем по порядку.*
Когда составили список интересующих нас браузеров, надо понять, какая версия драйвера понадобится для каждого из них. Версию для Chromium-браузеров посмотреть можно так: chrome://version. Выглядит это следующий образом, например:
В Atom.В Microsoft Edge.А далее самое интересное 🙂 Найти драйвер под каждый браузер — тот еще квест. Но вполне посильный для каждого ~~джедая~~ тестировщика. Слегка упрощу задачу:
* Chrome: <https://chromedriver.chromium.org/>
* Microsoft Edge: <https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/>
* Yandex: <https://github.com/yandex/YandexDriver/releases>
* Atom: (по запросу)
Конечно, есть и другие Chromium-браузеры, делитесь ссылками в комментариях.
Итак, **скачиваем драйвер** под нужную версию, **распаковываем, запоминаем путь до exe-файла** (я положила в /usr/local/bin для удобства). На macOS, возможно, после распаковки еще потребуется сделать файл исполняемым. Для этого в консоли выполним:
```
chmod +x msedgedrive
```
где `msedgedrive` — название исполняемого файла, который мы распаковали ранее. И теперь нужно выдать соответствующие разрешения на запуск. В Windows никаких дополнительных манипуляций не потребовалось.
Далее идем в конфиги фреймворка. Они обычно лежат в корне проекта. Мой называется nightwatch.conf.js. И там нас интересуют **настройки окружения test\_settings**. Здесь задаются настройки окружения, в том числе для каждого браузера. Можно добавлять туда сколько угодно вариантов окружений с учетом ограничений среды (Safari будет бегать только на macOS, Atom — пока только на Windows, и т.д.). Вот так, например, будет выглядеть блок с настройками под Microsoft Edge в Linux-среде (в том числе на macOS):
```
edge: {
desiredCapabilities: {
browserName: 'MicrosoftEdge',
'ms:edgeOptions': {
w3c: true,
// More info on EdgeDriver: https://docs.microsoft.com/en-us/microsoft-edge/webdriver-chromium/capabilities-edge-options
args: [
//'--headless'
]
}
},
webdriver: {
start_process: true,
// Download msedgedriver from https://docs.microsoft.com/en-us/microsoft-edge/webdriver-chromium/
// and set the location below:
server_path: '/usr/local/bin/msedgedriver',
cli_args: [
// --verbose
]
}
}
```
Вот тут самое интересное:
`desiredCapabilities.browserName=chrome` будет актуально для всех Chromium-браузеров.
`webdriver.server_path` — это непосредственно путь до драйвера, исполняемого файла, который мы скачали и распаковали до этого.
> **Важно!** В Linux-системах пусть указываем вплоть до файла, без расширения.
>
>
Для запуска в среде Windows понадобится немного больше извращения. Обратите внимание на путь до драйвера (двойные обратные слеши). И расширение для драйвера в данном случае указываем.
```
atom: {
desiredCapabilities: {
browserName: 'chrome',
'goog:chromeOptions': {
// More info on Chromedriver: https://sites.google.com/a/chromium.org/chromedriver/
//
// w3c:false tells Chromedriver to run using the legacy JSONWire protocol (not required in Chrome 78)
w3c: true,
args: [
//'--no-sandbox',
//'--ignore-certificate-errors',
//'--allow-insecure-localhost',
//'--headless'
]
}
},
webdriver: {
start_process: true,
server_path: 'C:\\Users\\username\\AppData\\Local\\Mail.Ru\\Atom\\Application\\chromedriver_18.0.0.660_x64.exe',
cli_args: [
// --verbose
]
}
},
```
Вот, собственно, и всё. Погнали! В Nightwatch.js команда запуска выглядит так:
```
nightwatch -g login -e atom
```
где `-e atom` — окружение, в котором запускаем, от слова environment (в данном случае Atom Browser). Это название нашего энва из test\_settings, которое мы задали ранее.
И в заключение упомяну ограничения и ошибки, с которыми есть вероятность столкнуться в процессе.
Основное ограничение: по такой схеме не получится запускать тесты параллельно на одной машине (если речь не идет про использование Selenium-сервера). То есть только последовательно можно будет запускать. Это касается лишь Chromium-браузеров, потому что они используют один движок.
Распространенная ошибка, с которой можно столкнуться: автотесты не запускаются, и при этом в консоли пусто — никаких ошибок. Обратите внимание на путь до исполняемого файла и сам файл. Он исполняемый? Путь указан правильно? Прав у системы на запуск драйвера достаточно?
Вторая распространенная проблема, с которой можно столкнуться: версия драйвера не соответствует версии браузера. Ошибка в консоли будет выглядеть так:
Тут надо будет подогнать либо драйвер под браузер, либо браузер под драйвер. Обычно первое проще 🙂
Делитесь вашими успехами и примерами в комментариях. До скорых встреч. | https://habr.com/ru/post/683992/ | null | ru | null |
# Tango Controls RestServer
Все работы произведены на Linux ([**TangoBox 9.3**](https://s2innovation.sharepoint.com/:f:/s/Developers/EovD2IBwhppAp-ZLXtawQ6gB9F6aXPPs2msr2hgPGTO-FQ?e=Ii3tnr) на основе Ubuntu 18.04), который является официальным дистрибутивом проекта.
Содержание
----------
1. [Установка](#install)
1. [Установка из репозитория](#install-repo)
2. [Установка из исходников](#install-src)
2. [Отключение](#off)
1. [Отключение старого RestServer-а](#rest-off)
3. [API](#api)
1. [Документация](#doc)
Установка
---------
Установка из репозитория
------------------------
Получаем последнюю версию docker-а из репозитория и запускаем его.
```
docker pull tangocs/rest-server:rest-server-2.1
docker run --restart unless-stopped -p 8080:8080 -d tangocs/rest-server:rest-server-2.1
```
Смотрим результат выполнения. В список контейнеров добавился **tangocs/rest-server**.
Список запущенных контейнеров пополнил **tangocs/rest-server:rest-server-2.1**.
Проверка работоспособности:
**Важный акцент**, в системе **TangoBox 9.3** изначально работает старый RestServer. Работает он не в docker-е, а в **самой системе**! Их **API** отличается.
Проверка его работы:
Работает на **10001** порту, и поскольку он работает в системе, то обратится может к **Tango Controls** как к **localhost**, чего не сможет docker.
```
http://localhost:10001/tango/rest/rc4/hosts/localhost/10000/devices/sys/tg_test/1/attributes/double_scalar/value
```
В docker-t RestServer работает на **8080** порту, и его порт проброшен в систему. Но обращаться к **Tango Controls** он должен по **ip** адресу системы **172.17.0.1** где тот работает!
```
http://localhost:8080/tango/rest/v10/hosts/172.17.0.1;port=10000/devices/sys/tg_test/1/attributes/double_scalar/value
```
Репозиторий содержит **не последнюю** версию. Установить последнюю версию можно из исходников, на текущий момент **2.2**.
### Установка из исходников
Последняя версия [TangoRestServer](https://github.com/tango-controls/rest-server).
```
git clone https://github.com/tango-controls/rest-server.git
cd rest-server
```
Собирается docker под **java** версии **11**, но все в системе работает под **8**-ой версий.
Временно поменяем версию по умолчанию с 8 на 11.
```
sudo update-alternatives --config java
```
```
mvn package
docker build -t tangocs/rest-server:rest-server-2.2 .
```
Получил следующую ошибку:
`COPY failed: file not found in build context or excluded by .dockerignore: stat target/.war: file does not exist`
Открываем **Dockerfile** и меняем
`COPY target/${REST_SERVER_VERSION}.war /usr/local/tomcat/webapps/tango.war`
на
`COPY target/rest-server-2.2-SNAPSHOT.war /usr/local/tomcat/webapps/tango.war`
Т.к. docker собрался с именем **rest-server-2.2-SNAPSHOT.war**
Смотрим список образов:
Теперь запускаем наш docker, он будет работать на **8080** порту.
```
docker run --restart unless-stopped -p 8080:8080 -d tangocs/rest-server:rest-server-2.2
```
Процедура проверки работоспособности такая же как и в 1-ом абзаце.
**Переключим версию java назад на 8-ую.**
```
sudo update-alternatives --config java
```
### Отключение старого RestServer-а
Запускаем **Astor**
```
astor
```
Выбираем ветку **Miscellaneous**, стартер **tangobox**, меню **Open control Panel**. Открывается окно управления стартером.
Ищем RestServer и выбираем **Set startup level**, и отключаем его.
В итоге получается следующее:
Старый RestServer выключен.
API
---
### Документация
[**Документация**](https://github.com/tango-controls/rest-api)
Спасибо за внимание. | https://habr.com/ru/post/554686/ | null | ru | null |
# Факты в puppet
Зачастую мы сталкиваемся с проблемой что стандартных фактов которые поставляются вместе с puppet не всегда хватает. Решение этой проблемы может быть достигнуто путем добавления новых фактов. Вы можете добавлять свои факты, написанные на Ruby, на puppet сервер. Затем сервер, используя синхронизацию плагинов, распространит их на все клиенты.
Для того чтобы посмотреть все факты которые сейчас есть на клиенте воспользуемся командой facter -p
Для чего нужны факты можно посмотреть в начале [статьи](http://habrahabr.ru/company/badoo/blog/157023/) пользователя [Badoo](https://habrahabr.ru/users/badoo/).
##### Пример
Допустим, нам нужно получить вывод команды uname -i для определения разрядности системы. Для этого нам нужно создать факт. Назовем наш факт hardware\_platform, и создадим hardware\_platform.rb, на Puppet сервере:
{modulepath}
└── {module}
└── lib
└── facter
```
# hardware_platform.rb
Facter.add("hardware_platform") do
setcode do
Facter::Util::Resolution.exec('/bin/uname -i')
end
end
```
##### Факты в фактах
Мы можем использовать значения фактов при написании своих используя конструкцию Facter.value(“somefact”) или Facter.somefact. При отсутствии факта первый вернет 0, а второй exception.
```
Facter.add("osfamily") do
setcode do
distid = Facter.value('lsbdistid')
case distid
when /RedHatEnterprise|CentOS|Fedora/
"redhat"
when "ubuntu"
"debian"
else
distid
end
end
end
```
Теперь после следующего запуска puppet агента на клиенте, факт станет доступным.
##### Замечание
На puppet сервере и клиенте в разделе [main] должна присутствовать опция
`pluginsync = true`
#### Настройка фактов.
Факты имеют несколько параметров, которые можно использовать для тонкой настройки фактов
##### Timeout
Если ваш факт ненадежен и не всегда может корректно завершить работу, вы можете использовать timeout. Если время выполнения setcode блока будет превышает timeout, Facter прервет процесс и присвоит факту заданное при ошибке значение.
```
# Случайный timeout
Facter.add(:sleep) do
timeout = 10
setcode do
if Random.rand(6) == 0
sleep 999999
else
"awake"
end
end
end
```
##### Кэширование
Если факты некоторое время не изменяются или для их нахождения требуется много времени, их можно закэшировать. Для этого нам нужно добавить опцию ':ttl' при объявлении факта
```
Facter.add("mylongoperation", :ttl => 600) do
setcode do
... операция ...
end
end
```
0 — никогда не кэшировать. Поведение по умолчанию.
-1 — Кэш навсегда. Полезно для разовых операций. Например: название дистрибутива.
##### Важность фактов
У фактов есть параметр — weight (вес). Факты с большим весом выполняются раньше
```
# Проверяем
Facter.add(:role) do
has_weight 100
setcode do
if File.exist? "/etc/postgres_server"
"postgres_server"
end
end
end
# Проверяем есть ли бинарник
Facter.add(:role) do
has_weight 50
setcode do
if File.exist? "/usr/sbin/pg_create"
"postgres_server"
end
end
end
# Если сервер не похож на сервер, значит это десктоп
Facter.add(:role) do
setcode do
"desktop"
end
end
```
##### Ограничение фактов
Мы можем ограничивать выполнение фактов, на основание других фактов с помощью параметра — confine.
Например, найти факт только если ядро системы — Linux
```
Facter.add(:powerstates) do
confine :kernel => "Linux"
setcode do
Facter::Util::Resolution.exec('cat /sys/power/states')
end
end
``` | https://habr.com/ru/post/165543/ | null | ru | null |
# Разбираем Теорию Игр с python-библиотеками nashpy и axelrod
Начнём с nashpy
---------------
[git-репозиторий](https://github.com/drvinceknight/Nashpy)
[Документация](https://nashpy.readthedocs.io/en/stable/index.html)
"Камень, ножницы, бумага" - кто из нас не играл в эту игру в детстве? Но вы когда-нибудь задумывались о том, что стратегии, которые мы выбирали, на самом деле могут быть смоделированы в с помощью Теории игр?
Вы можете подумать, будто играющие в КНБ случайным образом выбирают стратегию, но на самом деле игроки часто пытаются предсказать, какой будет стратегия противника, и, соответственно, выбрать выигрышный ход.
Теория игр - это анализ стратегического взаимодействия. Теория игр построена на анализе и моделировании стратегий и результатов их применения на основе определенных правил в игре из двух или более игроков. Она имеет широкое применение в анализе политических сценариев, логических салонных игр, ситуаций в бизнесе, а также для наблюдения за экономическим поведением.
Сегодня я постараюсь объяснить некоторые понятия теории игр простыми словами, используя игры для 2-х игроков. Вы также узнаете, как решать эти игры с помощью python-библиотеки `nashpy`. Вот что мы рассмотрим:
1. Матрица выплат в игре
2. Что такое доминирующая стратегия
3. Равновесие Нэша
4. Чистые и смешанные стратегии
5. Решение с использованием python
6. Некоторые ограничения равновесия Нэша
7. Эффективность Парето
8. Игра в дилемму заключенного и некоторые практические приложения
Рис. 1: Игра для 2 игроков. Эта и последующие иллюстрации - автораРассмотрим игру для 2 игроков - игрок A и игрок B, приведенную на рис. 1. У каждого игрока есть 2 стратегии - игрок A может выбрать верхний или нижний вариант, а игрок B - левый или правый. Приведенная выше матрица называется *"матрицей выплат" (матрицей выигрышей, платежной матрицей).*
Игрока A назовем *игроком ряда*, а игрока Б - *игроком столбца.*Цифры, выделенные красным цветом обозначают выплаты игрока A, а цифры голубым цветом обозначают выплаты игрока B. Например, если игрок A играет в нижний ряд, а игрок B играет в левый столбец, то как вы думаете, каковы будут выплаты?
Рис. 2: Игра 1Выплата игроку A составит 4, а игроку B - 2, как вы можете видеть на рис. 2. У этой конкретной игры есть очень простое решение. Для игрока А всегда лучше играть в нижний ряд, потому что его выигрыши (4 или 2) от этой стратегии всегда больше, чем в верхнем ряду (2 или 0). Аналогично, для игрока B всегда лучше играть "слева", потому что его выплаты (4 или 2) всегда больше, чем в правом ряду (2 или 0). Следовательно, стратегия равновесия заключается в том, чтобы игрок A играл "внизу", а игрок B играл "слева". Это подводит нас к концепции доминирующей стратегии.
> ***Доминирующая стратегия****: Существует только одна оптимальная стратегия для каждого игрока, независимо от того, какую стратегию принимает другой игрок. Какой бы выбор ни делал B, A всегда должен выбирать нижний ряд, и на любой выбор игрока A другой игрок, B всегда должен выбирать левый столбец.*
>
>
### Равновесие Нэша
Рассмотрим игру №2 :
Рис. 3: Игра 2*Примечание: Выплаты игрока A - зеленым цветом, а игрока B - коричневым.*
В этой игре, если игрок B выбирает левый столбец, то выплаты игрока A составляют либо 4, либо 0. Если же игрок B выбирает правый столбец, выплаты игрока A составляют 0 или 2. Следовательно, если B выбирает левый, A должен выбрать верхнюю строку, а если B выбирает правый, то A должен выбрать нижнюю. То есть оптимальный выбор A зависит от того, какой выбор делает B.
> *Пара стратегий является равновесием* [*Нэша*](https://ru.wikipedia.org/wiki/%D0%9D%D1%8D%D1%88,_%D0%94%D0%B6%D0%BE%D0%BD_%D0%A4%D0%BE%D1%80%D0%B1%D1%81) *(NE), если оптимальный выбор игрока A при выборе игрока B совпадает с оптимальным выбором игрока B при выборе игрока A. Проще говоря, изначально ни один из игроков не знает, что будет выбирать другой игрок. Следовательно, NE - это пара вариантов/стратегий/ожиданий, когда ни один из игроков не захочет менять свое поведение даже после раскрытия стратегии/выбора другого игрока.*
>
>
В этой игре стратегия (сверху, слева) - это [равновесие Нэша](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B2%D0%BD%D0%BE%D0%B2%D0%B5%D1%81%D0%B8%D0%B5_%D0%9D%D1%8D%D1%88%D0%B0), потому что если A выбирает верх, то лучше всего для B выбрать лево, потому что его выигрыш слева равен 2, а не 0. Аналогично, если B выберет левый столбец, то лучший выбор для A - выбрать верхнюю строку, потому что он получит более высокую выплату 4, а не 0, как при выборе нижней.
Итак, может ли быть множественное равновесие Нэша? Ответ - Да. В этой игре мы только что увидели, на самом деле у нас есть 2 равновесия Нэша - стратегия (нижняя строка, правый столбец) также является NE, потому что если A выбирает нижнюю строку, B должен выбрать правый столбец и наоборот.
Теперь давайте попробуем выяснить равновесие Нэша для этой игры (Игра 2) и предыдущей, т.е. Игры 1 с использованием `nashpy` в python.
### Игра 1 с использованием python:
```
import nashpy
# Create the game with the payoff matrix
A = np.array([[2,0],[4,2]]) # A is the row player
B = np.array([[4,2],[2,0]]) # B is the column player
game1 = nash.Game(A,B)
game1
```
```
Bi matrix game with payoff matrices:
Row player:
[[2 0]
[4 2]]
Column player:
[[4 2]
[2 0]]
```
Теперь определим равновесие Нэша:
```
# Find the Nash Equilibrium with Support Enumeration
equilibria = game1.support_enumeration()
for eq in equilibria:
print(eq)
```
```
(array([0., 1.]), array([1., 0.]))
```
Поскольку у игрока есть 2 стратегии - у игрока A (верхняя строка, нижняя строка), а у игрока B (слева, справа), то вывод можно интерпретировать следующим образом:
Игрок А выбирает стратегию 2, т.е. «Внизу», поскольку «1» на второй позиции массива, а игрок B выбирает стратегию 1, т.е. "Слева", поскольку "1" в первой позиции массива. Следовательно, как мы видели ранее, стратегия (внизу, слева), это исход этой игры.
### Игра 2 с использованием python:
Используя ту же логику, что и выше, давайте вычислим равновесия Нэша для игры 2.
```
# Create the payoff matrix
A = np.array([[4,0],[0,2]]) # A is the row player
B = np.array([[2,0],[0,4]]) # B is the column player
game2 = nash.Game(A,B)
print(game2)
# Find the Nash Equilibrium with Support Enumeration
equilibria = game2.support_enumeration()
for eq in equilibria:
print(eq)
```
```
(array([1., 0.]), array([1., 0.]))
(array([0., 1.]), array([0., 1.]))
(array([0.66666667, 0.33333333]), array([0.33333333, 0.66666667]))
```
Здесь мы видим 3 строки вывода, давайте возьмем каждую строку и поймем, что она означает:
> *У игрока A есть стратегии (сверху, снизу), а у игрока B есть стратегии (слева, справа)*
>
>
#### Строка 1: "(массив([1., 0.]), массив([1., 0.])) "
**Интерпретация**: Это первое равновесие Нэша (сверху, слева). Игрок А выбирает стратегию 1, т.е. «Верх», так как «1» на первой позиции первого массива, а игрок B выбирает стратегию 1, т.е. "Слева", так как "1" в первой позиции второго массива.
#### Строка 2: "(массив([0., 1.]), массив([0., 1.])) "
**Интерпретация**: Это второе равновесие Нэша (внизу, справа). Игрок А выбирает стратегию 2, т.е. «Внизу», поскольку «1» на второй позиции первого массива, а игрок B выбирает стратегию 2, т.е. "Справа", поскольку "1" во второй позиции второго массива.
Но у нас также есть 3-я линия, так почему же мы получили еще один результат? Чтобы понять это, позвольте мне представить **смешанные стратегии**.
Стратегии, которые мы обсуждали выше в игре 1 и 2, называются "***Чистые стратегии***". Но мы, люди, обычно не делаем один выбор навсегда, не так ли? Таким образом, игроки могут ***рандомизировать***свои стратегии. Вероятности могут быть присвоены каждой чистой стратегии, и игроки могут выбирать стратегии в соответствии с назначенной ей вероятностью. Следовательно, строку 3 вывода игры 2 можно интерпретировать так:
#### Строка 3: "(массив([0.66666667, 0.33333333]), массив([0.33333333, 0.66666667])) "
**Интерпретация:**Игрок А использует стратегию 1, т.е. "Верх" 66,67% времени и стратегию 2, т.е. "Нижняя строка" 33,33% времени, в то время как игрок B использует стратегию 1, т.е. "Лево" 33,33% времени и стратегию 2, т.е. "Право" 66,67% от всех ходов.
Логично же, что игрок A должен присвоить более высокую вероятность стратегии "Верх", а игрок B - "Право", потому что это дает им более высокие выигрыши.
Это равновесие представляет собой ***смешанную стратегию равновесия Нэша***и определяется так:
> *"Каждый игрок выбирает оптимальную "****частоту****", с которой можно играть свои стратегии, учитывая выбор частоты другого игрока"*
>
>
Как мы рассчитываем полезность/выплаты игрока A и игрока B в смешанной стратегии равновесия Нэша?
-------------------------------------------------------------------------------------------------
Общая математическая формулировка дается следующим образом:
Рассмотрим игру
σr и σc являются смешанными стратегиями для игроков строк и столбцов (игроков A и B соответственно).
Далее, полезность/ выигрыш/ оплата для игрока ряда (A) составляет:
и полезность/ выигрыш/ выплата для игрока столбца (B) составляет:
Вероятность нахождения в данной ячейке (одновременного выбора соответствующих ячейке вариантов стратегии со стороны игрока A и B) представляет собой произведение вероятностей выбора соответствующей строки и столбца со стороны игрока А и игрока B (см далее в примере расчёта):
Значение ячейки равно выигрышу для А или B:
В нашем случае полезность для A будет следующей:
`0.67*0.33*4 + 0.33*0.67*0 + 0.33*0.67*0 + 0.33*0.67*2 = 1.3266`
и для B это будет:
`0.33*0.67*2 + 0.67*0.33*0 + 0.33*0.67*0 + 0.67*0.33*4 = 1.3266`
Давайте вычислим это в python:
```
# Calculate Utilities
sigma_r = np.array([.67,.33])
sigma_c = np.array([.33,.67])
pd = nash.Game(A, B)
pd[sigma_r, sigma_c]
```
```
array([1.3266, 1.3266])
```
Отлично, это полностью соответствует нашим расчетам выше.
Существует несколько проблем или ***ограничений равновесия Нэша***:
1. **Множественные равновесия Нэша**: Как показано в игре 2, может быть несколько равновесий Нэша, поэтому в этом случае не существует уникального решения.
2. **Нет равновесия Нэша**: Есть игры, в которых нет равновесия Нэша. Рассмотрим игру 3 ниже:
Игра 3*Примечание: Выплаты игрока A - зеленым цветом, а игрока B - коричневым.*
Здесь, если игрок A играет Верх, то игрок B должен играть Лево (выплата 0 > выплата -2). Если игрок B играет Лево, то игрок A должен играть Низ (выплата 2 > выплата 0). Если игрок A играет Низ, то игрок B должен играть Право (выплата 6 > выплата 0), а если игрок B играет Право, то игрок A должен играть Верх (выплата 0 >выплата -2). Следовательно, в ***этой игре нет равновесия Нэша в чистой стратегии***.
3.**Равновесие Нэша не обеспечивает эффективные результаты Парето:**
Давайте проиллюстрируем это, рассмотрев одну из самых известных игр под названием ***"Дилемма заключенного".***
Но до этого определим ***эффективность Парето***в этом контексте:
> *Эффективность Парето - это ситуация, когда ни один игрок не может улучшить свое положение, не ухудшив положение хотя бы одного игрока.*
>
>
Теперь вернемся к дилемме заключенного. Два заключенных, обвиняются в преступлении, и их допрашивают в отдельных комнатах. У каждого из них есть 2 стратегии -
а) Признаться в преступлении - Признаться (Confess)
б) Отказаться признаваться в причастности - Отрицание (Deny)
Игра 4: Дилемма заключенногоЕсли бы только один заключенный признался, то он бы получил снисхождение (пошёл на сделку со следствием), а другой заключенный был бы приговорен к отбыванию 6 месяцев в тюрьме. Однако, если оба отрицают преступление, то им нужно будет отбыть по 1 месяцу в тюрьме. Если они оба признаются, то каждый из них должен будет отбыть по 3 месяца в тюрьме. Матрица выплат показана выше для 4-й игры.
Теперь давайте рассмотрим полезности и стратегии, которые должен выбрать каждый заключенный.
Если заключенный А признается, то заключенному B тоже лучше признаться, потому что его полезность -3 больше, чем -6. Если заключенный А отрицает, то заключенному B лучше признаться, потому что его полезность 0 > -1, и он может выйти. Следовательно, в обоих случаях, ***независимо от того, что делает заключенный Б***, заключенному А **лучше всегда признаваться**.
Та же логика применима и к заключенному Б. Таким образом, ***(Признание, Признание) - это равновесие Нэша в этой игре***. Это также доминирующая равновесная стратегия, потому что каждый заключенный имеет оптимальную стратегию, независимую от другого игрока.
Однако здесь есть подвох. Эта стратегия неэффективна по Парето, как мы проиллюстрируем ниже:
Если бы оба заключенных могли доверять друг другу (они не могут общаться друг с другом и координировать свои действия, потому что они находятся в разных комнатах и им не разрешается говорить) и договориться все отрицать, то им обоим было бы лучше. В этом случае их выплаты будут (-1, -1). Следовательно, с этой точки зрения стратегия ***(Отрицать, Отрицать) наиболее эффективна,***потому что нет другой стратегии, которая дает в сумме для обоих больший выигрыш.
### Расчет дилеммы заключенного на python:
Вот код, который вы можете использовать для решения игры:
```
# Create the payoff matrix
A = np.array([[-3,0],[-6,-1]]) # A is the row player
B = np.array([[-3,-6],[0,-1]]) # B is the column player
game4 = nash.Game(A,B)
game4
# Find the Nash Equilibrium with Support Enumeration
equilibria = game4.support_enumeration()
for eq in equilibria:
print(eq)
```
```
Bi matrix game with payoff matrices:
Row player:
[[-3 0]
[-6 -1]]
Column player:
[[-3 -6]
[ 0 -1]]
(array([1., 0.]), array([1., 0.]))
```
Как вы можете видеть, стратегия 1, т.е. (Признаться, Признаться) для обоих заключенных - это равновесие Нэша.
### Применение дилеммы заключенного
Игра в дилемму заключенного имеет много применений в экономике, политике, промышленности и других бизнес-решениях. Например: есть две фирмы - фирма A и фирма B, которые являются лидерами на рынке, скажем, авиационной отрасли. Пусть стратегия 1 (признаться) означает «сохранять цену авиабилета неизменной», а стратегия 2 (отрицание) как «снизить цену авиабилета». Снижение цены может быть попыткой заполнить пустые места и захватить рынок. Если фирма A сохранит цену авиабилета неизменной, то она проиграет фирме B, которая может снизить цену и захватить рынок. В последовательной игре это может привести к ценовой войне. Однако, если обе фирмы образуют картель и решат сохранить цены без изменений, то обеим будет лучше.
Резюме:
-------
Мы обсудили концепции теории игр с некоторыми известными играми. Ходы в них делались одновременно.
Далее мы изучим последовательные игры, в которых ходы делаются поочередности, и есть несколько раундов, и как из-за этого могут измениться результаты игры.
Вот еще одна известная игра "Hawk-Dove" (Ястреб-Голубь). Верный своему названию "ястреб" использует агрессивную стратегию, а "голубь" - к пассивную.
Игра 5: Игра Hawk-DoveПопробуйте сыграть в неё сначала в уме, а потом с использованием nashpy, и напишите в комментариях, каковы будут результаты и почему.
Полный код доступен на [Github](https://github.com/Mythili7/Game-Theory).
Продолжим с axelrod
-------------------
[git-репозиторий](https://github.com/Axelrod-Python)
[Документация](https://axelrod.readthedocs.io/en/stable/index.html#)
Теперь мы поговорим о повторяющихся играх и о том, как это может повлиять на ход игры, особенно в дилемме заключенного, обсуждавшийся выше.
Вот наш план:
1. Введем новые условия в стратегию дилеммы заключенного
2. Дилемма заключенного: играем **конечное**количество игр
3. Дилемма заключенного: играем **бесконечное**количество игр
4. Матрица выплат в двух случаях
5. Визуализация игры с использованием ***sparklines***
Итак, вернемся к дилемме заключенного. В таблице 1 показана матрица выплат. Мы принимаем матрицу выплат по умолчанию в соответствии с пакетом Axelrod:
Таблица 1: Матрица игры дилемма заключенногоВ нашем предыдущем разборе у заключенных было 2 стратегии (Признание, Отрицание), а равновесием Нэша было ***(Признание, Признание).*** Это будет доминирующей равновесной стратегией.
Обратите внимание, что стратегия "Признание" также является своего рода "предательской" (Defect) стратегией, а стратегия "Отрицание" фактически означает "сотрудничество" (Cooperate).
***В предыдущем случае игроки делали выбор только один раз, и игра была сыграна один раз.***
Теперь, когда игру можно сыграть несколько раз, каждому игроку доступен ряд новых стратегических возможностей. Стратегия зависит от того, будет ли игра сыграна ***конечное или бесконечное***число раз. Давайте рассмотрим оба случая по порядку.
**Случай 1: Игра играется конечное количество раз (скажем, 10)**
Давайте рассмотрим последний раунд, т.е. раунд 10 - это последний раз, когда игра будет сыграна, поэтому нет смысла сотрудничать, и, следовательно, каждый игрок скорее будет "предателем", т.е. признается.
Теперь давайте рассмотрим 9-й раунд: мы только что увидели, что в 10-м раунде игроки не сотрудничают, так почему же они должны сотрудничать в 9-м раунде? Если предположить, что игрок A сотрудничает, то игрок B может предать, используя хорошие побуждения игрока A, и выйти из заключения. (*Ведь в следующем раунде его все рано накажут - там всем выгодно быть "предателями" - прим. переводчика*). Каждый игрок будет размышлять таким образом, и каждый будет склоняться к "предательству", т.е. стратегии Признаться. Эта логика может быть применена далее ко всем предыдущим раундам.
> Следовательно, если игра сыграна конечное/фиксированное количество раз, то каждый игрок будет "предавать" в каждом раунде. Игроки сотрудничают, надеясь, что это вызовет сотрудничество в будущем. Но если нет шансов на будущую игру, нет необходимости сотрудничать сейчас.
>
>
**Следовательно, результат будет (Признаться, Признаться), как и раньше, когда игра была сыграна только один раз.**
Давайте проиллюстрируем это с python. Теперь мы будем использовать пакет `Axelrod` для повторяющихся игр.
***Обратите внимание, что стратегия сотрудничества в пакете Axelrod обозначается как "C", а стратегия перебежчика - как "D".***
```
import axelrod as axl
players = (axl.Defector(), axl.Defector())
match1 = axl.Match(players, turns =10)
match1.play()
```
```
[(D, D),
(D, D),
(D, D),
(D, D),
(D, D),
(D, D),
(D, D),
(D, D),
(D, D),
(D, D)]
```
Как видите, в конечной игре игроки будут "предавать" во всех раундах.
**Случай 2: Игра продолжается бесконечное количество раз**
Стратегии меняются, когда в игру играют бесконечное количество раз. Если игрок A отказывается сотрудничать в одном раунде, то игрок B может отказаться от сотрудничества в следующем раунде. Угроза отказа от сотрудничества заставит игроков прибегнуть к сотрудничеству и играть в соответствии с эффективной стратегией Парето, т.е. Отрицать.
[Роберт Аксельрод](https://ru.wikipedia.org/wiki/%D0%90%D0%BA%D1%81%D0%B5%D0%BB%D1%8C%D1%80%D0%BE%D0%B4,_%D0%A0%D0%BE%D0%B1%D0%B5%D1%80%D1%82) продемонстрировал это с помощью серии экспериментов, в которых различные стратегии были протестированы на игроках в турнире.
> Победившей стратегией/комбинацией ходов оказалась "Око за око", поскольку она давала самую высокую отдачу для игрока.
>
>
В первом раунде Игрок А сотрудничает и играет в стратегию "Отрицание". В каждом последующем раунде Игрок A сотрудничает, если Игрок B сотрудничал в предыдущем раунде, и признается ("предает"), если Игрок B признавался в предыдущем раунде. Таким образом, стратегия "Око за око" означает, что игрок A должен поступать так же, как игрок B поступал в предыдущем раунде.
Эта стратегия работает, потому что она дает немедленное наказание за "предательство" и немедленное вознаграждение за сотрудничество. Это в конечном итоге может привести к эффективному устойчивому результату по Парето (Отрицать, Отрицать).
Давайте проиллюстрируем это в python:
Для примера давайте сыграем в игру 20 раз.***Игрок A играет в стратегию "око за око", а игрок B пусть выбирает ходы случайным образом.***
```
players = (axl.TitForTat(), axl.Random())
match2 = axl.Match(players, turns =20)
match2.play()
```
```
[(C, D),
(D, D),
(D, D),
(D, D),
(D, C),
(C, C),
(C, D),
(D, D),
(D, C),
(C, C),
(C, D),
(D, C),
(C, D),
(D, C),
(C, C),
(C, D),
(D, C),
(C, C),
(C, C),
(C, C)]
```
Как видите, игра сходится с 18-го раунда, когда оба игрока начинают сотрудничать и играют (Отрицать, Отрицать), чем и достигается эффективный результат по Парето.
### Выгоды игроков и визуализация хода игры
Теперь мы рассмотрим выигрыши в течение игры, а также визуализируем игру с помощью Sparklines.
Выплаты, установленные по умолчанию в библиотеке `Axelrod` следующие:
Матрица выплат в AxelrodГде
* R: Reward, **Награда**(значение по умолчанию в библиотеке: 3)
* P: Punishment, **Наказание**(значение по умолчанию в библиотеке: 1)
* S: Sucker/Loss, **Простофиля/Потеря**(значение по умолчанию в библиотеке: 0)
* T: Temptation, **Соблазн**(значение по умолчанию в библиотеке: 5)
Это приведет к следующей матрице:
Матрица выплат по умолчанию в Axelrod### Выплаты при выборе в первом случае (10 раундов):
Давайте рассчитаем выплаты в первом случае:
```
match1.game
# Scores of a match
match1.scores()
```
```
[(1, 1),
(1, 1),
(1, 1),
(1, 1),
(1, 1),
(1, 1),
(1, 1),
(1, 1),
(1, 1),
(1, 1)]
```
Поскольку игроки всегда признаются, выплата будет (1,1), т.е. по 1 каждому игроку.
> Результат матча также можно рассматривать как линию, где сотрудничество отображается как сплошной блок, а "предательство" - как пустое пространство (пробел).
>
>
Первый ряд для игрока A, а второй ряд для игрока B.
```
print(match1.sparklines())
```
В этом случае вывод пуст (пробелы), потому что игроки всегда играют в "предателя". Проверьте это в python.
Вариант 2 (20 игр, один из игроков играет в "око за око"):
----------------------------------------------------------
```
match2.scores()
```
```
[(0, 5),
(1, 1),
(1, 1),
(1, 1),
(5, 0),
(3, 3),
(0, 5),
(1, 1),
(5, 0),
(3, 3),
(0, 5),
(5, 0),
(0, 5),
(5, 0),
(3, 3),
(0, 5),
(5, 0),
(3, 3),
(3, 3),
(3, 3)]
```
Видно, что выплаты сходятся к (3,3).
Теперь визуализируем этот результат игры с помощью Sparklines:
```
print(match2.sparklines())
█ ██ ██ █ ██ ███
██ ██ █ ██ ████
```
Резюме:
-------
Мы обсудили, как исход игры "дилемма заключенного" меняется в повторяющихся играх и как отличаются результаты, если сыграно конечное количество раундов против бесконечного количества раундов.
Полный код доступен на [Github](https://github.com/Mythili7/Game-Theory).
***P.S.: Посмотрите на результаты ниже и предположите, какая стратегия была выбрана каждым игроком?***
```
████████████████
█ █ █ █ █ █ █ █
```
Дополнительный бонус от переводчика:
------------------------------------
В библиотеке axelrod содержится набор из более чем 230 стратегий для игры в дилемму заключенного. Обратите внимание, как задавались стратегии игроков (первая `axl.TitForTat()` означает "око за око", вторая `axl.Random()` - случайный выбор):
```
players = (axl.TitForTat(), axl.Random())
```
Здесь будут постепенно выкладываться все стратегии и примеры соревнований между ними. Начнем с базовых:
```
import axelrod as axl
axl.basic_strategies
```
```
[axelrod.strategies.alternator.Alternator,
axelrod.strategies.titfortat.AntiTitForTat,
axelrod.strategies.titfortat.Bully,
axelrod.strategies.cooperator.Cooperator,
axelrod.strategies.cycler.CyclerDC,
axelrod.strategies.defector.Defector,
axelrod.strategies.titfortat.SuspiciousTitForTat,
axelrod.strategies.titfortat.TitForTat,
axelrod.strategies.memoryone.WinShiftLoseStay,
axelrod.strategies.memoryone.WinStayLoseShift]
```
Все стратегии будут играть 50 игр против классической оптимальной "око за око" (стратегия в пером ряду, око за око - во втором)
Alternator
----------
`Alternator` - игрок, чередующий сотрудничество и "предательство", начинает всегда с сотрудничества.
```
import axelrod as axl
players = (axl.Alternator(), axl.TitForTat())
match = axl.Match(players, turns =50)
match.play()
print(match.sparklines())
```
```
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
██ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
```
AntiTitForTat
-------------
`AntiTitForTat` - стратегия, при которой игрок ходит противоположно предыдущему ходу противника. Это выглядит как стратегия "Хулиган" (`Bully`), за исключением того, что первым шагом является Сотрудничество.
```
import axelrod as axl
players = (axl.AntiTitForTat(), axl.TitForTat())
match = axl.Match(players, turns =50)
match.play()
print(match.sparklines())
```
```
█ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
```
Bully
-----
`Bully` - Игрок, который ведет себя противоположно принципу "Око за око", включая первый ход. Начинает с "предательства", а затем делает ход, противоположный предыдущему ходу противника. Это полная противоположность "Око за око", также в литературе известен как "Хулиган".
```
import axelrod as axl
players = (axl.Bully(), axl.TitForTat())
match = axl.Match(players, turns =50)
match.play()
print(match.sparklines())
```
```
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
█ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
```
Cooperator
----------
`Cooperator` - Игрок, который всегда только сотрудничает.
```
import axelrod as axl
players = (axl.Cooperator(), axl.TitForTat())
match = axl.Match(players, turns=50)
match.play()
print(match.sparklines())
```
```
██████████████████████████████████████████████████
██████████████████████████████████████████████████
```
CyclerDC
--------
`CyclerDC` - Циклически чередует D, C, то есть "предательство" и сотрудничество.
```
import axelrod as axl
players = (axl.CyclerDC(), axl.TitForTat())
match = axl.Match(players, turns=50)
match.play()
print(match.sparklines())
```
```
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
```
Defector
--------
`Defector` - "Предатель", всегда.
```
import axelrod as axl
players = (axl.Defector(), axl.TitForTat())
match = axl.Match(players, turns=50)
match.play()
print(match.sparklines())
```
```
█
```
SuspiciousTitForTat
-------------------
`SuspiciousTitForTat` - Вариант "Око за око", который начинает с "предательства".
```
import axelrod as axl
players = (axl.SuspiciousTitForTat(), axl.TitForTat())
match = axl.Match(players, turns=50)
match.play()
print(match.sparklines())
```
```
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
```
TitForTat
---------
`TitForTat` - Око за око. Игрок начинает с сотрудничества, а затем повторяет предыдущее действие противника.
Эта стратегия была названа "самой простой" стратегией, представленной на первом турнире Аксельрода. Она победила.
```
import axelrod as axl
players = (axl.TitForTat(), axl.TitForTat())
match = axl.Match(players, turns=50)
match.play()
print(match.sparklines())
```
```
██████████████████████████████████████████████████
██████████████████████████████████████████████████
```
WinShiftLoseStay
----------------
`WinShiftLoseStay` - "выиграл - меняй, проиграл - остановись" также называется обратной стратегией Павлова (Reverse Pavlov).
Начинает с "предательства", если предыдущий раунд (Сотрудничество, Сотрудничество) либо (Предательство, Предательство), то есть стратегии совпали, то Предать в данном ходе. Иначе - Сотрудничество.
```
import axelrod as axl
players = (axl.WinShiftLoseStay(), axl.TitForTat())
match = axl.Match(players, turns=50)
match.play()
print(match.sparklines())
```
```
██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ █
█ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
```
WinStayLoseShift
----------------
`WinStayLoseShift` - "выиграл - продолжай так же, проиграл - поменяй стратегию" также называется стратегией Павлова.
Начинает с сотрудничества. Если предыдущий раунд (Сотрудничество, Сотрудничество) либо (Предательство, Предательство), то есть стратегии совпали, то Сотрудничать в данном ходе. Иначе - Предательство.
```
import axelrod as axl
players = (axl.WinStayLoseShift(), axl.TitForTat())
match = axl.Match(players, turns=50)
match.play()
print(match.sparklines())
```
```
██████████████████████████████████████████████████
██████████████████████████████████████████████████
```
Этот код выведет список всех имеющихся в библиотеке `axelrod` стратегий (на момент публикации статьи - 239) с описанием на английском.
```
import axelrod as axl
print('Всего стратегий:', len(axl.strategies))
for strategy in axl.strategies:
print(strategy)
print(strategy.__doc__)
print('-' * 80)
``` | https://habr.com/ru/post/713120/ | null | ru | null |
# Transcend WiFi. Пишем клиент Shoot&View; для Windows, Mac и Linux
 На хабре неоднократно [упоминали](http://habrahabr.ru/post/191742/) о карте памяти формата SDHC со встроенным WiFi передатчиком. Купив эту карту, я был разочарован ужасным программным обеспечением, которое идет «в комплекте» с картой. Если приложением для iOS и Android хоть как то можно пользоваться, то отсутствие клиента под windows и macos, лишает карту возможности использования ее профессионалами. Точнее сказать, на PC есть веб интерфейс, но кроме ужасного внешнего вида, меня разочаровало отсутствие востребованной у фотографов функции Shoot&View, которая позволяет практически мгновенно видеть на большом экране компьютера результат съемки.
Любители geek-porno скорее всего разочаруются — мы не будет модифицировать прошивку, хакать ее, вскрывать саму карту памяти. Мы будет работать со «стоковой» картой памяти, без каких либо модификаций.
Итак, в этой статье, мы разберем с вами протокол Shoot&View карт памяти Transcend WiFi и напишем на python кроссплатформенный клиент, который запустится на windows, linux и MacOS. А для самых нетерпеливых, в конце статьи вас ожидает готовый python модуль для своих проектов, консольный клиент, а так же GUI утилита, которая работает на windows, linux и macos.
#### Поиск карты памяти в сети.
Карта памяти может работать в двух режимах — режим точки доступа, когда карта создает свою точку достапа, и режим подключения к точке доступа, когда карта «цепляется» к заранее прописанным в ее настройках точкам доступа. Для наших экспериментов, лучше включить режим подключения к точке доступа, предварительно настроив подключение из приложения на android или ios. Так же не забудьте настроить «Turn Off WiFi», установив Never. Эта опция отвечает за отключение WiFi, если никто не подключился к карте. На первом этапе, советую подключить карту к кард-ридеру, либо настроить фотоаппарат так, чтоб он не отключался при бездействии.
Пожалуй начнем программировать. Для консольного клиента нам не потребуются какие либо дополнительные модули, только «батарейки в комплекте». А начнем мы с:
```
import socket
class SDCard:
def __init__(self,home_dir=''):
self.home_dir=home_dir
# узнаем ip адрес интерфейса, к которому в данный момент подключены
self.ip=socket.gethostbyname(socket.gethostname())
# переменная для ip карты
self.card_ip=None
if __name__=='__main__':
# подготовим папку для принимаемых фотографий
HOME_DIR=os.path.expanduser('~')
if not os.path.exists(HOME_DIR+'/'+'ShootAndView'):
os.mkdir(HOME_DIR+'/'+'ShootAndView')
HOME_DIR=HOME_DIR+'/ShootAndView/'
sd=SDCard(home_dir=HOME_DIR)
```
Если карта подключена к точке доступа, ее ip-адрес можно посмотреть, например, в web интерфейсе роутера, а если же у нас прямое подключение к карте, то ее ip-адрес равен 192.168.11.254 (в соответствии с дефолтными настройками).
Но не хотелось бы искать ее вручную, тем более создатели карты предусмотрели поиск ее в сети, как это сделано в мобильном приложении. Для этого нам нужно:
1. Создать сокет на порту 58255
2. Отправить с него пустой широковещательный запрос на порт 55777
3. Ожидать ~~чуда~~ ответа карты
Если нам повезет, то в ответ мы получим вот такой текст:
```
Transcend WiFiSD - interface=mlan0
ip=192.168.0.16
netmask=255.255.255.0
router=192.168.0.1
mode=client
essid=WiFiSDCard
apmac=CE:5D:4E:5B:70:48
```
Из этого всего, нам понадобится только ip адрес. Теперь осталось запрограммировать все это дело:
```
import os
import socket
import thread
import time
class SDCard:
def __init__(self,home_dir=''):
self.home_dir=home_dir
self.ip=socket.gethostbyname(socket.gethostname())
self.card_ip=None
def find_card(self,callback=None):
"""запускаем поиск в отдельном потоку"""
thread.start_new_thread(self.find_card_thread,(callback,))
def find_card_thread(self,callback=None):
while not self.card_ip:
"""создаем UDP сокет """
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(5)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
""" и биндимся на нужный порт """
try:s.bind((self.ip, 58255))
except socket.error:
s.close()
time.sleep(1)
continue
"""отправляем пустой широковещательный запрос на порт 55777"""
s.sendto('', ('', 55777))
try:
resp=s.recv(400)
s.close()
try:
"""пробуем в лоб распарсить результат"""
self.card\_ip=resp.split('ip=')[1].split('\n')[0]
except IndexError:
"""если не получилось сообщаем об этом"""
if callback:callback(None)
"""если получилось сообщаем ip"""
if callback:callback(self.card\_ip)
except socket.timeout:
callback(self.card\_ip)
finally:
time.sleep(2)
def monitor(ip):
if not ip:return
print 'Find card on ip:',ip
if \_\_name\_\_=='\_\_main\_\_':
HOME\_DIR=os.path.expanduser('~')
if not os.path.exists(HOME\_DIR+'/'+'ShootAndView'):
os.mkdir(HOME\_DIR+'/'+'ShootAndView')
HOME\_DIR=HOME\_DIR+'/ShootAndView/'
if options.dir:HOME\_DIR=options.dir
sd=SDCard(home\_dir=HOME\_DIR)
# мне удобнее сделать все на "коллбэках",
# так как с GUI потом будет проще
sd.find\_card(callback=monitor)
# так как поиск запускаем в отдельном потоке,
# приложение не должно завершаться
while 1:
time.sleep(1)
```
На самом деле, самое сложное уже позади. Осталось только узнать, как нам получать информацию о «поступлении» новых фотографий и скачивать их.
#### Получение новых фотографий.
С получением фотографий все очень просто. После того, как мы нашли карту, достаточно присоединиться к карте на порт 5566.
Теперь, как только фотоаппарат сделает новый кадр, через 7-8 секунд к нам через открытый сокет придет информация о новых файлах, которые появились на карте, выглядит это так:
`>/mnt/DCIM/101CANON/IMG_1754.JPG`
Если сделали несколько фотографий, то в одном сообщении эти строки разделены нулевым байтом (0x00)
Хочу подчеркнуть — именно через 7-8 секунд. Почему так сделано, не совсем понятно, но повлиять на это мы не можем. Так же, приходит только информация о новых снимках в формате jpeg, причем ПО карты имеет возможность вытаскивать вшитую jpg превьюшку из RAW файла (об этом чуть ниже), но программисты предпочли лишить нас возможности снимать в jpg, заставляя снимать в RAW+jpg, либо писать RAW на одну карту, а jpg на другую. Так же, у меня не получалось копировать фотографии с кард-ридера, Shoot&View реагирует только на новые снимки, сделанные камерой.
Запрограммировать все это дело проще простого. Я пожалуй начну показывать отрывки кода, а полный код вы сможете найти в конце статьи:
```
def listener_thread(self,callback):
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# коннектимся к карте памяти
sock.connect((self.card_ip, 5566))
while self.listen_flag:
message=sock.recv(1024)
# разделяем сообщение по нулевому байту (если пришло несколько фотографий)
new_files=message.split('\00')
for x in new_files:
if x:
# добавляем все файлы в список загрузок
self.all_files.append(x[1:]) # x[1:] - опускаем символ ">", он нам не нужен
# добавляем последний файл в очередь загрузок
self.download_list.put(self.all_files[-1])
if callback:callback(self.all_files[-1])
```
#### Загрузка фотографий с карты памяти
Теперь у нас есть список новых файлов, остался самый последний шаг — загрузка фотографий на компьютер. Сама по себе загрузка реализуется через встроенный веб сервер карты. Удивительно, но факт — все что мы делали раньше, а так же загрузка фотографий и некоторые действия, такие как получение списка файлов, получение превью и пр., совершенно НЕ ТРЕБУЮТ АВТОРИЗАЦИИ. То есть если карта настроена как точка доступа, и пользователь не сменил пароль WiFi, вы можете спокойно подключиться к ней, и скачать все что там есть. Надо будет как нибудь пройтись летом по туристическим местам и поискать WiFi сети среди туристов с фотоаппаратами.
Если заглянуть в папку cgi-bin, то мы найдем много чего интересного, что может понадобиться в других проектах. Заглянуть в нее легко, достаточно поднять на карте telnet, согласно простым [инструкциям](http://wwwstud.informatik.uni-rostock.de/ad001/inf/transcend-wifi-ftpd.html). А внутри у нас:
Например, бинарник wifi\_filelist отдаст нас список файлов в директории (в формате XML), достаточно обратиться к нему так: [CARD\_IP/cgi-bin/wifi\_filelist?fn=DIR](http://CARD_IP/cgi-bin/wifi_filelist?fn=DIR), где CARD\_IP — ip адрес карты памяти, который мы уже нашли, а DIR — директория (например, /mnt/DCIM). Бинарник thumbNail отдаст нам превьюшку фотографии, достаточно скормить ему таким же образом путь к файлу. Причем на стороне сервера не делается ресурсоемкий резайс фотографии, а выдергивается вшитая в jpg или в raw превьюшка.
Но нам интересна загрузка фотографии. Получение нужной фотографии реализуется простым GET запросом на адрес [CARD\_IP/cgi-bin/wifi\_download?fn=IMAGE\_PATH](http://CARD_IP/cgi-bin/wifi_download?fn=IMAGE_PATH), где IMAGE\_PATH путь к фотографий, который нам приходит по сокету, который мы создали выше. Для загрузки в python'e в данном случае подходит функция urlretrieve библиотеки urllib. Она позволяет сразу же сохранять результат запроса в файл, и самое главное — получать прогресс загрузки, что потом пригодится в GUI.
Функция загрузки выглядит так:
```
def download_thread(self,download_callback,download_complete):
while self.listen_flag:
# если очередь на загрузку не пуста
if not self.download_list.empty():
# берем путь из очереди
fl=self.download_list.get(block=0)
# и загружаем его в папку с фотографиями
urllib.urlretrieve('http://%s/cgi-bin/wifi_download?fn=%s'%(self.card_ip,fl),self.home_dir+fl.split('/')[-1],download_callback if download_callback else None)
if download_complete:download_complete(self.download_now)
time.sleep(0.1)
```
Теперь соединим все воедино, создав готовый модуль, заодно получив консольный клиент, который будет работать на windows, linux и macos.
**sdwificard.py**
```
#coding:utf-8
"""
Copyright (C) 2010 Igor zalomskij
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
"""
import os
import socket
import thread
import time
import ping
import Queue
import urllib
import sys
class SDCard:
def \_\_init\_\_(self,home\_dir=''):
self.home\_dir=home\_dir
# выясняем ip адрес сетевого интерфейса компьютера
self.ip=socket.gethostbyname(socket.gethostname())
self.card\_ip=None #переменная с ip адресом карты памяти
self.all\_files=[] # список всех файлов
self.download\_list=Queue.Queue() # очередь для загрузки фотографий
self.in\_queue=[] # что в очереди на загрузку, понадобится в GUI
def find\_card(self,callback=None):
# стартуем новый поток с поиском карты
thread.start\_new\_thread(self.find\_card\_thread,(callback,))
def find\_card\_thread(self,callback=None):
""" поток поиска карты памяти """
while not self.card\_ip:
# создаем UDP сокет
s = socket.socket(socket.AF\_INET, socket.SOCK\_DGRAM)
s.settimeout(5)
s.setsockopt(socket.SOL\_SOCKET, socket.SO\_REUSEADDR, 1)
s.setsockopt(socket.SOL\_SOCKET, socket.SO\_BROADCAST, 1)
try:s.bind((self.ip, 58255)) #биндим его на нужный порт
except socket.error:
s.close()
time.sleep(1)
continue
# посылаем широковещательный запрос на порт 55777
s.sendto('', ('', 55777))
try:
resp=s.recv(400)
s.close()
try:
# пробуем распарсить ответ
self.card\_ip=resp.split('ip=')[1].split('\n')[0]
except IndexError:
# иначе сообщаем о неудаче
if callback:callback(None)
if callback:callback(self.card\_ip)
except socket.timeout:
callback(None)
finally:
time.sleep(2)
def start\_listen(self,callback=None,download\_callback=None,download\_complete=None):
""" Запуск мониторинга новых фотографий. запускаем три потока """
self.listen\_flag=True
# поток сокета, который будет слушать сокет с новыми фотографиями
thread.start\_new\_thread(self.listener\_thread,(callback,))
# время от времени советую пинговать карту, чтоб она не отвелилась.
thread.start\_new\_thread(self.ping\_card,())
# поток фоновой загрузки фотографий
thread.start\_new\_thread(self.download\_thread,(download\_callback,download\_complete))
def ping\_card(self):
# пингуем карту с переодичность 20 секунд.
while self.listen\_flag:
try:
resp=ping.do\_one(self.card\_ip)
except socket.error: # во время загрузки фотографий карта может не отвечать на пинги, это нормально
pass
time.sleep(20)
def listener\_thread(self,callback):
# поток получения информации о новых фотографиях
sock=socket.socket(socket.AF\_INET, socket.SOCK\_STREAM)
# коннектимся к карте на порт 5566
sock.connect((self.card\_ip, 5566))
while self.listen\_flag:
message=sock.recv(1024)
new\_files=message.split('\00') # разделяем сообщение по нулевому байту (если пришло несколько фотографий)
for x in new\_files:
if x:
# добавляем все файлы в список всех файлов ;)
self.all\_files.append(x[1:]) # x[1:] отсекаем первый символ ">", он нам не нужен
self.download\_list.put(self.all\_files[-1]) # добавляем последний файл в очередь на загрузку
self.in\_queue.append(self.all\_files[-1]) # добавляем так же в другой список, он нужен для GUI
if callback:callback(self.all\_files[-1])
def download\_thread(self,download\_callback,download\_complete):
# поток загрузки фотографий
while self.listen\_flag:
if not self.download\_list.empty(): # если очередь не пуста
fl=self.download\_list.get(block=0)
self.download\_now=fl # что в данный момент загружается, нужно для GUI
# загружаем
urllib.urlretrieve('http://%s/cgi-bin/wifi\_download?fn=%s'%(self.card\_ip,fl),self.home\_dir+fl.split('/')[-1],download\_callback if download\_callback else None)
if download\_complete:download\_complete(self.download\_now)
time.sleep(0.1)
def find\_callback(ip):
if not ip:return
print 'Find card on ip:',ip
# если определен IP адрес карты, стартуем мониторинг новых файлов
sd.start\_listen(download\_complete=download\_complete)
def download\_complete(fname):
print 'New image: %s'%(HOME\_DIR+fname.split('/')[-1])
if \_\_name\_\_=='\_\_main\_\_':
""" Для консольного клиента, парсим опции. Возможно пользователь
захочет переопределить папку для загрузки изображений, либо ip адрес интерфейса компьютера
"""
from optparse import OptionParser
parser = OptionParser()
parser.add\_option("-d", "--dir", dest="dir",default=None,help="directory for storing images")
parser.add\_option("-i", "--ip", dest="ip",default=None,help="ip address of the computer (default %s)"%(socket.gethostbyname(socket.gethostname())))
(options, args) = parser.parse\_args()
# готовим папку для загрузки изображений по умолчанию.
HOME\_DIR=os.path.expanduser('~')
if not os.path.exists(HOME\_DIR+'/'+'ShootAndView'):
os.mkdir(HOME\_DIR+'/'+'ShootAndView')
HOME\_DIR=HOME\_DIR+'/ShootAndView/'
if options.dir:HOME\_DIR=options.dir
sd=SDCard(home\_dir=HOME\_DIR)
if options.ip:sd.ip=options.ip
print 'Finding sd card...'
# запускаем поиск карты памяти
sd.find\_card(callback=find\_callback)
while 1:
time.sleep(1)
```
Я прошу не ругать меня за возможные отступления от pep-8, сейчас я практикую программирование достаточно редко, да и люблю про себя повторять: «В голове моей опилки не-бе-да, pep-8 не читал я, да-да-да».
Все исходные коды вы можете взять на [github.com/kaist/shoot-and-view](https://github.com/kaist/shoot-and-view)
Забыл упомянуть, что во время работы с картой памяти, ее желательно время от времени пинговать. В скрипте я не стал искать способов делать ping на разных платформах, тем более, консольная утилита ping на некоторых платформах требует привилегий администратора. Я просто использовал [реализацию](https://gist.github.com/pklaus/856268) ping на чистом питоне. Этот модуль нужно поместить рядом со скриптом.
#### GUI
Для GUI я использовал самое простое средство в питоне, это Tkinter. Он доступен «из коробки» в windows и MacOS, и к тому же занимает мало места, если собирать standalone приложение. Процесс написания GUI, пожалуй описывать не буду, ограничусь только небольшой инструкцией:
1. Импортируйте Tkinter
```
from Tkinter import *
```
2. Напишите GUI
Консольное приложение не требует дополнительных библиотек, а вот GUI версия хочет разных плюшек, таких как чтение exif, работа с изображениями и пр. Если вы хотите запустить ее из исходников (извините, на Linux я подготовил только такой вариант), то вам потребуется:
`sudo apt-get install python-tk python-imagetk python-imaging libimage-exiftool-perl`
А так же, установить вручную [биндинг к exiftool](https://github.com/smarnach/pyexiftool) (`sudo python setup.py install`)
В windows, кроме python 2.7 и биндинга к exiftool, требуется [PIL](http://www.pythonware.com/products/pil/) и [exiftool](http://www.sno.phy.queensu.ca/~phil/exiftool/).
Так же установка exiftool и биндинга к нему требуется на MacOS, см. ссылки выше.
Приложение собирается при помощи py2exe на windows и py2app на MacOS, скрипты вы сможете так же найти среди исходников.
#### Итог
Как и обещал, для самых ленивых доступны готовые сборки для Windows и MacOS. Взять их можно на этой [странице](http://shootandview.zalomskij.ru).
Кое что из возможностей:
* История съемки — возможность клавишами влево-право просмотреть предыдущую или следующую отснятую фотографию.
* Зум — при нажатии клавиши «проблем», фотография зуммируется до 100%
* Автоматический поиск карты памяти
* Ну и конечно же, все бесплатно для коммерческого и некоммерческого использования. Исходники доступны по лицензии GPL v2
Ну и напоследок пару скриншотов:
P.S. Я собирал приложение для MacOS впервые, прошу протестировать, работает ли, особенно не на машине python разработчиков )
*Эта статья распространяется на условиях лицензии [Creative Commons Attribution 3.0 Unported (CC BY 3.0)](http://creativecommons.org/licenses/by/3.0/)* | https://habr.com/ru/post/216039/ | null | ru | null |
# Реактивные мозговые волны: рассказ о Muse, JS и браузерах
Несколько месяцев назад я наткнулся на интеллектуальную ЭЭГ-гарнитуру с поддержкой Bluetooth и тут же увидел её потенциал в некоторых крайне интересных областях. А именно, эта гарнитура и Web Bluetooth вполне могли позволить напрямую связать мой мозг с веб-страницами.
[](https://habrahabr.ru/company/ruvds/blog/341426/)
ЭЭГ, или электроэнцефалография — это способ мониторинга электрической активности мозга. Обычно при ЭЭГ-исследовании на поверхности головы размещают несколько электродов, которые затем регистрируют электрические явления, сопутствующие работе мозга. Результаты регистрации записывают в виде электроэнцефалограмм. Мне идея поэкспериментировать с этими данными показалась очень интересной. Обычно ЭЭГ применяют в медицинских целях, но в последнее время стали появляться проекты, предусматривающие новые способы использования данных об электрической активности мозга.
Один из таких проектов — [Muse](http://www.choosemuse.com/). Его создатели продают, примерно за $250, систему, которая обучает медитации. В её состав входит отлично сделанная ЭЭГ-гарнитура, которая поддерживает Bluetooth. Хотя Muse должна обучать тому, как успокаивать разум, мой разум успокоился только после того, как я понял, как мне работать с данными от гарнитуры в веб-браузере.
(Если вы тоже сгораете от нетерпения это узнать — можете перейти сразу к коду).
Гарнитура умеет работать с приложениями для Android и iOS. Кроме того, имеется библиотека, используя которую, можно создать собственное приложение на основе данных, получаемых от гарнитуры. Однако, подходит она лишь для разработки нативных приложений, а её исходный код оказался закрытым (в результате моя мечта об управлении веб-страницами силой мысли, показалась, на первый взгляд, неосуществимой).
Когда я оказался на конференции ng-cruise, я встретил [Алекса Кастилло](https://medium.com/@castillo.io). Он рассказывал о том, как подключил ЭЭГ-гарнитуру OpenBCI к Angular и визуализировал поступающие от неё сигналы. Эта гарнитура создана в рамках проекта с открытым аппаратным обеспечением. Хотя всё это выглядело весьма впечатляюще, ему пришлось использовать довольно сложную систему на базе Node.js и сервера на веб-сокетах для работы с данными от гарнитуры. А это было совсем не то, чего хотелось мне. Однако, позже, был ночной хакатон, где все пытались сделать что-нибудь интересное с разными железками, включая и ЭЭГ-гарнитуру. В результате, что совершенно естественно, я решил воспользоваться появившимся у меня шансом.
Я попытался отреверсить протокол Muse Bluetooth, примерно так же, как я сделал это с лампочкой [Magic Blue](https://medium.com/@urish/reverse-engineering-a-bluetooth-lightbulb-56580fcb7546). Провозившись примерно час, я понял, что кто-нибудь, возможно, уже это сделал. Я поискал по одному из обнаруженных мной номеров характеристик и нашёл [эту отличную](https://articles.jaredcamins.com/figuring-out-bluetooth-low-energy-8c2a2716e376) статью, через которую вышел на [библиотеку](https://github.com/alexandrebarachant/muse-lsl/blob/d2b74412585f3baa852516542a0d0853faec1b4e/muse/muse.py) для Python, которую написал [Александр Барачант](https://medium.com/@alexandre.barachant). В результате, совершенно неожиданно, у меня оказалось всё необходимое. Так появилась библиотека [muse-js](https://github.com/urish/muse-js).
Теперь я мог подключаться к гарнитуре Muse из веб-приложений и работать с поступающими с неё ЭЭГ-данными (а также — считывать уровень заряда батареи, данные акселерометра, гироскопа, и так далее). Сейчас я расскажу о том, что сделал на основе этой библиотеки.
Аппаратное обеспечение
----------------------
Прежде чем мы погрузимся в код, сначала немного лучше познакомимся с гарнитурой Muse. Она выполнена в виде миниатюрного оголовья со встроенными аккумуляторами. В Muse имеется четыре ЭЭГ-электрода. При надевании гарнитуры два из них находятся на лбу, чуть выше глаз, ещё два — в районе ушей. Кроме того, у неё есть гироскоп и акселерометр, что даёт возможность выяснить ориентацию головы того, кто носит гарнитуру. Мне очень понравилось то, что у Muse есть ещё один ЭЭГ-датчик, который можно подключить к собственному электроду (по Micro USB). В ближайшем будущем я планирую это опробовать.
Обратите внимание на то, что существует две версии этой гарнитуры. Одна — 2014-го года, вторая — 2016-го. Вам, безусловно, больше понравится версия 2016-го, которая использует Bluetooth Low Energy. Гарнитура 2014-го года использует для связи с внешним миром Classic Bluetooth, и, таким образом, её нельзя использовать с Web Bluetooth.
*Гарнитура Muse образца 2016-го года. Электроды AF7 и AF8 расположены на лбу. Электроды TP9 и TP10 — около ушей*
Реактивные потоки и RxJS
------------------------
Когда я создавал библиотеку, мне нужно было выбрать способ представления входящих ЭЭГ-данных. При работе с Web Bluetooth всякий раз при получении нового пакета вызывается событие. Каждый пакет содержит 12 образцов измерений с одного электрода. Я мог бы предусмотреть регистрацию JavaScript-функции, которая вызывалась бы каждый раз при приёме новой порции данных, но я решил реализовать это с использованием библиотеки RxJS (Reactive Extensions Library for JavaScript). Она включает в себя методы для работы с потоками данных. Их можно трансформировать, создавать, из них можно извлекать то, что нужно.
Сильная сторона RxJS заключается в том, что библиотека предлагает набор функций, которые позволяют манипулировать потоками необработанных данных, получаемых от гарнитуры Muse и обрабатывать их, конвертируя в нечто более удобное для дальнейшей работы (чем мы скоро и займёмся).
Визуализация
------------
Первое, что приходит в голову, когда думаешь о том, что можно сделать на базе новой библиотеки `muse-js —` это визуализация данных. В ходе ночного хакатона Алекс и я начали работать над проектом [angular-muse](https://github.com/urish/angular-muse). Это Angular-приложение, которое визуализирует данные ЭЭГ и показывает положение головы.
*Мой первый прототип для визуализации данных Muse*
На самом деле, если у вас есть Muse и браузер, который [поддерживает Web Bluetooth](https://medium.com/@urish/is-now-a-good-time-to-start-using-web-bluetooth-hint-yes-yes-it-is-99e998d7b9f6), вы можете открыть [эту страницу](https://muse-eeg-app.firebaseapp.com/) и попробовать всё самостоятельно.
*Визуализация электрической активности моего мозга с использованием Muse, Angular и Smoothie Charts*
С помощью этого приложения можно увидеть, что данные с гарнитуры действительно попадают в браузер. Однако, честно говоря, хотя наблюдение за графиками может быть занятием интересным, вам оно, вероятно, довольно скоро надоест, если с данными больше ничего делать нельзя (интересно, однако, как эта потеря интереса отобразилась бы на графиках...).
В мгновение ока
---------------
Одна из операций, выполняемых в ходе ЭЭГ-диагностики — измерение электрического потенциала (вольтажа) в различных областях головы. Измеренный сигнал является побочным эффектом деятельности мозга, он может быть использован для выяснения общего состояния мозга (такого, как уровень концентрации, выявление неожиданных раздражителей, и так далее).
Помимо электроэнцефалографии, которая исследует деятельность мозга, существует такое понятие, как [электроокулография](https://en.wikipedia.org/wiki/Electrooculography) (ЭОГ). Это — исследование, в ходе которого можно детектировать движения глаз (к счастью, моя девушка — специалист по коррекции зрения, она объяснила мне что к чему). У Muse есть два электрода, расположенных в районе лба, довольно близко к глазам. (Они называются AF7 и AF8 — в соответствии со стандартной системой позиционирования электродов при ЭЭГ «10-20%») Это даёт нам возможность отслеживать движения глаз.
*Человеческий глаз. Роговица, спереди, заряжена положительно; сетчатка, сзади, заряжена отрицательно*
Мы будем использовать сигналы с электродов в нашем электроэнцефалографическом «Hello World» для выявления морганий путём отслеживания активности глаз.
Начало работы
-------------
Действовать будем так: берём поток ЭЭГ-данных, поступающих от гарнитуры (`muse-js` даёт доступ к этим данным как к наблюдаемому объекту RxJS). Затем отбираем только данные от нужного нам электрода, AF7, который находится над левым глазом, и ищем в сигнале пики, то есть, образцы, абсолютное значение которые превышает 500 мкВ, что говорит о большом изменении потенциала в моменты таких пиков. Так как электрод расположен около глаза, мы ожидаем, что движение глазного яблока будет генерировать большую разницу потенциалов.
Хотя это, возможно, и не самый точный метод определения момента моргания, в моём случае он подошёл очень хорошо. Кроме того, код оказался простым, таким, в котором легко было бы разобраться (всё это — признаки любого хорошего «Hello World»).
Прежде чем приступать к работе с данными ЭЭГ, установим `muse-js`:
```
npm install --save muse-js
```
Затем импортируем библиотеку в код. В данном случае речь идёт об Angular-приложении — обычном пустом проекте, созданном с помощью Angular CLI. Вы, если хотите, можете всё это воспроизвести с использованием React или Vue.js, так как в этом примере очень мало кода, который жёстко привязан к фреймворку.
Далее, импортируем `muse-js` в главный компонент приложения:
```
import { MuseClient, channelNames } from `muse-js`;
```
Класс `MuseClient` отвечает за взаимодействие с гарнитурой, а `channelNames —` это просто массив, используемый для приведения названий каналов к удобному для работы виду.
В компоненте создаём новый экземпляр `MuseClient`:
```
this.muse = new MuseClient();
```
Теперь вот кое-что посложнее: код для подключения к гарнитуре.
Web Bluetooth требует вмешательства пользователя для того, чтобы инициировать подключение. Поэтому нам надо добавить в компонент кнопку. Мы будем подключаться к гарнитуре только после того, как пользователь щёлкнет по кнопке. Логику подключения к гарнитуре реализуем в методе `onConnectButtonClick`:
```
async onConnectButtonClick() {
await this.muse.connect();
this.muse.start();
// TODO: подписаться на данные с гарнитуры
}
```
Метод `connect()` объекта `MuseClient` инициирует соединение с гарнитурой. Затем метод `start()` передаёт на гарнитуру команду для начала сбора ЭЭГ-данных и передачи их в приложение.
*Подключение к гарнитуре Muse с использованием Web Bluetooth*
Следующее, что надо сделать — организовать подписку на данные ЭЭГ, доступные в наблюдаемом объекте `muse.eegReadings` (это делается там, где в вышеприведённом коде расположен комментарий `TODO`):
```
const leftEyeChannel = channelNames.indexOf('AF7');
this.leftBlinks = this.muse.eegReadings
.filter(r => r.electrode === leftEyeChannel)
```
Этот код принимает показатели ЭЭГ, полученные с устройства, и отбирает только те, которые имеют отношение к электроду AF7, который расположен над левым глазом. Каждый пакет содержит 12 образцов, в результате каждый элемент в наблюдаемом потоке — это объект со следующей структурой:
```
interface EEGReading {
electrode: number;
timestamp: number;
samples: number[];
}
```
Переменная `electrode` будет содержать числовой индекс электрода (используйте массив `channelNames` для того, чтобы привести этот индекс к более понятному названию электрода), `timestamp` содержит время, относительно начала измерений, когда было сделано измерение, а `samples —` это массив, содержащий 12 чисел с плавающей точкой, каждый элемент которого содержит одно ЭЭГ-измерение, выраженное в микровольтах (мкВ).
На следующем шаге нам нужно отобрать максимальное значение из каждого пакета (то есть — измерение с максимальных выходным значением). Тут мы обработаем полученный поток с помощью оператор RxJS `map` для того, чтобы получить нужное значение:
```
this.leftBlinks = this.muse.eegReadings
.filter(r => r.electrode === leftEyeChannel)
.map(r => Math.max(...r.samples.map(n => Math.abs(n))))
```
Теперь, так как у нас имеется поток обычных чисел, мы можем его отфильтровать и пропустить лишь значения, которые больше, чем 500. Эти значения, возможно, соответствуют морганию, а именно это нам и нужно:
```
this.leftBlinks = this.muse.eegReadings
.filter(r => r.electrode === leftEyeChannel)
.map(r => Math.max(...r.samples.map(n => Math.abs(n))))
.filter(max => max > 500)
```
На этом этапе у нас есть простой конвейер для обнаружения морганий, основанный на RxJS, но нам ещё нужно подписаться на него для того, чтобы начать получать данные. Начнём с обычного `console.log`:
```
this.leftBlinks.subscribe(value => {
console.log('Blink!', value);
});
```
Если запустить этот код, вы, возможно, увидите много сообщений «Blink!», пока надеваете гарнитуру, так как в это время будет немало статического шума. Как только гарнитура будет надёжно надета, сообщения должны появляться только при моргании:
*Программа реагирует на моргания*
Возможно, вы увидите несколько сообщений «Blink!» при каждом моргании. Причина этого заключается в том, что каждое моргание создаёт несколько изменений электрического потенциала. Для того, чтобы избавиться от ненужных сообщений, нужно применить антидребезговый фильтр, похожий на тот, который используется при работе [с механическими кнопками на Arduino](https://www.arduino.cc/en/Tutorial/Debounce).
Поэтому добавим в наш проект ещё одно улучшение: вместо вывода необработанных данных в консоль, мы будем выдавать значение 1 при обнаружении моргания, затем будем ждать полсекунды после последнего изменения потенциала, и выдавать 0. Это позволит отфильтровать множественные события «Blink!», которые мы видели:
```
this.leftBlinks = this.muse.eegReadings
.filter(r => r.electrode === leftEyeChannel)
.map(r => Math.max(...r.samples.map(n => Math.abs(n))))
.filter(max => max > 500)
.switchMap(() =>
Observable.merge(
Observable.of(1),
Observable.timer(500).map(() => 0)
)
);
```
В чём же секрет `switchMap`? А происходит тут следующее: когда поступает новый элемент, `switchMap` отбрасывает предыдущий поток и вызывает заданную функцию для создания нового потока. Этот новый поток включает в себя два элемента: значение 1, которое мы выдаём немедленно с помощью `Observable.of`, а затем значение 0, которое выдаётся через 500 миллисекунд, если только, конечно, не поступит новый элемент из строки `filter`, что перезапускает `switchMap` и отбрасывает ожидаемое значение 0.
Теперь мы можем использовать этот наблюдаемый объект `leftBlinks` для визуализации морганий. Эти данные можно связать с шаблоном Angular, используя асинхронный конвейер:
Данный код скрывает значок глаза при моргании. Вместо этого можно переключать класс CSS и использовать цвет или анимировать символ глаза при моргании:
В любом случае, рекомендую, если вы так можете, моргать только одним глазом для проверки кода.
Если создавать, пользуясь тем же подходом, приложение React, можно просто подписаться на этот наблюдаемый объект и обновлять состояние компонента при моргании:
```
this.leftBlinks.subscribe(value => {
this.setState({blinking: value});
});
```
Итак, мы это сделали! Вот он, «Hello World» для ЭЭГ-гарнитуры!
*Готовый «Hello World»*
[Здесь](https://github.com/urish/muse-blink) можно найти код этого проекта. Хочу выразить огромную благодарность [Бену Лешу](https://medium.com/@benlesh) за помощь с подготовкой RxJS-кода.
Итоги
-----
Несколько лет тому назад слово «электроэнцефалография» вызывало мысли о громоздком, страшно дорогом оборудовании, доступном только больницам да исследовательским учреждениям. Сегодня веб-разработчики, такие же как вы и я, могут работать с данными об электрической активности мозга, используются обычные инструменты: браузер, RxJS, Angular и вполне доступную гарнитуру.
Возможно, ЭЭГ — не ваша тема, но это не может помешать вам увидеть то, как новые поколения «интеллектуальных» устройств создают массу интереснейших возможностей для программистов. Эх, что за времена настали!
Уважаемые читатели! Какие варианты применение ЭЭГ-гарнитур в веб-разработке кажутся вам самыми интересными и перспективными? | https://habr.com/ru/post/341426/ | null | ru | null |
# Подводные камни при использовании Linked Server
В нашу компанию пришел достаточно интересный проект, связанный с обработкой очереди задач. Проект был разработан ранее другой командой. Нам необходимо было разобраться с проблемами, возникающими при большой нагрузке на очередь, и, соответственно, исправить найденные.
Если вкратце, то проект из себя представляет несколько БД и приложений, расположенных на разных серверах. «Задача» в данном проекте – это хранимая процедура или .Net приложение. Соответственно «задача» должна быть выполнена на определённой БД и на определенном сервере.
Все данные, которые относятся к очереди, хранятся на выделенном сервере. На серверах, где необходимо выполнять задачи, хранятся только метаданные, т.е. процедуры, функции и служебные данные, которые относятся к этому серверу. Соответственно, данные, относящиеся к задачам, мы получаем запросами с использованием LinkedServer.
Все данные, которые относятся к очереди, хранятся на выделенном сервере. На серверах, где необходимо выполнять задачи, хранятся только метаданные, т.е. процедуры, функции и служебные данные, которые относятся к этому серверу. Соответственно, данные, относящиеся к задачам, мы получаем запросами с использованием LinkedServer.
### Почему так?
1. Удобство. Мы можем в любой момент указать, что теперь на сервере Б хранятся данные.
2. Так было реализовано до нас.
Ниже приведены два наиболее популярных классических способа обработки очереди:
1. Отправлять уведомление обработчику задач о наличии задачи.
2. Производить опрос очереди на наличие задач.
Изначально в проекте был реализовал второй вариант. Чтобы минимизировать время ожидания обработки задач, наше приложение опрашивает очередь каждый 100-500ms.
Cобственно, в этом ничего страшного и нет, кроме одного – при такой реализации таблица лишний раз блокируется. Наперед скажу, в запросе используется блокировка строк с возможностью только чтения незаблокированных строк:
```
READPAST, ROWLOCK, UPDLOCK
```
Итак, вернемся к проблеме. При анализе я обратил внимание на значение счетчика — **batch requests/sec** в Active Monitor. Данное значение при малом количестве (около 50) задач в очереди, зашкаливало за 1000, а также нагрузка на CPU резко возрастала.
Первая мысль: нужно переходить к реализации первого варианта (отправка уведомления обработчику задач). Данный метод был реализован с использованием службы **Service Broker** и **SignalR**:
* Service Broker использовали для отправки уведомления о появлении задачи;
* SignalR использовали для отправки уведомления обработчикам задач.
### Почему SignalR?
Данный инструмент уже используется в проекте, а сроки были сжаты, поэтому я не стал внедрять что-то аналогичное, например, **NServiceBus**.
Моему удивлению не было предела, когда данное решение не помогло. Да, был получен прирост в производительности, но это не решило проблему окончательно. Для отладки был написан стресс-тест, когда в очередь добавляется более 500 задач.
Создание такого стресс-теста позволило найти «*корень зла*».
Анализ списка активных запросов и отчетов производительности, во время большой нагрузки показа наличие «очень интересных запросов», которые состояли из одной команды:
```
fetch api_cursor0000000000000003
```
Дальнейший анализ показал, что это запросы с LinkedServer. Сразу возник вопрос: ”Неужели запрос такого типа select \* from RemoteServer.RemoteDatabase.dbo.RemoteTable where FieldId = [Value](https://habrahabr.ru/users/value/) порождает запрос (fetch api\_cursor0000000000000003) на RemoteServer?” Оказывается, да, и даже тогда, когда LinkedServer — это MS SQL.
Для более наглядного примера созданим таблицу «Test» (код создания таблицы доступен в [приложении](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/f69337e12bfa/LinkedServer/?at=default) к статье) на сервере “А”, а на сервере “B” выполним запрос:
```
select * from dev2.test_db.dbo.test
```
где *dev2* — это наш сервер “А”.
При первом выполнении такого запроса у нас будет подобный лог в профайлере на сервере А:
**Часть лога на сервере А**
Полный лог доступен [здесь](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/select%20from%20linked%20server/%D0%BF%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0%20%D0%BF%D1%80%D0%B8%20%D0%BF%D0%B5%D1%80%D0%B2%D0%BE%D0%BC%20%D0%B7%D0%B0%D0%BF%D1%83%D1%81%D0%BA%D0%B5.trc?at=default).
А теперь выполним запросы уже по ID:
```
select * from dev2.test_db.dbo.test where ID = 3
```
**Лог профайлера для второго запроса**
Полный лог доступен [тут](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/select%20from%20linked%20server/%D0%BF%D0%B5%D1%80%D0%B2%D0%B0%D1%8F%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0%20%D0%BF%D0%BE%20%D0%B7%D0%B0%D0%B4%D0%B0%D0%BD%D0%BD%D0%BE%D0%BC%D1%83%20ID.trc?at=default).
Как видно на скриншоте, план запроса был добавлен в кэш. Если выполнить этот запрос второй раз, то уже немного лучше.
**лог профайлера после повторного запуска**
Полный лог доступен [здесь](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/select%20from%20linked%20server/%D0%BF%D0%BE%D0%B2%D1%82%D0%BE%D1%80%D0%BD%D0%B0%D1%8F%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0%20%D0%BF%D0%BE%20%D0%B7%D0%B0%D0%B4%D0%B0%D0%BD%D0%BD%D0%BE%D0%BC%D1%83%20Id.trc?at=default)
Как мы видим, данные уже берутся из кэша.
При изменении условий мы получим аналогичную выборку — *первая выборка по заданному Id*. Но суть в том, что при больших количествах разных запросов кэша не хватает. И sql начинает городить кучу запросов к таблице, что приводит к «тормозам». Вы спросите: «А как же индексы?» Индексы есть, но запросы даже с условием по Primary Key (PK) порождали данную проблему.
А что Google говорит по этому поводу? А много чего, только толку нет:
* Что запросы должны выполняться от пользователя, который относится к одной из следующих ролей: sysadmin, db\_owner, db\_ddladmin, чтобы можно было использовать статистику;
* Неверно настроен LinkedServer.
Более толковые ответы были найдены только в 3-х статьях:
* [Exposing API Server Cursors](http://www.sql-server-performance.com/2006/api-server-cursors/)
* [Top 3 Performance Killers For Linked Server Queries](http://stage.toadworld.com/platforms/sql-server/b/weblog/archive/2013/05/14/top-3-performance-killers-for-linked-server-queries)
* [Технологии Push и Pull при работе с linked servers в Microsoft SQL Server](http://www.sql.ru/articles/mssql/2007/051803pushandpullinmicrosoftsqlserverlinkedservers.shtml)
Насколько я разобрался, нельзя настроить LinkedServer так, чтобы всегда использовалась Pull технология для получения данных с LinkedServer. Все зависит от того, где вы обрабатываете запрос.
Время поджимало, и единственное решение, которые нас могло спасти, это переписать часть запросов на dynamic sql. Т.е. выполнять запросы на сервере, на котором хранятся данные.
Работать с данным на LinkedServer можно несколькими способами:
1. В запросе непосредственно указать источник данных – удаленный сервер. Данная реализация имеет несколько недостатков:
* низкая производительность;
* возращает большой объем данных.
```
select * from RemoteServer.RemoteDatabase.dbo.RemoteTable where Id = @Id
```
2. Использовать OPENQUERY. Не подходит по ряду причин:
* невозможно указать имя удаленного сервера в качестве параметра;
* передать параметры в запрос;
* также существуют проблемы, которые были описаны в статье [Dynamic T-SQL и как он может быть полезен](http://inostudio.com/ru/article/dynamic-sql.html)
```
select * from OPENQUERY(RemoteServer, 'select * from RemoteDatabase.dbo.RemoteTable').
```
По ссылкам доступны примеры логов для следующих запросов. Данные запросы выполнятся на сервере “B”, а логи с сервера “A”:
```
select * from OPENQUERY(dev2, 'select * from test_db.dbo.test') where id = 26
```
* [OpenQuery/выборка с заданным Id.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/OpenQuery/%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0%20%D1%81%20%D0%B7%D0%B0%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC%20Id.trc?at=default)
```
select * from OPENQUERY(dev2, 'select * from test_db.dbo.test where ID = 26')
```
* [OpenQuery/выборка с заданным Id в качестве параметра.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/OpenQuery/%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0%20%D1%81%20%D0%B7%D0%B0%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC%20Id%20%D0%B2%20%D0%BA%D0%B0%D1%87%D0%B5%D1%81%D1%82%D0%B2%D0%B5%20%D0%BF%D0%B0%D1%80%D0%B0%D0%BC%D0%B5%D1%82%D1%80%D0%B0.trc?at=default)
3. Выполнить запрос на удаленном сервере. Аналогично OPENQUERY:
* нельзя указать имя сервера в качестве параметра, так как имя задается на этапе компиляции процедуры;
* также существуют проблемы, которые были описаны в статье [Dynamic T-SQL и как он может быть полезен](http://inostudio.com/ru/article/dynamic-sql.html)
```
exec ('select * from RemoteDatabase.dbo.RemoteTable') at RemoteServer
```
По ссылкам доступны примеры логов для следующих запросов:
```
exec ('select * from test_db.dbo.test') at dev2
```
* [exec at server/На стороне клиента.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/exec%20at%20server/%D0%9D%D0%B0%20%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%B5%20%D0%BA%D0%BB%D0%B8%D0%B5%D0%BD%D1%82%D0%B0.trc?at=default)
* [exec at server/На стороне сервера.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/exec%20at%20server/%D0%9D%D0%B0%20%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%B5%20%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0.trc?at=default?at=default)
```
exec ('select * from test_db.dbo.test where Id = 30') at dev2
```
* [exec at server/На стороне клиента с заданным Id.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/exec%20at%20server/%D0%9D%D0%B0%20%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%B5%20%D0%BA%D0%BB%D0%B8%D0%B5%D0%BD%D1%82%D0%B0%20%D1%81%20%D0%B7%D0%B0%D0%B4%D0%B0%D0%BD%D1%8B%D0%BC%20Id.trc?at=default)
* [exec at server/На стороне сервера с заданым Id.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/exec%20at%20server/%D0%9D%D0%B0%20%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%B5%20%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0%20%D1%81%20%D0%B7%D0%B0%D0%B4%D0%B0%D0%BD%D1%8B%D0%BC%20Id.trc?at=default)
4. Еще возможно выполнить запрос на удаленном сервере, выполнив процедуру sp\_executesql.
```
DECLARE @C_SP_CMD nvarchar(50) = QUOTENAME(@RemoteServer) + N'.'+@RemoteDatabase +N'.sys.sp_executesql'
DECLARE @C_SQL_CMD nvarchar(4000) = 'select * from dbo.RemoteTable'
EXEC @C_SP_CMD @C_SQL_CMD
```
По ссылкам доступны примеры логов выполнения запросов с использованием sp\_executesql:
* [sp\_executesql/Полная выборка на клиенте.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/sp_executesql/%D0%9F%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0%20%20%D0%BD%D0%B0%20%D0%BA%D0%BB%D0%B8%D0%B5%D0%BD%D1%82%D0%B5.trc?at=default)
* [sp\_executesql/Полная выбрка на стороне сервера.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/sp_executesql/%D0%9F%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F%20%D0%B2%D1%8B%D0%B1%D1%80%D0%BA%D0%B0%20%D0%BD%D0%B0%20%D1%81%D1%82%D0%BE%D1%80%D0%BE%D0%BD%D0%B5%20%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0.trc?at=default)
* [sp\_executesql/Выборка по Id на клиенте.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/sp_executesql/%D0%92%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0%20%D0%BF%D0%BE%20Id%20%D0%BD%D0%B0%20%D0%BA%D0%BB%D0%B8%D0%B5%D0%BD%D1%82%D0%B5.trc?at=default)
* [sp\_executesql/Выборка по Id на сервере.trc](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b9966972b87ec943e2a7e2a881743f2/LinkedServer/%D0%A0%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%20%D1%82%D1%80%D0%B0%D1%81%D1%81%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/sp_executesql/%D0%92%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0%20%D0%BF%D0%BE%20Id%20%D0%BD%D0%B0%20%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B5.trc?at=default)
Четвертый способ и был использовал для решения задачи.
Ниже приведены несколько графиков входящего и исходящего трафика на сервере, где расположена основная база очереди до и после использования sp\_executesql. При этом размер БД 200-300Мб.
**входящий и исходящий трафик за несколько дней на сервере, до использования sp\_executesql**
**входящий и исходящий трафик, после начала использования sp\_executesql**
Исходящие пики – это копирование backup на NFS.
***Напрашивается вывод:*** изначально драйвер от MS для работы с «MS sql linked server» не может сам выполнять запросы на сервере источнике данных. Следовательно, коллеги, давайте стараться выполнять их на источнике данных, для решения хотя бы части вопросов с производительностью.
[Файлы](https://bitbucket.org/akotelevets/for-articles-by-inostudio/src/6723e6787b99/LinkedServer/?at=default) к статье. | https://habr.com/ru/post/302958/ | null | ru | null |
# Chaos Engineering: искусство умышленного разрушения. Часть 2
***Прим. перев.**: Этот материал продолжает замечательный цикл статей от технологического евангелиста из AWS — Adrian Hornsby, — задавшегося целью просто и понятно объяснить важность экспериментов, призванных смягчить последствия сбоев в ИТ-системах.*
> «Если провалил подготовку плана, то планируешь провал». — Бенджамин Франклин
В [первой части](https://habr.com/ru/company/flant/blog/460367/) данной серии статей я представил концепцию chaos engineering'а и объяснил, как он помогает находить и исправлять изъяны в системе до того, как они приведут к сбоям production. Также было рассказано о том, как хаос-инжиниринг способствует позитивным культурным изменениям внутри организаций.
В конце первой части я пообещал рассказать об «инструментах и способах внедрения сбоев в системы». Увы, у моей головы на сей счет имелись собственные планы, и в этой статье я попытаюсь ответить на самый популярный вопрос, возникающий и людей, желающих заняться хаос-инжинирингом: **Что ломать в первую очередь?**
Отличный вопрос! Впрочем, эту панду он, похоже, не особо беспокоит…
*Не связывайтесь с хаос-пандой!*
**Краткий ответ**: Цельтесь в критические сервисы на пути запроса.
**Длинный, но более вразумительный ответ**: Чтобы понять, с чего следует начинать эксперименты с хаосом, обратите внимание на три области:
1. Посмотрите на **историю сбоев** и выявите закономерности;
2. Определитесь с **критическими зависимостями**;
3. Воспользуйтесь т. н. **эффектом сверхуверенности**.
Забавно, но эту часть с тем же успехом можно было назвать *«Путешествие к самопознанию и просвещению»*. В ней же мы начнем «играть» с некоторым прикольными инструментами.
1. Ответ лежит в прошлом
------------------------
Если помните, в первой части я ввел понятие Correction-of-Errors (COE) — метода, с помощью которого мы анализируем наши промахи: промахи в технологии, процессе или организации, — чтобы понять их причину(-ы) и предотвратить повторение в будущем. В общем, с этого и следует начинать.
> «Чтобы понять настоящее, нужно знать прошлое». — Карл Саган
Посмотрите на историю сбоев, проставьте теги в СОЕ или postmortem'ах и классифицируйте их. Выявите общие закономерности, которые часто приводят к проблемам, и для каждого СОЕ задайте себе следующий вопрос:
**«Можно ли это было предвидеть, а следовательно, предотвратить с помощью внедрения неисправности?»**
Я вспоминаю один сбой в самом начале моей карьеры. Его можно было бы легко предотвратить, если бы мы провели пару простейших хаос-экспериментов:
> В нормальных условиях экземпляры backend'а отвечают на health check'и от [балансировщика нагрузки (ELB](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-healthchecks.html)). ELB использует эти проверки для перенаправления запросов на «здоровые» экземпляры. Когда оказывается, что некий экземпляр «нездоров», ELB перестает направлять на него запросы. Однажды, после успешной маркетинговой кампании, объем трафика вырос, и backend'ы начали отвечать на health check'и медленнее, чем обычно. Следует сказать, что эти health check'и были [глубокими](https://medium.com/@adhorn/patterns-for-resilient-architecture-part-3-16e8601c488e), то есть проводилась проверка состояния зависимостей.
>
>
>
> Тем не менее, некоторое время все было в порядке.
>
>
>
> Затем, уже находясь в довольно напряженных условиях, один из экземпляров приступил к выполнению некритической, регулярной cron-задачи из разряда ETL. Комбинация высокого трафика и cronjob'а подстегнула загрузку ЦПУ почти на 100%. Перегрузка процессора еще сильнее замедлила ответы на health check'и — настолько, что ELB решил, что экземпляр испытывает проблемы в работе. Как и ожидалось, балансировщик перестал распределять трафик на него, что, в свою очередь, привело к возрастанию нагрузки на остальные экземпляры в группе.
>
>
>
> Внезапно все остальные экземпляры также начали проваливать health check.
>
>
>
> Запуск нового экземпляра требовал загрузки и установки пакетов и занимал гораздо больше времени, чем требовалось ELB на их отключение — одного за другим — в группе автомасштабирования. Понятно, что вскоре весь процесс достиг критической отметки и приложение упало.
Тогда мы навсегда уяснили следующие моменты:
* Устанавливать ПО при создании нового экземпляра долго, лучше отдать предпочтение неизменному (immutable) подходу и [Golden AMI](https://aws.amazon.com/blogs/awsmarketplace/announcing-the-golden-ami-pipeline/).
* В сложных ситуациях ответы на health-check'и ELB должны иметь приоритет — меньше всего вы хотите усложнить жизнь оставшимся экземплярам.
* Хорошо помогает локальное кэширование health-check'ов (даже на несколько секунд).
* В сложной ситуации не запускайте cron-задачи и другие некритические процессы — берегите ресурсы для самых важных задач.
* При автомасштабировании используйте меньшие по размеру экземпляры. Группа из 10 малых экземпляров лучше, чем из 4 больших; если один экземпляр упадет, в первом случае 10% трафика распределятся по 9 точкам, во втором — 25% трафика по трем точкам.
Итак, **можно ли это было предвидеть, а следовательно — предотвратить с помощью внедрения проблемы?**
**Да**, и несколькими способами.
Во-первых, имитацией высокой загрузки CPU с помощью таких инструментов, как [`stress-ng`](https://www.mankier.com/1/stress-ng) или [`cpuburn`](https://www.cpuburnin.com/):
```
❯ stress-ng --matrix 1 -t 60s
```
*stress-ng*
Во-вторых, перегрузкой экземпляра с помощью [`wrk`](https://github.com/wg/wrk) и других похожих утилит:
```
❯ wrk -t12 -c400 -d20s http://127.0.0.1/api/health
```
Эксперименты сравнительно простые, но могут дать неплохую пищу для размышлений без необходимости переживать стресс реального сбоя.
Однако **не останавливайтесь на достигнутом**. Попробуйте воспроизвести сбой в тестовой среде и проверить свой ответ на вопрос «**Можно ли это было предвидеть, а следовательно — предотвратить с помощью внедрения неисправности?**». Это мини хаос-эксперимент внутри хаос-эксперимента для проверки предположений, но начиная со сбоя.
*Это был сон, или все случилось на самом деле?*
Так что изучайте историю сбоев, анализируйте **COE**, тегируйте и классифицируйте их по «радиусу поражения» — или, точнее, по числу затронутых клиентов, — а затем ищите закономерности. Спрашивайте себя, можно ли это было предвидеть и предотвратить путем внедрения проблемы. Проверяйте свой ответ.
Затем переключайтесь на самые распространенные паттерны с наибольшим радиусом поражения.
2. Постройте карту зависимостей
-------------------------------
Выберите минутку, чтобы подумать о своем приложении. Есть ли четкая карта его зависимостей? Знаете ли вы, какое влияние они окажут в случае сбоя?
Если вы не очень хорошо знакомы с кодом своего приложения или оно стало слишком большим, может быть трудно понять, что делает код и каковы его зависимости. Понимание этих зависимостей и их возможного влияния на приложение и пользователей критически важно для представления о том, с чего начать хаос-инжиниринг: отправной точкой будет выступать компонент с наибольшим радиусом поражения.
Выявление и документирование зависимостей именуют «**построением карты зависимостей**» *(dependency mapping)*. Обычно оно проводится для приложений с обширной базой кода с использованием инструментов для профилирования кода *(code profiling)* и инструментирования *(instrumentation)*. Также можно проводить построение карты, отслеживая сетевой трафик.
При этом не все зависимости одинаковы (что еще сильнее усложняет процесс). Некоторые **критически важны**, другие — **второстепенны** *(по крайней мере теоретически, поскольку сбои часто возникают из-за проблем с зависимостями, которые считались некритическими)*.
Без критических зависимости сервис не может работать. Некритические зависимости «**не должны**» оказывать влияния на сервис в случае своего падения. Чтобы разобраться с зависимостями, необходимо иметь четкое представление об API, используемых приложением. Это может быть намного сложнее, чем кажется — по крайней мере, для крупных приложений.
Начните с перебора всех API. Выделите самые **значимые и критические**. Возьмите **зависимости** из репозитория кода, изучите **логи подключений**, затем просмотрите **документацию** (конечно, если она существует — иначе у вас еще б*о*льшие проблемы). Задействуйте инструменты для **профилирования и трассировки**, отфильтруйте внешние вызовы.
Можно воспользоваться программами вроде `netstat` — утилитой командной строки, которая выводит список всех сетевых подключений (активных сокетов) в системе. Например, чтобы вывести все текущие соединения, наберите:
```
❯ netstat -a | more
```
В AWS можно использовать [логи потока](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) (flow logs) VPC — метод, позволяющий собрать информацию об IP-трафике, идущем к сетевым интерфейсам в VPC или от них. Такие логи способны помочь и с другими задачами — например, с поиском ответа на вопрос, почему определенный трафик не достигает экземпляра.
Также можно использовать [AWS X-Ray](https://aws.amazon.com/xray/). X-Ray позволяет получить подробный, «конечный» *(end-to-end)* обзор запросов по мере их продвижения по приложению, а также строит карту базовых компонентов приложения. Очень удобно, если нужно выявить зависимости.
*Консоль AWS X-Ray*
Карта сетевых зависимостей — лишь частичное решение. Да, она показывает, какое приложение с каким связывается, но ведь есть и другие зависимости.
Многие приложения используют DNS для подключения к зависимостям, в то время как другие могут использовать механизм обнаружения сервисов или даже жестко прописанные IP-адреса в конфигурационных файлах (к примеру, в `/etc/hosts`).
Например, можно создать [DNS blackhole](https://en.wikipedia.org/wiki/DNS_sinkhole) с помощью `iptables` и посмотреть, что сломается. Для этого введите следующую команду:
```
❯ iptables -I OUTPUT -p udp --dport 53 -j REJECT -m comment --comment "Reject DNS"
```
*«Черная дыра» DNS*
Если в `/etc/hosts` или других конфигурационных файлах вы обнаружите IP-адреса, о которых ничего не знаете (да, к сожалению, и такое бывает), на выручку снова может прийти `iptables`. Скажем, вы обнаружили `8.8.8.8` и не знаете, что это адрес общедоступного DNS-сервера Google. С помощью `iptables` можно закрыть входящий и исходящий трафик к этому адресу с помощью следующих команд:
```
❯ iptables -A INPUT -s 8.8.8.8 -j DROP -m comment --comment "Reject from 8.8.8.8"
❯ iptables -A OUTPUT -d 8.8.8.8 -j DROP -m comment --comment "Reject to 8.8.8.8"
```
*Закрытие доступа*
Первое правило отбрасывает все пакеты с публичного DNS Google: `ping` работает, но пакеты не возвращаются. Второе правило отбрасывает все пакеты, исходящие из вашей системы в направлении публичного DNS Google — в ответ на `ping` получаем *Operation not permitted*.
*Примечание: в этом конкретном случае было бы лучше использовать `whois 8.8.8.8`, но это всего лишь пример.*
Можно забраться еще глубже в кроличью нору, поскольку все, что использует TCP и UDP, на самом деле зависит и от IP. В большинстве случаев IP завязан на ARP. Не стоит забывать и о firewall'ах…
*Выберешь красную пилюлю — останешься в Стране Чудес, и я покажу, насколько глубоко уходит кроличья нора»*
Более радикальный подход состоит в том, чтобы **отключать** машины одну за одной и смотреть, что сломалось… станьте «обезьяной хаоса». Конечно, многие production-системы не рассчитаны на подобную грубую атаку, но по крайней мере ее можно попробовать в тестовой среде.
Построение карты зависимостей — часто весьма долгое мероприятие. Недавно я разговаривал с клиентом, что потратил почти 2 года на разработку инструмента, который в полуавтоматическом режиме генерирует карты зависимостей для сотен микросервисов и команд.
Результат, однако, чрезвычайно интересен и полезен. Вы узнаете много нового о своей системе, ее зависимостях и операциях. Опять же, будьте терпеливы: наибольшее значение имеет само путешествие.
3. Остерегайтесь самонадеянности
--------------------------------
> «Кто о чем мечтает, тот в то и верит». — Демосфен
Вы когда-нибудь слышали об **эффекте сверхуверенности**?
Согласно Википедии, эффект сверхуверенности — это «когнитивное искажение, при котором уверенность человека в своих действиях и решениях значительно выше, чем объективная точность этих суждений, особенно когда уровень уверенности относительно высок».
*Основываясь на чутье и опыте...*
По своему опыту могу сказать, что это искажение — отличный намек на то, с чего следует начинать хаос-инжиниринг.
Остерегайтесь самоуверенного оператора:
> Чарли: «Эта штука не падала лет пять, все в норме!»
>
> Сбой: «Ждите… скоро буду!»
Предвзятость как последствие самоуверенности — вещь коварная и даже опасная из-за различных факторов, влияющих на нее. Это особенно справедливо, когда члены команды вложили душу в некую технологию или потратили кучу времени на «исправления».
Подвожу итоги
-------------
Поиски отправной точки для хаос-инжиниринга всегда приносят больше результатов, чем ожидалось, и команды, начинающие слишком быстро ломать все вокруг, упускают из виду более глобальную и интересную суть (хаос-)**инжиниринга** — творческое применение **научных методов** и **эмпирических доказательств** для проектирования, разработки, эксплуатации, обслуживания и совершенствования (программных) систем.
На этом вторая часть подходит к концу. Пожалуйста, пишите отзывы, делитесь мнениями или просто хлопайте в ладоши на [Medium](https://medium.com/@adhorn/chaos-engineering-part-2-b9c78a9f3dde). ~~В следующей части я **действительно** рассмотрю инструменты и методы по внедрению сбоев в системы. До тех пор — пока!~~ **ОБНОВЛЕНО** (19 декабря): Стал доступен [перевод третьей части](https://habr.com/ru/company/flant/blog/477994/).
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Chaos Engineering: искусство умышленного разрушения. Часть 1](https://habr.com/ru/company/flant/blog/460367/)» *(про концепцию chaos engineering и как он помогает находить/исправлять проблемы до того, как они приведут к сбоям production)*;
* «[Chaos Engineering: искусство умышленного разрушения. Часть 3](https://habr.com/ru/company/flant/blog/477994/)» *(практика chaos engineering с внесением неисправностей и существующими для этого инструментами)*;
* «[Как обеспечивается высокая доступность в Kubernetes](https://habr.com/ru/company/flant/blog/427283/)»;
* «[Мониторинг и Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/412901/)»;
* «[Эксперименты с kube-proxy и недоступностью узла в Kubernetes](https://habr.com/ru/company/flant/blog/359120/)». | https://habr.com/ru/post/465107/ | null | ru | null |
# Парсинг при помощи JAVA
##### Иванов Максим
Младший Java программист
#### Или рецепт по приготовлению своего салата «Простенький парсер»
Всем привет, данная статья является - маленьким туториалом, для примера были взяты XML данные с сайта [Центр Банка](https://cbr.ru/scripts/XML_daily.asp?date_req=23/01/2022.xml).
> **В статье будут использованы - Spring Boot, PostgreSQL и Hibernate.**
>
>
#### Ингредиенты:
1. Создание Spring Boot проект, проще всего это сделать через [Spring Initializr](https://start.spring.io/). (в качестве системы сборки будет использоваться [Gradle](https://gradle.org/install/)).
2. [PostgreSQL](https://www.postgresql.org/download/) (для комфортной работы, я использую - [DBeaver](https://dbeaver.io/download/)).
3. [Postman](https://www.postman.com/downloads/) - для отправки запросов на сервер.
Если возникнут сложности с воссозданием туториалаПрошу пишите в комментариях возникшие проблемы, на всякий случай - вот мой [git](https://github.com/RushianHaker/DataParsingProgect) и [ТГ](https://t.me/l_i_m_k_o_r_n)
#### Начинаем с чистки ингредиентов:
Первостепенно нужно настроить build.gradle со всеми зависимостями.
build.gradle
```
buildscript {
repositories {
mavenCentral()
}
}
plugins {
id 'org.springframework.boot' version '2.5.2'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.parsing'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'
configurations {
compileOnly {
extendsFrom annotationProcessor
}
}
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web:2.6.2'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5'
implementation 'org.postgresql:postgresql:42.3.1'
implementation 'org.projectlombok:lombok:1.18.22'
compileOnly 'org.projectlombok:lombok:1.18.22'
annotationProcessor 'org.projectlombok:lombok:1.18.22'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
test {
useJUnitPlatform()
}
```
Теперь настройки application.properties
application.properties
```
# connected to JDBC
# setup spring.datasource
spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.url=jdbc:postgresql://localhost:5432/change-me
spring.datasource.username=change-me
spring.datasource.password=change-me
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=60000
spring.datasource.hikari.maximum-pool-size=120
# setup hibernate
spring.jpa.show-sql=true
spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.proc.param_null_passing=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL94Dialect
```
Хорошо, после настроек нашего проекта, давайте обговорим его структуру:
Структура проектаПакеты:
* controller - обрабатывает запрос пользователя;
* model - описывает модель данных;
* repository - логика работы с БД;
* service - основная бизнес логика проекта.
#### Нарезаем овощи и смешиваем:
### Перед описанием моделей, посмотрим на фрагмент данных:
```
036
AUD
1
Австралийский доллар
55,1633
944
AZN
1
Азербайджанский манат
45,1385
826
GBP
1
Фунт стерлингов Соединенного королевства
103,9997
```
- Сначала опишем общую модель курса валют, так как по схеме XML видно, что у нас должен быть общий список элементов валют (ValCurs), внутри которого элементы (Valute)
CourseDto
```
@XmlRootElement(name = "ValCurs")
@XmlAccessorType(XmlAccessType.FIELD)
public class CourseDto implements Serializable {
@XmlElement(name = "Valute")
private List valute;
@XmlElement(name = "Date")
private LocalDate date;
public List getValute() {
return valute;
}
@Override
public String toString() {
return "CourseDto{" +
"valute=" + valute +
", date=" + date +
'}';
}
}
```
- Теперь опишем модель единичных элементов списка валют.
CourseDtoOnce
```
@Entity
@XmlRootElement(name = "Valute")
@XmlAccessorType(XmlAccessType.FIELD)
public class CourseDtoOnce implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@XmlElement(name = "NumCode")
private String numCode;
@XmlElement(name = "CharCode")
private String charCode;
@XmlElement(name = "Nominal")
private int nominal;
@XmlElement(name = "Name")
private String name;
@XmlElement(name = "Value")
@JsonIgnore
@Transient
private String _Value;
private double value;
public String get_Value() {
return _Value;
}
public void setValue(double value) {
this.value = value;
}
@Override
public String toString() {
return "\n" + name + " (" +
"numCode = " + numCode + ", " +
"charCode = " + charCode + ", " +
"nominal = " + nominal + ", " +
"value = " + value + ")";
}
}
```
#### Теперь для работы с БД, напишем repository
- Создадим интерфейс, который наследует от JpaRepository методы, для работы с записями в БД.
CourseEntityRepository
```
public interface CourseEntityRepository extends JpaRepository {
}
```
#### Переходим к созданию бизнес логики приложения
- CourseClient - работа с внешним ресурсом, обработка и выдача результата.
CourseClient
```
@Component
public class CourseClient {
public static final String URL = "https://cbr.ru/scripts/XML_daily.asp?date_req=23/01/2022.xml";
final RestTemplate restTemplate = new RestTemplate();
public List getCourses() {
CourseDto response = restTemplate.getForObject(URL, CourseDto.class);
if (response != null) {
response
.getValute()
.forEach(x -> {
x.setValue(Double.parseDouble(x.get\_Value().replace(",", ".")));
System.out.println(x);
});
return response.getValute();
}
return null;
}
}
```
- CourseService - бизнес логика проекта.
CourseService
```
@Service
@RequiredArgsConstructor
public class CourseService {
private final CourseEntityRepository courseEntityRepository;
private final CourseClient courseClient;
public List findCourseInfo(){
return courseEntityRepository.saveAll(courseClient.getCourses());
}
}
```
#### Теперь создадим путь, для обращения к сервису из вне
- Пишем контроллер, который используется, для получения списка сохраненных в БД записей
CourseParsingController
```
@RestController
@RequiredArgsConstructor
public class CourseParsingController {
private final CourseService courseService;
/**
* Возвращает список курсов валют
*
* @return список курсов валют
*/
@GetMapping(value = "/getCourse")
public String getListInformation() {
return courseService.findCourseInfo().toString();
}
}
```
#### В конце класс, который собственно и запускает все наше приложение
ParsingProjectApplication
```
@SpringBootApplication
public class ParsingProjectApplication {
public static void main(String[] args) {
SpringApplication.run(ParsingProjectApplication.class, args);
}
}
```
#### Мы сделали салат, теперь заправляем его
- Запускаем сервис:
Логи запуска сервиса
```
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.5.2)
2022-01-24 04:46:48.318 INFO 42654 --- [ main] com.ParsingProjectApplication : No active profile set, falling back to default profiles: default
2022-01-24 04:46:49.028 INFO 42654 --- [ main] .s.d.r.c.RepositoryConfigurationDelegate : Bootstrapping Spring Data JPA repositories in DEFAULT mode.
2022-01-24 04:46:49.174 INFO 42654 --- [ main] .s.d.r.c.RepositoryConfigurationDelegate : Finished Spring Data repository scanning in 142 ms. Found 1 JPA repository interfaces.
2022-01-24 04:46:49.455 INFO 42654 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port(s): 8080 (http)
2022-01-24 04:46:49.460 INFO 42654 --- [ main] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2022-01-24 04:46:49.460 INFO 42654 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet engine: [Apache Tomcat/9.0.48]
2022-01-24 04:46:49.514 INFO 42654 --- [ main] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2022-01-24 04:46:49.514 INFO 42654 --- [ main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 1158 ms
2022-01-24 04:46:49.677 INFO 42654 --- [ main] o.hibernate.jpa.internal.util.LogHelper : HHH000204: Processing PersistenceUnitInfo [name: default]
2022-01-24 04:46:49.696 INFO 42654 --- [ main] org.hibernate.Version : HHH000412: Hibernate ORM core version 5.4.32.Final
2022-01-24 04:46:49.746 INFO 42654 --- [ main] o.hibernate.annotations.common.Version : HCANN000001: Hibernate Commons Annotations {5.1.2.Final}
2022-01-24 04:46:49.790 WARN 42654 --- [ main] com.zaxxer.hikari.HikariConfig : HikariPool-1 - idleTimeout has been set but has no effect because the pool is operating as a fixed size pool.
2022-01-24 04:46:49.790 INFO 42654 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2022-01-24 04:46:49.951 INFO 42654 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2022-01-24 04:46:49.960 INFO 42654 --- [ main] org.hibernate.dialect.Dialect : HHH000400: Using dialect: org.hibernate.dialect.PostgreSQL94Dialect
Hibernate:
drop table if exists course_dto_once cascade
2022-01-24 04:46:50.236 WARN 42654 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : SQL Warning Code: 0, SQLState: 00000
2022-01-24 04:46:50.236 WARN 42654 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : table "course_dto_once" does not exist, skipping
Hibernate:
drop sequence if exists hibernate_sequence
2022-01-24 04:46:50.237 WARN 42654 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : SQL Warning Code: 0, SQLState: 00000
2022-01-24 04:46:50.237 WARN 42654 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : sequence "hibernate_sequence" does not exist, skipping
Hibernate: create sequence hibernate_sequence start 1 increment 1
Hibernate:
create table course_dto_once (
id int8 not null,
char_code varchar(255),
name varchar(255),
nominal int4 not null,
num_code varchar(255),
value float8 not null,
primary key (id)
)
2022-01-24 04:46:50.318 INFO 42654 --- [ main] o.h.e.t.j.p.i.JtaPlatformInitiator : HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
2022-01-24 04:46:50.322 INFO 42654 --- [ main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
2022-01-24 04:46:50.480 WARN 42654 --- [ main] JpaBaseConfiguration$JpaWebConfiguration : spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning
2022-01-24 04:46:50.661 INFO 42654 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''
2022-01-24 04:46:50.668 INFO 42654 --- [ main] com.ParsingProjectApplication : Started ParsingProjectApplication in 2.682 seconds (JVM running for 3.006)
```
- Запускаем DBeaver, после запуска приложения, создастся таблица с полями:
Автоматически создаваемая таблица- Запускаем Postman, прописываем в поле для url - <http://localhost:8080/getCourse>:
GETзапрос на url - http://localhost:8080/getCourse- Нажимаем синию кнопку "Send" и получаем в ответ данные о курсе валют, на 23/01/2022:
Курс валют на 23/01/2022 - Так же курсами валют заполнилась и БД:
Заполненная курсами валют БДЛоги сервиса, после отправки запроса
```
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.5.2)
2022-01-24 04:46:48.318 INFO 42654 --- [ main] com.ParsingProjectApplication : No active profile set, falling back to default profiles: default
2022-01-24 04:46:49.028 INFO 42654 --- [ main] .s.d.r.c.RepositoryConfigurationDelegate : Bootstrapping Spring Data JPA repositories in DEFAULT mode.
2022-01-24 04:46:49.174 INFO 42654 --- [ main] .s.d.r.c.RepositoryConfigurationDelegate : Finished Spring Data repository scanning in 142 ms. Found 1 JPA repository interfaces.
2022-01-24 04:46:49.455 INFO 42654 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port(s): 8080 (http)
2022-01-24 04:46:49.460 INFO 42654 --- [ main] o.apache.catalina.core.StandardService : Starting service [Tomcat]
2022-01-24 04:46:49.460 INFO 42654 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet engine: [Apache Tomcat/9.0.48]
2022-01-24 04:46:49.514 INFO 42654 --- [ main] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2022-01-24 04:46:49.514 INFO 42654 --- [ main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 1158 ms
2022-01-24 04:46:49.677 INFO 42654 --- [ main] o.hibernate.jpa.internal.util.LogHelper : HHH000204: Processing PersistenceUnitInfo [name: default]
2022-01-24 04:46:49.696 INFO 42654 --- [ main] org.hibernate.Version : HHH000412: Hibernate ORM core version 5.4.32.Final
2022-01-24 04:46:49.746 INFO 42654 --- [ main] o.hibernate.annotations.common.Version : HCANN000001: Hibernate Commons Annotations {5.1.2.Final}
2022-01-24 04:46:49.790 WARN 42654 --- [ main] com.zaxxer.hikari.HikariConfig : HikariPool-1 - idleTimeout has been set but has no effect because the pool is operating as a fixed size pool.
2022-01-24 04:46:49.790 INFO 42654 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2022-01-24 04:46:49.951 INFO 42654 --- [ main] com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2022-01-24 04:46:49.960 INFO 42654 --- [ main] org.hibernate.dialect.Dialect : HHH000400: Using dialect: org.hibernate.dialect.PostgreSQL94Dialect
Hibernate:
drop table if exists course_dto_once cascade
2022-01-24 04:46:50.236 WARN 42654 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : SQL Warning Code: 0, SQLState: 00000
2022-01-24 04:46:50.236 WARN 42654 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : table "course_dto_once" does not exist, skipping
Hibernate:
drop sequence if exists hibernate_sequence
2022-01-24 04:46:50.237 WARN 42654 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : SQL Warning Code: 0, SQLState: 00000
2022-01-24 04:46:50.237 WARN 42654 --- [ main] o.h.engine.jdbc.spi.SqlExceptionHelper : sequence "hibernate_sequence" does not exist, skipping
Hibernate: create sequence hibernate_sequence start 1 increment 1
Hibernate:
create table course_dto_once (
id int8 not null,
char_code varchar(255),
name varchar(255),
nominal int4 not null,
num_code varchar(255),
value float8 not null,
primary key (id)
)
2022-01-24 04:46:50.318 INFO 42654 --- [ main] o.h.e.t.j.p.i.JtaPlatformInitiator : HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
2022-01-24 04:46:50.322 INFO 42654 --- [ main] j.LocalContainerEntityManagerFactoryBean : Initialized JPA EntityManagerFactory for persistence unit 'default'
2022-01-24 04:46:50.480 WARN 42654 --- [ main] JpaBaseConfiguration$JpaWebConfiguration : spring.jpa.open-in-view is enabled by default. Therefore, database queries may be performed during view rendering. Explicitly configure spring.jpa.open-in-view to disable this warning
2022-01-24 04:46:50.661 INFO 42654 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''
2022-01-24 04:46:50.668 INFO 42654 --- [ main] com.ParsingProjectApplication : Started ParsingProjectApplication in 2.682 seconds (JVM running for 3.006)
2022-01-24 04:52:00.787 INFO 42654 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring DispatcherServlet 'dispatcherServlet'
2022-01-24 04:52:00.788 INFO 42654 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet : Initializing Servlet 'dispatcherServlet'
2022-01-24 04:52:00.788 INFO 42654 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet : Completed initialization in 0 ms
Австралийский доллар (numCode = 036, charCode = AUD, nominal = 1, value = 55.1633)
Азербайджанский манат (numCode = 944, charCode = AZN, nominal = 1, value = 45.1385)
Фунт стерлингов Соединенного королевства (numCode = 826, charCode = GBP, nominal = 1, value = 103.9997)
Армянских драмов (numCode = 051, charCode = AMD, nominal = 100, value = 15.9539)
Белорусский рубль (numCode = 933, charCode = BYN, nominal = 1, value = 29.8058)
Болгарский лев (numCode = 975, charCode = BGN, nominal = 1, value = 44.4607)
Бразильский реал (numCode = 986, charCode = BRL, nominal = 1, value = 14.1505)
Венгерских форинтов (numCode = 348, charCode = HUF, nominal = 100, value = 24.35)
Гонконгских долларов (numCode = 344, charCode = HKD, nominal = 10, value = 98.4699)
Датская крона (numCode = 208, charCode = DKK, nominal = 1, value = 11.6842)
Доллар США (numCode = 840, charCode = USD, nominal = 1, value = 76.6903)
Евро (numCode = 978, charCode = EUR, nominal = 1, value = 86.9054)
Индийских рупий (numCode = 356, charCode = INR, nominal = 10, value = 10.2985)
Казахстанских тенге (numCode = 398, charCode = KZT, nominal = 100, value = 17.5815)
Канадский доллар (numCode = 124, charCode = CAD, nominal = 1, value = 61.2102)
Киргизских сомов (numCode = 417, charCode = KGS, nominal = 100, value = 90.427)
Китайский юань (numCode = 156, charCode = CNY, nominal = 1, value = 12.0972)
Молдавских леев (numCode = 498, charCode = MDL, nominal = 10, value = 42.4055)
Норвежских крон (numCode = 578, charCode = NOK, nominal = 10, value = 86.796)
Польский злотый (numCode = 985, charCode = PLN, nominal = 1, value = 19.2264)
Румынский лей (numCode = 946, charCode = RON, nominal = 1, value = 17.5847)
СДР (специальные права заимствования) (numCode = 960, charCode = XDR, nominal = 1, value = 107.5497)
Сингапурский доллар (numCode = 702, charCode = SGD, nominal = 1, value = 56.9722)
Таджикских сомони (numCode = 972, charCode = TJS, nominal = 10, value = 67.8976)
Турецких лир (numCode = 949, charCode = TRY, nominal = 10, value = 57.1544)
Новый туркменский манат (numCode = 934, charCode = TMT, nominal = 1, value = 21.9429)
Узбекских сумов (numCode = 860, charCode = UZS, nominal = 10000, value = 70.7797)
Украинских гривен (numCode = 980, charCode = UAH, nominal = 10, value = 27.0692)
Чешских крон (numCode = 203, charCode = CZK, nominal = 10, value = 35.819)
Шведских крон (numCode = 752, charCode = SEK, nominal = 10, value = 83.537)
Швейцарский франк (numCode = 756, charCode = CHF, nominal = 1, value = 83.8787)
Южноафриканских рэндов (numCode = 710, charCode = ZAR, nominal = 10, value = 50.6156)
Вон Республики Корея (numCode = 410, charCode = KRW, nominal = 1000, value = 64.3418)
Японских иен (numCode = 392, charCode = JPY, nominal = 100, value = 67.3165)
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
select
nextval ('hibernate_sequence')
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
Hibernate:
insert
into
course_dto_once
(char_code, name, nominal, num_code, value, id)
values
(?, ?, ?, ?, ?, ?)
```
> Вот и все, надеюсь, что у всех получилось повторить туториал с первого
> раза, в будущем будет еще много интересного, всем спасибо.
>
> | https://habr.com/ru/post/656575/ | null | ru | null |
# Тестирование СУБД: 10 лет опыта
Меня зовут Сергей Бронников, я работаю в команде Tarantool. Когда я только присоединился к ней, то вёл для себя заметки по мере погружения в разработку. Эти заметки я решил переработать в статью. Она может быть интересна тестировщикам в проектах на C/C++ или пользователям Tarantool, которые хотят узнать, сколько мы усилий прикладываем к тому, чтобы снизить вероятность появления проблем в новых версиях.
Популярной статьей такого рода является [описание тестирования библиотеки](https://www.sqlite.org/testing.html) SQLite за авторством Ричарда Хиппа. Но у SQLite есть специфика: их инструменты тяжело переиспользовать в других проектах. Это следствие того, что у команды разработчиков SQLite есть [обязательства](https://www.sqlite.org/lts.html) поддерживать библиотеку как минимум до 2050 года, и для сокращения внешних зависимостей они все инструменты пишут сами с нуля (например, тест-раннер, инструмент для мутационного тестирования, Fossil SCM). У нас таких требований нет, поэтому в выборе инструментов мы не ограничены и пользуемся всем, что приносит пользу. И если вас что-то заинтересует, то вы достаточно легко сможете это принести в свой проект на C/C++. Если я вас заинтересовал — велкам под кат.
Как известно, тестирование — это часть разработки. Я расскажу о нашем подходе к разработке Tarantool, помогающем выловить до финального релиза подавляющее большинство багов. У нас тестирование действительно неотделимо от самой разработки, и каждый в команде отвечает за качество. Всё уместить в одну статью не получилось, поэтому в самом конце я привёл ссылки на другие статьи, которые могут её дополнить.
Ядерная часть Tarantool состоит из кода, который полностью написан нами, внешних компонентов и библиотек. Некоторые, впрочем, тоже написаны нами. Это важно, потому что большую часть сторонних компонентов мы тестируем только косвенно, во время интеграционного тестирования.
В большинстве случаев качество внешних компонентов на хорошем уровне, но было исключение — библиотека libcurl. При её использовании иногда случались memory corruptions. Поэтому из runtime-зависимости libcurl стал git-модулем в нашем репозитории.
За поддержку языка Lua отвечает LuaJIT, который включает в себя как среду исполнения языка, так и трассирующий JIT компилятор. Наша версия LuaJIT уже давно отличается от ванильного [набором патчей](https://github.com/tarantool/tarantool/wiki/Vanilla-LuaJIT-sync-status), они добавляют как фичи, например профилировщик, так и новые тесты. Поэтому мы тщательно тестируем свой форк, чтобы не допустить регрессий. Хотя исходный код LuaJIT открыт и доступен под свободной лицензией, однако он не включает в себя регрессионные тесты. Поэтому мы собрали свой регрессионный тестовый набор из [тестов для реализации Lua от PUC Rio](https://www.lua.org/tests/), [набора тестов](https://fperrad.frama.io/lua-Harness/) от Франсуа Перра (François Perrad), тестов для других форков LuaJIT, и, конечно же, дополнили нашими собственными тестами.
Из других внешних библиотек это:
* [MsgPuck](https://github.com/rtsisyk/msgpuck) для сериализации данных в формате msgpack;
* libcoro для реализации файберов;
* libev для асинхронного ввода-вывода;
* c-ares для асинхронного разрешения DNS-имён;
* libcurl для работы с протоколом HTTP;
* icu4c для поддержки Unicode;
* OpenSSL, libunwind и zstd для сжатия данных;
* [small](https://github.com/tarantool/small) — наш набор специализированных аллокаторов памяти;
* lua-cjson для работы с JSON, lua-yaml, luarocks, xxHash, PMurHash и других.
Основная часть проекта написана на C, небольшие части на C++ (в сумме 36 KLOC) и меньшая часть на Lua (14 KLOC).
Подробный вывод статистики в cloc
```
767 text files.
758 unique files.
82 files ignored.
github.com/AlDanial/cloc v 1.82 T=0.78 s (881.9 files/s, 407614.4 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
C 274 12649 40673 123470
C/C++ Header 287 7467 36555 40328
C++ 38 2627 6923 24269
Lua 41 1799 2059 14384
yacc 1 191 342 1359
CMake 33 192 213 1213
...
-------------------------------------------------------------------------------
SUM: 688 25079 86968 205933
-------------------------------------------------------------------------------
```
Остальные языки относятся к инфраструктуре проекта или тестам: CMake, Make, Python (часть старых тестов написана на нём, но сейчас мы его не используем для написания тестов).
Подробный вывод cloc о распределении языков в тестах
```
2076 text files.
2006 unique files.
851 files ignored.
github.com/AlDanial/cloc v 1.82 T=2.70 s (455.5 files/s, 116365.0 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Lua 996 31528 46858 194972
C 89 2536 2520 14937
C++ 21 698 355 4990
Python 57 1131 1209 4500
C/C++ Header 11 346 629 1939
SQL 4 161 120 1174
...
-------------------------------------------------------------------------------
SUM: 1231 37120 51998 225336
-------------------------------------------------------------------------------
```
Из такого распределения используемых языков программирования следует один из основных акцентов тестирования: выявление проблем, присущих языкам с ручным управлением памятью (stack-overflow, heap-buffer-overflow, use-after-free и других). Наша система непрерывной интеграции неплохо с этим справляется. В следующей части расскажу о её устройстве.
### Непрерывная интеграция
В разработке у нас находится несколько веток Tarantool: основная ветка (master) и по одной ветке для каждой версии (1.10.x, 2.1.x, 2.2.x и т.д.). Новая функциональность появляется в новых минорных версиях, а bug fix’ы появляются во всех ветках. При слиянии в каждой из веток проходит полный цикл регрессионного тестирования с разными компиляторами, с разными опциями сборки, сборка пакетов под разные платформы и много чего ещё, об этом подробнее ниже. Всё это происходит автоматически в едином конвейере. Патчи попадают в основную ветку только после успешного прохождения всего конвейера. Пока что мы добавляем патчи в основную ветку вручную, но движемся в сторону автоматизации.
Сейчас у нас примерно 870 интеграционных тестов, и при тестировании в 5 потоков они проходят за 10 минут. Это, вроде бы, не так много, но тестирование в CI параметризовано разными семействами и версиями операционных систем, архитектурами, разными компиляторами и их опциями, поэтому общее время тестирования может достигать получаса.
Мы запускаем тесты на большом наборе ОС:
* шесть версий Ubuntu;
* три версии Debian;
* пять версий Fedora;
* две версии CentOS;
* две версии OpenSUSE и FreeBSD;
* две версии macOS.
Некоторые конфигурации ещё параметризуются версиями и опциями компилятора. Некоторые платформы имеют номинальный статус поддержки, например, macOS; их в основном используют разработчики. Другие, типа FreeBSD, активно тестируются, но случаи использования FreeBSD-порта Tarantool в production мне неизвестны. Третьи, как, например, Linux, широко используются для промышленной эксплуатации Tarantool нашими клиентами и пользователями.
Поэтому вторым уделяется больше внимания при разработке. Запуск тестов на разных операционных системах влияет на качество в проекте. Разные семейства ОС имеют разные аллокаторы памяти, могут иметь разные реализации libc, и редко, но такие отличия тоже позволяют находить баги.
Основная архитектура для нас это amd64, недавно добавили поддержку arm64 и она тоже представлена в CI. Запуск тестов на процессорах разных архитектур позволяет сделать код более портируемым за счёт разделения платформозависимого и платформонезависимого кода. Так можно выявлять баги, связанные с другим порядком байтов (big-endian vs little-endian), разной скоростью выполнения инструкций, разными результатами математических функций или с такими редкостями, как «минус ноль». Ещё такое тестирование облегчает портирование кода на новую архитектуру, если появится такая необходимость. Сильнее всего привязан к платформе LuaJIT, в нём используется много ассемблера и из кода на Lua он сразу генерирует машинный код.
Когда-то давно, когда не было такого разнообразия облачных CI-систем, мы, как и многие проекты, использовали Jenkins. Потом появился Travis-CI, интегрированный с GitHub, мы переехали на него. Наша матрица тестирования сильно выросла и бесплатная версия Travis-CI не позволяла подключать свои серверы, поэтому переехали на Gitlab CI. Из-за проблем с интеграцией GitHub PR’ов мы, как только появился GitHub Actions, начали плавный переезд на него, и теперь во всех проектах (а у нас в GitHub-организации их несколько сотен) пользуемся только им.
Можно сказать, что Github это наша платформа для всего цикла разработки: планирования задач, хранения кода, проверки новых изменений — полностью тестируем там. Для этого мы используем как свои физические серверы или виртуальные машины в облаке VK Cloud Solutions, так и виртуальные машины, которые предоставляет Github Actions. GitHub не лишён недостатков: иногда он недоступен, иногда происходят глюки, но у него хорошее соотношение цена-качество.
*Если хотите разрабатывать переносимый код, то нужно его тестировать на разных операционных системах и архитектурах.*
### Инспекция кода
Как во всех нормальных проектах с хорошей культурой разработки, все патчи проходят тщательную проверку двумя другими разработчиками. Процедура проверки описана в [открытом документе](https://github.com/tarantool/tarantool/wiki/Code-review-procedure). Во многом он описывает оформление патчей и самопроверку изменений перед отправкой на анализ. Не буду пересказывать этот документ, расскажу только о моментах, которые затрагивают тестирование:
* для патчей, которые исправляют баг, должен добавляться тест, который воспроизводит проблему;
* для патчей, которые добавляют новую функциональность — как минимум один тест, а лучше много тестов, покрывающих эту функциональность;
* тест не должен успешно проходить без патча;
* тест не должен быть flaky, то есть после нескольких запусков показывать и успешный, и неуспешный результат;
* тест не должен быть медленным, таким образом мы сохраняем небольшую длительность тестирования. Долгие тесты запускаются с отдельной опцией тест-раннеру.
*Инспекция кода позволяет проверять изменения ещё одной парой глаз.*
### Статический и динамический анализ
Статический анализ мы используем для контроля общего стиля программирования и для поиска ошибок. Оформление кода должно соответствовать руководствам по стилю Lua, Python и С. [Руководство по стилю для С](https://www.tarantool.io/en/doc/latest/dev_guide/c_style_guide/) во многом повторяет руководство по стилю ядра Linux, а [руководство по стилю для кода на Lua](https://www.tarantool.io/en/doc/latest/dev_guide/lua_style_guide/) следует стилю по умолчанию в luacheck, за исключением некоторых предупреждений, которые мы обычно выключаем. Всё это позволяет содержать код в едином стиле и улучшает удобочитаемость.
В сборочных файлах CMake мы используем флаги компиляторов, которые включают дополнительные проверки во время сборки, и следуем правилу «чистой» сборки, когда в выводе компилятора нет никаких необработанных предупреждений. Помимо статического анализа в самих компиляторах мы используем статический анализ в [Coverity](https://scan.coverity.com/projects/tarantool-tarantool). Один раз использовали PVS-Studio, и он нашёл несколько некритичных ошибок в [самом Tarantool](https://github.com/tarantool/tarantool-c/issues/50) и [коннекторе tarantool-c](https://github.com/tarantool/tarantool/issues/2035). Ещё эпизодически использовали cppcheck, но не то чтобы он приносил много багов.
В кодовой базе Tarantool много Lua-кода, и когда мы решили исправить все предупреждения, которые он нашёл, то большинство их было о нарушении стиля программирования, и только четыре настоящих ошибки в основном коде и одна ошибка в коде тестов. Так что, если вы пишете на Lua, то не пренебрегайте luacheck и пользуйтесь им с самого начала.
Все новые изменения тестируются на сборках с включенными динамическими анализаторами для выявления проблем с памятью в C/C++ (Address Sanitizer), неопределённого поведения в C/C++ (UndefinedBehavior Sanitizer). Так как эти анализаторы могут влиять на производительность приложения, то по умолчанию флаги, которые их включают, выключены. Address Sanitizer хорошо себя показывает в CI, но для использования в канареечных сборках у него всё-таки большой overhead. Я пробовал пользоваться ночной сборкой Firefox, когда Mozilla стала включать в них ASAN, и комфортно им пользоваться было невозможно. Что говорить о СУБД с высокими требованиями к скорости. Но с GWP-ASAN этот [overhead меньше](https://llvm.org/docs/GwpAsan.html#gwp-asan-vs-asan), и мы [думаем](https://github.com/tarantool/tarantool/issues/5696), как его применить в пакетах с промежуточными сборками.
Если санитайзеры выявляют проблемы на уровне кода, то assert’ы, повсеместно используемые в нашем коде, выявляют проблемы нарушения инвариантов в функциональности. Технически это [макрос](https://en.cppreference.com/w/cpp/error/assert), который является частью стандартной библиотеки Си. `assert()` проверяет переданное выражение и завершает выполнение, если результат равен нулю. Всего около 5 000 таких проверок, они всегда включены только в отладочной сборке и выключены в релизных.
Сборочная система поддерживает и Valgrind, но выполнение кода под ним гораздо медленнее, чем с санитайзерами, поэтому в CI эта сборка не тестируется.
### Функциональные регрессионные тесты
Так как интерпретатор Lua встроен в Tarantool и интерфейс к СУБД реализован с помощью Lua API, то использование Lua для тестов выглядит логичным следствием. Большая часть наших регрессионных тестов написана на Lua с использованием встроенных модулей Tarantool. Один из них — [модуль TAP](https://www.tarantool.io/en/doc/latest/reference/reference_lua/tap/) для тестирования кода на Lua. Он реализует набор примитивов для проверок в коде и структурирования тестов. Удобно, что есть некоторый минимум, которого достаточно для тестирования приложений на Lua. Многие модули или приложения, которые мы делаем, только этот модуль для тестирования и используют. Как очевидно из названия, он позволяет выводить результаты в формате [TAP (Test Anything Protocol)](https://testanything.org/); пожалуй, это самый старый формат для тестовой отчётности. Часть тестов параметризованные (например, выполняются с двумя движками), и если учитывать тесты в разных конфигурациях, то их количество вырастает в полтора раза.
Большая часть функциональности Tarantool доступна с помощью Lua API, а если и нет, то можно получить к ней доступ с помощью FFI. FFI удобен в использовании, когда функция на C не должна быть частью Lua API, но нужна для теста. Главное, чтобы она не была объявлена как static. Пример использования С-кода в Lua с помощью FFI (правда, лаконично?):
```
local ffi = require "ffi"
ffi.cdef [[
int printf(const char *fmt, ...);
]]
ffi.C.printf("Hello %s!", "world")
```
Для некоторых частей Tarantool, таких как [самодостаточные библиотеки](https://github.com/tarantool/tarantool/tree/master/src/lib) raft, http\_parser, csv, msgpuck, swim, uuid, vclock и т. д., написаны [модульн](https://github.com/tarantool/tarantool/tree/master/test/unit)ые тесты. Для их написания используется header-only библиотека на С в стиле TAP-тестов.
Для запуска тестов мы используем собственный инструмент — [test-run.py](https://github.com/tarantool/test-run). Сейчас кажется спорным писать свой тест-раннер с нуля, но он уже есть и мы его поддерживаем. В проекте есть разные типы тестов: модульные написаны на С и запускаются как бинари, и, как и в случае c TAP тестами, *test-run.py* для них анализирует успешность выполнения тестовых сценариев по выводу в TAP-формате:
```
TAP version 13
1..20
ok 1 — trigger is fired
ok 2 — is not deleted
ok 3 — ctx.member is set
ok 4 — ctx.events is set
ok 5 — self payload is updated
ok 6 — self is set as a member
ok 7 — both version and payload events are presented
ok 8 — suspicion fired a trigger
ok 9 — status suspected
ok 10 — death fired a trigger
ok 11 — status dead
ok 12 — drop fired a trigger
ok 13 — status dropped
ok 14 — dropped member is not presented in the member table
ok 15 — but is in the event context
ok 16 — yielding trigger is fired
ok 17 — non-yielding still is not
ok 18 — trigger is not deleted until all currently sleeping triggers are finished
```
Часть тестов сравнивает фактический вывод теста с эталонным: вывод нового теста сохраняют в файл и при дальнейших запусках сравнивают с фактическим. Такой подход, например, популярен для SQL-тестов (что в [MySQL](https://dev.mysql.com/doc/dev/mysql-server/latest/PAGE_DEALING_OUTPUT.html)), что в [PostgreSQL](https://www.postgresql.org/docs/12/regress-variant.html)): достаточно написать нужные конструкции на SQL, выполнить, убедиться, что вывод корректный, и сохранить в файл. Надо только убедиться, что ввод получается всегда детерминированный, иначе добавите себе flaky-тестов. Вывод может зависеть от установленной локали в системе (поможет *NO\_LOCALE=1*), от сообщений об ошибках, от времени или даты в выводе и т.д.
Такой подход у нас используется в тестах для поддержки SQL или репликации, потому что он удобен для отладки кода: можно вставлять тесты прямо в консоль и переключаться между экземплярами. Можно в интерактивном режиме экспериментировать, а потом этот код использовать как сниппет для тикета или сделать из него тест.
test-run.py позволяет нам запускать все типы тестов однообразно с формированием общего отчёта.
Для тестирования проектов на Lua у нас есть отдельный фреймворк luatest. Изначально это [форк](https://github.com/tarantool/luatest/commit/101f4088a136eb025cd6090b6c55bd8dd70c67c2) другого хорошего фреймворка [luaunit](https://github.com/bluebird75/luaunit). Форк позволил нам теснее интегрировать его с Tarantool (например, добавить специфичные фикстуры) и добавить много новых фич (интеграция с luacov, поддержка статуса XFail и др.) без зависимости от проекта luaunit.
Интересна история появления тестов для поддержки SQL в Tarantool. Мы взяли за основу часть кода SQLite, а именно парсер SQL-запросов и компилятор в байт-код с помощью [VDBE](https://www.sqlite.org/opcode.html). Одной из причин этого было близкое к 100 % покрытие тестами кода SQLite. Только вот тесты были написаны на языке TCL, а мы его совсем не используем. Чтобы портировать тесты, написанные на TCL, мы написали [транслятор с TCL на Lua](https://github.com//mejedi/tcl2lua) и после причёсывания получившегося кода [импортировали их в кодовую базу](https://github.com/tarantool/tarantool/tree/master/test/sql-tap). Этими тестами пользуемся до сих пор и по мере необходимости добавляем новые.
Отказоустойчивость — одно из требований к серверному ПО. Поэтому во многих тестах у нас [используется внедрение сбоев (error injections)](https://github.com/tarantool/tarantool/wiki/Error-injections) на уровне самого кода Tarantool. Для этого в исходном коде есть набор макросов и интерфейс в Lua API для включения. К примеру, нам нужно добавить сбой, который будет эмулировать задержку при записи в WAL. Добавляем ещё одну запись в массив *ERRINJ\_LIST* в src/lib/core/errinj.h:
```
--- a/src/lib/core/errinj.h
+++ b/src/lib/core/errinj.h
@@ -151,7 +151,6 @@ struct errinj {
_(ERRINJ_VY_TASK_COMPLETE, ERRINJ_BOOL, {.bparam = false}) \
_(ERRINJ_VY_WRITE_ITERATOR_START_FAIL, ERRINJ_BOOL, {.bparam = false})\
_(ERRINJ_WAL_BREAK_LSN, ERRINJ_INT, {.iparam = -1}) \
+ _(ERRINJ_WAL_DELAY, ERRINJ_BOOL, {.bparam = false}) \
_(ERRINJ_WAL_DELAY_COUNTDOWN, ERRINJ_INT, {.iparam = -1}) \
_(ERRINJ_WAL_FALLOCATE, ERRINJ_INT, {.iparam = 0}) \
_(ERRINJ_WAL_IO, ERRINJ_BOOL, {.bparam = false}) \
```
и добавляем этот сбой в код, который отвечает за запись операции в WAL:
```
--- a/src/box/wal.c
+++ b/src/box/wal.c
@@ -670,7 +670,6 @@ wal_begin_checkpoint_f(struct cbus_call_msg *data)
}
vclock_copy(&msg->vclock, &writer->vclock);
msg->wal_size = writer->checkpoint_wal_size;
+ ERROR_INJECT_SLEEP(ERRINJ_WAL_DELAY);
return 0;
}
```
После этого можно включить задержку записи в журнал в отладочной сборке с помощью Lua-функции:
```
$ tarantool
Tarantool 2.8.0-104-ga801f9f35
type 'help' for interactive help
tarantool> box.error.injection.get('ERRINJ_WAL_DELAY')
---
- false
...
tarantool> box.error.injection.set('ERRINJ_WAL_DELAY', true)
---
- true
...
```
Всего добавили 90 сбоев в разные части Tarantool, и с каждым из них выполняется как минимум один функциональный тест.
### Интеграционное тестирование с экосистемой
Экосистема Tarantool состоит из большого количества коннекторов для разных языков программирования, вспомогательных библиотек для реализации популярных архитектурных паттернов (например, [кеш](https://github.com/tarantool/expirationd) или [персистентная очередь](https://github.com/tarantool/queue)). Помимо этого есть продукты, написанные на Lua с использованием функциональности Tarantool: Tarantool DataGrid и Tarantool Cartridge. Мы дополнительно тестируем предрелизные версии Tarantool с этими модулями и продуктами для проверки обратной совместимости.
### Рандомизированное тестирование
Про часть наших тестов я хочу написать отдельно, потому что они отличаются от обычных тестов тем, что данные в них генерируются автоматически и случайным образом. В обычном регрессионном наборе таких тестов нет, они запускаются отдельно.
Ядро Tarantool написано, в основном, на С, и даже при аккуратной разработке трудно избежать проблем с управлением памятью: use-after-free, heap buffer overflow, NULL pointer dereference. Их наличие крайне нежелательно для серверного ПО. К счастью, развитие динамического анализа и технологий фаззинг-тестирования в последнее время позволяют снизить количество этих неприятностей в проекте.
Выше я говорил, что Tarantool использует сторонние библиотеки. Многие из них уже применяют фаззинг-тестирование: проекты curl, c-ares, zstd и openssl регулярно тестируются в инфраструктуре [OSS Fuzz](https://google.github.io/oss-fuzz/). В коде Tarantool много мест, где используется код для синтаксического разбора (например, SQL или парсинг HTTP-запросов) или разбора структур MsgPack. Такой код может быть уязвим для багов, связанных с управлением памятью. К счастью, фаззинг-тесты хорошо выявляют такие проблемы. Для Tarantool тоже [есть интеграция](https://github.com/google/oss-fuzz/tree/master/projects/tarantool) с OSS Fuzz, но тестов пока не очень много и мы нашли только один баг в библиотеке http\_parser. Возможно, со временем количество таких тестов будет увеличиваться, для желающих добавить новый есть [подробная инструкция](https://github.com/tarantool/tarantool/wiki/Fuzzing).
В 2020 году мы добавили поддержку синхронной репликации и MVCC. Появился запрос на тестирование этой функциональности и мы решили [часть тестов](https://github.com/tarantool/jepsen.tarantool) сделать на основе фреймворка Jepsen. Консистентность проверяем с помощью анализа истории транзакций. Но рассказ про тестирование с помощью Jepsen вполне потянет на отдельную статью, поэтому об этом в следующий раз.
### Нагрузочное тестирование и тестирование производительности
Одна из фич, из-за которых выбирают Tarantool, это высокая производительность. Было бы странно не тестировать её. У нас есть неформальный критерий — 1 миллион операций вставки кортежей в секунду на обычном железе. Каждый может запустить его на своей машине и получить 1 Mops на Tarantool своими собственными руками. Вот такой просто [сниппет](https://gist.github.com/sergos/c2dae39bf1ac47519356de23601ea7f4) на Lua может быть неплохим вариантом бенчмарка для запуска с синхронной репликацией:
```
sergeyb@pony:~/sources$ tarantool relay-1mops.lua 2
making 1000000 operations, 10 operations per txn using 50 fibers
starting 1 replicas
master done 1000009 ops in time: 1.156930, cpu: 2.701883
master speed 864363 ops/sec
replicas done 1000009 ops in time: 3.263066, cpu: 4.839174
replicas speed 306463 ops/sec
sergeyb@pony:~/sources$
```
Для тестирования производительности мы запускаем и стандартные бенчмарки: популярные [YCSB](https://github.com/brianfrankcooper/YCSB) (Yahoo! Cloud Serving Benchmark), [nosqlbench](https://github.com/nosqlbench/nosqlbench), linkbench, sysbench, TPC-H и TPC-C. А также [cbench](https://github.com/tarantool/cbench), наш собственный бенчмарк для Tarantool API. В нём примитивные операции написаны на С, а сценарии описываются на Lua.
### Метрики
Для оценки покрытия кода регрессионными тестами мы собираем информацию о покрытии кода. Сейчас у нас покрыто 83 % всех строк и 51 % всех веток кода, это неплохие показатели. Для визуализации покрытых участков используем [Coveralls](https://coveralls.io/github/tarantool/tarantool?branch=master). В случае сбора информации о покрытии кода на C/C++ ничего нового — инструментирование кода с опцией *-coverage*, запуск тестов и формирование отчёта с помощью gcov и lcov. А вот в случае Lua ситуация чуть хуже: здесь примитивный профилировщик, и luacov предоставляет информацию только о покрытии строк. Это немного расстраивает.
### Релизный чеклист
Выпуск каждой новой версии сопряжён с ворохом разнообразных задач, за которые отвечают разные команды: тегирование релиза в репозитории, публикация пакетов со сборками, публикация документации на сайте, проверка результатов функционального тестирования и производительности, проверка открытых багов и триаж на следующий milestone, и т.д. Выпуск новой версии легко превратить в хаос или забыть о каком-то из шагов. Чтобы такого не случилось, мы описали процесс выпуска в виде чеклиста и следуем ему перед выпуском новой версии.
### Заключение
Как говорил Козьма Прутков, «Нет предела совершенству». Со временем совершенствуются процессы и технологии для выявления багов, баги становятся сложнее и заковыристее, и чем сложнее и изощреннее система тестирования и обеспечения качества, тем меньше багов доходит до пользователя.
### Полезные ссылки
* [Видеозапись](https://www.youtube.com/watch?v=yU5QNKpATxk) и [слайды](http://www.inf.puc-rio.br/~roberto/talks/testingLua.pdf) доклада Роберто Иерузалимски о тестировании интерпретатора Lua (рекомендую!).
* [How SQLite Is Tested](https://www.sqlite.org/testing.html) — популярная статья Ричарда Хиппа о том, как тестируется библиотека SQLite.
* [The Untold Story of SQLite With Richard Hipp](https://corecursive.com/066-sqlite-with-richard-hipp/) — интервью с Ричардом Хиппом, в котором он, в числе прочего, рассказывает про тестирование SQLite.
* [Как я сократил код для нагрузочного тестирования в три раза](https://habr.com/ru/company/mailru/blog/563446/) — статья от коллег про успешное использование k6 для нагрузочного тестирования Tarantool.
* [Кто такая эта Ваша Pandora и при чем здесь Tarantool](https://habr.com/ru/post/517488/) — статья от коллег про тестирование производительности в проектах, построенных на основе Tarantool (спойлер — с помощью Pandora).
* Про библиотеку SMALL мой коллега написал подробную статью [— Работа с памятью в Tarantool: Small — Specialized Memory ALLocators](https://habr.com/ru/company/mailru/blog/525484/).
* [Как мы работаем над стабильностью нашей реализации Lua](https://www.youtube.com/watch?v=0MmDdTDql5E) — доклад, в котором разработчик LuaVela рассказывает о тестировании и разработке одного из форков LuaJIT.
* [Fuzzing для тестирования JVM: зачем и как](https://2018.jokerconf.com/2018/talks/3utdpeavowkqqyyqqykymg/) — интересный доклад о фаззинге JIT-компилятора. | https://habr.com/ru/post/584864/ | null | ru | null |
# Правильная валидация в Android
### О чём это?
Эта статья - обзор моей [**Android-библиотеки валидации**](https://github.com/Egor-Blagochinnov/Validation), которая позволяет организовать сложную валидацию данных. В первую очередь библиотека рассчитана на проверку пользовательского ввода.
Часто в мобильных приложениях приходится делать различные экраны для ввода пользователем информации. Но так как пользователи не отличаются умом и сообразительностью - приходится проверять, что они там написали: запрещенные символы, максимальная длина, соответствие RegExp и так далее.
Первое, что приходит в голову для решения проблемы - прицепить регулярку прямо на `EditText`
Например, вот так:
```
val pattern = "[a-z]+".toRegex()
editText.addTextChangedListener {
val text = it?.toString() ?: return@addTextChangedListener
if (text.matches(pattern)) {
hideError(editText)
} else {
showError(editText, "Only a-z symbols allowed")
}
}
```
Но а если теперь я хочу проверять поле по двум разным RegExp и выводить разные ошибки?
Ну тогда можно добавить второй слушатель:
```
editText.addTextChangedListener {
val text = it?.toString() ?: return@addTextChangedListener
if (text.length <= 10) {
hideError(editText)
} else {
showError(editText, "Only 10 symbols allowed")
}
}
```
Однако, теперь если в поле ввести строку "12345" то ошибки не будет: первый слушатель выставит ошибку на поле, потому что поле содержит цифры, а вот второй слушатель скроет ошибку, потому что по его мнению - поле правильное, не более 10 символов.
И это только одна проблема. Дальше - веселее:
* Как повесить на поле множество правил валидации, чтобы они правильно работали вместе?
* Как добавлять или удалять правила?
* Где хранить эту кучу валидаторов?
* Как проверять любые типы данных, а не только строковые?
* и многое другое...
Решение
-------
Вся валидация должна происходить во ViewModel или Presenter, но не в UI слое. Задача UI - должным образом реагировать на результат проверки.
Не должно быть никаких специальных view-классов с поддержкой валидации. Валидацию можно привязать к любой view
Валидаторы должны поддерживать множество различных правил проверки, чтобы, например, каждое правило выдавало собственную ошибку.
Схематично всё выглядит примерно вот так:
Всё это я реализовал в [отдельной библиотеке](https://github.com/Egor-Blagochinnov/Validation).
Теперь рассмотрим её подробнее.
### Condition - основа всего
В основе всей валидации лежит условие (`Condition`) - простейший интерфейс с одним методом `validate`.
interface Condition#### Как это работает?
На изи! У `Condition` есть метод `validate(data)`, который проверит данные и вернёт результат `ValidationResult`. Внутри `ValidationResult` будет булевый результат проверки `isValid` и сообщение об ошибке, которое должно появляться если `isValid == false`
#### Сложений и умножение
`Condition` можно складывать и умножать. Сложение работает как аналог булевого ИЛИ, а умножение как аналог булевого И
Сложение (ИЛИ)
| **ИЛИ** | **Conditon(true)** | **Conditon(false)** |
| --- | --- | --- |
| **Conditon(true)** | Conditon(true) | Conditon(true) |
| **Conditon(false)** | Conditon(true) | Conditon(false) |
Умножение (И)
| **И** | **Conditon(true)** | **Conditon(false)** |
| --- | --- | --- |
| **Conditon(true)** | Conditon(true) | Conditon(false) |
| **Conditon(false)** | Conditon(false) | Conditon(false) |
Точно так же склыдываются или умножаются `ValidationResult`
### Validator - проверка по множеству условий
А что если надо проверять значение по множеству условий?
#### Как это работает?
`Validator` по-сути является `Condition`, только более прокаченный.
Внутри `Validator` находится множуство условий `Set`. В момент проверки значение проверяется по каждому из условий, формируется набор результатов валидации `Set`. Затем, этот набор с результатами передается на вход оператору (`Operator`), который и решает, какой будет финальный результат валидации. Вот, Всё.
ValidatorУ валидатора есть свои приколы:
#### Оператор
`Operator` - это просто `Condition>`, то есть тупа проверяет коллекцию результатов валидации. Получается такой аналог логического оператора из начального курса булевой алгебры. По-умолчанию используется оператор-конъюнкция.
Но можно написать свой оператор, который, например, будет выдавать `ValidationResult(true)` если количество валидных условий достигло порогового значения.
```
class ThresholdOperator(val validThreshold: Int) : Validator.Operator {
override fun validate(value: Collection?): ValidationResult {
val validCount = value?.count { it.isValid } ?: 0
return if (validCount >= validThreshold) {
ValidationResult.valid()
} else {
ValidationResult.invalid("Less than $validThreshold valid conditions")
}
}
}
```
Установка оператора
```
validator.setOperator(ThresholdOperator(validator.getConditionsSet().size / 2))
```
Удаление оператора
Нельзя удалять оператор! `Validator` не может работать без оператора
Наблюдение за изменением оператора
Может быть такое, что необходимо отслеживать изменения оператора. Например, чтобы обновить view.
```
validator.addOperatorChangedListener {
// on operator changed
}
//Или удаляем слушателя
validator.removeOperatorChangedListener(operatorListener)
```
#### Набор условий
Добавление условия
```
validator.addCondition(Condition { string ->
ValidationResult.obtain(string?.contains("target") == true, "String must contains target")
})
```
Удаление условия
```
validator.removeCondition(condition)
```
Наблюдение за изменением условий
Чтобы следить за списком условий - добавьте слушателя `OnConditionsChangedListener`, который будет вызываться при любом изменении условий
```
validator.addConditionsChangedListener { newConditions ->
//on new conditions
}
```
Изменение условий
Если нужно сделать много преобразований можно использовать `changeConditionsSet`, чтобы слушатель `OnConditionsChangedListener` сработал только один раз - после всех преобразований набора условий.
```
validator.changeConditionsSet {
this.add(Conditions.RequiredField())
this.remove(condition2)
this.add(Conditions.NotNull())
}
```
### LiveDataValidator - реактивная валидация
Было бы удобно, если бы валидатор самостоятельно проверял данные при каждом их изменении. Так и сделаем! Сейчас модно молодежно использовать `LiveData`. Так пусть валидатор подпишется на неё и будет проверять каждое значение.
LiveDataValidator`LiveDataValidator` работает так же как и обычный `Vlidator`, однако у него есть свои особенности:
#### Состояние (state)
Состояние это результат последней проверки. Представляет собой `LiveData`, поэтому за состоянием валидатора можно удобно следить. `LiveDataValidator` всегда в актуальном состоянии пока он подписан на источник (`Validator.observe`; `Validator.observeForever`)
```
liveDataValidator.state
```
#### Активация LiveDataValidator
LiveDataValidator начинает работать только тогда, когда хоть кто-нибудь подписан на него
```
liveDataValidator.state.observe(viewLifecycleOwner) { validationResult ->
//apply validation result
}
//Или можно вот так, разницы нет
liveDataValidator.observe(viewLifecycleOwner) { validationResult ->
//apply validation result
}
```
#### Реакция на другие LiveData
`LiveDataValidator` умеет следить за другими LiveData и реагировать на их изменения
Для этого есть метод `watchOn`
```
liveDataValidator.watchOn(textMaxLength) { newTextMaxLength ->
liveDataValidator.validate()
}
```
В примере выше `liveDataValidator` следит за полем `textMaxLength` и как только значение `textMaxLength` меняется `liveDataValidator` принудительно валидируется
Для подобных случаев есть метод `triggerOn`, который запускает валидацию всякий раз когда изменяется дополнительный источник
```
liveDataValidator.triggerOn(textMaxLength)
```
Пример
Есть 2 текстовых поля: на одном пики точены, на другом ~~х\*\* д~~**~~\*~~**~~ы~~ вовсе не пики Задача, чтобы второе поле не содержало в себе текст первого поля
```
val first: MutableLiveData = MutableLiveData() //Первое поле (с пиками)
val second: MutableLiveData = MutableLiveData() //Второе поле (с другими пиками)
val secondValidator: LiveDataValidator = LiveDataValidator(second).apply {
addCondition(Conditions.RequiredField())
addCondition(Conditions.RegEx("[a-z]+".toRegex(), "only a-z symbols allowed"))
addCondition(Conditions.TextMaxLength(10))
addCondition {
// Внимание сюда: для проверки используется внешнее мутабельное поле first!
if (it?.contains(first.value ?: "") == true) {
ValidationResult.invalid("textField2 should not contains textField1")
} else {
ValidationResult.valid()
}
}
triggerOn(first) //Теперь при каждом изменении first будет вызываться метод validate()
}
```
Как видно, `secondValidator` проверяет поле `second`, но при этом использует исползует `first` для проверки. Но что если `first` изменился? Тогда валидатор будет висеть в неактуальном состоянии до следующего изменения `second`. Поэтому валидатору нужно следить за `first` и при каждом его изменении принудительно выполнять проверку Делается это методом `triggerOn(LiveData<*>)`, который будет запускать валидатор при каждом изменении `first`
Вместо `triggerOn` можно так же использовать `watchOn` и самостоятельно прописать нужное действие
```
watchOn(textField1) {
validate()
}
```
### MuxLiveDataValidator - объединяем валидаторы
А теперь, когда у нас есть куча полей с LiveDataValidator'ами надо каким-то образом опредилить общий результат валидации. Самый распространённый пример: если все поля на форме заполнены правильно - включаем кнопку "Далее".
Для этого есть `MuxLiveDataValidator`. Он подписывается на множество `LiveDataValidator'ов` и как только один из них изменяется - `MuxLiveDataValidator` собирает состояния (`ValidationResult`) всех LiveDataValidator'ов и отдаёт их на проверку оператору (`Operator`). Operator выдаёт окончательный результат.
Короче, `MuxLiveDataValidator` работает типа как мультиплексор. Отсюда и название.
MuxLiveDataValidator#### Состояние (state)
Аналогично `LiveDataValidator` у `MuxLiveDataValidator` есть состояние
```
muxValidator.state
```
Состояние это `LiveData` в котором находится последний результат проверки.
#### Активация MuxLiveDataValidator
Тут как у `LiveDataValidator` - доступ только по подписке
```
viewModel.muxValidator.observe(viewLifecycleOwner) { validationResult ->
// apply validatioin result
}
```
Примечание
Когда вы подписываетесь на `MuxLiveDataValidator`, то все его `LiveDataValidator` активируются, то есть подписка распространяется и на них (такой вот аналог семейной подписки у `MediatorLiveData` ). То есть если вы подписались на `MuxLiveDataValidator`, то не можно не подписываться на те `LiveDataValidator`, за которыми он следит.
#### Добавление валидатора
Добавить `LiveDataValidator` можно при создании `MuxLiveDataValidator`
```
val muxValidator = MuxLiveDataValidator(
textField1Validator,
textField2Validator
)
```
Можно и после создания
```
muxValidator.addValidator(textField3Validator)
//Можешь докинуть сразу несколько
muxValidator.addValidators(
listOf(
textField4Validator,
textField5Validator
)
)
```
#### Удаление валидатора
Ну тут типа ваще всё изян
```
muxValidator.removeValidator(textField3Validator)
```
#### Установка оператора
По-умолчанию `MuxLiveDataValidator` использует оператор-конъюнкцию. Чтобы поменять логику выдачи финального `ValidationResult` нужно установить другой оператор
```
muxValidator.setOperator(Validator.Operator.Disjunction())
```
Есть возможность следить за сменой оператора чтобы, например, очистить ошибку на view.
```
muxValidator.addOperatorChangedListener {
// on operator changed
}
//Удалить слушателя можно примерно вот так
muxValidator.removeOperatorChangedListener(listener)
```
### Подключение валидаторов к view
#### ConditionViewBinder
`ConditionViewBinder` базовый связыватель `view` и `Condition`
Работает так:
В момент вызова `ConditionViewBinder.validate()` достает из view данные для проверки абстрактным методом `getValidationData()`. Эти данные улетают в `Condition`, который проверит их и вернет `ValidationResult`. Затем этот `ValidationResult` передаётся абстрактному методу `onValidationResult()` в котором и происходит изменения view.
ConditionViewBinderПример
```
val editText1 = requireView().findViewById(R.id.edit\_text1)
val condition = Conditions.TextMaxLength(10)
val conditionBinder = object : ConditionViewBinder(WeakReference(editText1), condition) {
override fun getValidationData(view: TextView?): String? {
return view?.text?.toString()
}
override fun onValidationResult(view: TextView?, result: ValidationResult?) {
if (result?.isValid == true) {
view?.error = null
} else {
view?.error = result?.errorMessage
}
}
}
conditionBinder.check()
```
Таким образом можно привязать любой валидатор к любой view
#### ValidatorViewBinder
Предназначен для более удобной работы с `Validator`: следит за изменениями оператора и условий валидатора.
#### LiveDataValidatorViewBinder
`LiveDataValidator` - особый пациент. Для него свой binder, который:
* сам подписывается/отписывается на `LiveDataValidator` ( чтобы активировать его)
* `getValidationData()` берется не из view, а прямо из валидатора (из его `source`)
Активация
`LiveDataValidatorViewBinder` нужно активировать. Тут 2 способа:
* Через конструктор. В конструктор передать `LifeycleOwner`
```
object : LiveDataValidatorViewBinder(
viewLifecycleOwner,
WeakReference(binding.editText1),
viewModel.textField1Validator) {
override fun onValidationResult(view: TextView?, result: ValidationResult?) {
}
override fun onConditionsChanged(conditions: Set>) {
}
override fun onOperatorChanged() {
}
}
```
* Просто вызвать `attach`
```
liveDataValidatorViewBinder.attach(viewLifecycleOwner)
```
#### Готовые реализации
**TextConditionViewBinder**
Связывает простые `Condition` с `TextView`. Проверяет поле при каждом изменении текста в нём
Использовать так:
```
val editText1 = requireView().findViewById(R.id.edit\_text1)
val condition = Conditions.TextMaxLength(10)
editText.validateBy(condition)
```
**TextViewLiveDataValidatorBinder**
Тут то же самое, что и `TextConditionViewBinder`, но тут работаем с `LiveDataValidator`.
Использовать так:
```
val editText = requireView().findViewById(R.id.edit\_text1)
val liveDataValidator = LiveDataValidator(viewModel.textField1, Conditions.RequiredField())
editText.validateBy(viewLifecycleOwner, liveDataValidator)
```
### Примеры
#### Простая валидация
0. Во ViewModel делаем простейший `Condition`
```
val textFieldCondition = Conditions.RegEx(
"[a-z]+".toRegex(),
"only a-z symbols allowed"
)
```
1. Во фрагменте (или активити) применяем условие к текстовому полю
```
val editText = requireView().findViewById(R.id.edit\_text1)
editText.validateBy(viewModel.textFieldCondition)
```
2. Готово
#### Сложная валидация
Допустим у нас есть 3 поля: поле для ввода цифр, поле для ввода букв и поле, которое указывает максимальную длину поля ввода цифр. О как! А ещё нужно выводить общее состояние валидации всей формы в отдельное текстовое поле!
Пример доступен тут: <https://github.com/Egor-Blagochinnov/ValidationSample>
0. Для начала объявим сами поля и валидаторы к ним во ViewModel]
```
//Поле, которое определяет максимальную длину поля для ввода цифр
val textMaxLength: MutableLiveData = MutableLiveData()
//Цифровое поле
val textField1: MutableLiveData = MutableLiveData()
//Про этот валидатор - чуть ниже
val textField1Validator = ExampleValidators.DigitsFieldValidator(textField1).apply {
watchOn(textMaxLength) {
val maxLength = kotlin.runCatching { it?.toInt() }.getOrNull()
this.setMaxLength(maxLength)
}
}
//Буквенное поле
val textField2: MutableLiveData = MutableLiveData()
val textField2Validator: LiveDataValidator = LiveDataValidator(textField2).apply {
addCondition(Conditions.RequiredField())
addCondition(Conditions.RegEx("[a-z]+".toRegex(), "only a-z symbols allowed"))
addCondition(Conditions.TextMaxLength(10))
}
//Обобщенный валидатор
val muxValidator = MuxLiveDataValidator(
textField1Validator,
textField2Validator
)
```
1. Чтобы динамически менять условия валидации - лучше всего написать свой валидатор. Потому что для смены условий нужно хранить ссылки на эти самые условия, а это лучше сделать в отдельном классе
```
class ExampleValidators {
class DigitsFieldValidator~~(
source: LiveData~~,
initialCondition: Condition? = null,
operator: Operator = Operator.Conjunction()
) : LiveDataValidator~~(
source,
initialCondition,
operator
) {
val onlyDigitsCondition = Conditions.RegEx~~("[0-9]+".toRegex(), "only digits allowed")
private var maxLengthCondition = Conditions.TextMaxLength(5) //по-умолчанию пусть будет 5
init {
addCondition(onlyDigitsCondition)
addCondition(maxLengthCondition)
}
fun setMaxLength(maxLength: Int?) {
if (maxLength == null || maxLength < 0) {
removeCondition(maxLengthCondition)
return
}
val newCondition = Conditions.TextMaxLength(maxLength)
changeConditionsSet {
remove(maxLengthCondition)
maxLengthCondition = newCondition
add(maxLengthCondition)
}
}
}
}~~~~~~~~
```
2. Теперь идём во фрагмент и подключаем всё это дело
```
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel = ViewModelProvider(this).get(ExampleViewModel1::class.java)
binding.viewModel = viewModel
// Подключаем валидатор к цифровому полю
binding.editText1.validateBy(
viewLifecycleOwner,
viewModel.textField1Validator
)
// Подключаем валидатор к буквенному полю
binding.editText2.validateBy(
viewLifecycleOwner,
viewModel.textField2Validator
)
//Следим за обобщенным (mux) валидатором
viewModel.muxValidator.observe(viewLifecycleOwner) {
setGeneralValidationResult(it)
}
}
//Отображем результат общей валидации в отдельном текстовом поле "state"
private fun setGeneralValidationResult(validationResult: ValidationResult) {
if (validationResult.isValid) {
binding.state.text = "Correct!"
binding.state.setTextColor(ContextCompat.getColor(requireContext(), R.color.state_success))
} else {
binding.state.text = validationResult.errorMessage ?: "Error message is null"
binding.state.setTextColor(ContextCompat.getColor(requireContext(), R.color.design_default_color_error))
}
}
```
Готово!
#### Общие рекомендации по использованию
0. Все валидаторы должны находиться во ViewModel (ну или в Presenter) Не надо выносить логику валидирования во фрагменты, активности и вообще на view уровень.
1. По-возможности используйте `LiveDataValidator`. Он самый прокаченный. И вообще вся библиотека ради него написана была
2. Аккуратнее с множеством условий. Вы можете добавить на поле противоречащие друг другу условия и будет непонятно что!
3. Делайте свои реализации. Создавайте свои `ConditionViewBinder`ы, чтобы работать с кастомными view Создавайте свои валидаторы если вам нужна более сложная валидация | https://habr.com/ru/post/579164/ | null | ru | null |
# Как быстро прототипировать приложения с CSS-сеткой и CSS-переменными
Как CSS-сетка, так и CSS-переменные представляют собой мощные инструменты для frontend-разработчиков. Первое позволяет значительно упростить создание макетов веб-сайта, в то время как второе дает всю мощь переменных таблицам стилей.
В этом материале я покажу вам, как использовать оба инструмента для того, чтобы быстро прототипировать дизайн приложений.
> **Skillbox рекомендует:** онлайн-курс [UX-аналитика](https://skillbox.ru/aic/analytics/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=uxanalitics&utm_content=articles&utm_term=howtoprototypeapp)
>
> Напоминаем: для всех читателей Хабра — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».
### Настройка контейнера сетки
Наши приложения будут работать с CSS-сеткой, модулем, который позволяет быстро создавать макеты и управлять ими. Это полезно, в частности, если вы работаете со свойством grid-template-areas. (Ниже я покажу, как его использовать).
Давайте оценим внешний вид нашего приложения — это чат:
Если мы откроем инструменты разработчика в Chrome, то сможем увидеть, что собой представляет такая сетка. Как видите, здесь шесть столбцов и шесть строк.
Вот код для создания такой сетки:
```
.app {
display: grid;
grid-template-columns: 1fr 1fr 1fr 1fr 1fr 1fr;
grid-template-rows: 1fr 1fr 1fr 1fr 1fr 60px;
}
```
Сначала мы создаем для нее контейнер. Затем мы говорим, что хотели бы получить на выходе шесть столбцов, и каждый из них должен быть шириной с 1fr. Это означает часть свободного пространства. Таким образом, свободное пространство экрана мы делим на шесть равных по ширине частей.
А вот со строками по-другому. Высота каждой из первых пяти строк тоже 1 fr, но высоту последней мы ограничиваем в 60px вместо 1fr.
```
grid-template-rows: 1fr 1fr 1fr 1fr 1fr 60px;
```
Ну а теперь, когда мы разметили решетку, переходим к следующей части — размещению элементов.
### Размещение элементов сетки
Каждый прямой «наследник» контейнера сетки является элементом сетки. Всего у нас четыре элемента, каждый из которых помещен в прямоугольник, как показано на скриншоте ниже.
Для того, чтобы элементы были размещены точно так, как показано выше, нам необходимо использовать свойство grid-template-areas.
```
.app {
display: grid;
grid-template-columns: 1fr 1fr 1fr 1fr 1fr 1fr;
grid-template-rows: 1fr 1fr 1fr 1fr 1fr 60px;
grid-template-areas:
"r m m m m m"
"r m m m m m"
"r m m m m m"
"r m m m m m"
"r m m m m m"
"n s s s s s";
}
```
Каждая из строк кода представляет одну строку таблицы, а каждый символ — это ячейка сетки. Символы имеют семантическое отношение к элементам сетки, которые они представляют (список комнат, список сообщений, форма новой комнаты, форма сообщения).
Теперь для размещения наших элементов согласно grid-template-areas мы должны использовать символы с их grid-area значениями. Вот как здесь:
```
.new-room-form {
grid-area: n;
}
.rooms-list {
grid-area: r;
}
.message-list {
grid-area: m;
}
.send-message-form {
grid-area: s;
}
```
Разумеется, эти классы также применимы к нашим элементам сетки в вашем HTML. Однако я не буду подробно об этом рассказывать, так как, скорее всего, вы знаете, как добавлять классы в теги HTML.
С этого момента начинаем экспериментировать с макетом. Мы можем менять очень многое при помощи изменения значений grid-template-areas.
Как показано на иллюстрации выше, я пробую использовать четыре разных макета, изменяя позиции элемента «Список комнат» и новых элементов формы комнаты. Единственное, что я меняю, это свойство grid-template-areas.
Ниже четыре этих варианта. Попробуйте сопоставить каждый из них с соответствующим макетом.
```
grid-template-areas:
"n m m m m m"
"r m m m m m"
"r m m m m m"
"r m m m m m"
"r m m m m m"
"r s s s s s";
grid-template-areas:
"r m m m m m"
"r m m m m m"
"r m m m m m"
"r m m m m m"
"r m m m m m"
"n s s s s s";
grid-template-areas:
"m m m m m r"
"m m m m m r"
"m m m m m r"
"m m m m m r"
"m m m m m r"
"s s s s s n";
grid-template-areas:
"m m m m m n"
"m m m m m r"
"m m m m m r"
"m m m m m r"
"m m m m m r"
"s s s s s r";
```
### Изменение цвета с использованием CSS-переменных
Ну а сейчас мы попробуем изменять цвет приложения при помощи CSS-переменных. Если вы не работали с ними до настоящего момента, давайте посмотрим, что они собой представляют.
Способ, показанный на нижней картинке, несколько упрощает чтение кода, поскольку, если так можно выразиться, имя переменной более семантично, чем шестнадцатеричное. Кроме того, второй способ дает большую гибкость в вопросе изменения кода.
Давайте посмотрим, что можно сделать с нашим приложением, используя различные значения переменных.
```
:root {
--main-color: #5ea3d0;
--secondary-color: white;
--main-text-color: #3e5869;
--secondary-text-color: #b0c7d6;
--new-room-form: #d9e1e8;
--send-message-form: #F5F5F5;
}
```
Они повторяются 17 раз в нашем макете. Но все локации проверять не будем, давайте лучше глянем, как работает main color в применении к цвету сообщений и левой боковой панели.
Вот как мы обыгрываем все это в коде.
```
.rooms-list {
background: var(--main-color);
}
.message-text {
background: var(--main-color);
}
```
Переменные хороши тем, что мы можем редактировать их объявление, и этого будет достаточно для того, чтобы изменить все приложение. Пример:
```
:root {
--main-color: red;
}
```
И вот результат:
Мы можем просто изменять объявление переменных в :root, что позволит играть с внешним видом приложения.
Давайте заменим некоторые цвета в :root, воспользовавшись палитрой выше.
```
:root {
--main-color: #5ea3d0;
--secondary-color: white;
--main-text-color: #3e5869;
--secondary-text-color: #b0c7d6;
--new-room-form: #d9e1e8;
--send-message-form: #F5F5F5;
}
```
Результат — полностью иной внешний вид чата:
### Объединяем сетку и переменные
Если мы объединим все это, то получим возможность полностью изменять дизайн нашего чата. Давайте сделаем это.
Вот как выглядит начальный вариант по сравнению с финальным. Как вы можете видеть, я изменил и палитру, и макет. Единственная разница между этими двумя примерами — 11 строк кода, которые я выделил здесь.
```
:root {
--main-color: #ff66ff;
--secondary-color: #fbd8fb;
--main-text-color: #3e5869;
--secondary-text-color: #d8b2ff;
--new-room-form: #ffb2ff;
--send-message-form: #d8b2ff;x
}
.app {
display: grid;
grid-template-columns: repeat(6, 1fr);
grid-template-rows: 1fr 1fr 1fr 1fr 1fr 60px;
grid-template-areas:
"m m m m r r"
"m m m m r r"
"m m m m r r"
"m m m m r r"
"m m m m n n"
"f f f f f f";
}
```
Правда, круто?
> **Skillbox рекомендует:**
>
>
>
> * Практический курс [PHP-разработчик с 0 до PRO](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=phpdev&utm_content=articles&utm_term=howtoprototypeapp).
> * Годовой онлайн-курс [«Профессия Веб-разработчик»](https://skillbox.ru/webdev/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=webdev&utm_content=articles&utm_term=howtoprototypeapp).
> * Практический двухмесячный курс [Python-разработчик с нуля](https://skillbox.ru/python/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=ptndev&utm_content=articles&utm_term=howtoprototypeapp).
> | https://habr.com/ru/post/418067/ | null | ru | null |
# Размышление об Active Object в контексте Qt6. Часть 2.5
#### Ссылки на статьи
* [Часть 1](https://habr.com/ru/post/709768/)
* [Часть 2](https://habr.com/ru/post/710368/)
* [Часть 2.5](https://habr.com/ru/post/710550/)
* [Часть 2.6](https://habr.com/ru/post/712328/)
* [Часть 3](https://habr.com/ru/post/710656/)
Предисловие
-----------
Статья выпущена как дополнение к предыдущей и показывает, как можно сделать Active object, работающий асинхронно в среде Qt, но при этом не использующий события.
Иногда бывает слишком обременительно документировать использование кодов событий, поэтому желательно делать всё через сигналы.
Как это работает
----------------
Исходя из [документации Qt](https://doc.qt.io/qt-6/qt.html#ConnectionType-enum), при вызове QObject::connect, можно указать Qt::ConnectionType. Если вкратце, то нас волнует возможность определять с помощью этого перечисление указывать, как вызывать слот.
* Qt::DirectConnection — слот будет вызван напрямую при излучении сигнала, к которому он привязан. При этом обработка слота будет проводиться потоком, вызвавшим сигнал.
* Qt::QueuedConnection — излучение сигнала будет преобразовано в событие, которое будет отправлено в очередь событий. Точно также, как мы это делали в предыдущей статье. Обработку слота при этом проводит поток-владелец QObject-а.
* Qt::AutoConnection — если излучатель сигнала (sender) и его получатель (receiver) находятся в одном потоке, то слот этого QObject-а будет обработан напрямую потоком-владельцем. Если же они находятся в разных потоках, то сигнал пакуется в событие, которое помещается в очередь событий. Таким образом гарантируется, что слот всегда будет обрабатываться потоком-владельцем QObject-а.
* Остальные перечислители рассматривать здесь я не буду, поскольку они не нужны нам в реализации класса Active object.
Нам как раз идеально подойдёт Qt::AutoConnection.
Реализуем
---------
Для начала обернём задачу вывода на экран в целостную структуру. Эта структура является внутренней для класса SignalBasedAsyncQDebugPrinter, т.к. больше нигде не нужна. Получается практически тот же самый PrinterMessageEvent из [предыдущей части](https://habr.com/ru/post/710368/).
PrinterMessage
```
class PrinterMessage {
private:
QPromise m\_promise;
const QString m\_message;
public:
PrinterMessage(const QString &message);
const QString& message() const;
QPromise& promise();
};
SignalBasedAsyncQDebugPrinter::PrinterMessage::PrinterMessage(const QString &message)
:m\_message{ message } {}
const QString& SignalBasedAsyncQDebugPrinter::PrinterMessage::message() const {
return m\_message;
}
QPromise &SignalBasedAsyncQDebugPrinter::PrinterMessage::promise() {
return m\_promise;
}
```
Теперь опишем сам SignalBasedAsyncQDebugPrinter. Реализация очень близка к EventBasedAsyncQDebugPrinter из предыдущего примера с той разницей, что используется сигнально-слотовое соединение, а значит, нужно иметь собственную очередь для передачи задач.
EventBasedAsyncQDebugPrinter
```
class SignalBasedAsyncQDebugPrinter : public QObject {
private:
Q_OBJECT
class PrinterMessage {/*...*/};
private:
std::queue m\_messages;
std::mutex m\_mutex;
public:
explicit SignalBasedAsyncQDebugPrinter(QObject \*parent = nullptr);
QFuture print(const QString& message);
private slots:
void handleNextMessage();
signals:
void nextMessageReceived();
};
SignalBasedAsyncQDebugPrinter::SignalBasedAsyncQDebugPrinter(QObject \*parent)
:QObject{ parent } {
QObject::connect(this, &SignalBasedAsyncQDebugPrinter::nextMessageReceived, this, &SignalBasedAsyncQDebugPrinter::handleNextMessage);
}
QFuture SignalBasedAsyncQDebugPrinter::print(const QString &message) {
auto task = PrinterMessage{ message };
auto future = task.promise().future();
{
std::lock\_guard locker{ m\_mutex };
m\_messages.emplace(std::move(task));
}
emit this->nextMessageReceived();
return future;
}
void SignalBasedAsyncQDebugPrinter::handleNextMessage() {
std::queue buffer;
{
std::lock\_guard locker{ m\_mutex };
buffer.swap(m\_messages);
}
while(not buffer.empty()) {
qDebug() << buffer.front().message();
buffer.front().promise().finish();
buffer.pop();
}
}
```
Для connect также существует перегрузка вида
```
connect(pointer, &SomeClass::signal, &SomeClass::slot);
```
Эта форма существует специально для связывания сигнала и слота одного и того же объекта. Но нам она не подходит, поскольку будет преобразована в
```
connect(pointer, &SomeClass::signal,pointer, &SomeClass::slot, Qt::DirectConnection);
```
В целом и полностью код похож на код event-based active object из предыдущей статьи.
В методе print мы создаём задачу, под блокировкой помещаем её в очередь, уведомляем сами себя через сигнал о том, что в очереди лежит новая задача и возвращаем промис на неё.
В методе handleNextMessage мы под блокировкой забираем всю очередь задач и обрабатываем её в цикле.
Немного о блокировках
---------------------
Отдельно стоит отметить блокировку на 28-й строке в методе print. Если не снять блокировку до того, как вызвать emit this->nextMessageReceived();, то если метод print вызван потоком-владельцем SignalBasedAsyncQDebugPrinter, то тут же напрямую будет вызван метод handleNextMessage, который снова попытается захватить тот же самый мьютекс, в результате чего мы получаем deadlock.
Решить это можно несколькими путями.
Самый простой — в принципе запретить прямой вызов слота из сигнала. Для этого нужно вызывать метод connect в конструкторе с флагом Qt::QueuedConnection. Тогда даже независимо от того, какой поток вызвал print, слот будет вызван не сразу, а только по прошествии события через цикл событий.
QObject::connect с Qt::ConnectionType::QueuedConnection
```
QObject::connect(this, &SignalBasedAsyncQDebugPrinter::nextMessageReceived, &SignalBasedAsyncQDebugPrinter::handleNextMessage, Qt::ConnectionType::QueuedConnection);
```
Второй способ — тот, который представлен в реализации выше: просто обернуть lock\_guard в лишний скоуп, что даст нам RAII0-разблокировку.
Третий способ — немного облагороженный второй. Нужно добавить метода для добавления задачи в очередь и забирания всей очереди. Мьютекс будут использовать только эти два метода. Если я где-то ошибусь — просьба поправить.
Реализация с двумя служебными методами
```
class SignalBasedAsyncQDebugPrinter : public QObject {
//Всё то же самое, что и раньше
//...
private:
void emplaceTaskInQueue(PrinterMessage&& task);
std::queue takeTaskQueue();
};
QFuture SignalBasedAsyncQDebugPrinter::print(const QString &message) {
auto task = PrinterMessage{ message };
auto future = task.promise().future();
emplaceTaskInQueue(std::move(task));
emit this->nextMessageReceived();
return future;
}
void SignalBasedAsyncQDebugPrinter::handleNextMessage() {
std::queue buffer{ takeTaskQueue() };
while(not buffer.empty()) {
qDebug() << buffer.front().message();
buffer.front().promise().finish();
buffer.pop();
}
}
void SignalBasedAsyncQDebugPrinter::emplaceTaskInQueue(PrinterMessage &&task) {
std::lock\_guard locker{ m\_mutex };
m\_messages.emplace(std::move(task));
}
std::queue SignalBasedAsyncQDebugPrinter::takeTaskQueue() {
std::queue buffer;
std::lock\_guard locker{ m\_mutex };
m\_messages.swap(buffer);
return buffer;//NRVO, копирований нет
}
```
Заключение
----------
Задача не использовать события зачастую возникает, когда вы пишете собственную библиотеку. Тогда, чтобы не пересекаться с событиями, определяемыми вашими пользователями, приходится вовсе отказываться от их использования.
Этот класс является повторением класса из предыдущей статьи, но не использует события, за счёт чего такая конструкция, возможно, станет более приемлемой в некоторых ситуациях.
Код примера, как обычно, на [GitHub](https://github.com/ilyaBykonya/ActiveObjectExamples/tree/examples/qobject/QObjectBasedActiveObjectExample). | https://habr.com/ru/post/710550/ | null | ru | null |
# Конкурс по программированию: Торговля (промежуточные результаты и объявления)
Большое спасибо всем участникам [конкурса по программированию](https://habr.com/company/hola/blog/414723/)! Приём решений ещё не закончен, но в полночь на 17 июля мы взяли тот набор решений, который был на тот момент, и провели между ними мини-турнир. В него попали 82 решения.
Но сначала — несколько объявлений.
Конкурс продлевается на неделю
------------------------------
Срок приёма решений продлевается до **27 июля 2018**, 23:59:59 UTC. Также на неделю вперёд сдвигаются сроки, в которые будут объявлены результаты конкурса. Мы продлили конкурс для того, чтобы улучшить охват в сезон отпусков.
Уточнения по окончательному тестированию
----------------------------------------
После окончания приёма работ тестирование будет более тщательным, чем нынешнее предварительное.
### Затравочные значения
Мы публикуем способ, который обещаем использовать для выбора затравочных значений для финального тестирования. Этот способ должен быть однозначным и легко проверяемым, но непредсказуемым. Итак, мы возьмём первый твит из [этого Твиттера](https://twitter.com/SpringerTV), который появится там после наступления дедлайна. Трудно поверить, что мы сговорились с Джерри Спрингером, правда? Из твита берём только текст, без картинок и видео. Если в твите нет текста, а только картинка, то берём следующий твит. Ретвиты считаются. Имя ретвитнутого аккаунта не берётся.
Из текста твита мы получим затравочные значения так:
```
const random_js = require('random-js');
const text = 'The tweet goes here';
const bytes = Array.from(new Buffer(text));
const random = new random_js(random_js.engines.mt19937().seedWithArray(bytes));
for (let i = 0; i<200; i++) // сгенерируем столько, сколько потребуется
console.log(random.uint32());
```
Элементы получшившейся последовательности с *нечётными* номерами, при нумерации начиная с 1 (то есть первый, третий, пятый и так далее) будут использованы как затравочные значения для первого раунда, а с *чётными* — как дополнительные затравочные значения для финала.
В первом раунде каждая упорядоченная пара решений будет запущена на каждом из не менее 100 затравочных значений (больше, если успеем). В финале будет использовано не менее 100 дополнительных затравочных значений. Сеансы, проведённые в первом раунде между решениями, вышедшими в финал, будут использованы и в финале (но не сеансы между финалистом и решением, не вышедшим в финал). Таким образом, исход финала решат не менее 200 затравочных значений.
### Отбор финалистов
После первого раунда все решения будут упорядочены по сумме набранных очков. Некоторое количество решений, начиная с лидера списка, будут допущены в финал.
Для отбора финалистов будут применяться следующие правила. Число финалистов решит то из правил, которое окажется **наиболее строгим** (то есть пропустит в финал *наименьшее*) число решений.
* Не более половины решений.
* Не более 50 решений.
* Только решения, показавшие лучший результат, чем `example.js`.
Промежуточные результаты
------------------------
Для промежуточного тестирования мы использовали в качестве затравочных значений натуральные числа от 1 до 50 включительно. Каждая упорядоченная пара, состоящая из различных решений, была запущена на каждом из этих значений. Таким образом, для 82 участников турнир состоял из 332100 сеансов; каждое из решений поучаствовало в 8100 сеансах.
Пока что вместо имён участников — идентификаторы решений. Ваш идентификатор — в автоматическом письме, которое Вы получили после отправки решения. Не возбраняется в комментариях к этому посту раскрывать, что такое-то решение — Ваше.
Обратите внимание, что на 59, 60 и 61 местах расположились копии скрипта [example.js](https://github.com/hola/challenge_haggling/blob/master/src/example.js). Интересно, что 21 из 82 решений показали более низкий результат, чем наш примитивный пример. (Почему три копии одного и того же скрипта показали слегка разные результаты? Потому что некоторые решения используют `Math.random`, и результаты сеансов с их участием не воспроизводимы.)
Таблицу промежуточных результатов можно увидеть [на GitHub](https://github.com/hola/challenge_haggling/blob/master/blog/02-preliminary-standings-2018-07-17.md#preliminary-standings). Условные обозначения:
* **S**: Сумма набранных очков (это и есть предмет соревнования)
* **S/N**: Средний результат сеанса
* **A**: Число сеансов с достигнутым соглашением
* **A/N**: Процент сеансов с достигнутым соглашением
* **S/A**: Средний результат сеанса с достигнутым соглашением
* **X**: Число сеансов, прерванных данным участником (по причине исключений или некорректных результатов)
Разумеется, до окончания конкурса ещё осталось время, за которое расстановка сил может измениться. Дерзайте! | https://habr.com/ru/post/417645/ | null | ru | null |
# Хозяйке на заметку: разбираемся с конфигурационными файлами Linux
Понимая, как работают конфигурационные файлы, вы можете существенно повысить уровень владения Linux. В статье рассказываем, как конфигурационные файлы управляют пользовательскими разрешениями, системными приложениями, демонами и другими административными задачами в многопользовательской среде.
### Введение в конфигурационные файлы
Само ядро можно назвать «программой». Зачем ядру конфигурационные файлы? Ему нужно знать список пользователей и групп в системе, управлять правами доступа к файлам (определять, может ли файл открываться конкретным пользователем в соответствии с разрешениями UNIX\_USERS).
Такие файлы считываются не программами, а функцией, предоставляемой системной библиотекой и используемой ядром. Предположим, программа, которой требуется зашифрованный пароль пользователя, не должна открывать файл /etc/passwd. Вместо этого следует вызвать функцию системной библиотеки getpw(). Этот тип функции также известен как **системный вызов**. Через системную библиотеку ядро открывает файл /etc/passwd и затем ищет пароль запрошенного пользователя.
[«Администрирование Linux. Мега»](https://slurm.club/3D5ET95)
Большинство конфигурационных файлов Linux находятся в каталоге /etc, если не указано иное. В зависимости от сферы применения и служб, на которые они влияют, конфигурационные файлы делят на несколько категорий, о которых и пойдёт речь дальше.
### Доступ к файлам
| | |
| --- | --- |
| **/etc/host.conf** | Сообщает серверу сетевого домена, как искать имена хостов. Сначала идёт /etc/hosts, затем имя сервера. Файл можно изменить через netconf. |
| **/etc/hosts** | Содержит список известных хостов в локальной сети. Может использоваться, если IP-адрес системы не генерируется динамически. |
| **/etc/hosts.allow** | Справочная страница, аналогичная hosts\_access. |
| **/etc/hosts.deny** | Справочная страница, аналогичная hosts\_access. |
### Загрузка и вход/выход из системы
| | |
| --- | --- |
| **/etc/issue & /etc/issue.net** | Такие файлы считываются mingetty (и аналогичными программами) для отображения приветственной строки пользователю, подключающемуся с терминала (issue) или через сеанс telnet([issue.net](http://issue.net)). Они включают в себя несколько строк с указанием номера выпуска Red Hat, названия и идентификатора ядра. Используются rc.local. |
| **/etc/redhat-release** | Включает одну строку с указанием номера и названия выпуска Red Hat. Используется rc.local. |
| **/etc/rc.d/rc** | Предназначен для перевода системы с одного уровня выполнения на другой. В процессе начальной загрузки переводит систему из однопользовательского режима на уровень, задаваемый по умолчанию. |
| **/etc/rc.d/rc.local** | Помогает конфигурировать запуск системы — запускать дополнительные программы и подключать библиотеки к работающим процессам. Также позволяет уничтожать работающие процессы с помощью утилиты slay и перезапускать их с другими параметрами, однако такой подход считается громоздким. |
| **/etc/rc.d/rc.sysinit** | Используется для локальной инициализации системы. |
| **/etc/rc.d/rc/rc X.d** | Скрипты запускаются из rc (X означает любое число от 1 до 5). Эти каталоги являются специфичными каталогами «уровня выполнения». Когда система запускается, она определяет уровень выполнения, который необходимо инициировать, а затем вызывает все сценарии запуска, присутствующие в каталоге для этого уровня выполнения. Например, система запускается, и после сообщений о запуске появляется сообщение «вход на уровень выполнения 3» — это означает, что будут вызваны все сценарии инициализации в каталоге /etc/rc.d/rc3.d/. |
### Файловая система
Ядро предоставляет интерфейс для отображения структур данных, которые могут быть полезны при определении системных параметров — прерываний, статистики памяти и др. Этот интерфейс представляет собой отдельную файловую систему, известную как /proc filesystem. Многие системные утилиты используют значения, присутствующие в этой файловой системе или отображающие системную статистику. Например, в файле /proc/modules перечислены загруженные в данный момент модули. Информация считывается командой lsmod, которая затем отображает её в удобочитаемом формате.
| | |
| --- | --- |
| **/etc/mtab** | Содержимое файла не обновляется средствами ядра ОС, а поддерживается в актуальном состоянии средствами утилиты mount. Когда файловые системы монтируются и размонтируются, изменения немедленно отражаются в этом файле. |
| **/etc/fstab** | Содержит список файловых систем, которые в настоящее время «монтируются» компьютером. Файл важен, поскольку во время загрузки компьютер запускает команду mount -a, которая монтирует каждую файловую систему, отмеченную цифрой «1» в предпоследнем столбце fstab. |
| **/etc/mtools.conf** | Считается конфигурационным файлом для всех операций (mkdir, copy, format и др.) в файловой системе типа DOS. |
### Системное администрирование
| | |
| --- | --- |
| **/etc/group** | Определяет группы в системе Linux. Один пользователь может присутствовать более чем в одной группе, если он выполняет несколько задач. Например, если «user» является администратором, а также членом группы проекта «project 1», то его запись в файле группы будет выглядеть так: user: \* : group-id : project1 |
| **/etc/nologin** | Основная задача файла — показать сообщение пользователям, которые пытаются войти в систему во время завершения работы. Как только сообщение отображается, процедура входа в систему завершается, что останавливает вход пользователя в систему.Пример: если файл /etc/nologin существует, то login(1) разрешит доступ только пользователю root. Другим пользователям будет показано содержимое этого файла, но во входе в систему им будет отказано. |
| **/etc/passwd** | Содержит информацию об учётной записи пользователя, включая пароли (если они не «затенены»). |
| **/etc/rpmrc** | Конфигурация команды rpm. Все параметры командной строки rpm устанавливаются вместе в этом файле, поэтому они применяются глобально, когда любая команда rpm запускается в системе. |
| **/etc/securetty** | Содержит имена устройств tty-линий (по одной на строку, без ведущего /dev/), на которых root разрешён вход. |
| **/etc/usertty /etc/shadow** | Содержит информацию о зашифрованном пароле для учётных записей пользователей и, при необходимости, информацию об истечении срока действия пароля. Включены следующие поля: — имя для входа в систему — зашифрованный пароль — количество дней с 1 января 1970 года, когда пароль был изменен в последний раз — количество дней до того, как пароль может быть изменен — количество дней, после которых пароль должен быть изменен— количество дней до истечения срока действия пароля о том, что пользователь предупрежден — количество дней после истечения срока действия пароля. |
| **/etc/shells** | Содержит список возможных «оболочек», доступных системе. |
| **/etc/motd** | Сообщение дня — используется, если администратор хочет передать какое-то сообщение всем пользователям сервера Linux. |
### Сеть
| | |
| --- | --- |
| **/etc/gated.conf** | Представляет собой конфигурационные данные для работы демона gated, предназначенного для маршрутизации протоколов RIP, BGP, EGP, HELLO и OSPF. |
| **/etc/gated.version** | Содержит номер версии демона gated. |
| **/etc/gateway** | Опционально используется демоном routed. |
| **/etc/networks** | Хранит доменные имена и IP-адреса сетей, с которыми у вашей системы есть соединение. Сети имеют сокращенные IP-адреса. В зависимости от типа сети в IP-адресах может использоваться одно, два или три числа. IP-адреса записываются в файле /etc/networks вместе с соответствующими им доменными именами сетей. |
| **/etc/protocols** | Хранит список доступных на данный момент протоколов. Никогда не должен меняться. |
| **/etc/resolv.conf** | Определяет, как система использует DNS для разрешения имен хостов и IP-адресов. |
| **/etc/rpc** | Содержит инструкции/правила для RPC, которые можно использовать при вызовах NFS, удаленном монтировании файловой системы и др. |
| **/etc/exports** | В этом файле перечислены все каталоги, экспортируемые с сервера. Одна строка задает один каталог. В файле /etc/exports один каталог может быть указан дважды: один раз для NFS версии 2 или NFS версии 3 и один раз — для NFS версии 4. Сервер автоматически экспортирует указанные каталоги каждый раз при запуске сервера NFS. Затем клиенты могут смонтировать экспортированные каталоги. |
| **/etc/services** | Содержит информацию о многочисленных службах, которые клиентские приложения могут использовать на компьютере. Преобразует имена сетевых служб в номер порта/протокол. |
| **/etc/inetd.conf** | Конфигурационный файл для суперсервера inetd. Изменять этот файл следует только при необходимости добавления или удаления описаний серверов. |
| **/etc/sendmail.cf** | Файл конфигурации почтовой программы sendmail. Содержит большое количество опций, представленных в неудобном для восприятия виде, поэтому анализировать содержимое данного файла и редактировать его довольно сложно. |
| **/etc/sysconfig/network** | Глобальный файл конфигурации. Позволяет установить, хотите ли вы использовать сетевое соединение (NETWORKING=yes or no). |
| **/etc/sysconfig/network-scripts/if\*** | Скрипты настройки сети Red Hat. |
### Системные команды
Системные команды предназначены для управления системой и обеспечения того, чтобы все работало должным образом. Все программы вроде как logic (выполняющей аутентификацию пользователя на консоли) или bash (обеспечивающей взаимодействие между пользователем и компьютером) являются системными командами, поэтому связанные с ними файлы особенно важны.
В таблице перечисляем файлы, представляющий наибольший интерес для пользователей и администраторов.
| | |
| --- | --- |
| **/etc/lilo.conf** | Содержит параметры командной строки системы по умолчанию, а также различные образы для загрузки. Вы можете просмотреть весь список, нажав Tab в командной строке LILO. |
| **/etc/logrotate.conf** | Поддерживает файлы журнала, присутствующие в каталоге /var/log. |
| **/etc/identd.conf** | Identd — сервер, который реализует предлагаемый TCP/IP протокол идентификации пользователя IDENT. identd работает путем поиска конкретных соединений TCP/IP и возврата имени пользователя процесса, владеющего соединением. При необходимости он может возвращать другую информацию вместо имени пользователя. |
| **/etc/ld.so.conf** | Конфигурация для динамического компоновщика |
| **/etc/inittab** | Хронологически первый конфигурационный файл в UNIX. Первая программа, запускаемая после включения компьютера UNIX, — это init, которая знает, что делать благодаря inittab. Файл /etc/inittab управляет порождением процессов программой init. |
| **/etc/termcap** | База данных, содержащая все возможные типы терминалов и их возможности. |
### Демоны
**Демон** — программа, которая всегда работает в фоновом режиме. Обычно её задачи связаны с сетевой областью: они ожидают подключений, чтобы через них можно было предоставлять услуги. Для Linux доступно множество демонов, начиная от веб-серверов и заканчивая ftp-серверами.
| | |
| --- | --- |
| **/etc/syslogd.conf** | Содержит информацию, используемую демоном системного журнала syslogd(1M) для пересылки системного сообщения соответствующим файлам журнала и/или пользователям |
| **/etc/httpd.conf** | Файл конфигурации для веб-сервера Apache. Обычно находится не в /etc, а в в /usr/local/httpd/conf/ или /etc/httpd/conf/. Чтобы определить точное нахождение, вам нужно проверить конкретную установку Apache. |
| **/etc/conf.modules or /etc/modules.conf** | Файл конфигурации ядра. Заботится о загрузке дополнительных модулей ядра «на лету», когда это необходимо. |
### Пользовательские программы
В Linux (и UNIX в целом) существует бесчисленное множество «пользовательских» программ. Наиболее распространенным файлом конфигурации пользовательской программы считается /etc/lynx.cfg. Это файл конфигурации для lynx — хорошо известного текстового браузера. С помощью этого файла вы можете определить прокси-сервер, используемый набор символов и др.
Пример кода ниже показывает часть файла lynx.cfg, который может быть отредактирован для изменения настроек прокси-сервера системы Linux. Эти настройки применяются ко всем пользователям, запускающим lynx в соответствующих оболочках, если только пользователь не переопределит конфигурационный файл по умолчанию, указав --cfg = "mylynx.cfg.
```
.h1 proxy
.h2 HTTP_PROXY
.h2 HTTPS_PROXY
.h2 FTP_PROXY
.h2 GOPHER_PROXY
.h2 NEWS_PROXY
.h2 NNTP_PROXY
# Lynx version 2.2 and beyond supports the use of proxy servers that can act as
# firewall gateways and caching servers. They are preferable to the older
# gateway servers. Each protocol used by Lynx can be mapped separately using
# PROTOCOL_proxy environment variables (see Lynx Users Guide). If you have
# not set them externally, you can set them at run time via this configuration file.
# They will not override external settings. The no_proxy variable can be used
# to inhibit proxying to selected regions of the Web (see below). Note that on
# VMS these proxy variables are set as process logicals rather than symbols, to
# preserve lowercasing, and will outlive the Lynx image.
#
.ex 15
http_proxy:http://proxy3.in.ibm.com:80/
ftp_proxy:http://proxy3.in.ibm.com:80/
#http_proxy:http://penguin.in.ibm.com:8080
#ftp_proxy:http://penguin.in.ibm.com:8080/
.h2 NO_PROXY
# The no_proxy variable can be a comma-separated list of strings defining
# no-proxy zones in the DNS domain name space. If a tail substring of the
# domain-path for a host matches one of these strings, transactions with that
# node will not be proxied.
.ex
no_proxy:demiurge.in.ibm.com, demiurge
```
### Изменение конфигурационных файлов
При изменении конфигурационных файлов убедитесь, что программа, использующая эту конфигурацию, перезапущена, если она не контролируется системным администратором или ядром. Обычный пользователь, как правило, не имеет привилегий для запуска или остановки системных программ и/или демонов.
### Ядро
Изменение конфигурационных файлов в ядре сразу влияет на систему. Например, изменение файла passwd для добавления пользователя немедленно активирует этого пользователя. Также есть некоторые настраиваемые параметры ядра в каталоге /proc/sys в любой системе Linux. Доступ к записи ко всем этим файлам предоставляется только суперпользователю; другие пользователи имеют доступ только для чтения
Также в каталоге /proc/sys в любой системе Linux есть некоторые настраиваемые параметры ядра. Редактирование этих файлов доступно только суперпользователю; другие пользователи имеют доступ только для чтения. Файлы в этом каталоге классифицируются таким же образом, как и исходный код ядра Linux. Каждый файл в этом каталоге представляет собой структуру данных ядра, которую можно динамически модифицировать для изменения производительности системы.
**Важно**: прежде чем менять какое-либо значение в любом из файлов, убедитесь, что вы знаете о нём всё, чтобы избежать непоправимого ущерба для системы.
**Файлы в каталоге /proc/sys/kernel/**
| | |
| --- | --- |
| **Название файла** | **Описание** |
| threads-max | максимальное количество задач, которые может выполнить ядро |
| ctrl-alt-del | If 1, то нажатие этой последовательности клавиш полностью перезагружает систему |
| sysrq | If 1, то Alt-SysRq активен |
| osrelease | отображает версию операционной системы |
| ostype | отображает тип операционной системы |
| hostname | имя хоста системы |
| domainname | сетевой домен, частью которого является система |
| modprobe | указывает, должен ли modprobe автоматически запускаться и загружать необходимые модули |
### Демоны и системные программы
Некоторые демоны во время работы внимательно следят за конфигурационными файлами и автоматически перезагружают их при изменении. Однако большинство демонов не выполняют автоматическую перезагрузку. Нам нужно как-то «сообщить» им, что конфигурационный файл изменился и его следует перезагрузить. Это можно сделать путем перезапуска служб с помощью команды service.
Например, если мы изменили конфигурацию сети, нам нужно указать:
```
service network restart.
```
**Примечание**: сервисы чаще всего представляют собой скрипты, находящиеся в каталоге /etc/rc.d/init.d/\*, и запускаются программой инициализации при загрузке системы. Чтобы перезапустить сервис, вы также можете сделать следующее:
```
/etc/rc.d/init.d/ start | stop | status
```
start, stop и status — значения, которые эти скрипты принимают в качестве входных данных для выполнения действия.
### Пользовательские программы
Пользовательская или системная программа считывает свой конфигурационный файл при каждом запуске. Однако некоторые системные программы запускаются при включении компьютера, и их поведение зависит от того, что они читают в конфигурационных файлах в /etc/. Таким образом, при первом запуске пользовательской программы конфигурация по умолчанию считывается из файлов, находящихся в каталоге /etc/. Позже пользователь может настроить программы с помощью rc и . (dot) files.
### Пользовательские конфигурационные файлы: . (dot) files and rc files
«Обычный» пользователь не может зайти в /etc и изменить конфигурационные файлы. С точки зрения файловой системы они принадлежат пользователю root. Вот почему большинство пользовательских программ определяют два конфигурационных файла:
* на «системном» уровне, расположенный в /etc/;
* «личный» для пользователя, который можно найти в домашнем каталоге.
Разберём на примере утилиты wget. В /etc/ есть файл /etc/wgetrc. В домашнем каталоге есть файл с именем .wgetrc, который описывает настроенную конфигурацию (которая будет загружена только тогда, когда пользователь выполнит команду wget). Другие пользователи также могут иметь файл .wgetrc в своем домашнем каталоге (/home/other). Этот файл будет прочитан, только тогда, когда пользователь запустит команду wget. Иными словами, файл /etc/wgetrc предоставляет значения «по умолчанию» для wget, а файл /home/xxx/.wgetrc перечисляет «настройки» для определенного пользователя.
Важно понимать, что это «общее правило», и оно не обязательно верно для всех случаев. Например, у программы pine нет файлов в /etc/, только пользовательская конфигурация в домашнем каталоге пользователя в файле с именем .pinerc. Другие программы могут иметь только файл конфигурации по умолчанию в /etc/ и могут не позволять пользователям «настраивать» их.
### Коротко о главном
В этой статье мы разобрали конфигурационные файлы, которые управляют пользовательскими разрешениями, системными приложениями, демонами и др. А также рассмотрели особенности процесса изменения конфигурационных файлов.
[«Администрирование Linux. Мега»](https://slurm.club/3D5ET95) | https://habr.com/ru/post/710398/ | null | ru | null |
# ORM — отвратительный анти-паттерн
От автора перевода: Написанный далее текст может не совпадать с мнением автора перевода. Все высказывания идут от лица оригинального автора, просьба воздержаться от неоправданных минусов. Оригинальная статья выпущена в 2014 году, поэтому некоторые фрагменты кода могут быть устаревшими или "нежелаемыми".
Содержание статьи:
1. [Вступление](#1)
2. [Как работают ORM](#2)
3. [Что не так с ORM](#3)
4. [SQL-speaking объекты](#4)
5. [Как насчет производительности?](#5)
6. [Что касается транзакций](#6)
Вступление
----------
**ORM** - это ужасный анти-паттерн, который нарушает все принципы объектно-ориентированного программирования, разбирая объекты на части и превращая их в тупые и пассивные пакеты данных. Нет никаких оправданий существованию ORM в любом приложении, будь то небольшое веб-приложение или система корпоративного размера с тысячами таблиц и манипуляциями CRUD с ними. Какова альтернатива? Объекты, говорящие на языке SQL (**SQL-speaking objects**).
Как работают ORM
----------------
[**Object-relational mapping**](https://en.wikipedia.org/wiki/Object%E2%80%93relational_mapping) (ORM) - это способ (он же шаблон проектирования) доступа к реляционной базе данных с помощью объектно-ориентированного языка (например, Java). Существует несколько реализаций ORM почти на каждом языке, например: [**Hibernate**](http://hibernate.org/orm/) для Java, [**ActiveRecord**](https://guides.rubyonrails.org/active_record_basics.html) для Ruby on Rails, [**Doctrine**](https://www.doctrine-project.org/) для PHP и [**SQLAlchemy**](https://www.sqlalchemy.org/) для Python. В Java ORM даже стандартизирован как [**JPA**](https://en.wikipedia.org/wiki/Jakarta_Persistence).
Во-первых, рассмотрим на примере как работает ORM. Давайте использовать Java, PostgreSQL и Hibernate. Допустим, у нас есть единственная таблица в базе данных, называемая **post**:
```
+-----+------------+--------------------------+
| id | date | title |
+-----+------------+--------------------------+
| 9 | 10/24/2014 | How to cook a sandwich |
| 13 | 11/03/2014 | My favorite movies |
| 27 | 11/17/2014 | How much I love my job |
+-----+------------+--------------------------+
```
Теперь мы хотим манипулировать этой таблицей CRUD-методами из нашего Java-приложения (CRUD расшифровывается как **create**, **read**, **update** и **delete**). Для начала мы должны создать класс Post (извините, что он такой длинный, но это лучшее, что я могу сделать):
```
@Entity
@Table(name = "post")
public class Post {
private int id;
private Date date;
private String title;
@Id
@GeneratedValue
public int getId() {
return this.id;
}
@Temporal(TemporalType.TIMESTAMP)
public Date getDate() {
return this.date;
}
public String getTitle() {
return this.title;
}
public void setDate(Date when) {
this.date = when;
}
public void setTitle(String txt) {
this.title = txt;
}
}
```
Перед любой операцией с Hibernate мы должны создать SessionFactory:
```
SessionFactory factory = new AnnotationConfiguration()
.configure()
.addAnnotatedClass(Post.class)
.buildSessionFactory();
```
Эта фабрика будет выдавать нам “сеансы” каждый раз, когда мы захотим работать с объектами Post. Каждая манипуляция с сеансом должна быть заключена в этот блок кода:
```
Session session = factory.openSession();
try {
Transaction txn = session.beginTransaction();
// your manipulations with the ORM, see below
txn.commit();
} catch (HibernateException ex) {
txn.rollback();
} finally {
session.close();
}
```
Когда сеанс будет готов, вот так мы получаем список всех записей из этой таблицы:
```
List posts = session.createQuery("FROM Post").list();
for (Post post : (List) posts) {
System.out.println("Title: " + post.getTitle());
}
```
Я думаю, вам ясно, что здесь происходит. Hibernate - это большой, мощный движок, который устанавливает соединение с базой данных, выполняет необходимые SELECT запросы и извлекает данные. Затем он создает экземпляры класса Post и заполняет их данными. Когда объект приходит к нам, он заполняется данными, и чтобы получить доступ к ним, необходимо использовать геттеры, как пример **getTitle()** выше.
Когда мы хотим выполнить обратную операцию и отправить объект в базу данных, мы делаем все то же самое, но в обратном порядке. Мы создаем экземпляр класса Post, заполняем его данными и просим Hibernate сохранить его:
```
Post post = new Post();
post.setDate(new Date());
post.setTitle("How to cook an omelette");
session.save(post);
```
Так работает почти каждая ORM. Основной принцип всегда один и тот же — объекты ORM представляют собой *немощные/анемичные* (прямой перевод слова **anemic**) оболочки с данными. Мы разговариваем с ORM фреймворком, а фреймворк разговаривает с базой данных. Объекты только помогают нам отправлять запросы в ORM framework и понимать его ответ. Кроме геттеров и сеттеров, у объектов нет других методов. Они даже не знают, из какой базы данных они пришли.
Вот как работает object-relational mapping.
Что в этом плохого, спросите вы? Все!
Что не так с ORM?
-----------------
Серьезно, что не так? Hibernate уже более 10 лет является одной из самых популярных библиотек Java. Почти каждое приложение в мире с интенсивным использованием SQL использует его. В каждом руководстве по Java будет упоминаться Hibernate (или, возможно, какой-либо другой ORM, такой как TopLink или OpenJPA) для приложения, подключенного к базе данных. Это стандарт де-факто, и все же я говорю, что это неправильно? Да.
Я утверждаю, что вся идея, лежащая в основе ORM, неверна. Его изобретение было, возможно, второй большой ошибкой в ООП после [NULL reference](https://www.yegor256.com/2014/05/13/why-null-is-bad.html).
> ORM, вместо того чтобы инкапсулировать взаимодействие с базой данных внутри объекта, извлекает его, буквально разрывая на части прочный и сплоченный живой организм.
>
>
На самом деле, я не единственный, кто говорит что-то подобное, и определенно не первый. Многое на эту тему уже опубликовано очень уважаемыми авторами, в том числе [OrmHate](https://martinfowler.com/bliki/OrmHate.html) автора **Martin Fowler** (не против ORM, но в любом случае стоит упомянуть), [Object-Relational Mapping is the Vietnam of Computer Science](https://blog.codinghorror.com/object-relational-mapping-is-the-vietnam-of-computer-science/) от **Jeff Atwood**, [The Vietnam of Computer Science](http://blogs.tedneward.com/post/the-vietnam-of-computer-science/) автора **Ted Neward**, [ORM Is an Anti-Pattern](https://seldo.com/posts/orm_is_an_antipattern) от **Laurie Voss** и многие другие.
Однако мои аргументы отличаются от того, что они говорят. Несмотря на то, что их доводы практичны и обоснованны, например, “*ORM работает медленно*” или “*обновление базы данных затруднено*”, они упускают главное. Вы можете увидеть очень хороший, практический ответ на эти практические аргументы, от **Bozhidar Bozhanov** в его блоге [ORM Haters Don't Get It](https://techblog.bozho.net/orm-haters-dont-get-it/).
 Суть в том, что ORM вместо того, чтобы инкапсулировать взаимодействие с базой данных внутри объекта, извлекает его, буквально разрывая на части прочный и сплоченный живой организм. Одна часть объекта хранит данные, в то время как другая, реализованная внутри механизма ORM (`sessionFactory`), знает, как обращаться с этими данными, и передает их в реляционную базу данных. Посмотрите на эту картинку; она иллюстрирует, что делает ORM.
Я, будучи читателем сообщений, должен иметь дело с двумя компонентами: 1) ORM и 2) возвращенный мне объект “ob-truncated”. Предполагается, что поведение, с которым я взаимодействую, должно предоставляться через единую точку входа, которая является объектом в ООП. В случае ORM я получаю такое поведение через две точки входа — механизм ORM и “предмет”, который мы даже не можем назвать объектом.
Из-за этого ужасного и оскорбительного нарушения объектно-ориентированной парадигмы у нас есть много практических проблем, уже упомянутых в уважаемых публикациях. Я могу добавить еще только несколько.
**SQL Не Скрыт**. Пользователи ORM должны говорить на SQL (или его диалекте, например, HQL). Смотрите пример выше; мы вызываем `session.CreateQuery("FROM Post")`, чтобы получить все сообщения. Несмотря на то, что это не SQL, он очень похож на него. Таким образом, реляционная модель не инкапсулируется внутри объектов. Вместо этого он доступен для всего приложения. Каждому, с каждым объектом, неизбежно приходится иметь дело с реляционной моделью, чтобы что-то получить или сохранить. Таким образом, ORM не скрывает и не переносит SQL, а загрязняет им все приложение.
**Трудно протестировать**. Когда какой-либо объект работает со списком записей, ему необходимо иметь дело с экземпляром `SessionFactory`. Как мы можем замокать эту зависимость? Мы должны создать имитацию этого? Насколько сложна эта задача? Посмотрите на приведенный выше код, и вы поймете, насколько подробным и громоздким будет этот модульный тест. Вместо этого мы можем написать интеграционные тесты и подключить все приложение к тестовой версии PostgreSQL. В этом случае нет необходимости имитировать `SessionFactory`, но такие тесты будут довольно медленными, и, что еще более важно, наши объекты, не имеющие ничего общего с базой данных, будут протестированы на экземпляре базы данных. Ужасный замысел.
Позвольте мне еще раз повторить. Практические проблемы ORM - это всего лишь последствия. Фундаментальный недостаток заключается в том, что ORM разрывает объекты на части, ужасно и оскорбительно нарушая саму идею того, что такое объект.
SQL-speaking объекты
--------------------
 Какова альтернатива? Позвольте мне показать вам это на примере. Давайте попробуем спроектировать класс Post. Нам придется разбить его на два класса: `Post` и `Posts`, единственное и множественное число. Я уже упоминал в одной из своих предыдущих статей, что хороший объект - это всегда абстракция реальной сущности. Вот как этот принцип работает на практике. У нас есть две сущности: таблица базы данных и строка таблицы. Вот почему мы создадим два класса. `Posts` будет представлять таблицу, а `Post` будет представлять строку.
Как я также упоминал в этой статье, каждый объект должен работать по контракту и реализовывать интерфейс. Давайте начнем наш дизайн с двух интерфейсов. Конечно, наши объекты будут неизменяемыми. Вот как будут выглядеть `Posts`:
```
interface Posts {
Iterable iterate();
Post add(Date date, String title);
}
```
Вот как будет выглядеть один `Post`:
```
interface Post {
int id();
Date date();
String title();
}
```
Вот так мы будем перечислять все записи в таблице базы данных:
```
Posts posts = // we'll discuss this right now
for (Post post : posts.iterate()) {
System.out.println("Title: " + post.title());
}
```
Вот так создаётся новый `Post`:
```
Posts posts = // we'll discuss this right now
posts.add(new Date(), "How to cook an omelette");
```
Как вы видите, теперь у нас есть настоящие объекты. Они отвечают за все операции, и они прекрасно скрывают детали их реализации. Нет никаких транзакций, сеансов или фабрик. Мы даже не знаем, действительно ли эти объекты взаимодействуют с PostgreSQL или они хранят все данные в текстовых файлах. Все, что нам нужно от `Posts` - это возможность перечислить все записи для нас и создать новую. Детали реализации идеально скрыты внутри. Теперь давайте посмотрим, как мы можем реализовать эти два класса.
Я собираюсь использовать [jcabi-jdbc](https://jdbc.jcabi.com/) в качестве оболочки JDBC, но вы можете использовать что-то другое, например [jOOQ](http://www.jooq.org/), или просто JDBC, если хотите. На самом деле это не имеет значения. Важно то, что ваши взаимодействия с базой данных скрыты внутри объектов. Давайте начнем с `Posts` и реализуем его в классе `PgPosts` (“pg” означает PostgreSQL):
```
final class PgPosts implements Posts {
private final Source dbase;
public PgPosts(DataSource data) {
this.dbase = data;
}
public Iterable iterate() {
return new JdbcSession(this.dbase)
.sql("SELECT id FROM post")
.select(
new ListOutcome(
new ListOutcome.Mapping() {
@Override
public Post map(final ResultSet rset) {
return new PgPost(
this.dbase,
rset.getInt(1)
);
}
}
)
);
}
public Post add(Date date, String title) {
return new PgPost(
this.dbase,
new JdbcSession(this.dbase)
.sql("INSERT INTO post (date, title) VALUES (?, ?)")
.set(new Utc(date))
.set(title)
.insert(new SingleOutcome(Integer.class))
);
}
}
```
Далее давайте реализуем интерфейс `Post` в классе `PgPost`:
```
final class PgPost implements Post {
private final Source dbase;
private final int number;
public PgPost(DataSource data, int id) {
this.dbase = data;
this.number = id;
}
public int id() {
return this.number;
}
public Date date() {
return new JdbcSession(this.dbase)
.sql("SELECT date FROM post WHERE id = ?")
.set(this.number)
.select(new SingleOutcome(Utc.class));
}
public String title() {
return new JdbcSession(this.dbase)
.sql("SELECT title FROM post WHERE id = ?")
.set(this.number)
.select(new SingleOutcome(String.class));
}
}
```
Вот как будет выглядеть сценарий полного взаимодействия с базой данных с использованием только что созданных нами классов:
```
Posts posts = new PgPosts(dbase);
for (Post post : posts.iterate()){
System.out.println("Title: " + post.title());
}
Post post = posts.add(
new Date(), "How to cook an omelette"
);
System.out.println("Just added post #" + post.id());
```
Вы можете увидеть полный практический пример [здесь](https://github.com/aintshy/hub/tree/0.7.2/src/main/java/com/aintshy/pgsql). Это веб—приложение с открытым исходным кодом, которое работает с PostgreSQL, используя точный подход, описанный выше, - объекты, говорящие на SQL.
Как насчет производительности?
------------------------------
Я слышу, как вы спрашиваете: “А как же производительность?” В этом сценарии, приведенном несколькими строками выше, мы совершаем множество избыточных обходов базы данных. Сначала мы извлекаем идентификаторы записей с помощью `SELECT id`, а затем, чтобы получить их заголовки, мы выполняем дополнительный вызов `SELECT title` для каждой записи. Это неэффективно или, проще говоря, слишком медленно.
Не беспокойтесь, это объектно-ориентированное программирование, а это значит, что оно гибкое! Давайте создадим декоратор `PgPost`, который будет принимать все данные в своем конструкторе и кэшировать их внутри навсегда:
```
final class ConstPost implements Post {
private final Post origin;
private final Date dte;
private final String ttl;
public ConstPost(Post post, Date date, String title) {
this.origin = post;
this.dte = date;
this.ttl = title;
}
public int id() {
return this.origin.id();
}
public Date date() {
return this.dte;
}
public String title() {
return this.ttl;
}
}
```
Обратите внимание: этот декоратор ничего не знает о PostgreSQL или JDBC. Он просто декорирует объект типа `Post` и предварительно кэширует дату и заголовок. Как обычно, этот декоратор также неизменяем.
Теперь давайте создадим другую реализацию `Posts`, которая будет возвращать “постоянные” объекты:
```
final class ConstPgPosts implements Posts {
// ...
public Iterable iterate() {
return new JdbcSession(this.dbase)
.sql("SELECT \* FROM post")
.select(
new ListOutcome(
new ListOutcome.Mapping() {
@Override
public Post map(final ResultSet rset) {
return new ConstPost(
new PgPost(
ConstPgPosts.this.dbase,
rset.getInt(1)
),
Utc.getTimestamp(rset, 2),
rset.getString(3)
);
}
}
)
);
}
}
```
Теперь все записи, возвращаемые `iterate()` этого нового класса, предварительно снабжены датами и заголовками, полученными за одно обращение к базе данных.
Используя декораторы и несколько реализаций одного и того же интерфейса, вы можете создать любую функциональность, которую пожелаете. Что наиболее важно, так это то, что, хотя функциональность расширяется, сложность дизайна не возрастает, потому что классы не увеличиваются в размерах. Вместо этого мы вводим новые классы, которые остаются сплоченными и прочными, потому что они маленькие.
Что касается транзакций
-----------------------
Каждый объект должен иметь дело со своими собственными транзакциями и инкапсулировать их так же, как запросы `SELECT` или `INSERT`. Это приведет к вложенным транзакциям, что вполне нормально при условии, что сервер базы данных их поддерживает. Если такой поддержки нет, создайте объект транзакции для всего сеанса, который будет принимать “вызываемый” класс. Например:
```
final class Txn {
private final DataSource dbase;
public T call(Callable callable) {
JdbcSession session = new JdbcSession(this.dbase);
try {
session.sql("START TRANSACTION").exec();
T result = callable.call();
session.sql("COMMIT").exec();
return result;
} catch (Exception ex) {
session.sql("ROLLBACK").exec();
throw ex;
}
}
}
```
Затем, когда вы хотите обернуть несколько манипуляций с объектами в одну транзакцию, сделайте это следующим образом:
```
new Txn(dbase).call(
new Callable() {
@Override
public Integer call() {
Posts posts = new PgPosts(dbase);
Post post = posts.add(
new Date(), "How to cook an omelette"
);
post.comments().post("This is my first comment!");
return post.id();
}
}
);
```
Этот код создаст новую запись и опубликует комментарий к ней. Если один из вызовов завершится неудачей, вся транзакция будет откачена.
Мне этот подход кажется объектно-ориентированным. Я называю это “объектами, говорящими на SQL”, потому что они знают, как разговаривать на SQL с сервером базы данных. Это их мастерство, идеально заключенное в их границах. | https://habr.com/ru/post/667078/ | null | ru | null |
# OCR за час? — Не думаю
### О задаче
Одним прекрасным вечером коллега попросил подумать над алгоритмом поворота серийных номеров на металлических брусках — бруски овальные, серийные номера выбиты на их торцах, и ориентация надписи может быть произвольной (пример на картинке ниже).
Предполагалось, что если повернуть брусок так, чтобы номер располагался горизонтально, это поможет распознаванию. Один из возможных вариантов поворота придумать несложно, об этом ниже. Но глобально задача предполагала именно распознавание. Ранее задачами OCR глубоко я не занимался, и мне стало интересно, на что способны имеющиеся коробочные решения. Казалось бы, они должны легко решить нашу задачу за час. О том, что было на самом деле, и пойдет речь в этой статье.
### Paddle OCR
Одним из самых популярных репозиториев на Github и Papers With Code является [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR). Обычно OCR-пайплайны сначала детектируют области с текстом, а потом, с помощью так называемого recognizer’a, извлекают текст. PaddleOCR тут не исключение. Единственное усложнение - добавление [классификатора](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.4/doc/doc_en/angle_class_en.md) ориентации текста после детекции, что позволяет модели отрабатывать на текстах с ориентацией, кратной  (Рисунок 1).
Рисунок 1. Cхема работы PaddelOCR (Github).Сразу перейдем к примерам:
Рисунок 2. Пример с вертикально ориентированным номером (размер 450х523).Например, на такой картинке **(Рисунок 2)** PaddleOCR отлично справился с распознаванием номера 84612000 (confidence 0.98), а 281 не нашел вообще.
Рисунок 3. Пример с наклонным углом (размер 603х600).А вот на этом изображении **(Рисунок 3)** нашел:
* `('612', 0.988)`(значение в кавычках - распознанный текст, число рядом - confidence модели, далее результаты распознавания буду предоставлять в таком формате);
* `('C', 0.902)`;
* `('*8', 0.834)`.
Получаем лишь куски номеров или вовсе не то, что нужно.
### Поворачиваем текст
Окей, PaddleOCR не завелся идеально из коробки, пришлось поворачивать бруски. Идейно подход такой:
* сегментируем область с номером, получаем маску. Нестрого говоря, она имеет вид эллипса - то есть вытянута вдоль одной из осей.
* Далее через точки маски строится линейная регрессия.
* Зная коэффициент наклона прямой, находим угол поворота.
Рисунок 4. Схема алгоритма поворота надписи.### Тест Open Source решений
Для примера в статье возьму часть фотографии, на которой PaddleOCR не отработал, а именно часть фотографии с номером 281 (Рисунок 5)
Рисунок 5. Часть фотографии после поворота (размер 367x180).#### Подход №1. "В лоб"
* **PaddleOCR**
Тестируем PaddleOCR на повернутом тексте. Ничего не обнаруживается. Кстати, расположение текста мы уже "детектировали" с предыдущего этапа с поворотом номера и возникает вопрос: может быть детектор косячит, и попробовать отдать номер сразу в recognizer?
Окей, recognizer что-то распознал, но на номер это не похоже: `('HEi', 0.567)`.
* **Tesseract**
Возьмем представителя старой школы - [Tesseract](https://github.com/tesseract-ocr/tesseract#installing-tesseract) ([python wrapper](https://github.com/madmaze/pytesseract)).
Ожидаемо, он справляется не очень хорошо - ничего не видит.
И действительно, Tesseract довольно требователен к входным данным, есть даже отдельный раздел в документации по [улучшению данных](https://tesseract-ocr.github.io/tessdoc/ImproveQuality.html) на входе.
* **EasyOCR**
Рисунок 6. Схема работы EasyOCR (Github).
[EasyOCR](https://github.com/JaidedAI/EasyOCR) использует в качестве детектора текста [CRAFT](https://github.com/JaidedAI/EasyOCR), а в качестве recognizer'a - ResNet50 + LSTM + CTC Loss. Реализовано все на PyTorch. Надо сказать, что документации у EasyOCR простая и понятная, а recognizer довольно просто дообучить на своих данных.
Но вернёмся к результату на нашем примере. EasyOCR находит что-то более осмысленное:
* С детектором видит `('201', 0.728)`;
* Без детектора `('3281', 0.237)` - нашел даже больше, чем надо.
Замечу, что с настройками по умолчанию, EasyOCR производит вычисления для 4 изображений, повернутых на 0, 90, 180 и 270 градусов. Можно задать свои настройки для углов поворота. Если вы уверены, что текст ориентирован горизонтально,можно указать лишь один угол для экономии времени.
#### Подход №2. Бинаризация
Как оказалось, для моделей OCR довольно сложно распознавать текст, имеющий сложную форму и структуру (у нас символы состоят из светлых и темных частей за счет преломления света) на произвольном фоне. Попробуем избавиться от фона и минимизировать переливы света на выбитых цифрах за счет бинаризации фотографии. Для примера возьмем всё то же изображение.
Рисунок 7. Рисунок 5 после бинаризации.* **PaddleOCR**
А вот на бинаризованной фотографии paddle отработал исправно - `('281', 0.964)`
Recognizer без детектора нашел только `('t', 0.541)`
* **Tesseract**
Still nothing.
* **EasyOCR**
EasyOCR с детектором тоже справился - `('281', 0.983)`
А вот без детектора все еще находит лишнее - `('7281', 0.396)` (возможно, потому что на нашей фотографии 2 сильно похожа на 7)
#### Подход №2.1 Инвертированние
В качестве гипотезы, проверили, что будет, если инвертировать бинаризованное изображение так, чтобы текст стал черным, а фон белым - кажется, что модели должны были чаще видеть именно такой формат.
Рисунок 8. Инвертированный рисунок 7.Ниже в таблице приведены результаты моделей на рисунках 6-8.
Таблица 1. Результаты из подходов №1, №2, №2.1.
| Модель | Результат подхода №1 | Результат подхода №2 | Результат подхода №2.1 |
| --- | --- | --- | --- |
| PaddleOCR | \_ | ('281', 0.964) | ('8 2', 0.823) |
| PaddleOCR (recognizer only) | ('HEi', 0.567) | ('t', 0.541) | ('zal', 0.409) |
| Tesseract | - | - | - |
| EasyOCR | ('201', 0.728) | ('281', 0.983) | ('8281', 0.354) |
| EasyOCR (recognizer only) | ('3281', 0.237) | ('7281', 0.396) | ('7281', 0.199) |
### Telegram OCR
Казалось, что современные open source решения должны отрабатывать более стабильно. Поэтому, немного разочаровавшись в результатах, мы решили протестить OCR, встроенный в какое нибудь приложение. Как оказалось, в Telegram для iOS есть встроенный OCR, о котором узнали случайно, просто пересылая фотографию. Загрузили нашу картинку в "телегу" и опа! - он нашел "281" и для оригинальной фотографии, и для бинаризованной версии, а вот для инвертированной версии тоже выдал нечто - "2. 8 Fa" (хотя с "2. 8" можно согласиться).
### Выводы и варианты улучшения распознавания
Данная статья не претендует на какую-либо серьезность, скорее показывает на что можно расчитывать, запустив практически втупую современные коробочные решения на вашей задаче.
* Как и следовало ожидать, решения из коробки не дают отличных результатов на специфичных задачах. Без "докручивания" кастомными алгоритмами обойтись сложно.
* Скорее всего, модели в обучающей выборке видели не очень много выдавленных в металле цифр, и fine tuning моделей должен сильно улучшить результаты - эксперимент с бинаризацией это подтверждает. C другой стороны, Telegram справился, то есть существуют модели, которые "могут".
* Возможно, для конкретно такой задачи использованные модели OCR это overkill и следует использовать детекцию каждой отдельной цифры. | https://habr.com/ru/post/660405/ | null | ru | null |
# Учимся правильно писать CSS классы в JSX
Казалось бы такая простая тема как написание css-классов не должна быть проблемой, однако я встречал довольно много проектов, где допускаются ошибки, пишутся непроизводительные велосипеды, что приводит к ошибкам на продакшене и плохо читаемому коду.
Где проблема актуальна? В экосистеме React, и где мы пользуемся замечательным синтаксисом под названием JSX.
Согласно данным NPM Trends, если мы сложим количество использований двух популярных библиотек `clsx` и `classnames` для помощи в написании классов, мы увидим, что на данный момент около 300 тысяч проектов не имеют этих библиотек в качестве зависимостей. Добавив сюда 1 миллион 100 тысяч проектов на библиотеке Preact, получим около 1,5 миллиона проектов, где ни одна из этих двух библиотек не используется.
Также бывает, что библиотека есть, просто не используется разработчиками.
react vs classnames vs clsx### Почему именно эти библиотеки?
Они добавляют удобство за счет продуманного синтаксиса, который прекрасно подходит для решения большинства задач, связанных с множеством классов, которые мы задаем согласно определенным условиям.
Конечно, Javascript предлагает множество вариантов решения такой проблемы. Например, Template Literals или использование массива с последующим `join`.
Но давайте для начала рассмотрим примеры кода.
Вот, простой компонент, который должен иметь условный класс в зависимости от определенных условий:
```
const Button = (props) => (
{props.children}
)
```
Терпимо? В целом да, если не смотреть на феерию скобочек и кавычек в конце `'}`}>`
Однако данный код зарендерит следующее в зависимости от значения `pressed`:
```
Button
Button
Button
```
Окей. Нехорошо. Давайте попробуем тернарный оператор:
```
const Button = (props) => (
{props.children}
)
```
и... получаем лишний пробел в конце:
```
Button
Button
```
Это уже не так критично, однако, давайте рассмотрим пример из реального мира, путем усложнения количества свойств, а также добавим возможность передавать класс с помощью props:
```
const Card = (props) => {
const { className, elevated, outlined } = props;
return (
{props.children}
)
}
```
Конечно, можно использовать промежуточные переменные, использовать массив и метод `join(' ')`, иначе у нас появятся двойные или тройные пробелы. Или добавить очередной webpack-плагин, который бы это исправил... или... просто использовать библиотеку:
```
import clsx from 'clsx'
const Card = (props) => {
const { className, elevated, outlined } = props;
return (
{props.children}
)
}
```
В данном случае эта библиотека добавит вам 228 дополнительных байт, что будет ничем не хуже самописного велосипеда. А благодаря популярности и унифицированному синтаксу, который работает в этих обоих библиотеках, это больший выигрыш в отношении поддержки такого кода.
Как результат мы получили более читаемый код, который легче поддерживать, и который создает аккуратный html без случайных символов и слов.
Внимательный читатель заметит, что использовать глобальные css-классы нынче моветон, и будет прав. Если вы используете css-modules или JSS подход, это намного повышает надежность продуциемого кода, искореняя потенциальные конфликты стилей.
```
import clsx from 'clsx'
import classes from './index.modules.css'
const Card = (props) => {
const { className, elevated, outlined } = props;
return (
{props.children}
)
}
```
### Так какую библиотеку использовать? clsx или classnames
Если вы введете этот вопрос в Google, то возможно получите такой же ответ как и я:
Просто используй clsxИз статьи "[Вы не знаете библиотеку classnames](https://areknawo.com/you-dont-know-the-classnames-library)" Арека Нао вы сможете узнать, что библиотека `classnames` имеет более богатый функционал, которым... никто не пользуется. А синтаксис библиотеки `clsx` такой же, при том, что она быстрее и легче (правильно: функционала-то меньше).
Причина в высокой скорости библиотеки -- ее простота и использование `for`, `while` циклов, конкатенция строк вместо операций над массивами. [Исходный код на GitHub](https://github.com/lukeed/clsx/blob/master/src/index.js).
### Позвольте, но есть же альтернатива
Конечно же есть. Один из паттернов, про который все забыли -- это так называемые `data-` атрибуты. Ничто не мешает заменить лапшу из css-классов `btn btn-elevated btn-large` на `data-variant="elevated"` `data-size="large"`.
А затем, написать подобный css:
```
.button {}
.button[data-size="small"] {}
.button[data-size="large"] {}
.button[data-variant="elevated"] {}
.button:disabled,
.button[data-state="disabled"] {
/** Последний вариант иногда нужен,
чтобы иметь возможность кликнуть по кнопке
для получения определенного фидбека
*/
}
```
К сожалению, у этого подхода на самом деле один жирный минус. И нет, это не производительность браузера при поиске селекторов. **Так никто не делает**. А это значит отсутствие привычных инструментов: минификация css-классов доступна из коробки, а здесь придется что-то придумывать. Неудобный синтаксис, если мы используем JSS решения с object нотацией.
Напишите в комментариях, что вы думаете по поводу такого подхода?
### Бонус для разработчиков на Preact
Одной из киллер-фич этой библиотеки на заре была возможность использования ключевого слова `class` для использования его в JSX. Я помню, как способ задания css с помощью `className` был камнем преткновения для множества разработчиков, которым показали React и JSX. Однако... время показало, что `className` удобнее своей универсальностью. И сейчас я покажу почему:
В примере сверху мы разбирали вариант, где в компонент передавался параметр `className`, который обычно добавляется к корневому DOM-элементу компонента.
И если мы еще можем передавать `class` внутри JSX разметки, использовать этот ключ при декомпозиции объекта `props` или указывать его в интерфейсах Typescript уже не получится никак. Как результат, на моей практике я сталкивался с таким зоопарком в наименовании: `customClass`, `parentClass`, `rootClass`, `mainClass`, и так далее. Как результат, вместо упрощения мы получили усложнение и неконсистентность.
Поэтому во всех Preact проектах я использую привычное всем `className` вместе с набором совместимости `preact/compat`.
#### Бонус к бонусу или ремарка о статическом кодоанализе
> Если что-то можно автоматизировать ценой пары кликов, оно должно быть автоматизировано.
>
>
Для того, чтобы запретить эти нестандартные атрибуты в JSX можно сконфигурировать очень [популярный плагин](https://github.com/yannickcr/eslint-plugin-react) для eslint [следующим образом](https://github.com/yannickcr/eslint-plugin-react/blob/master/docs/rules/forbid-component-props.md):
```
"react/forbid-component-props": ["on", {
"forbid": ["class", "customClass", "parentClass"]
}]
```
### Мораль сей басни такова
Лишняя пара-тройка килобайт всегда стоит того, чтобы ваш код был более читаемым, поддерживаемым и содержал меньше ошибок. А порой, такая библиотека как `clsx` может оказаться быстрее вашей имплементации. | https://habr.com/ru/post/649381/ | null | ru | null |
# Пишем свой фондовый индекс (API Тинькофф, FastApi, TradingView)
Здравствуйте дорогие хабровчане, в этом посте я покажу, как написать свой биржевой индекс наподобие S&P 500 или Nasdaq.
О том, как мне это пришло в голову можно прочитать в моей предыдущей статье: [Как я решил стать трейдером и проигрался, а потом отыгрался, потому, что я программист. Мой опыт](https://habr.com/ru/post/651241/). Здесь будет рассмотрена только **техническая сторона**.
В силу того, что прошлая статья получила большой отклик у хабровчян, я решил сделать техническое описание кода приложения.
Не работаю в Тинькофф и мне не заплатили за рекламу. Конечно, была попытка добавить эту статью в корпоративный блог Тинькова хоть за символическую плату, но не тут то было. Меня просто месяц динамили, а потом сказали, дескать блог только исключительно для сотрудников компании (должно быть это месть за критику службы поддержки в прошлой статье).
В предыдущей [статье](https://habr.com/ru/post/651241/) было описано, как мне удалось рассчитать и использовать индекс чистой стоимости фонда и как я к этому пришёл. Этот индекс был написан на старом api, на тот момент единственном. Из-за этого возникло множество проблем, главная из которых большая задержка в обновлении данных.
Чтобы уменьшить эту задержку (которая в итоге составила 5,5 секунд!), мне пришлось использовать два токена доступа, которые чередовались для каждого запроса. Также я вынужден был выбрать строго ограниченное количество компаний, для которых проводился расчёт. Бутылочным горлышком являлось отсутствие возможности получать данные по нескольким компаниям в одном запросе. Например, чтобы получить текущие цены акций десяти компаний нужно было десять запросов. Если не укладывался в лимит, а количество запросов было ограничено в минуту, api возвращал ошибки на последующие обращения.
Однако, в начале 2022 года тинькофф выкатил новый [api](https://tinkoff.github.io/investAPI/), в котором эти проблемы были решены. Теперь можно в одном запросе получать все текущие цены на акции.
Сам микросервис написан на Python 3 и упакован в Docker-контейнер, клиент — на JavaScript, график [TradingView](https://www.tradingview.com/HTML5-stock-forex-bitcoin-charting-library/). Микросервис и клиент общаются при помощи api реализованном на [FastApi](https://fastapi.tiangolo.com/).
[Репозиторий с исходным кодом — на GitHub](https://github.com/cdies/custom_fund_index).
Шаг 1. Получаю данные из Тинькофф api
-------------------------------------
[custom\_index.py](https://github.com/cdies/custom_fund_index/blob/main/microservice/custom_index.py):
**Показать...**
```
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import logging
import sys
from tinkoff.invest import Client, CandleInterval
import warnings
warnings.filterwarnings("ignore", 'This pattern has match groups')
class CustomIndex:
def __init__(self, tickets, historical_days=2, token='token.txt'):
self.logger = self.__create_logger()
self.historical_days = historical_days
self.reset_last_candle()
try:
with open(token, 'r') as file:
self.__token = file.read().rstrip()
except Exception as e:
self.logger.exception(e)
raise Exception('--> Ошибка в файле token.txt: '+ str(e))
try:
with Client(self.__token) as client:
shares = client.instruments.shares()
except Exception as e:
self.logger.exception(e)
raise Exception('--> tinkoff api - Ошибка загрузки данных обо всех акциях.')
shares = pd.DataFrame(shares.instruments)
self.df = shares[shares['ticker'].isin(tickets)]
def reset_last_candle(self, open_price=0.0, time=pd.Timestamp(0, tz='Europe/Moscow')):
self.last_candle = pd.Series({'open': open_price,
'high': open_price,
'low': open_price,
'close': open_price,
'time': time})
def round_to_minutes(self, t, interval=5):
delta = pd.Timedelta(minutes=t.minute % interval,
seconds=t.second,
microseconds=t.microsecond)
t -= delta
return t
def __units_nano_convert(self, d):
price = '{}.{}'.format(d['units'], d['nano'])
price = float(price)
return price
def __create_logger(self):
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
formatter = logging.Formatter('--> %(asctime)s - %(name)s - %(levelname)s - %(message)s')
sh = logging.StreamHandler(sys.stdout)
sh.setFormatter(formatter)
logger.addHandler(sh)
# send logs in docker logs
fh = logging.FileHandler('/proc/1/fd/1')
fh.setFormatter(formatter)
logger.addHandler(fh)
return logger
def get_tinkoff_candles(self, figi, interval):
if interval == 1:
interval = CandleInterval.CANDLE_INTERVAL_1_MIN
elif interval == 5:
interval = CandleInterval.CANDLE_INTERVAL_5_MIN
elif interval == 15:
interval = CandleInterval.CANDLE_INTERVAL_15_MIN
else:
interval = -1
curr_time = datetime.now()
data = []
for day in range(self.historical_days):
try:
with Client(self.__token) as client:
data += client.market_data.get_candles(
figi=figi,
from_=curr_time - timedelta(days=day+1),
to=curr_time - timedelta(days=day),
interval=interval
).candles
except Exception as e:
self.logger.exception(e)
raise Exception('--> tinkoff api - history - Ошибка загрузки исторических данных.')
candles = pd.DataFrame(data)
for col in ['open', 'high', 'low', 'close']:
candles[col] = candles[col].apply(self.__units_nano_convert)
candles = candles[['time', 'open', 'high', 'low', 'close']]
candles['time'] = candles['time'].dt.tz_convert('Europe/Moscow')
candles.set_index('time', inplace=True)
candles = candles.drop_duplicates()
return candles
def get_tinkoff_last_prices(self):
try:
with Client(self.__token) as client:
last_prices = client.market_data.get_last_prices(figi=self.df['figi'].to_list())
except Exception as e:
self.logger.exception(e)
raise Exception('--> tinkoff api - last price - Ошибка загрузки последней цены.')
last_prices = pd.DataFrame(last_prices.last_prices)
last_prices = last_prices['price'].apply(self.__units_nano_convert)
return last_prices
```
У каждой компании, торгующейся на бирже, кроме названия, есть свой тикер. Однако, для того, чтобы получить данные по компании необходимо знать её `figi` код. Чтобы его получить необходимо сопоставить тикер и `figi` код. Это происходит в конструкторе класса `CustomIndex`. В нём скачиваются `figi` для всех акций и сопоставляются с нужными мне тикерами. Здесь нет ничего сложного.
Метод `get_tinkoff_candles` получает исторические данные по `figi` коду. Исходя из [ограничений api](https://tinkoff.github.io/investAPI/faq_marketdata/#_7) на интервалах 1, 5 и 15 минут можно получить только один день. Так же было и в старом api. То есть, чем больше исторических данных мне нужно, тем больше нужно запросов ([ограничение](https://tinkoff.github.io/investAPI/limits/) запросов в минуту никуда не делось). Любопытно было бы узнать, из каких соображений данные ограничили одним днём.
Ну и главное отличие от старого api я с удовольствием использовал в методе `get_tinkoff_last_prices`. В нём обновляются все последние цены для всех акций за один запрос.
Шаг 2. Микросервис (FastApi)
----------------------------
[tinkoff-microservice.py](https://github.com/cdies/custom_fund_index/blob/main/microservice/tinkoff-microservice.py):
**Показать...**
```
import pandas as pd
import numpy as np
from collections import defaultdict
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from custom_index import CustomIndex
# Топ 5 самых дорогих акций из S&P 500
tickets = ['NVR', 'AMZN', 'GOOG', 'GOOGL', 'BKNG']
# Количество исторических дней для отображения
historical_days = 4
# Расчёт индекса
def compute_index(prices):
mean_price = np.mean(prices)
return mean_price
api = FastAPI()
api.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
ci = CustomIndex(tickets, historical_days=historical_days, token='token.txt')
# Исторические данные
@api.get('/api/historical_candles/{interval}')
def historical_candles(interval: int):
global ci
# Средняя цена
d = defaultdict(pd.DataFrame)
# Собираем данные, все open от всех тикеров в один
# датафрейм, high в другой и т.д.
def concat_columns(d, one_ticket_candles):
for col in ['open', 'high', 'low', 'close']:
d[col] = pd.concat([d[col], one_ticket_candles[col]], axis=1)
return d
try:
# Исторические данные для каждого тикера
# скачиваем и обрабатываем отдельно
for _, row in ci.df.iterrows():
one_ticket_candles = ci.get_tinkoff_candles(row['figi'], interval)
d = concat_columns(d, one_ticket_candles)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
for col in ['open', 'high', 'low', 'close']:
d[col] = d[col].sort_index(ascending=True)
d[col] = d[col].fillna(method='ffill')
d[col] = d[col].dropna()
d[col] = d[col].apply(compute_index, axis=1)
candles = pd.DataFrame(d)
candles.index.name = 'time'
candles.reset_index(inplace=True)
ci.reset_last_candle()
return candles.to_json(orient="records")
# Текущая цена
@api.get('/api/currient_candle/{interval}')
def currient_candle(interval: int):
global ci
curr_time = ci.round_to_minutes(pd.Timestamp.now(tz='Europe/Moscow'), interval)
try:
last_prices = ci.get_tinkoff_last_prices()
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
last_price = compute_index(last_prices)
# формирование свечей по последней цене
if curr_time > ci.last_candle['time']:
# Новая свеча
ci.reset_last_candle(open_price=last_price, time=curr_time)
else:
ci.last_candle['close'] = last_price
if ci.last_candle['high'] < last_price:
ci.last_candle['high'] = last_price
elif ci.last_candle['low'] > last_price:
ci.last_candle['low'] = last_price
return ci.last_candle.to_json()
```
Через этот микросервис поставляются данные клиенту. Основные параметры для настройки находятся в начале файла.
* Лист `tickets` — в нём записаны тикеры компании на основе которых будет рассчитываться индекс. Для примера я взял 5 самых дорогих акций из списка S&P 500.
* Переменная `historical_days` — количество исторических дней для загрузки. Если дней будет слишком много, то можно получить ошибки, см. [лимитную политику](https://tinkoff.github.io/investAPI/limits/).
* Функция `compute_index` — здесь происходит непосредственный расчёт индекса, в моём случае я просто беру среднюю цену всех акций.
В функции `historical_candles` формируются исторические данные. Для их расчёта группируются все цены каждого тикера, т.е. цены `open`, `high`, `low` и `close` рассчитываются отдельно друг от друга. На выходе получаются исторические данные рассчитанного индекса.
Функция `currient_candle` формирует текущую свечку графика и рассчитывает индекс исходя из текущих цен на акции.
Шаг 3. Клиент (TradingView)
---------------------------
[index.html](https://github.com/cdies/custom_fund_index/blob/main/html/index.html):
**Показать...**
```
Custom fund index
Custom fund index chart
-----------------------
1 minute
5 minutes
15 minutes
```
Файл `index.html` совсем простой, содержит в себе переключатель 'radio' для изменения интервала графика 1, 5 и 15 минут, также `div` контейнер `custom_chart` для самого графика. Здесь же подключены скрипты TradingView.
[index.js](https://github.com/cdies/custom_fund_index/blob/main/html/index.js):
**Показать...**
```
const log = console.log;
let interval = document.querySelector('input[name="interval"]:checked').value;
let currInterval = interval
const chartProperties = {
width: 1450,
height: 600,
timeScale: {
timeVisible: true,
secondsVisible: false,
}
};
const domElement = document.getElementById('custom_chart');
const chart = LightweightCharts.createChart(domElement, chartProperties);
const candleSeries = chart.addCandlestickSeries()
// History
function getHistory(interval) {
fetch(`http://127.0.0.1:8000/api/historical_candles/` + interval)
.then(res => res.json())
.then(json_str => JSON.parse(json_str))
.then(data => {
// log(data);
for (let i = 0; i < data.length; ++i) {
data[i].time = data[i].time / 1000 + 10800; // localize to Moscow time 60*60*3 = 10800
};
candleSeries.setData(data);
})
.catch(err => log(err))
}
getHistory(interval);
// Dynamic Chart
setInterval(function () {
currInterval = document.querySelector('input[name="interval"]:checked').value;
if (currInterval != interval) {
getHistory(currInterval);
interval = currInterval;
}
fetch(`http://127.0.0.1:8000/api/currient_candle/` + interval)
.then(res => res.json())
.then(json_str => JSON.parse(json_str))
.then(data => {
log(data);
data.time = data.time / 1000 + 10800 // localize to Moscow time 60*60*3 = 10800
candleSeries.update(data);
})
.catch(err => log(err))
}, 1000); // <-- Увеличивай интервал здесь!
```
В файле `index.js` функция `getHistory` получает исторические данные из микросервиса и отображает график. Обновление текущей цены происходит в планировщике вызова `setInterval`, здесь же обновляются исторические данные, если поменять интервал свечей графика.
Шаг 4. Упаковываем в Docker контейнер
-------------------------------------
[Dockerfile](https://github.com/cdies/custom_fund_index/blob/main/microservice/Dockerfile):
**Показать...**
```
FROM python:3.8
RUN python -m pip install pandas numpy tinkoff-investments fastapi gunicorn uvicorn uvloop httptools
WORKDIR /app
ADD tinkoff-microservice.py tinkoff-microservice.py
ADD custom_index.py custom_index.py
ADD token.txt token.txt
```
Упакованный в Docker-контейнер микросервис очень удобно использовать и портировать.
[docker-compose.yml](https://github.com/cdies/custom_fund_index/blob/main/docker-compose.yml):
**Показать...**
```
version: '3.7'
services:
microservice:
build:
context: ./microservice
image: tinkoff-microservice
container_name: tinkoff-microservice
restart: unless-stopped
ports:
- "8000:8000"
command: gunicorn -b 0.0.0.0:8000 -k uvicorn.workers.UvicornWorker tinkoff-microservice:api
nginx:
image: nginx
container_name: nginx-html
restart: unless-stopped
volumes:
- ./html:/usr/share/nginx/html:ro
depends_on:
- microservice
ports:
- "8080:80"
```
Микросервис и клиент общаются между собой через порт `8000`, клиент доступен на `localhost:8080`
**Примечание:** для работы приложения нужен docker-compose и браузер. Чтобы запустить микросервис необходимо добавить свой [токен](https://tinkoff.github.io/investAPI/token/) от тиньков api в файл `token.txt`, который находится в папке `microservice`. Выполнить в корневой папке проекта `docker-compose up --build` и открыть в браузере `http://localhost:8080/`.
Заключение
----------
Как и было отмечено в предыдущей [статье](https://habr.com/ru/post/651241/), подобный индекс вполне себе рабочий инструмент. Однако есть несколько недочетов, которые не удалось решить (возможное решение это stream-соединения в тинькофф api):
* Не совсем точное отображение истории.
* Ошибки из-за превышения лимита запросов к тинькофф api.
Спасибо за внимание. | https://habr.com/ru/post/656547/ | null | ru | null |
# Elixir: Развёртывание приложений с помощью Edeliver
Мы уже обсуждали сборку и развёртывание приложений **Elixir**(*перев: с помощью **[exrm](https://github.com/bitwalker/exrm)***): как [осуществлять миграции поверх релиза](http://blog.plataformatec.com.br/2016/04/running-migration-in-an-exrm-release/) или как [работать с переменными среды](http://blog.plataformatec.com.br/2016/05/how-to-config-environment-variables-with-elixir-and-exrm/). Пришло время открыть для себя ещё один инструмент, который поможет развёртывать **Elixir** приложения.
Практика развёртывания **Elixir** приложений и дальнейшее отслеживание их работы на нодах с помощью **Exrm** позволяет нам чувствовать себя гораздо увереннее в вопросах управления релизами в *production*. Однако возникает следующий вопрос: как управлять самим процессом развёртывания? Конечно, мы можем воспользоваться **[Capistrano](http://capistranorb.com/)**, особенно если в мир **Elixir** мы пришли из **Rails**. Но посмотрим на цитату из *Edeliver README*:
> **edeliver** основан на доставке и предоставляет *bash*-скрипт для сборки и развёртывания Elixir и Erlang приложений, а так же позволяет совершать "горячее" обновление кода.
Пытаться организовать весь процесс развёртывания вручную — это жёсткая головная боль с кучей повторяющегося кода. А вот использование **Edeliver** для развёртывания оказалось очень простым с первой же попытки! В конце концов, весь процесс развёртывания уместился в один меленький *bash*-скрипт:
```
#!/bin/bash -ex
BRANCH=${1:-master};
mix edeliver build release --branch=BRANCH --verbose
mix edeliver deploy release to production --verbose
mix edeliver start production --verbose
mix edeliver migrate production up --verbose
```
Скорее всего Вам придётся подкрутить этот скрипт под собственные нужды. Мы используем его только для развёртывания в *production*, но Вы так же можете использовать его и для *staging* развёртываний. Описание того, как всё это работает — под катом.
Как это работает
----------------
Как мы видели в README, **Edeliver** работает в основном с помощью *bash*-скриптов. Команды **Mix** исполняются с помощью **Elixir**, но фактически они запускают *bash*-скрипты. Некоторые инструкции терминала выполняются локально: они создают новые инструкции, которые будут выполнятся на удалённых серверах с через *RPC*.
Давайте углубимся в некоторые аспекты работы библиотеки.
Окружение
---------
**Edeliver** представляет собой отличную возможность запускать и доставлять релизы в различные окружения. Концепция окружений проста: **build**, **stage** и **production**. Тут всё понятно, разве что некоторые нюансы есть у окружения *build*.
Для того, чтобы релиз благополучно запускался на рабочем сервере, он должен быть собран на машине с такой же архитектурой. Всё дело в том, что **Edeliver** использует **Exrm** для сборки релизов. **Exrm** будет использовать свои **NIF**ы (это функции, написанные на **C** для **Erlang**), которые могут различаться в зависимости от архитектуры машины, поэтому, к примеру, релиз собранный на OSX может не работать на Linux. Вы можете почитать подробнее об этом вот в это [пичальке](https://github.com/phoenixframework/phoenix_guides/issues/254) **Phoenix**, где люди обсуждают проблемы кросс-компиляции и всякие другие выкидоны **Exrm**.
Короче говоря, чтобы использовать *build* окружение на нашей машине разработчика, у неё должна быть такая же архитектура как и на *staging* и *production* машинах. Иначе работать не будет.
Для конфигурации наших окружений, нужно создать папку `.deliver` в нашем проекте и добавить конфигурационный файл. Посмотрим, что авторы **Edeliver** советуют нам в него записать:
```
#!/usr/bin/env bash
APP="your-erlang-app" # name of your release
BUILD_HOST="build-system.acme.org" # host where to build the release
BUILD_USER="build" # local user at build host
BUILD_AT="/tmp/erlang/my-app/builds" # build directory on build host
STAGING_HOSTS="test1.acme.org test2.acme.org" # staging / test hosts separated by space
STAGING_USER="test" # local user at staging hosts
TEST_AT="/test/my-erlang-app" # deploy directory on staging hosts. default is DELIVER_TO
PRODUCTION_HOSTS="deploy1.acme.org deploy2.acme.org" # deploy / production hosts separated by space
PRODUCTION_USER="production" # local user at deploy hosts
DELIVER_TO="/opt/my-erlang-app" # deploy directory on production hosts
```
В общем всё просто и прозрачно, надо только удостовериться в наличии **ssh** доступа ко всем перечисленным сервакам. Дополнительной фичей является то, что как уже горилось ранее, вполне реально запулить релизы на несколько серверов.
Как мне добавить дополнительные задания для моих процессов развёртывания?
-------------------------------------------------------------------------
**Edeliver** делает по стандарту только общие штуки для всех **Elixir** или **Erlang** приложений. Но если, к примеру, мы используем **Phoenix**, нам нужно запустить ещё парочку команд до того, как мы сгенерируем релиз. Самые важные — это
```
$ branch build --production
```
и
```
$ mix phoenix.digest
```
чтобы статика работала в наших релизах.
Для этого определим хук в нашем `.deliver/config` файле:
```
pre_erlang_clean_compile() {
status "Preparing assets with: brunch build and phoenix.digest"
__sync_remote "
# runs the commands on the build host
[ -f ~/.profile ] && source ~/.profile # load profile (optional)
# fail if any command fails (recommended)
set -e
# enter the build directory on the build host (required)
cd '$BUILD_AT'
mkdir -p priv/static # required by the phoenix.digest task
# installing npm dependencies
npm install
# building brunch
brunch build --production
# run your custom task
APP='$APP' MIX_ENV='$TARGET_MIX_ENV' $MIX_CMD phoenix.digest $SILENCE
"
}
```
Код вверху был нагло выдран из документации к **Edeliver**, которая объясняет как работать с хуками, и почему-то сразу заработал.
Что там насчёт моих переменных окружения?
-----------------------------------------
Мы уже рассказывали как правильно себя вести с переменными окружения так, чтобы не экспортировать их в *build* окружение [вот тут](http://blog.plataformatec.com.br/2016/05/how-to-config-environment-variables-with-elixir-and-exrm/), и это всё ещё работает! Впрочем, ещё кое-что надо иметь в виду.
Чтобы можно было менять окружения, необходимо добавить `RELX_REPLACE_OS_VARS=true` перед нашей командой запуска. Но это невозможно в **Edeliver**, потому что первая команда выполняется локально:
```
$ mix edeliver start production
```
Поэтому возможное решение — экспортировать `RELX_REPLACE_OS_VARS` в ваше *production* окружение.
Перед стартом
-------------
Похоже, что **Edeliver** — классная штука для управления релизами и вообще процессом развёртывания. Мне она показалась очень простой в использовании. В этой статье я никак не вникал во внутренности её работы, так что прочитайте *README* и всякие доки — там очень хорошо всё расписано.
Я деплою так, а ты как? Пиши в комментариях! | https://habr.com/ru/post/305564/ | null | ru | null |
# Mikrotik firewall filter: скрипт генерирующий основу для политики фильтрации
Кто хоть раз писал политику фильрации firewall знает, что это дело не простое и сопряжено с кучей ошибок, когда колличество сетевых зон больше 2-х. В этой сутации вам поможет скрипт из этой статьи.
Введение
--------
Под сетевой зоной я подразумеваю совокупность интерфейсов или IP адресов, для которых применяется правило фильтрации. В моем скрипте IP адреса зоны закреплены за интерфейсом. То есть, если мы ожидаем «доверенные» IP адреса из локальной сети, то будет странно, если соответствующие соединения прилетят к нам от провайдера.
Как оно работает
----------------
Все вертится вокруг описания зон, где мы задаем как они между собой взаимодействуют.
В моей конфигурации, если не заданы другие правила, весь трафик будет сброшен с правилом DROP, поэтому мы будем задавать правила ACCEPT и REJECT.
Далее скрипт в цикле проходит по всем описаниям зон и создает:
* Списки интерфейсов IF-<имя зоны>
* Списки адресов IP-<имя зоны>
* Задает дефолтовую и немного мной дополненую конфигурацию filter, mangle и raw
IP зона назначения трафика от интерфейсной отличается тем, что её имени нет в разделе для интерфейсов. Таким образом скрипт и понимает, где у нас назначение ip, а где интерфейс.
### Переменные
* gping — Разрешить ping во всех направлениях и на пересылке. Иными словами, пинговать можно будет даже то, что было закрыто другими правилами в filter. Включать по желанию ;)
* debug — Ставит в самое начало корневых цепочек ACCEPT правило, что делает все остальные правила бесполезными. Очень полезно на этапе отладки правил. Делаете политику как вы хотите, включаете Safe Mode, а потом эти правила отключаете. Если роутер стал недоступен, то уже через 10 сек правила будут включены опять и вы сможете подумать, а в чем вы ошиблись?
* allout — Разрешает исходящий трафик роутера, обычно роутер у нас не генерит плохого трафика, так что в ряде конфигураций такое приемлимо.
### Описание зон
Само описание разделено на два блока: интерфейсы и ip адреса. Для интерфейсов есть специальные переменные:
* is\_wan: добавляет правила для обработки тунелей и DNS
* do\_masq: добавляет правила для маскардинга трафика в эту зону
* is\_lan: добавляет правила для ответа на DHCP и DNS
* z2s: добавляет правила разрешающие форвард с интерфейса зоны на другой её интерфейс
* mss: добавляет правила корректировки mss для туннельных интерфейсов, если встроенные средства вас не устраивают
* ADDoS: Добавляет правила защиты от DDoS или подбора паролей. Работет примитивно — обнаруживает факты слишком частых (по нашему мнению) соединений, и такой IP помещает в список для дальнейшего бана. имеются предопределенные политики:
+ gen — generic, не зависит от протокола, лочит все что похоже на плохое.
+ mngr — managment, работает на протоколы управления mikrotik (winbox, ssh)
+ Любое другое имя — создаст отключенную цепочку, для вашего варианта протокола.
Так же есть две специальные зоны: rt, это сам роутер, и all, как не трудно догадаться «любое направление», all не может быть указан в качестве источника трафика.
Основное действие скрипта, это создание серии правил jump с фильтрацией по источнику и назначению трафика, которые терминируются правилом с ACCEPT или REJECT.
Описание зоны может быть редуцированно, как в примере для ISP и rt (должно быть всегда).
Если вы хотите терминировать цепочку своим правилом, то в описание зоны просто вместо accept или reject впишите custom (или что угодно), тогда цепочка jump-ов не будет завершена никаким правилом, а вы сможете создать его самостоятельно.
### Пояснение правил из скрипта
**Зоны**
```
:local gping 1
:local debug 0
:local zones {
"if"={
"ISP"={
"is_wan"=1;
"do_masq"=1;
"ADDoS"={
mngr={
dst-limit="4/1m,1,src-address/1m40s";
timeout="1d";
comment="Blocking bruteforcing winbox & ssh port";
excl=[:toarray ("Trusted")];
};
gen={
dst-limit="50,50,src-address/10s";
timeout="1d";
comment="Blocking potential DDoS";
excl=[:toarray ("Trusted")];
};
};
};
"LAN"={
"is_lan"=1;
"z2s"=1;
policy={
"all"="accept";
};
};
"TUN"={
mss=1400;
};
"rt"={};
};
"ip"={
"rt"={
policy={
"all"="accept"
};
};
"TUN"={
"Staff"={
"Server"="accept";
};
"Manager"={
"all"="accept";
};
};
"ISP"={
"Trusted"={
"rt"="accept";
};
};
};
}
```
Задано 4-е зоны для интерфейсов, одна из которых, обязательная rt:
* ISP — для провайдера, поэтому указано создавать дополнительные правила для некоторых протоколов.
* LAN — для локальной сети, ей заданы правила для lan и есть общее разрешающие действие на любые направления.
* TUN — для собственно тунелей, указана корректировка MSS.
B 3-и ip зоны:
* Staff и Manager на интерфейсах TUN:
+ Staff — имеет доступ только к ip зоне Server
+ Manager — могут куда угодно
* Trusted на интерфейсе ISP имеет доступ к роутеру
**gen-filter**
```
# jun/29/2020 10:00:00 by RouterOS 6.46.6
# RoS filter generator v 0.9.7
:local gping 0
:local debug 1
:local allout 1
:local zones {
"if"={
"ISP"={
"is_wan"=1;
"do_masq"=1;
"ADDoS"={
mngr={
dst-limit="4/1m,1,src-address/1m40s";
timeout="1d";
comment="Blocking bruteforcing winbox & ssh port";
excl=[:toarray ("Trusted")];
};
gen={
dst-limit="50,50,src-address/10s";
timeout="1d";
comment="Blocking potential DDoS";
excl=[:toarray ("Trusted")];
};
};
};
"LAN"={
"is_lan"=1;
"z2s"=1;
policy={
"all"="accept";
};
};
"TUN"={
mss=1400;
};
"rt"={};
};
"ip"={
"rt"={
policy={
"all"="accept"
};
};
"TUN"={
"Staff"={
"Server"="accept";
};
"Manager"={
"all"="accept";
};
};
"ISP"={
"Trusted"={
"rt"="accept";
};
};
};
}
/ip firewall raw
add action=notrack chain=prerouting ipsec-policy=in,ipsec comment="Notrack ipsec"
add action=notrack chain=prerouting dst-address-type=multicast comment="Notrack multicast"
/ip firewall filter
:if ( ($debug)=0 ) do={
add action=accept chain=forward comment=DEBUG!!! disabled=yes
add action=accept chain=input comment=DEBUG!!! disabled=yes
add action=accept chain=output comment=DEBUG!!! disabled=yes
} else={
add action=accept chain=forward comment=DEBUG!!!
add action=accept chain=input comment=DEBUG!!!
add action=accept chain=output comment=DEBUG!!!
}
add action=accept chain=input comment="defconf: accept to local loopback (for CAPsMAN)" dst-address=127.0.0.1 dst-port=5246,5247 protocol=udp src-address-type=local
add action=accept chain=input comment="defconf: accept established,related,untracked" connection-state=established,related,untracked
add action=drop chain=input comment="defconf: drop invalid" connection-state=invalid
add action=jump chain=input comment="defconf: new input" connection-state=new jump-target=in-new
add action=jump chain=input comment="defconf: notrack input" jump-target=in-notrack
add action=drop chain=input comment="defconf: drop all not allowed"
add action=accept chain=output comment="defconf: accept established,related,untracked" connection-state=established,related,untracked
add action=jump chain=output comment="defconf: new output" connection-state=new jump-target=out-new
add action=jump chain=output comment="defconf: notrack output" jump-target=out-notrack
:if ( ($allout)=1 ) do={
add action=accept chain=out-notrack comment="defconf: Allow any trafic from rt"
} else={
add action=accept chain=out-notrack comment="defconf: Allow any trafic from rt" disabled=yes
}
add action=drop chain=output comment="defconf: drop all not allowed"
add action=accept chain=forward comment="defconf: accept in ipsec policy" ipsec-policy=in,ipsec
add action=accept chain=forward comment="defconf: accept out ipsec policy" ipsec-policy=out,ipsec
add action=fasttrack-connection chain=forward comment="defconf: fasttrack" connection-mark=no-mark connection-state=established,related
add action=accept chain=forward comment="defconf: accept established,related, untracked" connection-state=established,related,untracked
add action=drop chain=forward comment="defconf: drop invalid" connection-state=invalid
add action=jump chain=forward comment="defconf: new forward" connection-state=new jump-target=fw-new
add action=jump chain=forward comment="defconf: notrack forward" jump-target=fw-notrack
add action=accept chain=forward comment="defconf: Accept all forward DSTNATed" connection-nat-state=dstnat
add action=drop chain=forward comment="defconf: drop all not allowed for forward"
:if ( ($gping)=1 ) do={
add action=accept chain=WAN2RT-STD-PROTO comment=ICMP protocol=icmp disabled=yes
} else={
add action=accept chain=WAN2RT-STD-PROTO comment=ICMP protocol=icmp
}
add action=accept chain=WAN2RT-STD-PROTO comment=GRE ipsec-policy=in,ipsec protocol=gre
add action=accept chain=WAN2RT-STD-PROTO comment=IPSec protocol=ipsec-esp
add action=accept chain=WAN2RT-STD-PROTO comment=IPSec protocol=ipsec-ah
add action=accept chain=WAN2RT-STD-PROTO comment="IPSec encapsulated" dst-port=500,4500 protocol=udp
add action=accept chain=WAN2RT-STD-PROTO comment=L2TP dst-port=1701 ipsec-policy=in,ipsec protocol=udp
add action=accept chain=WAN2RT-STD-PROTO comment=PPtP dst-port=1723 protocol=tcp
add action=accept chain=LAN2RT-STD-PROTO comment=DNS dst-port=53 protocol=tcp
add action=accept chain=LAN2RT-STD-PROTO comment=NTP,DNS,DHCP dst-port=53,123,67-68 protocol=udp
add action=accept chain=LAN2RT-STD-PROTO comment=DHCP dst-port=67-68 protocol=udp
add action=accept chain=RT2WAN-STD-PROTO comment=DNS dst-port=53 protocol=tcp
add action=accept chain=RT2WAN-STD-PROTO comment=NTP,DNS dst-port=53,123 protocol=udp
add action=accept chain=WAN2RT-STD-PROTO comment=IPSec protocol=ipsec-esp
add action=accept chain=RT2WAN-STD-PROTO comment=IPSec protocol=ipsec-ah
add action=accept chain=RT2WAN-STD-PROTO comment="IPSec encapsulated" dst-port=500,4500 protocol=udp
add action=reject chain=RT2WAN-STD-PROTO comment=GRE ipsec-policy=out,none protocol=gre reject-with=icmp-admin-prohibited
add action=reject chain=RT2WAN-STD-PROTO comment=L2TP dst-port=1701 ipsec-policy=out,none protocol=udp reject-with=icmp-admin-prohibited
:if ( ($gping)=1 ) do={
add action=accept chain=fw-new comment=ICMP protocol=icmp
add action=accept chain=in-new comment=ICMP protocol=icmp
add action=accept chain=out-new comment=ICMP protocol=icmp
} else={
add action=accept chain=fw-new comment=ICMP protocol=icmp disabled=yes
add action=accept chain=in-new comment=ICMP protocol=icmp disabled=yes
add action=accept chain=out-new comment=ICMP protocol=icmp disabled=yes
}
/ip firewall filter
:foreach zone,conf in=($zones->"if") do={
:if ( ($zone)!="rt" ) do={
:if ( [/interface list print count-only where name=("IF-".$zone)] = 0) do={
/interface list add name=("IF-".$zone)
}
add action=jump chain=fw-new in-interface-list=("IF-".$zone) comment=("Fwd plc from if ".$zone) jump-target=("fw-plc-s:".$zone)
add action=jump chain=in-new in-interface-list=("IF-".$zone) comment=("In plc for if ".$zone) jump-target=("in-plc-s:".$zone)
:foreach ddos,val in=($conf->"ADDoS") do={
:if ( $ddos="mngr" ) do={
add action=jump chain=("in-plc-s:".$zone) dst-port=22,8291 jump-target=("ADDoS-s:".$zone."-".$ddos) comment=("AntiDDoS for ".$ddos." from ".$zone) protocol=tcp
}
:if ( $ddos="gen" ) do={
add action=jump chain=("in-plc-s:".$zone) jump-target=("ADDoS-s:".$zone."-".$ddos) comment=("AntiDDoS for ".$ddos." from ".$zone)
}
:if ( $ddos="mngr" || $ddos="gen" ) do={
:foreach excl in=(($val)->"excl") do={
add action=return chain=("ADDoS-s:".$zone."-".$ddos) comment=("Execption for ".$excl." from ".$zone) src-address-list=("IP-".$excl)
}
add action=return chain=("ADDoS-s:".$zone."-".$ddos) comment=("Limit number incoming connections for ".$ddos." from ".$zone) dst-limit=(($val)->"dst-limit")
add action=add-src-to-address-list address-list=("IP-DDoS-s:".$zone."-".$ddos) address-list-timeout=(($val)->"timeout") chain=("ADDoS-s:".$zone."-".$ddos) comment=("Add to IP-DDoS-".$ddos." list from ".$zone)
}
:if ( $ddos!="mngr" && $ddos!="gen" ) do={
add action=jump chain=("in-plc-s:".$zone) jump-target=("ADDoS-".$ddos) comment=("AntiDDoS for ".$ddos." from ".$zone) disabled=yes
:foreach excl in=(($val)->"excl") do={
add action=return chain=("ADDoS-s:".$zone."-".$ddos) comment=("Execption for ".$excl." from ".$zone) src-address-list=("IP-".$excl)
}
add action=return chain=("ADDoS-s:".$zone."-".$ddos) comment=("Limit number incoming connections for ".$ddos." from ".$zone)
}
/ip firewall raw add action=drop chain=prerouting comment=("DROP Banned by ".$ddos." from ".$zone) in-interface-list=("IF-".$zone) src-address-list=("IP-DDoS-s:".$zone."-".$ddos)
}
} else={
add action=jump chain=out-new comment=("Out plc for rt") jump-target="out-plc-s:rt"
}
}
:foreach zone,conf in=($zones->"if") do={
:if ( ($zone)!="rt" && ($zone)!="all") do={
:if ( ($conf->"is_lan")=1 ) do={
add action=jump chain=in-notrack comment=("In Allow plc for STD LAN PROTO from ".$zone) in-interface-list=("IF-".$zone) jump-target=LAN2RT-STD-PROTO
}
:if ( ($conf->"is_wan")=1) do={
add action=jump chain=in-notrack comment=("In Allow plc for STD WAN PROTO from ".$zone) in-interface-list=("IF-".$zone) jump-target=WAN2RT-STD-PROTO
add action=jump chain=out-notrack out-interface-list=("IF-".$zone) comment=("Out Allow plc for STD WAN PROTO to ".$zone) jump-target=RT2WAN-STD-PROTO
}
:if ( ($conf->"do_masq")=1) do={
/ip firewall nat add action=masquerade chain=srcnat out-interface-list=("IF-".$zone) comment=("Masquerade traffic going to ".$zone)
}
:if ( [:len ($conf->"mss")]!=0 ) do={
/ip firewall mangle add action=change-mss chain=forward in-interface-list=("IF-".$zone) new-mss=($conf->"mss") passthrough=yes protocol=tcp tcp-flags=syn tcp-mss=(($conf->"mss"+1)."-65535") comment=("Fix mss on tunel ".$zone)
/ip firewall mangle add action=change-mss chain=forward out-interface-list=("IF-".$zone) new-mss=($conf->"mss") passthrough=yes protocol=tcp tcp-flags=syn tcp-mss=(($conf->"mss"+1)."-65535") comment=("Fix mss on tunel ".$zone)
}
:if ( ($conf->"z2s")=1 ) do={
add action=accept chain=("fw-plc-s:".$zone) out-interface-list=("IF-".$zone) comment=("Fwd plc from if ".$zone." to self")
}
:foreach src,val in=(($zones->"ip")->$"zone") do={
:foreach tgt,policy in=$val do={
:if ( ($tgt)!="rt" && ($tgt)!="all") do={
:if ( [:len (($zones->"if")->$"tgt")]=0 ) do={
add action=jump chain=("fw-plc-s:".$zone) src-address-list=("IP-".$src) dst-address-list=("IP-".$tgt) comment=("Fwd plc from if ".$zone." & ip ".$src." to ".$tgt) jump-target=("fw-plc-s:".$zone."&".$src.">".$tgt)
} else={
add action=jump chain=("fw-plc-s:".$zone) src-address-list=("IP-".$src) out-interface-list=("IF-".$tgt) comment=("Fwd plc from if ".$zone." & ip ".$src." to ".$tgt) jump-target=("fw-plc-s:".$zone."&".$src.">".$tgt)
}
:if ( ($policy)="accept") do={
add action=accept chain=("fw-plc-s:".$zone."&".$src.">".$tgt) comment=("Fwd plc from if ".$zone." & ip ".$src." Accept to ".$tgt)
}
:if ( ($policy)="reject") do={
add action=reject chain=("fw-plc-s:".$zone."&".$src.">".$tgt) comment=("Fwd plc from if ".$zone." & ip ".$src." Reject to ".$tgt)
}
}
:if ( ($tgt)="rt" ) do={
add action=jump chain=("in-plc-s:".$zone) src-address-list=("IP-".$src) comment=("In plc for if ".$zone." & ip ".$src." to rt") jump-target=("in-plc-s:".$zone."&".$src.">rt")
:if ( ($policy)="accept") do={
add action=accept chain=("in-plc-s:".$zone."&".$src.">rt") comment=("In plc for if ".$zone." & ip ".$src." Accept to rt")
}
:if ( ($policy)="reject") do={
add action=reject chain=("in-plc-s:".$zone."&".$src.">rt") comment=("In plc for if ".$zone." & ip ".$src." Accept to rt")
}
}
:if ( ($tgt)="all" ) do={
add action=jump chain=("fw-plc-s:".$zone) src-address-list=("IP-".$src) comment=("Fwd plc from if ".$zone." & ip ".$src." to All") jump-target=("fw-plc-s:".$zone."&".$src.">all")
add action=jump chain=("in-plc-s:".$zone) src-address-list=("IP-".$src) comment=("In plc for if ".$zone." & ip ".$src." to All") jump-target=("in-plc-s:".$zone."&".$src.">all")
:if ( ($policy)="accept") do={
add action=accept chain=("fw-plc-s:".$zone."&".$src.">all") comment=("Fwd plc from if ".$zone." & ip ".$src." Accept to All")
add action=accept chain=("in-plc-s:".$zone."&".$src.">all") comment=("In plc from if ".$zone." & ip ".$src." Accept to All")
}
:if ( ($policy)="reject") do={
add action=reject chain=("fw-plc-s:".$zone."&".$src.">all") comment=("Fwd plc from if ".$zone." & ip ".$src." Reject to All")
add action=reject chain=("in-plc-s:".$zone."&".$src.">all") comment=("In plc from if ".$zone." & ip ".$src." Reject to All")
}
}
}
}
:foreach tgt,policy in=($conf->"policy") do={
:if ( ($tgt)!="rt" && ($tgt)!="all") do={
:if ( [:len (($zones->"if")->$"tgt")]=0 ) do={
add action=jump chain=("fw-plc-s:".$zone) dst-address-list=("IP-".$tgt) comment=("Fwd plc from if ".$zone." to ".$tgt) jump-target=("fw-plc-s:".$zone.">".$tgt)
} else={
add action=jump chain=("fw-plc-s:".$zone) out-interface-list=("IF-".$tgt) comment=("Fwd plc from if ".$zone." to ".$tgt) jump-target=("fw-plc-s:".$zone.">".$tgt)
}
:if ( ($policy)="accept") do={
add action=accept chain=("fw-plc-s:".$zone.">".$tgt) comment=("Fwd plc from if ".$zone." Accept to ".$tgt)
}
:if ( ($policy)="reject") do={
add action=reject chain=("fw-plc-s:".$zone.">".$tgt) comment=("Fwd plc from if ".$zone." Reject to ".$tgt)
}
}
:if ( ($tgt)="rt" ) do={
:if ( ($conf->"is_lan")!=1 && ($conf->"is_wan")!=1 ) do={
add action=jump chain=("in-plc-s:".$zone) comment=("In plc for if ".$zone." to rt") jump-target=("in-plc-s:".$zone.">rt")
}
:if ( ($policy)="accept") do={
add action=accept chain=("in-plc-s:".$zone.">rt") comment=("In plc for if ".$zone." Accept to rt")
}
:if ( ($policy)="reject") do={
add action=reject chain=("in-plc-s:".$zone.">rt") comment=("In plc for if ".$zone." Reject to rt")
}
}
:if ( ($tgt)="all" ) do={
add action=jump chain=("fw-plc-s:".$zone) comment=("Fwd plc from if ".$zone." to All") jump-target=("fw-plc-s:".$zone.">all")
add action=jump chain=("in-plc-s:".$zone) comment=("In plc for if ".$zone." to All") jump-target=("in-plc-s:".$zone.">all")
:if ( ($policy)="accept") do={
add action=accept chain=("fw-plc-s:".$zone.">all") comment=("Fwd plc from if ".$zone." Accept to All")
add action=accept chain=("in-plc-s:".$zone.">all") comment=("In plc from if ".$zone." Accept to All")
}
:if ( ($policy)="reject") do={
add action=reject chain=("fw-plc-s:".$zone.">all") comment=("Fwd plc from if ".$zone." Reject to All")
add action=reject chain=("in-plc-s:".$zone.">all") comment=("In plc from if ".$zone." Reject to All")
}
}
}
}
}
```
### Заключение
Данный скрипт мне помог сильно облегчить настройку сложных политик, однако, ошибки в нем все-же могут быть. Перед применением проконсультируйтесь со специалистом. В случае обнаружения побочных явлений, пишите, будем исправлять. | https://habr.com/ru/post/500148/ | null | ru | null |
# Версия 0.4 — Stable Release Candidate
[](http://code.google.com/p/web-optimizator/) Веб Оптимизатор (Web Optimizer) — приложение для автоматизации всех действий по клиентской оптимизации — достиг версии 0.4. Список поддерживаемых систем ширится и растет с каждым днем: Drupal 5 и 6, Joomla 1.0 и 1.5, Joostina, Wordpress 2.7, PHP-Nuke, LiveStreet, vBulletin 3.8 и так далее.
[Подробное руководство по установке](http://webo.in/articles/habrahabr/87-web-optimizer-installation/) (немного устарело уже, правда)
[Загрузить версию 0.4.0](http://web-optimizator.googlecode.com/files/web-optimizer.0.4.0.zip)
[Загрузить мини-установщик](http://web-optimizator.googlecode.com/files/install.me.php)
[Помочь проекту материально](http://sprites.in/donate/)
### Изменения
Как и было заявлено ранее, в очередную «большую» версию вошло все для комфортной работы с клиентской оптимизацией сайта:
* Добавлено авто-обновление (начиная с версии 0.3.8). Теперь нет необходимости удалять Web Optimizer через веб-интерфейс, скачивать весь архив и устанавливать заново. Достаточно просто нажать «Обновить» — и будет загружена новая версия (с сохранением всех настроек).
* Добавлена «Цепочная оптимизация». Теперь клиентская оптимизация сайта может быть выполнена независимо от посещений самого сайта. Для этого нужно просто установить Web Optimizer любым из возможных путей. Вся оптимизация делается на тестовом файле, основной сайт не затрагивается. Как только основные файлы созданы в кэширующей директории, только тогда происходит переключение основного сайта на их использование. В ходе оптимизации запускается несколько последовательных PHP-процессов, поэтому такой метод доступен и для слабых серверов (не срабатывает ограничение по времени выполнения скриптов).
* Добавлена «Быстрая установка» в один клик. При этом используется «Цепочная оптимизация».
* Создание `data:URI` перенесено в алгоритм разбора и создания CSS Sprites. Стало работать намного быстрее. Также добавлено ограничение в 32 Кб на base64-строку (в связи с IE8).
* Проведены незначительные улучшения в работе алгоритма CSS Sprites: теперь он стал заметно стабильнее.
* Добавлены дополнительные настройки: объединение JavaScript-файлов и базовое уменьшение через JSMin разнесены (теперь можно отключить минимизацию файлов отдельно от их объединения: иногда бывают проблемы в связи с некорректностью исходных скриптов).
* Локализация полностью закончена. Доступно три языка: русский, английский, украинский. Выбираются автоматически на основе предпочтений браузера. За украинскую локализацию дружно говорим спасибо [charly](https://habrahabr.ru/users/charly/) .
* Наконец-то начинает появляться дизайн (пока только в виде логотипа). Над дизайном работает [fade](https://habrahabr.ru/users/fade/)
* Установка и работа Web Optimizer успешно протестирована на следующих системах:
+ Joomla 1.0.15
+ Joomla 1.5.0
+ Joomla 1.5.9
+ Joomla 1.5.10
+ Joostina 1.2
+ Drupal 6.10
+ Drupal 5.16
+ Wordpress 2.7.1
+ Typo3 4.2
+ Simpla
+ PHP Nuke 8.0
+ Etomite 1.1
+ Livestreet 0.2
+ Santafox 1.1
+ vBulletin 3.8
+ и некоторых других
* И сотня-другая небольших улучшений. В том числе: опциональная проверка на время изменения файлов, опциональное задание корня директорий, избавление от всех PHP Notices / Warnings, проверка существования и доступности классов и объектов, и др.
### Благодарности
Огромное спасибо хабраюзерам и просто хорошим людям:
* [akira](https://habrahabr.ru/users/akira/) за работу над интеграцией YUI Compressor в проект. Ожидается, что YUI полноценно войдет в проект буквально на днях.
* [charly](https://habrahabr.ru/users/charly/) за украинскую локализацию.
* [fade](https://habrahabr.ru/users/fade/) за работу над дизайном.
* [janvarev](https://habrahabr.ru/users/janvarev/) за патч касательно времени изменения файлов и пачку идей относительно применения Веб Оптимизатора для нескольких сайтов одновременно.
* [olegman](https://habrahabr.ru/users/olegman/) за терпение и настойчивость в обнаружении ошибок на платформе Drupal.
* [kellas](https://habrahabr.ru/users/kellas/) за предоставление окружения для PHP как CGI-модуля и немного терпения.
* [bazik](https://habrahabr.ru/users/bazik/) за помощь в адаптации Web Optimizer для нескольких окружений.
* [onthefly](https://habrahabr.ru/users/onthefly/) за помощь в настройке и тюнинге Livestreet для Web Optimizer (шаблон по умолчанию [содержит пару ошибок](http://www.livestreet.ru/blog/questions/1020.html#comment14331), которые противоречат спецификации и ломают оптимизацию).
* [ort](https://habrahabr.ru/users/ort/) за создание движка Livestreet, который можно было помучить :)
* Многочисленным пользователям, установившим Web Optimizer к себе на сайт и сообщивших об успешном (или не очень) процессе. Если кого забыл упомянуть лично — напишите, обязательно добавлю.
### Условия установки
Для быстрой установки Web Optimizer необходимо загрузить его на сервер и выставить права на запись для сервера на `config.webo.php` и папку `cache` (либо просто запустить мини-установщик из браузера) + разрешить запись для корневого `index.php` и убедиться, что в корне есть `.htaccess`, доступный на запись (либо в случае его отсутствия сам корень доступен на запись для веб-сервера). Также нелишним будет наличие curl.
В любом случае все модули проверяются на доступность перед использованием, поэтому ничего страшного не произойдет.
С [основными проблемными моментами](http://webo.in/articles/habrahabr/90-web-optimizer-0.3.5/) лучше ознакомиться в материале предыдущего релиза. Больше их не стало (а судя по отзывам — даже меньше)
### В следующей версии
Рук как обычно ни на что не хватает, поэтому если есть желание поучаствовать в процессе — милости просим. Сейчас открыты следующие вопросы:
* Более корректный и быстрый алгоритм разбора HTML-документа. Если кто-то может подсказать в этом направлении (только не Tidy как модуль к PHP — мы не можем закладываться на специфическое окружение).
* Выполнение оптимизации по расписанию. Либо «по кнопке».
* PHP-библиотеки для разбора и оптимизации JPEG/GIF/PNG-изображений — чтобы не использовать консольные утилиты.
* Поддержка CMS. Если у вас есть собственное решение на PHP — установите на него Web Optimizer. Также планируется включить поддержку совместимости не только с самими CMS, но и с PHP-фреймворками.
* Если вы хотите перевести установку на свой язык — пишите, пожалуйста, в приват. Обеспечим исходниками и полной поддержкой.
### Дизайн
Поскольку проект этот open source, и никто нас не финансирует, то вся надежда остается на сообщество, ради которого все это предпринимается. Следующий месяц (с 21 апреля по 20 мая) объявляется месяцем поддержки дизайна. Все средства, переведенные на эти счета
[sprites.in/donate](http://sprites.in/donate/)
будут полностью направлены [fade](https://habrahabr.ru/users/fade/) в знак благодарности. Никто ничего не переведет — ничего и не получится. Но кто знает, может, и разработка приложения так и заглохнет без поддержки сообщества? В общем, решать вам, пользователям.
### Заключение
В общем, ставим, радуемся или пишем об ошибках. Лучшей иллюстрацией будет оценка YSlow до и после оптимизации
[Загрузить версию 0.4.0](http://web-optimizator.googlecode.com/files/web-optimizer.0.4.0.zip)
[Загрузить мини-установщик](http://web-optimizator.googlecode.com/files/install.me.php)
[Помочь проекту материально](http://sprites.in/donate/)
[Сайт проекта пока в Google Code](http://code.google.com/p/web-optimizator/)
[Twitter-канал](http://twitter.com/dreamwind) | https://habr.com/ru/post/57780/ | null | ru | null |
# Контейнер LXC для веб-разработки как альтернатива Docker
Разработкой [LXC](https://linuxcontainers.org/lxc/introduction/) занимается компания Canonical, последняя версия LXC 4.0.10 вышла совсем недавно в *июле 2021*, а началась в 2008.
В чем разница LXC и Docker:
* Docker - это контейнер для упаковки одного процесса или службы;
на практике Docker это пачка легких контейнеров для упаковки одного веб-сервиса;
* LXC - это легкий контейнер на один веб-сервис или сайт, включающий все службы, которые нужны для его функционирования.
В каких случаях удобно применять LXC:
* Legacy: у вас уже есть веб-сервис/сайт размещенный на выделенном сервере и нужно упаковать его в форме контейнера, который можно отдать разработчикам, либо перенести на другой сервер (резервный или stage);
* Вам нравится работать в окружении, где все службы собраны в одном контейнере;
* Нужна изоляция на сервере чтобы каждый веб-сервис находился в своем контейнере, но при этом не терять производительность как в случае с виртуальными машинами;
* Если вы умеете настраивать основные сервисы в Linux, значит вы сможете создать LXC контейнер под ваш проект. LXC очень похож на обычную виртуалку.
**Наш опыт и небольшая победа над Legacy**
Преобразовать наш существующий массивный веб-проект в форме LXC-контейнера оказалось проще в форме LXC.
Незадолго до начала пандемии, начали искать решение для удобства дистанционной работы. Было очевидно, что удобнее развернуть окружение на своем рабочем компьютере, если это делается одной командой. До контейнеров в компании мы пользовались отдельным сервером для разработки с расшаренными директориями и виртуальными хостами nginx под каждого разработчика.
Docker не подошел, т.к. пришлось бы настроить и наладить с десяток контейнеров, хотелось получить результат быстрее.
В форме LXC образа удалось за несколько дней все упаковать, образ очень похож на обычный виртуальный сервер, куда были установлены нужные версии программ, а данные скопированы. За несколько недель продакшен и разработка перешла на LXC.
Как побочный эффект, получили:
* способ развернуть stage-окружение для тестирования;
* живую резервную копию сервера, куда настроили репликацию БД и синхронизацию файлов;
* легкий переезд на другой сервер, когда понадобилось переехать в другой дата-центр.
**Порог вхождения отсутствует**
Чтобы настроить окружение под веб-проект из нескольких служб (mysql, nginx, php-fpm, memcached, postfix) дополнительных знаний не требуется. Видео-демонстрация: [как создать контейнер установить nginx и php-fpm](https://www.youtube.com/watch?v=8va135GTjQw&t=71s) за несколько минут.
Все что нужно знать уместится в этот пост:
Установка LXC под Ubuntu: `apt install lxc`
```
# 1. создать контейнер с именем myapp
sudo lxc-create -t download -n myapp -- -d ubuntu -r focal -a amd64
# 2. посмотреть список контейнеров
sudo lxc-ls -f
# 3. запустить контейнер
sudo lxc-start myapp
# 4. остановить
sudo lxc-stop myapp
# 5. зайти в shell контейнера
sudo lxc-attach myapp
# 6. посмотреть файловую систему контейнера
ls -al /var/lib/lxc/myapp/rootfs
```
Для разработки каталог с исходными файлами проекта пробрасываем с хоста в контейнер.
Как пробросить (и особенность настройки прав)Конфигурируется это через файл настроек: `/var/lib/lxc/myapp/config`
```
# Добавляем строку
# монтируем директорию хоста /home/user1/myapp в контейнер /var/www/myapp
lxc.mount.entry = /home/user1/myapp var/www/myapp none bind,create=dir,rw 0 0
```
**Права для рабочей директории**
Бывают трудности, когда uid и gid пользователя не совпадают на хосте и в контейнере.
Когда какой-то файл создается в пробрасываемой директории контейнера, скажем от пользователя ubuntu с uid=1000, а у вас на хосте uid=1002, то файл будет не доступен на редактирование.
Рекомендую после создания контейнера создать пользователя в контейнере с таким же uid и gid, как и в вашей хост системе:
```
# Выполнить команду id, посмотреть свой uid и gid
$ id
uid=1002(user1) gid=1002(user1) группы=1002(user1),27(sudo),130(docker)
# Настроить аналогичного пользователя в myapp,
# перейти в контейнер
sudo lxc-attach myapp
userdel -r ubuntu
groupadd -g 1002 user1
useradd -s /bin/bash --gid 1002 -G sudo --uid 1002 -m user1
```
**Резюме по LXC**
* Низкий порог вхождения: можно создать свой контейнер за минуты;
* хорошо подходит для упаковки существующих проектов и для legacy;
* если нужно посмотреть чей-то веб проект, установить определенные версии mysql/nginx или другие программы, при этом не затрагивая основную систему;
* он легок, экономит время при отладке и настройке;
* проверено работает при наличии sudo, хотя фича unprivileged контейнеров есть;
* классно сочетается с zfs, в этом случае получаем мгновенные снэпшоты и дополнительную надежность.
**Когда Docker может быть лучше**
* Вам нужен IaC. Dockerfile это отраслевой стандарт.
В LXC похожее отсутствует. Концепция *Infrastructiure as Code* мне очень близка, я попробовал создать shell-скрипт который является аналогом Dockerfile чтобы [воспроизводит LAMP окружение на LXC](https://github.com/agorlov/lxc-lamp/blob/main/lxc-lamp.sh), но с помощью скрипта не обновить одной командой продакшен.
* Если нужен готовый публичный образ какой-то программы или опубликовать свой образ. | https://habr.com/ru/post/563040/ | null | ru | null |
# Получение пути к карте памяти SD Card на Android
Разрабатывая приложение для проведения соревнований, я столкнулся с проблемой хранения базы данных. Проблема состояла в том, как мне определить внешнюю карту памяти. В целом поиск в сети точного ответа не дал. Поэтому, объединив все найденные результаты, я собрал свой класс. Если кому интересно, смотрим под катом.
Итак, начнем с теории.
#### Терминология
Гугл нам говорит, что есть следующие понятия:
1. Внутренняя (**internal**) память — это часть встроенной в телефон карты памяти. При ее использовании по умолчанию папка приложения защищена от доступа других приложений ([Using the Internal Storage](http://developer.android.com/guide/topics/data/data-storage.html#filesInternal)).
2. Внешняя (**external**) память — это общее «внешнее хранилище», т.е. это может быть как часть встроенной памяти, так и удаляемое устройство. Обычно это часть встроенной памяти, как удаляемое устройство я видел в последний раз на андройде 2.2, где встроенная память была около 2Гб, и подключаемая память становилась внешней ([Using the External Storage](http://developer.android.com/guide/topics/data/data-storage.html#filesExternal)).
3. Удаляемая (**removable**) память — все хранилища, которые могут быть удалены из устройства без «хирургических» вмешательств.
До версии KitKat 4.4 API не предоставляло функционала для получения путей к внешней памяти. Начиная с этой версии (API 19) появилась функция public abstract File[] **getExternalFilesDirs** (String type), которая возвращает массив строк с путями к внутренней и внешней памяти. Но как же быть с нашей SD Card, которая вставлена в слот? Путь к ней мы опять не можем получить.
#### Результаты поиска
Чтобы ответить на поставленный вопрос я обратился к всезнающему гуглу. Но и он мне не дал четкого ответа. Было рассмотрено множество вариантов определения от использования стандартных функций, которые ведут к внешней памяти, но ничего общего с удаляемыми устройствами хранения данных они не имеют, до обработки правил монтирования устройств (Android же на ядре Linux работает). В последних случаях были использованы «зашитые» пути к папке с примонтироваными устройствами (в различных версиях эта директория разная). Не стоит забывать, что от версии к версии правила монтирования меняются.
В конечном итоге я решил объединить все полученные знания и написал свой класс, который может нам вернуть пути к внешним и удаляемым устройствам.
#### Описание кода
Был создан класс **MountDevice**, который содержит в себе путь к устройству, тип устройства и некий хэш.
Типов устройств выделено два (внутреннюю память я не стал трогать, так как к ней доступ можно получить через API системы).
```
public enum MountDeviceType {
EXTERNAL_SD_CARD, REMOVABLE_SD_CARD
}
```
И был создан класс **StorageHelper**, который и осуществляет поиск доступных карт памяти.
В классе StorageHelper реализовано два способа поиска — через системное окружение (**Environment**) и с использованием утилиты Linux **mount**, а точнее результата ее выполнения.
##### Способ первый — Environment
При работе с окружением я использую стандартную функцию getExternalStorageDirectory() для получения информации о внешней памяти. Чтобы получить информацию о удаляемой памяти, я использую переменную окружения "*SECONDARY\_STORAGE*".
Внешняя память всегда одна и обычно всегда есть, поэтому проверяем ее на читаемость, вычисляем хэш и запоминаем. Удаляемой памяти может быть много, поэтому необходимо полученную строку разбить по разделителю и проверять каждое значение.
**Функция fillDevicesEnvirement**
```
String path = android.os.Environment.getExternalStorageDirectory()
.getAbsolutePath();
if (!path.trim().isEmpty()
&& android.os.Environment.getExternalStorageState().equals(
android.os.Environment.MEDIA_MOUNTED)) {
testAndAdd(path, MountDeviceType.EXTERNAL_SD_CARD);
}
// Получаем ремувабл
String rawSecondaryStoragesStr = System.getenv("SECONDARY_STORAGE");
if (rawSecondaryStoragesStr != null
&& !rawSecondaryStoragesStr.isEmpty()) {
// All Secondary SD-CARDs splited into array
final String[] rawSecondaryStorages = rawSecondaryStoragesStr
.split(File.pathSeparator);
for (String rawSecondaryStorage : rawSecondaryStorages) {
testAndAdd(rawSecondaryStorage,
MountDeviceType.REMOVABLE_SD_CARD);
}
}
```
Вариант решения взят со [stackoverflow](http://stackoverflow.com/questions/5694933/find-an-external-sd-card-location#19831753). Ответ где-то там внизу.
##### Способ второй — mount
Так как у меня долго не получалось заставить систему мне сказать путь к удаляемой памяти, я решил искать в сторону примонтированных устройств. В системе есть файлы конфигурации, в которых описаны правила монтирования внешних устройств. Все бы хорошо, но на Android версии 4.\* к этому файлу простым смертным доступа нет, поэтому рассматривать этот способ не буду.
Вернемся к утилите mount. При запуске без параметров команда возвращает список смонтированных файловых систем. Удаляемые устройства имеют обычно формат файловой системы FAT, то будем выделять строки, в которых есть характеристика "**fat**". Внешняя память будет характеризоваться параметром "**fuse**".
Примечание: при использовании такого способа не всегда корректно (скорее всего я что-то не учел) определяются типы смотнтированных устройств. Разницу замечал на разных версиях Android. Поэтому этот способ можно использовать как дополнительный.
**Функция fillDevicesProcess**
```
try {
Runtime runtime = Runtime.getRuntime();
proc = runtime.exec("mount");
try {
is = proc.getInputStream();
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
while ((line = br.readLine()) != null) {
if (line.contains("secure"))
continue;
if (line.contains("asec"))
continue;
if (line.contains("fat")) {// TF card
String columns[] = line.split(" ");
if (columns != null && columns.length > 1) {
testAndAdd(columns[1],
MountDeviceType.REMOVABLE_SD_CARD);
}
} else if (line.contains("fuse")) {// internal(External)
// storage
String columns[] = line.split(" ");
if (columns != null && columns.length > 1) {
// mount = mount.concat(columns[1] + "\n");
testAndAdd(columns[1],
MountDeviceType.EXTERNAL_SD_CARD);
}
}
}
} finally {
...
}
} catch (Exception e) {
...
}
```
Вариант решения взят со [stackoverflow](http://stackoverflow.com/questions/5694933/find-an-external-sd-card-location#15612964). Ответов там несколько примерно одинаковых.
##### Про дублирование
Многие замечали в директории монтирования устройств такую картину:
```
/storage/sdcard0/
/storage/emulated/0/
/storage/emulated/legacy/
```
И что самое интересно, все это одна и та же внешняя карта памяти. Такое дробление начинается с версии Jelly Bean и сделано это для поддержки многопользовательского режима работы системы. Более подробно [тут](http://android.stackexchange.com/questions/39542/confused-by-the-many-locations-of-the-virtual-sdcard#39546). И вот, чтобы не получать одну и туже карту памяти как различные устройства, необходим способ определения идентичности. Если бы был доступ к конфигурации монтирования, то и вопросов не было. Но доступа нет. Поэтому я [тут](http://stackoverflow.com/questions/5694933/find-an-external-sd-card-location#15612964) подсмотрел решение с расчетом хэша для каждого устройства:
1. создаем StringBuilder
2. записываем в него общий размер устройства и размер используемого пространства устройства
3. обходим содержимое корня устройства
4. записываем имя каталога
5. записываем имя файла и размер
6. вычисляем hash
**Своя функция расчета хэша calcHash**
```
private int calcHash(File dir) {
StringBuilder tmpHash = new StringBuilder();
tmpHash.append(dir.getTotalSpace());
tmpHash.append(dir.getUsableSpace());
File[] list = dir.listFiles();
for (File file : list) {
tmpHash.append(file.getName());
if (file.isFile()) {
tmpHash.append(file.length());
}
}
return tmpHash.toString().hashCode();
}
```
#### Пример использования
```
/* Получаем базовый путь */
if (!mPreferences.contains(PREFS_BASEBATH)) {
// Если еще не сохранялся в настройках, то пытаемся найти карты
// памяти
ArrayList storages = StorageHelper.getInstance()
.getRemovableMountedDevices();
// проверяем съемные карты памяти
if (storages.size() != 0) {
setBasePath(storages.get(0).getPath() + mAppPath);
} else if ((storages = StorageHelper.getInstance() // Проверяем
// внутреннюю
// память
.getExternalMountedDevices()).size() != 0) {
setBasePath(storages.get(0).getPath() + mAppPath);
}
} else {
// Вытаскиваем из сохранненых настроек
mBasePath = mPreferences.getString(PREFS\_BASEBATH, context
.getFilesDir().getParent());
}
```
#### Заключение
Подробные рассуждения по этому вопросу понимания памяти в Android, некоторые советы можно прочитать [тут](http://commonsware.com/blog/2014/04/09/storage-situation-removable-storage.html).
Исходный код всего класса ~~расположен~~ еще нигде не расположен. На днях постараюсь разместить на gitHub.
Кто еще какими способами пользуется?
UPD1: Исходный код класса на [bitbucket](https://bitbucket.org/vait/android-helpers/src/4f0abd990ae43aa75fd6eabf377eb4cc5fda2fab/StorageHelper.java?at=master) | https://habr.com/ru/post/254813/ | null | ru | null |
# Пишем ХабраКвест на ASP.NET Core и Angular2
Каждый раз с выходом нового фреймворка, хочется попробовать его в деле и написать на нем какое-то приложение. В [прошлый раз](https://habrahabr.ru/post/250009/) отлично зашел формат квеста. По этому предлагаю посмотреть что поменялось за почти полтора года и написать еще один квест— и фреймворки посмотрим, и поиграть можно.
Результат:
— [сорсы на гитхабе](https://github.com/gbdrm/HabraQuest) для тех, кому интересно посмотреть на исходники
— [линк на квест](http://habraquest.azurewebsites.net/) для тех, кому интересно что получилось или потратить свое время на еще один логический квест.
Под катом описан полный процесс от создания проекта до его развертывания.
### Предварительные требования
Для работы с ASP.NET Core и Angular2 подойдет почти любая IDE или текстовый редактор. Конечно для полноценной отладки ASP.NET нужна Visual Studio, но с выходом новой Core версии для разработки она не обязательна, можно работать с кодом в Sublime\Atom\… и запускать приложение (предварительно установив SDK) из командной строки, с помощью:
```
dotnet run
```
Исходный код, инсталлятор, документацию для интерфейса командой строки .NET и SDK можно найти на:
[dotnet.github.io](https://dotnet.github.io/)
При чем все это теперь доступно не только лишь на Windows но и на Max, Linux, а так же Docker.
Наверное, многие испытают когнитивный диссонанс, увидев
```
sudo apt-get install dotnet-dev-1.0.0-preview2-003121
```
### Создаем проект
Для создания нового ASP.NET core приложения есть несколько путей:
1) С помощью **Visual Studio**
2) Из консоли — **dotnet new**
3) Используя сторонние **генераторы**.
Не будем углубляться во все проблемы создания и конфигурирования проекта, тем более что нам нужно не пустое приложение, а уже с подключенным Angular2 и, желательно настроенными билд скриптами.
Для этого идеально подходит ASP.NET Core **JavaScript Services** [github.com/aspnet/JavaScriptServices](https://github.com/aspnet/JavaScriptServices/), который позволяет создавать приложения для ASP.NET Core с JavaScript фреймворком на выбор: Angular 2, React, и Knockout.
Для этого нам потребуется: ASP.NET Core, Node.js и генератор yeoman с шаблоном aspnet-spa. Последний можно установить с помощью:
```
npm install -g yo generator-aspnetcore-spa
```
Теперь создание нового проекта сводится к
```
cd <папка_для_проекта>
yo aspnetcore-spa
```
Выбираем **Angular2** шаблон, название проекта и генератор сам создаст всю структуру, зависимости и т.д. (это может занять несколько минут).
Сначала может показаться, что этот генератор использует слишком много библиотек, особенно, если вы не любитель последних или же мало работали с фронт-ендом. Но лично мое мнение — что это один из наиболее сбалансированных шаблонов. Особенно хочется выделить следующие свойства:
#### TypeScript
Конечно же разрабатывать приложения на Angular2 можно и на простом JavaScript, TypeScript дает нам возможности типизации, автодополнения, более привычный (для большинства) синтаксис для ООП. А также команда Angular2 активно использует TypeScript и похоже на то, что TypeScript будет (или уже есть) не официальным языком по умолчанию для Angular2.
#### Webpack
Похоже, что **webpack** быстро становится фаворитом в битве инструментов для фронт-енда. Особенно важно заметить его возможности при постоянном изменении кода. Фактически разработчику можно забыть о том, чтобы постоянно пересобирать проект и обновлять страницу с помощью Горячей Подмены Модулей (Hot module replacement — **HMR**). После того как попробовали писать фронт-енд на одном мониторе, в то время как на втором он на глазах меняется уже не хочется возвращаться назад, на инструменты без возможности горячей подмены.
#### Другие бонусы
Серверный пре-рендер, ленивая загрузка, удобная работа с Development и Production билдами.
Больше можно узнать в блоге одного из разработчиков JavaScriptServices:
[blog.stevensanderson.com/2016/05/02/angular2-react-knockout-apps-on-aspnet-core](http://blog.stevensanderson.com/2016/05/02/angular2-react-knockout-apps-on-aspnet-core/)
или же увидеть реальный пример в одном из последних публичных стенд-апов команды ASP.NET:
### Собираем проект
Как уже говорилось раньше, чтобы собрать и запустить проект, можно воспользоваться консольной командой:
```
dotnet run
```
Как результат, сайт будет собран и запущен локально:
Или же, сделать тоже самое из Visual Studio.
Если после билда у вас будет уведомление, что не все модули npm установлены,
скорее всего это проблема с тем, что один из модулей не поддерживается в Windows, но по скольку зависимость не обязательная, приложение должно работать нормально.
В результате у вас должно запустить рабочее приложение с тремя простыми страничками.
### Приступаем к работе
Рассмотрим главные отличия, в сравнении с предыдущими версиями фреймворков.
#### Структура проекта
Похоже, структура проекта JavaScriptServices webpack-ориентирована. То есть это npm + webpack, соответственно отсутствуют gulp и bower. На сколько я понимаю **bower** просто решили не добавлять в стартовый проект, так как нет много зависимостей от JavaScript библиотек, со всем справляется npm. А все функции **gulp** (или grunt) теперь выполняет **webpack**.
Что касается файловой структуры, то по части серверных файлов все так же, как и раньше, а вот на front-end есть некоторые отличия. Например, в папке со статическими файлами wwwroot есть только папка dist, куда, фактически, компилируется весь JavaScript.
В сравнении с первой версией Angular бросается в глаза то, что нет никаких представлений и контроллеров — все в компонентах и для каждой html части компоненты есть TypeScript часть.
#### Особенности в процессе
Webpack конечно очень радует в плане горячей замены модулей, разработка front-end части из-за этого значительно приятнее.
Стоит так же заметить, что ошибки WebPack отлично показываются уже на уровне ASP.NET, очень удобная интеграция. Правда после ошибочного состояния (например, подтягивание не существующей компоненты) горячая замена у меня не заработала, возможно в таких случаях все же надо обновлять страницу вручную.
Так же очень удобно то, что дебажить в браузере можно TypeScript и все это уже встроено по умолчанию
В первую очередь я переделал страницы с примерами на те, что нужны мне. Это оказалось очень просто, несмотря на то, что мои знания Angular2 и TypeScript близки к нулю. Вообще синтаксис нового Angular кажется очень читабельным, как минимум с первого взгляда. А возможность описывать интерфейсы, классы и типы в TypeScript делают его очень понятным.
Пример простой компоненты:
Думаю большинство разработчиков, которые видят TypeScript в первый раз сразу поймут что здесь происходит.
#### Entity Framework и база данных
Если вы знакомы с предыдущими версиями Entity Framework то с Entity Framework Core проблем возникнуть не должно. В крайнем случае — можно просмотреть документацию на [docs.efproject.net/en/latest/intro.html](https://docs.efproject.net/en/latest/intro.html)
Сначала ставим nuget пакеты для самого EF, а также для инструментов для работы с базой (версия последнего пока не стабильна):
```
Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Tools –Pre
```
[github.com/gbdrm/HabraQuest/commit/959f4cb6c253dad0cc5e6eb34756ee5cc9c920f9](https://github.com/gbdrm/HabraQuest/commit/959f4cb6c253dad0cc5e6eb34756ee5cc9c920f9)
Дальше, добавляем команды инструментов в **project.json**, для этого открываем его, находим настройки **tools** и добавляем
```
"Microsoft.EntityFrameworkCore.Tools": "1.0.0-preview2-final",
```
Возможно в вашем шаблоне инструменты уже будут добавлены. Тогда ничего менять не надо.
Добавляем классы модели нашего приложения и DbContext и регистрируем их в **Startup.cs**.
Ну и конечно **ConnectionString** в **appsettings.json** и так же добавляем код для конфигурации в **Startup.cs**.
[github.com/gbdrm/HabraQuest/commit/7411eb4262bdef9f5fb810f6cf7d5a239221c0b5](https://github.com/gbdrm/HabraQuest/commit/7411eb4262bdef9f5fb810f6cf7d5a239221c0b5)
Следующий шаг, типичная история с миграциями — добавляем начальную миграцию и просим базу обновиться.
```
Add-Migration Initial
Update-Database
```
Поскольку база еще не существует, после второй команды она должна быть создана. Это можно проверить, посмотрев, какие базы данных существуют если присоединиться к SQL-серверу с помощью Visual или SQL Management студии.
[github.com/gbdrm/HabraQuest/commit/09b42dc0a8e45da1f461b38c2b41d79c4fc0b88a](https://github.com/gbdrm/HabraQuest/commit/09b42dc0a8e45da1f461b38c2b41d79c4fc0b88a)
Давайте добавим простой метод в Home контроллер и попробуем минимально использовать соединение с базой. Добавим метод создания нового игрока, который будем возвращать его токен.
[github.com/gbdrm/HabraQuest/commit/e67a322184517aa929d1347f6fd638c6290bf9d3](https://github.com/gbdrm/HabraQuest/commit/e67a322184517aa929d1347f6fd638c6290bf9d3)
Если теперь мы запустим приложение, можно протестировать этот метод, добавив **/home/registernewplayer** в конец адреса. В результате мы должны получить токен нашего игрока.
#### Первые шаги в Angular 2
По скольку мы уже создали примитивный back-end, то можем попробовать его использовать на клиенте. Попробуем сделать следующее:
когда новый пользователь заходит на страницу — проверить, есть ли у него cookie с токеном и, если нету, попросить его из сервера. Чтобы не создавать собственный велосипед, попробуем использовать существующую библиотеку для работы с cookie. Например, **ng2-cookies**.
Для этого нам надо установить ее и подключить в компоненте home.
[github.com/gbdrm/HabraQuest/commit/8c7aadd9607a0c4d0a1039707b08b0c4b720112c](https://github.com/gbdrm/HabraQuest/commit/8c7aadd9607a0c4d0a1039707b08b0c4b720112c)
Сложно описать мои следующие несколько часов упорной борьбы со стереотипами JavaScript и первого Angular. Оказалось, что во второй версии фреймворка все абсолютно иначе. Могу лишь сказать, что закончилось это тем, что я решил пока не использовать сервисы (решил сначала лучше разобраться с rxjs observable, который активно используется в Angular 2), обновил пакеты до следующего релиз кандидата (четвертого), добавил новые формы (оказалось, что они были сильно переделаны и этот процесс еще не закончен) и решил максимально упросить код (большинство логики в одну компоненту). Для начала нужно сделать что-то рабочее, а потом будем думать о хороших практиках. Так же добавил несколько заглушек на серверную часть.
[github.com/gbdrm/HabraQuest/commit/60c8239a89cae2357d0521973e091781027186ba](https://github.com/gbdrm/HabraQuest/commit/60c8239a89cae2357d0521973e091781027186ba)
Из интересных особенностей — то ли студия то ли решарпер умеют подтягивать правильные импорты для TypeScript, так же в большинстве случаев работает штатная навигация по методах. Из-за такого рода особенностей писать код для клиентской части становиться значительно приятней, нету больше чувства, что вы пишете какой-то скрипт, который может упасть где угодно. Вместо этого основные элементы синтаксиса проверяются автоматически и есть уверенность, что все не поломается где-то посредине. А даже если и поломается, то выполнится еще одна проверка на уровне webpack и в результате на странице будет показа ошибка, даже без перезапуска.
Правда, иногда, это начинает напрягать, когда после каждого сохранения файла — страница начинает перерисовываться. Но думаю это вопрос привычки.
Весь следующий код не представляет особой важности. В основному это реализация заглушенных моментов. Если вам все же интересно просмотреть — исходники доступны на [github.com/gbdrm/HabraQuest](https://github.com/gbdrm/HabraQuest)
#### Развертывание
По скольку бек-енд написан на .Net то деплоить наше приложение будем на Azure. Кстати за последние год-полтора тут тоже изменений хоть отбавляй, с первого раза не разберешься что и куда. Для нашего приложения нам достаточно будет создать самый базовый сайт с базой (Web App + SQL).
С деплойментом, как всегда, не очень гладко. Во-первых, он не проходит без ошибок. Сам сайт работает, но в итоге Visual Studio показывает ошибки в каких-то внешних модулях TypeScript. Пока так и не разобрался что это. Во-вторых, бывает, что при открытии сайта вылетает ошибка «TaskCanceledException: A task was canceled». С этим тоже пока не до конца ясно, но похоже проблема где-то на уровне хостинга. И кроме этого, немного поигрался с миграциями.
Хотя, в общем, я этим шагом остался доволен. Очень детальный и понятный лог, все можно сконфигурировать (база, миграции). Первый раз, правда, нужно подождать некоторое время (несколько минут) пока все билдится, копируется. Да и вообще, похоже, что процесс довольно сложный, на сколько я понял сначала все копируется локально, а потом уже перебрасывается на Azure, но это уже детали.
#### Результат, выводы
Все получилось так, как и планировалось. Новыми фреймворками лично я доволен, с радостью бы на них перешел. Конечно есть еще не очень стабильные моменты, Angular 2 еще и совсем не выпущен официально. Но выглядит все уже довольно интересно и, главное, работает.
Очень радует развитие инструментов, подходов в разработке которые позволяют делать меньше рутинных задач, типа обновления станицы, контролирования структуры базы данных.
Так же, очень много блогов, вопросов, документации в сети, так что с решением типичных задач уже должно быть все просто.
Все результаты можно найти на:
[github.com/gbdrm/HabraQuest](https://github.com/gbdrm/HabraQuest)
[habraquest.azurewebsites.net](http://habraquest.azurewebsites.net/)
Получилось довольно сумбурно, так как много разных тем. Какие из них вам наиболее интересны для описания в будущем? | https://habr.com/ru/post/306292/ | null | ru | null |
# Тестирование Flutter-приложений: гайд по разработке тестов на Flutter
*Привет! Меня зовут Юрий Петров, я Flutter Team Lead в* [*Friflex*](https://friflex.com/)*. Мы разрабатываем мобильные приложения для бизнеса и специализируемся на Flutter. В статье я расскажу про тестирование Flutter-проектов. Это гайд для новичков. Для понимания рекомендую полностью повторить процесс написания кода, который здесь демонстрируется. Готов ответить на любые вопросы по теме.*
Чтобы разобраться в теме, необходимо рассмотреть общую концепцию тестирования и понять, для чего вообще нужно тестировать приложения. Поэтому начнем с теории.
### Что такое тестирование
В интернете очень много определений тестирования: вы можете познакомиться с ними на страницах [Википедии](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BE%D0%B1%D0%B5%D1%81%D0%BF%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F). Говоря простыми словами, тестирование — это процесс испытания приложения для проверки соответствия между реальным поведением и ожидаемым. Когда вы создали приложение и вам необходимо проверить, будет ли поведение этого приложения таким, каким вы его изначально запланировали, вы должны его протестировать. Есть еще одна очень важная причина для покрытия кода тестами — это минимизация регрессии приложения с добавлением новой функциональности.
Давайте представим, что у вас есть опубликованное рабочее приложение, которое ежедневно используют миллионы пользователей. Перед вами стоит задача добавления новой функциональности. Вы успешно реализовываете ее и отправляете на тестирование в группу QA. Они проверяют эту функциональность и дают разрешение на публикацию обновления. Публикация проходит, и через какое-то время вы получаете резкий скачок ошибок в аналитике. При разборе данной ситуации становится понятно, что добавленная функциональность при определенных условиях воздействовала на основную функциональность приложения и вызывала ошибки. Это простой пример регрессии вашего приложения.
Разработка через тестирование (test-driven development, TDD)
------------------------------------------------------------
TDD — это методика разработки приложений, при которой сначала пишется тест, покрывающий желаемое изменение, а затем — код, который позволит пройти тест. Звучит непонятно, но это только на первый взгляд. Попробуем разобраться. Представим, что нам необходимо создать функцию, которая должна посчитать сумму двух переданных в нее параметров.
Мы создаем функцию **sum** и пока не знаем, какая у нее будет реализация.
```
int? sum(int a, int b) {
return null;
}
```
Для решения этой задачи пишем простой тест с параметрами «5» и «6». Который, конечно же, не проходит и выдает ошибку: ожидалось «11», а пришел **null**.
```
test("Разработка через тестирование TDD", () {
final result = sum(5, 6);
expect(result, 11);
});
```
Далее реализуем функцию **sum**, которая возвращает сумму.
```
int? sum(int a, int b) {
return a + b;
}
```
Запускаем тест, и он проходит. Таким образом, мы разработали функцию **sum** через тестирование.
Есть еще один интересный момент при разработке через тестирование. Когда разработчик пишет реализацию функции, которая покрыта тестами, он автоматически начинает придерживаться таких принципов программирования, как KISS и YAGNI.
KISS — «Делай проще» (англ. keep it simple, stupid, KISS);
YAGNI — «Вам это не понадобится» (англ. you aren't gonna need it, YAGNI).
Таким образом, код становится более чистым, масштабируемым и читаемым.
И еще пара рекомендаций о том, как нужно делать тесты:
* Исключите прямые зависимости. Здесь все просто: ваши тесты не должны зависеть друг от друга. Вы можете проверить себя таким образом: если у вас есть 10 тестов, которые успешно проходят, измените очередность их запуска. Тесты стали выдавать ошибки? Это значит, что они написаны с ошибками.
При написании тестов придерживайтесь правила «Один тест — одна функция».
Три типа тестирования Flutter-приложений
----------------------------------------
Фреймворк Flutter предоставляет разработчику полный набор инструментов для тестирования приложений: [*unit test*](https://docs.flutter.dev/testing#unit-tests) (модульный тест), [*widget test*](https://docs.flutter.dev/testing#widget-tests) (тест виджетов) и [*integration test*](https://docs.flutter.dev/testing#integration-tests) (интеграционный тест).
Каждый тест решает задачу на своем уровне.
**Модульный тест** тестирует одну функцию, метод или класс. Его цель проверить правильность работы определенной функции, метода или класса. Внешние зависимости для тестируемого модуля обычно передаются как параметр.
**Виджет тест** тестирует один виджет. Цель такого теста — убедиться, что пользовательский интерфейс виджета выглядит и взаимодействует, как запланировано. Тестирование виджета происходит в тестовой среде, которая обеспечивает контекст жизненного цикла виджета. Также тестируемый виджет должен иметь возможность получать действия и события пользователя и отвечать на них .
**Интеграционный тест** тестирует все приложение или его большую часть. Цель интеграционного теста — убедиться, что все тестируемые виджеты и сервисы работают вместе, как ожидалось. Кроме того, вы можете использовать интеграционные тесты для проверки производительности вашего приложения. Как правило, интеграционный тест выполняется на реальном устройстве или эмуляторе.
Теперь, зная, какие типы тестов есть во Flutter, вы можете спросить, какие из них нужно делать, а какие нет. На этот вопрос трудно дать однозначно правильный ответ, так как все зависит от команды, работающей над проектом, сроков и типа проекта. Какие тесты необходимо делать, а какие нет — этот вопрос ложится на плечи вашего техлида.
Например, в нашей компании pull-request будет сразу же отклонен, если в нем содержатся какие-нибудь публичные top-level функции, не покрытые тестами. Также мы всегда стараемся покрывать тестами общие виджеты, которые используются во всем приложении. Это очень помогает, когда новый разработчик в команде вносит изменения в такой виджет, думая, что этим он никак не может повлиять на его работу. Помните, выше я писал про регрессионное тестирование? Вот вам еще один пример.
Про интеграционный тест можно сказать, что мало кому хочется запускать его, потому что ждать, пока он выполнится, придется долго. Но если у вас в проекте настроены CI/CD инструменты (GitHub Action и др.), то тесты нужно сделать. Потому что в дальнейшем это сократит время на отладку приложения.
Есть таблица компромисса, которая была разработана умными дядьками из Google. С ее помощью вы можете решить, что для вас важнее — время или качество.
[Таблица компромисса](https://flutter.dev/docs/testing#unit-tests)
Например, мы видим, что модульное тестирование дает нам низкую уверенность в приложении, но при этом модульные тесты легко реализуются и быстро выполняются. Если говорить про интеграционные тесты, то здесь ситуация прямо противоположная. Уверенность самая высокая, а реализация и выполнение медленные.
Приступаем к практике
---------------------
Я написал небольшое приложение, которое позволяет получить информацию о погоде через общедоступный ресурс [**https://openweathermap.org**](https://openweathermap.org/api)**.** Приложение очень простое, но его будет достаточно, чтобы разобраться в тестировании Flutter-проектов.
Для работы вам необходимо клонировать данное приложение из репозитория на GitHub <https://github.com/petrovyuri/flutter_testing>. Для того чтобы оно заработало, нужно получить appId на сайте [**https://openweathermap.org**](https://openweathermap.org/api)и вставить его в [network\_data\_repository.dart](https://github.com/petrovyuri/flutter_testing/blob/master/lib/data/network_data_repository.dart).
Ура! Теперь у нас есть рабочее приложение, которое можно покрыть тестами.
Вот здесь замените appID на свойВнешний вид приложенияНа первый взгляд, все довольно просто. Но для того, чтобы отображать строку с температурой, необходимо специальным образом эту строку отформатировать: с помощью функции *convertHumanTemp()*
```
static String convertHumanTemp(double? temperature) {
try {
final value = int.parse(temperature.toString().split(".").first);
return "$value °C";
} catch (error) {
return "Ошибка данных";
}
}
```
В этом случае нам необходимо применить unit-тестирование.
Для этого в папке **test** (она уже должна быть у вас, если такой папки нет, то это очень странно))) создадим файл app\_test.dart. Это будет общий файл, откуда мы будем запускать все наши тесты. Далее в этой же папке создадим файл **unit\_test.dart**. В итоге у вас должно получиться что-то вроде этого:
Для каждого теста лучше создать отдельный файл: так будет удобнее. Отлично, теперь в файле ***unit\_test.dart*** создадим наш первый тест для функции ***convertHumanTemp().***
```
void main() {
test('Проверка функции на стандартные значения', () {
final result = Utilities.convertHumanTemp(27.3);
expect(result, equals("27 °C"));
});
test('Проверка функции на null', () {
final result = Utilities.convertHumanTemp(null);
expect(result, "Ошибка данных");
});
}
```
Разберем этот тест.
Для тестирования функции нам необходимо значение **result**, которое будет проинициализировано значением из функции ***Utilities.convertHumanTemp()***. В саму функцию мы передаем значение **27.3**. Далее с помощью встроенной функции ***expect*** мы можем проверить result с матчером. В первом случае это строка «27 °C» с валидными данными. Во втором случае мы передаем в функцию null, ожидая получить строку «Ошибка данных». Если в таком виде запустить тест, то он успешно пройдет.
 А если попробовать внести изменения в первый тест таким образом:
```
test('Проверка функции на стандартные значения', () {
final result = Utilities.convertHumanTemp(27.3);
expect(result, equals("30 °C"));
});
```
То мы получим ошибку прохождения теста:
При обнаружении несоответствия в тесте мы видим, где и какая проблема: какой тест не прошел и по какой причине. Таким простым способом мы можем проверить все функции в нашем приложении.
Тестирование виджетов
---------------------
Теперь попробуем разобрать тестирование виджетов. Для этого создадим файл ***widget\_test.dart.***Что нам необходимо проверить:
1. Экран до получения информации;
2. Экран с уже полученной информацией.
И здесь уже не все так просто и интуитивно понятно, как, например, в юнит-тестах. Дело в том, что нам каким-то образом надо взаимодействовать с виджетами на экране. Здесь я имею в виду тапы по кнопкам, ввод текста в текстовые поля и так далее. Для этого есть класс ***WidgetTester,*** который программно взаимодействует с виджетами и тестовой средой. Чтобы получить данный объект, нам необходимо создать тест. Почти такой же, как юнит-тест, только здесь мы будем использовать функцию ***testWidgets.***
Попробуем написать и разобрать наш первый тест.
```
testWidgets("Проверка начального экрана приложения",
(WidgetTester tester) async {
/// Тело теста
});
```
Мы видим, что ***testWidgets*** возвращает нам объект, ***tester*** — объект ***WidgetTester.*** Теперь мы может делать все что угодно с нашими виджетами. Первое, что нам нужно сделать — получить ссылку на наш репозиторий, так как виджет ***AppScreen*** принимает репозиторий в конструктор. Но здесь есть нюанс: при тестировании мы не должны обращаться к реальному источнику данных, так как они могут быть не достоверны.
Для этого используют [мок-репозитории](https://github.com/petrovyuri/flutter_testing/blob/master/lib/data/mock_data_repository.dart). В нашем случае у нас уже написан репозиторий, который всегда возвращает число «36.3».
```
class MockDataRepository implements DataRepository {
@override
Future fetchData() {
return Future(() => const DataModel(temp: 36.3));
}
}
```
Для удобства работы с мок-репозиториями я настоятельно рекомендую научиться работать с такими библиотеками как [Mockito](https://pub.dev/packages/mockito) или [Mocktail](https://pub.dev/packages/mocktail).
Продолжаем писать наш виджет тест. Инициализируем в теле теста мок-репозиторий в тесте:
```
final repository = MockDataRepository();
```
C помощью объекта ***tester*** добавляем в тестовую среду виджет ***AppScreen*** методом ***pumpWidget:***
```
await tester.pumpWidget(MaterialApp(
home: AppScreen(repository: repository)));
```
Далее нам необходимо найти текст «***Обновите данные***»в тестовой среде. Для этого мы используем класс ***Finder***. Искать можно разными способами и используя разные ***finders***. Вот самые распространенные из них (на самом деле их намного больше). Также вы легко может сам написать свой ***finder***.
* ***find.text()*** - ищет текст;
* ***find.byKey()*** - ищет виджет по ключу;
* ***find.byType()*** - ищет виджет по типу;
* ***find.byIcon()*** - ищет виджет типа Icon;
* ***find.byWidgetPredicate()*** - ищет виджет по предикату.
Соответственно мы можем найти текст и тип виджета ***FloatingActionButton.***
```
final textFinder = find.text("Обновите данные");
final fabFinder = find.byType(FloatingActionButton);
```
Осталось сравнить с помощью класса ***Matcher*** полученный результат с заданным ***finders***. Их тоже написано много: почти на все случае жизни. Но вы можете легко написать свои. Ниже приведены самые, на мой взгляд, используемые:
* ***findsOneWidget*** - сравнивает, что [Finder] находит только один виджет;
* ***findsWidgets*** - сравнивает, что [Finder] находит по крайней мере один виджет;
* ***isSameColorAs(Color color)***- сравнивает, что объект имеет определенный цвет;
* ***findsNothing*** - сравнивает, что [Finder] не находит виджет;
* ***isNotNull*** - сравнивает, что обьект не null.
***matchesGoldenFile -*** сравнивает, соответствует ли рендеринг виджета конкретному растровому изображению (тестирование «золотой файл»).
Далее с помощью уже знакомой функции ***expect*** проверяем результат.
```
expect(textFinder, findsOneWidget);
expect(fabFinder, findsOneWidget);
```
После всех этих манипуляций ваш тест должен выглядеть вот так. И после запуска этого теста вы увидите, что он успешно прошел.
```
testWidgets("Проверка начального экрана приложения",
(WidgetTester tester) async {
/// Инициализация репозитория
final repository = MockDataRepository();
/// Создание виджета
await tester
.pumpWidget(MaterialApp(home: AppScreen(repository: repository)));
/// Поиск текста
final textFinder = find.text("Обновите данные");
/// Поиск кнопки
final fabFinder = find.byType(FloatingActionButton);
/// Сравнение finder с matcher
expect(textFinder, findsOneWidget);
expect(fabFinder, findsOneWidget);
});
```
Теперь давайте попробуем взаимодействовать с виджетами и имитировать получение значения температуры при нажатии на кнопку. Пишем тест также, как и предыдущий, но здесь нам необходимо проверить, что после нажатия на кнопку у нас появились новые виджеты.
```
/// Имитация нажатия на кнопку
await tester.tap(fabFinder);
/// Перестройка интерфейса
await tester.pumpAndSettle();
/// Поиск текста
final tempTextFinder = find.text("Температура");
/// Поиск текста
final currentTempTextFinder = find.text("36 °C");
/// Сравнение finder с matcher
expect(tempTextFinder, findsOneWidget);
expect(currentTempTextFinder, findsOneWidget);
```
Здесь в принципе все понятно: обращаемся к объекту ***tester***, вызываем его метод ***tap*** и передаем в него ***fabFinder.*** Таким образом, мы имитируем нажатие на кнопку. Далее вызываем у объекта ***tester*** метод ***pumpAndSettle.*** Здесь необходимо остановиться подробнее. Дело в том, что в тестовой среде нам нужен полный контроль за перестройкой виджета (аналог ***setState()***). Для этого у WidgetTester есть методы:
* ***pump*** - немедленная перестройка виджета;
* ***pumpAndSettle*** - повторяет вызовы pump() с заданной продолжительностью до тех пор, пока не исчезнут запланированные кадры.
А так как получение данных — это продолжительная операция, необходимо использовать ***pumpAndSettle.*** Если в данном случае вызвать ***pump,*** то вы получите ошибку.
Теперь ваш тест должен выглядеть вот так.
```
testWidgets("Проверка начального экрана приложения",
(WidgetTester tester) async {
final repository = MockDataRepository();
await tester.pumpWidget(MaterialApp(
home: AppScreen(
repository: repository,
)));
final fabFinder = find.byType(FloatingActionButton);
expect(fabFinder, findsOneWidget);
await tester.tap(fabFinder);
await tester.pumpAndSettle();
final tempTextFinder = find.text("Температура");
final currentTempTextFinder = find.text("36 °C");
expect(tempTextFinder, findsOneWidget);
expect(currentTempTextFinder, findsOneWidget);
});
```
Группы тестов
-------------
Для удобства чтения теста вы можете объединять тесты в группы с помощью функции ***group***.
В нашем случае можно объединить два теста в одну группу.
```
void main() {
group("AppScreen", () {
testWidgets("Проверка начального экрана приложения",
(WidgetTester tester) async {
final repository = MockDataRepository();
await tester
.pumpWidget(MaterialApp(home: AppScreen(repository: repository)));
final textFinder = find.text("Обновите данные");
final fabFinder = find.byType(FloatingActionButton);
expect(textFinder, findsOneWidget);
expect(fabFinder, findsOneWidget);
});
testWidgets("Проверка начального экрана приложения",
(WidgetTester tester) async {
final repository = MockDataRepository();
await tester.pumpWidget(MaterialApp(
home: AppScreen(
repository: repository,
)));
final fabFinder = find.byType(FloatingActionButton);
expect(fabFinder, findsOneWidget);
await tester.tap(fabFinder);
await tester.pumpAndSettle();
final tempTextFinder = find.text("Температура");
final currentTempTextFinder = find.text("36 °C");
expect(tempTextFinder, findsOneWidget);
expect(currentTempTextFinder, findsOneWidget);
});
});
}
```
Инициализация и удаление
------------------------
Для удобства работы с тестами там, где необходимо создать и потом удалить общие для всех тестов объекты, можно использовать методы:
* ***setUp*** - функция вызывается **перед** каждым тестом;
* ***setUpAll*** - функция вызывается **однократно перед** запуском всех тестов;
* ***tearDown -*** функция вызывается **после** каждого теста;
* ***tearDownAll*** - функция вызывается **однократно после** всех тестов.
Если мы добавим в наш тест эти функции, то получим:
```
void main() {
setUp(() {
print('Запуск setUp');
});
tearDown(() {
print('Запуск tearDown');
});
testWidgets("Проверка начального экрана приложения",
(WidgetTester tester) async {
/// Первый тест
});
testWidgets("Проверка начального экрана приложения",
(WidgetTester tester) async {
/// Второй тест
});
}
```
Интеграционные тесты
--------------------
С приходом Flutter 2.5 интеграционные тесты стали намного проще. Но все равно есть действия, которые необходимо уметь делать.
1. Так как интеграционные тесты не входят в стандартный пакет flutter, нам необходимо добавить следующую запись в **pubspec.yaml**
2. В корне проекта создать папку ***integration\_test*** с файлом ***app\_test.dart*** внутри.
3. Написать такой же тест, как тот, который мы написали при тестировании виджетов, но с нескольким отличиями. Добавляем то выполнения тестов следующую строку:
```
void main() {
IntegrationTestWidgetsFlutterBinding.ensureInitialized();
/// далее тест
}
```
Так мы инициализируем службу синглтон для запуска тестов на физическом устройстве.
Теперь наш файл ***app\_test.dart*** выглядит следующим образом:
```
testWidgets("Проверка начального экрана приложения",
(WidgetTester tester) async {
final repository = MockDataRepository();
await tester
.pumpWidget(MaterialApp(home: AppScreen(repository: repository)));
final textFinder = find.text("Обновите данные");
final fabFinder = find.byType(FloatingActionButton);
expect(textFinder, findsOneWidget);
expect(fabFinder, findsOneWidget);
await Future.delayed(const Duration(seconds: 5));
await tester.tap(fabFinder);
await tester.pumpAndSettle();
final mainTextFinder = find.text("Иннополис");
final tempTextFinder = find.text("Температура");
final currentTempTextFinder = find.text("36 °C");
expect(mainTextFinder, findsOneWidget);
expect(tempTextFinder, findsOneWidget);
expect(currentTempTextFinder, findsOneWidget);
/// Здесь задержка нужна, только для того, что бы тест не закрылся сразу.
await Future.delayed(const Duration(seconds: 5));
});
}
```
4. Теперь необходимо запустить наш тест. Набираем в терминале команду и ждем:
```
flutter test integration_test/app_test.dart
```
Если у вас есть желание дополнить мою статью — например, информацией о том, чем тестирование Flutter-проектов отличается от тестирования приложений на других фреймворках — жду вас в комментариях.
Спасибо за внимание! | https://habr.com/ru/post/666578/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.